@remnic/core 9.3.732 → 9.3.734

package/dist/{chunk-QZHF4BWN.js → chunk-Q5LGXWNG.js}

@@ -11,16 +11,16 @@ import {
   processChatMessage,
   sessionBelongsToPrincipal,
   subscribeChatTranscript
-} from "./chunk-O4ZIBPIW.js";
+} from "./chunk-T7CGPTFU.js";
 import {
   validateRequest
 } from "./chunk-FVZ2ISIX.js";
 import {
   getOperation
-} from "./chunk-NOU77OHX.js";
+} from "./chunk-5DIKZKOD.js";
 import {
   EngramAccessInputError
-} from "./chunk-646B5ERJ.js";
+} from "./chunk-PKO5NJ65.js";
 import {
   CorrectionContractError
 } from "./chunk-WNGXQMRI.js";
@@ -29,7 +29,7 @@ import {
 } from "./chunk-JGSKJHF7.js";
 import {
   projectTagProjectId
-} from "./chunk-J6BH2OBA.js";
+} from "./chunk-UK6U5C3N.js";
 import {
   subscribeGraphEvents
 } from "./chunk-DEUNUKTD.js";
@@ -1769,7 +1769,7 @@ var EngramAccessHttpServer = class {
     if (req.method === "POST" && pathname === "/engram/v1/contradiction-scan") {
       void getOperation("contradiction_scan_run");
       const body = await this.readJsonBody(req);
-      const { runContradictionScan } = await import("./contradiction-scan-HWGEOUDS.js");
+      const { runContradictionScan } = await import("./contradiction-scan-OUHMCUBT.js");
       const principal = this.resolveRequestPrincipal(req);
       const result = await runContradictionScan({
         storage: this.service.storageRef,
@@ -2629,4 +2629,4 @@ function positiveIntQueryParam(value, label) {
 export {
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-QZHF4BWN.js.map
+//# sourceMappingURL=chunk-Q5LGXWNG.js.map

package/dist/{chunk-ESF7TRYJ.js → chunk-SHJGBAIW.js}

@@ -70,6 +70,37 @@ function resolveCreationMemoryCapabilities(config) {
     commitmentLifecycle: config.commitmentLifecycleEnabled
   });
 }
+function resolveNamespaceCapabilities(config) {
+  return Object.freeze({
+    namespaces: config.namespacesEnabled
+  });
+}
+function resolveQmdCapabilities(config) {
+  return Object.freeze({
+    qmd: config.qmdEnabled,
+    qmdTierMigration: config.qmdTierMigrationEnabled,
+    qmdTierAutoBackfill: config.qmdTierAutoBackfillEnabled,
+    qmdAutoEmbed: config.qmdAutoEmbedEnabled,
+    qmdMaintenance: config.qmdMaintenanceEnabled,
+    qmdColdTier: config.qmdColdTierEnabled === true,
+    qmdDaemon: config.qmdDaemonEnabled,
+    qmdTierParityGraph: config.qmdTierParityGraphEnabled,
+    qmdQueryRerank: config.qmdQueryRerankEnabled,
+    qmdIntentHints: config.qmdIntentHintsEnabled,
+    qmdExplain: config.qmdExplainEnabled,
+    qmdAutoUpgrade: config.qmdAutoUpgradeEnabled
+  });
+}
+function resolveIdentityContinuityCapabilities(config) {
+  return Object.freeze({
+    identityContinuity: config.identityContinuityEnabled
+  });
+}
+function resolveLocalLlmCapabilities(config) {
+  return Object.freeze({
+    localLlm: config.localLlmEnabled
+  });
+}
 
 export {
   resolveCapabilities,
@@ -77,6 +108,10 @@ export {
   resolveAccessSetupCapabilities,
   resolveMemoryLifecycleCapabilities,
   resolveIndexingCapabilities,
-  resolveCreationMemoryCapabilities
+  resolveCreationMemoryCapabilities,
+  resolveNamespaceCapabilities,
+  resolveQmdCapabilities,
+  resolveIdentityContinuityCapabilities,
+  resolveLocalLlmCapabilities
 };
-//# sourceMappingURL=chunk-ESF7TRYJ.js.map
+//# sourceMappingURL=chunk-SHJGBAIW.js.map

package/dist/{chunk-ESF7TRYJ.js.map → chunk-SHJGBAIW.js.map}

@@ -1 +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\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}\n\n/**\n * Resolve the {@link AccessSetupCapabilitySet} from parsed config.\n *\n * Call this ONCE at access-service handler entry and thread the result down.\n */\nexport type AccessSetupConfigProjection = Pick<\n  PluginConfig,\n  \"recallCrossNamespaceBudgetEnabled\" | \"recallAuditAnomalyDetectionEnabled\"\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  });\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}\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>;\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  });\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"],"mappings":";AA8EO,SAAS,oBAAoB,QAAqC;AACvE,SAAO,OAAO,OAAO;AAAA,IACnB,aAAa,OAAO;AAAA,IACpB,oBAAoB,OAAO;AAAA,IAC3B,yBAAyB,OAAO;AAAA;AAAA;AAAA,IAGhC,kBAAkB,OAAO,sBAAsB;AAAA,IAC/C,WAAW,OAAO;AAAA,IAClB,2BAA2B,OAAO;AAAA,IAClC,kBAAkB,OAAO;AAAA,IACzB,eAAe,OAAO;AAAA,IACtB,sBAAsB,OAAO;AAAA,IAC7B,aAAa,OAAO;AAAA;AAAA;AAAA,IAGpB,uBAAuB,OAAO,iCAAiC;AAAA,IAC/D,qBAAqB,OAAO,+BAA+B;AAAA;AAAA,IAE3D,QAAQ,OAAO;AAAA,IACf,mBAAmB,OAAO;AAAA,IAC1B,mBAAmB,OAAO;AAAA,EAC5B,CAAC;AACH;AAiDO,SAAS,qCACd,QACgC;AAChC,SAAO,OAAO,OAAO;AAAA,IACnB,aAAa,OAAO;AAAA,IACpB,WAAW,OAAO;AAAA,IAClB,aAAa,OAAO;AAAA,IACpB,kBAAkB,OAAO;AAAA;AAAA;AAAA,IAGzB,4BAA4B,OAAO,sCAAsC;AAAA,EAC3E,CAAC;AACH;AAkCO,SAAS,+BACd,QAC0B;AAC1B,SAAO,OAAO,OAAO;AAAA,IACnB,4BAA4B,OAAO;AAAA;AAAA,IAEnC,6BAA6B,OAAO,uCAAuC;AAAA,EAC7E,CAAC;AACH;AA2EO,SAAS,mCACd,QAC8B;AAC9B,SAAO,OAAO,OAAO;AAAA,IACnB,sBAAsB,OAAO;AAAA,IAC7B,oBAAoB,OAAO;AAAA,IAC3B,iBAAiB,OAAO;AAAA,IACxB,sBAAsB,OAAO;AAAA,IAC7B,kBAAkB,OAAO;AAAA,IACzB,+BAA+B,OAAO;AAAA,IACtC,iBAAiB,OAAO;AAAA,IACxB,kBAAkB,OAAO;AAAA,IACzB,8BAA8B,OAAO;AAAA,IACrC,0BAA0B,OAAO;AAAA,IACjC,mBAAmB,OAAO;AAAA,EAC5B,CAAC;AACH;AA2CO,SAAS,4BACd,QACuB;AACvB,SAAO,OAAO,OAAO;AAAA,IACnB,oBAAoB,OAAO;AAAA,IAC3B,mBAAmB,OAAO;AAAA,EAC5B,CAAC;AACH;AAmDO,SAAS,kCACd,QAC6B;AAC7B,SAAO,OAAO,OAAO;AAAA,IACnB,gBAAgB,OAAO;AAAA,IACvB,kBAAkB,OAAO;AAAA,IACzB,eAAe,OAAO;AAAA,IACtB,qBAAqB,OAAO;AAAA,EAC9B,CAAC;AACH;","names":[]}
+{"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\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}\n\n/**\n * Resolve the {@link AccessSetupCapabilitySet} from parsed config.\n *\n * Call this ONCE at access-service handler entry and thread the result down.\n */\nexport type AccessSetupConfigProjection = Pick<\n  PluginConfig,\n  \"recallCrossNamespaceBudgetEnabled\" | \"recallAuditAnomalyDetectionEnabled\"\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  });\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}\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>;\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  });\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"],"mappings":";AA8EO,SAAS,oBAAoB,QAAqC;AACvE,SAAO,OAAO,OAAO;AAAA,IACnB,aAAa,OAAO;AAAA,IACpB,oBAAoB,OAAO;AAAA,IAC3B,yBAAyB,OAAO;AAAA;AAAA;AAAA,IAGhC,kBAAkB,OAAO,sBAAsB;AAAA,IAC/C,WAAW,OAAO;AAAA,IAClB,2BAA2B,OAAO;AAAA,IAClC,kBAAkB,OAAO;AAAA,IACzB,eAAe,OAAO;AAAA,IACtB,sBAAsB,OAAO;AAAA,IAC7B,aAAa,OAAO;AAAA;AAAA;AAAA,IAGpB,uBAAuB,OAAO,iCAAiC;AAAA,IAC/D,qBAAqB,OAAO,+BAA+B;AAAA;AAAA,IAE3D,QAAQ,OAAO;AAAA,IACf,mBAAmB,OAAO;AAAA,IAC1B,mBAAmB,OAAO;AAAA,EAC5B,CAAC;AACH;AAiDO,SAAS,qCACd,QACgC;AAChC,SAAO,OAAO,OAAO;AAAA,IACnB,aAAa,OAAO;AAAA,IACpB,WAAW,OAAO;AAAA,IAClB,aAAa,OAAO;AAAA,IACpB,kBAAkB,OAAO;AAAA;AAAA;AAAA,IAGzB,4BAA4B,OAAO,sCAAsC;AAAA,EAC3E,CAAC;AACH;AAkCO,SAAS,+BACd,QAC0B;AAC1B,SAAO,OAAO,OAAO;AAAA,IACnB,4BAA4B,OAAO;AAAA;AAAA,IAEnC,6BAA6B,OAAO,uCAAuC;AAAA,EAC7E,CAAC;AACH;AA2EO,SAAS,mCACd,QAC8B;AAC9B,SAAO,OAAO,OAAO;AAAA,IACnB,sBAAsB,OAAO;AAAA,IAC7B,oBAAoB,OAAO;AAAA,IAC3B,iBAAiB,OAAO;AAAA,IACxB,sBAAsB,OAAO;AAAA,IAC7B,kBAAkB,OAAO;AAAA,IACzB,+BAA+B,OAAO;AAAA,IACtC,iBAAiB,OAAO;AAAA,IACxB,kBAAkB,OAAO;AAAA,IACzB,8BAA8B,OAAO;AAAA,IACrC,0BAA0B,OAAO;AAAA,IACjC,mBAAmB,OAAO;AAAA,EAC5B,CAAC;AACH;AA2CO,SAAS,4BACd,QACuB;AACvB,SAAO,OAAO,OAAO;AAAA,IACnB,oBAAoB,OAAO;AAAA,IAC3B,mBAAmB,OAAO;AAAA,EAC5B,CAAC;AACH;AAmDO,SAAS,kCACd,QAC6B;AAC7B,SAAO,OAAO,OAAO;AAAA,IACnB,gBAAgB,OAAO;AAAA,IACvB,kBAAkB,OAAO;AAAA,IACzB,eAAe,OAAO;AAAA,IACtB,qBAAqB,OAAO;AAAA,EAC9B,CAAC;AACH;AAqCO,SAAS,6BACd,QACwB;AACxB,SAAO,OAAO,OAAO;AAAA,IACnB,YAAY,OAAO;AAAA,EACrB,CAAC;AACH;AAyEO,SAAS,uBAAuB,QAA+C;AACpF,SAAO,OAAO,OAAO;AAAA,IACnB,KAAK,OAAO;AAAA,IACZ,kBAAkB,OAAO;AAAA,IACzB,qBAAqB,OAAO;AAAA,IAC5B,cAAc,OAAO;AAAA,IACrB,gBAAgB,OAAO;AAAA,IACvB,aAAa,OAAO,uBAAuB;AAAA,IAC3C,WAAW,OAAO;AAAA,IAClB,oBAAoB,OAAO;AAAA,IAC3B,gBAAgB,OAAO;AAAA,IACvB,gBAAgB,OAAO;AAAA,IACvB,YAAY,OAAO;AAAA,IACnB,gBAAgB,OAAO;AAAA,EACzB,CAAC;AACH;AA2BO,SAAS,sCACd,QACiC;AACjC,SAAO,OAAO,OAAO;AAAA,IACnB,oBAAoB,OAAO;AAAA,EAC7B,CAAC;AACH;AA2BO,SAAS,4BACd,QACuB;AACvB,SAAO,OAAO,OAAO;AAAA,IACnB,UAAU,OAAO;AAAA,EACnB,CAAC;AACH;","names":[]}

package/dist/{chunk-O4ZIBPIW.js → chunk-T7CGPTFU.js}

@@ -12,10 +12,10 @@ import {
 } from "./chunk-FVZ2ISIX.js";
 import {
   getOperation
-} from "./chunk-NOU77OHX.js";
+} from "./chunk-5DIKZKOD.js";
 import {
   EngramAccessInputError
-} from "./chunk-646B5ERJ.js";
+} from "./chunk-PKO5NJ65.js";
 import {
   readEnvVar
 } from "./chunk-JUC24CTX.js";
@@ -3619,4 +3619,4 @@ export {
   processChatMessage,
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-O4ZIBPIW.js.map
+//# sourceMappingURL=chunk-T7CGPTFU.js.map

package/dist/{chunk-PLBIPT6I.js → chunk-TJSQHO4Q.js}

@@ -10,6 +10,9 @@ import {
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
+import {
+  resolveNamespaceCapabilities
+} from "./chunk-SHJGBAIW.js";
 import {
   log
 } from "./chunk-NU3CSQ4H.js";
@@ -236,7 +239,7 @@ async function runContradictionScan(deps) {
     return { scanned: 0, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: 0 };
   }
   const { storage: scanStorage, namespace } = await resolveScanStorage(deps, requestedNamespace);
-  if (config.namespacesEnabled && namespace !== void 0 && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {
+  if (resolveNamespaceCapabilities(config).namespaces && namespace !== void 0 && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {
     const migrated = migrateUnscopedPairsToNamespace(memoryDir, namespace, { cooldownDays: scanConfig.cooldownDays });
     if (migrated > 0) {
       log.info("[contradiction-scan] migrated %d legacy unscoped review pairs to namespace %s", migrated, namespace);
@@ -433,7 +436,7 @@ function normalizeScanNamespace(namespace) {
   return trimmed ? trimmed : void 0;
 }
 async function resolveScanStorage(deps, namespace) {
-  if (!deps.config.namespacesEnabled) {
+  if (!resolveNamespaceCapabilities(deps.config).namespaces) {
     const defaultNamespace = normalizeScanNamespace(deps.config.defaultNamespace);
     if (namespace && namespace !== defaultNamespace) {
       throw new Error(`unsupported namespace: ${namespace}`);
@@ -473,7 +476,7 @@ function isStorageManagerLike(value) {
 }
 function fallbackResolvedNamespace(deps, namespace) {
   if (namespace) return namespace;
-  return deps.config.namespacesEnabled ? deps.config.defaultNamespace : void 0;
+  return resolveNamespaceCapabilities(deps.config).namespaces ? deps.config.defaultNamespace : void 0;
 }
 function isDefaultNamespaceScan(config, requestedNamespace, resolvedNamespace) {
   if (requestedNamespace === void 0) return true;
@@ -543,4 +546,4 @@ export {
   ACTIVE_STATUSES,
   runContradictionScan
 };
-//# sourceMappingURL=chunk-PLBIPT6I.js.map
+//# sourceMappingURL=chunk-TJSQHO4Q.js.map

package/dist/chunk-TJSQHO4Q.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contradiction/contradiction-judge.ts","../src/contradiction/contradiction-scan.ts"],"sourcesContent":["/**\n * Contradiction Judge — LLM-as-judge for semantic contradiction detection (issue #520).\n *\n * Pairs semantically-similar memories and classifies their relationship.\n * Reuses the extraction-judge adapter pattern but with a contradiction-specific\n * prompt and verdict taxonomy.\n *\n * Design constraints:\n *   - Default verdict on any failure is \"needs-user\" (rule 48: least-privileged default).\n *   - Never auto-resolve; all verdicts enter the review queue.\n *   - Content-hash caching avoids redundant LLM calls across runs.\n */\n\nimport { createHash } from \"node:crypto\";\nimport { log } from \"../logger.js\";\nimport type { PluginConfig } from \"../types.js\";\nimport type { LocalLlmClient } from \"../local-llm.js\";\nimport type { FallbackLlmClient } from \"../fallback-llm.js\";\nimport { extractJsonCandidates } from \"../json-extract.js\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\nexport type ContradictionVerdict =\n  | \"contradicts\"\n  | \"independent\"\n  | \"duplicates\"\n  | \"needs-user\";\n\nexport interface ContradictionJudgeInput {\n  /** Memory ID of the first fact. */\n  memoryIdA: string;\n  /** Memory ID of the second fact. */\n  memoryIdB: string;\n  /** Content text of the first fact. */\n  textA: string;\n  /** Content text of the second fact. */\n  textB: string;\n  /** Category of the first fact (optional context). */\n  categoryA?: string;\n  /** Category of the second fact (optional context). */\n  categoryB?: string;\n}\n\nexport interface ContradictionJudgeResult {\n  /** Memory IDs of the pair. */\n  memoryIdA: string;\n  memoryIdB: string;\n  /** Verdict from the judge. */\n  verdict: ContradictionVerdict;\n  /** Human-readable rationale. */\n  rationale: string;\n  /** Confidence in [0, 1]. */\n  confidence: number;\n}\n\nexport interface ContradictionJudgeBatchResult {\n  /** Results keyed by pair key (\"idA:idB\"). */\n  results: Map<string, ContradictionJudgeResult>;\n  /** Number served from cache. */\n  cached: number;\n  /** Number produced by LLM call. */\n  judged: number;\n  /** Total wall-clock time in ms. */\n  elapsed: number;\n}\n\n// ── Prompt ─────────────────────────────────────────────────────────────────────\n\nconst CONTRADICTION_JUDGE_PROMPT = `You are a memory contradiction classifier. You will receive pairs of stored memories and must classify their semantic relationship.\n\nFor each pair, respond with a JSON array where each element has:\n- \"pairKey\": the pairKey provided in the input\n- \"verdict\": one of \"contradicts\", \"independent\", \"duplicates\", \"needs-user\"\n- \"rationale\": one sentence explaining why\n- \"confidence\": number between 0 and 1\n\nVERDICT DEFINITIONS:\n- \"contradicts\": The two memories make claims that cannot both be true. One must be wrong or outdated.\n- \"duplicates\": The two memories convey essentially the same information (near-paraphrase).\n- \"independent\": The memories are topically similar but do not conflict or duplicate.\n- \"needs-user\": Cannot determine with sufficient confidence; requires human review.\n\nIMPORTANT:\n- Be conservative. When in doubt, prefer \"needs-user\" over a wrong classification.\n- Two memories about the same entity/topic are NOT necessarily contradictory.\n- Temporal changes (\"Joshua uses pnpm\" vs \"Joshua switched to npm\") ARE contradictions.\n- Different aspects of the same entity (\"Joshua uses pnpm\" vs \"Joshua works on Remnic\") are \"independent\".`;\n\n// ── Cache ──────────────────────────────────────────────────────────────────────\n\n/** Module-level fallback cache — only used when caller does not supply one. */\nlet defaultVerdictCache: Map<string, ContradictionJudgeResult> = new Map();\nconst CACHE_MAX = 10_000;\n\nfunction pairKey(idA: string, idB: string): string {\n  const sorted = [idA, idB].sort();\n  return `${sorted[0]}:${sorted[1]}`;\n}\n\nfunction contentHash(a: ContradictionJudgeInput): string {\n  // Sort each side pair to be order-independent (matching pairKey behavior)\n  const sides = [\n    { text: a.textA.trim(), category: (a.categoryA ?? \"\").trim() },\n    { text: a.textB.trim(), category: (a.categoryB ?? \"\").trim() },\n  ].sort((left, right) => {\n    const leftKey = JSON.stringify(left);\n    const rightKey = JSON.stringify(right);\n    return leftKey.localeCompare(rightKey);\n  });\n  const normalized = JSON.stringify(sides);\n  return createHash(\"sha256\").update(normalized).digest(\"hex\").slice(0, 16);\n}\n\nexport function createVerdictCache(): Map<string, ContradictionJudgeResult> {\n  return new Map();\n}\n\nexport function clearVerdictCache(): void {\n  defaultVerdictCache.clear();\n}\n\nexport function verdictCacheSize(): number {\n  return defaultVerdictCache.size;\n}\n\n// ── Public API ──────────────────────────────────────────────────────────────────\n\n/**\n * Judge a batch of memory pairs for contradiction.\n *\n * Uses content-hash caching to skip pairs already judged in a prior run.\n * On any LLM failure, all unresolved pairs default to \"needs-user\".\n */\nexport async function judgeContradictionPairs(\n  pairs: ContradictionJudgeInput[],\n  config: PluginConfig,\n  localLlm: LocalLlmClient | null,\n  fallbackLlm: FallbackLlmClient | null,\n  cache?: Map<string, ContradictionJudgeResult>,\n): Promise<ContradictionJudgeBatchResult> {\n  const startTime = Date.now();\n  const results = new Map<string, ContradictionJudgeResult>();\n  const activeCache = cache ?? defaultVerdictCache;\n  let cached = 0;\n  let judged = 0;\n\n  // Partition into cached vs needs-judging\n  const toJudge: ContradictionJudgeInput[] = [];\n  for (const pair of pairs) {\n    const key = pairKey(pair.memoryIdA, pair.memoryIdB);\n    const hash = contentHash(pair);\n    const cachedResult = activeCache.get(hash);\n    if (cachedResult) {\n      results.set(key, { ...cachedResult, memoryIdA: pair.memoryIdA, memoryIdB: pair.memoryIdB });\n      cached++;\n    } else {\n      toJudge.push(pair);\n    }\n  }\n\n  if (toJudge.length === 0) {\n    return { results, cached, judged, elapsed: Date.now() - startTime };\n  }\n\n  // Build the prompt with all pairs\n  const pairDescriptions = toJudge.map((p, i) => {\n    const pk = pairKey(p.memoryIdA, p.memoryIdB);\n    const catA = p.categoryA ? ` [${p.categoryA}]` : \"\";\n    const catB = p.categoryB ? ` [${p.categoryB}]` : \"\";\n    return `Pair ${i + 1} (pairKey: \"${pk}\"):${catA} \"${p.textA}\"${catB} \"${p.textB}\"`;\n  });\n\n  const userMessage = `Classify these ${toJudge.length} memory pair(s):\\n\\n${pairDescriptions.join(\"\\n\\n\")}`;\n\n  // Try LLM call\n  let llmResponse: string | null = null;\n\n  if (localLlm) {\n    try {\n      llmResponse = await callLlm(localLlm, config, userMessage);\n    } catch (err) {\n      log.warn(\"[contradiction-judge] local LLM call failed: %s\", err instanceof Error ? err.message : err);\n    }\n  }\n\n  if (!llmResponse && fallbackLlm) {\n    try {\n      llmResponse = await callLlm(fallbackLlm, config, userMessage);\n    } catch (err) {\n      log.warn(\"[contradiction-judge] fallback LLM call failed: %s\", err instanceof Error ? err.message : err);\n    }\n  }\n\n  // Parse response or default to needs-user\n  if (llmResponse) {\n    const candidates = extractJsonCandidates(llmResponse);\n    const parsed = parseJudgeResponse(candidates, toJudge);\n\n    for (const result of parsed) {\n      const key = pairKey(result.memoryIdA, result.memoryIdB);\n      results.set(key, result);\n\n      // Update cache\n      const input = toJudge.find(\n        (p) => pairKey(p.memoryIdA, p.memoryIdB) === key,\n      );\n      if (input) {\n        const hash = contentHash(input);\n        if (activeCache.size >= CACHE_MAX) {\n          const firstKey = activeCache.keys().next().value;\n          if (firstKey !== undefined) activeCache.delete(firstKey);\n        }\n        activeCache.set(hash, result);\n      }\n      judged++;\n    }\n  } else {\n    // All unresolved → needs-user (rule 48)\n    for (const pair of toJudge) {\n      const key = pairKey(pair.memoryIdA, pair.memoryIdB);\n      const result: ContradictionJudgeResult = {\n        memoryIdA: pair.memoryIdA,\n        memoryIdB: pair.memoryIdB,\n        verdict: \"needs-user\",\n        rationale: \"LLM call failed; requires manual review\",\n        confidence: 0,\n      };\n      results.set(key, result);\n      judged++;\n    }\n  }\n\n  return { results, cached, judged, elapsed: Date.now() - startTime };\n}\n\n// ── Internals ──────────────────────────────────────────────────────────────────\n\nasync function callLlm(\n  client: LocalLlmClient | FallbackLlmClient,\n  config: PluginConfig,\n  userMessage: string,\n): Promise<string> {\n  const messages: Array<{ role: \"user\" | \"assistant\" | \"system\"; content: string }> = [\n    { role: \"system\", content: CONTRADICTION_JUDGE_PROMPT },\n    { role: \"user\", content: userMessage },\n  ];\n  if (\"chatCompletion\" in client && typeof client.chatCompletion === \"function\") {\n    const result = await client.chatCompletion(messages, {\n      temperature: 0.1,\n      maxTokens: 4096,\n      operation: \"contradiction-judge\",\n    });\n    return result?.content ?? \"\";\n  }\n  // FallbackLlmClient — try OpenAI-compatible chat completions\n  if (\"complete\" in client && typeof (client as Record<string, unknown>).complete === \"function\") {\n    const result = await (client as { complete: (msg: Array<{ role: string; content: string }>) => Promise<{ content: string }> }).complete(messages);\n    return result.content ?? \"\";\n  }\n  return \"\";\n}\n\nfunction parseJudgeResponse(\n  candidates: string[],\n  inputs: ContradictionJudgeInput[],\n): ContradictionJudgeResult[] {\n  const VALID_VERDICTS: ContradictionVerdict[] = [\"contradicts\", \"independent\", \"duplicates\", \"needs-user\"];\n  let conservativeFallback: ContradictionJudgeResult[] | null = null;\n\n  for (const candidate of candidates) {\n    try {\n      const parsed = JSON.parse(candidate);\n      const items = Array.isArray(parsed) ? parsed : [parsed];\n      const results: ContradictionJudgeResult[] = [];\n      const matchedKeys = new Set<string>();\n\n      for (const item of items) {\n        if (!item || typeof item !== \"object\") continue;\n\n        const verdict = typeof item.verdict === \"string\" && VALID_VERDICTS.includes(item.verdict as ContradictionVerdict)\n          ? (item.verdict as ContradictionVerdict)\n          : \"needs-user\";\n\n        const pairKeyVal = typeof item.pairKey === \"string\" && item.pairKey.length > 0\n          ? item.pairKey\n          : null;\n        const input = pairKeyVal\n          ? inputs.find((p) => pairKey(p.memoryIdA, p.memoryIdB) === pairKeyVal)\n          : null;\n\n        if (!input) continue;\n\n        matchedKeys.add(pairKey(input.memoryIdA, input.memoryIdB));\n\n        const confidence = typeof item.confidence === \"number\"\n          ? Math.min(1, Math.max(0, item.confidence))\n          : 0.5;\n\n        results.push({\n          memoryIdA: input.memoryIdA,\n          memoryIdB: input.memoryIdB,\n          verdict,\n          rationale: typeof item.rationale === \"string\" ? item.rationale : \"No rationale provided\",\n          confidence,\n        });\n      }\n\n      // Backfill any inputs the LLM omitted with needs-user\n      for (const inp of inputs) {\n        const key = pairKey(inp.memoryIdA, inp.memoryIdB);\n        if (!matchedKeys.has(key)) {\n          results.push({\n            memoryIdA: inp.memoryIdA,\n            memoryIdB: inp.memoryIdB,\n            verdict: \"needs-user\",\n            rationale: \"LLM response omitted this pair\",\n            confidence: 0,\n          });\n        }\n      }\n\n      if (matchedKeys.size > 0) return results;\n      if (results.length > 0 && conservativeFallback === null) {\n        conservativeFallback = results;\n      }\n    } catch {\n      continue;\n    }\n  }\n\n  if (conservativeFallback !== null) return conservativeFallback;\n\n  // All parse attempts failed → needs-user for every input\n  return inputs.map((p) => ({\n    memoryIdA: p.memoryIdA,\n    memoryIdB: p.memoryIdB,\n    verdict: \"needs-user\" as ContradictionVerdict,\n    rationale: \"Failed to parse judge response\",\n    confidence: 0,\n  }));\n}\n\nexport { pairKey as _pairKey, contentHash as _contentHash };\n","/**\n * Contradiction Scan — pair generator + scan driver (issue #520).\n *\n * Nightly cron that pairs semantically-similar active memories within\n * the same namespace, sends candidate pairs to the LLM-as-judge\n * contradiction classifier, and drops contradicting pairs into a\n * review queue for user resolution.\n *\n * Pair generation (cheap pre-filter):\n *   1. Find candidate peers via embedding cosine >= similarityFloor.\n *   2. Restrict to pairs sharing at least one entityRef OR overlapping\n *      topic tokens >= topicOverlapFloor.\n *   3. Skip pairs already judged independent/both-valid within cooldown.\n *   4. Cap per-run work at maxPairsPerRun.\n */\n\nimport { resolveNamespaceCapabilities } from \"../capabilities.js\";\nimport type { StorageManager } from \"../storage.js\";\nimport type { PluginConfig, MemoryFile, MemoryStatus } from \"../types.js\";\nimport type { SemanticDedupLookup } from \"../dedup/semantic.js\";\nimport { log } from \"../logger.js\";\nimport { judgeContradictionPairs, type ContradictionJudgeInput } from \"./contradiction-judge.js\";\nimport {\n  writePairs,\n  readPair,\n  isCoolingDown,\n  memoryHashesChanged,\n  computeMemoryContentHash,\n  computePairId,\n  migrateUnscopedPairsToNamespace,\n  type ContradictionPair,\n} from \"./contradiction-review.js\";\nimport type { LocalLlmClient } from \"../local-llm.js\";\nimport type { FallbackLlmClient } from \"../fallback-llm.js\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\n/** The set of statuses that represent \"live\" memories eligible for scanning. */\nexport const ACTIVE_STATUSES: Set<MemoryStatus> = new Set([\"active\"]);\n\n/** High-value taxonomy buckets to scan. */\nconst SCAN_CATEGORIES = new Set([\n  \"decision\",\n  \"principle\",\n  \"rule\",\n  \"entity\",\n  \"fact\",\n  \"preference\",\n]);\n\nexport interface ScanResult {\n  /** Total active memories scanned. */\n  scanned: number;\n  /** Candidate pairs generated by the pre-filter. */\n  candidates: number;\n  /** Pairs sent to judge. */\n  judged: number;\n  /** Pairs written to review queue. */\n  queued: number;\n  /** Pairs skipped due to cooldown. */\n  cooledDown: number;\n  /** Total wall-clock time in ms. */\n  elapsedMs: number;\n}\n\nexport interface ScanStorageResolution {\n  storage: StorageManager;\n  namespace?: string;\n}\n\nexport interface ScanDependencies {\n  storage: StorageManager;\n  config: PluginConfig;\n  memoryDir: string;\n  /** Pre-built embedding lookup. When provided, used as-is for Strategy 3. */\n  embeddingLookup?: SemanticDedupLookup;\n  /**\n   * Factory to build a namespace-scoped embedding lookup.\n   * When provided, takes precedence over `embeddingLookup`.\n   * The scan driver passes its own `storage` so the lookup queries the correct index.\n   */\n  embeddingLookupFactory?: (storage: StorageManager) => SemanticDedupLookup | undefined;\n  /** Resolver for namespace-scoped storage. Required for scans when namespaces are enabled. */\n  storageForNamespace?: (\n    namespace: string | undefined,\n  ) => StorageManager | ScanStorageResolution | Promise<StorageManager | ScanStorageResolution>;\n  localLlm: LocalLlmClient | null;\n  fallbackLlm: FallbackLlmClient | null;\n  namespace?: string;\n}\n\n// ── Main scan driver ───────────────────────────────────────────────────────────\n\n/**\n * Run a contradiction scan over the memory corpus.\n *\n * This is the entry point called by the nightly cron and by the CLI.\n */\nexport async function runContradictionScan(deps: ScanDependencies): Promise<ScanResult> {\n  const startTime = Date.now();\n  const { config, memoryDir, embeddingLookup, embeddingLookupFactory, localLlm, fallbackLlm } = deps;\n  const requestedNamespace = normalizeScanNamespace(deps.namespace);\n  const scanConfig = config.contradictionScan;\n\n  if (!scanConfig.enabled) {\n    log.info(\"[contradiction-scan] disabled by config\");\n    return { scanned: 0, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: 0 };\n  }\n\n  const { storage: scanStorage, namespace } = await resolveScanStorage(deps, requestedNamespace);\n  if (resolveNamespaceCapabilities(config).namespaces && namespace !== undefined && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {\n    const migrated = migrateUnscopedPairsToNamespace(memoryDir, namespace, { cooldownDays: scanConfig.cooldownDays });\n    if (migrated > 0) {\n      log.info(\"[contradiction-scan] migrated %d legacy unscoped review pairs to namespace %s\", migrated, namespace);\n    }\n  }\n\n  // Prefer the factory (which uses the scan's own storage for correct namespace scoping)\n  // over a pre-built lookup (which may use default-namespace storage).\n  const scopedEmbeddingLookup = embeddingLookupFactory\n    ? embeddingLookupFactory(scanStorage)\n    : embeddingLookup;\n\n  // 1. Load active memories in scan categories\n  const memories = await loadEligibleMemories(scanStorage);\n  log.info(\"[contradiction-scan] loaded %d eligible memories\", memories.length);\n\n  if (memories.length < 2) {\n    return { scanned: memories.length, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: Date.now() - startTime };\n  }\n\n  // 2. Prepare exact existing-pair lookup for cooldown checking.\n  // Pair IDs are deterministic, so lookup the candidate's file directly instead\n  // of paging through the review queue and risking a bounded-list miss.\n  const existingPairCache = new Map<string, ContradictionPair | undefined>();\n  const getExistingPair = (pairId: string): ContradictionPair | undefined => {\n    if (!existingPairCache.has(pairId)) {\n      existingPairCache.set(pairId, readPair(memoryDir, pairId) ?? undefined);\n    }\n    return existingPairCache.get(pairId);\n  };\n\n  // 3. Generate candidate pairs\n  const candidates = await generatePairs(memories, getExistingPair, scanConfig, namespace, scopedEmbeddingLookup);\n  const cooledDown = candidates.skipped;\n  log.info(\"[contradiction-scan] generated %d candidates (%d cooled down)\", candidates.pairs.length, cooledDown);\n\n  if (candidates.pairs.length === 0) {\n    return {\n      scanned: memories.length,\n      candidates: 0,\n      judged: 0,\n      queued: 0,\n      cooledDown,\n      elapsedMs: Date.now() - startTime,\n    };\n  }\n\n  // 4. Build judge inputs. Candidate generation already preserves strategy\n  // priority and caps work at maxPairsPerRun.\n  const judgeInputs: ContradictionJudgeInput[] = candidates.pairs.map((pair) => ({\n    memoryIdA: pair.idA,\n    memoryIdB: pair.idB,\n    textA: pair.textA,\n    textB: pair.textB,\n    categoryA: pair.categoryA,\n    categoryB: pair.categoryB,\n  }));\n\n  // 6. Send to judge (per-scan cache avoids module-level singleton leak)\n  const scanCache = new Map<string, import(\"./contradiction-judge.js\").ContradictionJudgeResult>();\n  const judgeResult = await judgeContradictionPairs(judgeInputs, config, localLlm, fallbackLlm, scanCache);\n  log.info(\"[contradiction-scan] judge completed: %d judged, %d cached in %dms\", judgeResult.judged, judgeResult.cached, judgeResult.elapsed);\n\n  // 7. Write to review queue\n  const queueEntries: Array<Omit<ContradictionPair, \"pairId\"> & { memoryIds: [string, string] }> = [];\n  const currentMemoryHashes = memoryContentHashMap(memories);\n  for (const [key, result] of judgeResult.results) {\n    queueEntries.push({\n      memoryIds: [result.memoryIdA, result.memoryIdB],\n      verdict: result.verdict,\n      rationale: result.rationale,\n      confidence: result.confidence,\n      detectedAt: new Date().toISOString(),\n      // Set lastReviewedAt for non-actionable verdicts so cooldown prevents re-judging\n      lastReviewedAt: result.verdict === \"independent\" ? new Date().toISOString() : undefined,\n      memoryContentHashes: pairMemoryContentHashes(result.memoryIdA, result.memoryIdB, currentMemoryHashes),\n      namespace,\n    });\n  }\n\n  const written = writePairs(memoryDir, queueEntries, { cooldownDays: scanConfig.cooldownDays });\n  const elapsed = Date.now() - startTime;\n  log.info(\"[contradiction-scan] complete: %d queued in %dms\", written.length, elapsed);\n\n  return {\n    scanned: memories.length,\n    candidates: candidates.pairs.length,\n    judged: judgeResult.judged,\n    queued: written.length,\n    cooledDown,\n    elapsedMs: elapsed,\n  };\n}\n\n// ── Pair generation ────────────────────────────────────────────────────────────\n\ninterface CandidatePair {\n  idA: string;\n  idB: string;\n  textA: string;\n  textB: string;\n  categoryA?: string;\n  categoryB?: string;\n}\n\ninterface PairGenResult {\n  pairs: CandidatePair[];\n  skipped: number;\n}\n\nasync function generatePairs(\n  memories: MemoryFile[],\n  getExistingPair: (pairId: string) => ContradictionPair | undefined,\n  scanConfig: PluginConfig[\"contradictionScan\"],\n  namespace: string | undefined,\n  embeddingLookup?: SemanticDedupLookup,\n): Promise<PairGenResult> {\n  const pairs: CandidatePair[] = [];\n  let skipped = 0;\n  const seen = new Set<string>();\n  const maxPairs = Math.max(0, Math.floor(scanConfig.maxPairsPerRun));\n  if (maxPairs === 0) return { pairs, skipped };\n\n  const orderedMemories = [...memories].sort(compareMemoryId);\n  const currentMemoryHashes = memoryContentHashMap(orderedMemories);\n\n  const pushCandidate = (pair: CandidatePair): void => {\n    if (pairs.length < maxPairs) pairs.push(pair);\n  };\n\n  const hasCapacity = (): boolean => pairs.length < maxPairs;\n  const isSkippedByCooldown = (existing: ContradictionPair | undefined): boolean => {\n    if (!existing || !isCoolingDown(existing, scanConfig.cooldownDays)) return false;\n    return !memoryHashesChanged(\"\", existing, (memoryId) => currentMemoryHashes.get(memoryId) ?? null);\n  };\n\n  // Build index by entityRef for fast lookup\n  const byEntity = new Map<string, MemoryFile[]>();\n  for (const mem of orderedMemories) {\n    const entity = mem.frontmatter.entityRef;\n    if (entity) {\n      const existing = byEntity.get(entity) ?? [];\n      existing.push(mem);\n      byEntity.set(entity, existing);\n    }\n  }\n\n  // Strategy 1: Entity-ref based pairing (high precision)\n  entityPairs:\n  for (const entity of [...byEntity.keys()].sort()) {\n    const group = byEntity.get(entity) ?? [];\n    if (group.length < 2) continue;\n    for (let i = 0; i < group.length; i++) {\n      for (let j = i + 1; j < group.length; j++) {\n        if (!hasCapacity()) break entityPairs;\n        const a = group[i];\n        const b = group[j];\n        const pairId = computePairId(a.frontmatter.id!, b.frontmatter.id!, namespace);\n\n        if (seen.has(pairId)) continue;\n        seen.add(pairId);\n\n        // Check cooldown\n        const existing = getExistingPair(pairId);\n        if (isSkippedByCooldown(existing)) {\n          skipped++;\n          continue;\n        }\n\n        pushCandidate({\n          idA: a.frontmatter.id!,\n          idB: b.frontmatter.id!,\n          textA: a.content,\n          textB: b.content,\n          categoryA: a.frontmatter.category as string | undefined,\n          categoryB: b.frontmatter.category as string | undefined,\n        });\n      }\n    }\n  }\n\n  // Strategy 2: Tag/topic overlap for memories without a shared entityRef\n  topicPairs:\n  for (let i = 0; i < orderedMemories.length; i++) {\n    for (let j = i + 1; j < orderedMemories.length; j++) {\n      if (!hasCapacity()) break topicPairs;\n      const a = orderedMemories[i];\n      const b = orderedMemories[j];\n      if (shareEntityRef(a, b)) continue;\n      const overlap = jaccardOverlap(\n        (a.frontmatter.tags as string[]) ?? [],\n        (b.frontmatter.tags as string[]) ?? [],\n      );\n\n      if (overlap < scanConfig.topicOverlapFloor) continue;\n\n      const pairId = computePairId(a.frontmatter.id!, b.frontmatter.id!, namespace);\n      if (seen.has(pairId)) continue;\n      seen.add(pairId);\n\n      const existing = getExistingPair(pairId);\n      if (isSkippedByCooldown(existing)) {\n        skipped++;\n        continue;\n      }\n\n      pushCandidate({\n        idA: a.frontmatter.id!,\n        idB: b.frontmatter.id!,\n        textA: a.content,\n        textB: b.content,\n        categoryA: a.frontmatter.category as string | undefined,\n        categoryB: b.frontmatter.category as string | undefined,\n      });\n    }\n  }\n\n  // Strategy 3: Embedding cosine similarity (enforces similarityFloor config)\n  if (embeddingLookup && hasCapacity()) {\n    const memoryById = new Map(orderedMemories.map((m) => [m.frontmatter.id!, m]));\n    embeddingPairs:\n    for (const mem of orderedMemories) {\n      if (!hasCapacity()) break;\n      const id = mem.frontmatter.id!;\n      try {\n        const hits = (await embeddingLookup(mem.content, 20)).sort((a, b) =>\n          b.score - a.score || a.id.localeCompare(b.id),\n        );\n        for (const hit of hits) {\n          if (!hasCapacity()) break embeddingPairs;\n          if (hit.score < scanConfig.similarityFloor) continue;\n          if (hit.id === id) continue;\n          const peer = memoryById.get(hit.id);\n          if (!peer) continue;\n\n          const pairId = computePairId(id, hit.id, namespace);\n          if (seen.has(pairId)) continue;\n          seen.add(pairId);\n\n          const existing = getExistingPair(pairId);\n          if (isSkippedByCooldown(existing)) {\n            skipped++;\n            continue;\n          }\n\n          pushCandidate({\n            idA: id,\n            idB: hit.id,\n            textA: mem.content,\n            textB: peer.content,\n            categoryA: mem.frontmatter.category as string | undefined,\n            categoryB: peer.frontmatter.category as string | undefined,\n          });\n        }\n      } catch {\n        // Embedding backend unavailable — skip, entity-ref/tag strategies already covered\n      }\n    }\n  }\n\n  return { pairs, skipped };\n}\n\n// ── Helpers ────────────────────────────────────────────────────────────────────\n\nfunction normalizeScanNamespace(namespace: string | undefined): string | undefined {\n  const trimmed = namespace?.trim();\n  return trimmed ? trimmed : undefined;\n}\n\nasync function resolveScanStorage(\n  deps: ScanDependencies,\n  namespace: string | undefined,\n): Promise<ScanStorageResolution> {\n  if (!resolveNamespaceCapabilities(deps.config).namespaces) {\n    const defaultNamespace = normalizeScanNamespace(deps.config.defaultNamespace);\n    if (namespace && namespace !== defaultNamespace) {\n      throw new Error(`unsupported namespace: ${namespace}`);\n    }\n    return { storage: deps.storage, namespace: undefined };\n  }\n\n  if (deps.storageForNamespace) {\n    const resolved = await deps.storageForNamespace(namespace);\n    if (isScanStorageResolution(resolved)) {\n      return {\n        storage: resolved.storage,\n        namespace: normalizeScanNamespace(resolved.namespace) ?? fallbackResolvedNamespace(deps, namespace),\n      };\n    }\n    if (!isStorageManagerLike(resolved)) {\n      throw new Error(\"storageForNamespace must return a StorageManager or { storage: StorageManager, namespace?: string }\");\n    }\n    return {\n      storage: resolved,\n      namespace: fallbackResolvedNamespace(deps, namespace),\n    };\n  }\n\n  throw new Error(\n    \"contradiction scans require storageForNamespace when namespaces are enabled so callers can enforce namespace access\",\n  );\n}\n\nfunction isScanStorageResolution(value: StorageManager | ScanStorageResolution): value is ScanStorageResolution {\n  if (isStorageManagerLike(value)) return false;\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as { storage?: unknown };\n  return isStorageManagerLike(candidate.storage);\n}\n\nfunction isStorageManagerLike(value: unknown): value is StorageManager {\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as { readAllMemories?: unknown };\n  return typeof candidate.readAllMemories === \"function\";\n}\n\nfunction fallbackResolvedNamespace(deps: ScanDependencies, namespace: string | undefined): string | undefined {\n  if (namespace) return namespace;\n  return resolveNamespaceCapabilities(deps.config).namespaces ? deps.config.defaultNamespace : undefined;\n}\n\nfunction isDefaultNamespaceScan(\n  config: PluginConfig,\n  requestedNamespace: string | undefined,\n  resolvedNamespace: string,\n): boolean {\n  if (requestedNamespace === undefined) return true;\n  return requestedNamespace === config.defaultNamespace || resolvedNamespace === config.defaultNamespace;\n}\n\nasync function loadEligibleMemories(storage: StorageManager): Promise<MemoryFile[]> {\n  let all: MemoryFile[];\n  try {\n    all = await storage.readAllMemories();\n  } catch {\n    return [];\n  }\n\n  return all.filter((mem) => {\n    const fm = mem.frontmatter;\n    // Only active memories (rule 53: explicit ACTIVE_STATUSES set)\n    const status = (fm.status as MemoryStatus) ?? \"active\";\n    if (!ACTIVE_STATUSES.has(status)) return false;\n\n    // Only scan high-value categories\n    const category = fm.category as string | undefined;\n    if (category && !SCAN_CATEGORIES.has(category)) return false;\n\n    // Must have content\n    if (!mem.content || mem.content.trim().length === 0) return false;\n\n    // Must have an ID\n    if (!fm.id) return false;\n\n    return true;\n  });\n}\n\nfunction jaccardOverlap(a: string[], b: string[]): number {\n  if (a.length === 0 && b.length === 0) return 0;\n  const setA = new Set(a.map((t) => t.toLowerCase()));\n  const setB = new Set(b.map((t) => t.toLowerCase()));\n  let intersection = 0;\n  for (const item of setA) {\n    if (setB.has(item)) intersection++;\n  }\n  const union = setA.size + setB.size - intersection;\n  return union === 0 ? 0 : intersection / union;\n}\n\nfunction shareEntityRef(a: MemoryFile, b: MemoryFile): boolean {\n  const entityA = a.frontmatter.entityRef?.trim();\n  const entityB = b.frontmatter.entityRef?.trim();\n  return Boolean(entityA && entityB && entityA === entityB);\n}\n\nfunction compareMemoryId(a: MemoryFile, b: MemoryFile): number {\n  return (a.frontmatter.id ?? \"\").localeCompare(b.frontmatter.id ?? \"\");\n}\n\nfunction memoryContentHashMap(memories: MemoryFile[]): Map<string, string> {\n  const hashes = new Map<string, string>();\n  for (const memory of memories) {\n    const id = memory.frontmatter.id;\n    if (!id) continue;\n    hashes.set(id, computeMemoryContentHash(memory.content, memory.frontmatter.category as string | undefined));\n  }\n  return hashes;\n}\n\nfunction pairMemoryContentHashes(\n  memoryIdA: string,\n  memoryIdB: string,\n  currentMemoryHashes: Map<string, string>,\n): Record<string, string> | undefined {\n  const hashA = currentMemoryHashes.get(memoryIdA);\n  const hashB = currentMemoryHashes.get(memoryIdB);\n  if (!hashA || !hashB) return undefined;\n  return {\n    [memoryIdA]: hashA,\n    [memoryIdB]: hashB,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-6TUWSUUD.js → chunk-UF3N7IRP.js}

@@ -98,12 +98,12 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-LUCARK4W.js";
+} from "./chunk-6U7TES2M.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-GGL34GCW.js";
+} from "./chunk-IZLTOS5L.js";
 import {
   GraphDashboardServer
 } from "./chunk-EZ25VE3G.js";
@@ -145,7 +145,7 @@ import {
 } from "./chunk-33JBK2XP.js";
 import {
   formatNamespaceMaintenanceHealthText
-} from "./chunk-KSJCXXOU.js";
+} from "./chunk-FAGERSH2.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -215,7 +215,7 @@ import {
 } from "./chunk-OADWQ5CR.js";
 import {
   EngramAccessHttpServer
-} from "./chunk-QZHF4BWN.js";
+} from "./chunk-Q5LGXWNG.js";
 import {
   WearablesInputError
 } from "./chunk-7WV3F5DQ.js";
@@ -228,10 +228,10 @@ import {
   createProductionChatLlmAdapter,
   loadChatSession,
   sessionBelongsToPrincipal
-} from "./chunk-O4ZIBPIW.js";
+} from "./chunk-T7CGPTFU.js";
 import {
   EngramAccessService
-} from "./chunk-646B5ERJ.js";
+} from "./chunk-PKO5NJ65.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -258,12 +258,6 @@ import {
 import {
   getObjectiveStateStoreStatus
 } from "./chunk-6HMYUWXR.js";
-import {
-  resolveCapabilities,
-  resolveCreationMemoryCapabilities,
-  resolveGraphConstructionCapabilities,
-  resolveMemoryLifecycleCapabilities
-} from "./chunk-ESF7TRYJ.js";
 import {
   getCausalTrajectoryStoreStatus
 } from "./chunk-SQNED75R.js";
@@ -285,6 +279,14 @@ import {
   evaluateActionConfidence,
   renderActionConfidenceText
 } from "./chunk-Z2YFLXHU.js";
+import {
+  resolveCapabilities,
+  resolveCreationMemoryCapabilities,
+  resolveGraphConstructionCapabilities,
+  resolveIdentityContinuityCapabilities,
+  resolveMemoryLifecycleCapabilities,
+  resolveNamespaceCapabilities
+} from "./chunk-SHJGBAIW.js";
 import {
   selectRouteRule,
   validateRouteTarget
@@ -2429,7 +2431,7 @@ function hasDestructivePurgeFailures(errors) {
 }
 function resolvePolicySignalNamespaces(orchestrator) {
   const names = /* @__PURE__ */ new Set([orchestrator.config.defaultNamespace]);
-  if (orchestrator.config.namespacesEnabled) {
+  if (resolveNamespaceCapabilities(orchestrator.config).namespaces) {
     names.add(orchestrator.config.sharedNamespace);
     for (const policy of orchestrator.config.namespacePolicies) {
       if (policy?.name) names.add(policy.name);
@@ -2552,7 +2554,7 @@ function resolveAuditNamespaces(orchestrator, namespace) {
     return [namespace];
   }
   const names = /* @__PURE__ */ new Set([orchestrator.config.defaultNamespace]);
-  if (orchestrator.config.namespacesEnabled) {
+  if (resolveNamespaceCapabilities(orchestrator.config).namespaces) {
     names.add(orchestrator.config.sharedNamespace);
     for (const policy of orchestrator.config.namespacePolicies) {
       if (policy?.name) names.add(policy.name);
@@ -3149,7 +3151,7 @@ async function resolveMemoryDirForNamespace(orchestrator, namespace, options) {
   const ns = (namespace ?? "").trim();
   if (!ns) return orchestrator.config.memoryDir;
   assertSafeNamespaceSegment(ns);
-  if (!orchestrator.config.namespacesEnabled) {
+  if (!resolveNamespaceCapabilities(orchestrator.config).namespaces) {
     if (options?.rejectUnsupportedOverride && ns !== orchestrator.config.defaultNamespace) {
       throw new Error(`namespaces are disabled; cannot target namespace: ${ns}`);
     }
@@ -3536,7 +3538,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
       );
       tierCmd.command("list").description("Summarize tier distribution across all memories").option("--json", "Emit machine-readable JSON only").action(async (...args) => {
         const options = args[0] ?? {};
-        const { summarizeTiers, formatTierSummaryText } = await import("./tier-stats-3LYQ3VV5.js");
+        const { summarizeTiers, formatTierSummaryText } = await import("./tier-stats-LSM35HZY.js");
         const summary = await summarizeTiers(orchestrator.storage);
         if (reportHasMachineReadableOutput(options)) {
           console.log(JSON.stringify(summary, null, 2));
@@ -3547,7 +3549,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
       tierCmd.command("explain").description("Explain the tier-transition decision for a single memory").argument("<id>", "Memory id to explain").option("--json", "Emit machine-readable JSON only").action(async (...args) => {
         const idArg = typeof args[0] === "string" ? args[0] : "";
         const options = args[1] ?? {};
-        const { explainTierForMemory, formatTierExplainText } = await import("./tier-stats-3LYQ3VV5.js");
+        const { explainTierForMemory, formatTierExplainText } = await import("./tier-stats-LSM35HZY.js");
         try {
           const explain = await explainTierForMemory(
             orchestrator.storage,
@@ -6282,7 +6284,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
       });
       const continuityCmd = cmd.command("continuity").description("Identity continuity incident workflow commands");
       continuityCmd.command("incidents").description("List continuity incidents").option("--state <state>", "Filter by state: open|closed|all", "open").option("--limit <number>", "Maximum incidents to list", "25").action(async (...args) => {
-        if (!orchestrator.config.identityContinuityEnabled) {
+        if (!resolveIdentityContinuityCapabilities(orchestrator.config).identityContinuity) {
           console.log("Identity continuity is disabled.");
           return;
         }
@@ -6303,7 +6305,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         }
       });
       continuityCmd.command("incident-open").description("Open a continuity incident").option("--symptom <text>", "Required symptom description").option("--trigger-window <window>", "Optional incident trigger window").option("--suspected-cause <text>", "Optional suspected cause").action(async (...args) => {
-        if (!orchestrator.config.identityContinuityEnabled) {
+        if (!resolveIdentityContinuityCapabilities(orchestrator.config).identityContinuity) {
           console.log("Identity continuity is disabled.");
           return;
         }
@@ -6326,7 +6328,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
         console.log(formatContinuityIncidentCli(created));
       });
       continuityCmd.command("incident-close").description("Close a continuity incident").option("--id <id>", "Required incident ID").option("--fix-applied <text>", "Required fix description").option("--verification-result <text>", "Required verification result").option("--preventive-rule <text>", "Optional preventive rule").action(async (...args) => {
-        if (!orchestrator.config.identityContinuityEnabled) {
+        if (!resolveIdentityContinuityCapabilities(orchestrator.config).identityContinuity) {
           console.log("Identity continuity is disabled.");
           return;
         }
@@ -6768,7 +6770,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           mergedContent: cmdOpts.mergedContent,
           storageForNamespace: (namespace) => {
             const requested = namespace?.trim();
-            if (!orchestrator.config.namespacesEnabled) {
+            if (!resolveNamespaceCapabilities(orchestrator.config).namespaces) {
               if (requested && requested !== orchestrator.config.defaultNamespace) {
                 throw new Error(`unsupported namespace: ${requested}`);
               }
@@ -6790,7 +6792,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
       });
       reviewCmd.command("scan").description("Run an on-demand contradiction scan").option("--namespace <ns>", "Namespace to scan").action(async (...args) => {
         const options = args[0] ?? {};
-        const { runContradictionScan } = await import("./contradiction-scan-HWGEOUDS.js");
+        const { runContradictionScan } = await import("./contradiction-scan-OUHMCUBT.js");
         console.log("Running contradiction scan...");
         const result = await runContradictionScan({
           storage: orchestrator.storage,
@@ -6807,7 +6809,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
             };
           },
           storageForNamespace: async (namespace) => {
-            const resolvedNamespace = namespace?.trim() || (orchestrator.config.namespacesEnabled ? orchestrator.config.defaultNamespace : void 0);
+            const resolvedNamespace = namespace?.trim() || (resolveNamespaceCapabilities(orchestrator.config).namespaces ? orchestrator.config.defaultNamespace : void 0);
             const storage = await orchestrator.getStorageForNamespace(resolvedNamespace);
             return { storage, namespace: resolvedNamespace };
           },
@@ -7510,4 +7512,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-6TUWSUUD.js.map
+//# sourceMappingURL=chunk-UF3N7IRP.js.map