@remnic/core 9.54.7 → 9.55.0

package/dist/{chunk-3GD2HFR6.js → chunk-IGWVMA4Y.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-U3PN77QT.js";
 import {
   resolveNamespaceCapabilities
-} from "./chunk-2XRE6FLM.js";
+} from "./chunk-JUOZ62Y7.js";
 
 // src/namespaces/principal.ts
 var MAX_REGEX_SESSION_KEY_LENGTH = 512;
@@ -111,4 +111,4 @@ export {
   recallNamespacesForPrincipal,
   citationAuthorizedNamespaces
 };
-//# sourceMappingURL=chunk-3GD2HFR6.js.map
+//# sourceMappingURL=chunk-IGWVMA4Y.js.map

package/dist/{chunk-FONWBCVY.js → chunk-IKT6ZVO7.js}

@@ -1,10 +1,10 @@
 import {
   parseXrayFormat
-} from "./chunk-H7NAZ3UB.js";
+} from "./chunk-U7BMN33M.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-76JJSXK7.js";
+} from "./chunk-5QHDXMXP.js";
 
 // src/recall-xray-cli.ts
 function parseXrayDisclosureFlag(value) {
@@ -50,4 +50,4 @@ export {
   parseXrayBudgetFlag,
   parseXrayCliOptions
 };
-//# sourceMappingURL=chunk-FONWBCVY.js.map
+//# sourceMappingURL=chunk-IKT6ZVO7.js.map

package/dist/{chunk-TO7ZTWJW.js → chunk-ION47U3Z.js}

@@ -1,13 +1,13 @@
 import {
   createSearchBackend
-} from "./chunk-QZLDRQ4I.js";
+} from "./chunk-F7M36OG2.js";
 import {
   namespaceIdentityToken,
   normalizeNamespaceIdentity
 } from "./chunk-EGGE52UU.js";
 import {
   resolveNamespaceCapabilities
-} from "./chunk-2XRE6FLM.js";
+} from "./chunk-JUOZ62Y7.js";
 import {
   ALL_CATEGORY_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -470,4 +470,4 @@ export {
   NamespaceSearchRouter,
   normalizeQmdResultPath
 };
-//# sourceMappingURL=chunk-TO7ZTWJW.js.map
+//# sourceMappingURL=chunk-ION47U3Z.js.map

package/dist/{chunk-OCIP6YMD.js → chunk-IXGQP4RZ.js}

@@ -2,10 +2,10 @@ import {
   RECONCILE_MANIFEST_FORMAT,
   RECONCILE_MANIFEST_SCHEMA_VERSION,
   buildReconcileManifestFile
-} from "./chunk-RBII7637.js";
+} from "./chunk-XRPPHIRI.js";
 import {
   offlineSyncStorageForSnapshot
-} from "./chunk-NQMSEB5D.js";
+} from "./chunk-X5OIPQME.js";
 import {
   isSupportPassportPrivateMemory
 } from "./chunk-XX4HPFFM.js";
@@ -49,4 +49,4 @@ async function createOfflineSyncManifestStream(orchestrator, namespace, userExcl
 export {
   createOfflineSyncManifestStream
 };
-//# sourceMappingURL=chunk-OCIP6YMD.js.map
+//# sourceMappingURL=chunk-IXGQP4RZ.js.map

package/dist/{chunk-UPLZNJKN.js → chunk-JFPZEWY3.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-M4YHAODQ.js";
+} from "./chunk-BWJMBJCY.js";
 import {
   keyring_exports,
   secureStoreDir
@@ -18,7 +18,7 @@ import {
 import {
   resolveNamespaceCapabilities,
   resolveRecallAuxiliaryCapabilities
-} from "./chunk-2XRE6FLM.js";
+} from "./chunk-JUOZ62Y7.js";
 import {
   ALL_CATEGORY_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -388,4 +388,4 @@ export {
   resolveNamespaceStorageRoot,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-UPLZNJKN.js.map
+//# sourceMappingURL=chunk-JFPZEWY3.js.map

package/dist/{chunk-SMNYAMJD.js → chunk-JKL53MOY.js}

@@ -2,11 +2,11 @@ import {
   buildExplicitCaptureDedupKey,
   isTombstoneBlockedCaptureWriteLockBusy,
   normalizeExplicitCaptureContent
-} from "./chunk-K2UGPTYY.js";
+} from "./chunk-H6ZXNH5I.js";
 import {
   TAG_LIMITS,
   composeMemoryEnvelope
-} from "./chunk-NSVDUN76.js";
+} from "./chunk-LCU5R6TQ.js";
 import {
   isSupportPassportPrivateMemory
 } from "./chunk-XX4HPFFM.js";
@@ -18,7 +18,7 @@ import {
 } from "./chunk-U3PN77QT.js";
 import {
   resolveNamespaceCapabilities
-} from "./chunk-2XRE6FLM.js";
+} from "./chunk-JUOZ62Y7.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -787,4 +787,4 @@ export {
   shouldProcessInlineExplicitCapture,
   InlineExplicitCaptureProcessor
 };
-//# sourceMappingURL=chunk-SMNYAMJD.js.map
+//# sourceMappingURL=chunk-JKL53MOY.js.map

package/dist/{chunk-2FKEIPIT.js → chunk-JOA4Q765.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-S4DDLTPX.js";
 import {
   LocalLlmClient
-} from "./chunk-KFBOPMF6.js";
+} from "./chunk-5ZIWRMZM.js";
 import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
@@ -23,7 +23,7 @@ import {
 import {
   resolveLocalLlmCapabilities,
   resolvePipelineProcessingCapabilities
-} from "./chunk-2XRE6FLM.js";
+} from "./chunk-JUOZ62Y7.js";
 import {
   encodeStoragePathSegment,
   resolveSafeStoragePath
@@ -690,4 +690,4 @@ ${truncatedConversation}`;
 export {
   HourlySummarizer
 };
-//# sourceMappingURL=chunk-2FKEIPIT.js.map
+//# sourceMappingURL=chunk-JOA4Q765.js.map

package/dist/{chunk-2XRE6FLM.js → chunk-JUOZ62Y7.js}

@@ -109,6 +109,8 @@ function resolveSecurityCapabilities(config) {
     trustZones: config.trustZonesEnabled,
     quarantinePromotion: config.quarantinePromotionEnabled,
     memoryPoisoningDefense: config.memoryPoisoningDefenseEnabled,
+    originAuthority: config.originAuthorityEnabled,
+    injectionScreen: config.injectionScreenEnabled,
     trustZoneRecall: config.trustZoneRecallEnabled
   });
 }
@@ -274,4 +276,4 @@ export {
   resolvePipelineProcessingCapabilities,
   resolveConversationContextCapabilities
 };
-//# sourceMappingURL=chunk-2XRE6FLM.js.map
+//# sourceMappingURL=chunk-JUOZ62Y7.js.map

package/dist/chunk-JUOZ62Y7.js.map

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

package/dist/{chunk-MLPTFODV.js → chunk-KHQ57QLJ.js}

@@ -1,10 +1,10 @@
+import {
+  computeLegacyContentHash
+} from "./chunk-5FVVY2EB.js";
 import {
   serializeMutations,
   withHeldFileLock
 } from "./chunk-FFAZ2XFU.js";
-import {
-  computeLegacyContentHash
-} from "./chunk-5FVVY2EB.js";
 
 // src/lifecycle/tombstones.ts
 var TOMBSTONE_NORMALIZER_VERSION = 2;
@@ -659,4 +659,4 @@ export {
   applyTombstoneResurrectionGate,
   buildRetiredFactTombstoneInputs
 };
-//# sourceMappingURL=chunk-MLPTFODV.js.map
+//# sourceMappingURL=chunk-KHQ57QLJ.js.map

package/dist/{chunk-NSVDUN76.js → chunk-LCU5R6TQ.js}

@@ -216,6 +216,7 @@ function composeMemoryEnvelope(input, ctx, opts = {}) {
     ttl: normalizeOptionalString("ttl", input.ttl, hygiene),
     validAt,
     sourceConnector: normalizeOptionalString("sourceConnector", input.sourceConnector, hygiene),
+    origin: normalizeOptionalString("origin", input.origin, hygiene),
     sourceReason: normalizeOptionalString("sourceReason", input.sourceReason, hygiene),
     source: ctx.source.trim(),
     composedAt: now.toISOString(),
@@ -271,6 +272,7 @@ function isSealedMemoryEnvelope(value) {
         ...v.ttl !== void 0 ? { ttl: v.ttl } : {},
         ...v.validAt !== void 0 ? { validAt: v.validAt } : {},
         ...v.sourceConnector !== void 0 ? { sourceConnector: v.sourceConnector } : {},
+        ...v.origin !== void 0 ? { origin: v.origin } : {},
         ...v.sourceReason !== void 0 ? { sourceReason: v.sourceReason } : {}
       },
       { source: v.source, now: () => new Date(v.composedAt) }
@@ -285,7 +287,7 @@ function isSealedMemoryEnvelope(value) {
     const bk = Object.keys(b);
     return ak.length === bk.length && ak.every((k) => Object.hasOwn(b, k) && a[k] === b[k]);
   };
-  return rebuilt.content === v.content && rebuilt.persistedBody === v.persistedBody && rebuilt.category === v.category && rebuilt.source === v.source && rebuilt.composedAt === v.composedAt && rebuilt.confidence === v.confidence && rebuilt.entityRef === v.entityRef && rebuilt.ttl === v.ttl && rebuilt.validAt === v.validAt && rebuilt.sourceConnector === v.sourceConnector && rebuilt.sourceReason === v.sourceReason && sameArray(rebuilt.tags, v.tags) && sameArray(rebuilt.sanitizeViolations, v.sanitizeViolations) && sameMap(rebuilt.structuredAttributes, v.structuredAttributes) && sameMap(rebuilt.rawStructuredAttributes, attrs);
+  return rebuilt.content === v.content && rebuilt.persistedBody === v.persistedBody && rebuilt.category === v.category && rebuilt.source === v.source && rebuilt.composedAt === v.composedAt && rebuilt.confidence === v.confidence && rebuilt.entityRef === v.entityRef && rebuilt.ttl === v.ttl && rebuilt.validAt === v.validAt && rebuilt.sourceConnector === v.sourceConnector && rebuilt.origin === v.origin && rebuilt.sourceReason === v.sourceReason && sameArray(rebuilt.tags, v.tags) && sameArray(rebuilt.sanitizeViolations, v.sanitizeViolations) && sameMap(rebuilt.structuredAttributes, v.structuredAttributes) && sameMap(rebuilt.rawStructuredAttributes, attrs);
 }
 function sealedWriteToLegacyArgs(envelope, extras = {}) {
   return {
@@ -306,7 +308,8 @@ function sealedWriteToLegacyArgs(envelope, extras = {}) {
       // extras — a conditional spread let extras.sourceConnector smuggle
       // unvalidated connector provenance past the sealed envelope when the
       // envelope had none.
-      sourceConnector: envelope.sourceConnector
+      sourceConnector: envelope.sourceConnector,
+      origin: envelope.origin
     }
   };
 }
@@ -325,6 +328,8 @@ var FINGERPRINT_EXEMPT_FIELDS = [
   // slightly different confidence are the same write for dedup purposes.
   "confidence",
   // Free-text provenance note; carries no identity.
+  // Origin is provenance metadata, not write identity (#1955).
+  "origin",
   "sourceReason"
 ];
 var FINGERPRINT_SCOPE_FIELDS = [
@@ -418,4 +423,4 @@ export {
   buildAccessWriteRequestFingerprint,
   buildObserveRequestFingerprint
 };
-//# sourceMappingURL=chunk-NSVDUN76.js.map
+//# sourceMappingURL=chunk-LCU5R6TQ.js.map

package/dist/chunk-LCU5R6TQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/write-envelope.ts"],"sourcesContent":["/**\n * Sealed memory-write envelope (issue #1989, umbrella #1988).\n *\n * THE single stamping point for cross-cutting memory-creation fields.\n *\n * Why this exists: PR #1852 needed 27 rework commits because adding one\n * cross-cutting field (`sourceConnector`) required hand-editing every\n * write call site and every idempotency payload, and reviewers discovered\n * missed sites one round at a time. This module removes the fan-out:\n *\n *   1. `composeMemoryEnvelope()` is the only way to mint a\n *      `SealedMemoryEnvelope` — the brand is a non-exported `unique symbol`,\n *      so a hand-built object literal fails `tsc` (`npm run check-types`\n *      is already a required repo-wide gate; the type system IS the fence).\n *   2. `buildWriteIdempotencyPayload()` derives every access-surface\n *      idempotency payload from ONE ordered field registry\n *      (`WRITE_FINGERPRINT_FIELDS`). Adding a fingerprint-relevant field is\n *      a one-line registry change picked up by every surface; forgetting to\n *      classify a new `MemoryWriteInput` field is a compile error (see the\n *      exhaustiveness guards at the bottom of this file).\n *\n * PR1 scope (no call-site changes): the composer, the registry, and the\n * payload builder, fully tested. PR2–PR4 migrate storage entry points and\n * the write call sites onto this module (see #1989 for the slicing).\n */\n\nimport type { MemoryCategory } from \"./types.js\";\nimport { normalizeTags } from \"./recall-tag-filter.js\";\nimport { parseFlexibleIsoTimestamp } from \"./utils/iso-timestamp.js\";\nimport { assemblePersistedBody } from \"./structured-attributes.js\";\n\n// ---------------------------------------------------------------------------\n// Input surface\n// ---------------------------------------------------------------------------\n\n/**\n * Every cross-cutting memory-creation field lives HERE and only here.\n *\n * When you add a field you MUST also add it to either\n * `WRITE_FINGERPRINT_FIELDS` or `FINGERPRINT_EXEMPT_FIELDS` — the\n * exhaustiveness guard below makes forgetting a compile error.\n */\nexport interface MemoryWriteInput {\n  /** Raw memory content. Must be non-empty after trimming. */\n  content: string;\n  /** Memory category — validated against the canonical category set. */\n  category: MemoryCategory;\n  /** Free-form labels; normalized (trim/dedupe) and capped, see TAG_LIMITS. */\n  tags?: string[];\n  /** String→string structured attributes; non-string values are rejected. */\n  structuredAttributes?: Record<string, string>;\n  /** Entity file reference (e.g. `person-jane-doe`). */\n  entityRef?: string;\n  /** Extraction confidence in [0, 1]. */\n  confidence?: number;\n  /** Opaque TTL expression (e.g. `90d` or an ISO date) — validated non-empty. */\n  ttl?: string;\n  /** Event-time validity start (ISO 8601). */\n  validAt?: string;\n  /** Connector identity that produced this write (issue #1852). */\n  sourceConnector?: string;\n  /** Origin class stamped at creation time (issue #1955). */\n  origin?: string;\n  /** Human-readable provenance note. */\n  sourceReason?: string;\n}\n\n/** Context supplied by the write path, not by the payload author. */\nexport interface WriteContext {\n  /** Frontmatter `source` string (e.g. `extraction`, `wearable:bee`). */\n  source: string;\n  /** Clock override for tests. */\n  now?: () => Date;\n}\n\n/** Scope facts that participate in idempotency but never in frontmatter. */\nexport interface FingerprintScope {\n  /** Access surface performing the write (e.g. `memory_store`, `observe`). */\n  surface: string;\n  namespace?: string;\n  principal?: string;\n  codingContext?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Normalization limits (single source of truth — docs/tags.md contract)\n// ---------------------------------------------------------------------------\n\nexport const TAG_LIMITS = Object.freeze({\n  /** Maximum number of tags persisted per memory. */\n  maxTags: 50,\n  /** Maximum length of a single tag. */\n  maxTagLength: 256,\n});\n\nexport const STRUCTURED_ATTRIBUTE_LIMITS = Object.freeze({\n  /** Maximum number of structured attributes per memory. */\n  maxEntries: 64,\n  /** Maximum length of one attribute key. */\n  maxKeyLength: 128,\n  /** Maximum length of one attribute value. */\n  maxValueLength: 1024,\n});\n\nconst MEMORY_CATEGORY_TABLE: Record<MemoryCategory, true> = {\n  fact: true,\n  preference: true,\n  correction: true,\n  entity: true,\n  decision: true,\n  relationship: true,\n  principle: true,\n  commitment: true,\n  moment: true,\n  skill: true,\n  rule: true,\n  procedure: true,\n  reasoning_trace: true,\n};\n\nconst MEMORY_CATEGORY_NAMES = Object.keys(MEMORY_CATEGORY_TABLE).sort();\n\nexport function isMemoryCategory(value: string): value is MemoryCategory {\n  return Object.prototype.hasOwnProperty.call(MEMORY_CATEGORY_TABLE, value);\n}\n\n// ---------------------------------------------------------------------------\n// Sealed envelope\n// ---------------------------------------------------------------------------\n\ndeclare const sealed: unique symbol;\n\n/**\n * A normalized, validated memory-write envelope.\n *\n * Opaque: only `composeMemoryEnvelope()` can mint one. Storage creation\n * entry points accept this type (PR2), so every write path is forced\n * through the composer at compile time.\n */\nexport interface SealedMemoryEnvelope {\n  readonly [sealed]: true;\n  /**\n   * Caller-supplied content VERBATIM (validated non-empty-after-trim).\n   * `StorageManager.writeMemory` persists content byte-for-byte (callers\n   * that trim, e.g. explicit capture, do so before composing), so the\n   * envelope must not transform it — the earlier compose-time trim/sanitize\n   * broke byte-parity with extraction writes and was removed in PR2.\n   */\n  readonly content: string;\n  /**\n   * The exact body persistence will write: attribute-suffix enrichment then\n   * combined sanitization, produced by the SAME `assemblePersistedBody`\n   * helper `writeMemory` uses (issue #1989 PR2; AGENTS.md §13). This is the\n   * form write-idempotency fingerprints hash.\n   */\n  readonly persistedBody: string;\n  /** Injection patterns matched during body assembly (empty = clean). */\n  readonly sanitizeViolations: readonly string[];\n  /**\n   * Salvage-mode hygiene notes (empty in strict mode): each dropped/clamped\n   * invalid optional field is recorded here — visible, never silent\n   * (repo rule 34). Callers persisting machine-generated input log these.\n   */\n  readonly salvageNotes: readonly string[];\n  readonly category: MemoryCategory;\n  readonly tags: readonly string[];\n  /**\n   * CANONICAL attributes (keys trim+lowercase, values trim) — the form\n   * fingerprints and downstream consumers use; stable across caller casing.\n   */\n  readonly structuredAttributes: Readonly<Record<string, string>> | undefined;\n  /**\n   * The validated ORIGINAL attribute map, byte-preserved. `writeMemory`\n   * persists frontmatter attributes raw (canonicalizing only the body\n   * suffix via normalizeAttributePairs) — a pre-existing raw/canonical\n   * inconsistency (supersession keys read the raw form). The sealed path\n   * preserves those bytes; canonicalizing the frontmatter at the storage\n   * boundary is a follow-up once the legacy path retires (#1989 PR4).\n   */\n  readonly rawStructuredAttributes: Readonly<Record<string, string>> | undefined;\n  readonly entityRef: string | undefined;\n  readonly confidence: number | undefined;\n  readonly ttl: string | undefined;\n  readonly validAt: string | undefined;\n  readonly sourceConnector: string | undefined;\n  readonly origin: string | undefined;\n  readonly sourceReason: string | undefined;\n  readonly source: string;\n  /** ISO timestamp the envelope was composed (from ctx.now). */\n  readonly composedAt: string;\n}\n\nfunction fail(field: string, message: string): never {\n  throw new Error(`composeMemoryEnvelope: ${field} ${message}`);\n}\n\n/**\n * Compose-time input hygiene mode (issue #1989 PR2, review round on #2014).\n *\n * - `strict` (default): every invalid field throws — correct for OPERATOR\n *   and API input (explicit capture, memory_store), where a bad value is a\n *   caller bug that must surface.\n * - `salvage`: for MACHINE-GENERATED input (LLM extraction, wearable\n *   ingestion). One malformed fact from an extractor must not abort a whole\n *   persistence batch that legacy `writeMemory` would have accepted.\n *   Invalid tags/attributes/optional fields are DROPPED with a note pushed\n *   to `envelope.salvageNotes` — visible, never silent (repo rule 34);\n *   callers log the notes. Content, category, ctx.source, and validAt stay\n *   FATAL in both modes (legacy writeMemory also throws on bad validAt, and\n *   a write without valid content/category cannot proceed).\n */\nexport interface ComposeEnvelopeOptions {\n  salvage?: boolean;\n}\n\n/** Internal reporter: throws in strict mode, records a note in salvage. */\ninterface Hygiene {\n  salvage: boolean;\n  notes: string[];\n  flag(field: string, message: string): void;\n}\n\nfunction makeHygiene(salvage: boolean): Hygiene {\n  const notes: string[] = [];\n  return {\n    salvage,\n    notes,\n    flag(field: string, message: string): void {\n      if (!salvage) fail(field, message);\n      notes.push(`${field} ${message}`);\n    },\n  };\n}\n\n/**\n * Validate and CANONICALIZE `validAt` via the repo's shared flexible ISO\n * parser (`utils/iso-timestamp.ts`) — the same family durable writes use, so\n * the envelope can never accept a value storage would reject or reinterpret\n * (review findings on #1998: no second validation convention; reduced\n * precision like `2026-07-17T09:30Z` is valid; offsets are bounded ±14:00;\n * `Date.parse` alone is not an ISO validator).\n *\n * Canonical form is the epoch round-trip (`Date.toISOString()`), so\n * fingerprints are identical for `...T09:30Z`, `...T09:30:00.000Z`, and the\n * same instant expressed with an offset (§13 hash-consistency).\n */\nfunction validateIsoTimestamp(field: string, value: string): string {\n  const trimmed = value.trim();\n  if (trimmed.length === 0) fail(field, \"must be a non-empty ISO 8601 timestamp\");\n  const epochMs = parseFlexibleIsoTimestamp(trimmed);\n  if (epochMs === null) {\n    fail(\n      field,\n      `is not a valid ISO 8601 date/timestamp: ${JSON.stringify(value)} (date-only, reduced precision, Z, and ±HH:MM offsets up to ±14:00 are accepted; calendar overflow is not)`,\n    );\n  }\n  return new Date(epochMs).toISOString();\n}\n\nfunction normalizeEnvelopeTags(raw: string[] | undefined, hygiene: Hygiene): readonly string[] {\n  if (raw === undefined) return Object.freeze([]);\n  if (!Array.isArray(raw)) {\n    hygiene.flag(\"tags\", \"must be an array of strings — dropped\");\n    return Object.freeze([]);\n  }\n  const usable: string[] = [];\n  for (const tag of raw) {\n    if (typeof tag !== \"string\") {\n      hygiene.flag(\"tags\", `entries must be strings (got ${typeof tag})`);\n      continue;\n    }\n    if (tag.trim().length > TAG_LIMITS.maxTagLength) {\n      hygiene.flag(\"tags\", `entry exceeds ${TAG_LIMITS.maxTagLength} characters: ${JSON.stringify(tag.slice(0, 40))}…`);\n      continue;\n    }\n    usable.push(tag);\n  }\n  let normalized = normalizeTags(usable) ?? [];\n  if (normalized.length > TAG_LIMITS.maxTags) {\n    hygiene.flag(\"tags\", `exceed the ${TAG_LIMITS.maxTags}-tag limit (got ${normalized.length}) — keeping the first ${TAG_LIMITS.maxTags}`);\n    normalized = normalized.slice(0, TAG_LIMITS.maxTags);\n  }\n  return Object.freeze(normalized);\n}\n\nfunction normalizeStructuredAttributes(\n  raw: Record<string, string> | undefined,\n  hygiene: Hygiene,\n): { canonical: Readonly<Record<string, string>>; raw: Readonly<Record<string, string>> } | undefined {\n  if (raw === undefined) return undefined;\n  if (\n    raw === null ||\n    typeof raw !== \"object\" ||\n    Array.isArray(raw) ||\n    (Object.getPrototypeOf(raw) !== Object.prototype && Object.getPrototypeOf(raw) !== null)\n  ) {\n    // Map/Date/class instances have empty Object.entries() and would\n    // silently normalize to \"no attributes\" (review finding on #1998\n    // round 5) — never a plain pass-through.\n    hygiene.flag(\"structuredAttributes\", \"must be a plain object of string values (Map, Date, and class instances are rejected) — dropped\");\n    return undefined;\n  }\n  let entries = Object.entries(raw);\n  if (entries.length === 0) return undefined;\n  if (entries.length > STRUCTURED_ATTRIBUTE_LIMITS.maxEntries) {\n    hygiene.flag(\n      \"structuredAttributes\",\n      `exceed the ${STRUCTURED_ATTRIBUTE_LIMITS.maxEntries}-entry limit (got ${entries.length}) — keeping the first ${STRUCTURED_ATTRIBUTE_LIMITS.maxEntries} in insertion order`,\n    );\n    entries = entries.slice(0, STRUCTURED_ATTRIBUTE_LIMITS.maxEntries);\n  }\n  // Keys that collide with Object.prototype machinery are REJECTED outright:\n  // `hashAccessIdempotencyPayload`'s stableStringify rebuilds objects with\n  // plain assignment, where a \"__proto__\" own property silently vanishes —\n  // so such a key can never round-trip through the fingerprint faithfully\n  // (review finding on #1998 round 3). Rejection beats smuggling (§1/§39).\n  const FORBIDDEN_ATTRIBUTE_KEYS = [\"__proto__\", \"constructor\", \"prototype\"];\n  const out: Record<string, string> = Object.create(null);\n  const survivingOriginal: Array<[string, string]> = [];\n  for (const [key, value] of entries) {\n    // Canonicalize exactly like storage's normalizeAttributePairs\n    // (storage.ts:1277): keys trim+lowercase, values trim — so the\n    // fingerprint and the persisted searchable form can never diverge\n    // (review finding on #1998; AGENTS.md §13 hash-consistency).\n    const cleanKey = key.trim().toLowerCase();\n    if (cleanKey.length === 0) {\n      hygiene.flag(\"structuredAttributes\", \"contain an empty key\");\n      continue;\n    }\n    if (cleanKey.length > STRUCTURED_ATTRIBUTE_LIMITS.maxKeyLength) {\n      hygiene.flag(\"structuredAttributes\", `key exceeds ${STRUCTURED_ATTRIBUTE_LIMITS.maxKeyLength} characters: ${JSON.stringify(cleanKey.slice(0, 40))}…`);\n      continue;\n    }\n    if (typeof value !== \"string\") {\n      hygiene.flag(\"structuredAttributes\", `value for ${JSON.stringify(cleanKey)} must be a string (got ${typeof value}) — stringify numbers/booleans at the call site`);\n      continue;\n    }\n    const cleanValue = value.trim();\n    if (FORBIDDEN_ATTRIBUTE_KEYS.includes(cleanKey)) {\n      hygiene.flag(\n        \"structuredAttributes\",\n        `contain the reserved key ${JSON.stringify(cleanKey)} — prototype-machinery names cannot round-trip through fingerprint serialization`,\n      );\n      continue;\n    }\n    if (cleanValue.length > STRUCTURED_ATTRIBUTE_LIMITS.maxValueLength) {\n      hygiene.flag(\"structuredAttributes\", `value for ${JSON.stringify(cleanKey)} exceeds ${STRUCTURED_ATTRIBUTE_LIMITS.maxValueLength} characters`);\n      continue;\n    }\n    if (Object.hasOwn(out, cleanKey)) {\n      hygiene.flag(\"structuredAttributes\", `contain duplicate key after canonicalization (trim + lowercase): ${JSON.stringify(cleanKey)}`);\n      continue;\n    }\n    out[cleanKey] = cleanValue;\n    survivingOriginal.push([key, value]);\n  }\n  if (Object.keys(out).length === 0) return undefined;\n  // Copy onto a normal object so downstream JSON/stableStringify behavior is\n  // unchanged; keys are already validated. The RAW map carries only the\n  // SURVIVING original pairs — dropped entries must not reach frontmatter.\n  return {\n    canonical: Object.freeze({ ...out }),\n    raw: Object.freeze(Object.fromEntries(survivingOriginal)),\n  };\n}\n\nfunction normalizeOptionalString(\n  field: string,\n  value: string | undefined,\n  hygiene: Hygiene,\n): string | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"string\") {\n    hygiene.flag(field, `must be a string (got ${typeof value}) — dropped`);\n    return undefined;\n  }\n  const trimmed = value.trim();\n  if (trimmed.length === 0) {\n    hygiene.flag(field, \"must be non-empty when provided — dropped\");\n    return undefined;\n  }\n  return trimmed;\n}\n\n/**\n * Compose (normalize + validate + seal) a memory-write envelope.\n *\n * Strict mode (default) throws on any invalid input — never silently\n * defaults (AGENTS.md §1/§39). Salvage mode (`{ salvage: true }`, for\n * machine-generated input like LLM extraction) drops invalid OPTIONAL\n * fields with notes on `envelope.salvageNotes` instead of aborting the\n * batch; content/category/source/validAt stay fatal in both modes.\n */\nexport function composeMemoryEnvelope(\n  input: MemoryWriteInput,\n  ctx: WriteContext,\n  opts: ComposeEnvelopeOptions = {},\n): SealedMemoryEnvelope {\n  if (input === null || typeof input !== \"object\") fail(\"input\", \"must be an object\");\n  if (ctx === null || typeof ctx !== \"object\") fail(\"ctx\", \"must be an object\");\n  const hygiene = makeHygiene(opts.salvage === true);\n\n  if (typeof input.content !== \"string\" || input.content.trim().length === 0) {\n    fail(\"content\", \"must be a non-empty string\");\n  }\n  if (typeof input.category !== \"string\" || !isMemoryCategory(input.category)) {\n    fail(\n      \"category\",\n      `must be one of: ${MEMORY_CATEGORY_NAMES.join(\", \")} (got ${JSON.stringify(input.category)})`,\n    );\n  }\n  if (typeof ctx.source !== \"string\" || ctx.source.trim().length === 0) {\n    fail(\"ctx.source\", \"must be a non-empty string\");\n  }\n\n  let confidence: number | undefined;\n  if (input.confidence !== undefined) {\n    if (\n      typeof input.confidence !== \"number\" ||\n      !Number.isFinite(input.confidence) ||\n      input.confidence < 0 ||\n      input.confidence > 1\n    ) {\n      hygiene.flag(\n        \"confidence\",\n        `must be a finite number within [0, 1] (got ${String(input.confidence)}) — dropped (storage defaults apply)`,\n      );\n    } else {\n      confidence = input.confidence;\n    }\n  }\n\n  // validAt stays FATAL in salvage too: legacy writeMemory throws on an\n  // invalid validAt (normalizeMemoryWriteTimestamp), so salvage-dropping it\n  // would CHANGE behavior rather than preserve it.\n  const validAt =\n    input.validAt === undefined ? undefined : validateIsoTimestamp(\"validAt\", input.validAt);\n\n  const now = ctx.now ? ctx.now() : new Date();\n  if (!(now instanceof Date) || Number.isNaN(now.getTime())) {\n    fail(\"ctx.now\", \"must return a valid Date\");\n  }\n\n  const attributes = normalizeStructuredAttributes(input.structuredAttributes, hygiene);\n  // Assemble the EXACT persisted form (attribute suffix + combined sanitize)\n  // with the same helper writeMemory uses — fingerprints hash this form, so\n  // envelope and storage cannot diverge (§13; #1998 round-8 thread resolved\n  // here in PR2 as promised). writeMemory assembles from the RAW map;\n  // normalizeAttributePairs canonicalizes internally, so raw and canonical\n  // maps yield the same suffix — asserted by the parity suite.\n  const assembled = assemblePersistedBody(\n    input.content,\n    attributes ? { ...attributes.raw } : undefined,\n  );\n  if (assembled.text.trim().length === 0) {\n    fail(\"content\", \"is empty after sanitization\");\n  }\n\n  const body = {\n    content: input.content,\n    persistedBody: assembled.text,\n    sanitizeViolations: Object.freeze([...assembled.violations]),\n    category: input.category,\n    tags: normalizeEnvelopeTags(input.tags, hygiene),\n    structuredAttributes: attributes?.canonical,\n    rawStructuredAttributes: attributes?.raw,\n    entityRef: normalizeOptionalString(\"entityRef\", input.entityRef, hygiene),\n    confidence,\n    ttl: normalizeOptionalString(\"ttl\", input.ttl, hygiene),\n    validAt,\n    sourceConnector: normalizeOptionalString(\"sourceConnector\", input.sourceConnector, hygiene),\n    origin: normalizeOptionalString(\"origin\", input.origin, hygiene),\n    sourceReason: normalizeOptionalString(\"sourceReason\", input.sourceReason, hygiene),\n    source: ctx.source.trim(),\n    composedAt: now.toISOString(),\n    salvageNotes: Object.freeze([...hygiene.notes]),\n  };\n  const envelope = Object.freeze(body) as unknown as SealedMemoryEnvelope;\n  SEALED_ENVELOPES.add(envelope);\n  return envelope;\n}\n\n// The runtime seal registry. The declared `sealed` unique symbol exists only\n// at the type level (compile-time fence); this WeakSet is the runtime fence.\nconst SEALED_ENVELOPES = new WeakSet<object>();\n\n/**\n * TOCTOU guard for the structural arm (#2014 round 4): a frozen object may\n * still carry ACCESSOR properties whose getters return different values on\n * each read — valid data during re-composition, forged data when the write\n * path reads the field again. Frozen DATA properties are immutable, so\n * requiring data-only descriptors (on the envelope and its array/map\n * fields) makes every later read provably identical to the validated one.\n */\nfunction hasOnlyFrozenDataProperties(value: object): boolean {\n  if (!Object.isFrozen(value)) return false;\n  // Inherited accessors are as dangerous as own ones (round 5): a frozen\n  // object can inherit a `tags` getter from a custom prototype. Composer\n  // envelopes are plain object literals and plain arrays — require exactly\n  // those prototypes so prototype-supplied getters cannot serve fields.\n  const proto = Object.getPrototypeOf(value);\n  if (Array.isArray(value)) {\n    if (proto !== Array.prototype) return false;\n  } else if (proto !== Object.prototype && proto !== null) {\n    return false;\n  }\n  for (const key of Reflect.ownKeys(value)) {\n    const descriptor = Object.getOwnPropertyDescriptor(value, key);\n    if (!descriptor || descriptor.get !== undefined || descriptor.set !== undefined) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Runtime check (belt) — the compile-time brand is the real fence.\n *\n * Fast path: WeakSet membership (same module graph). Fallback: RE-COMPOSITION\n * EQUIVALENCE — Node resolves `@remnic/core` through `dist/` for built\n * consumers and `src/` for tsx-loaded tests, and each graph gets its OWN\n * WeakSet, so identity alone would reject genuinely-sealed envelopes that\n * crossed a build boundary. The structural arm requires frozen DATA-only\n * properties (no accessors — TOCTOU guard, round 4), then re-runs the\n * STRICT composer on the candidate's own inputs and demands every envelope\n * field reproduce exactly (#2014 round 2: shape-only validation admitted\n * lookalikes with 51 tags or out-of-range confidence). A value that\n * survives has, by construction, passed every composer invariant, and its\n * fields cannot change between validation and the write that follows.\n *\n * `salvageNotes` is deliberately NOT compared: a legitimately salvage-minted\n * envelope carries notes while the strict re-composition of its (already\n * clean) surviving fields yields none. Notes are advisory provenance, not\n * identity — every load-bearing field is still verified.\n */\n\nexport function isSealedMemoryEnvelope(value: unknown): value is SealedMemoryEnvelope {\n  if (typeof value !== \"object\" || value === null) return false;\n  if (SEALED_ENVELOPES.has(value)) return true;\n  if (!hasOnlyFrozenDataProperties(value)) return false;\n  const v = value as Partial<SealedMemoryEnvelope>;\n  if (\n    typeof v.content !== \"string\" ||\n    typeof v.persistedBody !== \"string\" ||\n    typeof v.source !== \"string\" ||\n    typeof v.composedAt !== \"string\" ||\n    typeof v.category !== \"string\" ||\n    !isMemoryCategory(v.category) ||\n    !Array.isArray(v.tags) ||\n    !hasOnlyFrozenDataProperties(v.tags) ||\n    !Array.isArray(v.sanitizeViolations) ||\n    !hasOnlyFrozenDataProperties(v.sanitizeViolations) ||\n    !Array.isArray(v.salvageNotes) ||\n    !hasOnlyFrozenDataProperties(v.salvageNotes)\n  ) {\n    return false;\n  }\n  const attrs = v.rawStructuredAttributes;\n  if (\n    attrs !== undefined &&\n    (attrs === null || typeof attrs !== \"object\" || Array.isArray(attrs) || !hasOnlyFrozenDataProperties(attrs))\n  ) {\n    return false;\n  }\n  const canonicalAttrs = v.structuredAttributes;\n  if (\n    canonicalAttrs !== undefined &&\n    (canonicalAttrs === null ||\n      typeof canonicalAttrs !== \"object\" ||\n      Array.isArray(canonicalAttrs) ||\n      !hasOnlyFrozenDataProperties(canonicalAttrs))\n  ) {\n    return false;\n  }\n  let rebuilt: SealedMemoryEnvelope;\n  try {\n    rebuilt = composeMemoryEnvelope(\n      {\n        content: v.content,\n        category: v.category,\n        ...(v.tags.length > 0 ? { tags: [...(v.tags as string[])] } : {}),\n        ...(attrs !== undefined ? { structuredAttributes: { ...attrs } } : {}),\n        ...(v.entityRef !== undefined ? { entityRef: v.entityRef } : {}),\n        ...(v.confidence !== undefined ? { confidence: v.confidence } : {}),\n        ...(v.ttl !== undefined ? { ttl: v.ttl } : {}),\n        ...(v.validAt !== undefined ? { validAt: v.validAt } : {}),\n        ...(v.sourceConnector !== undefined ? { sourceConnector: v.sourceConnector } : {}),\n        ...(v.origin !== undefined ? { origin: v.origin } : {}),\n        ...(v.sourceReason !== undefined ? { sourceReason: v.sourceReason } : {}),\n      },\n      { source: v.source, now: () => new Date(v.composedAt as string) },\n    );\n  } catch {\n    // Strict re-composition rejected an input — the candidate carries a\n    // value the composer would never have minted.\n    return false;\n  }\n  const sameArray = (a: readonly string[], b: readonly string[]): boolean =>\n    a.length === b.length && a.every((entry, i) => entry === b[i]);\n  const sameMap = (\n    a: Readonly<Record<string, string>> | undefined,\n    b: Readonly<Record<string, string>> | undefined,\n  ): boolean => {\n    if (a === undefined || b === undefined) return a === b;\n    const ak = Object.keys(a);\n    const bk = Object.keys(b);\n    return ak.length === bk.length && ak.every((k) => Object.hasOwn(b, k) && a[k] === b[k]);\n  };\n  return (\n    rebuilt.content === v.content &&\n    rebuilt.persistedBody === v.persistedBody &&\n    rebuilt.category === v.category &&\n    rebuilt.source === v.source &&\n    rebuilt.composedAt === v.composedAt &&\n    rebuilt.confidence === v.confidence &&\n    rebuilt.entityRef === v.entityRef &&\n    rebuilt.ttl === v.ttl &&\n    rebuilt.validAt === v.validAt &&\n    rebuilt.sourceConnector === v.sourceConnector &&\n    rebuilt.origin === v.origin &&\n    rebuilt.sourceReason === v.sourceReason &&\n    sameArray(rebuilt.tags, v.tags as string[]) &&\n    sameArray(rebuilt.sanitizeViolations, v.sanitizeViolations as string[]) &&\n    sameMap(rebuilt.structuredAttributes, v.structuredAttributes) &&\n    sameMap(rebuilt.rawStructuredAttributes, attrs)\n  );\n}\n\n/**\n * The ONE mapping from a sealed envelope (+ extras) to the legacy\n * `writeMemory(category, content, options)` argument shape. Used by\n * `StorageManager.writeSealedMemory` AND by test doubles that stub storage —\n * so mock fidelity (AGENTS.md §21) cannot drift from production.\n */\nexport function sealedWriteToLegacyArgs(\n  envelope: SealedMemoryEnvelope,\n  extras: Record<string, unknown> = {},\n): { category: MemoryCategory; content: string; options: Record<string, unknown> } {\n  return {\n    category: envelope.category,\n    content: envelope.content,\n    options: {\n      ...extras,\n      confidence: envelope.confidence,\n      tags: envelope.tags.length > 0 ? [...envelope.tags] : undefined,\n      entityRef: envelope.entityRef,\n      source: envelope.source,\n      expiresAt: envelope.ttl,\n      validAt: envelope.validAt,\n      // RAW map for frontmatter byte-parity with the legacy path; the body\n      // suffix canonicalizes identically from either form.\n      structuredAttributes: envelope.rawStructuredAttributes\n        ? { ...envelope.rawStructuredAttributes }\n        : undefined,\n      // Unconditional (round 3): envelope-owned fields must ALWAYS overwrite\n      // extras — a conditional spread let extras.sourceConnector smuggle\n      // unvalidated connector provenance past the sealed envelope when the\n      // envelope had none.\n      sourceConnector: envelope.sourceConnector,\n      origin: envelope.origin,\n    },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Idempotency field registry\n// ---------------------------------------------------------------------------\n\n/**\n * Ordered registry of envelope fields that participate in write-idempotency\n * fingerprints. Adding a fingerprint-relevant field = one entry here; every\n * surface that builds its payload via `buildWriteIdempotencyPayload()` picks\n * it up automatically.\n */\nexport const WRITE_FINGERPRINT_FIELDS = [\n  \"content\",\n  \"category\",\n  \"tags\",\n  \"structuredAttributes\",\n  \"entityRef\",\n  \"ttl\",\n  \"validAt\",\n  \"sourceConnector\",\n] as const satisfies readonly (keyof MemoryWriteInput)[];\n\n/**\n * Envelope fields deliberately EXCLUDED from fingerprints. Exempting a field\n * is a visible, reviewable decision — this list exists so the exhaustiveness\n * guard can force every new `MemoryWriteInput` field to be classified.\n */\nexport const FINGERPRINT_EXEMPT_FIELDS = [\n  // Confidence is a scoring detail: two extractions of the same fact with\n  // slightly different confidence are the same write for dedup purposes.\n  \"confidence\",\n  // Free-text provenance note; carries no identity.\n  // Origin is provenance metadata, not write identity (#1955).\n  \"origin\",\n  \"sourceReason\",\n] as const satisfies readonly (keyof MemoryWriteInput)[];\n\n/** Scope keys always folded into the fingerprint payload. */\nexport const FINGERPRINT_SCOPE_FIELDS = [\n  \"surface\",\n  \"namespace\",\n  \"principal\",\n  \"codingContext\",\n] as const satisfies readonly (keyof FingerprintScope)[];\n\n// --- compile-time exhaustiveness guards ------------------------------------\n// A new MemoryWriteInput field that is in NEITHER list is a compile error;\n// a registry entry that names a non-existent field is a compile error; a\n// field in BOTH lists is a compile error.\n\ntype RegistryField = (typeof WRITE_FINGERPRINT_FIELDS)[number];\ntype ExemptField = (typeof FINGERPRINT_EXEMPT_FIELDS)[number];\ntype UnclassifiedField = Exclude<keyof MemoryWriteInput, RegistryField | ExemptField>;\ntype DoublyClassifiedField = RegistryField & ExemptField;\n\nconst assertEveryFieldClassified: UnclassifiedField extends never ? true : never = true;\nconst assertNoDoubleClassification: DoublyClassifiedField extends never ? true : never = true;\nvoid assertEveryFieldClassified;\nvoid assertNoDoubleClassification;\n\n// ---------------------------------------------------------------------------\n// Payload builder\n// ---------------------------------------------------------------------------\n\n/**\n * Build the canonical write-idempotency payload for a sealed envelope.\n *\n * Determinism guarantees (AGENTS.md §26):\n *   - tags are SORTED in the payload (tag order never changes identity);\n *   - structured attributes are serialized key-sorted by the existing\n *     `stableStringify` inside `hashAccessIdempotencyPayload`;\n *   - the payload shape is versioned (`v: 1`) so a future field-semantics\n *     change can migrate stored idempotency state explicitly instead of\n *     silently colliding.\n *\n * Feed the result to `hashAccessIdempotencyPayload()` — this module does\n * not hash so surfaces keep a single hashing implementation.\n */\nexport function buildWriteIdempotencyPayload(\n  envelope: SealedMemoryEnvelope,\n  scope: FingerprintScope,\n): Record<string, unknown> {\n  if (!isSealedMemoryEnvelope(envelope)) {\n    throw new Error(\n      \"buildWriteIdempotencyPayload: envelope must be minted by composeMemoryEnvelope\",\n    );\n  }\n  if (scope === null || typeof scope !== \"object\") {\n    throw new Error(\"buildWriteIdempotencyPayload: scope must be an object\");\n  }\n  if (typeof scope.surface !== \"string\" || scope.surface.trim().length === 0) {\n    throw new Error(\"buildWriteIdempotencyPayload: scope.surface must be a non-empty string\");\n  }\n\n  const fields: Record<string, unknown> = {};\n  for (const field of WRITE_FINGERPRINT_FIELDS) {\n    const value = envelope[field];\n    if (value === undefined) continue;\n    if (field === \"tags\") {\n      const tags = value as readonly string[];\n      if (tags.length === 0) continue;\n      fields.tags = [...tags].sort();\n      continue;\n    }\n    if (field === \"content\") {\n      // Fingerprints hash the PERSISTED form (attribute suffix + combined\n      // sanitize), not the raw input — one instant of stored state, one\n      // fingerprint (§13; issue #1989 PR2).\n      fields.content = envelope.persistedBody;\n      continue;\n    }\n    fields[field] = value;\n  }\n  // The write source (extraction vs wearable:bee vs observe replay, ...) is\n  // identity: the same content arriving from two different sources must not\n  // dedupe into one write (review finding on #1998). Not a MemoryWriteInput\n  // key, so it rides beside the registry fields explicitly.\n  fields.source = envelope.source;\n\n  const scopeOut: Record<string, string> = {};\n  for (const key of FINGERPRINT_SCOPE_FIELDS) {\n    const value = scope[key];\n    if (value === undefined) continue;\n    if (typeof value !== \"string\") {\n      throw new Error(`buildWriteIdempotencyPayload: scope.${key} must be a string`);\n    }\n    // Trimmed: \"ns\" and \"ns \" must not mint distinct fingerprints (review\n    // finding on #1998). Empty-after-trim optional scope values are dropped.\n    const cleanValue = value.trim();\n    if (key === \"surface\" || cleanValue.length > 0) {\n      scopeOut[key] = cleanValue;\n    }\n  }\n\n  return { v: 1, kind: \"memory-write\", fields, scope: scopeOut };\n}\n\n// ---------------------------------------------------------------------------\n// Access-surface request fingerprints (issue #1989 PR3)\n// ---------------------------------------------------------------------------\n//\n// The access surfaces (memory_store / suggestion_submit writes, their peek\n// twins, and observe) key their idempotency dedup on a hash of the RAW\n// request — computed BEFORE validation, and persisted indefinitely in\n// `AccessIdempotencyStore` (last-512 LRU, no time TTL). Those stored hashes\n// are load-bearing state: changing the payload shape would silently break\n// replay/conflict detection for every in-flight key. So these builders\n// REPRODUCE each surface's historical shape byte-for-byte (asserted by the\n// parity suite) instead of adopting the versioned envelope payload above —\n// a versioned migration of stored state is the explicit prerequisite for\n// unifying them (#1989 PR3 scope note).\n//\n// What centralizing buys even under byte-parity: one module now owns every\n// fingerprint shape, and the compile-time assertion below ties the write\n// shape to WRITE_FINGERPRINT_FIELDS — adding a fingerprint-relevant field\n// to MemoryWriteInput fails compilation here until the author decides how\n// the access surfaces represent it.\n\n/** The raw request fields the write surfaces fingerprint (legacy shape). */\nexport interface AccessWriteFingerprintParts {\n  schemaVersion: number;\n  namespace: string;\n  content: string;\n  category?: string;\n  confidence?: number;\n  tags?: string[];\n  entityRef?: string;\n  ttl?: string;\n  sourceReason?: string;\n  sourceConnector?: string;\n}\n\n// Registry coupling: every fingerprint-relevant MemoryWriteInput field must\n// either appear in AccessWriteFingerprintParts or be named in this explicit\n// exemption list. `structuredAttributes` and `validAt` are exempt because\n// the access write requests cannot express them today (ExplicitCaptureInput\n// has no such fields) — the moment they become representable, this type\n// stops compiling and forces a fingerprint decision (+ versioned state\n// migration) instead of a silent dedup gap.\ntype AccessSurfaceUnrepresentable = \"structuredAttributes\" | \"validAt\";\ntype UncoveredAccessFingerprintField = Exclude<\n  Extract<RegistryField, keyof MemoryWriteInput>,\n  keyof AccessWriteFingerprintParts | AccessSurfaceUnrepresentable\n>;\nconst assertAccessFingerprintCoversRegistry: UncoveredAccessFingerprintField extends never\n  ? true\n  : never = true;\nvoid assertAccessFingerprintCoversRegistry;\n\n/**\n * Fingerprint payload for `memory_store` / `suggestion_submit` (write AND\n * peek paths — both MUST call this so peek can never diverge from the\n * write it predicts). Key set and values reproduce the historical inline\n * literals exactly; `hashAccessIdempotencyPayload`'s stableStringify sorts\n * keys and drops `undefined`, so optional absent fields hash identically\n * to the old shape.\n */\nexport function buildAccessWriteRequestFingerprint(\n  parts: AccessWriteFingerprintParts,\n): Record<string, unknown> {\n  return {\n    schemaVersion: parts.schemaVersion,\n    content: parts.content,\n    category: parts.category,\n    confidence: parts.confidence,\n    namespace: parts.namespace,\n    tags: parts.tags,\n    entityRef: parts.entityRef,\n    ttl: parts.ttl,\n    sourceReason: parts.sourceReason,\n    sourceConnector: parts.sourceConnector,\n  };\n}\n\n/** The raw request fields the observe surface fingerprints (legacy shape). */\nexport interface ObserveFingerprintParts {\n  sessionKey: string;\n  messages: unknown;\n  namespace?: string;\n  skipExtraction?: boolean;\n  authenticatedPrincipal?: string;\n  cwd?: string;\n  projectTag?: string;\n  /** Resolved coding context — `null` (not undefined) when absent, matching the historical literal. */\n  effectiveCodingContext: unknown;\n  sourceConnector?: string;\n}\n\n/**\n * Fingerprint payload for `observe` — turn ingestion, not a memory write,\n * so it fingerprints session/message identity rather than MemoryWriteInput\n * fields. Shape reproduces the historical inline literal exactly.\n */\nexport function buildObserveRequestFingerprint(\n  parts: ObserveFingerprintParts,\n): Record<string, unknown> {\n  return {\n    sessionKey: parts.sessionKey,\n    messages: parts.messages,\n    namespace: parts.namespace,\n    skipExtraction: parts.skipExtraction,\n    authenticatedPrincipal: parts.authenticatedPrincipal,\n    cwd: parts.cwd,\n    projectTag: parts.projectTag,\n    effectiveCodingContext: parts.effectiveCodingContext,\n    sourceConnector: parts.sourceConnector,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-IQ4NVWEF.js → chunk-LYPG7GOO.js}

@@ -1,9 +1,9 @@
 import {
   StorageManager
-} from "./chunk-M4YHAODQ.js";
+} from "./chunk-BWJMBJCY.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-NSVDUN76.js";
+} from "./chunk-LCU5R6TQ.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -521,7 +521,7 @@ async function promoteSemanticRuleFromMemory(options) {
     }
     await lock.beforePromotedRuleWrite();
     const ruleEnvelope = composeMemoryEnvelope(
-      { content, category: "rule", confidence, tags: candidateBase.tags },
+      { content, category: "rule", confidence, tags: candidateBase.tags, origin: sourceMemory.frontmatter.origin },
       { source: "semantic-rule-promotion" },
       { salvage: true }
     );
@@ -546,4 +546,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-IQ4NVWEF.js.map
+//# sourceMappingURL=chunk-LYPG7GOO.js.map