@remnic/core 9.40.0 → 9.41.0

package/dist/utility-runtime.d.ts

@@ -1,5 +1,5 @@
 import { TierRoutingPolicy } from './tier-routing.js';
-import './types-CCGL-9NX.js';
+import './types-CqWwMPr_.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { v as MemoryCategory } from './types-CCGL-9NX.js';
+import { v as MemoryCategory } from './types-CqWwMPr_.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.40.0",
+  "version": "9.41.0",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3086,7 +3086,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.40.0"
+    "@remnic/coding-graph": "^9.41.0"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-http.test.ts

@@ -1993,7 +1993,7 @@ test("HTTP externalRequestHandler runs pre-auth, can end responses, and falls th
         oldestBufferedTurnAgeMs: null,
         degraded: false,
         degradedReason: null,
-        watermarkScope: "root-store",
+        watermarkScope: "aggregate",
       },
       corpus: [],
       corpusComplete: true,
@@ -2120,7 +2120,7 @@ test("HTTP authTokenEntriesGetter is authoritative: scope policy binds connector
         oldestBufferedTurnAgeMs: null,
         degraded: false,
         degradedReason: null,
-        watermarkScope: "root-store",
+        watermarkScope: "aggregate",
       },
       corpus: [],
       corpusComplete: true,

package/src/access-service-health.test.ts

@@ -1,11 +1,12 @@
 import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
 import { EngramAccessService } from "./access-service.js";
 import { parseConfig } from "./config.js";
+import { TOKEN_CAPABILITIES_VERSION, tokenCapabilityStore } from "./access-token-capabilities.js";
 import { namespaceCollectionName } from "./namespaces/search.js";
 import type { Orchestrator } from "./orchestrator.js";
 import type { SearchBackend } from "./search/port.js";
@@ -548,16 +549,27 @@ test("health reports extraction liveness ok when the buffer is empty (nothing to
     assert.equal(health.extraction.degraded, false);
     assert.equal(health.extraction.bufferedSessionCount, 0);
     assert.equal(health.extraction.lastExtractionAt, oldTs);
+    const scopedHealth = await tokenCapabilityStore.run(
+      { version: TOKEN_CAPABILITIES_VERSION, namespaces: ["default"] },
+      () => service.health(),
+    );
+    assert.equal(scopedHealth.extraction.degraded, health.extraction.degraded);
+    assert.equal(scopedHealth.extraction.lastExtractionAt, null);
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
 
-test("health returns the same daemon-global extraction verdict for every namespace (issue #2151)", async () => {
+test("health returns one daemon-global aggregate extraction verdict for every namespace", async () => {
   const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-liveness-ns-"));
   try {
-    const rootTs = new Date().toISOString(); // fresh daemon-global watermark
-    const staleTs = new Date(Date.now() - 7_200_000).toISOString(); // 2h old
+    const namespaceDirs: Record<string, string> = {
+      fresh: path.join(memoryDir, "namespaces", "fresh"),
+      stale: path.join(memoryDir, "namespaces", "stale"),
+    };
+    await Promise.all(Object.values(namespaceDirs).map((dir) => mkdir(dir, { recursive: true })));
+    const freshTs = new Date().toISOString();
+    const staleTs = new Date(Date.now() - 7_200_000).toISOString();
     const config = parseConfig({
       memoryDir,
       qmdEnabled: false,
@@ -565,20 +577,25 @@ test("health returns the same daemon-global extraction verdict for every namespa
       defaultNamespace: "default",
       extractionLiveness: { staleWindowMs: 3_600_000 },
     });
-    // Per-namespace stores return DIVERGING watermarks (fresh vs 2h stale vs
-    // never), but the global buffer is shared and the watermark must be sourced
-    // from the root store. Pre-fix, the extraction verdict tracked the
-    // namespace argument; post-fix it is identical for every namespace.
-    const perNamespaceMeta: Record<string, string | null> = { fresh: rootTs, stale: staleTs };
+    const perNamespaceMeta: Record<string, string | null> = {
+      default: staleTs,
+      fresh: freshTs,
+      stale: staleTs,
+    };
     const service = new EngramAccessService({
       config,
       qmd: makeQmd({}),
       buffer: {
-        getBufferSnapshot: async () => ({ bufferedSessionCount: 3, pendingTurnCount: 12, oldestTurnTimestamp: staleTs }),
+        getBufferSnapshot: async () => ({
+          bufferedSessionCount: 3,
+          pendingTurnCount: 12,
+          oldestTurnTimestamp: staleTs,
+        }),
       },
       storage: {
+        dir: memoryDir,
         loadMeta: async () => ({
-          lastExtractionAt: rootTs,
+          lastExtractionAt: staleTs,
           extractionCount: 4,
           lastConsolidationAt: null,
           totalMemories: 0,
@@ -586,10 +603,11 @@ test("health returns the same daemon-global extraction verdict for every namespa
         }),
       },
       async getStorage(namespace?: string) {
+        const resolved = namespace ?? "default";
         return {
-          dir: memoryDir,
+          dir: namespaceDirs[resolved] ?? memoryDir,
           loadMeta: async () => ({
-            lastExtractionAt: namespace ? perNamespaceMeta[namespace] ?? null : staleTs,
+            lastExtractionAt: perNamespaceMeta[resolved] ?? null,
             extractionCount: 4,
             lastConsolidationAt: null,
             totalMemories: 0,
@@ -599,19 +617,23 @@ test("health returns the same daemon-global extraction verdict for every namespa
       },
     } as unknown as Orchestrator);
 
+    await service.health();
+    const serviceWithCache = service as unknown as {
+      corpusWatermarkCache: { whenIdle(): Promise<void> };
+    };
+    await serviceWithCache.corpusWatermarkCache.whenIdle();
+
     const fresh = (await service.health("fresh")).extraction;
     const stale = (await service.health("stale")).extraction;
     const def = (await service.health()).extraction;
-    // The namespace-governed fields must not vary with the namespace argument
-    // (oldestBufferedTurnAgeMs is time-derived and intentionally excluded).
     assert.equal(stale.degraded, fresh.degraded, "degraded must not vary by namespace");
     assert.equal(def.degraded, fresh.degraded, "default health matches namespaced health");
     assert.equal(stale.lastExtractionAt, fresh.lastExtractionAt, "watermark must not vary by namespace");
     assert.equal(def.lastExtractionAt, fresh.lastExtractionAt);
     assert.equal(stale.degradedReason, fresh.degradedReason);
-    // Sourced from the fresh root watermark → healthy despite stale per-namespace stores.
     assert.equal(fresh.degraded, false);
-    assert.equal(fresh.lastExtractionAt, rootTs);
+    assert.equal(fresh.lastExtractionAt, freshTs);
+    assert.equal(fresh.watermarkScope, "aggregate");
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }

package/src/access-service.ts

@@ -7,6 +7,7 @@ import { createHash } from "node:crypto";
 import { ZodError } from "zod";
 import { AccessIdempotencyStore, hashAccessIdempotencyPayload } from "./access-idempotency.js";
 import { computeExtractionLivenessStatus, ExtractionLivenessWarnThrottle } from "./extraction-liveness.js";
+import { readAggregateExtractionWatermark } from "./orchestration/extraction-watermark.js";
 import { enforceNamespaceAllowList, tokenCapabilityStore } from "./access-token-capabilities.js";
 import {
   recordCitationUsage as recordCitationUsageForAccess,
@@ -2369,10 +2370,31 @@ export class EngramAccessService {
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
     const searchBackend = this.orchestrator.config.searchBackend ?? "qmd";
     const qmdEnabled = resolveQmdCapabilities(this.orchestrator.config).qmd === true;
-    const extraction = await computeExtractionLivenessStatus(this.orchestrator, this.extractionLivenessWarn);
+    const caps = tokenCapabilityStore.getStore();
+    const extractionWatermark = await readAggregateExtractionWatermark({
+      config: this.orchestrator.config,
+      rootStorage: this.orchestrator.storage,
+      storageForNamespace: (candidate) => this.orchestrator.getStorage(candidate),
+      rootsCache: this.corpusWatermarkCache,
+    });
+    const extraction = await computeExtractionLivenessStatus(
+      this.orchestrator,
+      extractionWatermark,
+      caps?.namespaces !== undefined ? undefined : this.extractionLivenessWarn,
+    );
+    const visibleExtraction =
+      caps?.namespaces !== undefined
+        ? {
+            ...extraction,
+            lastExtractionAt: null,
+            bufferedSessionCount: 0,
+            pendingTurnCount: 0,
+            oldestBufferedTurnAgeMs: null,
+            degradedReason: extraction.degraded ? "daemon extraction pipeline degraded" : null,
+          }
+        : extraction;
     // ONE call: the corpus array and the flag describing it must not come from
     // two independently-cached scans (round 8, codex P1).
-    const caps = tokenCapabilityStore.getStore();
     const corpusCensus = await computeServiceCorpusCensus(this.orchestrator, {
       cache: this.corpusWatermarkCache, caps });
     let projectionAvailable = false;
@@ -2398,7 +2420,7 @@ export class EngramAccessService {
       ),
       nativeKnowledgeEnabled: this.orchestrator.config.nativeKnowledge?.enabled === true,
       projectionAvailable,
-      extraction,
+      extraction: visibleExtraction,
       corpus: corpusCensus.watermarks,
       // Describes THIS response's array (round 8): a separate scan could report
       // complete while the shipped corpus was partial, and peers trust it.

package/src/cli.ts

@@ -31,6 +31,7 @@ import { chunkContent } from "./chunking.js";
 import { rescoreMemoryImportance } from "./importance.js";
 import { renderQmdBacklogStatus } from "./qmd-status.js";
 import { renderExtractionLivenessStats } from "./extraction-liveness.js";
+import { readAggregateExtractionWatermark } from "./orchestration/extraction-watermark.js";
 import { exportJsonBundle } from "./transfer/export-json.js";
 import { exportMarkdownBundle } from "./transfer/export-md.js";
 import { backupMemoryDir } from "./transfer/backup.js";
@@ -3653,9 +3654,7 @@ export function registerCli(
         .command("stats")
         .description("Show memory system statistics")
         .action(async () => {
-          // Ensure QMD is probed before checking availability
           await orchestrator.qmd.probe();
-
           const memories = await orchestrator.storage.readAllMemories();
           const entities = await orchestrator.storage.readEntities();
           const profile = await orchestrator.storage.readProfile();
@@ -3664,7 +3663,8 @@ export function registerCli(
           console.log(`Total memories: ${memories.length}`);
           console.log(`Total entities: ${entities.length}`);
           console.log(`Profile size: ${profile.length} chars`);
-          for (const line of await renderExtractionLivenessStats(orchestrator)) console.log(line);
+          const extractionWatermark = await readAggregateExtractionWatermark({ config: orchestrator.config, rootStorage: orchestrator.storage, storageForNamespace: (ns) => orchestrator.getStorage(ns) });
+          for (const line of await renderExtractionLivenessStats(orchestrator, extractionWatermark)) console.log(line);
           console.log(`QMD: ${orchestrator.qmd.isAvailable() ? "available" : "not available"}`);
           for (const line of await renderQmdBacklogStatus(orchestrator.qmd, orchestrator.config.qmdEmbeddingBacklogThreshold)) console.log(line);
 

package/src/corpus-watermark.test.ts

@@ -780,6 +780,22 @@ test("finding round-7: namespace enumeration is cached (resolved once per TTL, s
   assert.equal(resolveCalls, 2, "re-enumerated once the TTL elapsed");
 });
 
+test("computeServiceCorpusCensus returns incomplete when roots refresh error is set in cache", async () => {
+  const cache = new CorpusWatermarkCache();
+  const host = {
+    config: parseConfig({ namespacesEnabled: true }),
+    getStorage: async () => ({ readAllMemories: async () => [] } as unknown as StorageManager),
+  };
+  const failingResolve = async (): Promise<CorpusNamespaceRoot[]> => {
+    throw new Error("disk unreadable");
+  };
+  cache.getResolvedRootsStatus(failingResolve);
+  await cache.whenIdle();
+  const census = await computeServiceCorpusCensus(host, { cache });
+  assert.equal(census.complete, false);
+  assert.deepEqual(census.watermarks, []);
+});
+
 test("finding round-9: background refresh scans are bounded to maxConcurrentRefreshes", async () => {
   const cache = new CorpusWatermarkCache({ maxConcurrentRefreshes: 2 });
   let active = 0;

package/src/corpus-watermark.ts

@@ -312,9 +312,13 @@ export interface CorpusNamespaceRoot {
  */
 export async function resolveCorpusNamespaceRoots(options: {
   config: PluginConfig;
+  propagateDiscoveryErrors?: boolean;
 }): Promise<CorpusNamespaceRoot[]> {
   const { config } = options;
-  const configDriven = await listNamespaces({ config });
+  const configDriven = await listNamespaces({
+    config,
+    propagateDiscoveryErrors: options.propagateDiscoveryErrors,
+  });
   // Default namespace first so it wins the representative label when several
   // configured names collapse onto one root (namespaces disabled → memoryDir).
   const ordered = [
@@ -376,6 +380,7 @@ export class CorpusWatermarkCache {
   private readonly clock: () => number;
   private rootsEntry: { value: CorpusNamespaceRoot[]; expiresAt: number } | undefined;
   private rootsInFlight: Promise<void> | undefined;
+  private rootsRefreshError: unknown;
   private readonly queued = new Map<string, () => void>();
   private activeRefreshes = 0;
   private readonly maxConcurrentRefreshes: number;
@@ -444,9 +449,12 @@ export class CorpusWatermarkCache {
       this.rootsInFlight = compute()
         .then((value) => {
           this.rootsEntry = { value, expiresAt: this.clock() + this.ttlMs };
+          this.rootsRefreshError = undefined;
         })
-        .catch(() => {
-          // Enumeration failed: keep serving any stale roots; retry next probe.
+        .catch((error: unknown) => {
+          this.rootsRefreshError = error;
+          // Keep serving any stale roots; callers that require completeness
+          // inspect the refresh status before trusting them.
         })
         .finally(() => {
           this.rootsInFlight = undefined;
@@ -454,6 +462,14 @@ export class CorpusWatermarkCache {
     }
     return this.rootsEntry?.value;
   }
+
+  getResolvedRootsStatus(compute: () => Promise<CorpusNamespaceRoot[]>): {
+    roots: CorpusNamespaceRoot[] | undefined;
+    refreshError: unknown;
+  } {
+    const roots = this.getResolvedRoots(compute);
+    return { roots, refreshError: this.rootsRefreshError };
+  }
   /** Await every background refresh — in-flight AND queued (issue #2156 round-9) —
    *  plus any roots refresh (shutdown / deterministic tests). */
   async whenIdle(): Promise<void> {
@@ -518,10 +534,17 @@ export async function computeServiceCorpusCensus(
 ): Promise<{ watermarks: CorpusWatermark[]; complete: boolean }> {
   let roots: CorpusNamespaceRoot[] | undefined;
   if (options.cache) {
-    roots = options.cache.getResolvedRoots(() => resolveCorpusNamespaceRoots({ config: host.config }));
+    const { roots: cachedRoots, refreshError } = options.cache.getResolvedRootsStatus(() =>
+      resolveCorpusNamespaceRoots({ config: host.config, propagateDiscoveryErrors: true }),
+    );
+    if (refreshError !== undefined) return { watermarks: [], complete: false };
+    roots = cachedRoots;
   } else {
     try {
-      roots = await resolveCorpusNamespaceRoots({ config: host.config });
+      roots = await resolveCorpusNamespaceRoots({
+        config: host.config,
+        propagateDiscoveryErrors: true,
+      });
     } catch {
       return { watermarks: [], complete: false }; // never enumerated — not an empty corpus
     }

package/src/extraction-liveness.test.ts

@@ -194,6 +194,30 @@ test("evaluate: an unreadable buffer degrades with a distinct reason, even with
   assert.equal(disabled.degraded, false, "disabled gate suppresses even a read-failure degradation");
 });
 
+test("evaluate: a warming aggregate watermark remains pending without degrading", () => {
+  const status = evaluateExtractionLiveness({
+    config: ENABLED,
+    lastExtractionAt: null,
+    snapshot: snapshot({ bufferedSessionCount: 1, pendingTurnCount: 2 }),
+    nowMs: NOW,
+    watermarkPending: true,
+  });
+  assert.equal(status.degraded, false);
+  assert.equal(status.watermarkPending, true);
+});
+
+test("evaluate: warming watermark does not suppress an independent buffer read failure", () => {
+  const status = evaluateExtractionLiveness({
+    config: ENABLED,
+    lastExtractionAt: null,
+    snapshot: snapshot({ readFailed: true, readError: "buffer unavailable" }),
+    nowMs: NOW,
+    watermarkPending: true,
+  });
+  assert.equal(status.degraded, true);
+  assert.match(status.degradedReason ?? "", /buffer unavailable/);
+});
+
 test("evaluate: an unreadable watermark degrades with a distinct reason, even with an empty buffer (§22)", () => {
   const status = evaluateExtractionLiveness({
     config: ENABLED,
@@ -311,22 +335,14 @@ test("getBufferSnapshot: counts retained (deferred) turns as pending, not just a
   assert.equal(snap.oldestTurnTimestamp, "2026-04-01T00:00:00.000Z", "oldest is the first retained turn");
 });
 
-test("evaluate: emits watermarkScope, defaulting to root-store and honoring an explicit scope", () => {
-  const rootScoped = evaluateExtractionLiveness({
-    config: ENABLED,
-    lastExtractionAt: null,
-    snapshot: snapshot(),
-    nowMs: NOW,
-  });
-  assert.equal(rootScoped.watermarkScope, "root-store", "defaults to root-store today (#2159)");
-  const aggregate = evaluateExtractionLiveness({
+test("evaluate: emits only the aggregate watermark scope", () => {
+  const status = evaluateExtractionLiveness({
     config: ENABLED,
     lastExtractionAt: null,
     snapshot: snapshot(),
     nowMs: NOW,
-    watermarkScope: "aggregate",
   });
-  assert.equal(aggregate.watermarkScope, "aggregate", "threads an explicit scope for #2159");
+  assert.equal(status.watermarkScope, "aggregate");
 });
 
 // ── ExtractionLivenessWarnThrottle ───────────────────────────────────────────
@@ -339,7 +355,7 @@ test("throttle: warns once per staleness window and again after it elapses; rese
     oldestBufferedTurnAgeMs: null,
     degraded: true,
     degradedReason: "stalled",
-    watermarkScope: "root-store",
+    watermarkScope: "aggregate",
   };
   const healthy: ExtractionLivenessStatus = { ...degraded, degraded: false, degradedReason: null };
   const t = new ExtractionLivenessWarnThrottle();
@@ -351,13 +367,31 @@ test("throttle: warns once per staleness window and again after it elapses; rese
   assert.equal(t.maybeWarn(degraded, WINDOW, NOW + WINDOW + 2), true, "recovery reset lets a fresh episode warn at once");
 });
 
+test("summarizeExtractionLiveness: fails closed for legacy root-store-only storage argument", async () => {
+  const storage = {
+    readMetadata: async () => ({ lastExtractionAt: "2026-07-29T10:00:00.000Z" }),
+  };
+  const doctorCheck = await summarizeExtractionLiveness(
+    { extractionLiveness: { enabled: true, staleWindowMs: WINDOW } },
+    storage,
+    undefined,
+    NOW,
+  );
+  assert.equal(doctorCheck.status, "warn");
+  assert.ok(doctorCheck.summary.includes("aggregate watermark unavailable"));
+});
+
 // ── renderExtractionLivenessStats ────────────────────────────────────────────
 
 test("renderExtractionLivenessStats: emits watermark, backlog, and a degraded verdict", async () => {
+  let rootReads = 0;
   const orchestrator = {
     config: { extractionLiveness: { enabled: true, staleWindowMs: WINDOW } },
     storage: {
-      loadMeta: async () => ({ extractionCount: 7, lastExtractionAt: ancient, lastConsolidationAt: null }),
+      loadMeta: async () => {
+        rootReads += 1;
+        return { extractionCount: 7, lastExtractionAt: ancient, lastConsolidationAt: null };
+      },
     },
     buffer: {
       getBufferSnapshot: async (): Promise<ExtractionBufferSnapshot> => ({
@@ -367,14 +401,32 @@ test("renderExtractionLivenessStats: emits watermark, backlog, and a degraded ve
       }),
     },
   };
-  const lines = await renderExtractionLivenessStats(orchestrator, NOW);
+  const lines = await renderExtractionLivenessStats(
+    orchestrator,
+    {
+      lastExtractionAt: ancient,
+      readFailed: false,
+      rootStats: { extractionCount: 7, lastConsolidationAt: null },
+    },
+    NOW,
+  );
   assert.ok(lines.includes("Extractions: 7"), "reports extraction count");
+  assert.equal(rootReads, 0, "rendering reuses the aggregate reader's root metadata");
   assert.ok(lines.includes("Buffered sessions: 2 (5 turns pending)"), "reports backlog");
-  assert.ok(lines.includes("Extraction watermark scope: root-store"), "reports the watermark scope");
+  assert.ok(lines.includes("Extraction watermark scope: aggregate"), "reports the watermark scope");
   assert.ok(
     lines.some((l) => l.startsWith("Extraction liveness: DEGRADED")),
     "reports a degraded verdict when the watermark is stale",
   );
+  const warmingLines = await renderExtractionLivenessStats(
+    orchestrator,
+    { lastExtractionAt: null, readFailed: false, pending: true },
+    NOW,
+  );
+  assert.ok(
+    warmingLines.some((line) => line === "Extraction liveness: ok"),
+    "cache warming is pending rather than degraded",
+  );
 });
 
 test("renderExtractionLivenessStats: reports DEGRADED when the buffer read fails (§22)", async () => {
@@ -393,7 +445,11 @@ test("renderExtractionLivenessStats: reports DEGRADED when the buffer read fails
       },
     },
   };
-  const lines = await renderExtractionLivenessStats(orchestrator, NOW);
+  const lines = await renderExtractionLivenessStats(
+    orchestrator,
+    { lastExtractionAt: new Date(NOW).toISOString(), readFailed: false },
+    NOW,
+  );
   const verdict = lines.find((l) => l.startsWith("Extraction liveness:"));
   assert.ok(verdict, "emits a liveness verdict line");
   assert.match(verdict, /DEGRADED/);
@@ -418,7 +474,11 @@ test("renderExtractionLivenessStats: reports DEGRADED + unavailable counts when
       }),
     },
   };
-  const lines = await renderExtractionLivenessStats(orchestrator, NOW);
+  const lines = await renderExtractionLivenessStats(
+    orchestrator,
+    { lastExtractionAt: null, readFailed: true, readError: "meta.json corrupt" },
+    NOW,
+  );
   assert.ok(lines.includes("Extractions: unavailable"), "meta counts read as unavailable, not 0/never");
   const verdict = lines.find((l) => l.startsWith("Extraction liveness:"));
   assert.match(verdict ?? "", /DEGRADED/);
@@ -448,12 +508,14 @@ test("resolveExtractionLivenessConfig: absent or partial block defaults to enabl
 });
 
 test("summarizeExtractionLiveness: no throw when the extractionLiveness block is absent or partial (host/legacy config)", async () => {
-  const storage = { loadMeta: async () => ({ lastExtractionAt: null }) };
   // A PluginConfig built directly (host adapter / older persisted config) can omit
   // the block or leave it partial; every liveness surface must return a sane status
   // rather than crash (#2155 review).
   for (const config of [{}, { extractionLiveness: {} }, { extractionLiveness: { enabled: true } }]) {
-    const check = await summarizeExtractionLiveness(config as never, storage);
+    const check = await summarizeExtractionLiveness(
+      config as never,
+      { lastExtractionAt: null, readFailed: false },
+    );
     assert.equal(check.key, "extraction_liveness");
     assert.ok(check.status === "ok" || check.status === "warn", `sane status for ${JSON.stringify(config)}`);
     assert.ok(!check.summary.includes("liveness check disabled"), "missing/partial block reads as enabled default");