fix(ai): dimension-gatherer degrade-not-throw on Chroma connection failure (#14130) (#14258)

createLiveDimensionConsistencyGatherer awaited storageRouter.ready() +
getMemoryCollection()/getSummaryCollection() with no guard, so a Chroma
connection failure threw. In Orchestrator.dataIntegrityEvidenceGatherer
(coverage gathered first, then await dimensionGatherer()), that throw discarded
the already-gathered coverage diagnosis and blanked the entire hourly
data-integrity sweep — violating #14130 AC3 (connection failure -> empty
samples, never a thrown gather or a suppressed coverage signal).

Wrap the live-binding resolution in try-catch -> return null on failure
(degrade-not-throw; null is filtered by the evidence-gather's .filter(Boolean),
so coverage survives). The audit primitive already degraded on a probe failure;
this extends the same contract to the connection boundary.

7 specs pass (+ a new AC3 test: ready()-throws and mid-resolution
getCollection()-throws both resolve to null). node --check clean.

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

Author: neo-opus-ada

ai/daemons/orchestrator/services/dimensionConsistencyGatherer.mjs

@@ -68,11 +68,21 @@ export async function gatherDimensionConsistencyDiagnosis({
  */
 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});
+        // Degrade-not-throw at the live-binding boundary, not only inside the audit primitive (#14130 AC3).
+        // A Chroma *connection* failure (storageRouter.ready / getCollection) must skip the dimension signal
+        // for this cycle and return null — never throw. The shared `dataIntegrityEvidenceGatherer` gathers
+        // coverage first then awaits this; an unguarded throw here would discard the already-gathered coverage
+        // diagnosis and blank the whole hourly sweep. A down-Chroma is surfaced separately (coverage gatherer
+        // + container-health), so a silent dimension-skip is the safe degrade; null is filtered downstream.
+        try {
+            await storageRouter.ready();
+            const collections = [
+                {collection: await storageRouter.getMemoryCollection(),  collectionName: 'neo-agent-memory'},
+                {collection: await storageRouter.getSummaryCollection(), collectionName: 'neo-agent-sessions'}
+            ];
+            return await gatherDimensionConsistencyDiagnosis({collections, expectedDimension, serviceId, observedAt, auditFn});
+        } catch (error) {
+            return null;
+        }
     };
 }

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

@@ -74,5 +74,24 @@ test.describe('createLiveDimensionConsistencyGatherer', () => {
               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()
+    });
+
+    test('degrades to null (never throws) on a Chroma connection failure — coverage is not suppressed (#14130 AC3)', async () => {
+        // ready() throws (Chroma down): an unguarded throw here would discard the already-gathered coverage
+        // diagnosis in the shared evidence-gather and blank the whole sweep. Must resolve to null, not reject.
+        const downRouter = {
+            ready               : async () => { throw new Error('chroma connection refused'); },
+            getMemoryCollection : async () => ({id: 'mem'}),
+            getSummaryCollection: async () => ({id: 'sum'})
+        };
+        await expect(createLiveDimensionConsistencyGatherer({storageRouter: downRouter, expectedDimension: 1024, serviceId: 'mc-server'})(1000)).resolves.toBeNull();
+
+        // mid-resolution failure (getCollection throws after a successful ready()) — same degrade.
+        const midFailRouter = {
+            ready               : async () => {},
+            getMemoryCollection : async () => { throw new Error('chroma get failed'); },
+            getSummaryCollection: async () => ({id: 'sum'})
+        };
+        await expect(createLiveDimensionConsistencyGatherer({storageRouter: midFailRouter, expectedDimension: 1024, serviceId: 'mc-server'})(1000)).resolves.toBeNull()
     })
 });