@remnic/core 9.40.0 → 9.42.0

package/src/extraction-watermark.test.ts

@@ -0,0 +1,290 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { TOKEN_CAPABILITIES_VERSION } from "./access-token-capabilities.js";
+import { parseConfig } from "./config.js";
+import { CorpusWatermarkCache } from "./corpus-watermark.js";
+import { readAggregateExtractionWatermark } from "./orchestration/extraction-watermark.js";
+import type { PluginConfig } from "./types.js";
+
+interface FakeWatermarkStorage {
+  readonly dir: string;
+  loadMeta(): Promise<{ lastExtractionAt: string | null }>;
+}
+
+function storage(dir: string, read: () => Promise<string | null>): FakeWatermarkStorage {
+  return {
+    dir,
+    loadMeta: async () => ({ lastExtractionAt: await read() }),
+  };
+}
+
+async function namespacedFixture(): Promise<{
+  memoryDir: string;
+  config: PluginConfig;
+  namespaceDirs: Record<string, string>;
+}> {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-extraction-watermark-"));
+  const namespaceDirs = {
+    "team-a": path.join(memoryDir, "namespaces", "team-a"),
+    "team-b": path.join(memoryDir, "namespaces", "team-b"),
+  };
+  await Promise.all(Object.values(namespaceDirs).map((dir) => mkdir(dir, { recursive: true })));
+  return {
+    memoryDir,
+    config: parseConfig({ memoryDir, namespacesEnabled: true, defaultNamespace: "default" }),
+    namespaceDirs,
+  };
+}
+
+test("aggregate watermark selects the most recent extraction across distinct namespace stores", async () => {
+  const fixture = await namespacedFixture();
+  try {
+    const timestamps = {
+      default: "2026-07-20T12:00:00.000Z",
+      "team-a": "2026-07-21T12:00:00.000Z",
+      "team-b": "2026-07-22T12:00:00.000Z",
+    };
+    const result = await readAggregateExtractionWatermark({
+      config: fixture.config,
+      rootStorage: storage(fixture.memoryDir, async () => timestamps.default),
+      storageForNamespace: async (namespace) =>
+        storage(fixture.namespaceDirs[namespace], async () => timestamps[namespace as keyof typeof timestamps]),
+    });
+
+    assert.deepEqual(result, {
+      lastExtractionAt: timestamps["team-b"],
+      readFailed: false,
+    });
+  } finally {
+    await rm(fixture.memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a namespace-isolated extraction advances the daemon aggregate watermark", async () => {
+  const fixture = await namespacedFixture();
+  try {
+    const rootTimestamp = "2026-07-20T12:00:00.000Z";
+    let teamTimestamp = "2026-07-19T12:00:00.000Z";
+    const options = {
+      config: fixture.config,
+      rootStorage: storage(fixture.memoryDir, async () => rootTimestamp),
+      storageForNamespace: async (namespace: string) =>
+        storage(fixture.namespaceDirs[namespace], async () => (namespace === "team-a" ? teamTimestamp : null)),
+    };
+
+    assert.equal((await readAggregateExtractionWatermark(options)).lastExtractionAt, rootTimestamp);
+    teamTimestamp = "2026-07-23T12:00:00.000Z";
+    assert.equal((await readAggregateExtractionWatermark(options)).lastExtractionAt, teamTimestamp);
+  } finally {
+    await rm(fixture.memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a partial namespace read returns readFailed instead of a survivor's fresh watermark", async () => {
+  const fixture = await namespacedFixture();
+  try {
+    const result = await readAggregateExtractionWatermark({
+      config: fixture.config,
+      rootStorage: storage(fixture.memoryDir, async () => "2026-07-23T12:00:00.000Z"),
+      storageForNamespace: async (namespace) =>
+        storage(fixture.namespaceDirs[namespace], async () => {
+          if (namespace === "team-b") throw new Error("meta store unavailable");
+          return "2026-07-22T12:00:00.000Z";
+        }),
+    });
+
+    assert.equal(result.lastExtractionAt, null, "a surviving timestamp must not be reported as complete");
+    assert.equal(result.readFailed, true);
+    assert.match(result.readError ?? "", /namespace watermark unreadable/);
+    assert.match(result.readError ?? "", /meta store unavailable/);
+  } finally {
+    await rm(fixture.memoryDir, { recursive: true, force: true });
+  }
+});
+test("scoped capabilities filter candidate namespaces during aggregate read", async () => {
+  const fixture = await namespacedFixture();
+  try {
+    let scannedTeamB = false;
+    const result = await readAggregateExtractionWatermark({
+      config: fixture.config,
+      rootStorage: storage(fixture.memoryDir, async () => "2026-07-20T12:00:00.000Z"),
+      storageForNamespace: async (namespace) => {
+        if (namespace === "team-b") scannedTeamB = true;
+        return storage(fixture.namespaceDirs[namespace], async () => "2026-07-25T12:00:00.000Z");
+      },
+      caps: { version: TOKEN_CAPABILITIES_VERSION, namespaces: ["team-a"] },
+    });
+
+    assert.equal(scannedTeamB, false, "team-b should be skipped when token is restricted to team-a");
+    assert.equal(result.readFailed, false);
+  } finally {
+    await rm(fixture.memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("default root capability check uses normalized aliases for migrated storage", async () => {
+  const fixture = await namespacedFixture();
+  try {
+    const migratedDefaultDir = path.join(fixture.memoryDir, "namespaces", "default");
+    await mkdir(migratedDefaultDir, { recursive: true });
+    const result = await readAggregateExtractionWatermark({
+      config: { ...fixture.config, defaultNamespace: " default " },
+      rootStorage: storage(fixture.memoryDir, async () => {
+        throw new Error("inactive legacy root is unreadable");
+      }),
+      storageForNamespace: async (_namespace, rootDir) =>
+        storage(rootDir, async () =>
+          path.resolve(rootDir) === path.resolve(migratedDefaultDir)
+            ? "2026-07-26T12:00:00.000Z"
+            : "2026-07-24T12:00:00.000Z",
+        ),
+      caps: { version: TOKEN_CAPABILITIES_VERSION, namespaces: ["default"] },
+    });
+
+    assert.equal(result.lastExtractionAt, "2026-07-26T12:00:00.000Z");
+    assert.equal(result.readFailed, false);
+  } finally {
+    await rm(fixture.memoryDir, { recursive: true, force: true });
+  }
+});
+test("unparsable non-null timestamp in namespace store fails the aggregate read", async () => {
+  const fixture = await namespacedFixture();
+  try {
+    const result = await readAggregateExtractionWatermark({
+      config: fixture.config,
+      rootStorage: storage(fixture.memoryDir, async () => "2026-07-20T12:00:00.000Z"),
+      storageForNamespace: async (namespace) =>
+        storage(fixture.namespaceDirs[namespace], async () => (namespace === "team-a" ? "invalid-date-string" : "2026-07-25T12:00:00.000Z")),
+    });
+
+    assert.equal(result.lastExtractionAt, null);
+    assert.equal(result.readFailed, true);
+    assert.match(result.readError ?? "", /watermark timestamp invalid/);
+  } finally {
+    await rm(fixture.memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("namespace discovery I/O failure is an explicit incomplete read", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-extraction-watermark-enumeration-"));
+  try {
+    await writeFile(path.join(memoryDir, "namespaces"), "not a directory", "utf8");
+    const config = parseConfig({ memoryDir, namespacesEnabled: true });
+    const result = await readAggregateExtractionWatermark({
+      config,
+      rootStorage: storage(memoryDir, async () => "2026-07-23T12:00:00.000Z"),
+      storageForNamespace: async (_namespace, rootDir) => storage(rootDir, async () => null),
+    });
+
+    assert.equal(result.lastExtractionAt, null);
+    assert.equal(result.readFailed, true);
+    assert.match(result.readError ?? "", /namespace watermark enumeration failed/);
+    assert.match(result.readError ?? "", /ENOTDIR/);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a failed stale-cache refresh makes later reads incomplete", async () => {
+  const fixture = await namespacedFixture();
+  try {
+    let now = 1;
+    const cache = new CorpusWatermarkCache({ ttlMs: 1, clock: () => now });
+    const options = {
+      config: fixture.config,
+      rootStorage: storage(fixture.memoryDir, async () => "2026-07-20T12:00:00.000Z"),
+      storageForNamespace: async (namespace: string) =>
+        storage(fixture.namespaceDirs[namespace], async () => "2026-07-21T12:00:00.000Z"),
+      rootsCache: cache,
+    };
+
+    const coldRead = await readAggregateExtractionWatermark(options);
+    assert.equal(coldRead.readFailed, false);
+    assert.equal(coldRead.pending, true);
+    await cache.whenIdle();
+    assert.equal((await readAggregateExtractionWatermark(options)).readFailed, false);
+
+    await rm(path.join(fixture.memoryDir, "namespaces"), { recursive: true, force: true });
+    await writeFile(path.join(fixture.memoryDir, "namespaces"), "not a directory", "utf8");
+    now += 2;
+    assert.equal(
+      (await readAggregateExtractionWatermark(options)).readFailed,
+      false,
+      "the stale value may be served while refresh is still in flight",
+    );
+    await cache.whenIdle();
+    const failedRefresh = await readAggregateExtractionWatermark(options);
+    assert.equal(failedRefresh.lastExtractionAt, null);
+    assert.equal(failedRefresh.readFailed, true);
+    assert.match(failedRefresh.readError ?? "", /namespace watermark enumeration failed/);
+  } finally {
+    await rm(fixture.memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a cold namespace-root cache is pending, not a failed read", async () => {
+  const fixture = await namespacedFixture();
+  try {
+    let rootReads = 0;
+    const result = await readAggregateExtractionWatermark({
+      config: fixture.config,
+      rootStorage: storage(fixture.memoryDir, async () => {
+        rootReads += 1;
+        return "2026-07-23T12:00:00.000Z";
+      }),
+      storageForNamespace: async (namespace) => storage(fixture.namespaceDirs[namespace], async () => null),
+      rootsCache: {
+        getResolvedRootsStatus: () => ({ roots: undefined, refreshError: undefined }),
+      },
+    });
+
+    assert.equal(result.lastExtractionAt, null);
+    assert.equal(result.readFailed, false);
+    assert.equal(result.pending, true);
+    assert.equal(rootReads, 0, "a root survivor is not read or published before enumeration completes");
+  } finally {
+    await rm(fixture.memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("namespaces disabled performs exactly one root metadata read", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-extraction-watermark-single-"));
+  try {
+    const config = parseConfig({ memoryDir, namespacesEnabled: false });
+    let rootReads = 0;
+    let namespaceResolutions = 0;
+    const timestamp = "2026-07-23T12:00:00.000Z";
+    const result = await readAggregateExtractionWatermark({
+      config,
+      rootStorage: {
+        dir: memoryDir,
+        loadMeta: async () => {
+          rootReads += 1;
+          return {
+            lastExtractionAt: timestamp,
+            extractionCount: 9,
+            lastConsolidationAt: null,
+          };
+        },
+      },
+      storageForNamespace: async () => {
+        namespaceResolutions += 1;
+        throw new Error("disabled path must not resolve namespace storage");
+      },
+    });
+
+    assert.deepEqual(result, {
+      lastExtractionAt: timestamp,
+      readFailed: false,
+      rootStats: { extractionCount: 9, lastConsolidationAt: null },
+    });
+    assert.equal(rootReads, 1);
+    assert.equal(namespaceResolutions, 0);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/namespaces/migrate.ts

@@ -65,6 +65,7 @@ async function hasAnyLegacyData(rootDir: string): Promise<boolean> {
 
 async function discoverConfiguredNamespaces(
   config: PluginConfig,
+  propagateDiscoveryErrors: boolean,
 ): Promise<string[]> {
   const discovered = new Set<string>([
     config.defaultNamespace,
@@ -85,7 +86,10 @@ async function discoverConfiguredNamespaces(
         discovered.add(namespace);
       }
     }
-  } catch {
+  } catch (error) {
+    if (propagateDiscoveryErrors && (error as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw error;
+    }
     // No namespace directory yet.
   }
 
@@ -95,9 +99,13 @@ async function discoverConfiguredNamespaces(
 export async function listNamespaces(options: {
   config: PluginConfig;
   storageRouter?: NamespaceStorageRouter;
+  propagateDiscoveryErrors?: boolean;
 }): Promise<NamespaceInventoryEntry[]> {
   const storageRouter = options.storageRouter ?? new NamespaceStorageRouter(options.config);
-  const namespaces = await discoverConfiguredNamespaces(options.config);
+  const namespaces = await discoverConfiguredNamespaces(
+    options.config,
+    options.propagateDiscoveryErrors ?? false,
+  );
   const items = await Promise.all(
     namespaces.map(async (namespace) => {
       const storage = await storageRouter.storageFor(namespace);

package/src/operator-doctor-corpus.test.ts

@@ -143,11 +143,18 @@ test("runOperatorDoctor: includes the corpus_watermark check", async () => {
   const { root, memoryDir, configPath, orchestrator } = await makeFixture();
   try {
     await writeMemory(memoryDir, "facts/2026-03-08/a.md");
+    let metadataReads = 0;
+    const loadMeta = orchestrator.storage.loadMeta.bind(orchestrator.storage);
+    orchestrator.storage.loadMeta = async () => {
+      metadataReads += 1;
+      return loadMeta();
+    };
     const report = await runOperatorDoctor({ configPath, orchestrator });
     const check = report.checks.find((c) => c.key === "corpus_watermark");
     assert.ok(check, "expected a corpus_watermark check");
     assert.equal(check?.status, "ok");
     assert.equal(corpusOf(check)[0]?.memoryFileCount, 1);
+    assert.equal(metadataReads, 1, "doctor reuses the root metadata read for extraction liveness");
   } finally {
     await rm(root, { recursive: true, force: true });
   }

package/src/operator-doctor-corpus.ts

@@ -42,7 +42,7 @@ export async function summarizeCorpusWatermark(
     // The doctor orchestrator has no live namespace catalog, so config-driven
     // enumeration (deduped by root inside the shared helper) is the whole set.
     const rootByNamespace = new Map<string, string>();
-    for (const root of await resolveCorpusNamespaceRoots({ config })) {
+    for (const root of await resolveCorpusNamespaceRoots({ config, propagateDiscoveryErrors: true })) {
       rootByNamespace.set(root.namespace, root.rootDir);
     }
     resolved = [...rootByNamespace.keys()];

package/src/operator-toolkit.ts

@@ -4,6 +4,7 @@ import { access, mkdir, readFile, readdir, stat, unlink, writeFile } from "node:
 import { lintWorkspaceFiles } from "./hygiene.js";
 import { parseConfig } from "./config.js";
 import { summarizeExtractionLiveness, type ExtractionBufferSource } from "./extraction-liveness.js";
+import { readAggregateExtractionWatermark } from "./orchestration/extraction-watermark.js";
 import type { OperatorDoctorCheck } from "./operator-doctor-types.js";
 import { readEnvVar, resolveHomeDir } from "./runtime/env.js";
 import { resolvePluginEntry } from "./plugin-entry-resolver.js";
@@ -53,6 +54,7 @@ import type {
   DreamsPhasesConfig,
   FileHygieneConfig,
   MemoryFile,
+  MetaState,
   PluginConfig,
 } from "./types.js";
 import { reportBufferSurpriseDistribution } from "./buffer-surprise-report.js";
@@ -155,12 +157,12 @@ interface ConversationIndexLike {
     }>;
   };
 }
-
 export interface OperatorToolkitOrchestrator extends ConversationIndexLike {
   config: PluginConfig;
   storage: StorageManager;
   qmd: QmdRuntimeLike;
   buffer?: ExtractionBufferSource;
+  getStorage?(namespace: string): Promise<StorageManager>;
 }
 
 export interface OperatorConfigLoadResult {
@@ -1496,11 +1498,10 @@ export async function runOperatorDoctor(options: OperatorDoctorOptions): Promise
   checks.push(await summarizeGraphEdgeDecayStatus(config));
 
   // Tier distribution (issue #686 retention-completion).
-  // Shows hot/cold counts, per-status breakdown, and forgotten-memory count.
-  // Informational only — never errors, never blocks doctor from returning ok.
   checks.push(await summarizeTierDistribution(options.orchestrator.storage));
-  checks.push(await summarizeDreamsPhases(config, storage));
-  checks.push(await summarizeExtractionLiveness(config, storage, options.orchestrator.buffer));
+  checks.push(await summarizeDreamsPhases(config, storage, meta));
+  const extractionWatermark = await readAggregateExtractionWatermark({ config, rootStorage: storage, rootMeta: meta, storageForNamespace: (ns, rootDir) => options.orchestrator.getStorage?.(ns) ?? new StorageManager(rootDir) });
+  checks.push(await summarizeExtractionLiveness(config, extractionWatermark, options.orchestrator.buffer));
   checks.push(...(await summarizeCorpusAndReplica(config, (d) => new StorageManager(d), options.resolveSecretRef)));
   // Security mitigation status (issue #565).
   // Reports whether the cross-namespace budget and anomaly detection
@@ -1898,11 +1899,10 @@ export async function summarizeTierDistribution(
 export async function summarizeDreamsPhases(
   config: Pick<PluginConfig, "memoryDir" | "dreamsPhases">,
   storage: StorageManager = new StorageManager(config.memoryDir),
+  loadedMeta?: MetaState,
 ): Promise<OperatorDoctorCheck> {
   const phases: DreamsPhasesConfig = config.dreamsPhases;
-
-  // Load meta.json for best-available last-run timestamps.
-  const meta = await storage.loadMeta();
+  const meta = loadedMeta ?? (await storage.loadMeta());
 
   let deepSleepLastRun: string | null = null;
   let deepSleepLastRunWarning: string | null = null;

package/src/orchestration/extraction-watermark.ts

@@ -0,0 +1,188 @@
+import path from "node:path";
+
+import { capabilityAllowsNamespace, type TokenCapabilities } from "../access-token-capabilities.js";
+import { resolveNamespaceCapabilities } from "../capabilities.js";
+import { resolveCorpusNamespaceRoots, type CorpusNamespaceRoot } from "../corpus-watermark.js";
+import { normalizeNamespaceIdentity } from "../namespaces/identity.js";
+import type { ExtractionRootStats, ExtractionWatermarkRead } from "../extraction-liveness.js";
+import type { MetaState, PluginConfig } from "../types.js";
+
+export interface ExtractionWatermarkMeta extends Pick<MetaState, "lastExtractionAt"> {
+  extractionCount?: number;
+  lastConsolidationAt?: string | null;
+}
+
+export interface ExtractionWatermarkStorage {
+  readonly dir: string;
+  loadMeta(): Promise<ExtractionWatermarkMeta>;
+}
+
+export interface ExtractionNamespaceRootCache {
+  getResolvedRootsStatus(compute: () => Promise<CorpusNamespaceRoot[]>): {
+    roots: CorpusNamespaceRoot[] | undefined;
+    refreshError: unknown;
+  };
+}
+
+export interface AggregateExtractionWatermarkOptions {
+  config: PluginConfig;
+  rootStorage: ExtractionWatermarkStorage;
+  rootMeta?: ExtractionWatermarkMeta;
+  storageForNamespace(
+    namespace: string,
+    rootDir: string
+  ): ExtractionWatermarkStorage | Promise<ExtractionWatermarkStorage>;
+  rootsCache?: ExtractionNamespaceRootCache;
+  caps?: TokenCapabilities;
+}
+
+function readFailure(reason: string, rootStats?: ExtractionRootStats): ExtractionWatermarkRead {
+  return {
+    lastExtractionAt: null,
+    readFailed: true,
+    readError: reason,
+    ...(rootStats ? { rootStats } : {}),
+  };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function watermarkFromMeta(meta: ExtractionWatermarkMeta, name: string): ExtractionWatermarkRead {
+  if (meta.lastExtractionAt !== null && meta.lastExtractionAt !== undefined) {
+    const parsed = Date.parse(meta.lastExtractionAt);
+    if (!Number.isFinite(parsed)) {
+      return readFailure(`${name} watermark timestamp invalid`);
+    }
+  }
+  const hasRootStats = meta.extractionCount !== undefined || meta.lastConsolidationAt !== undefined;
+  return {
+    lastExtractionAt: meta.lastExtractionAt ?? null,
+    readFailed: false,
+    ...(hasRootStats
+      ? {
+          rootStats: {
+            extractionCount: meta.extractionCount,
+            lastConsolidationAt: meta.lastConsolidationAt,
+          },
+        }
+      : {}),
+  };
+}
+
+async function readWatermark(storage: ExtractionWatermarkStorage, name: string): Promise<ExtractionWatermarkRead> {
+  try {
+    return watermarkFromMeta(await storage.loadMeta(), name);
+  } catch (error) {
+    return readFailure(`${name} watermark unreadable: ${errorMessage(error)}`);
+  }
+}
+
+async function resolveRoots(
+  options: AggregateExtractionWatermarkOptions
+): Promise<CorpusNamespaceRoot[] | ExtractionWatermarkRead> {
+  const compute = () =>
+    resolveCorpusNamespaceRoots({
+      config: options.config,
+      propagateDiscoveryErrors: true,
+    });
+  if (options.rootsCache) {
+    const { roots, refreshError } = options.rootsCache.getResolvedRootsStatus(compute);
+    if (refreshError !== undefined) {
+      return readFailure(`namespace watermark enumeration failed: ${errorMessage(refreshError)}`);
+    }
+    return roots ?? { lastExtractionAt: null, readFailed: false, pending: true };
+  }
+  try {
+    return await compute();
+  } catch (error) {
+    return readFailure(`namespace watermark enumeration failed: ${errorMessage(error)}`);
+  }
+}
+
+function isReadFailure(value: CorpusNamespaceRoot[] | ExtractionWatermarkRead): value is ExtractionWatermarkRead {
+  return !Array.isArray(value);
+}
+
+function newerWatermark(current: string | null, candidate: string | null): string | null {
+  if (candidate === null) return current;
+  const candidateMs = Date.parse(candidate);
+  if (!Number.isFinite(candidateMs)) return current;
+  if (current === null) return candidate;
+  const currentMs = Date.parse(current);
+  return !Number.isFinite(currentMs) || candidateMs > currentMs ? candidate : current;
+}
+
+export async function readAggregateExtractionWatermark(
+  options: AggregateExtractionWatermarkOptions
+): Promise<ExtractionWatermarkRead> {
+  if (!resolveNamespaceCapabilities(options.config).namespaces) {
+    return options.rootMeta
+      ? watermarkFromMeta(options.rootMeta, "root store")
+      : readWatermark(options.rootStorage, "root store");
+  }
+
+  const resolved = await resolveRoots(options);
+  if (isReadFailure(resolved)) return resolved;
+
+  const rootDir = path.resolve(options.rootStorage.dir);
+  const seenDirs = new Set<string>([rootDir]);
+  const targets: CorpusNamespaceRoot[] = [];
+  for (const root of resolved) {
+    if (
+      options.caps &&
+      !root.namespaces.some((ns) =>
+        capabilityAllowsNamespace(options.caps, normalizeNamespaceIdentity(ns)),
+      )
+    ) {
+      continue;
+    }
+    const resolvedDir = path.resolve(root.rootDir);
+    if (seenDirs.has(resolvedDir)) continue;
+    seenDirs.add(resolvedDir);
+    targets.push(root);
+  }
+
+  const defaultNamespace = normalizeNamespaceIdentity(options.config.defaultNamespace);
+  const hasMigratedDefault = resolved.some(
+    (root) =>
+      path.resolve(root.rootDir) !== rootDir &&
+      root.namespaces.some((namespace) => normalizeNamespaceIdentity(namespace) === defaultNamespace),
+  );
+  const canAccessRoot =
+    !hasMigratedDefault &&
+    (!options.caps || capabilityAllowsNamespace(options.caps, defaultNamespace));
+  let rootRead: ExtractionWatermarkRead = { lastExtractionAt: null, readFailed: false };
+  if (canAccessRoot) {
+    rootRead = await readWatermark(options.rootStorage, "root store");
+    if (rootRead.readFailed) return rootRead;
+  }
+  let lastExtractionAt = rootRead.lastExtractionAt;
+
+  const reads = await Promise.all(
+    targets.map(async (target) => {
+      try {
+        const storage = await options.storageForNamespace(target.namespace, target.rootDir);
+        return await readWatermark(storage, "namespace");
+      } catch (error) {
+        return readFailure(`namespace watermark storage unavailable: ${errorMessage(error)}`);
+      }
+    })
+  );
+
+  for (const read of reads) {
+    if (read.readFailed) {
+      return readFailure(
+        read.readError ?? "namespace watermark unreadable",
+        rootRead.rootStats
+      );
+    }
+    lastExtractionAt = newerWatermark(lastExtractionAt, read.lastExtractionAt);
+  }
+  return {
+    lastExtractionAt,
+    readFailed: false,
+    ...(rootRead.rootStats ? { rootStats: rootRead.rootStats } : {}),
+  };
+}

package/dist/chunk-443XCR34.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/extraction-liveness.ts"],"sourcesContent":["/**\n * Extraction-pipeline liveness (issue #2151).\n *\n * A daemon's implicit extraction can fail continuously for months while\n * `/health` stays green and recall keeps serving: every individual failure is\n * logged (timeouts, fallback-no-parsed-output), but nothing aggregates them\n * into a checkable status. This module surfaces a liveness *watermark* — the\n * last successful extraction plus the current buffer backlog — and decides when\n * that watermark is stale enough to call the pipeline degraded.\n *\n * The §22 error-vs-empty principle applies at the pipeline level: \"no\n * extraction succeeded for 90 days\" (a non-empty buffer with a stale/absent\n * watermark) must be distinguishable from \"nothing to extract\" (an empty\n * buffer). Degradation therefore requires a NON-EMPTY buffer — an idle daemon\n * with nothing buffered is healthy, not degraded.\n *\n * The core decision (`evaluateExtractionLiveness`) is a pure function shared by\n * every surface (authenticated `/health`, `remnic doctor`, `remnic stats`) so\n * the verdict never diverges across code paths.\n */\nimport { coerceBool, coerceNumber } from \"./connectors/coerce.js\";\nimport { log } from \"./logger.js\";\nimport type { OperatorDoctorCheck } from \"./operator-doctor-types.js\";\nimport type { MetaState, PluginConfig } from \"./types.js\";\n\n/** Default staleness window: 24h. A watermark older than this with a non-empty buffer is degraded. */\nconst DEFAULT_STALE_WINDOW_MS = 86_400_000;\n\nexport interface ExtractionLivenessConfig {\n  /** Master gate. When false, liveness is never reported degraded. Default true. */\n  enabled: boolean;\n  /**\n   * How stale the last-successful-extraction watermark may get (ms) before a\n   * non-empty buffer flags the pipeline degraded. Default 24h.\n   */\n  staleWindowMs: number;\n}\n\n/**\n * A read-only snapshot of buffered, not-yet-extracted work. Structurally\n * satisfied by `SmartBuffer.getBufferSnapshot()` so callers can pass the live\n * buffer without this module depending on the buffer implementation.\n */\nexport interface ExtractionBufferSnapshot {\n  bufferedSessionCount: number;\n  pendingTurnCount: number;\n  oldestTurnTimestamp: string | null;\n  /**\n   * Set by the liveness reader (never by `SmartBuffer`) when the buffer exists\n   * but its snapshot read threw. An unreadable buffer is a pipeline fault, not\n   * an empty queue (§22): it degrades the pipeline with a distinct reason\n   * instead of masquerading as a zero-backlog (healthy) snapshot.\n   */\n  readFailed?: boolean;\n  /** Read-failure detail, surfaced in the degraded reason when `readFailed`. */\n  readError?: string;\n}\n\nexport interface ExtractionBufferSource {\n  getBufferSnapshot(): Promise<ExtractionBufferSnapshot>;\n}\n\n/**\n * The liveness payload surfaced on `/health.extraction` and in the doctor/stats\n * details.\n *\n * DAEMON-SCOPED SIGNAL: a daemon exposes a single extraction verdict; the\n * last-extraction watermark is read from the daemon's default/root store, so\n * `/health` returns the same `extraction` block for every namespace argument.\n *\n * KNOWN LIMITATION (issue #2159): extraction stamps `lastExtractionAt` on the\n * PER-NAMESPACE store (`storageFor(selfNamespace)`), so this watermark reflects\n * only extraction that stamped the root store (default-namespace work). On a\n * single-namespace deployment (the common case) the watermark and buffer share\n * one scope and the verdict is exact. On a multi-namespace deployment the verdict\n * is NOT guaranteed correct for work isolated to a non-default namespace: it can\n * over-report `degraded` (the default namespace idle while another is extracting)\n * or miss a stall confined to a non-default namespace. Aggregating the watermark\n * across namespace stores is tracked in #2159.\n */\nexport interface ExtractionLivenessStatus {\n  lastExtractionAt: string | null;\n  bufferedSessionCount: number;\n  pendingTurnCount: number;\n  oldestBufferedTurnAgeMs: number | null;\n  degraded: boolean;\n  degradedReason: string | null;\n  /**\n   * Scope of the last-extraction watermark: `root-store` today (read from the\n   * daemon's default/root store only), `aggregate` once it is resolved across\n   * every namespace store (#2159). A monitor can alert on\n   * `watermarkScope !== \"aggregate\"` while namespaces are enabled instead of\n   * trusting a number that may be wrong in either direction.\n   */\n  watermarkScope: \"root-store\" | \"aggregate\";\n}\n\ninterface ExtractionLivenessStorageLike {\n  loadMeta(): Promise<Pick<MetaState, \"lastExtractionAt\">>;\n}\n\ninterface ExtractionLivenessOrchestratorLike {\n  config: Pick<PluginConfig, \"extractionLiveness\">;\n  buffer?: ExtractionBufferSource;\n}\n\n/**\n * Parse the `extractionLiveness` config block. Follows the nested-block shape\n * validation used elsewhere in `config.ts` and coerces string booleans (§24:\n * CLI/JSON deliver `\"false\"`/`\"0\"` as strings, which must read as falsy).\n */\nexport function parseExtractionLivenessConfig(\n  cfg: Record<string, unknown>,\n): ExtractionLivenessConfig {\n  const raw = cfg.extractionLiveness;\n  if (raw !== undefined && (raw === null || typeof raw !== \"object\" || Array.isArray(raw))) {\n    throw new Error(`extractionLiveness must be a plain object (got ${JSON.stringify(raw)})`);\n  }\n  const block = (raw ?? {}) as Record<string, unknown>;\n  return {\n    // `?? true` keeps the default on when the key is absent while honoring\n    // explicit \"false\"/\"0\"/false opt-outs (coerceBool handles the string forms).\n    enabled: coerceBool(block.enabled) ?? true,\n    staleWindowMs: parseStaleWindowMs(block.staleWindowMs),\n  };\n}\n\n/**\n * Parse `extractionLiveness.staleWindowMs`. Absent (`undefined`) → the 24h\n * default; any PRESENT value (including an explicit `null`) must coerce to a\n * positive INTEGER of milliseconds, else THROW. A fractional or non-positive\n * value (\"0.5\" would floor to 0, making every backlog instantly stale; 1.9 would\n * floor to 1) is rejected, never floored/reinterpreted (§1/§17/§39). Mirrors\n * config.ts's `parseIntegerInClosedRange` (round 9 finding 1): only an absent key\n * falls back; an explicit `null` is invalid input, not \"use the default\".\n * Inlined rather than imported because config.ts already imports this module\n * (importing back would be circular), the same reason `recall-concurrency-config.ts`\n * inlines its numeric validation.\n */\nfunction parseStaleWindowMs(value: unknown): number {\n  // Only an absent key (undefined) falls back to the default; an explicit `null`\n  // is invalid input and proceeds to validation → throw (mirrors\n  // parseIntegerInClosedRange, round 9 finding 1).\n  if (value === undefined) return DEFAULT_STALE_WINDOW_MS;\n  const coerced = coerceNumber(value);\n  if (coerced === undefined || !Number.isFinite(coerced) || !Number.isInteger(coerced) || coerced < 1) {\n    throw new Error(\n      `extractionLiveness.staleWindowMs must be an integer greater than or equal to 1; got ${JSON.stringify(value)}`,\n    );\n  }\n  return coerced;\n}\n\n/** Milliseconds between `timestamp` and `nowMs`, clamped at 0; null when unparsable/absent. */\nfunction ageMsFrom(timestamp: string | null, nowMs: number): number | null {\n  if (typeof timestamp !== \"string\") return null;\n  const parsed = Date.parse(timestamp);\n  if (!Number.isFinite(parsed)) return null;\n  return Math.max(0, nowMs - parsed);\n}\n\n/** Compact human-readable duration (\"3d\", \"5h\", \"12m\", \"45s\") for logs and CLI output. */\nexport function formatAgeMs(ms: number): string {\n  const s = Math.max(0, Math.floor(ms / 1000));\n  if (s >= 86_400) return `${Math.floor(s / 86_400)}d`;\n  if (s >= 3_600) return `${Math.floor(s / 3_600)}h`;\n  if (s >= 60) return `${Math.floor(s / 60)}m`;\n  return `${s}s`;\n}\n\n/**\n * Pure liveness verdict. Degraded when the feature is enabled AND any of: the\n * last-extraction watermark could not be READ (a storage fault, §22), the buffer\n * read failed (a pipeline fault, §22), or the buffer is non-empty and the\n * watermark is absent or stale. Each cause yields a DISTINCT reason so an\n * operator can tell a meta-read failure from a buffer-read failure from a\n * pipeline that has genuinely never extracted.\n *\n * Staleness uses a half-open freshness window (§23): an extraction is fresh\n * while its age is in `[0, staleWindowMs)`, so an age of EXACTLY `staleWindowMs`\n * is stale (the upper bound on \"fresh\" is exclusive). A null/unparsable watermark\n * means \"never succeeded\" and is treated as stale — as is a FUTURE watermark (a\n * clock-skewed or corrupt timestamp ahead of now must not read as a fresh\n * extraction and hide a real backlog stall).\n */\nexport function evaluateExtractionLiveness(input: {\n  config: ExtractionLivenessConfig;\n  lastExtractionAt: string | null;\n  snapshot: ExtractionBufferSnapshot;\n  nowMs: number;\n  metaReadFailed?: boolean;\n  metaReadError?: string;\n  watermarkScope?: \"root-store\" | \"aggregate\";\n}): ExtractionLivenessStatus {\n  const { config, lastExtractionAt, snapshot, nowMs } = input;\n  const lastMs = lastExtractionAt !== null ? Date.parse(lastExtractionAt) : Number.NaN;\n  const hasWatermark = Number.isFinite(lastMs);\n  const ageMs = nowMs - lastMs;\n  // A future watermark (negative age) is clock-skewed or corrupt data, not a\n  // fresh extraction: treat it as stale so a real backlog stall is not hidden.\n  const stale = !hasWatermark || ageMs < 0 || ageMs >= config.staleWindowMs;\n  const hasBacklog = snapshot.bufferedSessionCount > 0;\n  // A watermark or buffer that cannot be READ is a fault, not an empty queue\n  // (§22): a storage/pipeline outage must not read as healthy, and must stay\n  // distinct from a pipeline that has genuinely never extracted.\n  const metaReadFailed = input.metaReadFailed === true;\n  const readFailed = snapshot.readFailed === true;\n  const degraded = config.enabled && (metaReadFailed || readFailed || (hasBacklog && stale));\n\n  let degradedReason: string | null = null;\n  if (degraded) {\n    if (metaReadFailed) {\n      degradedReason = `extraction watermark unreadable: ${input.metaReadError ?? \"meta read failed\"}`;\n    } else if (readFailed) {\n      degradedReason = `extraction buffer unreadable: ${snapshot.readError ?? \"buffer snapshot read failed\"}`;\n    } else {\n      const watermark = hasWatermark\n        ? `last succeeded ${formatAgeMs(nowMs - lastMs)} ago`\n        : \"no successful extraction on record\";\n      degradedReason =\n        `${watermark}; ${snapshot.bufferedSessionCount} buffered session(s), ` +\n        `${snapshot.pendingTurnCount} turn(s) pending extraction`;\n    }\n  }\n\n  return {\n    lastExtractionAt,\n    bufferedSessionCount: snapshot.bufferedSessionCount,\n    pendingTurnCount: snapshot.pendingTurnCount,\n    oldestBufferedTurnAgeMs: ageMsFrom(snapshot.oldestTurnTimestamp, nowMs),\n    degraded,\n    degradedReason,\n    watermarkScope: input.watermarkScope ?? \"root-store\",\n  };\n}\n\nconst EMPTY_SNAPSHOT: ExtractionBufferSnapshot = {\n  bufferedSessionCount: 0,\n  pendingTurnCount: 0,\n  oldestTurnTimestamp: null,\n};\n\n/**\n * Read a buffer snapshot without throwing. An ABSENT buffer degrades to an empty\n * (healthy) snapshot — some service constructions have no orchestrator buffer. A\n * buffer that EXISTS but whose read throws yields a `readFailed` snapshot so the\n * verdict can distinguish a pipeline fault from an empty queue (§22).\n */\nasync function readBufferSnapshot(\n  buffer: ExtractionBufferSource | undefined,\n): Promise<ExtractionBufferSnapshot> {\n  if (!buffer || typeof buffer.getBufferSnapshot !== \"function\") return EMPTY_SNAPSHOT;\n  try {\n    return await buffer.getBufferSnapshot();\n  } catch (err) {\n    return {\n      ...EMPTY_SNAPSHOT,\n      readFailed: true,\n      readError: err instanceof Error ? err.message : String(err),\n    };\n  }\n}\n\n/**\n * Gather the liveness status from a meta store (last-extraction watermark) and\n * an optional buffer (backlog). A read failure on EITHER side is captured and\n * surfaced as a DEGRADED status with a distinct reason (§22) rather than being\n * swallowed into a healthy-looking verdict; no failure path throws.\n */\nexport async function gatherExtractionLivenessStatus(input: {\n  config: ExtractionLivenessConfig;\n  storage: ExtractionLivenessStorageLike;\n  buffer: ExtractionBufferSource | undefined;\n  nowMs: number;\n}): Promise<ExtractionLivenessStatus> {\n  const { config, storage, buffer, nowMs } = input;\n  let lastExtractionAt: string | null = null;\n  let metaReadFailed = false;\n  let metaReadError: string | undefined;\n  try {\n    lastExtractionAt = (await storage.loadMeta()).lastExtractionAt ?? null;\n  } catch (err) {\n    // A swallowed loadMeta() failure that reads as \"never extracted\" is the\n    // exact §22 conflation this feature exists to kill — surface it explicitly.\n    metaReadFailed = true;\n    metaReadError = err instanceof Error ? err.message : String(err);\n  }\n  const snapshot = await readBufferSnapshot(buffer);\n  return evaluateExtractionLiveness({\n    config,\n    lastExtractionAt,\n    snapshot,\n    nowMs,\n    metaReadFailed,\n    metaReadError,\n    // Today the watermark comes from the root store only; #2159 flips this to\n    // \"aggregate\" when the resolver reads across every namespace store.\n    watermarkScope: \"root-store\",\n  });\n}\n\n/**\n * Aggregated-WARN throttle (issue #2151): emit at most ONE warning per\n * staleness window while degraded — not one line per failed extraction attempt.\n * State is instance-scoped (held by the owning service), never a module global\n * (§5), so multiple service instances throttle independently.\n */\nexport class ExtractionLivenessWarnThrottle {\n  private lastWarnAtMs: number | null = null;\n\n  /** Warn if degraded and outside the throttle window; returns whether a WARN was emitted. */\n  maybeWarn(status: ExtractionLivenessStatus, staleWindowMs: number, nowMs: number): boolean {\n    if (!status.degraded) {\n      // Recovered (or never degraded): reset so a fresh episode warns at once.\n      this.lastWarnAtMs = null;\n      return false;\n    }\n    if (this.lastWarnAtMs !== null && nowMs - this.lastWarnAtMs < staleWindowMs) return false;\n    this.lastWarnAtMs = nowMs;\n    log.warn(\n      `extraction pipeline liveness degraded: ${status.degradedReason ?? \"buffered turns are not being extracted\"}`,\n    );\n    return true;\n  }\n}\n\n/**\n * Normalize the `extractionLiveness` block at the read boundary. `parseConfig`\n * always populates it, but a host adapter, an older persisted config, or a\n * hand-built `PluginConfig` can hand us an absent, partial, or loosely-typed\n * block - and every liveness surface (/health, doctor, stats) must degrade to\n * the documented default (enabled, 24h window) rather than throw. Both fields\n * are coerced with the same rules as `parseExtractionLivenessConfig` (§24:\n * `\"false\"`/`\"0\"` read as falsy; a numeric string like `\"5000\"` parses), except a\n * present but non-integer or non-positive `staleWindowMs` falls back to the\n * default here rather than throwing.\n */\nexport function resolveExtractionLivenessConfig(\n  block: { enabled?: unknown; staleWindowMs?: unknown } | undefined,\n): ExtractionLivenessConfig {\n  const staleWindowMs = coerceNumber(block?.staleWindowMs);\n  return {\n    enabled: coerceBool(block?.enabled) ?? true,\n    staleWindowMs:\n      staleWindowMs !== undefined && Number.isInteger(staleWindowMs) && staleWindowMs >= 1\n        ? staleWindowMs\n        : DEFAULT_STALE_WINDOW_MS,\n  };\n}\n\n/**\n * Compute the liveness status for the authenticated `/health` payload and emit\n * the throttled aggregated WARN.\n *\n * The watermark is read from the daemon's default/root store (`orchestrator.storage`),\n * which is why `/health` returns the same `extraction` block for any namespace\n * argument. KNOWN LIMITATION (issue #2159): extraction writes `lastExtractionAt`\n * per-namespace, so this watermark reflects only default-namespace extraction and\n * the verdict is exact only for a single-namespace daemon (see\n * `ExtractionLivenessStatus`).\n */\nexport async function computeExtractionLivenessStatus(\n  orchestrator: ExtractionLivenessOrchestratorLike & { storage: ExtractionLivenessStorageLike },\n  throttle?: ExtractionLivenessWarnThrottle,\n  nowMs: number = Date.now(),\n): Promise<ExtractionLivenessStatus> {\n  const config = resolveExtractionLivenessConfig(orchestrator.config.extractionLiveness);\n  const status = await gatherExtractionLivenessStatus({\n    config,\n    storage: orchestrator.storage,\n    buffer: orchestrator.buffer,\n    nowMs,\n  });\n  throttle?.maybeWarn(status, config.staleWindowMs, nowMs);\n  return status;\n}\n\n/**\n * `remnic doctor` check for extraction-pipeline liveness. Status `warn` when\n * degraded (with a remediation hint), `ok` otherwise.\n */\nexport async function summarizeExtractionLiveness(\n  config: Pick<PluginConfig, \"extractionLiveness\">,\n  storage: ExtractionLivenessStorageLike,\n  buffer?: ExtractionBufferSource,\n  nowMs: number = Date.now(),\n): Promise<OperatorDoctorCheck> {\n  const livenessConfig = resolveExtractionLivenessConfig(config.extractionLiveness);\n  const status = await gatherExtractionLivenessStatus({\n    config: livenessConfig,\n    storage,\n    buffer,\n    nowMs,\n  });\n  const scopeNote =\n    ` Watermark scope: ${status.watermarkScope}` +\n    (status.watermarkScope === \"root-store\"\n      ? \" (default-namespace only; multi-namespace aggregation tracked in #2159).\"\n      : \".\");\n  const summary =\n    (status.degraded\n      ? `Extraction pipeline degraded: ${status.degradedReason}.`\n      : `Extraction pipeline healthy: last extraction ${status.lastExtractionAt ?? \"never\"}, ` +\n        `${status.bufferedSessionCount} buffered session(s), ${status.pendingTurnCount} turn(s) pending` +\n        `${livenessConfig.enabled ? \"\" : \" (liveness check disabled)\"}.`) + scopeNote;\n  return {\n    key: \"extraction_liveness\",\n    status: status.degraded ? \"warn\" : \"ok\",\n    summary,\n    remediation: status.degraded\n      ? \"Extraction has stalled while turns are buffered. Inspect daemon logs for extraction \" +\n        \"timeouts or fallback-no-parsed-output errors, verify the extraction model/provider is \" +\n        \"reachable, then force a flush (e.g. `remnic flush`).\"\n      : undefined,\n    details: { ...status, staleWindowMs: livenessConfig.staleWindowMs, enabled: livenessConfig.enabled },\n  };\n}\n\n/** Meta fields the `remnic stats` view renders directly, beyond the liveness watermark. */\ntype ExtractionStatsMeta = Pick<MetaState, \"extractionCount\" | \"lastExtractionAt\" | \"lastConsolidationAt\">;\n\n/**\n * Lines for `remnic stats`: extraction watermark, buffer backlog, and the\n * liveness verdict so dashboards can alert on a stalled pipeline. The meta\n * watermark is loaded HERE (not by the caller) so a meta-read failure surfaces\n * as an explicit DEGRADED verdict plus \"unavailable\" counts (§22) instead of\n * crashing the whole `stats` command.\n */\nexport async function renderExtractionLivenessStats(\n  orchestrator: ExtractionLivenessOrchestratorLike & { storage: { loadMeta(): Promise<ExtractionStatsMeta> } },\n  nowMs: number = Date.now(),\n): Promise<string[]> {\n  let meta: ExtractionStatsMeta | null = null;\n  let metaReadFailed = false;\n  let metaReadError: string | undefined;\n  try {\n    meta = await orchestrator.storage.loadMeta();\n  } catch (err) {\n    metaReadFailed = true;\n    metaReadError = err instanceof Error ? err.message : String(err);\n  }\n  const status = evaluateExtractionLiveness({\n    config: resolveExtractionLivenessConfig(orchestrator.config.extractionLiveness),\n    lastExtractionAt: meta?.lastExtractionAt ?? null,\n    snapshot: await readBufferSnapshot(orchestrator.buffer),\n    nowMs,\n    metaReadFailed,\n    metaReadError,\n  });\n  const oldestAge =\n    status.oldestBufferedTurnAgeMs !== null ? formatAgeMs(status.oldestBufferedTurnAgeMs) : \"n/a\";\n  const unavailable = metaReadFailed ? \"unavailable\" : \"never\";\n  return [\n    `Extractions: ${meta?.extractionCount ?? unavailable}`,\n    `Last extraction: ${meta?.lastExtractionAt ?? unavailable}`,\n    `Last consolidation: ${meta?.lastConsolidationAt ?? unavailable}`,\n    `Buffered sessions: ${status.bufferedSessionCount} (${status.pendingTurnCount} turns pending)`,\n    `Oldest buffered turn age: ${oldestAge}`,\n    `Extraction watermark scope: ${status.watermarkScope}`,\n    `Extraction liveness: ${status.degraded ? `DEGRADED — ${status.degradedReason}` : \"ok\"}`,\n  ];\n}\n"],"mappings":"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","names":[]}