feat(ai): wire dimension-consistency gatherer into the data-integrity runner evidence seam (#14225) (#14226)

* feat(ai): wire dimension-consistency gatherer into the data-integrity runner evidence seam (#14225)

#14130 slice-2 (slice-1 = #14216, merged). Wires gatherDimensionConsistencyDiagnosis into Orchestrator.dataIntegrityEvidenceGatherer as a 2nd producer alongside coverage.

- New dataIntegrityDimensionGatherer getter: runs the gatherer over the live Memory Core collections (StorageRouter.getMemoryCollection/getSummaryCollection) with AiConfig.vectorDimension (root-level leaf) + dataIntegrityServiceId. - dataIntegrityEvidenceGatherer folds the dimension diagnosis into diagnoses alongside coverage ([coverageDiagnosis, dimensionDiagnosis].filter(Boolean)), one shared observedAt. - evidenceFacts (vector-dimension-mismatch) compose with the assembler's existing per-collection fold, no glue (per @neo-opus-vega, seam owner).

Degrade-not-throw preserved (down-Chroma → no false diagnosis; coverage = the offline baseline). actionClass:escalate drop out of scope (#14138). 79 Orchestrator specs + node --check clean; gatherer #14216-tested + assembler tested. @neo-opus-vega primary-reviews. Resolves #14225.

* refactor(ai): extract live dimension-gatherer resolution into a factory (#14226)

Addresses @neo-gpt's #14226 placement RC: the live Memory Core collection
resolution + producer-config binding no longer live in a durable Orchestrator
getter. Moved into createLiveDimensionConsistencyGatherer() in the gatherer
service module; the orchestrator reads AiConfig.vectorDimension at its use-site
(per the ADR-0019 SSOT discipline) and injects the resolved deps (storageRouter,
expectedDimension, serviceId). The durable get dataIntegrityDimensionGatherer()
is removed; dataIntegrityEvidenceGatherer calls the factory inline. auditFn
threads through for test isolation (matching the sibling gatherer's seam).

6 specs pass (4 existing + 2 new factory tests covering collection-resolution +
config-binding); node --check clean on both modules.

---------

Co-authored-by: tobiu <tobiasuhlig78@gmail.com>

Author: neo-opus-ada

ai/daemons/orchestrator/Orchestrator.mjs

@@ -41,6 +41,7 @@ import {appendHealEvent, healEventsToRecentRuns, queryHealLedger, readHealLedger
 import {Memory_StorageRouter as StorageRouter, Memory_TextEmbeddingService as TextEmbeddingService} from '../../services.mjs';
 import {buildDataIntegrityCoverageDiagnosis}                                                        from './services/dataIntegrityCoverageDiagnosis.mjs';
 import {assembleDataIntegrityEvidence}                                                              from './services/dataIntegrityEvidenceAssembler.mjs';
+import {createLiveDimensionConsistencyGatherer}                                                     from './services/dimensionConsistencyGatherer.mjs';
 import DreamService                                                                                 from './services/DreamService.mjs';
 import SwarmHeartbeatService                                                                        from './services/SwarmHeartbeatService.mjs';
 import GoldenPathSynthesizer                                                                        from '../../services/graph/GoldenPathSynthesizer.mjs';
@@ -580,12 +581,19 @@ export class Orchestrator extends Base {
      * @returns {Function} `async () => Promise<Object[]>` — the assembled classifier-input rows.
      */
     get dataIntegrityEvidenceGatherer() {
-        const coverageGatherer = this.dataIntegrityCoverageGatherer,
-              serviceId        = this.dataIntegrityServiceId;
+        const coverageGatherer  = this.dataIntegrityCoverageGatherer,
+              dimensionGatherer = createLiveDimensionConsistencyGatherer({
+                  storageRouter    : StorageRouter,
+                  expectedDimension: AiConfig.vectorDimension,
+                  serviceId        : this.dataIntegrityServiceId
+              }),
+              serviceId         = this.dataIntegrityServiceId;
         return async () => {
-            const coverageResult    = await coverageGatherer(),
-                  coverageDiagnosis = buildDataIntegrityCoverageDiagnosis({coverageResult, observedAt: Date.now(), serviceId}),
-                  diagnoses         = coverageDiagnosis ? [coverageDiagnosis] : [];
+            const observedAt         = Date.now(),
+                  coverageResult     = await coverageGatherer(),
+                  coverageDiagnosis  = buildDataIntegrityCoverageDiagnosis({coverageResult, observedAt, serviceId}),
+                  dimensionDiagnosis = await dimensionGatherer(observedAt),
+                  diagnoses          = [coverageDiagnosis, dimensionDiagnosis].filter(Boolean);
             return assembleDataIntegrityEvidence({diagnoses, serviceId});
         };
     }

ai/daemons/orchestrator/services/dimensionConsistencyGatherer.mjs

@@ -46,3 +46,33 @@ export async function gatherDimensionConsistencyDiagnosis({
 
     return buildDimensionConsistencyDiagnosis({samples, observedAt, serviceId});
 }
+
+/**
+ * @summary Builds the live-Chroma dimension-consistency gatherer the data-integrity sweep schedules: it
+ * resolves the Memory Core collections from the injected storage router and binds the producer config, then
+ * returns a closure that runs {@link gatherDimensionConsistencyDiagnosis} over the resolved live collections.
+ *
+ * The live-collection resolution + config binding live here with the gatherer service (not in the
+ * scheduling/orchestrator class): the orchestrator reads the AiConfig leaf at its use-site per the SSOT
+ * discipline and injects the resolved `expectedDimension` + the `storageRouter`, keeping this module free of
+ * config/Neo imports while owning the gather wiring. Injected `storageRouter` makes the factory testable in
+ * isolation (no live Chroma).
+ *
+ * @param {Object} options
+ * @param {Object} options.storageRouter The Memory Core storage router — supplies `ready()` +
+ * `getMemoryCollection()` / `getSummaryCollection()`.
+ * @param {Number} options.expectedDimension The configured embedding dimension (read at the orchestrator use-site).
+ * @param {String} options.serviceId The Memory Core compose-service identifier.
+ * @param {Function} [options.auditFn] The dimension-audit primitive — passed through to the gatherer; injectable for tests.
+ * @returns {Function} `async (observedAt) => Promise<Object|null>` — a dimension-mismatch recovery-diagnosis or null.
+ */
+export function createLiveDimensionConsistencyGatherer({storageRouter, expectedDimension, serviceId, auditFn} = {}) {
+    return async observedAt => {
+        await storageRouter.ready();
+        const collections = [
+            {collection: await storageRouter.getMemoryCollection(),  collectionName: 'neo-agent-memory'},
+            {collection: await storageRouter.getSummaryCollection(), collectionName: 'neo-agent-sessions'}
+        ];
+        return gatherDimensionConsistencyDiagnosis({collections, expectedDimension, serviceId, observedAt, auditFn});
+    };
+}

test/playwright/unit/ai/daemons/orchestrator/services/dimensionConsistencyGatherer.spec.mjs

@@ -1,7 +1,7 @@
 import {test, expect}                        from '@playwright/test';
 import Neo                                   from '../../../../../../../src/Neo.mjs';
 import * as core                             from '../../../../../../../src/core/_export.mjs';
-import {gatherDimensionConsistencyDiagnosis} from '../../../../../../../ai/daemons/orchestrator/services/dimensionConsistencyGatherer.mjs';
+import {createLiveDimensionConsistencyGatherer, gatherDimensionConsistencyDiagnosis} from '../../../../../../../ai/daemons/orchestrator/services/dimensionConsistencyGatherer.mjs';
 
 // The live-Chroma audit+scheduling half of the dimension-consistency detect signal: it samples each
 // collection via the (injected) dimension-audit primitive and feeds the samples to the pure producer.
@@ -39,3 +39,40 @@ test.describe('dimensionConsistencyGatherer', () => {
         expect(await gatherDimensionConsistencyDiagnosis({collections, expectedDimension: 1024, serviceId: 'svc', observedAt: 1000, auditFn})).not.toBeNull()
     })
 });
+
+// The live-binding factory: owns the Memory Core collection resolution + config binding (moved out of the
+// Orchestrator getter per #14226's placement RC), so the orchestrator just reads the AiConfig leaf at its
+// use-site and injects the resolved deps. Injected storageRouter + auditFn keep it testable without live Chroma.
+test.describe('createLiveDimensionConsistencyGatherer', () => {
+    const makeRouter = () => {
+        const calls = {ready: 0};
+        return {
+            calls,
+            ready               : async () => { calls.ready++; },
+            getMemoryCollection : async () => ({id: 'mem'}),
+            getSummaryCollection: async () => ({id: 'sum'})
+        };
+    };
+
+    test('resolves the memory + summary collections from the router, binds config, and builds a diagnosis on a mismatch', async () => {
+        const router  = makeRouter(),
+              audited = [],
+              auditFn = async ({collectionName, expectedDimension}) => {
+                  audited.push({collectionName, expectedDimension});
+                  return {collection: collectionName, expectedDimension, mismatchedVectorCount: collectionName === 'neo-agent-memory' ? 4 : 0, sampledCount: 100};
+              },
+              gather    = createLiveDimensionConsistencyGatherer({storageRouter: router, expectedDimension: 1024, serviceId: 'mc-server', auditFn}),
+              diagnosis = await gather(1000);
+        expect(router.calls.ready).toBe(1);
+        expect(audited.map(a => a.collectionName)).toEqual(['neo-agent-memory', 'neo-agent-sessions']);
+        expect(audited.every(a => a.expectedDimension === 1024)).toBe(true);
+        expect(diagnosis).not.toBeNull()
+    });
+
+    test('returns null when both live collections match the dimension', async () => {
+        const router  = makeRouter(),
+              auditFn = async ({collectionName, expectedDimension}) => ({collection: collectionName, expectedDimension, mismatchedVectorCount: 0, sampledCount: 100}),
+              gather  = createLiveDimensionConsistencyGatherer({storageRouter: router, expectedDimension: 1024, serviceId: 'mc-server', auditFn});
+        expect(await gather(1000)).toBeNull()
+    })
+});