@remnic/core 9.3.728 → 9.3.730

package/dist/{chunk-QNEUZIAH.js → chunk-OUITHS6V.js}

@@ -4,10 +4,13 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-4T3BMHKD.js";
+} from "./chunk-OZECYVGI.js";
+import {
+  CompressionGuidelineCoordinator
+} from "./chunk-SYX73XD7.js";
 import {
   MaintenanceScheduler
-} from "./chunk-MLKWJOAJ.js";
+} from "./chunk-CGPHMNL4.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
@@ -23,7 +26,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-4NR2PDZ5.js";
+} from "./chunk-ZVHRSR2R.js";
 import {
   SharedContextManager
 } from "./chunk-UFS7OXGL.js";
@@ -154,7 +157,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   ExtractionEngine
-} from "./chunk-I5REUWLH.js";
+} from "./chunk-NIZQH6AU.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -187,29 +190,29 @@ import {
 } from "./chunk-Q6IP2ARR.js";
 import {
   EmbeddingFallback
-} from "./chunk-C2PG7IEH.js";
+} from "./chunk-P3VJCTVE.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-YOLZS7NY.js";
-import {
-  normalizeReplaySessionKey
-} from "./chunk-2PRQG7PV.js";
+} from "./chunk-OTQE66IX.js";
 import {
   RoutingRulesStore
 } from "./chunk-WIWPSQYU.js";
+import {
+  normalizeReplaySessionKey
+} from "./chunk-2PRQG7PV.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-ASKXIAHD.js";
+} from "./chunk-WDJCZQB4.js";
 import {
   ThreadingManager
 } from "./chunk-QRDOSYOR.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-UVPL565C.js";
+} from "./chunk-IQOEW5YV.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -222,14 +225,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-CBWI22JN.js";
+} from "./chunk-KSJCXXOU.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-M4V2JVSZ.js";
+} from "./chunk-FFUCCKPN.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-3TSTGI6F.js";
+} from "./chunk-ZQUAVZNG.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-AV5ZEH4M.js";
@@ -253,10 +256,7 @@ import {
   applyCommitmentLedgerLifecycle
 } from "./chunk-LMDRGRJ2.js";
 import {
-  buildCompressionGuidelinesMarkdown,
-  computeCompressionGuidelineCandidate,
-  refineCompressionGuidelineCandidateSemantically,
-  renderCompressionGuidelinesMarkdown
+  buildCompressionGuidelinesMarkdown
 } from "./chunk-OD4FM2U7.js";
 import {
   buildConsolidationPrompt,
@@ -267,7 +267,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-DMQWV6SQ.js";
+} from "./chunk-5RZOFIDL.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -308,7 +308,7 @@ import {
   clusterByKey,
   createCorrectionService,
   detectPassiveCorrections
-} from "./chunk-AQLOP5F4.js";
+} from "./chunk-WNGXQMRI.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -333,11 +333,11 @@ import {
 } from "./chunk-J6BH2OBA.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-V4GNSDFH.js";
+} from "./chunk-KQYGNGON.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-UTHQPSRC.js";
+} from "./chunk-HHNSLPX7.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -360,12 +360,14 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-EH5ED3C6.js";
+} from "./chunk-PMAQRUN4.js";
 import {
   resolveCapabilities,
+  resolveCreationMemoryCapabilities,
   resolveGraphConstructionCapabilities,
+  resolveIndexingCapabilities,
   resolveMemoryLifecycleCapabilities
-} from "./chunk-3RCBIOOJ.js";
+} from "./chunk-ESF7TRYJ.js";
 import {
   searchCausalTrajectories
 } from "./chunk-SQNED75R.js";
@@ -378,7 +380,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-EY6MDMHK.js";
+} from "./chunk-F6OEXJQQ.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -386,7 +388,7 @@ import {
   fingerprintEntityStructuredFacts,
   normalizeAttributePairs,
   parseEntityFile
-} from "./chunk-7RLCCNHU.js";
+} from "./chunk-Q6BAA57B.js";
 import {
   buildRetiredFactTombstoneInputs
 } from "./chunk-L2B3EE7B.js";
@@ -746,6 +748,130 @@ var TierMigrationCoordinator = class {
   }
 };
 
+// src/orchestration/extraction-queue-coordinator.ts
+var ExtractionQueueCoordinator = class {
+  /**
+   * Background serial queue for extractions (agent_end optimization).
+   * Queue stores tasks that resolve when extraction should run.
+   */
+  queue = [];
+  /** Whether the serial drain loop is currently running. */
+  processing = false;
+  /** Current queue depth (idle-wait + test seam). */
+  get length() {
+    return this.queue.length;
+  }
+  /** Whether the serial drain loop is currently running (idle-wait + test seam). */
+  get isProcessing() {
+    return this.processing;
+  }
+  /**
+   * Enqueue a task and start the serial processor if it is idle. This is
+   * the production entry point — the orchestrator's `queueBufferedExtraction`
+   * builds each task closure and hands it here.
+   */
+  enqueue(task) {
+    this.queue.push(task);
+    if (!this.processing) {
+      this.processing = true;
+      this.processQueue().catch((err) => {
+        this.logExtractionQueueFailure(err, "processor");
+        this.processing = false;
+      });
+    }
+  }
+  /**
+   * Background serial queue processor.
+   * Processes extractions one at a time to avoid race conditions.
+   * Called automatically when items are queued via `enqueue`; also exposed
+   * for the characterization tests that push raw tasks and assert drain
+   * semantics directly.
+   */
+  async processQueue() {
+    while (this.queue.length > 0) {
+      const task = this.queue.shift();
+      if (task) {
+        try {
+          await task();
+        } catch (err) {
+          this.logExtractionQueueFailure(err, "task");
+        }
+      }
+    }
+    this.processing = false;
+  }
+  /**
+   * Classify + log a failure from either the per-task catch inside
+   * `processQueue()` or the outer `processQueue().catch(...)` in
+   * `enqueue()`.  Issue #549: `throwIfRecallAborted`
+   * (used throughout `runExtraction`) raises an Error whose `name` is
+   * `"AbortError"`.  That path fires when `before_reset` aborts a
+   * queued task to avoid duplicate extraction — it is intentional
+   * cancellation, not a failure.  Downgrading the log to debug
+   * prevents spurious `error`-level lines that routinely appear
+   * right next to a successful `persisted: N facts, M entities` log
+   * and that confuse operators into thinking extraction is broken.
+   * Genuine extraction failures (network, parse, I/O) still log at
+   * `error`.
+   *
+   * Source differentiates the two call sites so the log message
+   * names the right layer (`task` vs `processor`).
+   */
+  logExtractionQueueFailure(err, source) {
+    const aborted = source === "task" ? "background extraction task aborted (session transition)" : "background extraction queue processor aborted (session transition)";
+    const failed = source === "task" ? "background extraction task failed" : "background extraction queue processor failed";
+    if (isAbortError(err)) {
+      log.debug(aborted);
+    } else {
+      log.error(failed, err);
+    }
+  }
+  /**
+   * Wait until the extraction queue is fully drained (no tasks queued, no
+   * drain in flight) or `timeoutMs` elapses. Used by bootstrap (after a
+   * dry-run import) and by tests that need to assert extraction settled.
+   * Returns false on timeout, true once idle.
+   */
+  async waitForIdle(timeoutMs = 6e4) {
+    const started = Date.now();
+    while (this.processing || this.queue.length > 0) {
+      if (Date.now() - started > timeoutMs) {
+        log.warn(`waitForExtractionIdle timed out after ${timeoutMs}ms`);
+        return false;
+      }
+      const { promise, resolve } = Promise.withResolvers();
+      setTimeout(resolve, 50);
+      await promise;
+    }
+    return true;
+  }
+  // ── Test seams ─────────────────────────────────────────────────────────
+  // Mirror the pre-extraction `orchestrator.extractionQueue` /
+  // `orchestrator.queueProcessing` direct-field access the characterization
+  // and flush deadline tests relied on. Each is a thin, well-named handle
+  // onto the coordinator's private state — no behavior change.
+  /**
+   * Push a raw task WITHOUT auto-starting the processor, matching the
+   * pre-extraction `this.extractionQueue.push(...)` used by the
+   * characterization tests that drive the drain manually via `processQueue`.
+   */
+  pushRaw(task) {
+    this.queue.push(task);
+  }
+  /** Remove + return the front task (test seam for the flush deadline tests). */
+  shift() {
+    return this.queue.shift();
+  }
+  /**
+   * Force the processor-busy flag so `enqueue` does not auto-start the
+   * drain — used by the flush deadline test to simulate a busy queue and
+   * assert a queued task's deadline expires while it waits.
+   */
+  setProcessingForTest(value) {
+    this.processing = value;
+  }
+};
+
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
   return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
@@ -2468,20 +2594,6 @@ function deriveTopicsFromExtraction(result) {
 function buildCompressionGuidelinesMarkdown2(events, generatedAtIso = (/* @__PURE__ */ new Date()).toISOString()) {
   return buildCompressionGuidelinesMarkdown(events, generatedAtIso);
 }
-function formatCompressionGuidelinesForRecall(raw, maxLines = 5) {
-  if (typeof raw !== "string" || raw.trim().length === 0) return null;
-  const sectionMatch = raw.match(
-    // End the section at `\n## ` or end-of-string. Plain $ (not \s*$): the
-    // \s* branch overlapped the lazy body and backtracked polynomially
-    // (CodeQL js/polynomial-redos). Captured lines are trimmed/filtered below,
-    // so trailing whitespace handling is unchanged.
-    /## Suggested Guidelines\s*\n([\s\S]*?)(?:\n##\s+|$)/i
-  );
-  if (!sectionMatch) return null;
-  const lines = sectionMatch[1].split("\n").map((line) => line.trim()).filter((line) => line.startsWith("- ")).slice(0, Math.max(1, Math.floor(maxLines)));
-  if (lines.length === 0) return null;
-  return lines.join("\n");
-}
 function filterRecallCandidates(candidates, options) {
   const scopedByNamespace = options.namespacesEnabled ? candidates.filter(
     (r) => options.recallNamespaces.includes(options.resolveNamespace(r.path))
@@ -2918,6 +3030,7 @@ var Orchestrator = class _Orchestrator {
   handleHistory;
   tierMigrationStatus;
   tierMigrationCoordinator;
+  compressionGuidelineCoordinator;
   /**
    * In-memory X-ray snapshot from the most recent `recall()` call that
    * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
@@ -2998,10 +3111,14 @@ var Orchestrator = class _Orchestrator {
   passiveCorrectionDedup = /* @__PURE__ */ new Set();
   _passiveCorrectionService = null;
   passiveCorrectionTelemetry = { detected: 0, queued: 0, autoApplied: 0, suppressedReasonCounts: {} };
-  // Background serial queue for extractions (agent_end optimization)
-  // Queue stores promises that resolve when extraction should run
-  extractionQueue = [];
-  queueProcessing = false;
+  /**
+   * Background serial extraction queue coordinator (issue #1526 — moved
+   * from inline `extractionQueue`/`queueProcessing` fields). Owns queue
+   * state + scheduling + the serial drain + failure classification; the
+   * orchestrator builds each task closure in `queueBufferedExtraction` and
+   * hands it to `enqueue`.
+   */
+  extractionQueueCoordinator;
   heartbeatObserverChains = /* @__PURE__ */ new Map();
   recentExtractionFingerprints = /* @__PURE__ */ new Map();
   consolidationObservers = /* @__PURE__ */ new Set();
@@ -3706,6 +3823,7 @@ var Orchestrator = class _Orchestrator {
       namespaceSearchRouter: this.namespaceSearchRouter,
       namespaceCatalog: this.namespaceCatalog
     });
+    this.extractionQueueCoordinator = new ExtractionQueueCoordinator();
     const conversationIndexRuntime = createConversationIndexRuntime(config, {
       getQmd: () => this.conversationQmd,
       getFaiss: () => this.conversationFaiss
@@ -3738,6 +3856,11 @@ var Orchestrator = class _Orchestrator {
       getCompounding: () => this.compounding,
       createColdStorage: (parentDir) => new StorageManager(parentDir)
     });
+    this.compressionGuidelineCoordinator = new CompressionGuidelineCoordinator({
+      config,
+      getStorage: () => this.storage,
+      fastChatCompletion: (messages, options) => this.fastChatCompletion(messages, options)
+    });
     this.sessionObserver = new SessionObserverState({
       memoryDir: config.memoryDir,
       debounceMs: config.sessionObserverDebounceMs ?? 12e4,
@@ -4048,6 +4171,25 @@ var Orchestrator = class _Orchestrator {
         }
         await this.namespaceCatalog.registerConfiguredNamespaces().catch(() => void 0);
       }
+      try {
+        const correctionNamespaces = new Set(this.configuredNamespaceList());
+        if (this.namespaceCatalog.enabled) {
+          try {
+            for (const rec of await this.namespaceCatalog.listNamespaces()) {
+              correctionNamespaces.add(rec.namespace);
+            }
+          } catch {
+          }
+        }
+        const recovered = await this.passiveCorrectionService().recoverStaleApplyingPlans(
+          [...correctionNamespaces]
+        );
+        if (recovered > 0) {
+          log.info(`correction: recovered ${recovered} stale applying plan(s) on startup`);
+        }
+      } catch (staleErr) {
+        log.debug(`correction: stale-plan recovery skipped: ${staleErr instanceof Error ? staleErr.message : String(staleErr)}`);
+      }
       await this.relevance.load();
       await this.negatives.load();
       await this.lastRecall.load();
@@ -4253,7 +4395,7 @@ var Orchestrator = class _Orchestrator {
     }));
     await Promise.all(cacheWarmups);
     if (signal.aborted) return;
-    if (this.config.conversationIndexEnabled && this.conversationIndexBackend) {
+    if (resolveIndexingCapabilities(this.config).conversationIndex && this.conversationIndexBackend) {
       try {
         const init = await this.conversationIndexBackend.initialize();
         if (!init.enabled) {
@@ -4284,7 +4426,7 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && this.config.qmdTierMigrationEnabled) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-22LPFHD5.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-OOR57AYR.js");
         const result = await runFirstStartMigration({
           storage: this.storage,
           config: this.config,
@@ -4307,7 +4449,7 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     if (!this.wearablesAutoSyncHandle && this.config.wearables.enabled && this.config.wearables.autoSyncEnabled && Object.values(this.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-F3KCSQFJ.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-G3V5AN4C.js");
         if (signal.aborted) return;
         this.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -4814,7 +4956,7 @@ ${doc.content}` : doc.content,
           const entry = await targetStorage.snapshotForProvenance(m.path);
           if (entry) derivedFromEntries.push(entry);
         }
-        const canonicalId = await targetStorage.writeMemory(
+        const { id: canonicalId, tombstoneBlocked: canonicalBlocked } = await targetStorage.writeMemory(
           newest.frontmatter.category,
           canonicalContent,
           {
@@ -4831,6 +4973,10 @@ ${doc.content}` : doc.content,
             derivedVia: operator
           }
         );
+        if (canonicalBlocked) {
+          log.info(`[semantic-consolidation] cluster in "${cluster.category}" tombstone-blocked \u2014 keeping ${cluster.memories.length} source(s) active (pending_review ${canonicalId})`);
+          continue;
+        }
         canonicalWriteCompleted = true;
         result.memoriesConsolidated++;
         for (const m of cluster.memories) {
@@ -4847,7 +4993,7 @@ ${doc.content}` : doc.content,
             );
             try {
               await this.embeddingFallback.removeFromIndex(m.frontmatter.id);
-              if (this.config.queryAwareIndexingEnabled && m.path && m.frontmatter?.created) {
+              if (resolveIndexingCapabilities(this.config).queryAwareIndexing && m.path && m.frontmatter?.created) {
                 deindexMemory(
                   targetStorage.dir,
                   m.path,
@@ -4928,15 +5074,7 @@ ${doc.content}` : doc.content,
     return result;
   }
   async waitForExtractionIdle(timeoutMs = 6e4) {
-    const started = Date.now();
-    while (this.queueProcessing || this.extractionQueue.length > 0) {
-      if (Date.now() - started > timeoutMs) {
-        log.warn(`waitForExtractionIdle timed out after ${timeoutMs}ms`);
-        return false;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 50));
-    }
-    return true;
+    return this.extractionQueueCoordinator.waitForIdle(timeoutMs);
   }
   async waitForConsolidationIdle(timeoutMs = 6e4) {
     const started = Date.now();
@@ -5537,7 +5675,7 @@ ${r.snippet.trim()}
       ...this.conversationIndexLastUpdateAtMs.values()
     );
     const lastUpdateAt = lastUpdateAtMs > 0 ? new Date(lastUpdateAtMs).toISOString() : null;
-    if (!this.config.conversationIndexEnabled) {
+    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
       return {
         enabled: false,
         backend: this.config.conversationIndexBackend,
@@ -5566,7 +5704,7 @@ ${r.snippet.trim()}
       ...this.conversationIndexLastUpdateAtMs.values()
     );
     const lastUpdateAt = lastUpdateAtMs > 0 ? new Date(lastUpdateAtMs).toISOString() : null;
-    if (!this.config.conversationIndexEnabled) {
+    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
       return {
         enabled: false,
         backend: this.config.conversationIndexBackend,
@@ -5604,7 +5742,7 @@ ${r.snippet.trim()}
     return this.transcript.getRecoverySummary(sessionKey);
   }
   async updateConversationIndex(sessionKey, hours = 24, opts) {
-    if (!this.config.conversationIndexEnabled) {
+    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
       return { chunks: 0, skipped: true, reason: "disabled", embedded: false };
     }
     const enforceMinInterval = opts?.enforceMinInterval !== false;
@@ -5646,7 +5784,7 @@ ${r.snippet.trim()}
     return { chunks: chunks.length, skipped: false, embedded };
   }
   async rebuildConversationIndex(sessionKey, hours = 24, opts) {
-    if (!this.config.conversationIndexEnabled) {
+    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
       return {
         chunks: 0,
         skipped: true,
@@ -6083,7 +6221,7 @@ ${r.snippet.trim()}
     return scoped;
   }
   async buildQueryAwarePrefilter(prompt, recallNamespaces) {
-    if (!this.config.queryAwareIndexingEnabled || !prompt.trim()) {
+    if (!resolveIndexingCapabilities(this.config).queryAwareIndexing || !prompt.trim()) {
       return {
         candidatePaths: null,
         temporalFromDate: null,
@@ -8179,7 +8317,7 @@ ${rows.join("\n")}
       })();
       const workProductsPromise = (async () => {
         const t0 = Date.now();
-        if (!this.config.creationMemoryEnabled || !this.config.workProductRecallEnabled || !this.isRecallSectionEnabled(
+        if (!resolveCreationMemoryCapabilities(this.config).creationMemory || !this.config.workProductRecallEnabled || !this.isRecallSectionEnabled(
           "work-products",
           this.config.workProductRecallEnabled === true
         )) {
@@ -8241,7 +8379,7 @@ ${rows.join("\n")}
       })();
       const queryAwarePrefilterPromise = (async () => {
         const t0 = Date.now();
-        if (!this.config.queryAwareIndexingEnabled || !prompt.trim()) {
+        if (!resolveIndexingCapabilities(this.config).queryAwareIndexing || !prompt.trim()) {
           recordRecallSectionMetric({
             section: "queryAware",
             priority: "enrichment",
@@ -8834,7 +8972,7 @@ ${formatted}`;
       );
       const conversationRecallPromise = (async () => {
         const t0 = Date.now();
-        if (!this.config.conversationIndexEnabled || queryPolicy.skipConversationRecall || !this.isRecallSectionEnabled("conversation-recall", true)) {
+        if (!resolveIndexingCapabilities(this.config).conversationIndex || queryPolicy.skipConversationRecall || !this.isRecallSectionEnabled("conversation-recall", true)) {
           recordRecallSectionMetric({
             section: "convRecall",
             priority: "core",
@@ -11161,7 +11299,7 @@ _Context: ${topQuestion.context}_`
         settleTask(new Error("replay extraction deadline exceeded (queue_wait)"));
       }, remainingMs);
     }
-    this.extractionQueue.push(async () => {
+    this.extractionQueueCoordinator.enqueue(async () => {
       if (settled) return;
       if (typeof extractionDeadlineMs === "number" && extractionDeadlineMs <= Date.now()) {
         settleTask(new Error("replay extraction deadline exceeded (queue_wait)"));
@@ -11187,13 +11325,6 @@ _Context: ${topQuestion.context}_`
         }
       }
     });
-    if (!this.queueProcessing) {
-      this.queueProcessing = true;
-      this.processQueue().catch((err) => {
-        this.logExtractionQueueFailure(err, "processor");
-        this.queueProcessing = false;
-      });
-    }
     log.debug(`queued extraction from ${reason}`);
   }
   normalizeExtractionFingerprintTurns(turns) {
@@ -11237,50 +11368,6 @@ ${normalized}`).digest("hex");
     }
     return true;
   }
-  /**
-   * Background serial queue processor.
-   * Processes extractions one at a time to avoid race conditions.
-   * Called automatically when items are queued.
-   */
-  async processQueue() {
-    while (this.extractionQueue.length > 0) {
-      const task = this.extractionQueue.shift();
-      if (task) {
-        try {
-          await task();
-        } catch (err) {
-          this.logExtractionQueueFailure(err, "task");
-        }
-      }
-    }
-    this.queueProcessing = false;
-  }
-  /**
-   * Classify + log a failure from either the per-task catch inside
-   * `processQueue()` or the outer `processQueue().catch(...)` in
-   * `queueBufferedExtraction()`.  Issue #549: `throwIfRecallAborted`
-   * (used throughout `runExtraction`) raises an Error whose `name` is
-   * `"AbortError"`.  That path fires when `before_reset` aborts a
-   * queued task to avoid duplicate extraction — it is intentional
-   * cancellation, not a failure.  Downgrading the log to debug
-   * prevents spurious `error`-level lines that routinely appear
-   * right next to a successful `persisted: N facts, M entities` log
-   * and that confuse operators into thinking extraction is broken.
-   * Genuine extraction failures (network, parse, I/O) still log at
-   * `error`.
-   *
-   * Source differentiates the two call sites so the log message
-   * names the right layer (`task` vs `processor`).
-   */
-  logExtractionQueueFailure(err, source) {
-    const aborted = source === "task" ? "background extraction task aborted (session transition)" : "background extraction queue processor aborted (session transition)";
-    const failed = source === "task" ? "background extraction task failed" : "background extraction queue processor failed";
-    if (isAbortError(err)) {
-      log.debug(aborted);
-    } else {
-      log.error(failed, err);
-    }
-  }
   /**
    * Passive correction capture (issue #1581) — detects corrections expressed
    * passively in conversation turns and routes them to the Correction Contract
@@ -11895,6 +11982,7 @@ ${normalized}`).digest("hex");
     const profileAllowsSharedWrites = !scopeProfileWritePlan || Boolean(
       scopeProfileWritePlan.profile.readOrder.includes("serverShared") && scopeProfileWritePlan.readNamespaces.includes(this.config.sharedNamespace) && sharedProfileLayer?.readable && sharedProfileLayer.writable && sharedPromotionTarget?.authorized
     );
+    const namespacesEnabled = this.config.namespacesEnabled;
     const profileAutoPromotionAllows = (category, confidence) => {
       if (!scopeProfileWritePlan) return false;
       const actualTier = confidenceTier(confidence);
@@ -11963,7 +12051,7 @@ ${normalized}`).digest("hex");
             }
             continue;
           }
-          const promotedId = await targetStorage.writeMemory(
+          const targetPromotion = await targetStorage.writeMemory(
             options.category,
             citedContent,
             {
@@ -11989,7 +12077,8 @@ ${normalized}`).digest("hex");
               ...options.provenance ? { provenance: options.provenance } : {}
             }
           );
-          if (lifecycleCaps.temporalSupersession && options.category === "fact" && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
+          const promotedId = targetPromotion.id;
+          if (!targetPromotion.tombstoneBlocked && lifecycleCaps.temporalSupersession && options.category === "fact" && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
             try {
               await applyTemporalSupersession({
                 storage: targetStorage,
@@ -12005,19 +12094,21 @@ ${normalized}`).digest("hex");
               );
             }
           }
-          trackPersistedId(targetStorage, promotedId, { includeReturnedIds: false });
-          await this.indexPersistedMemory(targetStorage, promotedId);
-          trackBehaviorSignals(
-            targetStorage,
-            buildBehaviorSignalsForMemory({
-              memoryId: promotedId,
-              category: options.category,
-              content: options.content,
-              namespace: target.namespace,
-              confidence: options.confidence,
-              source: "extraction"
-            })
-          );
+          if (!targetPromotion.tombstoneBlocked) {
+            trackPersistedId(targetStorage, promotedId, { includeReturnedIds: false });
+            await this.indexPersistedMemory(targetStorage, promotedId);
+            trackBehaviorSignals(
+              targetStorage,
+              buildBehaviorSignalsForMemory({
+                memoryId: promotedId,
+                category: options.category,
+                content: options.content,
+                namespace: target.namespace,
+                confidence: options.confidence,
+                source: "extraction"
+              })
+            );
+          }
         } catch (err) {
           log.warn(
             `persistExtraction: ${target.target} promotion failed open for ${options.sourceMemoryId}: ${err}`
@@ -12109,7 +12200,7 @@ ${normalized}`).digest("hex");
             return;
           }
         }
-        const promotedId = await sharedStorage.writeMemory(
+        const sharedPromotion = await sharedStorage.writeMemory(
           options.category,
           citedContent,
           {
@@ -12136,7 +12227,8 @@ ${normalized}`).digest("hex");
             ...options.provenance ? { provenance: options.provenance } : {}
           }
         );
-        if (lifecycleCaps.temporalSupersession && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
+        const promotedId = sharedPromotion.id;
+        if (!sharedPromotion.tombstoneBlocked && lifecycleCaps.temporalSupersession && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
           try {
             await applyTemporalSupersession({
               storage: sharedStorage,
@@ -12152,21 +12244,23 @@ ${normalized}`).digest("hex");
             );
           }
         }
-        trackPersistedId(sharedStorage, promotedId, {
-          includeReturnedIds: false
-        });
-        await this.indexPersistedMemory(sharedStorage, promotedId);
-        trackBehaviorSignals(
-          sharedStorage,
-          buildBehaviorSignalsForMemory({
-            memoryId: promotedId,
-            category: options.category,
-            content: options.content,
-            namespace: this.config.sharedNamespace,
-            confidence: options.confidence,
-            source: "extraction"
-          })
-        );
+        if (!sharedPromotion.tombstoneBlocked) {
+          trackPersistedId(sharedStorage, promotedId, {
+            includeReturnedIds: false
+          });
+          await this.indexPersistedMemory(sharedStorage, promotedId);
+          trackBehaviorSignals(
+            sharedStorage,
+            buildBehaviorSignalsForMemory({
+              memoryId: promotedId,
+              category: options.category,
+              content: options.content,
+              namespace: this.config.sharedNamespace,
+              confidence: options.confidence,
+              source: "extraction"
+            })
+          );
+        }
       } catch (err) {
         log.warn(
           `persistExtraction: shared promotion failed open for ${options.sourceMemoryId}: ${err}`
@@ -12294,6 +12388,7 @@ ${normalized}`).digest("hex");
     const routeRules = await this.loadRoutingRules();
     const routeOptions = this.routeEngineOptions();
     const preRoutedCategories = new Array(facts.length);
+    const preRoutedNamespaceByFact = new Array(facts.length);
     if (routeRules.length > 0) {
       for (let fi = 0; fi < facts.length; fi++) {
         const f = facts[fi];
@@ -12307,6 +12402,9 @@ ${normalized}`).digest("hex");
           if (selected?.target.category) {
             preRoutedCategories[fi] = selected.target.category;
           }
+          if (selected?.target.namespace) {
+            preRoutedNamespaceByFact[fi] = selected.target.namespace;
+          }
         } catch {
         }
       }
@@ -12344,9 +12442,24 @@ ${normalized}`).digest("hex");
           )) {
             continue;
           }
-          if (preJudgeRedactionRules.length > 0) {
+          let factRedactionRules = preJudgeRedactionRules;
+          let factNs = preRoutedNamespaceByFact[fi];
+          if (!factNs && lifecycleCaps.extractionScopeClassification && namespacesEnabled && f.scope === "global" && profileAllowsSharedWrites && this.storageDirNamespace(storage.dir) !== this.config.sharedNamespace) {
+            factNs = this.config.sharedNamespace;
+          }
+          if (factNs) {
+            try {
+              const factDir = (await this.storageRouter.storageFor(factNs)).dir;
+              if (factDir !== storage.dir) {
+                const targetRules = await redactionRulesFor(factDir);
+                if (targetRules.length) factRedactionRules = [...preJudgeRedactionRules, ...targetRules];
+              }
+            } catch {
+            }
+          }
+          if (factRedactionRules.length > 0) {
             const rc = f.content + (f.structuredAttributes ? " " + JSON.stringify(f.structuredAttributes) : "") + (f.procedureSteps ? " " + f.procedureSteps.map((s) => `${s.intent} ${s.expectedOutcome ?? ""} ${s.toolCall ? `${s.toolCall.kind} ${s.toolCall.signature}` : ""}`.trim()).join(" ") : "");
-            if (contentMatchesRedactionRules(rc, preJudgeRedactionRules)) continue;
+            if (contentMatchesRedactionRules(rc, factRedactionRules)) continue;
           }
           judgeCandidates.push({
             text: f.content,
@@ -12483,7 +12596,7 @@ ${normalized}`).digest("hex");
           );
         }
       }
-      if (lifecycleCaps.extractionScopeClassification && this.config.namespacesEnabled && fact.scope === "global" && !routedNamespaceExplicit) {
+      if (lifecycleCaps.extractionScopeClassification && namespacesEnabled && fact.scope === "global" && !routedNamespaceExplicit) {
         const currentNs = this.storageDirNamespace(targetStorage.dir);
         if (currentNs !== this.config.sharedNamespace && profileAllowsSharedWrites) {
           try {
@@ -12677,9 +12790,10 @@ ${normalized}`).digest("hex");
       let supersedes;
       let links = [];
       let contradictionDetected = false;
+      let contradiction;
       if (this.config.contradictionDetectionEnabled && this.qmd.isAvailable() && faithfulnessEnforceStatus !== "pending_review") {
         const targetNamespace = this.storageDirNamespace(targetStorage.dir);
-        const contradiction = await this.checkForContradiction(
+        contradiction = await this.checkForContradiction(
           fact.content,
           writeCategory,
           targetNamespace
@@ -12695,14 +12809,6 @@ ${normalized}`).digest("hex");
             strength: contradiction.confidence,
             reason: contradiction.reason
           });
-          if (this.config.contradictionAutoResolve && this.config.queryAwareIndexingEnabled && contradiction.supersededPath) {
-            deindexMemory(
-              this.config.memoryDir,
-              contradiction.supersededPath,
-              contradiction.supersededCreated,
-              contradiction.supersededTags
-            );
-          }
         }
       }
       const isCorrection = writeCategory === "correction";
@@ -12742,7 +12848,7 @@ ${normalized}`).digest("hex");
           const memoryKind2 = this.config.episodeNoteModeEnabled ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory) : void 0;
           const rawChunkedContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
           const citedChunkedContent = applyInlineCitation(rawChunkedContent);
-          const parentId = await targetStorage.writeMemory(
+          const parentWrite = await targetStorage.writeMemory(
             writeCategory,
             citedChunkedContent,
             {
@@ -12769,6 +12875,15 @@ ${normalized}`).digest("hex");
               ...fact.provenance ? { provenance: fact.provenance } : {}
             }
           );
+          const parentId = parentWrite.id;
+          const tombstoneBlocked2 = parentWrite.tombstoneBlocked;
+          const postWriteGuard2 = faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked2;
+          await this.applyDeferredContradictionResolve(
+            contradiction,
+            targetStorage,
+            parentId,
+            postWriteGuard2
+          );
           try {
             for (const chunk of chunkResult.chunks) {
               const chunkImportance = scoreImportance(
@@ -12806,7 +12921,9 @@ ${normalized}`).digest("hex");
                   // fact's verdict + enforce status so a pending_review fact
                   // is not indexed as active through its chunks (chatgpt P2).
                   ...faithfulnessFm ? { faithfulness: faithfulnessFm } : {},
-                  ...faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {},
+                  // #1645 (OchiE): inherit pending_review + blockedBy so no chunk lands active.
+                  ...postWriteGuard2 ? { status: "pending_review" } : faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {},
+                  ...tombstoneBlocked2 && parentWrite.blockedBy ? { blockedBy: parentWrite.blockedBy } : {},
                   // Claim-level provenance (issue #1575 PR 2): mirror the
                   // parent's spans onto each chunk so a chunk surfaced
                   // independently (memory_get/x-ray on a chunk ID) preserves
@@ -12827,13 +12944,15 @@ ${normalized}`).digest("hex");
             `chunked memory ${parentId} into ${chunkResult.chunks.length} chunks`
           );
           trackPersistedId(targetStorage, parentId, {
-            pendingReview: faithfulnessEnforceStatus === "pending_review"
+            pendingReview: postWriteGuard2
           });
-          if (faithfulnessEnforceStatus !== "pending_review" && threadEpisodeIdsForGraph && !threadEpisodeIdsForGraph.includes(parentId)) {
+          if (!postWriteGuard2 && threadEpisodeIdsForGraph && !threadEpisodeIdsForGraph.includes(parentId)) {
             threadEpisodeIdsForGraph.push(parentId);
           }
-          await this.indexPersistedMemory(targetStorage, parentId);
-          if (faithfulnessEnforceStatus !== "pending_review") {
+          if (!postWriteGuard2) {
+            await this.indexPersistedMemory(targetStorage, parentId);
+          }
+          if (!postWriteGuard2) {
             try {
               const supersessionEntityRef = typeof fact.entityRef === "string" ? fact.entityRef : void 0;
               await applyTemporalSupersession({
@@ -12851,7 +12970,7 @@ ${normalized}`).digest("hex");
               log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
             }
           }
-          if (faithfulnessEnforceStatus !== "pending_review") await promoteMemoryToShared({
+          if (!postWriteGuard2) await promoteMemoryToShared({
             sourceStorage: targetStorage,
             category: writeCategory,
             content: fact.content,
@@ -12877,7 +12996,9 @@ ${normalized}`).digest("hex");
           });
           try {
             const canonicalChunkedContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
-            await this.addContentHashDedup(targetStorage, canonicalChunkedContent);
+            if (!tombstoneBlocked2) {
+              await this.addContentHashDedup(targetStorage, canonicalChunkedContent);
+            }
           } catch (err) {
             log.warn(
               `content-hash dedup registration failed for chunked memory ${parentId}: ${err}`
@@ -12885,10 +13006,12 @@ ${normalized}`).digest("hex");
           }
           for (const chunk of chunkResult.chunks) {
             const chunkId = `${parentId}-chunk-${chunk.index}`;
-            await this.indexPersistedMemory(targetStorage, chunkId);
+            if (!postWriteGuard2) {
+              await this.indexPersistedMemory(targetStorage, chunkId);
+            }
           }
           try {
-            if (this.config.verbatimArtifactsEnabled && this.config.verbatimArtifactCategories.includes(writeCategory) && fact.confidence >= this.config.verbatimArtifactsMinConfidence && faithfulnessEnforceStatus !== "pending_review") {
+            if (this.config.verbatimArtifactsEnabled && this.config.verbatimArtifactCategories.includes(writeCategory) && fact.confidence >= this.config.verbatimArtifactsMinConfidence && !postWriteGuard2) {
               await targetStorage.writeArtifact(citedChunkedContent, {
                 confidence: fact.confidence,
                 tags: [...fact.tags, "artifact", "chunked-parent"],
@@ -12899,7 +13022,7 @@ ${normalized}`).digest("hex");
                 intentEntityTypes: inferredIntent?.entityTypes
               });
             }
-            if (graphCaps.multiGraphMemory && faithfulnessEnforceStatus !== "pending_review") {
+            if (graphCaps.multiGraphMemory && !postWriteGuard2) {
               try {
                 const graphContext = await ensureGraphContext(targetStorage);
                 const entityRef = typeof fact.entityRef === "string" ? fact.entityRef : void 0;
@@ -12965,7 +13088,7 @@ ${normalized}`).digest("hex");
       const memoryKind = writeCategory === "procedure" ? void 0 : this.config.episodeNoteModeEnabled ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory) : void 0;
       const rawPersistBody = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : fact.content;
       const citedFactContent = applyInlineCitation(rawPersistBody);
-      const memoryId = await targetStorage.writeMemory(
+      const factWrite = await targetStorage.writeMemory(
         writeCategory,
         citedFactContent,
         {
@@ -12994,12 +13117,21 @@ ${normalized}`).digest("hex");
           ...fact.provenance ? { provenance: fact.provenance } : {}
         }
       );
+      const memoryId = factWrite.id;
+      const tombstoneBlocked = factWrite.tombstoneBlocked;
+      const postWriteGuard = faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked;
+      await this.applyDeferredContradictionResolve(
+        contradiction,
+        targetStorage,
+        memoryId,
+        postWriteGuard
+      );
       if (routedRuleId) {
         log.debug(
           `routing applied for memory ${memoryId}: rule=${routedRuleId} category=${writeCategory} storage=${targetStorage.dir}`
         );
       }
-      if (faithfulnessEnforceStatus !== "pending_review") {
+      if (!postWriteGuard) {
         try {
           const supersessionEntityRef = typeof fact.entityRef === "string" ? fact.entityRef : void 0;
           await applyTemporalSupersession({
@@ -13027,13 +13159,15 @@ ${normalized}`).digest("hex");
           })
         );
         trackPersistedId(targetStorage, memoryId, {
-          pendingReview: faithfulnessEnforceStatus === "pending_review"
+          pendingReview: postWriteGuard
         });
-        if (faithfulnessEnforceStatus !== "pending_review" && threadEpisodeIdsForGraph && !threadEpisodeIdsForGraph.includes(memoryId)) {
+        if (!postWriteGuard && threadEpisodeIdsForGraph && !threadEpisodeIdsForGraph.includes(memoryId)) {
           threadEpisodeIdsForGraph.push(memoryId);
         }
-        await this.indexPersistedMemory(targetStorage, memoryId);
-        if (faithfulnessEnforceStatus !== "pending_review") await promoteMemoryToShared({
+        if (!postWriteGuard) {
+          await this.indexPersistedMemory(targetStorage, memoryId);
+        }
+        if (!postWriteGuard) await promoteMemoryToShared({
           sourceStorage: targetStorage,
           category: writeCategory,
           content: fact.content,
@@ -13057,7 +13191,7 @@ ${normalized}`).digest("hex");
           ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
           ...fact.provenance ? { provenance: fact.provenance } : {}
         });
-        if (graphCaps.multiGraphMemory && faithfulnessEnforceStatus !== "pending_review") {
+        if (graphCaps.multiGraphMemory && !postWriteGuard) {
           try {
             const graphContext = await ensureGraphContext(targetStorage);
             const entityRef = typeof fact.entityRef === "string" ? fact.entityRef : void 0;
@@ -13093,7 +13227,7 @@ ${normalized}`).digest("hex");
           } catch {
           }
         }
-        if (this.config.verbatimArtifactsEnabled && this.config.verbatimArtifactCategories.includes(writeCategory) && fact.confidence >= this.config.verbatimArtifactsMinConfidence && faithfulnessEnforceStatus !== "pending_review") {
+        if (this.config.verbatimArtifactsEnabled && this.config.verbatimArtifactCategories.includes(writeCategory) && fact.confidence >= this.config.verbatimArtifactsMinConfidence && !postWriteGuard) {
           await targetStorage.writeArtifact(citedFactContent, {
             confidence: fact.confidence,
             tags: [...fact.tags, "artifact"],
@@ -13107,7 +13241,9 @@ ${normalized}`).digest("hex");
         try {
           const canonicalFactContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
           const hashRegisterKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalFactContent;
-          await this.addContentHashDedup(targetStorage, hashRegisterKey);
+          if (!tombstoneBlocked) {
+            await this.addContentHashDedup(targetStorage, hashRegisterKey);
+          }
         } catch (err) {
           log.warn(
             `content-hash dedup registration failed for memory ${memoryId}: ${err}`
@@ -13344,7 +13480,7 @@ ${normalized}`).digest("hex");
    */
   async updateTemporalTagIndexes(storage, persistedIds) {
     const caps = resolveCapabilities(this.config);
-    if (!this.config.queryAwareIndexingEnabled && !caps.parallelRetrieval)
+    if (!resolveIndexingCapabilities(this.config).queryAwareIndexing && !caps.parallelRetrieval)
       return;
     const needsFullRebuild = !indexesExist(this.config.memoryDir);
     if (!needsFullRebuild && persistedIds.length === 0) return;
@@ -13410,11 +13546,11 @@ ${normalized}`).digest("hex");
     );
     const profile = await this.storage.readProfile();
     const result = await this.extraction.consolidate(recent, older, profile);
-    const memoryLookup = this.config.queryAwareIndexingEnabled ? new Map(allMemories.map((m) => [m.frontmatter.id, m])) : null;
+    const memoryLookup = resolveIndexingCapabilities(this.config).queryAwareIndexing ? new Map(allMemories.map((m) => [m.frontmatter.id, m])) : null;
     for (const item of result.items) {
       switch (item.action) {
         case "INVALIDATE": {
-          const toInvalidate = this.config.queryAwareIndexingEnabled ? memoryLookup?.get(item.existingId) ?? null : null;
+          const toInvalidate = resolveIndexingCapabilities(this.config).queryAwareIndexing ? memoryLookup?.get(item.existingId) ?? null : null;
           if (await this.storage.invalidateMemory(item.existingId)) {
             invalidated += 1;
             memoryItemMutated = true;
@@ -13455,7 +13591,7 @@ ${normalized}`).digest("hex");
             );
             memoryItemMutated = true;
             await this.indexPersistedMemory(this.storage, item.existingId);
-            const toMergeInvalidate = this.config.queryAwareIndexingEnabled ? memoryLookup?.get(item.mergeWith) ?? null : null;
+            const toMergeInvalidate = resolveIndexingCapabilities(this.config).queryAwareIndexing ? memoryLookup?.get(item.mergeWith) ?? null : null;
             if (await this.storage.invalidateMemory(item.mergeWith)) {
               invalidated += 1;
               merged += 1;
@@ -13511,7 +13647,7 @@ ${normalized}`).digest("hex");
     if (deletedCommitments.length > 0) {
       memoryItemMutated = true;
       log.info(`cleaned ${deletedCommitments.length} expired commitments`);
-      if (this.config.queryAwareIndexingEnabled) {
+      if (resolveIndexingCapabilities(this.config).queryAwareIndexing) {
         for (const m of deletedCommitments) {
           deindexMemory(
             this.config.memoryDir,
@@ -13522,7 +13658,7 @@ ${normalized}`).digest("hex");
         }
       }
     }
-    if (this.config.creationMemoryEnabled && this.config.commitmentLedgerEnabled && this.config.commitmentLifecycleEnabled) {
+    if (resolveCreationMemoryCapabilities(this.config).creationMemory && resolveCreationMemoryCapabilities(this.config).commitmentLedger && resolveCreationMemoryCapabilities(this.config).commitmentLifecycle) {
       try {
         const lifecycle = await applyCommitmentLedgerLifecycle({
           memoryDir: this.config.memoryDir,
@@ -13544,7 +13680,7 @@ ${normalized}`).digest("hex");
     if (deletedTTL.length > 0) {
       memoryItemMutated = true;
       log.info(`cleaned ${deletedTTL.length} TTL-expired memories`);
-      if (this.config.queryAwareIndexingEnabled) {
+      if (resolveIndexingCapabilities(this.config).queryAwareIndexing) {
         for (const m of deletedTTL) {
           deindexMemory(
             this.config.memoryDir,
@@ -13769,242 +13905,19 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
     return { memoriesProcessed: allMemories.length, merged, invalidated };
   }
   async optimizeCompressionGuidelines(options) {
-    const dryRun = options?.dryRun === true;
-    const eventLimit = typeof options?.eventLimit === "number" ? Math.max(0, Math.floor(options.eventLimit)) : 500;
-    const [activeState, draftState] = await Promise.all([
-      this.storage.readCompressionGuidelineOptimizerState(),
-      this.storage.readCompressionGuidelineDraftState().catch(() => null)
-    ]);
-    const previousState = draftState && ((activeState?.guidelineVersion ?? 0) < draftState.guidelineVersion || (activeState?.guidelineVersion ?? 0) === draftState.guidelineVersion) ? draftState : activeState;
-    if (!this.config.compressionGuidelineLearningEnabled) {
-      return {
-        enabled: false,
-        dryRun,
-        eventCount: 0,
-        previousGuidelineVersion: previousState?.guidelineVersion ?? null,
-        nextGuidelineVersion: previousState?.guidelineVersion ?? 0,
-        changedRules: 0,
-        semanticRefinementApplied: false,
-        persisted: false,
-        draftContentHash: null
-      };
-    }
-    let events = await this.storage.readMemoryActionEvents(eventLimit);
-    if (eventLimit > 0) {
-      let effectiveEvents = events.filter((event) => event.dryRun !== true);
-      let fetchLimit = eventLimit;
-      while (effectiveEvents.length < eventLimit && events.length === fetchLimit) {
-        fetchLimit = Math.min(fetchLimit * 2, fetchLimit + 1e3);
-        if (fetchLimit <= events.length) break;
-        events = await this.storage.readMemoryActionEvents(fetchLimit);
-        effectiveEvents = events.filter((event) => event.dryRun !== true);
-      }
-      events = effectiveEvents.slice(-eventLimit);
-    }
-    const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const candidate = computeCompressionGuidelineCandidate(events, {
-      generatedAtIso: generatedAt,
-      previousState
-    });
-    if (candidate.eventCounts.total === 0) {
-      return {
-        enabled: true,
-        dryRun,
-        eventCount: 0,
-        previousGuidelineVersion: previousState?.guidelineVersion ?? null,
-        nextGuidelineVersion: previousState?.guidelineVersion ?? 0,
-        changedRules: 0,
-        semanticRefinementApplied: false,
-        persisted: false,
-        draftContentHash: null
-      };
-    }
-    const refinedCandidate = await refineCompressionGuidelineCandidateSemantically(candidate, {
-      enabled: this.config.compressionGuidelineSemanticRefinementEnabled,
-      timeoutMs: this.config.compressionGuidelineSemanticTimeoutMs,
-      runRefinement: async (baseline) => {
-        const prompt = [
-          "You refine compression policy suggestions conservatively.",
-          "Return JSON only in this shape:",
-          '{"updates":[{"action":"summarize_node","delta":0.02,"confidence":"medium","note":"..."}]}',
-          "Constraints:",
-          "- Keep updates sparse and conservative.",
-          "- delta must stay between -0.15 and 0.15.",
-          "- Only include actions present in the input.",
-          "Input candidate:",
-          JSON.stringify(baseline)
-        ].join("\n");
-        const response = await this.fastChatCompletion(
-          [
-            {
-              role: "system",
-              content: "Respond with strict JSON only. No markdown."
-            },
-            { role: "user", content: prompt }
-          ],
-          {
-            temperature: 0.1,
-            maxTokens: 400,
-            operation: "compression_guideline_semantic_refinement",
-            priority: "background"
-          }
-        );
-        return this.parseCompressionSemanticRefinement(
-          response?.content ?? ""
-        );
-      }
-    });
-    const content = renderCompressionGuidelinesMarkdown(refinedCandidate);
-    const contentHash = createHash("sha256").update(content).digest("hex");
-    const semanticRefinementApplied = JSON.stringify(refinedCandidate.ruleUpdates) !== JSON.stringify(candidate.ruleUpdates);
-    const changedRules = refinedCandidate.ruleUpdates.filter(
-      (rule) => rule.delta !== 0
-    ).length;
-    if (!dryRun) {
-      await this.storage.writeCompressionGuidelineDraft(content);
-      await this.storage.writeCompressionGuidelineDraftState({
-        version: refinedCandidate.optimizerVersion,
-        updatedAt: refinedCandidate.generatedAt,
-        sourceWindow: refinedCandidate.sourceWindow,
-        eventCounts: refinedCandidate.eventCounts,
-        guidelineVersion: refinedCandidate.guidelineVersion,
-        contentHash,
-        activationState: "draft",
-        actionSummaries: refinedCandidate.actionSummaries,
-        ruleUpdates: refinedCandidate.ruleUpdates
-      });
-    }
-    return {
-      enabled: true,
-      dryRun,
-      eventCount: candidate.eventCounts.total,
-      previousGuidelineVersion: previousState?.guidelineVersion ?? null,
-      nextGuidelineVersion: refinedCandidate.guidelineVersion,
-      changedRules,
-      semanticRefinementApplied,
-      persisted: !dryRun,
-      draftContentHash: dryRun ? null : contentHash
-    };
+    return this.compressionGuidelineCoordinator.optimizeCompressionGuidelines(options);
   }
   async activateCompressionGuidelineDraft(options) {
-    if (!this.config.compressionGuidelineLearningEnabled) {
-      return {
-        enabled: false,
-        activated: false,
-        guidelineVersion: null,
-        reason: "disabled"
-      };
-    }
-    const draftState = await this.storage.readCompressionGuidelineDraftState();
-    if (!draftState) {
-      return {
-        enabled: true,
-        activated: false,
-        guidelineVersion: null,
-        reason: "missing_draft"
-      };
-    }
-    const expectedContentHash = options?.expectedContentHash?.trim();
-    const expectedGuidelineVersion = options?.expectedGuidelineVersion;
-    if ((!expectedContentHash || expectedContentHash.length === 0) && typeof expectedGuidelineVersion !== "number") {
-      return {
-        enabled: true,
-        activated: false,
-        guidelineVersion: null,
-        reason: "expected_revision_required"
-      };
-    }
-    if (expectedContentHash && draftState.contentHash !== expectedContentHash) {
-      return {
-        enabled: true,
-        activated: false,
-        guidelineVersion: null,
-        reason: "content_hash_mismatch"
-      };
-    }
-    if (typeof expectedGuidelineVersion === "number" && draftState.guidelineVersion !== expectedGuidelineVersion) {
-      return {
-        enabled: true,
-        activated: false,
-        guidelineVersion: null,
-        reason: "guideline_version_mismatch"
-      };
-    }
-    const activated = await this.storage.activateCompressionGuidelineDraft({
-      ...expectedContentHash ? { expectedContentHash } : {},
-      ...typeof expectedGuidelineVersion === "number" ? { expectedGuidelineVersion } : {}
-    });
-    return {
-      enabled: true,
-      activated,
-      guidelineVersion: activated ? draftState.guidelineVersion : null,
-      ...activated ? {} : { reason: "draft_changed" }
-    };
+    return this.compressionGuidelineCoordinator.activateCompressionGuidelineDraft(options);
   }
+  // Issue #1526 (seam 4): compression-guideline learning moved to
+  // CompressionGuidelineCoordinator. Thin delegation keeps the
+  // consolidation-loop hook + recall-section hook call sites stable.
   async runCompressionGuidelineLearningPass() {
-    if (!this.config.compressionGuidelineLearningEnabled) return;
-    try {
-      const result = await this.optimizeCompressionGuidelines({
-        dryRun: false,
-        eventLimit: 500
-      });
-      log.info(
-        `compression guideline learning updated (${result.eventCount} events)`
-      );
-    } catch (err) {
-      log.warn(`compression guideline learning failed (ignored): ${err}`);
-    }
+    return this.compressionGuidelineCoordinator.runCompressionGuidelineLearningPass();
   }
   async buildCompressionGuidelineRecallSection() {
-    if (!this.config.contextCompressionActionsEnabled) return null;
-    if (!this.config.compressionGuidelineLearningEnabled) return null;
-    const state = await this.storage.readCompressionGuidelineOptimizerState().catch(() => null);
-    if (!state || state.guidelineVersion <= 0) return null;
-    const raw = await this.storage.readCompressionGuidelines().catch(() => null);
-    const summary = raw ? formatCompressionGuidelinesForRecall(raw, 5) : null;
-    if (!summary) return null;
-    return [
-      "## Active Compression Guidelines",
-      "",
-      `Guideline version: ${state.guidelineVersion}`,
-      `Updated: ${state.updatedAt}`,
-      "",
-      summary
-    ].join("\n");
-  }
-  parseCompressionSemanticRefinement(raw) {
-    if (typeof raw !== "string" || raw.trim().length === 0) return null;
-    const trimmed = raw.trim();
-    const start = trimmed.indexOf("{");
-    const end = trimmed.lastIndexOf("}");
-    if (start === -1 || end === -1 || end <= start) return null;
-    try {
-      const parsed = JSON.parse(trimmed.slice(start, end + 1));
-      if (!Array.isArray(parsed?.updates)) return null;
-      const validActions = /* @__PURE__ */ new Set([
-        "store_episode",
-        "store_note",
-        "update_note",
-        "create_artifact",
-        "summarize_node",
-        "discard",
-        "link_graph"
-      ]);
-      const updates = parsed.updates.filter(
-        (item) => item && typeof item.action === "string" && validActions.has(item.action)
-      ).map((item) => {
-        const confidence = item.confidence === "low" || item.confidence === "medium" || item.confidence === "high" ? item.confidence : void 0;
-        return {
-          action: item.action,
-          delta: typeof item.delta === "number" && Number.isFinite(item.delta) ? item.delta : void 0,
-          confidence,
-          note: typeof item.note === "string" ? item.note : void 0
-        };
-      });
-      return { updates };
-    } catch {
-      return null;
-    }
+    return this.compressionGuidelineCoordinator.buildCompressionGuidelineRecallSection();
   }
   actionOutcomePriorDelta(event) {
     if (event.outcome === "failed") return -0.3;
@@ -14198,7 +14111,7 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
           "fact-archival"
         );
         await this.embeddingFallback.removeFromIndex(memory.frontmatter.id);
-        if (this.config.queryAwareIndexingEnabled && memory.path && memory.frontmatter?.created) {
+        if (resolveIndexingCapabilities(this.config).queryAwareIndexing && memory.path && memory.frontmatter?.created) {
           deindexMemory(
             this.config.memoryDir,
             memory.path,
@@ -15868,7 +15781,7 @@ ${lines.join("\n\n")}`;
     );
     let temporalFromDate = null;
     let promptTags = [];
-    if (this.config.queryAwareIndexingEnabled && prompt) {
+    if (resolveIndexingCapabilities(this.config).queryAwareIndexing && prompt) {
       if (isTemporalQuery(prompt)) {
         temporalFromDate = recencyWindowFromPrompt(prompt, now);
       }
@@ -15881,7 +15794,7 @@ ${lines.join("\n\n")}`;
     const queryIntent = this.config.intentRoutingEnabled && prompt ? inferIntentFromText(prompt) : null;
     let temporalCandidates = null;
     let tagCandidates = null;
-    if (this.config.queryAwareIndexingEnabled && prompt) {
+    if (resolveIndexingCapabilities(this.config).queryAwareIndexing && prompt) {
       const maxCandidates = this.config.queryAwareIndexingMaxCandidates;
       const capSet = (s) => {
         if (!s) return null;
@@ -15967,7 +15880,7 @@ ${lines.join("\n\n")}`;
             "boost"
           );
         }
-        if (this.config.queryAwareIndexingEnabled && r.path) {
+        if (resolveIndexingCapabilities(this.config).queryAwareIndexing && r.path) {
           if (temporalCandidates?.has(r.path)) {
             score += applyUtilityRankingRuntimeDelta(
               0.08,
@@ -16126,14 +16039,6 @@ ${lines.join("\n\n")}`;
           );
           continue;
         }
-        if (this.config.contradictionAutoResolve) {
-          await resultStorage.supersedeMemory(
-            existingMemory.frontmatter.id,
-            "pending-new",
-            // Will be updated after the new memory is written
-            verification.reasoning
-          );
-        }
         log.info(
           `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory${this.config.contradictionAutoResolve ? " (auto-resolved)" : " (queued for manual review)"}`
         );
@@ -16149,6 +16054,50 @@ ${lines.join("\n\n")}`;
     }
     return null;
   }
+  /**
+   * #1645: Complete the deferred contradiction auto-resolve after writeMemory
+   * returns and the new write's tombstone status is known. Retires the old
+   * memory + deindexes it ONLY when the new write is genuinely active (not
+   * tombstone-blocked / pending_review). A blocked write must not retire the
+   * only active copy — deferring here closes the "contradictionAutoResolve
+   * supersedes before tombstone status is known" defect class.
+   */
+  async applyDeferredContradictionResolve(contradiction, storage, newMemoryId, postWriteGuard) {
+    if (postWriteGuard && contradiction && this.config.contradictionAutoResolve) {
+      try {
+        const blockedRow = await storage.getMemoryById(newMemoryId);
+        if (blockedRow?.frontmatter?.supersedes) {
+          await storage.writeMemoryFrontmatter(blockedRow, { supersedes: void 0 });
+        }
+      } catch (err) {
+        log.warn(
+          `contradiction auto-resolve supersedes clear failed for blocked ${newMemoryId}: ${err}`
+        );
+      }
+    }
+    if (!contradiction || !this.config.contradictionAutoResolve || postWriteGuard) {
+      return;
+    }
+    try {
+      await storage.supersedeMemory(
+        contradiction.supersededId,
+        newMemoryId,
+        contradiction.reason
+      );
+      if (resolveIndexingCapabilities(this.config).queryAwareIndexing && contradiction.supersededPath) {
+        deindexMemory(
+          this.config.memoryDir,
+          contradiction.supersededPath,
+          contradiction.supersededCreated,
+          contradiction.supersededTags
+        );
+      }
+    } catch (err) {
+      log.warn(
+        `contradiction auto-resolve supersede failed for ${contradiction.supersededId}: ${err}`
+      );
+    }
+  }
   // ---------------------------------------------------------------------------
   // Memory Linking (Phase 3A)
   // ---------------------------------------------------------------------------
@@ -16299,7 +16248,6 @@ export {
   isArtifactMemoryPath,
   deriveTopicsFromExtraction,
   buildCompressionGuidelinesMarkdown2 as buildCompressionGuidelinesMarkdown,
-  formatCompressionGuidelinesForRecall,
   filterRecallCandidates,
   shouldFilterLifecycleRecallCandidate,
   lifecycleRecallScoreAdjustment,
@@ -16322,4 +16270,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-QNEUZIAH.js.map
+//# sourceMappingURL=chunk-OUITHS6V.js.map