@remnic/core 9.7.15 → 9.8.0

package/dist/chunk-R3DJVOSM.js

@@ -0,0 +1,34 @@
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
+
+// src/structured-attributes.ts
+function stripAttributesSuffix(content) {
+  const trimmed = content.trimEnd();
+  if (!trimmed.endsWith("]")) return content.trim();
+  const marker = "\n[Attributes: ";
+  const markerIndex = trimmed.lastIndexOf(marker);
+  if (markerIndex === -1) return content.trim();
+  const inner = trimmed.slice(markerIndex + marker.length, -1);
+  if (inner.includes("]") || inner.includes("\n")) return content.trim();
+  return trimmed.slice(0, markerIndex).trim();
+}
+function normalizeAttributePairs(pairs) {
+  return Object.entries(pairs).map(([k, v]) => [k.trim().toLowerCase(), v.trim()]).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}: ${v}`).join("; ");
+}
+function assemblePersistedBody(content, structuredAttributes) {
+  let enriched = content;
+  if (structuredAttributes && Object.keys(structuredAttributes).length > 0) {
+    enriched = `${content}
+[Attributes: ${normalizeAttributePairs(structuredAttributes)}]`;
+  }
+  const sanitized = sanitizeMemoryContent(enriched);
+  return { text: sanitized.text, clean: sanitized.clean, violations: sanitized.violations };
+}
+
+export {
+  stripAttributesSuffix,
+  normalizeAttributePairs,
+  assemblePersistedBody
+};
+//# sourceMappingURL=chunk-R3DJVOSM.js.map

package/dist/chunk-R3DJVOSM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/structured-attributes.ts"],"sourcesContent":["/**\n * Shared helpers for the `\\n[Attributes: …]` enrichment suffix that\n * `writeMemory` appends to a stored body when `structuredAttributes` are\n * present.\n *\n * Extracted here (out of `storage.ts`) so every reader — the storage\n * manager, the wearable service, and the coding surfaces — strips the suffix\n * with ONE definition. Previously `coding/architecture-surfaces.ts` carried a\n * weaker local copy that only checked the trailing `]`, which could truncate\n * card markdown that legitimately ends in a `[Attributes: …]` line (cursor\n * review: duplicate attribute suffix stripper).\n *\n * String operations, not regex — CodeQL `js/polynomial-redos` flags\n * suffix-anchored patterns over library-supplied content.\n */\n\nimport { sanitizeMemoryContent } from \"./sanitize.js\";\n\n/**\n * Remove the `[Attributes: …]` suffix `writeMemory` appends to the stored\n * body when structuredAttributes are present, yielding the raw fact/card text\n * for content comparison or client display. Inverse companion of\n * `normalizeAttributePairs` enrichment in `storage.ts`.\n *\n * Returns the stripped (trimmed) body when the marker opens the final\n * non-empty line and its inner payload contains no premature `]` or newline\n * (mirrors the exact shape `normalizeAttributePairs` emits). Otherwise\n * returns the trimmed input unchanged — never truncates legitimate content.\n */\nexport function stripAttributesSuffix(content: string): string {\n  const trimmed = content.trimEnd();\n  if (!trimmed.endsWith(\"]\")) return content.trim();\n  const marker = \"\\n[Attributes: \";\n  const markerIndex = trimmed.lastIndexOf(marker);\n  if (markerIndex === -1) return content.trim();\n  // The block must be the FINAL line and contain no \"]\" before the\n  // closing bracket (mirrors the shape normalizeAttributePairs emits).\n  const inner = trimmed.slice(markerIndex + marker.length, -1);\n  if (inner.includes(\"]\") || inner.includes(\"\\n\")) return content.trim();\n  return trimmed.slice(0, markerIndex).trim();\n}\n// ---------------------------------------------------------------------------\n// Persisted-body assembly (issue #1989 PR2)\n// ---------------------------------------------------------------------------\n//\n// `writeMemory` historically enriched content with the attribute suffix and\n// then sanitized the COMBINED body inline. That assembly is the persisted\n// form both the file body and write-idempotency fingerprints must agree on\n// (AGENTS.md §13), so it lives here — shared by `StorageManager.writeMemory`\n// and `composeMemoryEnvelope` — instead of existing twice.\n\n/**\n * Canonical `key: value; …` rendering of structured attributes. Keys are\n * trimmed + lowercased, values trimmed, pairs sorted by normalized key.\n * Moved verbatim from `storage.ts` (which re-exports it for API stability);\n * used at the write path, the dedup-lookup path, and envelope assembly.\n */\nexport function normalizeAttributePairs(pairs: Record<string, string>): string {\n  return Object.entries(pairs)\n    .map(([k, v]) => [k.trim().toLowerCase(), v.trim()] as [string, string])\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([k, v]) => `${k}: ${v}`)\n    .join(\"; \");\n}\n\nexport interface AssembledPersistBody {\n  /** The exact body persistence writes: enriched then sanitized. */\n  text: string;\n  /** False when sanitization redacted injection-bearing text. */\n  clean: boolean;\n  /** Matched injection pattern sources (for the storage warn log). */\n  violations: string[];\n}\n\n/**\n * Assemble the persisted body exactly as `writeMemory` does: append the\n * normalized attribute suffix when attributes are present, then sanitize the\n * combined result. ONE definition — byte-identity between the legacy write\n * path and the sealed-envelope path is structural, not tested-by-hope.\n */\nexport function assemblePersistedBody(\n  content: string,\n  structuredAttributes?: Record<string, string>,\n): AssembledPersistBody {\n  let enriched = content;\n  if (structuredAttributes && Object.keys(structuredAttributes).length > 0) {\n    enriched = `${content}\\n[Attributes: ${normalizeAttributePairs(structuredAttributes)}]`;\n  }\n  const sanitized = sanitizeMemoryContent(enriched);\n  return { text: sanitized.text, clean: sanitized.clean, violations: sanitized.violations };\n}\n"],"mappings":";;;;;AA6BO,SAAS,sBAAsB,SAAyB;AAC7D,QAAM,UAAU,QAAQ,QAAQ;AAChC,MAAI,CAAC,QAAQ,SAAS,GAAG,EAAG,QAAO,QAAQ,KAAK;AAChD,QAAM,SAAS;AACf,QAAM,cAAc,QAAQ,YAAY,MAAM;AAC9C,MAAI,gBAAgB,GAAI,QAAO,QAAQ,KAAK;AAG5C,QAAM,QAAQ,QAAQ,MAAM,cAAc,OAAO,QAAQ,EAAE;AAC3D,MAAI,MAAM,SAAS,GAAG,KAAK,MAAM,SAAS,IAAI,EAAG,QAAO,QAAQ,KAAK;AACrE,SAAO,QAAQ,MAAM,GAAG,WAAW,EAAE,KAAK;AAC5C;AAiBO,SAAS,wBAAwB,OAAuC;AAC7E,SAAO,OAAO,QAAQ,KAAK,EACxB,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,YAAY,GAAG,EAAE,KAAK,CAAC,CAAqB,EACtE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,EACrC,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,EAC5B,KAAK,IAAI;AACd;AAiBO,SAAS,sBACd,SACA,sBACsB;AACtB,MAAI,WAAW;AACf,MAAI,wBAAwB,OAAO,KAAK,oBAAoB,EAAE,SAAS,GAAG;AACxE,eAAW,GAAG,OAAO;AAAA,eAAkB,wBAAwB,oBAAoB,CAAC;AAAA,EACtF;AACA,QAAM,YAAY,sBAAsB,QAAQ;AAChD,SAAO,EAAE,MAAM,UAAU,MAAM,OAAO,UAAU,OAAO,YAAY,UAAU,WAAW;AAC1F;","names":[]}

package/dist/{chunk-SFQ6QNL7.js → chunk-R6YJI3HE.js}

@@ -71,7 +71,8 @@ async function commitPreparedFileAtomically(tempPath, outputPath, backupPath) {
 }
 
 export {
+  copyExistingFileToBackup,
   writeFileAtomically,
   commitPreparedFileAtomically
 };
-//# sourceMappingURL=chunk-SFQ6QNL7.js.map
+//# sourceMappingURL=chunk-R6YJI3HE.js.map

package/dist/{chunk-5CJVLG3H.js → chunk-RFDD3B7W.js}

@@ -1,12 +1,12 @@
-import {
-  resolveConversationContextCapabilities
-} from "./chunk-BFPETA3S.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
+import {
+  resolveConversationContextCapabilities
+} from "./chunk-SCCO46KZ.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/shared-context/manager.ts
 import { randomUUID } from "crypto";
@@ -704,4 +704,4 @@ export {
   resolveSharedContextDir,
   SharedContextManager
 };
-//# sourceMappingURL=chunk-5CJVLG3H.js.map
+//# sourceMappingURL=chunk-RFDD3B7W.js.map

package/dist/{chunk-JBPKEARU.js → chunk-RKNJBZ55.js}

@@ -1,6 +1,3 @@
-import {
-  ReplitAdapter
-} from "./chunk-TMSXWOBZ.js";
 import {
   ClaudeCodeAdapter
 } from "./chunk-J64TK33U.js";
@@ -10,6 +7,9 @@ import {
 import {
   HermesAdapter
 } from "./chunk-42NQ7AVG.js";
+import {
+  ReplitAdapter
+} from "./chunk-TMSXWOBZ.js";
 
 // src/adapters/registry.ts
 var AdapterRegistry = class {
@@ -53,4 +53,4 @@ var AdapterRegistry = class {
 export {
   AdapterRegistry
 };
-//# sourceMappingURL=chunk-JBPKEARU.js.map
+//# sourceMappingURL=chunk-RKNJBZ55.js.map

package/dist/chunk-ROI7BK7H.js

@@ -0,0 +1,88 @@
+// src/prioritized-embed.ts
+var EMBED_FLUSH_MS = 3e4;
+var EMBED_BATCH_MAX = 50;
+function installPrioritizedEmbedding(getBackendForNamespace, logDebug) {
+  const pendingByNamespace = /* @__PURE__ */ new Map();
+  let embedFlushTimer = null;
+  let disposed = false;
+  const scheduleFlush = () => {
+    if (disposed || embedFlushTimer !== null) return;
+    embedFlushTimer = setTimeout(flushEmbedBatch, EMBED_FLUSH_MS);
+    embedFlushTimer.unref?.();
+  };
+  const flushNamespace = async (namespace, paths) => {
+    let backend;
+    try {
+      backend = await Promise.resolve(getBackendForNamespace(namespace));
+    } catch {
+      if (paths.length > 0) scheduleFlush();
+      return;
+    }
+    if (!backend || typeof backend.embedFiles !== "function") {
+      if (paths.length > 0) scheduleFlush();
+      return;
+    }
+    const batch = paths.splice(0, EMBED_BATCH_MAX);
+    if (paths.length === 0 && pendingByNamespace.get(namespace) === paths) {
+      pendingByNamespace.delete(namespace);
+    }
+    if (batch.length === 0) return;
+    backend.embedFiles(batch).then((ok) => {
+      if (ok === false) {
+        requeue(namespace, paths, batch);
+        return;
+      }
+      if (pendingByNamespace.get(namespace) === paths) {
+        if (paths.length > 0) {
+          scheduleFlush();
+        } else {
+          pendingByNamespace.delete(namespace);
+        }
+      }
+    }).catch(() => {
+      requeue(namespace, paths, batch);
+    });
+  };
+  const requeue = (namespace, paths, batch) => {
+    const live = pendingByNamespace.get(namespace);
+    if (live && live !== paths) {
+      live.unshift(...batch);
+    } else {
+      paths.unshift(...batch);
+      if (!disposed) pendingByNamespace.set(namespace, paths);
+    }
+    scheduleFlush();
+  };
+  const flushEmbedBatch = () => {
+    embedFlushTimer = null;
+    for (const [namespace, paths] of [...pendingByNamespace]) {
+      void flushNamespace(namespace, paths);
+    }
+  };
+  const dispose = () => {
+    disposed = true;
+    if (embedFlushTimer) {
+      clearTimeout(embedFlushTimer);
+      embedFlushTimer = null;
+    }
+    pendingByNamespace.clear();
+  };
+  const enqueue = (filePath, namespace) => {
+    if (disposed) return;
+    const key = namespace ?? "default";
+    let paths = pendingByNamespace.get(key);
+    if (!paths) {
+      paths = [];
+      pendingByNamespace.set(key, paths);
+    }
+    paths.push(filePath);
+    scheduleFlush();
+    logDebug(`prioritized embed: queued ${filePath} in namespace ${key} (${paths.length} pending)`);
+  };
+  return { enqueue, dispose };
+}
+
+export {
+  installPrioritizedEmbedding
+};
+//# sourceMappingURL=chunk-ROI7BK7H.js.map

package/dist/chunk-ROI7BK7H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/prioritized-embed.ts"],"sourcesContent":["/**\n * Prioritized embedding: debounce and batch-trigger collection-level QMD embeds\n * so fresh memory writes become searchable within minutes. The QMD CLI does not\n * support per-file embed targeting; each trigger runs `qmd embed -c <collection>`\n * which embeds all pending files. Batching avoids hammering the CLI on every write.\n *\n * Writes are keyed by namespace so a write persisted into a non-default namespace\n * is embedded against that namespace's own QMD collection/backend, not the default\n * collection (review thread: namespace-aware prioritized embedding).\n *\n * Extracted from orchestrator.ts to keep that file under the structural ratchet.\n */\n\nconst EMBED_FLUSH_MS = 30_000;\nconst EMBED_BATCH_MAX = 50;\n\nexport interface PrioritizedEmbeddingHandle {\n  enqueue: (filePath: string, namespace?: string) => void;\n  dispose: () => void;\n}\n\ninterface EmbedBackend {\n  embedFiles?: (paths: string[]) => Promise<unknown>;\n}\n\nexport function installPrioritizedEmbedding(\n  getBackendForNamespace: (namespace: string) => unknown | Promise<unknown>,\n  logDebug: (msg: string) => void,\n): PrioritizedEmbeddingHandle {\n  const pendingByNamespace = new Map<string, string[]>();\n  let embedFlushTimer: ReturnType<typeof setTimeout> | null = null;\n  let disposed = false;\n\n  const scheduleFlush = (): void => {\n    if (disposed || embedFlushTimer !== null) return;\n    embedFlushTimer = setTimeout(flushEmbedBatch, EMBED_FLUSH_MS);\n    // Do not keep the process alive for the flush delay — short-lived CLI\n    // and import commands must exit promptly (review thread: timer unref).\n    embedFlushTimer.unref?.();\n  };\n\n  const flushNamespace = async (namespace: string, paths: string[]): Promise<void> => {\n    let backend: EmbedBackend | null | undefined;\n    try {\n      backend = (await Promise.resolve(getBackendForNamespace(namespace))) as\n        | EmbedBackend\n        | null\n        | undefined;\n    } catch {\n      if (paths.length > 0) scheduleFlush();\n      return;\n    }\n    if (!backend || typeof backend.embedFiles !== \"function\") {\n      if (paths.length > 0) scheduleFlush();\n      return;\n    }\n    const batch = paths.splice(0, EMBED_BATCH_MAX);\n    if (paths.length === 0 && pendingByNamespace.get(namespace) === paths) {\n      pendingByNamespace.delete(namespace);\n    }\n    if (batch.length === 0) return;\n    backend.embedFiles(batch).then((ok) => {\n      if (ok === false) {\n        requeue(namespace, paths, batch);\n        return;\n      }\n      // Collection-level embed drains the entire backlog. If new writes\n      // were appended to the tail while the embed was in flight, reschedule\n      // so they get picked up; otherwise clear the queue.\n      if (pendingByNamespace.get(namespace) === paths) {\n        if (paths.length > 0) {\n          scheduleFlush();\n        } else {\n          pendingByNamespace.delete(namespace);\n        }\n      }\n    }).catch(() => {\n      requeue(namespace, paths, batch);\n    });\n  };\n\n  const requeue = (namespace: string, paths: string[], batch: string[]): void => {\n    const live = pendingByNamespace.get(namespace);\n    if (live && live !== paths) {\n      live.unshift(...batch);\n    } else {\n      paths.unshift(...batch);\n      if (!disposed) pendingByNamespace.set(namespace, paths);\n    }\n    scheduleFlush();\n  };\n\n  const flushEmbedBatch = (): void => {\n    embedFlushTimer = null;\n    for (const [namespace, paths] of [...pendingByNamespace]) {\n      void flushNamespace(namespace, paths);\n    }\n  };\n\n  const dispose = (): void => {\n    disposed = true;\n    if (embedFlushTimer) {\n      clearTimeout(embedFlushTimer);\n      embedFlushTimer = null;\n    }\n    pendingByNamespace.clear();\n  };\n\n  const enqueue = (filePath: string, namespace?: string): void => {\n    if (disposed) return;\n    const key = namespace ?? \"default\";\n    let paths = pendingByNamespace.get(key);\n    if (!paths) {\n      paths = [];\n      pendingByNamespace.set(key, paths);\n    }\n    paths.push(filePath);\n    scheduleFlush();\n    logDebug(`prioritized embed: queued ${filePath} in namespace ${key} (${paths.length} pending)`);\n  };\n\n  return { enqueue, dispose };\n}\n"],"mappings":";AAaA,IAAM,iBAAiB;AACvB,IAAM,kBAAkB;AAWjB,SAAS,4BACd,wBACA,UAC4B;AAC5B,QAAM,qBAAqB,oBAAI,IAAsB;AACrD,MAAI,kBAAwD;AAC5D,MAAI,WAAW;AAEf,QAAM,gBAAgB,MAAY;AAChC,QAAI,YAAY,oBAAoB,KAAM;AAC1C,sBAAkB,WAAW,iBAAiB,cAAc;AAG5D,oBAAgB,QAAQ;AAAA,EAC1B;AAEA,QAAM,iBAAiB,OAAO,WAAmB,UAAmC;AAClF,QAAI;AACJ,QAAI;AACF,gBAAW,MAAM,QAAQ,QAAQ,uBAAuB,SAAS,CAAC;AAAA,IAIpE,QAAQ;AACN,UAAI,MAAM,SAAS,EAAG,eAAc;AACpC;AAAA,IACF;AACA,QAAI,CAAC,WAAW,OAAO,QAAQ,eAAe,YAAY;AACxD,UAAI,MAAM,SAAS,EAAG,eAAc;AACpC;AAAA,IACF;AACA,UAAM,QAAQ,MAAM,OAAO,GAAG,eAAe;AAC7C,QAAI,MAAM,WAAW,KAAK,mBAAmB,IAAI,SAAS,MAAM,OAAO;AACrE,yBAAmB,OAAO,SAAS;AAAA,IACrC;AACA,QAAI,MAAM,WAAW,EAAG;AACxB,YAAQ,WAAW,KAAK,EAAE,KAAK,CAAC,OAAO;AACrC,UAAI,OAAO,OAAO;AAChB,gBAAQ,WAAW,OAAO,KAAK;AAC/B;AAAA,MACF;AAIA,UAAI,mBAAmB,IAAI,SAAS,MAAM,OAAO;AAC/C,YAAI,MAAM,SAAS,GAAG;AACpB,wBAAc;AAAA,QAChB,OAAO;AACL,6BAAmB,OAAO,SAAS;AAAA,QACrC;AAAA,MACF;AAAA,IACF,CAAC,EAAE,MAAM,MAAM;AACb,cAAQ,WAAW,OAAO,KAAK;AAAA,IACjC,CAAC;AAAA,EACH;AAEA,QAAM,UAAU,CAAC,WAAmB,OAAiB,UAA0B;AAC7E,UAAM,OAAO,mBAAmB,IAAI,SAAS;AAC7C,QAAI,QAAQ,SAAS,OAAO;AAC1B,WAAK,QAAQ,GAAG,KAAK;AAAA,IACvB,OAAO;AACL,YAAM,QAAQ,GAAG,KAAK;AACtB,UAAI,CAAC,SAAU,oBAAmB,IAAI,WAAW,KAAK;AAAA,IACxD;AACA,kBAAc;AAAA,EAChB;AAEA,QAAM,kBAAkB,MAAY;AAClC,sBAAkB;AAClB,eAAW,CAAC,WAAW,KAAK,KAAK,CAAC,GAAG,kBAAkB,GAAG;AACxD,WAAK,eAAe,WAAW,KAAK;AAAA,IACtC;AAAA,EACF;AAEA,QAAM,UAAU,MAAY;AAC1B,eAAW;AACX,QAAI,iBAAiB;AACnB,mBAAa,eAAe;AAC5B,wBAAkB;AAAA,IACpB;AACA,uBAAmB,MAAM;AAAA,EAC3B;AAEA,QAAM,UAAU,CAAC,UAAkB,cAA6B;AAC9D,QAAI,SAAU;AACd,UAAM,MAAM,aAAa;AACzB,QAAI,QAAQ,mBAAmB,IAAI,GAAG;AACtC,QAAI,CAAC,OAAO;AACV,cAAQ,CAAC;AACT,yBAAmB,IAAI,KAAK,KAAK;AAAA,IACnC;AACA,UAAM,KAAK,QAAQ;AACnB,kBAAc;AACd,aAAS,6BAA6B,QAAQ,iBAAiB,GAAG,KAAK,MAAM,MAAM,WAAW;AAAA,EAChG;AAEA,SAAO,EAAE,SAAS,QAAQ;AAC5B;","names":[]}

package/dist/{chunk-FNZQGN76.js → chunk-S2BBISHU.js}

@@ -1,6 +1,6 @@
 import {
   scanMemoryDir
-} from "./chunk-6SXVCD7W.js";
+} from "./chunk-W7IGLX4G.js";
 import {
   isSearchAborted,
   throwIfSearchAborted
@@ -8,10 +8,10 @@ import {
 import {
   reportSearchDegradation,
   resolveEnsureCollectionArgs
-} from "./chunk-RAR2BSEM.js";
+} from "./chunk-YV32N67O.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/search/meilisearch-backend.ts
 var MeilisearchBackend = class {
@@ -253,4 +253,4 @@ function isMeilisearchIndexNotFoundError(err) {
 export {
   MeilisearchBackend
 };
-//# sourceMappingURL=chunk-FNZQGN76.js.map
+//# sourceMappingURL=chunk-S2BBISHU.js.map

package/dist/{chunk-IALLX7EE.js → chunk-S2FSBU4H.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-JLNBQWZ2.js";
 import {
   resolvePipelineProcessingCapabilities
-} from "./chunk-BFPETA3S.js";
+} from "./chunk-SCCO46KZ.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/day-summary.ts
 import path from "path";
@@ -116,4 +116,4 @@ export {
   formatDaySummaryMemories,
   buildExtensionsFooterForSummary
 };
-//# sourceMappingURL=chunk-IALLX7EE.js.map
+//# sourceMappingURL=chunk-S2FSBU4H.js.map

package/dist/{chunk-BFPETA3S.js → chunk-SCCO46KZ.js}

@@ -38,7 +38,8 @@ function resolveAccessSetupCapabilities(config) {
   return Object.freeze({
     recallCrossNamespaceBudget: config.recallCrossNamespaceBudgetEnabled,
     // Optional/default-off flag: preserve `=== true` semantics.
-    recallAuditAnomalyDetection: config.recallAuditAnomalyDetectionEnabled === true
+    recallAuditAnomalyDetection: config.recallAuditAnomalyDetectionEnabled === true,
+    recallSingleFlight: config.recallSingleFlightEnabled === true
   });
 }
 function resolveMemoryLifecycleCapabilities(config) {
@@ -271,4 +272,4 @@ export {
   resolvePipelineProcessingCapabilities,
   resolveConversationContextCapabilities
 };
-//# sourceMappingURL=chunk-BFPETA3S.js.map
+//# sourceMappingURL=chunk-SCCO46KZ.js.map

package/dist/chunk-SCCO46KZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/capabilities.ts"],"sourcesContent":["/**\n * CapabilitySet — recall-operation feature gates resolved once, then threaded.\n *\n * Issue #1523 (Phase 1 of epic #1520). Root cause this addresses: 161+\n * scattered `config.<flag>Enabled` reads mean each gate is re-derived at every\n * call site, and reviews keep finding parallel code paths where one branch\n * checks a gate the other forgot (CLAUDE.md rule 39 — the \"gate divergence\"\n * defect class). The fix is to resolve a frozen capability projection ONCE at\n * the top of the recall operation and pass it down explicitly.\n *\n * Scope of THIS module (first migration PR): only the recall-operation-scoped\n * flags below. Flags that are also read in graph construction, writes, CLI, or\n * the summarizer are deliberately deferred to a follow-up so we never leave a\n * single flag half-migrated (some sites on `caps.`, some on `config.`).\n *\n * Field naming: each field is the config flag name with the trailing `Enabled`\n * removed (`recallMmrEnabled` → `recallMmr`).\n *\n * This is plumbing, not a feature — there is deliberately NO `enabled` gate for\n * the CapabilitySet itself (rule 30 governs behavior changes; resolving and\n * threading a capability projection must stay behavior-preserving).\n *\n * Flag-retirement audit (#1780, 2026-07-08): all projected fields across 18\n * capability sets were verified for live consumers. Two dead projections found\n * and removed: recallGraph (RecallEnhancementCapabilitySet — production reads\n * recallGraphEnabled directly via graph-recall.ts) and behaviorLoopAutoTune\n * (ConversationContextCapabilitySet — production reads behaviorLoopAutoTuneEnabled\n * directly via cli.ts). The flags themselves remain alive.\n */\n\nimport type { PluginConfig } from \"./types.js\";\n\n/**\n * Frozen projection of recall-operation feature gates.\n *\n * Every field is `readonly boolean`. The composition that maps a config flag to\n * a capability (including default-when-undefined semantics for optional flags)\n * lives ONLY in {@link resolveCapabilities} — call sites must read the\n * capability, never re-derive it from raw config.\n */\nexport interface CapabilitySet {\n  /** `rerankCacheEnabled` — cache reranker scores across recall passes. */\n  readonly rerankCache: boolean;\n  /** `recallDirectAnswerEnabled` — observation-mode direct-answer tier. */\n  readonly recallDirectAnswer: boolean;\n  /** `recallMemoryWorthFilterEnabled` — Memory-Worth score reweighting. */\n  readonly recallMemoryWorthFilter: boolean;\n  /** `trustScoreEnabled` — unified TrustScore recall stage (issue #1577). */\n  readonly recallTrustScore: boolean;\n  /** `recallMmrEnabled` — maximal-marginal-relevance diversification. */\n  readonly recallMmr: boolean;\n  /** `recallReasoningTraceBoostEnabled` — boost reasoning-trace memories. */\n  readonly recallReasoningTraceBoost: boolean;\n  /** `recallPlannerLlmEnabled` — LLM-backed recall-mode planner. */\n  readonly recallPlannerLlm: boolean;\n  /** `recallPlannerEnabled` — recall-mode planner (heuristic + optional LLM). */\n  readonly recallPlanner: boolean;\n  /** `recallConfidenceGateEnabled` — Synapse-style confidence gate. */\n  readonly recallConfidenceGate: boolean;\n  /** `graphRecallEnabled` — graph-mode recall tier (gates planner graph mode). */\n  readonly graphRecall: boolean;\n  /** `graphAssistInFullModeEnabled` — graph-assist overlay in full mode. */\n  readonly graphAssistInFullMode: boolean;\n  /** `graphExpandedIntentEnabled` — promote broad-intent asks to graph mode. */\n  readonly graphExpandedIntent: boolean;\n  // --- Issue #1566 Cluster C: mixed-operation flags (recall + summarizer/CLI/writes) ---\n  /** `rerankEnabled` — optional LLM reranking of recall candidates. */\n  readonly rerank: boolean;\n  /** `harmonicRetrievalEnabled` — abstraction-node harmonic retrieval tier. */\n  readonly harmonicRetrieval: boolean;\n  /** `parallelRetrievalEnabled` — three-agent parallel retrieval (DirectFact + Contextual + Temporal). */\n  readonly parallelRetrieval: boolean;\n}\n\n/**\n * Resolve the recall-operation {@link CapabilitySet} from parsed config.\n *\n * Call this ONCE per recall operation (at the `recall()` / `recallInternal`\n * entry) and thread the result down. Composition lives here and only here.\n *\n * Session toggles are intentionally not a parameter yet: `session-toggles.ts`\n * is agent-scoped (per session/agent enable-disable of the whole plugin), not\n * flag-scoped — none of the flags projected here have a per-session override,\n * so there is nothing for a toggle argument to compose at this layer.\n */\nexport function resolveCapabilities(config: PluginConfig): CapabilitySet {\n  return Object.freeze({\n    rerankCache: config.rerankCacheEnabled,\n    recallDirectAnswer: config.recallDirectAnswerEnabled,\n    recallMemoryWorthFilter: config.recallMemoryWorthFilterEnabled,\n    // Issue #1577: TrustScore subsumes the Memory Worth multiplier when on;\n    // the orchestrator runs exactly one of the two (mutual exclusion, rule 39).\n    recallTrustScore: config.trustScoreEnabled === true,\n    recallMmr: config.recallMmrEnabled,\n    recallReasoningTraceBoost: config.recallReasoningTraceBoostEnabled,\n    recallPlannerLlm: config.recallPlannerLlmEnabled,\n    recallPlanner: config.recallPlannerEnabled,\n    recallConfidenceGate: config.recallConfidenceGateEnabled,\n    graphRecall: config.graphRecallEnabled,\n    // Optional flags: preserve the exact default-when-undefined semantics the\n    // migrated call sites used (`!== false` = default-on, `=== true` = default-off).\n    graphAssistInFullMode: config.graphAssistInFullModeEnabled !== false,\n    graphExpandedIntent: config.graphExpandedIntentEnabled === true,\n    // Issue #1566 Cluster C: mixed-operation flags resolved once per recall op.\n    rerank: config.rerankEnabled,\n    harmonicRetrieval: config.harmonicRetrievalEnabled,\n    parallelRetrieval: config.parallelRetrievalEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Graph-construction capability set (issue #1566 Cluster A).\n//\n// The recall CapabilitySet above covers flags whose EVERY read site lives on\n// the recall call chain. The five flags below are read on graph-construction,\n// write/extraction, AND recall paths — so they cannot join the recall set\n// without leaving some sites on `caps.` and others on `config.` (the exact\n// divergence #1523 forbade). They get their own projection, resolved at graph\n// build/write entry (and alongside `caps` when recall reads them).\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of graph-construction feature gates.\n *\n * Every field is `readonly boolean`. Composition (including default-when-\n * undefined semantics for the optional `graphWriteSessionAdjacencyEnabled`)\n * lives ONLY in {@link resolveGraphConstructionCapabilities}.\n */\nexport interface GraphConstructionCapabilitySet {\n  /** `entityGraphEnabled` — maintain entity co-reference graph edges. */\n  readonly entityGraph: boolean;\n  /** `timeGraphEnabled` — maintain thread-adjacency graph edges. */\n  readonly timeGraph: boolean;\n  /** `causalGraphEnabled` — maintain causal-language graph edges. */\n  readonly causalGraph: boolean;\n  /** `multiGraphMemoryEnabled` — master switch for multi-graph writes/traversal. */\n  readonly multiGraphMemory: boolean;\n  /** `graphWriteSessionAdjacencyEnabled` — session-adjacency fallback for time edges (default-on). */\n  readonly graphWriteSessionAdjacency: boolean;\n}\n\n/**\n * Resolve the {@link GraphConstructionCapabilitySet} from parsed config.\n *\n * Call this ONCE at graph build/write entry (extraction, recall graph\n * expansion, graph-health/repair) and thread the result down — exactly the\n * pattern {@link resolveCapabilities} established for recall.\n */\nexport type GraphConstructionConfigProjection = Pick<\n  PluginConfig,\n  | \"entityGraphEnabled\"\n  | \"timeGraphEnabled\"\n  | \"causalGraphEnabled\"\n  | \"multiGraphMemoryEnabled\"\n  | \"graphWriteSessionAdjacencyEnabled\"\n>;\n\nexport function resolveGraphConstructionCapabilities(\n  config: GraphConstructionConfigProjection,\n): GraphConstructionCapabilitySet {\n  return Object.freeze({\n    entityGraph: config.entityGraphEnabled,\n    timeGraph: config.timeGraphEnabled,\n    causalGraph: config.causalGraphEnabled,\n    multiGraphMemory: config.multiGraphMemoryEnabled,\n    // Optional flag: preserve the exact default-when-undefined semantics the\n    // migrated call site used (`!== false` = default-on).\n    graphWriteSessionAdjacency: config.graphWriteSessionAdjacencyEnabled !== false,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Access-setup capability set (issue #1566 Cluster B).\n//\n// These two flags gate cross-namespace recall budgeting and anomaly-detection\n// auditing. Resolved once at access-service handler entry (and the operator\n// doctor check) rather than re-derived from raw config at each site.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of access-setup feature gates (issue #1566 Cluster B).\n *\n * Every field is `readonly boolean`. Composition (including the default-off\n * semantics for the optional `recallAuditAnomalyDetectionEnabled`) lives ONLY\n * in {@link resolveAccessSetupCapabilities}.\n */\nexport interface AccessSetupCapabilitySet {\n  /** `recallCrossNamespaceBudgetEnabled` — rolling cross-namespace recall budget. */\n  readonly recallCrossNamespaceBudget: boolean;\n  /** `recallAuditAnomalyDetectionEnabled` — access-audit anomaly detection (default-off). */\n  readonly recallAuditAnomalyDetection: boolean;\n  readonly recallSingleFlight: boolean;\n}\n\n/** Resolve the {@link AccessSetupCapabilitySet} from parsed config. Call ONCE at\n *  access-service handler entry and thread the result down. */\nexport type AccessSetupConfigProjection = Pick<\n  PluginConfig,\n  \"recallCrossNamespaceBudgetEnabled\" | \"recallAuditAnomalyDetectionEnabled\" | \"recallSingleFlightEnabled\"\n>;\n\nexport function resolveAccessSetupCapabilities(\n  config: AccessSetupConfigProjection,\n): AccessSetupCapabilitySet {\n  return Object.freeze({\n    recallCrossNamespaceBudget: config.recallCrossNamespaceBudgetEnabled,\n    // Optional/default-off flag: preserve `=== true` semantics.\n    recallAuditAnomalyDetection: config.recallAuditAnomalyDetectionEnabled === true,\n    recallSingleFlight: config.recallSingleFlightEnabled === true,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Memory-lifecycle capability set (issue #1523 batch 3).\n//\n// The flags below gate memory WRITE/EXTRACTION (extraction judge, scope\n// classification, dedupe, telemetry prefilter), temporal supersession of\n// stored facts, and the lifecycle policy pass (promotion / decay / stale\n// filtering). They are read on the persistExtraction write path, the recall\n// candidate-filter path, and the maintenance / lifecycle-pass path — so, like\n// the graph-construction set above, they get their own projection resolved\n// ONCE at each operation entry that reads them (never re-derived from raw\n// config mid-operation — the gate-divergence defect class #1523 targets).\n//\n// Every field projects from an already-resolved PluginConfig boolean (defaults\n// are applied at the config-parse boundary, rule 36), so the resolver is a\n// pure projection — no `!== false` / `=== true` re-coercion here.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of memory-lifecycle feature gates (issue #1523 batch 3).\n *\n * Resolved once per write / recall-filter / maintenance operation and threaded\n * down. Composition lives ONLY in {@link resolveMemoryLifecycleCapabilities}.\n */\nexport interface MemoryLifecycleCapabilitySet {\n  /** `temporalSupersessionEnabled` — supersede stale structured facts on write, filter on recall. */\n  readonly temporalSupersession: boolean;\n  /** `temporalMemoryTreeEnabled` — temporal-memory-tree build + recall tier. */\n  readonly temporalMemoryTree: boolean;\n  /** `lifecyclePolicyEnabled` — lifecycle promotion / decay metadata pass. */\n  readonly lifecyclePolicy: boolean;\n  /** `lifecycleFilterStaleEnabled` — filter stale-lifecycle memories from recall. */\n  readonly lifecycleFilterStale: boolean;\n  /** `lifecycleMetricsEnabled` — emit lifecycle-pass metrics. */\n  readonly lifecycleMetrics: boolean;\n  /** `extractionScopeClassificationEnabled` — LLM classifies each fact's scope. */\n  readonly extractionScopeClassification: boolean;\n  /** `extractionJudgeEnabled` — LLM-as-judge fact-worthiness gate. */\n  readonly extractionJudge: boolean;\n  /** `extractionDedupeEnabled` — dedupe against recent extractions. */\n  readonly extractionDedupe: boolean;\n  /** `extractionTelemetryPrefilterEnabled` — skip mechanical-telemetry transcripts. */\n  readonly extractionTelemetryPrefilter: boolean;\n  /** `extractionJudgeTelemetryEnabled` — collect judge verdict telemetry. */\n  readonly extractionJudgeTelemetry: boolean;\n  /** `embeddingFallbackEnabled` — semantic-dedup / archive-search embedding fallback. */\n  readonly embeddingFallback: boolean;\n  /** `extractionRetryEnabled` — per-fingerprint backoff + provider circuit breaker on the extraction retry path. */\n  readonly extractionRetry: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveMemoryLifecycleCapabilities}.\n */\nexport type MemoryLifecycleConfigProjection = Pick<\n  PluginConfig,\n  | \"temporalSupersessionEnabled\"\n  | \"temporalMemoryTreeEnabled\"\n  | \"lifecyclePolicyEnabled\"\n  | \"lifecycleFilterStaleEnabled\"\n  | \"lifecycleMetricsEnabled\"\n  | \"extractionScopeClassificationEnabled\"\n  | \"extractionJudgeEnabled\"\n  | \"extractionDedupeEnabled\"\n  | \"extractionTelemetryPrefilterEnabled\"\n  | \"extractionJudgeTelemetryEnabled\"\n  | \"embeddingFallbackEnabled\"\n  | \"extractionRetryEnabled\"\n>;\n\n/**\n * Resolve the {@link MemoryLifecycleCapabilitySet} from parsed config.\n *\n * Call this ONCE per write / recall-filter / maintenance operation entry and\n * thread the result down — exactly the pattern {@link resolveCapabilities}\n * established for recall.\n */\nexport function resolveMemoryLifecycleCapabilities(\n  config: MemoryLifecycleConfigProjection,\n): MemoryLifecycleCapabilitySet {\n  return Object.freeze({\n    temporalSupersession: config.temporalSupersessionEnabled,\n    temporalMemoryTree: config.temporalMemoryTreeEnabled,\n    lifecyclePolicy: config.lifecyclePolicyEnabled,\n    lifecycleFilterStale: config.lifecycleFilterStaleEnabled,\n    lifecycleMetrics: config.lifecycleMetricsEnabled,\n    extractionScopeClassification: config.extractionScopeClassificationEnabled,\n    extractionJudge: config.extractionJudgeEnabled,\n    extractionDedupe: config.extractionDedupeEnabled,\n    extractionTelemetryPrefilter: config.extractionTelemetryPrefilterEnabled,\n    extractionJudgeTelemetry: config.extractionJudgeTelemetryEnabled,\n    embeddingFallback: config.embeddingFallbackEnabled,\n    extractionRetry: config.extractionRetryEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Indexing capability set (issue #1523 batch 4).\n//\n// The flags below gate query-aware indexing (temporal/tag index build +\n// prefilter) and the conversation index (QMD/FAISS backend selection). They\n// are read on the recall path, the extraction/persist path, and the\n// maintenance/invalidation path — so they get their own projection resolved\n// ONCE at each operation entry that reads them.\n//\n// Every field projects from an already-resolved PluginConfig boolean (defaults\n// applied at the parse boundary), so the resolver is a pure projection.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of indexing feature gates (issue #1523 batch 4).\n *\n * Resolved once per recall / extraction / maintenance operation and threaded\n * down. Composition lives ONLY in {@link resolveIndexingCapabilities}.\n */\nexport interface IndexingCapabilitySet {\n  /** `queryAwareIndexingEnabled` — build + use temporal/tag index for recall prefilter. */\n  readonly queryAwareIndexing: boolean;\n  /** `conversationIndexEnabled` — conversation-index backend (QMD / FAISS). */\n  readonly conversationIndex: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveIndexingCapabilities}.\n */\nexport type IndexingConfigProjection = Pick<\n  PluginConfig,\n  \"queryAwareIndexingEnabled\" | \"conversationIndexEnabled\"\n>;\n\n/**\n * Resolve the {@link IndexingCapabilitySet} from parsed config.\n *\n * Call this ONCE per recall / extraction / maintenance operation entry and\n * thread the result down — exactly the pattern {@link resolveCapabilities}\n * established for recall.\n */\nexport function resolveIndexingCapabilities(\n  config: IndexingConfigProjection,\n): IndexingCapabilitySet {\n  return Object.freeze({\n    queryAwareIndexing: config.queryAwareIndexingEnabled,\n    conversationIndex: config.conversationIndexEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Creation-memory capability set (issue #1523 batch 4).\n//\n// The flags below gate the creation-memory subsystem: resume-bundle handoff,\n// commitment ledger, commitment lifecycle, and the master creation-memory\n// switch. They are read on the extraction/persist path, the recall\n// enrichment path, and the CLI command surface — so they get their own\n// projection resolved ONCE at each operation entry that reads them.\n//\n// Every field projects from an already-resolved PluginConfig boolean (defaults\n// applied at the parse boundary), so the resolver is a pure projection.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of creation-memory feature gates (issue #1523 batch 4).\n *\n * Resolved once per creation-memory operation (CLI command, extraction,\n * recall enrichment) and threaded down. Composition lives ONLY in\n * {@link resolveCreationMemoryCapabilities}.\n */\nexport interface CreationMemoryCapabilitySet {\n  /** `creationMemoryEnabled` — master switch for creation-memory subsystem. */\n  readonly creationMemory: boolean;\n  /** `commitmentLedgerEnabled` — commitment-ledger read/write. */\n  readonly commitmentLedger: boolean;\n  /** `resumeBundlesEnabled` — resume-bundle handoff bundles. */\n  readonly resumeBundles: boolean;\n  /** `commitmentLifecycleEnabled` — commitment lifecycle (promotion / decay). */\n  readonly commitmentLifecycle: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveCreationMemoryCapabilities}.\n */\nexport type CreationMemoryConfigProjection = Pick<\n  PluginConfig,\n  | \"creationMemoryEnabled\"\n  | \"commitmentLedgerEnabled\"\n  | \"resumeBundlesEnabled\"\n  | \"commitmentLifecycleEnabled\"\n>;\n\n/**\n * Resolve the {@link CreationMemoryCapabilitySet} from parsed config.\n *\n * Call this ONCE per creation-memory operation entry and thread the result\n * down — exactly the pattern {@link resolveCapabilities} established for\n * recall.\n */\nexport function resolveCreationMemoryCapabilities(\n  config: CreationMemoryConfigProjection,\n): CreationMemoryCapabilitySet {\n  return Object.freeze({\n    creationMemory: config.creationMemoryEnabled,\n    commitmentLedger: config.commitmentLedgerEnabled,\n    resumeBundles: config.resumeBundlesEnabled,\n    commitmentLifecycle: config.commitmentLifecycleEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Namespace capability set (issue #1523 batch 5).\n//\n// `namespacesEnabled` is the single most-scattered config flag in the codebase\n// (101 read sites outside config.ts across 18 files — orchestrator, access-service,\n// namespace modules, maintenance, CLI, admin). It gates whether the multi-namespace\n// system is active at all: every namespace resolution, storage path, recall budget,\n// and maintenance fanout checks it. Like the other projections above it gets its own\n// resolver invoked ONCE per operation entry rather than re-derived at each site.\n//\n// The field is a non-optional boolean in PluginConfig, so no coercion is needed.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of namespace feature gates (issue #1523 batch 5).\n *\n * Every field is `readonly boolean`. Composition lives ONLY in\n * {@link resolveNamespaceCapabilities}.\n */\nexport interface NamespaceCapabilitySet {\n  /** `namespacesEnabled` — multi-namespace system master switch. */\n  readonly namespaces: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveNamespaceCapabilities}.\n */\nexport type NamespaceConfigProjection = Pick<PluginConfig, \"namespacesEnabled\">;\n\n/**\n * Resolve the {@link NamespaceCapabilitySet} from parsed config.\n *\n * Call this ONCE at operation entry and thread the result down. The flag is a\n * non-optional boolean so the projection is a pure pass-through.\n */\nexport function resolveNamespaceCapabilities(\n  config: NamespaceConfigProjection,\n): NamespaceCapabilitySet {\n  return Object.freeze({\n    namespaces: config.namespacesEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// QMD capability set (issue #1523 batch 6).\n//\n// The twelve QMD (query-managed database) flags are the largest remaining\n// scattered cluster after batch 5. They gate every aspect of the tiered\n// memory system: master switch, tier migration, cold tier, daemon, auto-embed,\n// maintenance, query rerank, intent hints, explain, auto-upgrade, and parity\n// graph. Read sites span orchestrator, operator-toolkit, access-service, and\n// search/factory. All flags are non-optional booleans on PluginConfig (defaults\n// resolved at the parse boundary), so the projection is pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of QMD feature gates (issue #1523 batch 6).\n *\n * Every field is `readonly boolean`. Composition lives ONLY in\n * {@link resolveQmdCapabilities}.\n */\nexport interface QmdCapabilitySet {\n  /** `qmdEnabled` — QMD tiered-memory master switch. */\n  readonly qmd: boolean;\n  /** `qmdTierMigrationEnabled` — automatic tier promotion/demotion. */\n  readonly qmdTierMigration: boolean;\n  /** `qmdTierAutoBackfillEnabled` — backfill stale tier entries. */\n  readonly qmdTierAutoBackfill: boolean;\n  /** `qmdAutoEmbedEnabled` — auto-embed documents on write. */\n  readonly qmdAutoEmbed: boolean;\n  /** `qmdMaintenanceEnabled` — QMD maintenance pass runner. */\n  readonly qmdMaintenance: boolean;\n  /** `qmdColdTierEnabled` — cold-tier storage. */\n  readonly qmdColdTier: boolean;\n  /** `qmdDaemonEnabled` — background QMD daemon. */\n  readonly qmdDaemon: boolean;\n  /** `qmdTierParityGraphEnabled` — tier parity graph. */\n  readonly qmdTierParityGraph: boolean;\n  /** `qmdQueryRerankEnabled` — QMD query reranking. */\n  readonly qmdQueryRerank: boolean;\n  /** `qmdIntentHintsEnabled` — QMD intent hint extraction. */\n  readonly qmdIntentHints: boolean;\n  /** `qmdExplainEnabled` — QMD explain output. */\n  readonly qmdExplain: boolean;\n  /** `qmdAutoUpgradeEnabled` — QMD auto-upgrade tiers. */\n  readonly qmdAutoUpgrade: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveQmdCapabilities}.\n */\nexport type QmdConfigProjection = Pick<\n  PluginConfig,\n  | \"qmdEnabled\"\n  | \"qmdTierMigrationEnabled\"\n  | \"qmdTierAutoBackfillEnabled\"\n  | \"qmdAutoEmbedEnabled\"\n  | \"qmdMaintenanceEnabled\"\n  | \"qmdColdTierEnabled\"\n  | \"qmdDaemonEnabled\"\n  | \"qmdTierParityGraphEnabled\"\n  | \"qmdQueryRerankEnabled\"\n  | \"qmdIntentHintsEnabled\"\n  | \"qmdExplainEnabled\"\n  | \"qmdAutoUpgradeEnabled\"\n>;\n\n/**\n * Resolve the {@link QmdCapabilitySet} from parsed config.\n *\n * Call this ONCE at operation entry and thread the result down. Eleven flags\n * are non-optional booleans (pure pass-through); `qmdColdTierEnabled` is\n * optional and coerced with `=== true` (matching the pre-migration call sites).\n */\nexport function resolveQmdCapabilities(config: QmdConfigProjection): QmdCapabilitySet {\n  return Object.freeze({\n    qmd: config.qmdEnabled,\n    qmdTierMigration: config.qmdTierMigrationEnabled,\n    qmdTierAutoBackfill: config.qmdTierAutoBackfillEnabled,\n    qmdAutoEmbed: config.qmdAutoEmbedEnabled,\n    qmdMaintenance: config.qmdMaintenanceEnabled,\n    qmdColdTier: config.qmdColdTierEnabled === true,\n    qmdDaemon: config.qmdDaemonEnabled,\n    qmdTierParityGraph: config.qmdTierParityGraphEnabled,\n    qmdQueryRerank: config.qmdQueryRerankEnabled,\n    qmdIntentHints: config.qmdIntentHintsEnabled,\n    qmdExplain: config.qmdExplainEnabled,\n    qmdAutoUpgrade: config.qmdAutoUpgradeEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Identity-continuity capability set (issue #1523 batch 6).\n//\n// `identityContinuityEnabled` gates the identity/continuity system (agent\n// identity tracking, continuity incident logging). Its 13 read sites span\n// orchestrator, access-service, and CLI. The flag is a non-optional boolean\n// on PluginConfig, so the projection is a pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of identity-continuity feature gates (issue #1523 batch 6).\n */\nexport interface IdentityContinuityCapabilitySet {\n  /** `identityContinuityEnabled` — identity-continuity master switch. */\n  readonly identityContinuity: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveIdentityContinuityCapabilities}.\n */\nexport type IdentityContinuityConfigProjection = Pick<PluginConfig, \"identityContinuityEnabled\">;\n\n/**\n * Resolve the {@link IdentityContinuityCapabilitySet} from parsed config.\n */\nexport function resolveIdentityContinuityCapabilities(\n  config: IdentityContinuityConfigProjection,\n): IdentityContinuityCapabilitySet {\n  return Object.freeze({\n    identityContinuity: config.identityContinuityEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Local-LLM capability set (issue #1523 batch 6).\n//\n// `localLlmEnabled` gates whether a local (on-device) LLM is used for\n// summarization, embedding fallback, extraction, and search. Its 11 read\n// sites span orchestrator, extraction, embedding-fallback, local-llm,\n// search/embed-helper, and summarizer. The flag is a non-optional boolean.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of local-LLM feature gates (issue #1523 batch 6).\n */\nexport interface LocalLlmCapabilitySet {\n  /** `localLlmEnabled` — local (on-device) LLM master switch. */\n  readonly localLlm: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveLocalLlmCapabilities}.\n */\nexport type LocalLlmConfigProjection = Pick<PluginConfig, \"localLlmEnabled\">;\n\n/**\n * Resolve the {@link LocalLlmCapabilitySet} from parsed config.\n */\nexport function resolveLocalLlmCapabilities(\n  config: LocalLlmConfigProjection,\n): LocalLlmCapabilitySet {\n  return Object.freeze({\n    localLlm: config.localLlmEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Security capability set (issue #1523 batch 7).\n//\n// The four security/trust-zone flags gate quarantine promotion, poisoning\n// defense, and trust-zone recall. Read sites span orchestrator, access-service,\n// CLI, and research-status commands. All flags are non-optional booleans on\n// PluginConfig (defaults resolved at the parse boundary), so the projection is\n// a pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of security/trust-zone feature gates (issue #1523 batch 7).\n */\nexport interface SecurityCapabilitySet {\n  /** `trustZonesEnabled` — master switch for trust-zone enforcement. */\n  readonly trustZones: boolean;\n  /** `quarantinePromotionEnabled` — promote quarantined memories after review. */\n  readonly quarantinePromotion: boolean;\n  /** `memoryPoisoningDefenseEnabled` — detect and defend against memory poisoning. */\n  readonly memoryPoisoningDefense: boolean;\n  /** `trustZoneRecallEnabled` — restrict recall to trusted zones. */\n  readonly trustZoneRecall: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveSecurityCapabilities}.\n */\nexport type SecurityConfigProjection = Pick<\n  PluginConfig,\n  \"trustZonesEnabled\" | \"quarantinePromotionEnabled\" | \"memoryPoisoningDefenseEnabled\" | \"trustZoneRecallEnabled\"\n>;\n\n/**\n * Resolve the {@link SecurityCapabilitySet} from parsed config.\n */\nexport function resolveSecurityCapabilities(config: SecurityConfigProjection): SecurityCapabilitySet {\n  return Object.freeze({\n    trustZones: config.trustZonesEnabled,\n    quarantinePromotion: config.quarantinePromotionEnabled,\n    memoryPoisoningDefense: config.memoryPoisoningDefenseEnabled,\n    trustZoneRecall: config.trustZoneRecallEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Eval/benchmark capability set (issue #1523 batch 7).\n//\n// The five eval/benchmark flags gate the evaluation harness, shadow mode,\n// baseline snapshot management, delta reporting, and red-team benchmarking.\n// Read sites span orchestrator, CLI, and operator-toolkit. All flags are\n// non-optional booleans on PluginConfig.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of eval/benchmark feature gates (issue #1523 batch 7).\n */\nexport interface EvalCapabilitySet {\n  /** `evalHarnessEnabled` — master switch for the eval harness. */\n  readonly evalHarness: boolean;\n  /** `evalShadowModeEnabled` — run evaluations in shadow mode. */\n  readonly evalShadowMode: boolean;\n  /** `benchmarkBaselineSnapshotsEnabled` — manage baseline snapshots. */\n  readonly benchmarkBaselineSnapshots: boolean;\n  /** `benchmarkDeltaReporterEnabled` — report benchmark deltas. */\n  readonly benchmarkDeltaReporter: boolean;\n  /** `memoryRedTeamBenchEnabled` — red-team benchmarking of memory. */\n  readonly memoryRedTeamBench: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveEvalCapabilities}.\n */\nexport type EvalConfigProjection = Pick<\n  PluginConfig,\n  \"evalHarnessEnabled\" | \"evalShadowModeEnabled\" | \"benchmarkBaselineSnapshotsEnabled\" | \"benchmarkDeltaReporterEnabled\" | \"memoryRedTeamBenchEnabled\"\n>;\n\n/**\n * Resolve the {@link EvalCapabilitySet} from parsed config.\n */\nexport function resolveEvalCapabilities(config: EvalConfigProjection): EvalCapabilitySet {\n  return Object.freeze({\n    evalHarness: config.evalHarnessEnabled,\n    evalShadowMode: config.evalShadowModeEnabled,\n    benchmarkBaselineSnapshots: config.benchmarkBaselineSnapshotsEnabled,\n    benchmarkDeltaReporter: config.benchmarkDeltaReporterEnabled,\n    memoryRedTeamBench: config.memoryRedTeamBenchEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Utility-learning capability set (issue #1523 batch 7).\n//\n// The two utility-learning flags gate memory utility learning and\n// promotion-by-outcome. Read sites span orchestrator, CLI research-status\n// commands, and maintenance files. Both flags are non-optional booleans.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of utility-learning feature gates (issue #1523 batch 7).\n */\nexport interface UtilityLearningCapabilitySet {\n  /** `memoryUtilityLearningEnabled` — learn memory utility weights from outcomes. */\n  readonly memoryUtilityLearning: boolean;\n  /** `promotionByOutcomeEnabled` — promote memories by outcome tracking. */\n  readonly promotionByOutcome: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveUtilityLearningCapabilities}.\n */\nexport type UtilityLearningConfigProjection = Pick<\n  PluginConfig,\n  \"memoryUtilityLearningEnabled\" | \"promotionByOutcomeEnabled\"\n>;\n\n/**\n * Resolve the {@link UtilityLearningCapabilitySet} from parsed config.\n */\nexport function resolveUtilityLearningCapabilities(config: UtilityLearningConfigProjection): UtilityLearningCapabilitySet {\n  return Object.freeze({\n    memoryUtilityLearning: config.memoryUtilityLearningEnabled,\n    promotionByOutcome: config.promotionByOutcomeEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Objective-state capability set (issue #1523 batch 7).\n//\n// The three objective-state flags gate objective-state memory, snapshot\n// writes, and recall. Read sites span orchestrator, access-service, CLI\n// creation-ledger commands, and research-status commands. All flags are\n// non-optional booleans.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of objective-state feature gates (issue #1523 batch 7).\n */\nexport interface ObjectiveStateCapabilitySet {\n  /** `objectiveStateMemoryEnabled` — store objective-state memories. */\n  readonly objectiveStateMemory: boolean;\n  /** `objectiveStateSnapshotWritesEnabled` — write objective-state snapshots. */\n  readonly objectiveStateSnapshotWrites: boolean;\n  /** `objectiveStateRecallEnabled` — recall objective-state memories. */\n  readonly objectiveStateRecall: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveObjectiveStateCapabilities}.\n */\nexport type ObjectiveStateConfigProjection = Pick<\n  PluginConfig,\n  \"objectiveStateMemoryEnabled\" | \"objectiveStateSnapshotWritesEnabled\" | \"objectiveStateRecallEnabled\"\n>;\n\n/**\n * Resolve the {@link ObjectiveStateCapabilitySet} from parsed config.\n */\nexport function resolveObjectiveStateCapabilities(config: ObjectiveStateConfigProjection): ObjectiveStateCapabilitySet {\n  return Object.freeze({\n    objectiveStateMemory: config.objectiveStateMemoryEnabled,\n    objectiveStateSnapshotWrites: config.objectiveStateSnapshotWritesEnabled,\n    objectiveStateRecall: config.objectiveStateRecallEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Compression capability set (issue #1523 batch 7).\n//\n// The three compression flags gate guideline learning, semantic refinement,\n// and context-compression actions. Read sites span orchestrator,\n// access-service, and the compression-guideline coordinator. All flags are\n// non-optional booleans.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of compression feature gates (issue #1523 batch 7).\n */\nexport interface CompressionCapabilitySet {\n  /** `compressionGuidelineLearningEnabled` — learn compression guidelines. */\n  readonly compressionGuidelineLearning: boolean;\n  /** `compressionGuidelineSemanticRefinementEnabled` — semantically refine guidelines. */\n  readonly compressionGuidelineSemanticRefinement: boolean;\n  /** `contextCompressionActionsEnabled` — apply context-compression actions. */\n  readonly contextCompressionActions: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveCompressionCapabilities}.\n */\nexport type CompressionConfigProjection = Pick<\n  PluginConfig,\n  \"compressionGuidelineLearningEnabled\" | \"compressionGuidelineSemanticRefinementEnabled\" | \"contextCompressionActionsEnabled\"\n>;\n\n/**\n * Resolve the {@link CompressionCapabilitySet} from parsed config.\n */\nexport function resolveCompressionCapabilities(config: CompressionConfigProjection): CompressionCapabilitySet {\n  return Object.freeze({\n    compressionGuidelineLearning: config.compressionGuidelineLearningEnabled,\n    compressionGuidelineSemanticRefinement: config.compressionGuidelineSemanticRefinementEnabled,\n    contextCompressionActions: config.contextCompressionActionsEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Presentation capability set (issue #1523 batch 8).\n//\n// These flags gate output formatting and presentation across the orchestrator, extraction\n// pipeline, consolidation engine, and related modules. Resolved ONCE per\n// operation entry rather than re-derived from raw config at each read site.\n// All flags are non-optional booleans on PluginConfig (defaults applied at\n// the parse boundary), so the projection is a pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of output formatting and presentation feature gates (issue #1523 batch 8).\n */\nexport interface PresentationCapabilitySet {\n  /** `verbatimArtifactsEnabled` — verbatim-artifact rendering in recall output. */\n  readonly verbatimArtifacts: boolean;\n  /** `memoryBoxesEnabled` — memory-box rendering in recall output. */\n  readonly memoryBoxes: boolean;\n  /** `bufferSurpriseTriggerEnabled` — buffer surprise-detection trigger. */\n  readonly bufferSurpriseTrigger: boolean;\n  /** `threadingEnabled` — conversation threading in output. */\n  readonly threading: boolean;\n  /** `episodeNoteModeEnabled` — episode note-mode formatting. */\n  readonly episodeNoteMode: boolean;\n  /** `transcriptEnabled` — transcript-mode output. */\n  readonly transcript: boolean;\n  /** `entitySummaryEnabled` — entity summary generation. */\n  readonly entitySummary: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolvePresentationCapabilities}.\n */\nexport type PresentationConfigProjection = Pick<\n  PluginConfig,\n  \"verbatimArtifactsEnabled\" |\n  \"memoryBoxesEnabled\" |\n  \"bufferSurpriseTriggerEnabled\" |\n  \"threadingEnabled\" |\n  \"episodeNoteModeEnabled\" |\n  \"transcriptEnabled\" |\n  \"entitySummaryEnabled\"\n>;\n\n/**\n * Resolve the {@link PresentationCapabilitySet} from parsed config.\n */\nexport function resolvePresentationCapabilities(config: PresentationConfigProjection): PresentationCapabilitySet {\n  return Object.freeze({\n    verbatimArtifacts: config.verbatimArtifactsEnabled,\n    memoryBoxes: config.memoryBoxesEnabled,\n    bufferSurpriseTrigger: config.bufferSurpriseTriggerEnabled,\n    threading: config.threadingEnabled,\n    episodeNoteMode: config.episodeNoteModeEnabled,\n    transcript: config.transcriptEnabled,\n    entitySummary: config.entitySummaryEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Consolidation capability set (issue #1523 batch 8).\n//\n// These flags gate memory consolidation, compounding, and abstraction across the orchestrator, extraction\n// pipeline, consolidation engine, and related modules. Resolved ONCE per\n// operation entry rather than re-derived from raw config at each read site.\n// All flags are non-optional booleans on PluginConfig (defaults applied at\n// the parse boundary), so the projection is a pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of memory consolidation, compounding, and abstraction feature gates (issue #1523 batch 8).\n */\nexport interface ConsolidationCapabilitySet {\n  /** `compoundingSemanticEnabled` — semantic compounding of memories. */\n  readonly compoundingSemantic: boolean;\n  /** `abstractionAnchorsEnabled` — abstraction-anchor extraction. */\n  readonly abstractionAnchors: boolean;\n  /** `compoundingEnabled` — master compounding switch. */\n  readonly compounding: boolean;\n  /** `calibrationEnabled` — memory calibration pass. */\n  readonly calibration: boolean;\n  /** `semanticConsolidationEnabled` — semantic consolidation pass. */\n  readonly semanticConsolidation: boolean;\n  /** `patternReinforcementEnabled` — pattern reinforcement in consolidation. */\n  readonly patternReinforcement: boolean;\n  /** `continuityAuditEnabled` — continuity audit during consolidation. */\n  readonly continuityAudit: boolean;\n  /** `graphEdgeDecayEnabled` — graph edge decay in maintenance. */\n  readonly graphEdgeDecay: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveConsolidationCapabilities}.\n */\nexport type ConsolidationConfigProjection = Pick<\n  PluginConfig,\n  \"compoundingSemanticEnabled\" |\n  \"abstractionAnchorsEnabled\" |\n  \"compoundingEnabled\" |\n  \"calibrationEnabled\" |\n  \"semanticConsolidationEnabled\" |\n  \"patternReinforcementEnabled\" |\n  \"continuityAuditEnabled\" |\n  \"graphEdgeDecayEnabled\"\n>;\n\n/**\n * Resolve the {@link ConsolidationCapabilitySet} from parsed config.\n */\nexport function resolveConsolidationCapabilities(config: ConsolidationConfigProjection): ConsolidationCapabilitySet {\n  return Object.freeze({\n    compoundingSemantic: config.compoundingSemanticEnabled,\n    abstractionAnchors: config.abstractionAnchorsEnabled,\n    compounding: config.compoundingEnabled,\n    calibration: config.calibrationEnabled,\n    semanticConsolidation: config.semanticConsolidationEnabled,\n    patternReinforcement: config.patternReinforcementEnabled,\n    continuityAudit: config.continuityAuditEnabled,\n    graphEdgeDecay: config.graphEdgeDecayEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// RecallAuxiliary capability set (issue #1523 batch 8).\n//\n// These flags gate extraction pipeline details and auxiliary recall enrichment across the orchestrator, extraction\n// pipeline, consolidation engine, and related modules. Resolved ONCE per\n// operation entry rather than re-derived from raw config at each read site.\n// All flags are non-optional booleans on PluginConfig (defaults applied at\n// the parse boundary), so the projection is a pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of extraction pipeline details and auxiliary recall enrichment feature gates (issue #1523 batch 8).\n */\nexport interface RecallAuxiliaryCapabilitySet {\n  /** `causalRuleExtractionEnabled` — causal-rule extraction in pipeline. */\n  readonly causalRuleExtraction: boolean;\n  /** `correctionEnabled` — memory correction subsystem. */\n  readonly correction: boolean;\n  /** `continuityIncidentLoggingEnabled` — continuity incident logging. */\n  readonly continuityIncidentLogging: boolean;\n  /** `daySummaryEnabled` — day-summary generation. */\n  readonly daySummary: boolean;\n  /** `versioningEnabled` — memory versioning. */\n  readonly versioning: boolean;\n  /** `verifiedRecallEnabled` — verified-recall tier. */\n  readonly verifiedRecall: boolean;\n  /** `semanticRuleVerificationEnabled` — semantic-rule verification. */\n  readonly semanticRuleVerification: boolean;\n  /** `workProductRecallEnabled` — work-product recall tier. */\n  readonly workProductRecall: boolean;\n  /** `secureStoreEnabled` — secure storage mode. */\n  readonly secureStore: boolean;\n  /** `knowledgeIndexEnabled` — knowledge index in recall. */\n  readonly knowledgeIndex: boolean;\n  /** `factDeduplicationEnabled` — fact deduplication in recall. */\n  readonly factDeduplication: boolean;\n  /** `compactionResetEnabled` — compaction reset on re-ingest. */\n  readonly compactionReset: boolean;\n  /** `entityRetrievalEnabled` — entity retrieval tier. */\n  readonly entityRetrieval: boolean;\n  /** `cronRecallPolicyEnabled` — cron-based recall policy. */\n  readonly cronRecallPolicy: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveRecallAuxiliaryCapabilities}.\n */\nexport type RecallAuxiliaryConfigProjection = Pick<\n  PluginConfig,\n  \"causalRuleExtractionEnabled\" |\n  \"correctionEnabled\" |\n  \"continuityIncidentLoggingEnabled\" |\n  \"daySummaryEnabled\" |\n  \"versioningEnabled\" |\n  \"verifiedRecallEnabled\" |\n  \"semanticRuleVerificationEnabled\" |\n  \"workProductRecallEnabled\" |\n  \"secureStoreEnabled\" |\n  \"knowledgeIndexEnabled\" |\n  \"factDeduplicationEnabled\" |\n  \"compactionResetEnabled\" |\n  \"entityRetrievalEnabled\" |\n  \"cronRecallPolicyEnabled\"\n>;\n\n/**\n * Resolve the {@link RecallAuxiliaryCapabilitySet} from parsed config.\n */\nexport function resolveRecallAuxiliaryCapabilities(config: RecallAuxiliaryConfigProjection): RecallAuxiliaryCapabilitySet {\n  return Object.freeze({\n    causalRuleExtraction: config.causalRuleExtractionEnabled,\n    correction: config.correctionEnabled,\n    continuityIncidentLogging: config.continuityIncidentLoggingEnabled,\n    daySummary: config.daySummaryEnabled,\n    versioning: config.versioningEnabled,\n    verifiedRecall: config.verifiedRecallEnabled,\n    semanticRuleVerification: config.semanticRuleVerificationEnabled,\n    workProductRecall: config.workProductRecallEnabled,\n    secureStore: config.secureStoreEnabled,\n    knowledgeIndex: config.knowledgeIndexEnabled,\n    factDeduplication: config.factDeduplicationEnabled,\n    compactionReset: config.compactionResetEnabled,\n    entityRetrieval: config.entityRetrievalEnabled,\n    cronRecallPolicy: config.cronRecallPolicyEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// RecallEnhancement capability set (issue #1523 batch 9).\n//\n// These 24 flags gate recall enrichment, memory reconstruction, entity\n// relationships, causal trajectory recall, CMC retrieval, and related\n// enhancement paths. Read sites span orchestrator, access-service, graph-recall,\n// and CLI research-status commands. All flags are non-optional booleans on\n// PluginConfig (defaults resolved at the parse boundary), so the projection\n// is a pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of recall-enhancement feature gates (issue #1523 batch 9).\n */\nexport interface RecallEnhancementCapabilitySet {\n  readonly explicitCueRecall: boolean;\n  readonly targetedFactRecall: boolean;\n  readonly focusedListRecall: boolean;\n  readonly responseGuidanceRecall: boolean;\n  readonly eventOrderRecall: boolean;\n  readonly reinforcementRecallBoost: boolean;\n  readonly recallPlannerTelemetry: boolean;\n  readonly peerProfileRecall: boolean;\n  readonly graphAssistShadowEval: boolean;\n  readonly memoryReconstruction: boolean;\n  readonly memoryLinking: boolean;\n  readonly causalTrajectoryRecall: boolean;\n  readonly causalTrajectoryMemory: boolean;\n  readonly cmcRetrieval: boolean;\n  readonly contradictionDetection: boolean;\n  readonly factArchival: boolean;\n  readonly entityRelationships: boolean;\n  readonly entityActivityLog: boolean;\n  readonly compoundingInject: boolean;\n  readonly accessTracking: boolean;\n  readonly autoPromoteToShared: boolean;\n  readonly feedback: boolean;\n  readonly identity: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveRecallEnhancementCapabilities}.\n */\nexport type RecallEnhancementConfigProjection = Pick<\n  PluginConfig,\n  | \"explicitCueRecallEnabled\"\n  | \"targetedFactRecallEnabled\"\n  | \"focusedListRecallEnabled\"\n  | \"responseGuidanceRecallEnabled\"\n  | \"eventOrderRecallEnabled\"\n  | \"reinforcementRecallBoostEnabled\"\n  | \"recallPlannerTelemetryEnabled\"\n  | \"peerProfileRecallEnabled\"\n  | \"graphAssistShadowEvalEnabled\"\n  | \"memoryReconstructionEnabled\"\n  | \"memoryLinkingEnabled\"\n  | \"causalTrajectoryRecallEnabled\"\n  | \"causalTrajectoryMemoryEnabled\"\n  | \"cmcRetrievalEnabled\"\n  | \"contradictionDetectionEnabled\"\n  | \"factArchivalEnabled\"\n  | \"entityRelationshipsEnabled\"\n  | \"entityActivityLogEnabled\"\n  | \"compoundingInjectEnabled\"\n  | \"accessTrackingEnabled\"\n  | \"autoPromoteToSharedEnabled\"\n  | \"feedbackEnabled\"\n  | \"identityEnabled\"\n>;\n\n/**\n * Resolve the {@link RecallEnhancementCapabilitySet} from parsed config.\n */\nexport function resolveRecallEnhancementCapabilities(config: RecallEnhancementConfigProjection): RecallEnhancementCapabilitySet {\n  return Object.freeze({\n    explicitCueRecall: config.explicitCueRecallEnabled,\n    targetedFactRecall: config.targetedFactRecallEnabled,\n    focusedListRecall: config.focusedListRecallEnabled,\n    responseGuidanceRecall: config.responseGuidanceRecallEnabled,\n    eventOrderRecall: config.eventOrderRecallEnabled,\n    reinforcementRecallBoost: config.reinforcementRecallBoostEnabled,\n    recallPlannerTelemetry: config.recallPlannerTelemetryEnabled,\n    peerProfileRecall: config.peerProfileRecallEnabled,\n    graphAssistShadowEval: config.graphAssistShadowEvalEnabled === true,\n    memoryReconstruction: config.memoryReconstructionEnabled,\n    memoryLinking: config.memoryLinkingEnabled,\n    causalTrajectoryRecall: config.causalTrajectoryRecallEnabled,\n    causalTrajectoryMemory: config.causalTrajectoryMemoryEnabled,\n    cmcRetrieval: config.cmcRetrievalEnabled,\n    contradictionDetection: config.contradictionDetectionEnabled,\n    factArchival: config.factArchivalEnabled,\n    entityRelationships: config.entityRelationshipsEnabled,\n    entityActivityLog: config.entityActivityLogEnabled,\n    compoundingInject: config.compoundingInjectEnabled,\n    accessTracking: config.accessTrackingEnabled,\n    autoPromoteToShared: config.autoPromoteToSharedEnabled,\n    feedback: config.feedbackEnabled,\n    identity: config.identityEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// PipelineProcessing capability set (issue #1523 batch 9).\n//\n// These 22 flags gate the extraction/chunking/summarization pipeline and LLM\n// infrastructure. Read sites span orchestrator, extraction, summarizer,\n// embedding-fallback, local-llm, search, day-summary, and semantic-consolidation.\n// All flags are non-optional booleans on PluginConfig (defaults resolved at\n// the parse boundary), so the projection is a pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of pipeline-processing feature gates (issue #1523 batch 9).\n */\nexport interface PipelineProcessingCapabilitySet {\n  readonly chunking: boolean;\n  readonly semanticChunking: boolean;\n  readonly semanticDedup: boolean;\n  readonly summarization: boolean;\n  readonly topicExtraction: boolean;\n  readonly sessionObserver: boolean;\n  readonly profiling: boolean;\n  readonly checkpoint: boolean;\n  readonly traceWeaver: boolean;\n  readonly routingRules: boolean;\n  readonly inlineSourceAttribution: boolean;\n  readonly negativeExamples: boolean;\n  readonly hourlySummaries: boolean;\n  readonly lcm: boolean;\n  readonly localLlmFast: boolean;\n  readonly proactiveExtraction: boolean;\n  readonly delinearize: boolean;\n  readonly slowLog: boolean;\n  readonly hostEmbeddingProvider: boolean;\n  readonly memoryExtensions: boolean;\n  readonly hourlySummariesExtended: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolvePipelineProcessingCapabilities}.\n */\nexport type PipelineProcessingConfigProjection = Pick<\n  PluginConfig,\n  | \"chunkingEnabled\"\n  | \"semanticChunkingEnabled\"\n  | \"semanticDedupEnabled\"\n  | \"summarizationEnabled\"\n  | \"topicExtractionEnabled\"\n  | \"sessionObserverEnabled\"\n  | \"profilingEnabled\"\n  | \"checkpointEnabled\"\n  | \"traceWeaverEnabled\"\n  | \"routingRulesEnabled\"\n  | \"inlineSourceAttributionEnabled\"\n  | \"negativeExamplesEnabled\"\n  | \"hourlySummariesEnabled\"\n  | \"lcmEnabled\"\n  | \"localLlmFastEnabled\"\n  | \"proactiveExtractionEnabled\"\n  | \"delinearizeEnabled\"\n  | \"slowLogEnabled\"\n  | \"hostEmbeddingProviderEnabled\"\n  | \"memoryExtensionsEnabled\"\n  | \"hourlySummariesExtendedEnabled\"\n>;\n\n/**\n * Resolve the {@link PipelineProcessingCapabilitySet} from parsed config.\n */\nexport function resolvePipelineProcessingCapabilities(config: PipelineProcessingConfigProjection): PipelineProcessingCapabilitySet {\n  return Object.freeze({\n    chunking: config.chunkingEnabled,\n    semanticChunking: config.semanticChunkingEnabled,\n    semanticDedup: config.semanticDedupEnabled,\n    summarization: config.summarizationEnabled,\n    topicExtraction: config.topicExtractionEnabled,\n    sessionObserver: config.sessionObserverEnabled === true,\n    profiling: config.profilingEnabled,\n    checkpoint: config.checkpointEnabled,\n    traceWeaver: config.traceWeaverEnabled,\n    routingRules: config.routingRulesEnabled,\n    inlineSourceAttribution: config.inlineSourceAttributionEnabled,\n    negativeExamples: config.negativeExamplesEnabled,\n    hourlySummaries: config.hourlySummariesEnabled,\n    lcm: config.lcmEnabled,\n    localLlmFast: config.localLlmFastEnabled,\n    proactiveExtraction: config.proactiveExtractionEnabled,\n    delinearize: config.delinearizeEnabled,\n    slowLog: config.slowLogEnabled,\n    hostEmbeddingProvider: config.hostEmbeddingProviderEnabled,\n    memoryExtensions: config.memoryExtensionsEnabled,\n    hourlySummariesExtended: config.hourlySummariesExtendedEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// ConversationContext capability set (issue #1523 batch 9).\n//\n// These 12 flags gate conversation context, shared signals, intent routing,\n// operator-aware consolidation, CMC consolidation, maintenance fanout, CLI\n// presentation, and code connectors. Read sites span orchestrator, CLI,\n// shared-context/manager, semantic-consolidation-coordinator, compounding/engine,\n// maintenance modules, procedural stats, connectors, and wearables. All flags\n// are non-optional booleans on PluginConfig (defaults resolved at the parse\n// boundary), so the projection is a pure pass-through.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of conversation/context feature gates (issue #1523 batch 9).\n */\nexport interface ConversationContextCapabilitySet {\n  readonly sharedContext: boolean;\n  readonly intentRouting: boolean;\n  readonly crossSignalsSemantic: boolean;\n  readonly sharedCrossSignalSemantic: boolean;\n  readonly operatorAwareConsolidation: boolean;\n  readonly peerProfileReasoner: boolean;\n  readonly cmcConsolidation: boolean;\n  readonly maintenanceNamespaceFanout: boolean;\n  readonly citations: boolean;\n  readonly semanticRulePromotion: boolean;\n  readonly codexMarketplace: boolean;\n}\n\n/**\n * Config projection consumed by {@link resolveConversationContextCapabilities}.\n */\nexport type ConversationContextConfigProjection = Pick<\n  PluginConfig,\n  | \"sharedContextEnabled\"\n  | \"intentRoutingEnabled\"\n  | \"crossSignalsSemanticEnabled\"\n  | \"sharedCrossSignalSemanticEnabled\"\n  | \"operatorAwareConsolidationEnabled\"\n  | \"peerProfileReasonerEnabled\"\n  | \"cmcConsolidationEnabled\"\n  | \"maintenanceNamespaceFanoutEnabled\"\n  | \"citationsEnabled\"\n  | \"semanticRulePromotionEnabled\"\n  | \"codexMarketplaceEnabled\"\n>;\n\n/**\n * Resolve the {@link ConversationContextCapabilitySet} from parsed config.\n */\nexport function resolveConversationContextCapabilities(config: ConversationContextConfigProjection): ConversationContextCapabilitySet {\n  return Object.freeze({\n    sharedContext: config.sharedContextEnabled,\n    intentRouting: config.intentRoutingEnabled,\n    crossSignalsSemantic: config.crossSignalsSemanticEnabled,\n    sharedCrossSignalSemantic: config.sharedCrossSignalSemanticEnabled === true,\n    operatorAwareConsolidation: config.operatorAwareConsolidationEnabled,\n    peerProfileReasoner: config.peerProfileReasonerEnabled,\n    cmcConsolidation: config.cmcConsolidationEnabled,\n    maintenanceNamespaceFanout: config.maintenanceNamespaceFanoutEnabled,\n    citations: config.citationsEnabled,\n    semanticRulePromotion: config.semanticRulePromotionEnabled,\n    codexMarketplace: config.codexMarketplaceEnabled,\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-SICXL4MK.js

@@ -0,0 +1,165 @@
+import {
+  encodeStoragePathSegment,
+  resolveSafeStoragePath
+} from "./chunk-FF4KLI5W.js";
+
+// src/write-quarantine.ts
+import { randomUUID } from "crypto";
+import { lstat, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "fs/promises";
+import path from "path";
+var DEFAULT_QUARANTINE_CAPS = {
+  maxEntriesPerPrincipal: 500,
+  maxAgeMs: 14 * 24 * 60 * 60 * 1e3
+};
+var QUARANTINE_DIRNAME = "quarantine";
+function validateCaps(caps) {
+  if (!Number.isInteger(caps.maxEntriesPerPrincipal) || caps.maxEntriesPerPrincipal < 1) {
+    throw new Error(
+      `WriteQuarantineStore: maxEntriesPerPrincipal must be a positive integer (got ${caps.maxEntriesPerPrincipal})`
+    );
+  }
+  if (!Number.isFinite(caps.maxAgeMs) || caps.maxAgeMs <= 0) {
+    throw new Error(
+      `WriteQuarantineStore: maxAgeMs must be a positive finite number of milliseconds (got ${caps.maxAgeMs})`
+    );
+  }
+}
+function isQuarantinedRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return (record.operation === "observe" || record.operation === "memory_store" || record.operation === "suggestion_submit") && (record.principal === null || typeof record.principal === "string") && typeof record.attemptedNamespace === "string" && typeof record.timestamp === "string" && "payload" in record;
+}
+var WriteQuarantineStore = class {
+  constructor(memoryDir, caps = DEFAULT_QUARANTINE_CAPS) {
+    this.caps = caps;
+    validateCaps(caps);
+    this.memoryDir = path.resolve(memoryDir);
+  }
+  caps;
+  memoryDir;
+  /** Absolute quarantine root (`<memoryDir>/state/quarantine`). */
+  get root() {
+    return path.join(this.memoryDir, "state", QUARANTINE_DIRNAME);
+  }
+  /**
+   * Resolve a path under the quarantine root, checked for containment and
+   * symlink traversal from `memoryDir` down — so a symlinked `state` or
+   * `quarantine` component that escapes the memory directory is rejected.
+   */
+  safeDir(...segments) {
+    return resolveSafeStoragePath(this.memoryDir, "state", QUARANTINE_DIRNAME, ...segments);
+  }
+  /**
+   * Park a rejected write. Returns the absolute path of the record written.
+   * Prunes the principal's bucket to the configured caps afterward.
+   */
+  async quarantine(input) {
+    const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      operation: input.operation,
+      principal: input.principal ?? null,
+      attemptedNamespace: input.attemptedNamespace,
+      timestamp,
+      payload: input.payload
+    };
+    const principalSegment = encodeStoragePathSegment(input.principal ?? "unknown");
+    const fileName = `${timestamp.replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}.json`;
+    const dir = await this.safeDir(principalSegment);
+    await mkdir(dir, { recursive: true });
+    const finalPath = await this.safeDir(principalSegment, fileName);
+    const tmpPath = await this.safeDir(principalSegment, `${fileName}.tmp`);
+    await writeFile(tmpPath, JSON.stringify(record, null, 2), { encoding: "utf8", flag: "wx" });
+    await rename(tmpPath, finalPath);
+    await this.pruneDir(dir);
+    return finalPath;
+  }
+  /**
+   * All valid, non-expired quarantined records across every principal, oldest
+   * first. Expired records are deleted on read (lazy GC), so an inactive
+   * principal bucket with no follow-up write is still bounded by age.
+   */
+  async list() {
+    const now = Date.now();
+    const records = [];
+    for (const dir of await this.principalDirs()) {
+      for (const file of await this.entryFiles(dir)) {
+        const info = await stat(file).catch(() => null);
+        if (!info) continue;
+        if (now - info.mtimeMs > this.caps.maxAgeMs) {
+          await rm(file, { force: true }).catch(() => {
+          });
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readFile(file, "utf8"));
+        } catch {
+          continue;
+        }
+        if (isQuarantinedRecord(parsed)) records.push(parsed);
+      }
+    }
+    records.sort((a, b) => a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0);
+    return records;
+  }
+  /** Total valid, non-expired quarantined record count across every principal. */
+  async count() {
+    return (await this.list()).length;
+  }
+  /** lstat (no symlink follow): true only for a real directory. */
+  async isRealDir(dir) {
+    const info = await lstat(dir).catch(() => null);
+    return info?.isDirectory() === true;
+  }
+  async principalDirs() {
+    const root = await this.safeDir();
+    if (!await this.isRealDir(root)) return [];
+    let entries;
+    try {
+      entries = await readdir(root, { withFileTypes: true });
+    } catch (err) {
+      if (err?.code === "ENOENT") return [];
+      throw err;
+    }
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(root, entry.name)).sort();
+  }
+  async entryFiles(dir) {
+    if (!await this.isRealDir(dir)) return [];
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (err) {
+      if (err?.code === "ENOENT") return [];
+      throw err;
+    }
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path.join(dir, entry.name)).sort();
+  }
+  async pruneDir(dir) {
+    const files = await this.entryFiles(dir);
+    const now = Date.now();
+    const survivors = [];
+    for (const file of files) {
+      const info = await stat(file).catch(() => null);
+      if (!info) continue;
+      if (now - info.mtimeMs > this.caps.maxAgeMs) {
+        await rm(file, { force: true }).catch(() => {
+        });
+        continue;
+      }
+      survivors.push({ path: file, mtimeMs: info.mtimeMs });
+    }
+    const surplus = survivors.length - this.caps.maxEntriesPerPrincipal;
+    if (surplus <= 0) return;
+    survivors.sort((a, b) => a.mtimeMs - b.mtimeMs || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    for (const victim of survivors.slice(0, surplus)) {
+      await rm(victim.path, { force: true }).catch(() => {
+      });
+    }
+  }
+};
+
+export {
+  DEFAULT_QUARANTINE_CAPS,
+  WriteQuarantineStore
+};
+//# sourceMappingURL=chunk-SICXL4MK.js.map

package/dist/chunk-SICXL4MK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/write-quarantine.ts"],"sourcesContent":["/**\n * Dead-letter quarantine for writes rejected by the namespace write-ACL\n * (issue #1888).\n *\n * When `observe` / `memory_store` / `suggestion_submit` fail namespace\n * authorization, the payload used to be dropped with no recoverable copy: a\n * client configured with a namespace that matches no policy (and is not the\n * default/shared namespace) had every write in the window silently destroyed.\n * The ACL rejection is CORRECT and stays fail-closed; this store only\n * preserves the payload so it can be replayed after the config is fixed,\n * following the AGENTS.md \"reject loudly but never destroy state\" posture\n * (patterns 14/42).\n *\n * Records live OUTSIDE any memory namespace at\n * `<memoryDir>/state/quarantine/<principalSafe>/<timestamp>-<id>.json`, keyed\n * by the encoded principal, and are bounded per principal by count and age.\n * Every path is resolved from `memoryDir` through `resolveSafeStoragePath`, so\n * a symlinked `state`/`quarantine` cannot redirect writes outside the memory\n * directory. The store never re-routes a payload into a writable namespace.\n */\n\nimport { randomUUID } from \"node:crypto\";\nimport type { Dirent } from \"node:fs\";\nimport { lstat, mkdir, readFile, readdir, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\nimport { encodeStoragePathSegment, resolveSafeStoragePath } from \"./storage-paths.js\";\n\nexport type QuarantineOperation = \"observe\" | \"memory_store\" | \"suggestion_submit\";\n\nexport interface QuarantineEntryInput {\n  operation: QuarantineOperation;\n  /** Authenticated principal the write was attributed to, if any. */\n  principal: string | undefined;\n  /** Namespace the caller attempted to write and was denied. */\n  attemptedNamespace: string;\n  /** The original request payload, preserved verbatim for replay. */\n  payload: unknown;\n  /** ISO timestamp; defaults to now. Injectable for deterministic tests. */\n  timestamp?: string;\n}\n\nexport interface QuarantinedRecord {\n  operation: QuarantineOperation;\n  principal: string | null;\n  attemptedNamespace: string;\n  timestamp: string;\n  payload: unknown;\n}\n\nexport interface QuarantineCaps {\n  /** Keep at most this many records per principal (newest win). */\n  maxEntriesPerPrincipal: number;\n  /** Drop records older than this many milliseconds. */\n  maxAgeMs: number;\n}\n\nexport const DEFAULT_QUARANTINE_CAPS: QuarantineCaps = {\n  maxEntriesPerPrincipal: 500,\n  maxAgeMs: 14 * 24 * 60 * 60 * 1000,\n};\n\nconst QUARANTINE_DIRNAME = \"quarantine\";\n\nfunction validateCaps(caps: QuarantineCaps): void {\n  if (!Number.isInteger(caps.maxEntriesPerPrincipal) || caps.maxEntriesPerPrincipal < 1) {\n    throw new Error(\n      `WriteQuarantineStore: maxEntriesPerPrincipal must be a positive integer (got ${caps.maxEntriesPerPrincipal})`\n    );\n  }\n  if (!Number.isFinite(caps.maxAgeMs) || caps.maxAgeMs <= 0) {\n    throw new Error(\n      `WriteQuarantineStore: maxAgeMs must be a positive finite number of milliseconds (got ${caps.maxAgeMs})`\n    );\n  }\n}\n\nfunction isQuarantinedRecord(value: unknown): value is QuarantinedRecord {\n  if (!value || typeof value !== \"object\") return false;\n  const record = value as Record<string, unknown>;\n  return (\n    (record.operation === \"observe\" ||\n      record.operation === \"memory_store\" ||\n      record.operation === \"suggestion_submit\") &&\n    (record.principal === null || typeof record.principal === \"string\") &&\n    typeof record.attemptedNamespace === \"string\" &&\n    typeof record.timestamp === \"string\" &&\n    \"payload\" in record\n  );\n}\n\nexport class WriteQuarantineStore {\n  private readonly memoryDir: string;\n\n  constructor(\n    memoryDir: string,\n    private readonly caps: QuarantineCaps = DEFAULT_QUARANTINE_CAPS\n  ) {\n    validateCaps(caps);\n    this.memoryDir = path.resolve(memoryDir);\n  }\n\n  /** Absolute quarantine root (`<memoryDir>/state/quarantine`). */\n  get root(): string {\n    return path.join(this.memoryDir, \"state\", QUARANTINE_DIRNAME);\n  }\n\n  /**\n   * Resolve a path under the quarantine root, checked for containment and\n   * symlink traversal from `memoryDir` down — so a symlinked `state` or\n   * `quarantine` component that escapes the memory directory is rejected.\n   */\n  private safeDir(...segments: string[]): Promise<string> {\n    return resolveSafeStoragePath(this.memoryDir, \"state\", QUARANTINE_DIRNAME, ...segments);\n  }\n\n  /**\n   * Park a rejected write. Returns the absolute path of the record written.\n   * Prunes the principal's bucket to the configured caps afterward.\n   */\n  async quarantine(input: QuarantineEntryInput): Promise<string> {\n    const timestamp = input.timestamp ?? new Date().toISOString();\n    const record: QuarantinedRecord = {\n      operation: input.operation,\n      principal: input.principal ?? null,\n      attemptedNamespace: input.attemptedNamespace,\n      timestamp,\n      payload: input.payload,\n    };\n    const principalSegment = encodeStoragePathSegment(input.principal ?? \"unknown\");\n    const fileName = `${timestamp.replace(/[:.]/g, \"-\")}-${randomUUID().slice(0, 8)}.json`;\n\n    const dir = await this.safeDir(principalSegment);\n    await mkdir(dir, { recursive: true });\n    // The temp write uses the exclusive `wx` flag so a pre-planted symlink at\n    // the temp name can never be followed (O_EXCL); rename is atomic (rule 42).\n    const finalPath = await this.safeDir(principalSegment, fileName);\n    const tmpPath = await this.safeDir(principalSegment, `${fileName}.tmp`);\n    await writeFile(tmpPath, JSON.stringify(record, null, 2), { encoding: \"utf8\", flag: \"wx\" });\n    await rename(tmpPath, finalPath);\n\n    await this.pruneDir(dir);\n    return finalPath;\n  }\n\n  /**\n   * All valid, non-expired quarantined records across every principal, oldest\n   * first. Expired records are deleted on read (lazy GC), so an inactive\n   * principal bucket with no follow-up write is still bounded by age.\n   */\n  async list(): Promise<QuarantinedRecord[]> {\n    const now = Date.now();\n    const records: QuarantinedRecord[] = [];\n    for (const dir of await this.principalDirs()) {\n      for (const file of await this.entryFiles(dir)) {\n        const info = await stat(file).catch(() => null);\n        if (!info) continue;\n        if (now - info.mtimeMs > this.caps.maxAgeMs) {\n          await rm(file, { force: true }).catch(() => {});\n          continue;\n        }\n        let parsed: unknown;\n        try {\n          parsed = JSON.parse(await readFile(file, \"utf8\"));\n        } catch {\n          continue;\n        }\n        if (isQuarantinedRecord(parsed)) records.push(parsed);\n      }\n    }\n    records.sort((a, b) => (a.timestamp < b.timestamp ? -1 : a.timestamp > b.timestamp ? 1 : 0));\n    return records;\n  }\n\n  /** Total valid, non-expired quarantined record count across every principal. */\n  async count(): Promise<number> {\n    return (await this.list()).length;\n  }\n\n  /** lstat (no symlink follow): true only for a real directory. */\n  private async isRealDir(dir: string): Promise<boolean> {\n    const info = await lstat(dir).catch(() => null);\n    return info?.isDirectory() === true;\n  }\n\n  private async principalDirs(): Promise<string[]> {\n    // safeDir() rejects a symlinked/containment-escaping root — let that\n    // propagate instead of masquerading as an empty store.\n    const root = await this.safeDir();\n    if (!(await this.isRealDir(root))) return [];\n    let entries: Dirent[];\n    try {\n      entries = await readdir(root, { withFileTypes: true });\n    } catch (err) {\n      // Root vanished mid-scan → legitimately empty. Any other failure\n      // (permissions, IO) is a genuine inspection failure and must surface.\n      if ((err as NodeJS.ErrnoException)?.code === \"ENOENT\") return [];\n      throw err;\n    }\n    return entries\n      .filter((entry) => entry.isDirectory())\n      .map((entry) => path.join(root, entry.name))\n      .sort();\n  }\n\n  private async entryFiles(dir: string): Promise<string[]> {\n    if (!(await this.isRealDir(dir))) return [];\n    let entries: Dirent[];\n    try {\n      entries = await readdir(dir, { withFileTypes: true });\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException)?.code === \"ENOENT\") return [];\n      throw err;\n    }\n    return entries\n      .filter((entry) => entry.isFile() && entry.name.endsWith(\".json\"))\n      .map((entry) => path.join(dir, entry.name))\n      .sort();\n  }\n\n  private async pruneDir(dir: string): Promise<void> {\n    const files = await this.entryFiles(dir);\n    const now = Date.now();\n    const survivors: Array<{ path: string; mtimeMs: number }> = [];\n    for (const file of files) {\n      const info = await stat(file).catch(() => null);\n      if (!info) continue;\n      if (now - info.mtimeMs > this.caps.maxAgeMs) {\n        await rm(file, { force: true }).catch(() => {});\n        continue;\n      }\n      survivors.push({ path: file, mtimeMs: info.mtimeMs });\n    }\n    const surplus = survivors.length - this.caps.maxEntriesPerPrincipal;\n    if (surplus <= 0) return;\n    survivors.sort((a, b) => a.mtimeMs - b.mtimeMs || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));\n    for (const victim of survivors.slice(0, surplus)) {\n      await rm(victim.path, { force: true }).catch(() => {});\n    }\n  }\n}\n"],"mappings":"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","names":[]}