@remnic/core 9.3.744 → 9.3.746

package/src/orchestrator.ts

@@ -81,7 +81,6 @@ import { NoopSearchBackend } from "./search/noop-backend.js";
 import {
   StorageManager,
   ContentHashIndex,
-  normalizeAttributePairs,
 } from "./storage.js";
 import { sanitizeMemoryContent } from "./sanitize.js";
 import { ThreadingManager } from "./threading.js";
@@ -107,6 +106,9 @@ import { RecallRerankCoordinator } from "./orchestration/recall-rerank-coordinat
 import { RecallSectionCoordinator } from "./orchestration/recall-section-coordinator.js";
 import { QmdResultResolver, qmdCollectionPathParts, qmdResultPathCandidates } from "./orchestration/qmd-result-resolver.js";
 import { ContradictionLinkingCoordinator } from "./orchestration/contradiction-linking-coordinator.js";
+import { ExtractionRunCoordinator, type ExtractionRunResult } from "./orchestration/extraction-run.js";
+import { ConsolidationRunCoordinator } from "./orchestration/consolidation-run.js";
+import { ExtractionPersistCoordinator } from "./orchestration/extraction-persist.js";
 export { hasIdentityRecoveryIntent, resolveEffectiveIdentityInjectionMode } from "./orchestration/recall-result-formatter.js";
 import {
   GraphRecallCoordinator,
@@ -489,13 +491,8 @@ export class BulkImportBatchPartialFailureError extends Error {
   }
 }
 
-interface ExtractionRunResult {
-  status: "completed" | "skipped";
-  reason?: string;
-  persistedCount: number;
-  durableOutputCount: number;
-  postPersistMetadataFailed?: boolean;
-}
+// Issue #1526 seam 15: ExtractionRunResult moved to orchestration/extraction-run.ts.
+export type { ExtractionRunResult } from "./orchestration/extraction-run.js";
 
 export interface GraphRecallSnapshot {
   recordedAt: string;
@@ -914,20 +911,6 @@ export function sanitizeSessionKeyForFilename(sessionKey: string): string {
   return `${readable}-${hash}`;
 }
 
-function latestSourceValidAtFromTurns(turns: readonly BufferTurn[]): string | undefined {
-  let latestMs: number | null = null;
-  for (const turn of turns) {
-    if (turn.extractionContextOnly === true) continue;
-    if (typeof turn.sourceValidAt !== "string") continue;
-    const parsed = parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
-    if (parsed === null) continue;
-    if (latestMs === null || parsed > latestMs) {
-      latestMs = parsed;
-    }
-  }
-  return latestMs === null ? undefined : new Date(latestMs).toISOString();
-}
-
 function sourceValidAtMs(turn: BufferTurn): number | null {
   if (typeof turn.sourceValidAt !== "string") return null;
   return parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
@@ -1044,24 +1027,8 @@ function splitTurnsBySourceValidAt(
 export function isArtifactMemoryPath(filePath: string): boolean {
   return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(filePath);
 }
-
-export function deriveTopicsFromExtraction(result: ExtractionResult): string[] {
-  const topics = new Set<string>();
-  for (const fact of result.facts ?? []) {
-    for (const tag of fact.tags ?? []) {
-      if (tag && tag.length >= 2) topics.add(tag.toLowerCase());
-    }
-    if (fact.entityRef) topics.add(fact.entityRef.toLowerCase());
-    if (fact.category) topics.add(fact.category);
-  }
-  for (const entity of (result as any).entities ?? []) {
-    if (typeof entity.name === "string" && entity.name.length >= 2) {
-      topics.add(entity.name.toLowerCase());
-    }
-  }
-  return [...topics].slice(0, 16);
-}
-
+// Issue #1526 seam 15: deriveTopicsFromExtraction moved to orchestration/extraction-run.ts.
+export { deriveTopicsFromExtraction } from "./orchestration/extraction-run.js";
 export function buildCompressionGuidelinesMarkdown(
   events: MemoryActionEvent[],
   generatedAtIso: string = new Date().toISOString(),
@@ -1769,6 +1736,128 @@ export class Orchestrator {
    * hands it to `enqueue`.
    */
   readonly extractionQueueCoordinator: ExtractionQueueCoordinator;
+  /**
+   * Extraction-run pipeline coordinator (issue #1526 seam 15). Owns
+   * `runExtraction` + dedupe fingerprint helpers + processed-fingerprint
+   * recording. The orchestrator delegates and injects its own methods.
+   */
+  private _extractionRunCoordinator: ExtractionRunCoordinator | undefined;
+
+  /**
+   * Lazy getter: creates the ExtractionRunCoordinator on first access using
+   * the orchestrator's live field references. Supports Object.create(prototype)
+   * tests that set fields post-construction without invoking the constructor.
+   */
+  private get extractionRunCoordinator(): ExtractionRunCoordinator {
+    if (!this._extractionRunCoordinator) {
+      this._extractionRunCoordinator = new ExtractionRunCoordinator({
+        config: this.config,
+        getBuffer: () => this.buffer,
+        getExtraction: () => this.extraction,
+        getStorageRouter: () => this.storageRouter,
+        getThreading: () => this.threading,
+        persistExtraction: (result, storage, threadId, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps, lifecycleCaps) =>
+          this.persistExtraction(result, storage, threadId, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps, lifecycleCaps),
+        maybeCapturePassiveCorrections: (turns, opts) => this.maybeCapturePassiveCorrections(turns, opts),
+        resolveSelfNamespace: (sessionKey) => this.resolveSelfNamespace(sessionKey),
+        getCodingContextForSession: (sessionKey) => this.getCodingContextForSession(sessionKey),
+        applyCodingNamespaceOverlay: (sessionKey, namespace) => this.applyCodingNamespaceOverlay(sessionKey, namespace),
+        boxBuilderFor: (storage) => this.boxBuilderFor(storage),
+        appendPersistedThreadEpisodes: (threadId, ids) => this.appendPersistedThreadEpisodes(threadId, ids),
+        maybeScheduleConsolidation: (nonZero) => this.maybeScheduleConsolidation(nonZero),
+        requestQmdMaintenance: () => this.requestQmdMaintenance(),
+        runTierMigrationCycle: (storage, trigger, options) => this.runTierMigrationCycle(storage, trigger, options),
+        getLastPersistExtractionDeferredCount: () => this.lastPersistExtractionDeferredCount,
+        recordProcessedExtractionFingerprint: (storage, fingerprint, preloadedMeta) =>
+          this.recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta),
+      });
+    }
+    return this._extractionRunCoordinator;
+  }
+  /**
+   * Consolidation-run coordinator (issue #1526 seam 17). Owns
+   * the full consolidation maintenance pass (LLM merge/invalidate/update,
+   * entity merge, commitment/TTL cleanup, lifecycle policy, compression
+   * guideline learning, tier migration, fact archival, semantic consolidation,
+   * identity consolidation, profile consolidation, summarization, topic
+   * extraction, TMT rebuild). The orchestrator delegates and injects
+   * its own methods + coordinators.
+   */
+  private _consolidationRunCoordinator: ConsolidationRunCoordinator | undefined;
+
+  private get consolidationRunCoordinator(): ConsolidationRunCoordinator {
+    if (!this._consolidationRunCoordinator) {
+      this._consolidationRunCoordinator = new ConsolidationRunCoordinator({
+        config: this.config,
+        getStorage: () => this.storage,
+        getStorageRouter: () => this.storageRouter,
+        getExtraction: () => this.extraction,
+        embeddingFallback: this.embeddingFallback,
+        tmtBuilder: this.tmtBuilder,
+        consolidationObservers: this.consolidationObservers,
+        getAccessTrackingBuffer: () => this.accessTrackingBuffer,
+        lifecyclePolicyCoordinator: this.lifecyclePolicyCoordinator,
+        compressionGuidelineCoordinator: this.compressionGuidelineCoordinator,
+        semanticConsolidationCoordinator: this.semanticConsolidationCoordinator,
+        entitySynthesisCoordinator: this.entitySynthesisCoordinator,
+        recallSectionCoordinator: this.recallSectionCoordinator,
+        tierMigrationCoordinator: this.tierMigrationCoordinator,
+        flushAccessTracking: () => this.flushAccessTracking(),
+        indexPersistedMemory: (storage, memoryId) => this.indexPersistedMemory(storage, memoryId),
+        autoConsolidateIdentity: () => this.autoConsolidateIdentity(),
+        fastChatCompletion: (messages, options) => this.fastChatCompletion(messages, options),
+      });
+    }
+    return this._consolidationRunCoordinator;
+  }
+
+  /**
+   * Extraction-persist coordinator (issue #1526 seam 16). Owns the
+   * `persistExtraction` pipeline. Lazy: created on first access so
+   * Object.create(prototype) tests that set fields post-construction work.
+   */
+  private _extractionPersistCoordinator: ExtractionPersistCoordinator | undefined;
+
+  private get extractionPersistCoordinator(): ExtractionPersistCoordinator {
+    if (!this._extractionPersistCoordinator) {
+      this._extractionPersistCoordinator = new ExtractionPersistCoordinator({
+        config: this.config,
+        getStorageRouter: () => this.storageRouter,
+        getThreading: () => this.threading,
+        getLocalLlm: () => this.localLlm,
+        getQmd: () => this.qmd,
+        getJudgeVerdictCache: () => this.judgeVerdictCache,
+        getJudgeDeferCounts: () => this.judgeDeferCounts,
+        getFaithfulnessCounters: () => this.faithfulnessCounters,
+        getEmbeddingFallback: () => this.embeddingFallback,
+        setLastPersistExtractionDeferredCount: (v) => { this.lastPersistExtractionDeferredCount = v; },
+        setLastPersistExtractionPendingReviewIds: (ids) => { this.lastPersistExtractionPendingReviewIds = ids; },
+        addContentHashDedup: (targetStorage, content) => this.addContentHashDedup(targetStorage, content),
+        hasContentHashDedup: (targetStorage, content) => this.hasContentHashDedup(targetStorage, content),
+        backfillTemporalBoundsOnDedupHit: (targetStorage, dedupContent, bounds, entityRef) =>
+          this.backfillTemporalBoundsOnDedupHit(targetStorage, dedupContent, bounds, entityRef),
+        saveContentHashIndexes: () => this.saveContentHashIndexes(),
+        artifactTypeForCategory: (category) => this.artifactTypeForCategory(category),
+        loadRoutingRules: () => this.loadRoutingRules(),
+        routeEngineOptions: () => this.routeEngineOptions(),
+        semanticDedupLookup: (content, limit, targetStorage) =>
+          this.semanticDedupLookup(content, limit, targetStorage),
+        checkForContradiction: (content, category, namespaceScope) =>
+          this.checkForContradiction(content, category, namespaceScope),
+        applyDeferredContradictionResolve: (contradiction, storage, newMemoryId, postWriteGuard) =>
+          this.applyDeferredContradictionResolve(contradiction, storage, newMemoryId, postWriteGuard),
+        suggestLinksForMemory: (content, category, namespaceScope) =>
+          this.suggestLinksForMemory(content, category, namespaceScope),
+        storageDirNamespace: (storageDir) => this.storageDirNamespace(storageDir),
+        indexPersistedMemory: (storage, memoryId) => this.indexPersistedMemory(storage, memoryId),
+        buildGraphEdge: (storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps) =>
+          this.buildGraphEdge(storage, memoryRelPath, entityRef, memoryId, factContent, allMemsForGraph, memoryPathById, threadIdForEdge, threadEpisodeIdsForGraph, fallbackCausalPredecessor, graphCaps),
+        updateTemporalTagIndexes: (storage, persistedIds) =>
+          this.updateTemporalTagIndexes(storage, persistedIds),
+      });
+    }
+    return this._extractionPersistCoordinator;
+  }
   /**
    * Issue #1526: recall result formatting + identity continuity section moved
    * to RecallResultFormatter.
@@ -2751,6 +2840,7 @@ export class Orchestrator {
     });
     // Issue #1526: background extraction queue lives on its own coordinator.
     this.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+
     this.recallResultFormatter = new RecallResultFormatter(this.config);
     const conversationIndexRuntime = createConversationIndexRuntime(config, {
       getQmd: () => this.conversationQmd,
@@ -11983,67 +12073,18 @@ export class Orchestrator {
   }
 
   private normalizeExtractionFingerprintTurns(turns: BufferTurn[]): string[] {
-    if (!Array.isArray(turns) || turns.length === 0) return [];
-    return turns
-      .filter((turn) => turn.role === "user" || turn.role === "assistant")
-      .map((turn) => {
-        if (
-          typeof turn.turnFingerprint === "string" &&
-          turn.turnFingerprint.length > 0
-        ) {
-          return `fp:${turn.turnFingerprint}`;
-        }
-        return `${turn.role}:${(turn.content ?? "").replace(/\s+/g, " ").trim().slice(0, this.config.extractionMaxTurnChars)}`;
-      })
-      .filter((value) => value.length > 0);
+    return this.extractionRunCoordinator.normalizeExtractionFingerprintTurns(turns);
   }
 
-  private buildExtractionFingerprint(
-    turns: BufferTurn[],
-    bufferKey: string,
-  ): string | null {
-    const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
-    if (!normalized) return null;
-    return createHash("sha256")
-      .update(`${bufferKey}\n${normalized}`)
-      .digest("hex");
+  private buildExtractionFingerprint(turns: BufferTurn[], bufferKey: string): string | null {
+    return this.extractionRunCoordinator.buildExtractionFingerprint(turns, bufferKey);
   }
 
   private shouldQueueExtraction(
     turns: BufferTurn[],
     options: { commit?: boolean; bufferKey?: string } = {},
   ): boolean {
-    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-    if (!lifecycleCaps.extractionDedupe) return true;
-    if (!Array.isArray(turns) || turns.length === 0) return false;
-
-    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
-    const fingerprint = this.buildExtractionFingerprint(turns, bufferKey);
-    if (!fingerprint) return false;
-    const now = Date.now();
-    const seenAt = this.recentExtractionFingerprints.get(fingerprint);
-    if (seenAt && now - seenAt < this.config.extractionDedupeWindowMs) {
-      log.debug("extraction dedupe: skipped duplicate buffered turn set");
-      return false;
-    }
-
-    if (options.commit !== false) {
-      this.recentExtractionFingerprints.set(fingerprint, now);
-    }
-    // Keep this cache bounded to avoid unbounded growth.
-    if (
-      options.commit !== false &&
-      this.recentExtractionFingerprints.size > 200
-    ) {
-      const entries = Array.from(
-        this.recentExtractionFingerprints.entries(),
-      ).sort((a, b) => a[1] - b[1]);
-      for (const [key] of entries.slice(0, entries.length - 200)) {
-        this.recentExtractionFingerprints.delete(key);
-      }
-    }
-
-    return true;
+    return this.extractionRunCoordinator.shouldQueueExtraction(turns, options);
   }
 
   /**
@@ -12179,3204 +12220,91 @@ export class Orchestrator {
     return this._passiveCorrectionService;
   }
 
-  private async runExtraction(
-    turns: BufferTurn[],
-    options: {
-      clearBufferAfterExtraction?: boolean;
-      skipCharThreshold?: boolean;
-      skipUserTurnThreshold?: boolean;
-      deadlineMs?: number;
-      bufferKey?: string;
-      abortSignal?: AbortSignal;
-      failOnExtractionFailure?: boolean;
-      /**
-       * Explicit namespace override for the write path (#460).  When set,
-       * extraction writes go to this namespace instead of the one derived
-       * from `defaultNamespaceForPrincipal(resolvePrincipal(sessionKey))`.
-       * The resolved `principal` is still threaded into memory metadata
-       * for provenance; only the storage target is overridden.
-       */
-      writeNamespaceOverride?: string;
-      /**
-       * Pin the provenance principal instead of deriving it from
-       * `resolvePrincipal(sessionKey)` (#1495 thread 1). When set, this is the
-       * identity an access surface already authenticated; used so observed-turn
-       * provenance is correct even though `turn.sessionKey` is the ORIGINAL
-       * (un-prefixed) key and storage is pinned via `writeNamespaceOverride`.
-       */
-      principalOverride?: string;
-    } = {},
+  async runExtraction(
+    ...args: Parameters<ExtractionRunCoordinator["runExtraction"]>
   ): Promise<ExtractionRunResult> {
-    log.debug(`running extraction on ${turns.length} turns`);
-    const clearBufferAfterExtraction =
-      options.clearBufferAfterExtraction ?? true;
-    const skipCharThreshold = options.skipCharThreshold ?? false;
-    const skipUserTurnThreshold = options.skipUserTurnThreshold ?? false;
-    const deadlineMs =
-      typeof options.deadlineMs === "number" &&
-      Number.isFinite(options.deadlineMs)
-        ? options.deadlineMs
-        : undefined;
-    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
-    const throwIfDeadlineExceeded = (stage: string): void => {
-      if (typeof deadlineMs === "number" && Date.now() > deadlineMs) {
-        throw new Error(`replay extraction deadline exceeded (${stage})`);
-      }
-    };
-    const throwIfAborted = (stage: string): void => {
-      throwIfRecallAborted(options.abortSignal, `extraction aborted (${stage})`);
-    };
-    const clearBuffer = async (options?: { ignoreAbort?: boolean }) => {
-      if (options?.ignoreAbort !== true) {
-        throwIfAborted("before_clear_buffer");
-      }
-      if (clearBufferAfterExtraction) {
-        await this.buffer.clearAfterExtraction(bufferKey, turns);
-      }
-    };
-
-    // Skip extraction for cron job sessions - these are system operations, not user conversations
-    const sessionKey = turns[0]?.sessionKey ?? "";
-    if (sessionKey.includes(":cron:")) {
-      log.debug(`skipping extraction for cron session: ${sessionKey}`);
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "cron_session",
-        persistedCount: 0,
-        durableOutputCount: 0,
-      };
-    }
+    return this.extractionRunCoordinator.runExtraction(...args);
+  }
 
-    const normalizedTurns = turns
-      .filter(
-        (t) =>
-          (t.role === "user" || t.role === "assistant") &&
-          typeof t.content === "string",
-      )
-      .map((t) => ({
-        ...t,
-        content: t.content.trim().slice(0, this.config.extractionMaxTurnChars),
-      }))
-      .filter((t) => t.content.length > 0);
-    const targetTurns = normalizedTurns.filter(
-      (turn) => turn.extractionContextOnly !== true,
+  private async recordProcessedExtractionFingerprint(
+    storage: StorageManager,
+    fingerprint: string,
+    preloadedMeta?: Awaited<ReturnType<StorageManager["loadMeta"]>>,
+  ): Promise<void> {
+    return this.extractionRunCoordinator.recordProcessedExtractionFingerprint(
+      storage, fingerprint, preloadedMeta,
     );
-    if (targetTurns.length === 0) {
-      log.debug("skipping extraction: no non-context turns after normalization");
-      // Context-only turns may still contain corrections (review: "context-only
-      // turns skip capture"). Scan normalizedTurns before clearing the buffer.
-      if (normalizedTurns.length > 0) {
-        await this.maybeCapturePassiveCorrections(normalizedTurns as BufferTurn[], { sessionKey, principal: resolvePrincipal(sessionKey, this.config), namespace: this.resolveSelfNamespace(sessionKey), bufferKey, isLiveSession: clearBufferAfterExtraction });
-      }
-      await clearBuffer();
-      return { status: "skipped", reason: "empty_normalized_turns", persistedCount: 0, durableOutputCount: 0 };
-    }
-    const sourceValidAt = latestSourceValidAtFromTurns(targetTurns);
-    throwIfDeadlineExceeded("before_extract");
-    throwIfAborted("before_extract");
+  }
 
-    const userTurns = targetTurns.filter((t) => t.role === "user");
-    const totalChars = targetTurns.reduce(
-      (sum, t) => sum + t.content.length,
-      0,
-    );
-    const belowCharThreshold = totalChars < this.config.extractionMinChars;
-    const belowUserTurnThreshold =
-      !skipUserTurnThreshold &&
-      userTurns.length < this.config.extractionMinUserTurns;
-    if ((!skipCharThreshold && belowCharThreshold) || belowUserTurnThreshold) {
-      log.debug(
-        `skipping extraction: below threshold (totalChars=${totalChars}, userTurns=${userTurns.length})`,
-      );
-      await clearBuffer();
-      // Passive correction capture runs even when extraction is skipped for
-      // being below the char/user-turn threshold (review: "skipped extraction
-      // skips capture"). A short correction like "stop using Vim" is under
-      // extractionMinChars but is exactly the high-value case this feature
-      // exists for. The write namespace resolves through the SAME scope-profile
-      // plan as the full extraction path so corrections target the active
-      // profile's write layer, not just resolveSelfNamespace (review:
-      // "below-threshold wrong namespace"). The ACL in passiveCorrectionService
-      // authorizes the actual plan/apply.
-      {
-        const capturePrincipal =
-          typeof options.principalOverride === "string" && options.principalOverride.length > 0
-            ? options.principalOverride
-            : resolvePrincipal(sessionKey, this.config);
-        const captureWO = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0
-          ? options.writeNamespaceOverride : undefined;
-        const captureCodingCtx = sessionKey ? this.getCodingContextForSession(sessionKey) : null;
-        const captureCodingOv = resolveCodingNamespaceOverlay(captureCodingCtx, this.config.codingMode, this.config.defaultNamespace);
-        const captureScopePlan = resolveScopeProfilePlan({ config: this.config, principal: capturePrincipal, codingContext: captureCodingCtx, codingOverlay: captureCodingOv });
-        const captureNamespace = captureWO ?? captureScopePlan?.writeNamespace ?? this.resolveSelfNamespace(sessionKey);
-        await this.maybeCapturePassiveCorrections(normalizedTurns as BufferTurn[], {
-          sessionKey, principal: capturePrincipal, namespace: captureNamespace, bufferKey, isLiveSession: clearBufferAfterExtraction,
-        });
-      }
-      return {
-        status: "skipped",
-        reason: "below_threshold",
-        persistedCount: 0,
-        durableOutputCount: 0,
-      };
-    }
+  private async runTierMigrationCycle(
+    storage: StorageManager,
+    trigger: "extraction" | "maintenance" | "manual",
+    options?: {
+      dryRun?: boolean;
+      limitOverride?: number;
+      force?: boolean;
+    },
+  ): Promise<TierMigrationCycleSummary> {
+    return this.tierMigrationCoordinator.runCycle(storage, trigger, options);
+  }
 
-    // Provenance principal honours the access-surface override (#1495 thread 1,
-    // mirroring the recall path's `principalOverride`, issue #570 PR 4). Access
-    // surfaces that authenticated the caller at the transport layer pass their
-    // resolved principal so provenance uses the SAME identity the surface
-    // authorized, instead of `resolvePrincipal(sessionKey)` — which on a
-    // namespace-prefixed key would collapse to `default`. The ORIGINAL,
-    // un-prefixed session key still drives threading.
-    const principal =
-      typeof options.principalOverride === "string" &&
-      options.principalOverride.length > 0
-        ? options.principalOverride
-        : resolvePrincipal(sessionKey, this.config);
-    // Write path — explicit callers still win. Otherwise, an active hosted
-    // scope profile owns the extraction write target so hook-captured turns land
-    // in the same layer that profile recall searches. Without a profile, preserve
-    // the existing coding-agent overlay behavior (issue #569).
-    const explicitWriteNamespace =
-      typeof options.writeNamespaceOverride === "string" &&
-      options.writeNamespaceOverride.length > 0
-        ? options.writeNamespaceOverride
-        : undefined;
-    const codingContextForWrite = sessionKey
-      ? this.getCodingContextForSession(sessionKey)
-      : null;
-    const codingOverlayForWrite = resolveCodingNamespaceOverlay(
-      codingContextForWrite,
-      this.config.codingMode,
-      this.config.defaultNamespace,
-    );
-    const scopeProfileGatePlan = resolveScopeProfilePlan({
-      config: this.config,
-      principal,
-      codingContext: codingContextForWrite,
-      codingOverlay: codingOverlayForWrite,
+  async getTierMigrationStatus(): Promise<TierMigrationStatusSnapshot> {
+    return this.tierMigrationStatus.get();
+  }
+
+  async runTierMigrationNow(options?: {
+    dryRun?: boolean;
+    limit?: number;
+  }): Promise<TierMigrationCycleSummary> {
+    return this.runTierMigrationCycle(this.storage, "manual", {
+      dryRun: options?.dryRun === true,
+      limitOverride: options?.limit,
+      force: false,
     });
-    const scopeProfileWritePlan = explicitWriteNamespace ? null : scopeProfileGatePlan;
-    if (scopeProfileWritePlan) {
-      const selectedLayer = scopeProfileWritePlan.layers.find(
-        (layer) => layer.id === scopeProfileWritePlan.writeLayer,
-      );
-      const writeNamespaceReadable = scopeProfileWritePlan.readNamespaces.includes(
-        scopeProfileWritePlan.writeNamespace,
-      );
-      if (!selectedLayer?.writable || !writeNamespaceReadable) {
-        log.warn(
-          `runExtraction: skipping scope profile ${scopeProfileWritePlan.profileId} because write layer ${scopeProfileWritePlan.writeLayer} is not writable inside the profile read stack`,
-        );
-        await clearBuffer();
-        return {
-          status: "skipped",
-          reason: "scope_profile_no_writable_layer",
-          persistedCount: 0,
-          durableOutputCount: 0,
-        };
-      }
-    }
-    const selfNamespace =
-      explicitWriteNamespace ??
-      scopeProfileWritePlan?.writeNamespace ??
-      this.applyCodingNamespaceOverlay(
-        sessionKey,
-        defaultNamespaceForPrincipal(principal, this.config),
-      );
-    const storage = await this.storageRouter.storageFor(selfNamespace);
-    const shouldPersistProcessedFingerprint = targetTurns.some(
-      (turn) => turn.persistProcessedFingerprint === true,
-    );
-    const extractionFingerprint = this.buildExtractionFingerprint(
-      targetTurns,
-      bufferKey,
-    );
-    let meta =
-      extractionFingerprint && shouldPersistProcessedFingerprint
-        ? await storage.loadMeta()
-        : null;
-    if (
-      extractionFingerprint &&
-      shouldPersistProcessedFingerprint &&
-      (meta?.processedExtractionFingerprints ?? []).some(
-        (entry) => entry.fingerprint === extractionFingerprint,
-      )
-    ) {
-      log.debug(
-        `runExtraction: skipping already-processed extraction fingerprint for ${bufferKey}`,
-      );
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "processed_fingerprint",
-        persistedCount: 0,
-        durableOutputCount: 0,
-      };
-    }
+  }
 
-    // Pass existing entity names so the LLM can reuse them instead of inventing variants
-    const existingEntities = await storage.listEntityNames();
-    const result = await raceRecallAbort(
-      this.extraction.extract(
-        normalizedTurns,
-        existingEntities,
-      ),
-      options.abortSignal,
-      "extraction aborted (during_extract)",
+  private maybeScheduleConsolidation(nonZeroExtraction: boolean): void {
+    this.maintenanceScheduler.maybeScheduleConsolidation(
+      nonZeroExtraction,
+      () => this.runConsolidation(),
     );
-    throwIfDeadlineExceeded("before_persist");
-    throwIfAborted("before_persist");
-
-    // Defensive: validate extraction result before processing. Explicit
-    // fail-closed callers, such as flush-plan import, must not observe
-    // malformed extractor output as a successful skip.
-    if (!result) {
-      log.warn("runExtraction: extraction returned null/undefined");
-      if (options.failOnExtractionFailure) {
-        throw new Error("extraction failed: invalid_extraction_result");
-      }
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "invalid_extraction_result",
-        persistedCount: 0,
-        durableOutputCount: 0,
-      };
-    }
-    const invalidExtractionResultFields = [
-      ["facts", result.facts],
-      ["entities", result.entities],
-      ["questions", result.questions],
-      ["profileUpdates", result.profileUpdates],
-    ]
-      .filter(([, value]) => !Array.isArray(value))
-      .map(([field]) => field);
-    if (invalidExtractionResultFields.length > 0) {
-      log.warn(
-        "runExtraction: extraction returned invalid collection fields",
-        {
-          invalidFields: invalidExtractionResultFields,
-          resultKeys:
-            typeof result === "object" && result !== null
-              ? Object.keys(result)
-              : [],
-        },
-      );
-      if (options.failOnExtractionFailure) {
-        throw new Error("extraction failed: invalid_extraction_result");
-      }
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "invalid_extraction_result",
-        persistedCount: 0,
-        durableOutputCount: 0,
-      };
-    }
-    const extractionFailure =
-      typeof result.extractionFailure === "string" &&
-      result.extractionFailure.trim().length > 0
-        ? result.extractionFailure
-        : undefined;
-    if (options.failOnExtractionFailure && extractionFailure) {
-      throw new Error(`extraction failed: ${extractionFailure}`);
-    }
-    if (
-      result.facts.length === 0 &&
-      result.entities.length === 0 &&
-      result.questions.length === 0 &&
-      result.profileUpdates.length === 0
-    ) {
-      log.debug(
-        "runExtraction: extraction produced no durable outputs; skipping persistence",
-      );
-      if (extractionFailure) {
-        log.warn(
-          "runExtraction: extraction reported failure with no durable outputs; not marking fingerprint processed",
-          { extractionFailure },
-        );
-      }
-      if (
-        extractionFingerprint &&
-        shouldPersistProcessedFingerprint &&
-        !extractionFailure
-      ) {
-        meta ??= await storage.loadMeta();
-        await this.recordProcessedExtractionFingerprint(
-          storage,
-          extractionFingerprint,
-          meta,
-        );
-        meta.extractionCount += 1;
-        meta.lastExtractionAt = new Date().toISOString();
-        await storage.saveMeta(meta);
-      }
-      // Correction-only turns that meet char/user-turn thresholds but yield
-      // zero facts still need passive capture (review: "empty extraction skips
-      // capture"). selfNamespace/principal already resolved above.
-      await this.maybeCapturePassiveCorrections(normalizedTurns as BufferTurn[], { sessionKey, principal, namespace: selfNamespace, bufferKey, isLiveSession: clearBufferAfterExtraction });
-      await clearBuffer();
-      return { status: "skipped", reason: "empty_extraction_result", persistedCount: 0, durableOutputCount: 0 };
-    }
+  }
 
-    let threadIdForExtraction: string | null = null;
-    if (resolvePresentationCapabilities(this.config).threading && turns.length > 0) {
-      const lastTurn = turns[turns.length - 1];
-      try {
-        threadIdForExtraction = await this.threading.processTurn(lastTurn, []);
-      } catch (err) {
-        // Fail-open: threading errors must not block memory persistence.
-        log.warn(
-          "[threading] processTurn failed before persistence (non-fatal)",
-          err,
-        );
-      }
-    }
+  requestQmdMaintenance(): void {
+    this.maintenanceScheduler.requestQmdMaintenanceForTool("__internal__");
+  }
+
+  /**
+   * Public entrypoint for tool-driven QMD maintenance requests.
+   * Delegates to the maintenance scheduler (issue #1526 PR1).
+   */
+  requestQmdMaintenanceForTool(reason: string): void {
+    this.maintenanceScheduler.requestQmdMaintenanceForTool(reason);
+  }
 
-    const persistedIds = await this.persistExtraction(
+  private async persistExtraction(
+    result: ExtractionResult,
+    storage: StorageManager,
+    threadIdForExtraction?: string | null,
+    sourceContext?: { sessionKey?: string; principal?: string; validAt?: string },
+    baseNamespace?: string,
+    scopeProfileWritePlan?: ResolvedScopeProfilePlan | null,
+    /** Verbatim source turn text the facts were extracted from (faithfulness gate #1576). */
+    sourceText?: string,
+    graphCaps: GraphConstructionCapabilitySet = resolveGraphConstructionCapabilities(this.config),
+    lifecycleCaps: MemoryLifecycleCapabilitySet = resolveMemoryLifecycleCapabilities(this.config),
+  ): Promise<string[]> {
+    return this.extractionPersistCoordinator.persistExtraction(
       result,
       storage,
       threadIdForExtraction,
-      { sessionKey, principal, validAt: sourceValidAt },
-      // Pass the KNOWN base namespace (NHIdx) so the catalog write touch records the
-      // real namespace rather than a guess decoded from the storage dir.
-      selfNamespace,
-      scopeProfileGatePlan,
-      // Verbatim source turns for the faithfulness gate (#1576) so it can
-      // locate a quote per fact when #1575 spans are absent.
-      normalizedTurns.map((t) => t.content).join("\n\n"),
+      sourceContext,
+      baseNamespace,
+      scopeProfileWritePlan,
+      sourceText,
+      graphCaps,
+      lifecycleCaps,
     );
-    let postPersistMetadataFailed = false;
-    meta ??= await storage.loadMeta();
-    if (extractionFingerprint && shouldPersistProcessedFingerprint) {
-      try {
-        await this.recordProcessedExtractionFingerprint(
-          storage,
-          extractionFingerprint,
-          meta,
-        );
-      } catch (error) {
-        log.warn(
-          "runExtraction: failed to persist processed extraction fingerprint; continuing with buffer clear",
-          error,
-        );
-        postPersistMetadataFailed = true;
-      }
-    }
-    // Persist extraction counters and processed fingerprints before running
-    // follow-on helpers so replay dedupe survives any later non-essential
-    // failure. If this aggregate meta write fails, still clear the buffer:
-    // the durable memories are already written and replaying the same turns
-    // would duplicate them.
-    meta.extractionCount += 1;
-    meta.lastExtractionAt = new Date().toISOString();
-    meta.totalMemories += Array.isArray(result?.facts)
-      ? result.facts.length
-      : 0;
-    meta.totalEntities += Array.isArray(result?.entities)
-      ? result.entities.length
-      : 0;
-    try {
-      await storage.saveMeta(meta);
-    } catch (error) {
-      log.warn(
-        "runExtraction: failed to save extraction metadata after durable persistence; continuing with buffer clear",
-        error,
-      );
-      postPersistMetadataFailed = true;
-    }
-
-    const durableOutputCount =
-      result.facts.length +
-      result.entities.length +
-      result.questions.length +
-      result.profileUpdates.length;
-
-    // Buffer retention for defer verdicts (issue #562, PR 2). When the judge
-    // deferred at least one candidate, retain the tail of the current turn
-    // window so the next extraction pass has the surrounding context that
-    // may disambiguate the deferred fact. Non-defer runs clear the slot.
-    //
-    // Gated on:
-    //   - `clearBufferAfterExtraction` — replay / bulk-import paths call
-    //     `runExtraction` with this false and do not operate on live buffer
-    //     state. Writing retention there would create synthetic buffer
-    //     entries and cross-contaminate future live extractions.
-    //   - NOT `extractionJudgeShadow` — in shadow mode the judge is only
-    //     advisory; facts are still persisted regardless of verdict, so
-    //     retaining the turn window on top of a persisted write would both
-    //     waste buffer space and cause the same facts to re-enter the
-    //     pipeline on the next pass.
-    try {
-      if (
-        clearBufferAfterExtraction &&
-        !this.config.extractionJudgeShadow
-      ) {
-        const deferredCount = this.lastPersistExtractionDeferredCount;
-        if (deferredCount > 0 && normalizedTurns.length > 0) {
-          await this.buffer.retainDeferredTurns(
-            bufferKey,
-            normalizedTurns as BufferTurn[],
-            10,
-          );
-        } else {
-          await this.buffer.retainDeferredTurns(bufferKey, [], 0);
-        }
-      }
-    } catch (err) {
-      // Fail-open: retention is a nice-to-have. If it fails the judge will
-      // still cap deferrals and convert to reject on the next pass.
-      log.debug(
-        `extraction-judge: defer retention failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`,
-      );
-    }
-
-    await clearBuffer({ ignoreAbort: true });
-
-    // Passive correction capture (issue #1581) — detect corrections expressed
-    // passively in the extracted turns and route to the Correction Contract.
-    // Runs AFTER persistence + buffer clear so a capture failure never blocks
-    // the extraction return. `clearBufferAfterExtraction` gates live-session
-    // auto-apply (replay/import → queue-only).
-    await this.maybeCapturePassiveCorrections(normalizedTurns as BufferTurn[], {
-      sessionKey,
-      principal,
-      namespace: selfNamespace,
-      bufferKey,
-      isLiveSession: clearBufferAfterExtraction,
-    });
-
-    // Build memory box from this extraction (v8.0 Phase 2A)
-    // Topics are derived from the current extraction's facts and entities only —
-    // not from readAllMemories() — so box topics accurately reflect the current
-    // session window and the call is free of expensive full-corpus I/O.
-    if (resolvePresentationCapabilities(this.config).memoryBoxes && persistedIds.length > 0) {
-      const extractionTopics = deriveTopicsFromExtraction(result);
-      // Derive episodic metadata from buffer turns (REMem-inspired)
-      const firstUserTurn = turns.find((t) => t.role === "user");
-      const boxGoal =
-        firstUserTurn?.content?.slice(0, 100)?.trim() || undefined;
-      await this.boxBuilderFor(storage)
-        .onExtraction({
-          topics: extractionTopics,
-          memoryIds: persistedIds,
-          timestamp: new Date().toISOString(),
-          goal: boxGoal,
-        })
-        .catch((err) =>
-          log.warn("[boxes] onExtraction failed (non-fatal)", err),
-        );
-    }
-
-    // Batch-append persisted IDs so non-fact memories (entities/questions) are
-    // always attached to the thread. The helper excludes pending_review ids (#1635).
-    if (
-      resolvePresentationCapabilities(this.config).threading &&
-      threadIdForExtraction &&
-      persistedIds.length > 0
-    ) {
-      await this.appendPersistedThreadEpisodes(
-        threadIdForExtraction,
-        persistedIds,
-      );
-    }
-
-    // Thread title update for the already-established thread context.
-    if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction) {
-      const conversationContent = turns.map((t) => t.content).join(" ");
-      try {
-        await this.threading.updateThreadTitle(
-          threadIdForExtraction,
-          conversationContent,
-        );
-      } catch (err) {
-        log.warn(
-          "[threading] updateThreadTitle failed after persistence (non-fatal)",
-          err,
-        );
-      }
-    }
-
-    // Check if consolidation is needed (debounced + non-zero gated).
-    const nonZeroExtraction = durableOutputCount > 0;
-    try {
-      // The increment of nonZeroExtractionsSinceConsolidation moved into
-      // the scheduler with the rest of the cadence state (issue #1526 PR1).
-      this.maybeScheduleConsolidation(nonZeroExtraction);
-    } catch (err) {
-      log.warn(
-        "runExtraction: consolidation scheduling failed after persistence (non-fatal)",
-        err,
-      );
-    }
-
-    try {
-      this.requestQmdMaintenance();
-    } catch (err) {
-      log.warn(
-        "runExtraction: QMD maintenance scheduling failed after persistence (non-fatal)",
-        err,
-      );
-    }
-
-    try {
-      await this.runTierMigrationCycle(storage, "extraction");
-    } catch (err) {
-      log.warn(
-        "runExtraction: tier migration failed after persistence (non-fatal)",
-        err,
-      );
-    }
-
-    return {
-      status: "completed",
-      persistedCount: persistedIds.length,
-      durableOutputCount,
-      postPersistMetadataFailed,
-    };
-  }
-
-  private async recordProcessedExtractionFingerprint(
-    storage: StorageManager,
-    fingerprint: string,
-    preloadedMeta?: Awaited<ReturnType<StorageManager["loadMeta"]>>,
-  ): Promise<void> {
-    const meta = preloadedMeta ?? (await storage.loadMeta());
-    const observedAt = new Date().toISOString();
-    const seen = new Map(
-      (meta.processedExtractionFingerprints ?? []).map((entry) => [
-        entry.fingerprint,
-        entry.observedAt,
-      ]),
-    );
-    seen.set(fingerprint, observedAt);
-    meta.processedExtractionFingerprints = Array.from(seen.entries())
-      .map(([value, at]) => ({ fingerprint: value, observedAt: at }))
-      .sort((left, right) => left.observedAt.localeCompare(right.observedAt))
-      .slice(-500);
-    if (!preloadedMeta) {
-      await storage.saveMeta(meta);
-    }
-  }
-
-  private async runTierMigrationCycle(
-    storage: StorageManager,
-    trigger: "extraction" | "maintenance" | "manual",
-    options?: {
-      dryRun?: boolean;
-      limitOverride?: number;
-      force?: boolean;
-    },
-  ): Promise<TierMigrationCycleSummary> {
-    return this.tierMigrationCoordinator.runCycle(storage, trigger, options);
-  }
-
-  async getTierMigrationStatus(): Promise<TierMigrationStatusSnapshot> {
-    return this.tierMigrationStatus.get();
-  }
-
-  async runTierMigrationNow(options?: {
-    dryRun?: boolean;
-    limit?: number;
-  }): Promise<TierMigrationCycleSummary> {
-    return this.runTierMigrationCycle(this.storage, "manual", {
-      dryRun: options?.dryRun === true,
-      limitOverride: options?.limit,
-      force: false,
-    });
-  }
-
-  private maybeScheduleConsolidation(nonZeroExtraction: boolean): void {
-    this.maintenanceScheduler.maybeScheduleConsolidation(
-      nonZeroExtraction,
-      () => this.runConsolidation(),
-    );
-  }
-
-  requestQmdMaintenance(): void {
-    this.maintenanceScheduler.requestQmdMaintenanceForTool("__internal__");
-  }
-
-  /**
-   * Public entrypoint for tool-driven QMD maintenance requests.
-   * Delegates to the maintenance scheduler (issue #1526 PR1).
-   */
-  requestQmdMaintenanceForTool(reason: string): void {
-    this.maintenanceScheduler.requestQmdMaintenanceForTool(reason);
-  }
-
-  private async persistExtraction(
-    result: ExtractionResult,
-    storage: StorageManager,
-    threadIdForExtraction?: string | null,
-    sourceContext?: { sessionKey?: string; principal?: string; validAt?: string },
-    baseNamespace?: string,
-    scopeProfileWritePlan?: ResolvedScopeProfilePlan | null,
-    /** Verbatim source turn text the facts were extracted from (faithfulness gate #1576). */
-    sourceText?: string,
-    graphCaps: GraphConstructionCapabilitySet = resolveGraphConstructionCapabilities(this.config),
-    lifecycleCaps: MemoryLifecycleCapabilitySet = resolveMemoryLifecycleCapabilities(this.config),
-  ): Promise<string[]> {
-    // Inline source attribution (issue #369). When enabled, every extracted
-    // fact is rewritten to carry a compact provenance tag inside its body so
-    // the citation survives hostile memory text, copy/paste, and LLM quoting.
-    // The helper is a no-op when the feature flag is off, so legacy pipelines
-    // see zero behavioral change.
-    const citationEnabled = resolvePipelineProcessingCapabilities(this.config).inlineSourceAttribution === true;
-    const citationTemplate = this.config.inlineSourceAttributionFormat;
-    // The stable fields (agent, session) are computed once; `ts` is intentionally
-    // omitted here and added fresh per invocation so each fact in a large batch
-    // gets its own insertion timestamp rather than sharing a single batch-start time.
-    const citationContextBase: Omit<CitationContext, "ts"> = citationEnabled
-      ? {
-          agent: sourceContext?.principal,
-          session: sourceContext?.sessionKey,
-        }
-      : {};
-    const applyInlineCitation = (content: string): string => {
-      if (!citationEnabled) return content;
-      if (typeof content !== "string" || content.length === 0) return content;
-      // Build a fresh CitationContext per call so `ts` reflects the actual
-      // insertion time of each individual fact rather than the batch-start time.
-      const citationContext: CitationContext = {
-        ...citationContextBase,
-        ts: new Date().toISOString(),
-      };
-      // `attachCitation` already calls `hasCitationForTemplate` internally and
-      // is a no-op when the content already carries a citation (default or
-      // custom template).  The outer check was redundant and has been removed
-      // to avoid a maintenance hazard where the two guard paths could diverge.
-      return attachCitation(content, citationContext, citationTemplate);
-    };
-    const persistedIds: string[] = [];
-    const supersessionOrderingAt = (validAt?: string): string =>
-      validAt && validAt.length > 0 ? validAt : new Date().toISOString();
-    // #1635: pending_review persisted ids, excluded from the thread episode set below.
-    const pendingReviewPersistedIds: string[] = [];
-    const persistedIdsByStorage = new Map<
-      string,
-      { storage: StorageManager; ids: string[] }
-    >();
-    const trackPersistedId = (
-      targetStorage: StorageManager,
-      id: string,
-      options: {
-        includeReturnedIds?: boolean;
-        /** #1635: keep this id out of the persisted thread episode set. */
-        pendingReview?: boolean;
-      } = {},
-    ): void => {
-      if (options.includeReturnedIds !== false) {
-        persistedIds.push(id);
-      }
-      if (options.pendingReview) {
-        pendingReviewPersistedIds.push(id);
-      }
-      const key = targetStorage.dir;
-      const existing = persistedIdsByStorage.get(key);
-      if (existing) {
-        existing.ids.push(id);
-        return;
-      }
-      persistedIdsByStorage.set(key, { storage: targetStorage, ids: [id] });
-    };
-    let dedupedCount = 0;
-    // Counter for facts skipped by the importance write-gate (issue #372).
-    // Emitted via the `importance_gated` metric below and rolled into the
-    // final `persisted:` log line so operators can tune the threshold.
-    let importanceGatedCount = 0;
-    // UUI2: short-circuit semantic dedup after first backend-unavailable signal
-    // within this batch. Once any fact in the batch gets reason="backend_unavailable"
-    // (meaning the embedding backend is degraded), subsequent facts skip the
-    // lookup entirely and proceed directly to write. This prevents N-fact batches
-    // from paying N × timeout when the backend is down. The flag resets per-batch
-    // (declared here, inside persistExtraction) so a transient hiccup in one
-    // batch does not permanently disable dedup in future batches.
-    let batchBackendUnavailable = false;
-    // #1669: per-namespace redaction-rule cache for this persist pass. A
-    // `never_store` / redaction_rule correction persists patterns under each
-    // namespace's state/corrections/redaction-rules/ dir; we consult them
-    // before a fact reaches the storage write chokepoint so matching content
-    // is withheld entirely rather than landing as pending_review. Cached per
-    // dir so a multi-fact batch over one namespace reads the dir once.
-    let redactionGatedCount = 0;
-    const redactionRulesByDir = new Map<string, CompiledRedactionRule[]>();
-    const redactionRulesFor = async (...dirs: string[]): Promise<CompiledRedactionRule[]> => {
-      const out: CompiledRedactionRule[] = [];
-      for (const d of dirs) {
-        let r = redactionRulesByDir.get(d);
-        if (!r) { r = await loadRedactionRules(d); redactionRulesByDir.set(d, r); }
-        out.push(...r);
-      }
-      return out;
-    };
-    const behaviorSignalsByStorage = new Map<
-      string,
-      { storage: StorageManager; events: BehaviorSignalEvent[] }
-    >();
-    const trackBehaviorSignals = (
-      targetStorage: StorageManager,
-      events: BehaviorSignalEvent[],
-    ): void => {
-      if (events.length === 0) return;
-      const key = targetStorage.dir;
-      const existing = behaviorSignalsByStorage.get(key);
-      if (existing) {
-        existing.events.push(...events);
-        return;
-      }
-      behaviorSignalsByStorage.set(key, {
-        storage: targetStorage,
-        events: [...events],
-      });
-    };
-    const confidenceTierOrder = [
-      "explicit",
-      "implied",
-      "inferred",
-      "speculative",
-    ] as const;
-    const sharedProfileLayer = scopeProfileWritePlan?.layers.find(
-      (layer) =>
-        layer.id === "serverShared" &&
-        layer.namespace === this.config.sharedNamespace,
-    );
-    const sharedPromotionTarget = scopeProfileWritePlan?.promotionTargets.find(
-      (target) =>
-        target.target === "serverShared" &&
-        target.namespace === this.config.sharedNamespace,
-    );
-    const profileAllowsSharedWrites =
-      !scopeProfileWritePlan ||
-      Boolean(
-        scopeProfileWritePlan.profile.readOrder.includes("serverShared") &&
-          scopeProfileWritePlan.readNamespaces.includes(this.config.sharedNamespace) &&
-          sharedProfileLayer?.readable &&
-          sharedProfileLayer.writable &&
-          sharedPromotionTarget?.authorized,
-      );
-    // #1713: hoist namespaces-enabled once for the scope-routing mirrors
-    // (pre-judge + write-loop) so no new scattered config.*Enabled read is
-    // introduced (ratchet scatteredConfigFlagReads; see #1523).
-    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces;
-    const profileAutoPromotionAllows = (
-      category: string,
-      confidence: number,
-    ): boolean => {
-      if (!scopeProfileWritePlan) return false;
-      const actualTier = confidenceTier(confidence);
-      const actualRank = confidenceTierOrder.indexOf(actualTier);
-      if (actualRank === -1) return false;
-      const autoPromote = scopeProfileWritePlan.profile.autoPromote;
-      if (!autoPromote.enabled) return false;
-      if (!autoPromote.categories.includes(category as any)) return false;
-      const minimumRank = confidenceTierOrder.indexOf(autoPromote.minConfidenceTier);
-      return minimumRank !== -1 && actualRank <= minimumRank;
-    };
-    const sharedAutoPromotionAllows = (
-      category: string,
-      confidence: number,
-    ): boolean => {
-      if (!scopeProfileWritePlan) {
-        const actualTier = confidenceTier(confidence);
-        const actualRank = confidenceTierOrder.indexOf(actualTier);
-        if (actualRank === -1) return false;
-        if (!resolveRecallEnhancementCapabilities(this.config).autoPromoteToShared) return false;
-        if (!this.config.autoPromoteToSharedCategories.includes(category as any))
-          return false;
-        const minimumRank = confidenceTierOrder.indexOf(
-          this.config.autoPromoteMinConfidenceTier,
-        );
-        return minimumRank !== -1 && actualRank <= minimumRank;
-      }
-      return (
-        scopeProfileWritePlan.profile.autoPromote.targets.includes("serverShared") &&
-        profileAutoPromotionAllows(category, confidence)
-      );
-    };
-    const shouldPromoteToShared = (
-      targetStorage: StorageManager,
-      category: string,
-      confidence: number,
-    ): boolean => {
-      if (
-        !resolveNamespaceCapabilities(this.config).namespaces ||
-        !profileAllowsSharedWrites ||
-        !sharedAutoPromotionAllows(category, confidence)
-      )
-        return false;
-      if (
-        this.storageDirNamespace(targetStorage.dir) ===
-        this.config.sharedNamespace
-      )
-        return false;
-      return true;
-    };
-    const promoteMemoryToProfileTargets = async (options: {
-      sourceStorage: StorageManager;
-      category: string;
-      content: string;
-      confidence: number;
-      tags: string[];
-      entityRef?: string;
-      structuredAttributes?: Record<string, string>;
-      sourceMemoryId: string;
-      importance?: ReturnType<typeof scoreImportance>;
-      intentGoal?: string;
-      intentActionType?: string;
-      intentEntityTypes?: string[];
-      memoryKind?: MemoryFrontmatter["memoryKind"];
-      validAt?: string;
-      // #1578 — bi-temporal bounds + ingestion provenance forwarded to profile-
-      // target copies (same defect class as shared promotion; cursor bugbot).
-      invalidAt?: string;
-      observedAt?: string;
-      eventTimeSource?: "extracted" | "assumed";
-      source: string;
-      sources?: ProvenanceSource[];
-      provenance?: "verified" | "unverified" | "none";
-    }): Promise<void> => {
-      if (
-        !scopeProfileWritePlan ||
-        !profileAutoPromotionAllows(options.category, options.confidence)
-      )
-        return;
-      const autoTargets = new Set(scopeProfileWritePlan.profile.autoPromote.targets);
-      const targets = scopeProfileWritePlan.promotionTargets.filter(
-        (target) =>
-          target.target !== "serverShared" &&
-          autoTargets.has(target.target) &&
-          target.authorized &&
-          target.namespace,
-      );
-      if (targets.length === 0) return;
-      const rawContent =
-        citationEnabled && hasCitationForTemplate(options.content, citationTemplate)
-          ? stripCitationForTemplate(options.content, citationTemplate)
-          : options.content;
-      const citedContent = applyInlineCitation(rawContent);
-      const sanitizedBase = sanitizeMemoryContent(rawContent);
-      const dedupContent =
-        options.category === "fact" &&
-        options.structuredAttributes &&
-        Object.keys(options.structuredAttributes).length > 0
-          ? `${sanitizedBase.text}\n[Attributes: ${normalizeAttributePairs(options.structuredAttributes)}]`
-          : sanitizedBase.text;
-      for (const target of targets) {
-        if (!target.namespace) continue;
-        try {
-          const targetStorage = await this.storageRouter.storageFor(target.namespace);
-          if (targetStorage.dir === options.sourceStorage.dir) continue;
-          if (
-            options.category === "fact" &&
-            (await targetStorage.hasFactContentHash(dedupContent))
-          ) {
-            // #1671 — backfill bi-temporal bounds the existing promoted copy
-            // lacks (re-extraction with a now-resolved invalidAt). Best-effort,
-            // fail-open; the helper gates on invalidAt to avoid I/O when no
-            // end bound is present.
-            if (options.invalidAt || options.validAt) {
-              await this.backfillTemporalBoundsOnDedupHit(
-                targetStorage,
-                dedupContent,
-                {
-                  invalidAt: options.invalidAt,
-                  // #1707 thread 2 — carry the corrected start bound.
-                  validFrom: options.validAt,
-                  ...(options.observedAt ? { observedAt: options.observedAt } : {}),
-                  ...(options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {}),
-                },
-                options.entityRef,
-              );
-            }
-            continue;
-          }
-          const targetPromotion = await targetStorage.writeMemory(
-            options.category as any,
-            citedContent,
-            {
-              confidence: options.confidence,
-              tags: [...options.tags, `${target.target}-promotion`],
-              entityRef: options.entityRef,
-              structuredAttributes: options.structuredAttributes,
-              source: `${options.source}-${target.target}-promotion`,
-              importance: options.importance,
-              lineage: [options.sourceMemoryId],
-              sourceMemoryId: options.sourceMemoryId,
-              intentGoal: options.intentGoal,
-              intentActionType: options.intentActionType,
-              intentEntityTypes: options.intentEntityTypes,
-              memoryKind: options.memoryKind,
-              validAt: options.validAt,
-              // #1578 — forward bi-temporal bounds + ingestion provenance.
-              ...(options.invalidAt ? { invalidAt: options.invalidAt } : {}),
-              ...(options.observedAt ? { observedAt: options.observedAt } : {}),
-              ...(options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {}),
-              contentHashSource: options.category === "fact" ? dedupContent : rawContent,
-              ...(options.sources && options.sources.length > 0 ? { sources: options.sources } : {}),
-              ...(options.provenance ? { provenance: options.provenance } : {}),
-            },
-          );
-          const promotedId = targetPromotion.id;
-          // #1645: if the TARGET namespace's own tombstone blocked this promotion,
-          // the row lands pending_review — do NOT supersede active target memories.
-          if (
-            !targetPromotion.tombstoneBlocked &&
-            lifecycleCaps.temporalSupersession &&
-            options.category === "fact" &&
-            options.entityRef &&
-            options.structuredAttributes &&
-            Object.keys(options.structuredAttributes).length > 0
-          ) {
-            try {
-              await applyTemporalSupersession({
-                storage: targetStorage,
-                newMemoryId: promotedId,
-                entityRef: options.entityRef,
-                structuredAttributes: options.structuredAttributes,
-                createdAt: supersessionOrderingAt(options.validAt),
-                enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
-              });
-            } catch (profileSupersessionErr) {
-              log.warn(
-                `persistExtraction: ${target.target} promotion temporal supersession failed open for promoted ${promotedId}: ${profileSupersessionErr}`,
-              );
-            }
-          }
-          // #1645 TV6: a tombstone-blocked promotion is pending_review (no
-          // active copy) — skip catalog/index/behavior like postWriteGuard.
-          if (!targetPromotion.tombstoneBlocked) {
-            trackPersistedId(targetStorage, promotedId, { includeReturnedIds: false });
-            await this.indexPersistedMemory(targetStorage, promotedId);
-            trackBehaviorSignals(
-              targetStorage,
-              buildBehaviorSignalsForMemory({
-                memoryId: promotedId,
-                category: options.category as any,
-                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}`,
-          );
-        }
-      }
-    };
-    const promoteMemoryToShared = async (options: {
-      sourceStorage: StorageManager;
-      category: string;
-      content: string;
-      confidence: number;
-      tags: string[];
-      entityRef?: string;
-      structuredAttributes?: Record<string, string>;
-      sourceMemoryId: string;
-      importance?: ReturnType<typeof scoreImportance>;
-      intentGoal?: string;
-      intentActionType?: string;
-      intentEntityTypes?: string[];
-      memoryKind?: MemoryFrontmatter["memoryKind"];
-      validAt?: string;
-      // #1578 — bi-temporal bounds + ingestion provenance forwarded to the
-      // shared-namespace copy so shared recall honours the same invalid_at
-      // window as the source fact (cursor bugbot).
-      invalidAt?: string;
-      observedAt?: string;
-      eventTimeSource?: "extracted" | "assumed";
-      source: string;
-      /** Claim-level provenance spans (issue #1575 PR 2). */
-      sources?: ProvenanceSource[];
-      provenance?: "verified" | "unverified" | "none";
-    }): Promise<void> => {
-      await promoteMemoryToProfileTargets(options);
-      if (
-        !shouldPromoteToShared(
-          options.sourceStorage,
-          options.category,
-          options.confidence,
-        )
-      )
-        return;
-      try {
-        const sharedStorage = await this.storageRouter.storageFor(
-          this.config.sharedNamespace,
-        );
-        // Dedup gate: canonicalize content before hashing.
-        //
-        // Issue #369 (PR #401): When inline attribution is enabled,
-        // `applyInlineCitation` appends a timestamp-bearing marker (e.g.
-        // `[Source: ..., ts=2026-04-11T...]`).  Because the timestamp changes
-        // on every call, hashing cited content produces a unique hash each
-        // time — defeating dedup entirely and allowing the same logical fact to
-        // be promoted repeatedly.  Also, both promotion call sites pass
-        // `fact.content`, which can already carry an inline citation (e.g. a
-        // relayed or reprocessed fact).  Strip any pre-existing citation so the
-        // dedup key matches the hash stored from the original un-cited write.
-        //
-        // PR #402 round-6 (Fix #2 / chatgpt-codex P1 PRRT_kwDORJXyws56U74n):
-        // Compute the enriched content before the hash-dedup check so the
-        // lookup uses the same content that writeMemory will actually store.
-        // When structuredAttributes are present, writeMemory appends an
-        // "[Attributes: ...]" suffix before hashing; hasFactContentHash must
-        // receive the same enriched body or the check is against a different
-        // hash and dedup fails to fire (letting duplicates through) or fires
-        // when it shouldn't (collapsing memories with different enrichments).
-        // Fix #1 (P2 PRRT_kwDORJXyws56VHZc): use normalizeAttributePairs so
-        // key order and casing are canonical — identical to the enrichment
-        // applied by storage.writeMemory — preventing spurious hash misses
-        // when attribute maps arrive with different insertion orders or casing.
-        //
-        // Fix #4 (Low PRRT_kwDORJXyws56VHth): sanitize the base content before
-        // building dedupContent.  writeMemory runs sanitizeMemoryContent on the
-        // enriched body before hashing; if sanitization redacts the content to
-        // REDACTED_PLACEHOLDER the stored hash is for the redacted form, not
-        // the raw form.  Computing dedupContent from sanitized.text here ensures
-        // the hash lookup and the normalizedIncoming comparison both use the
-        // same content that writeMemory will actually store.
-        //
-        // Combined fix: strip any pre-existing citation FIRST to obtain
-        // rawContent (the canonical body), then sanitize rawContent (not
-        // options.content) when building dedupContent, so that citation
-        // stripping and sanitization are applied in a consistent order.
-        const rawContent =
-          citationEnabled &&
-          hasCitationForTemplate(options.content, citationTemplate)
-            ? stripCitationForTemplate(options.content, citationTemplate)
-            : options.content;
-        const citedContent = applyInlineCitation(rawContent);
-        const sanitizedBase = sanitizeMemoryContent(rawContent);
-        const dedupContent =
-          options.category === "fact" &&
-          options.structuredAttributes &&
-          Object.keys(options.structuredAttributes).length > 0
-            ? `${sanitizedBase.text}\n[Attributes: ${normalizeAttributePairs(options.structuredAttributes)}]`
-            : sanitizedBase.text;
-        if (
-          options.category === "fact" &&
-          (await sharedStorage.hasFactContentHash(dedupContent))
-        ) {
-          // #1671 — backfill bi-temporal bounds onto the existing shared copy
-          // before the supersession short-circuit. Covers all return paths below
-          // (supersession-hit, catch-skip, and the no-supersession short-circuit)
-          // in one shot. Best-effort / fail-open; the helper gates on invalidAt.
-          if (options.invalidAt || options.validAt) {
-            await this.backfillTemporalBoundsOnDedupHit(
-              sharedStorage,
-              dedupContent,
-              {
-                invalidAt: options.invalidAt,
-                // #1707 thread 2 — carry the corrected start bound.
-                validFrom: options.validAt,
-                ...(options.observedAt ? { observedAt: options.observedAt } : {}),
-                ...(options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {}),
-              },
-              options.entityRef,
-            );
-          }
-          // Uj6H fix: shared-namespace temporal supersession must also run when
-          // the hash-dedup short-circuit fires.  Without this, an existing shared
-          // fact whose structuredAttributes are stale (or an older conflicting
-          // shared fact that is still active) never gets retired — supersession
-          // only ran in the post-writeMemory block which is unreachable here.
-          //
-          // Strategy: scan the shared namespace for the existing fact whose
-          // normalized content matches the incoming content, then run
-          // applyTemporalSupersession against it using the same logic that
-          // would have run post-writeMemory.  This is a best-effort / fail-open
-          // step — if the lookup fails we skip silently (same as the normal path).
-          if (
-            lifecycleCaps.temporalSupersession &&
-            options.entityRef &&
-            options.structuredAttributes &&
-            Object.keys(options.structuredAttributes).length > 0
-          ) {
-            // PR #402 round-7 (Fix #2 / Codex P1 PRRT_kwDORJXyws56VALC):
-            // Track whether matchingFact lookup completed before the try block
-            // so the catch block can distinguish an early-lookup failure (where
-            // we don't know if a duplicate exists) from a post-lookup supersession
-            // failure (where we confirmed a duplicate and must skip the write).
-            let hashDedupMatchingFact: MemoryFile | undefined;
-            let hashDedupLookupComplete = false;
-            try {
-              // Fix #2 (P2 PRRT_kwDORJXyws56VHZf): dedupContent is now built
-              // from sanitizedBase.text (see fix #4 above), so normalizedIncoming
-              // uses the same sanitized+normalized content that writeMemory hashes
-              // and that hasFactContentHash just matched.  Previously this used the
-              // raw options.content, which diverged from the stored hash when
-              // sanitization redacted the content, causing the candidate lookup to
-              // return undefined and leaving stale facts active.
-              const normalizedIncoming = ContentHashIndex.normalizeContent(dedupContent);
-              const allShared = await sharedStorage.readAllMemories();
-              // PR #402 round-12 (Finding Uybg): restrict hash-dedup matching to
-              // the SAME entity.  Content-hash equality alone can collide across
-              // entities when two entities share identical fact text.  Using an
-              // unrelated entity's existing fact as `newMemoryId` would anchor
-              // supersession to that entity's record and corrupt its
-              // `supersededBy` links.  Only consider facts whose normalized
-              // `entityRef` matches the incoming entity.
-              const incomingEntityNorm = normalizeSupersessionKey(options.entityRef);
-              hashDedupMatchingFact = allShared.find((m) => {
-                if (m.frontmatter.category !== "fact") return false;
-                if ((m.frontmatter.status ?? "active") !== "active") return false;
-                // Same-entity guard: skip if entity doesn't match.
-                if (!m.frontmatter.entityRef) return false;
-                if (normalizeSupersessionKey(m.frontmatter.entityRef) !== incomingEntityNorm) {
-                  log.debug(
-                    `persistExtraction: hash-dedup skipping cross-entity match (incoming="${incomingEntityNorm}" candidate="${normalizeSupersessionKey(m.frontmatter.entityRef)}")`,
-                  );
-                  return false;
-                }
-                // PR #402 round-7 (Fix #2): compare stored fact's full body
-                // (including any appended "[Attributes: ...]" suffix) against the
-                // enriched normalizedIncoming so the candidate selected is the one
-                // whose hash actually matched in hasFactContentHash.
-                return ContentHashIndex.normalizeContent(m.content ?? "") === normalizedIncoming;
-              });
-              hashDedupLookupComplete = true;
-              if (hashDedupMatchingFact) {
-                // Finding UvU1 (PR #402 round-11): anchor supersession to the
-                // incoming event's time, not the existing fact's persisted
-                // `created`.  For source-dated replay/import, this is the
-                // source valid_at; otherwise it is the current wall-clock. The
-                // matching fact may be an old shared copy whose `created`
-                // predates the incoming promotion event — using it as
-                // `createdAt` would make the new memory appear older than the
-                // existing one, preventing supersession from firing.
-                // PR #402 round-12 (Finding Uyui): the matching fact is an
-                // existing OLD memory — its persisted `frontmatter.created` is
-                // stale relative to the incoming promotion event.  Pass
-                // `useCallerTimestamp: true` so the function uses
-                // `createdAt` as the ordering anchor instead of the old fact's
-                // timestamp, ensuring supersession fires correctly even when
-                // the matching fact predates conflicting candidates.
-                const hashDedupSupersession = await applyTemporalSupersession({
-                  storage: sharedStorage,
-                  newMemoryId: hashDedupMatchingFact.frontmatter.id,
-                  entityRef: options.entityRef,
-                  structuredAttributes: options.structuredAttributes,
-                  createdAt: supersessionOrderingAt(options.validAt),
-                  enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
-                  useCallerTimestamp: true,
-                });
-                // Catalog touch (issue #1499 — codex P2 NElSf): this dedup branch
-                // returns WITHOUT the post-write catalog touch (now at the storage chokepoint #1522),
-                // but `applyTemporalSupersession` mutated the shared namespace
-                // (it rewrote frontmatter to retire stale shared facts). When any
-                // ids were actually superseded, the shared namespace changed, so we
-                // must record the write — otherwise the shared record's
-                // `lastWriteAt` stays stale and `writtenSince` maintenance / QMD
-                // fanout skips the namespace after a supersession-only update.
-                // Best-effort and failure-tolerant (the storage chokepoint swallows
-                // errors); only touch when work happened to avoid spurious writes.
-                if (hashDedupSupersession.supersededIds.length > 0) {
-                }
-                // Active matching fact exists — normal short-circuit is safe.
-                return;
-              }
-              // No active same-entity shared fact found with this content hash.
-              // This can happen when the previously-written shared fact has since
-              // been superseded (e.g. Austin → NYC → Austin reversion): the hash
-              // index still records the hash but the fact is no longer active.
-              // Fall through to the write path below so a new active shared
-              // memory is created, then supersession fires post-write as usual.
-              log.debug(
-                `persistExtraction: hash-dedup found no active same-entity shared fact for ${options.sourceMemoryId}; falling through to write`,
-              );
-            } catch (hashDedupSupersessionErr) {
-              log.warn(
-                `persistExtraction: shared-namespace supersession on hash-dedup path failed open for ${options.sourceMemoryId}: ${hashDedupSupersessionErr}`,
-              );
-              // PR #402 round-7 (Fix #1 / cursor Medium PRRT_kwDORJXyws56U_ig):
-              // Only skip the write if we CONFIRMED a matching active shared fact
-              // before the error occurred (hashDedupLookupComplete is true AND
-              // hashDedupMatchingFact is set).  If the error was thrown before
-              // matchingFact was resolved — e.g. readAllMemories() threw — we
-              // cannot assume a duplicate exists, and unconditionally returning
-              // would permanently lose the shared promotion.  Fall through to the
-              // write path so the fact is not silently dropped.
-              if (hashDedupLookupComplete && hashDedupMatchingFact) {
-                // A matching active shared fact was confirmed — skip the write to
-                // avoid duplicating content that is already present.  The existing
-                // fact remains active and the supersession failure is logged above.
-                return;
-              }
-              // Lookup did not complete or no candidate was found — we cannot
-              // confirm a duplicate.  Fall through to the write + post-write
-              // supersession path so the shared promotion is not lost.
-              log.debug(
-                `persistExtraction: hash-dedup catch: lookup incomplete or no candidate found for ${options.sourceMemoryId}; falling through to write`,
-              );
-            }
-          } else {
-            // temporalSupersessionEnabled is off or no entity/attributes — keep
-            // the original short-circuit behaviour.
-            return;
-          }
-        }
-        const sharedPromotion = await sharedStorage.writeMemory(
-          options.category as any,
-          citedContent,
-          {
-            confidence: options.confidence,
-            tags: [...options.tags, "shared-promotion"],
-            entityRef: options.entityRef,
-            structuredAttributes: options.structuredAttributes,
-            source: `${options.source}-shared-promotion`,
-            importance: options.importance,
-            lineage: [options.sourceMemoryId],
-            sourceMemoryId: options.sourceMemoryId,
-            intentGoal: options.intentGoal,
-            intentActionType: options.intentActionType,
-            intentEntityTypes: options.intentEntityTypes,
-            memoryKind: options.memoryKind,
-            validAt: options.validAt,
-            // #1578 — forward bi-temporal bounds + ingestion provenance.
-            ...(options.invalidAt ? { invalidAt: options.invalidAt } : {}),
-            ...(options.observedAt ? { observedAt: options.observedAt } : {}),
-            ...(options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {}),
-            contentHashSource: options.category === "fact" ? dedupContent : rawContent,
-            // Claim-level provenance spans (issue #1575 PR 2).
-            ...(options.sources && options.sources.length > 0 ? { sources: options.sources } : {}),
-            ...(options.provenance ? { provenance: options.provenance } : {}),
-          },
-        );
-        const promotedId = sharedPromotion.id;
-        // #1645: if the shared namespace's own tombstone blocked this promotion,
-        // leave the row pending_review but do NOT supersede active shared memories.
-        // PR #402 Finding 3 fix: run temporal supersession against the shared
-        // namespace after the promoted write lands so stale shared-namespace
-        // copies of the same entity attribute are retired.  Without this,
-        // source-namespace supersession leaves the shared copy active and
-        // shared recall continues returning the stale state.  Reuses the same
-        // applyTemporalSupersession helper — no logic duplication.
-        if (
-          !sharedPromotion.tombstoneBlocked &&
-          lifecycleCaps.temporalSupersession &&
-          options.entityRef &&
-          options.structuredAttributes &&
-          Object.keys(options.structuredAttributes).length > 0
-        ) {
-          try {
-            await applyTemporalSupersession({
-              storage: sharedStorage,
-              newMemoryId: promotedId,
-              entityRef: options.entityRef,
-              structuredAttributes: options.structuredAttributes,
-              createdAt: supersessionOrderingAt(options.validAt),
-              enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
-            });
-          } catch (sharedSupersessionErr) {
-            log.warn(
-              `persistExtraction: shared-namespace temporal supersession failed open for promoted ${promotedId}: ${sharedSupersessionErr}`,
-            );
-          }
-        }
-        // Catalog touch (issue #1499, Issue B + ordering sweep): a shared-
-        // namespace promotion is the ONLY write the shared namespace receives on
-        // this path, so without this the shared record's lastWriteAt stays stale
-        // and `writtenSince` filters / maintenance fanout skip it. Record AFTER
-        // the promoted write and the shared temporal-supersession attempt so the
-        // catalog timestamp never precedes a later durable frontmatter mutation in
-        // the same promotion pass. The hot-path source-namespace touch uses a
-        // different storage dir, so this does not double-count the source.
-        // Best-effort and failure-tolerant — it must never crash the promotion.
-        // #1645 TV6: same guard as the profile-target promotion above.
-        if (!sharedPromotion.tombstoneBlocked) {
-          trackPersistedId(sharedStorage, promotedId, {
-            includeReturnedIds: false,
-          });
-          await this.indexPersistedMemory(sharedStorage, promotedId);
-          trackBehaviorSignals(
-            sharedStorage,
-            buildBehaviorSignalsForMemory({
-              memoryId: promotedId,
-              category: options.category as any,
-              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}`,
-        );
-      }
-    };
-    // #1707 thread 1 — backfill temporal bounds onto promotion copies when the
-    // SOURCE-namespace dedup short-circuit fires. That branch patches the
-    // source copy then `continue`s before the promotion dedup paths run, so
-    // promoted shared/profile copies written before the source fact carried
-    // resolved bounds stay stale (cross-namespace recall surfaces an expired
-    // fact). This mirrors the promotion-target resolution used by the two
-    // promote closures above and calls the same fail-open helper against each
-    // target storage. Backfill-only: never writes a new promoted copy.
-    const backfillTemporalBoundsOnPromotionCopies = async (args: {
-      sourceStorage: StorageManager;
-      content: string;
-      category: string;
-      confidence: number;
-      entityRef?: string;
-      structuredAttributes?: Record<string, string>;
-      bounds: {
-        invalidAt?: string;
-        validFrom?: string;
-        observedAt?: string;
-        eventTimeSource?: "extracted" | "assumed";
-      };
-    }): Promise<void> => {
-      // Mirror the helper's I/O gate: only resolve promotion targets when
-      // there is an end bound OR an EXTRACTED start bound. An "assumed"
-      // validFrom is just the ingestion anchor (no recall effect), so
-      // skipping it avoids resolving target storages on every bi-temporal
-      // duplicate (review cursor PRRT_OvHk).
-      const hasExtractedStart =
-        args.bounds.validFrom !== undefined &&
-        args.bounds.eventTimeSource === "extracted";
-      if (!args.bounds.invalidAt && !hasExtractedStart) return;
-      // Build the same dedupContent the promotion functions hash on so the
-      // content-hash lookup in the helper matches what was stored.
-      const rawContent =
-        citationEnabled && hasCitationForTemplate(args.content, citationTemplate)
-          ? stripCitationForTemplate(args.content, citationTemplate)
-          : args.content;
-      const sanitizedBase = sanitizeMemoryContent(rawContent);
-      const dedupContent =
-        args.category === "fact" &&
-        args.structuredAttributes &&
-        Object.keys(args.structuredAttributes).length > 0
-          ? `${sanitizedBase.text}\n[Attributes: ${normalizeAttributePairs(args.structuredAttributes)}]`
-          : sanitizedBase.text;
-      // Profile targets. NOTE: we do NOT gate on profileAutoPromotionAllows —
-      // a promoted profile copy may exist from an EARLIER extraction with
-      // higher confidence or older auto-promote settings, so the current
-      // duplicate's confidence must not skip backfilling an already-existing
-      // promoted copy (review codex PRRT_Ov7LKF). The helper no-ops when no
-      // matching copy is found, so resolving all configured auto-promote
-      // targets is safe.
-      if (scopeProfileWritePlan) {
-        const autoTargets = new Set(
-          scopeProfileWritePlan.profile.autoPromote.targets,
-        );
-        const profileTargets = scopeProfileWritePlan.promotionTargets.filter(
-          (target) =>
-            target.target !== "serverShared" &&
-            autoTargets.has(target.target) &&
-            target.authorized &&
-            target.namespace,
-        );
-        for (const target of profileTargets) {
-          if (!target.namespace) continue;
-          try {
-            const targetStorage = await this.storageRouter.storageFor(
-              target.namespace,
-            );
-            if (targetStorage.dir === args.sourceStorage.dir) continue;
-            await this.backfillTemporalBoundsOnDedupHit(
-              targetStorage,
-              dedupContent,
-              args.bounds,
-              args.entityRef,
-            );
-          } catch (err) {
-            log.warn(
-              `bitemporal-backfill: profile-target backfill failed open for ${target.target}: ${err}`,
-            );
-          }
-        }
-      }
-      // Shared target. A shared copy may exist from an earlier extraction
-      // regardless of the current confidence, so do not gate on
-      // shouldPromoteToShared (review codex PRRT_Ov7LKF) — BUT still respect
-      // shared-write AUTHORIZATION: a scoped profile that does not authorize
-      // serverShared writes must not have its shared namespace backfilled
-      // (review codex PRRT_Ov7dHR). profileAllowsSharedWrites is true for the
-      // legacy no-scope case and encodes the readable/writable/authorized
-      // checks under a scope profile.
-      if (profileAllowsSharedWrites) {
-        try {
-          const sharedStorage = await this.storageRouter.storageFor(
-            this.config.sharedNamespace,
-          );
-          if (sharedStorage.dir !== args.sourceStorage.dir) {
-            await this.backfillTemporalBoundsOnDedupHit(
-              sharedStorage,
-              dedupContent,
-              args.bounds,
-              args.entityRef,
-            );
-          }
-        } catch (err) {
-          log.warn(
-            `bitemporal-backfill: shared-target backfill failed open: ${err}`,
-          );
-        }
-      }
-    };
-
-    // Defensive: validate result and facts array
-    if (!result || !Array.isArray(result.facts)) {
-      log.warn(
-        "persistExtraction: result or result.facts is invalid, skipping",
-        { resultType: typeof result, factsType: typeof result?.facts },
-      );
-      return persistedIds;
-    }
-
-    // Chunking config from plugin settings
-    const chunkingConfig: ChunkingConfig = {
-      targetTokens: this.config.chunkingTargetTokens,
-      minTokens: this.config.chunkingMinTokens,
-      overlapSentences: this.config.chunkingOverlapSentences,
-    };
-
-    const rawEntities = Array.isArray((result as any).entities)
-      ? (result as any).entities
-      : [];
-    const rawQuestions = Array.isArray((result as any).questions)
-      ? (result as any).questions
-      : [];
-    const rawProfileUpdates = Array.isArray((result as any).profileUpdates)
-      ? (result as any).profileUpdates
-      : [];
-
-    const facts = result.facts.slice(0, this.config.extractionMaxFactsPerRun);
-    const entities = rawEntities.slice(
-      0,
-      this.config.extractionMaxEntitiesPerRun,
-    );
-    const questions = rawQuestions.slice(
-      0,
-      this.config.extractionMaxQuestionsPerRun,
-    );
-    const profileUpdates = rawProfileUpdates.slice(
-      0,
-      this.config.extractionMaxProfileUpdatesPerRun,
-    );
-
-    if (
-      facts.length < result.facts.length ||
-      entities.length < result.entities.length ||
-      questions.length < result.questions.length ||
-      profileUpdates.length < result.profileUpdates.length
-    ) {
-      log.warn(
-        "persistExtraction: capped extraction payload to guardrails " +
-          `(facts ${facts.length}/${result.facts.length}, entities ${entities.length}/${result.entities.length}, ` +
-          `questions ${questions.length}/${result.questions.length}, profile ${profileUpdates.length}/${result.profileUpdates.length})`,
-      );
-    }
-
-    // v8.2: pre-load all memories once for entity-sibling graph edges (avoids per-fact disk scan)
-    type GraphStorageContext = {
-      allMemsForGraph: Awaited<
-        ReturnType<typeof storage.readAllMemories>
-      > | null;
-      memoryPathById: Map<string, string>;
-      previousPersistedRelPath?: string;
-    };
-    const graphContextByStorageDir = new Map<string, GraphStorageContext>();
-    const ensureGraphContext = async (
-      targetStorage: StorageManager,
-    ): Promise<GraphStorageContext> => {
-      const existing = graphContextByStorageDir.get(targetStorage.dir);
-      if (existing) return existing;
-      const created: GraphStorageContext = {
-        allMemsForGraph: null,
-        memoryPathById: new Map<string, string>(),
-      };
-      if (graphCaps.multiGraphMemory) {
-        try {
-          created.allMemsForGraph = await targetStorage.readAllMemories();
-          for (const [id, relPath] of buildMemoryPathById(
-            created.allMemsForGraph,
-            targetStorage.dir,
-          )) {
-            created.memoryPathById.set(id, relPath);
-          }
-        } catch {
-          /* fail-open */
-        }
-      }
-      graphContextByStorageDir.set(targetStorage.dir, created);
-      return created;
-    };
-    let threadEpisodeIdsForGraph: string[] | undefined;
-    if (graphCaps.multiGraphMemory && threadIdForExtraction) {
-      try {
-        const thread = await this.threading.loadThread(threadIdForExtraction);
-        threadEpisodeIdsForGraph = thread?.episodeIds
-          ? [...thread.episodeIds]
-          : [];
-      } catch {
-        /* fail-open */
-      }
-    }
-    const routeRules = await this.loadRoutingRules();
-    const routeOptions = this.routeEngineOptions();
-
-    // Pre-routing pass: compute the routed category for every fact BEFORE
-    // building judge candidates.  Route rules may override f.category (e.g.
-    // via taxonomy remapping), and the judge must evaluate against the
-    // *final* category that will actually be persisted — not the raw
-    // extraction-time category.  The per-fact write loop below reuses
-    // these pre-computed results so routing is evaluated exactly once per
-    // fact (no duplicated logic).
-    const preRoutedCategories: Array<string | undefined> = new Array(facts.length);
-    // #1713 Item 1: collect routed target namespaces so the pre-judge redaction
-    // filter can consult rules from cross-namespace targets, not just the source.
-    // #1713 P2 (cursor): track per-fact routed namespace for per-fact pre-judge rules
-    const preRoutedNamespaceByFact: Array<string | undefined> = new Array(facts.length);
-    if (routeRules.length > 0) {
-      for (let fi = 0; fi < facts.length; fi++) {
-        const f = facts[fi];
-        if (
-          !f ||
-          typeof f.content !== "string" ||
-          !f.content.trim() ||
-          typeof f.category !== "string" ||
-          !f.category.trim()
-        ) {
-          continue;
-        }
-        try {
-          const tags = Array.isArray(f.tags) ? f.tags : [];
-          const routeText = `${f.category} ${tags.join(" ")} ${f.content}`;
-          const selected = selectRouteRule(routeText, routeRules, routeOptions);
-          if (selected?.target.category) {
-            preRoutedCategories[fi] = selected.target.category;
-          }
-          if (selected?.target.namespace) {
-            preRoutedNamespaceByFact[fi] = selected.target.namespace;
-          }
-        } catch {
-          // Fail-open: routing errors fall through to the extracted category.
-        }
-      }
-    }
-
-    // Extraction judge gate (issue #376). When enabled, batch-evaluate all
-    // candidate facts for durability before the per-fact write loop.
-    // The verdicts map is keyed by candidate index — we maintain a
-    // candidateIndexToFactIndex mapping so the write loop can look up
-    // verdicts by original fact index.
-    //
-    // Candidates are built using the *routed* category (preRoutedCategories)
-    // so the judge evaluates durability against the same category that will
-    // be persisted, not the raw extraction-time category.
-    let judgeVerdictsByFactIndex: Map<number, import("./extraction-judge.js").JudgeVerdict> | null = null;
-    let judgeGatedCount = 0;
-    // Reset the side-channel defer count at the start of every
-    // persistExtraction call so stale state from a prior call cannot leak
-    // into the caller's buffer-retention decision.
-    this.lastPersistExtractionDeferredCount = 0;
-    if (lifecycleCaps.extractionJudge) {
-      // #1669 P1 + #1713 Item 1: pre-filter redacted facts from judge candidates
-      // so never-store content is not persisted as judge training data.
-      // Consult source + shared + routed target namespace rules so a
-      // never-store pattern registered under a cross-namespace target is
-      // caught at the batch pre-filter point, not just at the persist gate.
-      let preJudgeRedactionRules: CompiledRedactionRule[] = [];
-      try {
-        // #1713: base rules are source-only. Per-fact routed target rules
-        // (including shared when a fact is routed there) are checked in the
-        // fact loop, matching the write-time gate's per-fact scoping exactly.
-        preJudgeRedactionRules = await redactionRulesFor(storage.dir);
-      } catch { /* fail open */ }
-      try {
-        const judgeCandidates: JudgeCandidate[] = [];
-        const candidateToFactIndex: number[] = [];
-        for (let fi = 0; fi < facts.length; fi++) {
-          const f = facts[fi];
-          if (
-            !f ||
-            typeof f.content !== "string" ||
-            !f.content.trim() ||
-            typeof f.category !== "string" ||
-            !f.category.trim()
-          ) {
-            continue;
-          }
-          // Use the routed category when available so the judge sees the
-          // final persisted category, not the raw extraction-time value.
-          // Cast to MemoryCategory — routing targets are always valid
-          // category slugs defined in the taxonomy; the fallback is the
-          // original ExtractedFact.category which is already typed.
-          const judgeCategory = (preRoutedCategories[fi] ?? f.category) as import("./types.js").MemoryCategory;
-          if (judgeCategory === "procedure") {
-            continue;
-          }
-          const tags = Array.isArray(f.tags) ? f.tags : [];
-          const imp = scoreImportance(
-            f.content,
-            judgeCategory,
-            tags,
-          );
-          // Pre-filter: skip facts below importance threshold to avoid
-          // wasting LLM calls on facts that will be filtered anyway in
-          // the per-fact write loop (issue #376 review finding).
-          if (
-            !isAboveImportanceThreshold(
-              imp.level,
-              this.config.extractionMinImportanceLevel,
-            )
-          ) {
-            continue;
-          }
-          // #1713 P2 (cursor): per-fact rules — load this fact's routed target
-          // namespace rules FIRST, then check. This catches target-only rules
-          // even when the base (source+shared) rules are empty (threads acc58c42
-          // + PBJEe/PBKAj).
-          let factRedactionRules = preJudgeRedactionRules;
-          let factNs = preRoutedNamespaceByFact[fi];
-          // #1713 (codex PRRT_kwDORJXyws6PBj5X): scope classification can route
-          // a scope=global fact to the shared namespace independent of routing
-          // rules. If so, the pre-judge filter must consult the shared
-          // namespace's rules too, or a never-store pattern under shared is
-          // missed at pre-judge and only caught at the write gate — letting the
-          // content reach the extraction judge/training path. Mirror the write
-          // loop's scope-routing conditions exactly.
-          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 { /* fail open */ }
-          }
-          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, factRedactionRules)) continue;
-          }
-          judgeCandidates.push({
-            text: f.content,
-            category: judgeCategory,
-            confidence: typeof f.confidence === "number" ? f.confidence : 0.7,
-            tags,
-            importanceLevel: imp.level,
-          });
-          candidateToFactIndex.push(fi);
-        }
-        // Telemetry + training-pair emit (issue #562 PR 3 + PR 4). The
-        // orchestrator wires two fire-and-forget writers behind a single
-        // callback so `judgeFactDurability` does not need to know about
-        // either ledger. Both handlers are skipped when their flags are
-        // off; the combined callback itself is undefined when both are
-        // disabled so there is zero overhead in the default configuration.
-        const judgeTelemetryOpts = {
-          enabled: lifecycleCaps.extractionJudgeTelemetry,
-          memoryDir: this.config.memoryDir,
-        };
-        const judgeTrainingOpts = {
-          enabled: this.config.collectJudgeTrainingPairs === true,
-          ...(this.config.judgeTrainingDir
-            ? { directory: this.config.judgeTrainingDir }
-            : {}),
-        };
-        const judgeTelemetryHandler =
-          judgeTelemetryOpts.enabled || judgeTrainingOpts.enabled
-            ? (obs: import("./extraction-judge.js").JudgeVerdictObservation) => {
-                const ts = new Date().toISOString();
-                const verdictKind = getVerdictKind(obs.verdict);
-                if (judgeTelemetryOpts.enabled) {
-                  const event: import("./extraction-judge-telemetry.js").JudgeVerdictEvent = {
-                    version: 1,
-                    category: EXTRACTION_JUDGE_VERDICT_CATEGORY,
-                    ts,
-                    verdictKind,
-                    reason: obs.verdict.reason,
-                    deferrals: obs.priorDeferrals,
-                    elapsedMs: obs.elapsedMs,
-                    candidateCategory: obs.candidate.category,
-                    confidence: obs.candidate.confidence,
-                    contentHash: obs.contentHash,
-                    fromCache: obs.source === "cache",
-                    ...(obs.source === "llm-cap-rejected"
-                      ? { deferCapTriggered: true }
-                      : {}),
-                  };
-                  void recordJudgeVerdict(event, judgeTelemetryOpts);
-                }
-                if (judgeTrainingOpts.enabled) {
-                  const pair: import("./extraction-judge-training.js").JudgeTrainingPair = {
-                    version: 1,
-                    ts,
-                    candidateText: obs.candidate.text,
-                    candidateCategory: obs.candidate.category,
-                    ...(typeof obs.candidate.confidence === "number"
-                      ? { candidateConfidence: obs.candidate.confidence }
-                      : {}),
-                    verdictKind,
-                    reason: obs.verdict.reason,
-                    priorDeferrals: obs.priorDeferrals,
-                  };
-                  void recordJudgeTrainingPair(pair, judgeTrainingOpts);
-                }
-              }
-            : undefined;
-        const judgeResult = await judgeFactDurability(
-          judgeCandidates,
-          this.config,
-          this.localLlm,
-          new FallbackLlmClient(
-            this.config.gatewayConfig,
-            fallbackLlmRuntimeContextFromConfig(this.config),
-          ),
-          this.judgeVerdictCache,
-          this.judgeDeferCounts,
-          judgeTelemetryHandler,
-        );
-        // Remap candidate-indexed verdicts to original fact indexes
-        judgeVerdictsByFactIndex = new Map();
-        for (const [candidateIdx, verdict] of judgeResult.verdicts) {
-          const factIdx = candidateToFactIndex[candidateIdx];
-          if (factIdx !== undefined) {
-            judgeVerdictsByFactIndex.set(factIdx, verdict);
-          }
-        }
-        log.info(
-          `extraction-judge: ${judgeResult.verdicts.size}/${judgeCandidates.length} facts evaluated, ` +
-            `${judgeResult.cached} cached, ${judgeResult.judged} judged, ` +
-            `${judgeResult.deferred} deferred` +
-            (judgeResult.deferredCappedToReject > 0
-              ? ` (${judgeResult.deferredCappedToReject} cap-rejected)`
-              : "") +
-            `, ${judgeResult.elapsed}ms`,
-        );
-        // Expose defer count to the caller (issue #562 PR 2) so it can decide
-        // whether to retain buffer turns for the next extraction pass.
-        this.lastPersistExtractionDeferredCount = judgeResult.deferred;
-      } catch (err) {
-        // Fail-open: if the entire judge pipeline errors, proceed without filtering
-        log.warn(
-          `extraction-judge: pipeline error, proceeding without filtering (fail-open): ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
-    }
-
-    // Faithfulness gate (issue #1576). Entailment-verification of extracted
-    // facts against their verified source spans from #1575. Placement: after
-    // parse + provenance validation, BEFORE persist/index (rule 44). The
-    // substantive batch logic lives in the pure module; this is thin
-    // delegation (ground rule 4). off → null map (byte-identical pre-feature
-    // pipeline, rule 39); shadow → record only; enforce → pending_review.
-    const faithfulnessMode = this.config.extractionFaithfulnessGate;
-    const faithfulnessResultsByFactIndex =
-      faithfulnessMode === "shadow" || faithfulnessMode === "enforce"
-        ? await runFaithfulnessGateBatch(
-            facts,
-            faithfulnessMode,
-            this.config,
-            this.localLlm,
-            new FallbackLlmClient(
-              this.config.gatewayConfig,
-              fallbackLlmRuntimeContextFromConfig(this.config),
-            ),
-            this.faithfulnessCounters,
-            sourceText,
-          )
-        : null;
-
-    let factLoopIndex = -1;
-    for (const fact of facts) {
-      factLoopIndex++;
-      if (
-        !fact ||
-        typeof (fact as any).content !== "string" ||
-        !(fact as any).content.trim()
-      ) {
-        continue;
-      }
-      if (
-        typeof (fact as any).category !== "string" ||
-        !(fact as any).category.trim()
-      ) {
-        continue;
-      }
-      (fact as any).tags = Array.isArray((fact as any).tags)
-        ? (fact as any).tags.filter((t: any) => typeof t === "string")
-        : [];
-      (fact as any).confidence =
-        typeof (fact as any).confidence === "number"
-          ? (fact as any).confidence
-          : 0.7;
-      // #1670 — anchor each fact's event-time to its SOURCE TURN timestamp,
-      // not the batch-wide latest. When a buffered conversation spans a date
-      // boundary, a relative expression ("yesterday") on an early-turn fact
-      // must resolve against that early turn's date. Prefer the fact's
-      // explicit sourceTurnTimestamp, then the earliest provenance span's
-      // observedAt, then fall back to the batch anchor (legacy extractors).
-      const factAnchor = pickFactEventTimeAnchor(fact, sourceContext?.validAt);
-      const biTemporal = this.config.temporalBiTemporal && factAnchor ? resolveFactEventTime(fact.eventTime, factAnchor) : undefined;
-      // Content-hash dedup check (v6.0)
-      //
-      // Canonicalize pre-tagged facts before hashing (Codex P2 — issue #369).
-      // When a fact already carries an inline citation (e.g. relayed or
-      // reprocessed), hashing `fact.content` as-is would produce a different
-      // hash than the one stored from the original write (which used the raw,
-      // un-cited body as contentHashSource). Strip any citation first so the
-      // dedup key matches what the hash index recorded.
-      //
-      // stripCitationForTemplate handles both the default and custom template
-      // formats. For all-placeholder templates it cannot detect citations and
-      // returns the text unchanged — dedup may miss in that edge case, which
-      // is acceptable (no false-positive suppression).
-      //
-      // Routing runs before content-hash dedup and scoring so category overrides
-      // affect both the dedup fingerprint and importance (issue #519 procedure routing).
-      let writeCategory = fact.category;
-      let targetStorage = storage;
-      const sourceStorageDir = storage.dir; // #1669 thread #2: pre-routing source ns for redaction gate
-      // Track the KNOWN target namespace NAME alongside targetStorage (round 6,
-      // codex P2 — NCQI0). Re-deriving it from `targetStorage.dir` mangles a raw
-      // namespace literally named like a canonical token (e.g. `ns-616c706861`
-      // served from its legacy raw dir decodes to `alpha`). We seed it from the
-      // EXPLICIT base namespace the caller used to obtain `storage` (NHIdx, codex
-      // P2) — `selfNamespace`/`writeNamespaceOverride` — so the catalog write touch
-      // records the real namespace, not a guess decoded from the directory. We only
-      // fall back to decoding the dir when no base namespace was passed (legacy
-      // callers). The EXPLICIT routed name (below) still overrides this verbatim.
-      let targetNamespaceName =
-        baseNamespace && baseNamespace.length > 0
-          ? baseNamespace
-          : this.storageDirNamespace(targetStorage.dir);
-      let routedRuleId: string | undefined;
-      let routedNamespaceExplicit = false;
-      if (routeRules.length > 0) {
-        try {
-          const routeText = `${fact.category} ${fact.tags.join(" ")} ${fact.content}`;
-          const selected = selectRouteRule(routeText, routeRules, routeOptions);
-          if (selected) {
-            routedRuleId = selected.rule.id;
-            if (selected.target.category) {
-              writeCategory = selected.target.category;
-            }
-            if (selected.target.namespace) {
-              routedNamespaceExplicit = true;
-              targetStorage = await this.storageRouter.storageFor(
-                selected.target.namespace,
-              );
-              targetNamespaceName = selected.target.namespace;
-            }
-          }
-        } catch (err) {
-          log.warn(
-            `routing evaluation failed; fail-open to extracted category/namespace: ${err}`,
-          );
-        }
-      }
-
-      // Scope-based namespace routing: when scope classification is enabled
-      // and the LLM tagged this fact as "global", route it to the shared
-      // namespace so cross-project knowledge is visible everywhere. Only
-      // applies when namespaces are enabled and the fact was not already
-      // routed to a specific namespace by a routing rule (routing rules
-      // that set an explicit namespace take precedence; category-only rules
-      // do not block scope routing). Rule 30: gated by
-      // extractionScopeClassificationEnabled.
-      if (
-        lifecycleCaps.extractionScopeClassification &&
-        namespacesEnabled &&
-        fact.scope === "global" &&
-        !routedNamespaceExplicit
-      ) {
-        const currentNs = this.storageDirNamespace(targetStorage.dir);
-        if (currentNs !== this.config.sharedNamespace && profileAllowsSharedWrites) {
-          try {
-            targetStorage = await this.storageRouter.storageFor(
-              this.config.sharedNamespace,
-            );
-            targetNamespaceName = this.config.sharedNamespace;
-            log.debug(
-              `scope-routing: fact "${fact.content.slice(0, 60)}…" routed to shared namespace (scope=global)`,
-            );
-          } catch (scopeRouteErr) {
-            log.warn(
-              `scope-routing: failed to resolve shared namespace storage; writing to session namespace (fail-open): ${scopeRouteErr}`,
-            );
-          }
-        } else if (currentNs !== this.config.sharedNamespace) {
-          log.debug(
-            `scope-routing: skipped shared namespace for global fact because active scope profile ${scopeProfileWritePlan?.profileId ?? "none"} does not authorize serverShared writes`,
-          );
-        }
-      }
-      // #1669 redaction-rule gate: consult BOTH source and target namespace
-      // rules before any write. A never-store pattern registered under the
-      // source namespace must survive scope-routing to a different target
-      // (review thread #2). Fails open on read error.
-      try {
-        const redactionRules = await redactionRulesFor(sourceStorageDir, targetStorage.dir);
-        const redactionCandidate = fact.content
-          + (fact.structuredAttributes ? " " + JSON.stringify(fact.structuredAttributes) : "")
-          + (fact.procedureSteps ? " " + fact.procedureSteps.map((s) => `${s.intent} ${s.expectedOutcome ?? ""} ${s.toolCall ? `${s.toolCall.kind} ${s.toolCall.signature}` : ""}`.trim()).join(" ") : "");
-        if (redactionRules.length > 0 && contentMatchesRedactionRules(redactionCandidate, redactionRules)) {
-          redactionGatedCount++;
-          log.debug(`extraction: redaction-rule withheld fact #${redactionGatedCount} in ${targetStorage.dir}`);
-          continue;
-        }
-      } catch (redactionErr) {
-        log.warn(`extraction: redaction-rule gate failed open: ${redactionErr}`);
-      }
-
-      // Procedures: fingerprint the full serialized body (title + steps), not
-      // the title alone, so distinct step lists are not collapsed (issue #519).
-      const canonicalContentForHash =
-        citationEnabled &&
-        hasCitationForTemplate(fact.content, citationTemplate)
-          ? stripCitationForTemplate(fact.content, citationTemplate)
-          : fact.content;
-      const contentHashDedupKey =
-        writeCategory === "procedure"
-          ? buildProcedurePersistBody(fact.content, fact.procedureSteps)
-          : canonicalContentForHash;
-      // Importance is scored before the dedup short-circuit so #1671 backfill
-      // can gate on it (cursor PRRT_OvKnS): a low-value duplicate that the
-      // importance write-gate (#372) or the judge pre-filter would drop must
-      // not expire an active fact.
-      const importance = scoreImportance(
-        fact.content,
-        writeCategory,
-        fact.tags,
-      );
-      let exactDuplicate = false;
-      try {
-        exactDuplicate = await this.hasContentHashDedup(
-          targetStorage,
-          contentHashDedupKey,
-        );
-      } catch (err) {
-        log.warn(
-          `content-hash dedup lookup failed for storage ${targetStorage.dir}; writing fact fail-open: ${err}`,
-        );
-      }
-      if (exactDuplicate) {
-        // #1671 — before short-circuiting, backfill bi-temporal bounds
-        // onto the existing source-namespace copy if it lacks bounds the
-        // incoming fact now carries (re-extraction with a resolved invalidAt).
-        // Skip when the fact would be rejected/deferred/pending by downstream
-        // gates — a non-durable candidate must not expire an active fact
-        // (chatgpt-codex P1: faithfulness, requireSpans, extraction judge).
-        // #1671 + #1707: backfill bi-temporal bounds onto the existing
-        // source-namespace copy if it lacks bounds the incoming fact now
-        // carries (re-extraction with a resolved bound). #1707 thread 3:
-        // gate on writeCategory === "fact" — the helper only matches facts,
-        // so a non-fact duplicate must not reach the fact-only scan.
-        // #1707 thread 2: also fire when only a corrected start bound
-        // (validFrom) is present, not just an end bound (validUntil). The
-        // downstream-gate skip still applies — a non-durable candidate must
-        // not expire an active fact (chatgpt-codex P1).
-        if (
-          biTemporal &&
-          writeCategory === "fact" &&
-          (biTemporal.validUntil || biTemporal.validFrom)
-        ) {
-          const fr = faithfulnessResultsByFactIndex?.get(factLoopIndex);
-          const faithfulnessWouldPending =
-            faithfulnessMode === "enforce" &&
-            fr?.ok === true &&
-            (fr.verdict === "unsupported" || fr.verdict === "contradicted");
-          const requireSpansWouldPending =
-            this.config.provenance?.requireSpans === true &&
-            fact.requireSpansPending === true;
-          const judgeVerdict = judgeVerdictsByFactIndex?.get(factLoopIndex);
-          const judgeWouldGate =
-            !this.config.extractionJudgeShadow &&
-            judgeVerdict !== undefined &&
-            !judgeVerdict.durable;
-          // Importance gate (cursor PRRT_OvKnS): below-threshold duplicates
-          // would never persist (#372) and carry no judge verdict (the
-          // pre-filter skips them), so they must not expire an active fact.
-          if (
-            isAboveImportanceThreshold(importance.level, this.config.extractionMinImportanceLevel) &&
-            !faithfulnessWouldPending &&
-            !requireSpansWouldPending &&
-            !judgeWouldGate
-          ) {
-            await this.backfillTemporalBoundsOnDedupHit(
-              targetStorage,
-              contentHashDedupKey,
-              {
-                invalidAt: biTemporal.validUntil,
-                // #1707 thread 2 — carry the corrected start bound too.
-                validFrom: biTemporal.validFrom,
-                observedAt: biTemporal.observedAt,
-                eventTimeSource: biTemporal.eventTimeSource,
-              },
-              fact.entityRef,
-            );
-            // #1707 thread 1 — the source branch short-circuits (`continue`
-            // below) before the promotion dedup paths run, so promoted
-            // shared/profile copies written before the source fact carried
-            // resolved bounds stay stale and cross-namespace recall surfaces
-            // an expired fact. Backfill the promotion targets too (fail-open,
-            // backfill-only — never writes a new promoted copy).
-            await backfillTemporalBoundsOnPromotionCopies({
-              sourceStorage: targetStorage,
-              content: fact.content,
-              category: writeCategory,
-              confidence: fact.confidence,
-              entityRef: fact.entityRef,
-              structuredAttributes: fact.structuredAttributes,
-              bounds: {
-                invalidAt: biTemporal.validUntil,
-                validFrom: biTemporal.validFrom,
-                observedAt: biTemporal.observedAt,
-                eventTimeSource: biTemporal.eventTimeSource,
-              },
-            });
-          }
-        }
-        log.debug(
-          `dedup: skipping duplicate fact "${fact.content.slice(0, 60)}…" in storage ${targetStorage.dir}`,
-        );
-        dedupedCount++;
-        continue;
-      }
-
-      if (writeCategory === "procedure" && this.config.procedural?.enabled !== true) {
-        log.debug("persistExtraction: skip procedure memory (procedural.enabled is false)");
-        continue;
-      }
-
-      // Importance write-gate (issue #372). Drop facts whose locally-scored
-      // level falls below the configured minimum BEFORE the semantic dedup
-      // lookup so that low-importance facts never incur an embedding search.
-      // scoreImportance() already applies category boosts (e.g. corrections
-      // +0.15) before deriving the level, so a correction at raw ~0.35
-      // still lands at "normal" and passes the default gate. Without this
-      // gate, trivial turn-level chatter ("hi", "k", heartbeat pings) gets
-      // persisted as a fact memory and dilutes the store.
-      if (
-        !isAboveImportanceThreshold(
-          importance.level,
-          this.config.extractionMinImportanceLevel,
-        )
-      ) {
-        importanceGatedCount++;
-        const snippet = fact.content.slice(0, 60).replace(/\s+/g, " ").trim();
-        log.debug(`extraction: skip trivial "${snippet}"`);
-        // Log-based counter (no dedicated metric bus in remnic-core yet).
-        // Operators can grep for `metric:importance_gated` in gateway.log
-        // to tune extractionMinImportanceLevel.
-        log.debug(
-          `metric:importance_gated level=${importance.level} threshold=${this.config.extractionMinImportanceLevel} category=${writeCategory} count=${importanceGatedCount}`,
-        );
-        continue;
-      }
-
-      // Extraction judge gate (issue #376 + #562 PR 2). After the local
-      // importance gate passes, consult the judge verdict (computed before
-      // the loop). In active mode, non-durable facts are dropped. In shadow
-      // mode, verdicts are logged but all facts proceed to write.
-      //
-      // Defer verdicts (issue #562): do not persist now, but also do not
-      // cache the outcome so the candidate is re-evaluated on a later
-      // extraction pass. The judge module tracks how many times the same
-      // content has been deferred and converts to reject at the configured
-      // cap, so the orchestrator only needs to skip the write here.
-      if (judgeVerdictsByFactIndex) {
-        const verdict = judgeVerdictsByFactIndex.get(factLoopIndex);
-        if (verdict && !verdict.durable) {
-          const verdictKind = getVerdictKind(verdict);
-          if (this.config.extractionJudgeShadow) {
-            log.info(
-              `extraction-judge[shadow]: would ${verdictKind} "${fact.content.slice(0, 60)}…" reason="${verdict.reason}"`,
-            );
-          } else if (verdictKind === "defer") {
-            judgeGatedCount++;
-            log.debug(
-              `extraction-judge: deferred "${fact.content.slice(0, 60)}…" reason="${verdict.reason}"`,
-            );
-            continue;
-          } else {
-            judgeGatedCount++;
-            log.debug(
-              `extraction-judge: rejected "${fact.content.slice(0, 60)}…" reason="${verdict.reason}"`,
-            );
-            continue;
-          }
-        }
-      }
-
-      // Procedure extraction gate (issue #519): ≥2 steps + trigger phrasing.
-      // Runs even when extractionJudgeEnabled is false (durability judge is unrelated).
-      // Never tied to extractionJudgeShadow — that flag is only for the LLM durability judge.
-      if (writeCategory === "procedure") {
-        const procGate = validateProcedureExtraction({
-          content: fact.content,
-          procedureSteps: fact.procedureSteps,
-        });
-        if (!procGate.durable) {
-          log.debug(
-            `extraction-procedure-gate: rejected "${fact.content.slice(0, 60)}…" reason="${procGate.reason}"`,
-          );
-          continue;
-        }
-      }
-
-      // Faithfulness gate verdict application (issue #1576). Look up the
-      // pre-computed verdict for this fact and translate it to frontmatter +
-      // an optional enforce-mode pending_review status. Logic lives in the
-      // pure module; this is thin read-through (ground rule 4).
-      const { faithfulness: faithfulnessFm, enforceStatus: faithfulnessGateStatus } =
-        applyFaithfulnessVerdict(
-          faithfulnessResultsByFactIndex,
-          factLoopIndex,
-          faithfulnessMode,
-          fact.content,
-          this.faithfulnessCounters,
-        );
-
-      // requireSpans enforcement (issue #1575 PR 2): when an operator opts
-      // into provenance.requireSpans, a fact whose quote could not be located
-      // in any source turn (carried as the transient requireSpansPending
-      // signal from the extraction validator) routes to pending_review — the
-      // same review queue an unsupported faithfulness verdict uses. This is
-      // the persist-path wiring ProvenanceConfig.requireSpans documents.
-      // Faithfulness takes precedence when it already routed the fact; both
-      // gates agree on pending_review so the merge is a simple coalesce
-      // (chatgpt-codex-connector thread 4xB).
-      const requireSpansPendingStatus =
-        this.config.provenance?.requireSpans === true &&
-        fact.requireSpansPending === true
-          ? ("pending_review" as const)
-          : undefined;
-      const faithfulnessEnforceStatus = faithfulnessGateStatus ?? requireSpansPendingStatus;
-
-      // Issue #373 — write-time semantic similarity guard. Hook runs after
-      // the exact content-hash miss and the importance gate so that:
-      //   (a) paraphrased near-duplicates never reach writeMemory(), and
-      //   (b) low-importance facts that will be dropped never trigger an
-      //       embedding lookup (avoids unnecessary API latency/cost).
-      // Fails open when the embedding backend is unavailable.
-      //
-      // Defense in depth (PR #399 review): decideSemanticDedup already
-      // catches lookup errors internally, and the embedding fetch is
-      // bounded by a timeout in embedding-fallback.ts. We still wrap the
-      // whole call in its own try/catch here so that any unexpected
-      // rejection (future refactors, misbehaving custom backends, etc.)
-      // can never block the persist loop — a failure in the dedup path
-      // must always default to "not a duplicate".
-      // Track a pending semantic-skip decision (populated inside the block
-      // below). The actual drop happens AFTER contradiction detection so that
-      // a high-similarity update/correction is linked as a superseding
-      // contradiction rather than silently dropped.
-      let pendingSemanticSkip: (SemanticDedupDecision & { action: "skip" }) | null = null;
-      if (resolvePipelineProcessingCapabilities(this.config).semanticDedup) {
-        let semanticDecision: SemanticDedupDecision;
-        // UUI2: skip embedding lookup for the rest of this batch once we know
-        // the backend is unavailable. The flag is reset per-batch (set to false
-        // at the top of persistExtraction), so a transient hiccup in one call
-        // does not permanently disable dedup in subsequent calls.
-        if (batchBackendUnavailable) {
-          semanticDecision = { action: "keep", reason: "backend_unavailable" };
-        } else {
-          try {
-            // Pass the resolved target storage so the lookup scopes the
-            // embedding index to the target namespace (PR #399 P1 fix).
-            // Without this, a high-similarity hit in a different namespace
-            // would cause the fact to be dropped here — cross-namespace
-            // write suppression / data loss.
-            const lookupStorage = targetStorage;
-            semanticDecision = await decideSemanticDedup(
-              fact.content,
-              (content, limit) =>
-                this.semanticDedupLookup(content, limit, lookupStorage),
-              {
-                enabled: true,
-                threshold: this.config.semanticDedupThreshold,
-                candidates: this.config.semanticDedupCandidates,
-              },
-            );
-          } catch (err) {
-            log.warn(
-              `semantic dedup decision failed; failing open and writing fact: ${err}`,
-            );
-            semanticDecision = {
-              action: "keep",
-              reason: "backend_unavailable",
-            };
-          }
-          // UUI2: cache the backend-unavailable signal for the rest of this batch.
-          if (semanticDecision.reason === "backend_unavailable") {
-            batchBackendUnavailable = true;
-          }
-        }
-        if (semanticDecision.action === "skip") {
-          pendingSemanticSkip = semanticDecision;
-        }
-      }
-
-      const inferredIntent = resolveConversationContextCapabilities(this.config).intentRouting
-        ? inferIntentFromText(
-            `${writeCategory} ${fact.tags.join(" ")} ${fact.content}`,
-          )
-        : null;
-      const extractionWriteSource =
-        (fact as any).source === "proactive"
-          ? "extraction-proactive"
-          : "extraction";
-
-      // Check for contradictions before writing (Phase 2B).
-      // NOTE: This block was moved above the chunking branch so that the
-      // pendingSemanticSkip guard (below) can also protect the chunking path.
-      // Previously, contradiction detection only ran on the non-chunked path,
-      // meaning chunked facts could be persisted even when semanticDecision was
-      // "skip" (the deferred guard was bypassed by the chunking `continue`).
-      let supersedes: string | undefined;
-      let links: MemoryLink[] = [];
-      // True when contradiction detection ran and confirmed a contradiction,
-      // regardless of whether auto-resolve is enabled. Used by the
-      // semantic-skip guard so that contradictory updates are never silently
-      // dropped — even when `contradictionAutoResolve=false` (in which case
-      // `supersedes` is intentionally left unset to avoid retiring the old
-      // memory without user confirmation).
-      let contradictionDetected = false;
-      // #1645: hoist the contradiction result so the deferred auto-resolve
-      // (post-write, gated on tombstone status) can read its fields.
-      let contradiction: {
-        supersededId: string;
-        confidence: number;
-        reason: string;
-        supersededPath: string;
-        supersededCreated: string;
-        supersededTags: string[];
-      } | null | undefined;
-
-      // Faithfulness gate (#1576, chatgpt P2): skip contradiction detection
-      // for a pending_review fact — an unfaithful extraction in the review queue
-      // must not trigger auto-resolve and retire an existing active memory.
-      if (
-        resolveRecallEnhancementCapabilities(this.config).contradictionDetection &&
-        this.qmd.isAvailable() &&
-        faithfulnessEnforceStatus !== "pending_review"
-      ) {
-        const targetNamespace = this.storageDirNamespace(targetStorage.dir);
-        contradiction = await this.checkForContradiction(
-          fact.content,
-          writeCategory,
-          targetNamespace,
-        );
-        if (contradiction) {
-          contradictionDetected = true;
-          // When auto-resolve is enabled the existing memory has already been
-          // marked superseded; set `supersedes` so the new write carries the
-          // relationship. When auto-resolve is disabled we still record the
-          // contradiction link (so the memory is annotated for manual review)
-          // but do NOT set `supersedes` on the new write — the old memory
-          // remains active until a human resolves it.
-          if (this.config.contradictionAutoResolve) {
-            supersedes = contradiction.supersededId;
-          }
-          links.push({
-            targetId: contradiction.supersededId,
-            linkType: "contradicts",
-            strength: contradiction.confidence,
-            reason: contradiction.reason,
-          });
-          // #1645: deindex + supersede are deferred to after writeMemory so the
-          // caller can gate them on the new write's tombstone status. A
-          // tombstone-blocked write (pending_review) must not deindex or retire
-          // the existing active memory — see the post-write guard below.
-        }
-      }
-
-      // Apply the deferred semantic-skip now that contradiction detection has
-      // run. If a contradiction was found (contradictionDetected is true), the
-      // candidate is a contradictory update and must be written — do not skip
-      // it. Only drop it when there is no detected contradiction (true
-      // near-duplicate). This check intentionally runs BEFORE the chunking
-      // branch so that a fact flagged as a semantic near-duplicate cannot be
-      // persisted (with its hash registered) simply because it was long enough
-      // to trigger chunking.
-      //
-      // NOTE: We use `contradictionDetected` rather than `!!supersedes` here
-      // so that facts are preserved even when `contradictionAutoResolve=false`.
-      // When auto-resolve is disabled `supersedes` is intentionally unset, but
-      // the write must still proceed so the user can manually reconcile the
-      // two memories later.
-      //
-      // UUI1: correction category writes are NEVER suppressed by the semantic
-      // skip fallback, regardless of whether supersedes is set. When contradiction
-      // detection is disabled or QMD is unavailable, supersedes is never set —
-      // without this exemption a high-similarity correction would be silently
-      // dropped, leaving a stale fact active. writeCategory (not fact.category)
-      // is used because routing rules may have overridden the raw category.
-      const isCorrection = writeCategory === "correction";
-      // Faithfulness gate (#1576, cursor High): a pending_review fact must
-      // bypass the semantic-dedup skip so it reaches the review queue — the
-      // gate's contract is "persists with status: pending_review, never
-      // silently dropped" (issue #1576).
-      if (
-        pendingSemanticSkip &&
-        !contradictionDetected &&
-        !isCorrection &&
-        faithfulnessEnforceStatus !== "pending_review"
-      ) {
-        log.debug(
-          `dedup: skipping semantic near-duplicate fact "${fact.content
-            .slice(0, 60)
-            .replace(/\s+/g, " ")}…" score=${pendingSemanticSkip.topScore.toFixed(
-            3,
-          )} neighbor=${pendingSemanticSkip.topId}`,
-        );
-        dedupedCount++;
-        // Do NOT add fact.content to contentHashIndex here. No memory was
-        // persisted for this fact, so registering a synthetic hash would
-        // permanently suppress exact-copy writes once the neighbor memory is
-        // archived or deleted (the hash would linger with no backing record).
-        continue;
-      }
-
-      // Check if chunking is enabled and content should be chunked.
-      // When semanticChunkingEnabled is true, prefer the embedding-based
-      // semantic chunker which produces more coherent topic-aligned segments.
-      // Falls back to the recursive sentence-boundary chunker on failure.
-      if (resolvePipelineProcessingCapabilities(this.config).chunking && writeCategory !== "procedure") {
-        let chunkResult: { chunked: boolean; chunks: { content: string; index: number; tokenCount: number }[] };
-
-        if (resolvePipelineProcessingCapabilities(this.config).semanticChunking) {
-          try {
-            const embedFn = this.embeddingFallback.embedTexts.bind(this.embeddingFallback);
-            const semanticResult: SemanticChunkResult = await semanticChunkContent(
-              fact.content,
-              embedFn,
-              this.config.semanticChunkingConfig,
-            );
-            chunkResult = semanticResult;
-          } catch (err) {
-            // Honor the fallbackToRecursive contract: when the user explicitly
-            // disables fallback, re-throw so extraction fails fast instead of
-            // silently using the recursive chunker. semanticChunkContent already
-            // throws when fallback is disabled, but this outer catch swallowed
-            // that signal. (PR #439 post-merge Finding 1.)
-            if (this.config.semanticChunkingConfig?.fallbackToRecursive === false) {
-              throw err;
-            }
-            log.debug(
-              `semantic chunking failed, falling back to recursive chunker: ${err}`,
-            );
-            chunkResult = chunkContent(fact.content, chunkingConfig);
-          }
-        } else {
-          chunkResult = chunkContent(fact.content, chunkingConfig);
-        }
-
-        if (chunkResult.chunked && chunkResult.chunks.length > 1) {
-          // Classify memory kind (v8.0 Phase 2B: HiMem episode/note dual store)
-          const memoryKind = resolvePresentationCapabilities(this.config).episodeNoteMode
-            ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory)
-            : undefined;
-
-          // Write the parent memory first (with full content for reference).
-          //
-          // Compute the cited content once so that writeMemory and writeArtifact
-          // (when verbatim artifacts are enabled) share the same citation timestamp.
-          // See the normal write path comment for the full dedup rationale.
-          //
-          // Propagate supersedes/links from contradiction detection (round 6
-          // fix): contradiction detection now runs BEFORE this branch so the
-          // parent must carry the supersession relationship — without it the
-          // old memory is deindexed but the new chunked parent has no link
-          // back, leaving a dangling deindex with no replacement reference.
-          // Child chunks intentionally do NOT carry supersedes; only the
-          // parent represents the logical memory unit.
-          // Canonicalize contentHashSource before writing (Thread 3 — Codex P2,
-          // issue #369). If fact.content already carries an inline citation
-          // (e.g. re-processed or relayed fact), strip it so contentHashSource
-          // records the raw un-cited body — matching what the dedup check hashes
-          // via stripCitationForTemplate before calling hasFactContentHash.
-          const rawChunkedContent =
-            citationEnabled &&
-            hasCitationForTemplate(fact.content, citationTemplate)
-              ? stripCitationForTemplate(fact.content, citationTemplate)
-              : fact.content;
-          const citedChunkedContent = applyInlineCitation(rawChunkedContent);
-          const parentWrite = await targetStorage.writeMemory(
-            writeCategory,
-            citedChunkedContent,
-            {
-              confidence: fact.confidence,
-              tags: [...fact.tags, "chunked"],
-              entityRef: fact.entityRef,
-              source: extractionWriteSource,
-              importance,
-              supersedes,
-              links: links.length > 0 ? links : undefined,
-              intentGoal: inferredIntent?.goal,
-              intentActionType: inferredIntent?.actionType,
-              intentEntityTypes: inferredIntent?.entityTypes,
-              memoryKind,
-              structuredAttributes: fact.structuredAttributes,
-              validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
-              ...(biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...(biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}) } : {}),
-              contentHashSource: rawChunkedContent,
-              // Faithfulness gate (issue #1576).
-              ...(faithfulnessFm ? { faithfulness: faithfulnessFm } : {}),
-              ...(faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {}),
-              // Claim-level provenance spans (issue #1575 PR 2).
-              ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
-              ...(fact.provenance ? { provenance: fact.provenance } : {}),
-            },
-          );
-          const parentId = parentWrite.id;
-          // #1645: surface the tombstone block and gate active post-write paths
-          // (chunks, supersession, shared promotion, graph/artifact) like #1576.
-          const tombstoneBlocked = parentWrite.tombstoneBlocked;
-          const postWriteGuard =
-            faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked;
-          // #1645: defer contradiction auto-resolve until tombstone status is
-          // known (see applyDeferredContradictionResolve).
-          await this.applyDeferredContradictionResolve(
-            contradiction,
-            targetStorage,
-            parentId,
-            postWriteGuard,
-          );
-          try {
-            // Write individual chunks with parent reference
-            for (const chunk of chunkResult.chunks) {
-              // Score each chunk's importance separately
-              const chunkImportance = scoreImportance(
-                chunk.content,
-                writeCategory,
-                fact.tags,
-              );
-              const chunkWriteSource =
-                (fact as any).source === "proactive"
-                  ? "chunking-proactive"
-                  : "chunking";
-
-              await targetStorage.writeChunk(
-                parentId,
-                chunk.index,
-                chunkResult.chunks.length,
-                writeCategory,
-                // Each chunk carries its own inline citation so provenance
-                // survives when a single chunk is quoted in isolation.
-                applyInlineCitation(chunk.content),
-                {
-                  confidence: fact.confidence,
-                  tags: fact.tags,
-                  entityRef: fact.entityRef,
-                  source: chunkWriteSource,
-                  importance: chunkImportance,
-                  intentGoal: inferredIntent?.goal,
-                  intentActionType: inferredIntent?.actionType,
-                  intentEntityTypes: inferredIntent?.entityTypes,
-                  memoryKind,
-                  validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
-                  // #1578: propagate end bound + provenance to chunks (cursor bugbot).
-                  ...(biTemporal
-                    ? {
-                        observedAt: biTemporal.observedAt,
-                        eventTimeSource: biTemporal.eventTimeSource,
-                        ...(biTemporal.validUntil
-                          ? { invalidAt: biTemporal.validUntil }
-                          : {}),
-                      }
-                    : {}),
-                  // Faithfulness gate (issue #1576): propagate the parent
-                  // fact's verdict + enforce status so a pending_review fact
-                  // is not indexed as active through its chunks (chatgpt P2).
-                  ...(faithfulnessFm ? { faithfulness: faithfulnessFm } : {}),
-                  // #1645 (OchiE): inherit pending_review + blockedBy so no chunk lands active.
-                  ...(postWriteGuard
-                    ? { status: "pending_review" as const }
-                    : (faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {})),
-                  ...(tombstoneBlocked && 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
-                  // the verified span (chatgpt-codex-connector thread Ocvmo).
-                  ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
-                  ...(fact.provenance ? { provenance: fact.provenance } : {}),
-                },
-              );
-            }
-          } finally {
-            // The parent memory is durable once writeMemory returns `parentId`.
-            // Touch immediately around the chunk-write loop so a later chunk
-            // failure still surfaces the partially durable parent/chunk files to
-            // catalog-driven `writtenSince` maintenance. The final touch below
-            // still refreshes `lastWriteAt` after later durable writes on success.
-          }
-
-          if (routedRuleId) {
-            log.debug(
-              `routing applied for chunked memory ${parentId}: rule=${routedRuleId} category=${writeCategory} storage=${targetStorage.dir}`,
-            );
-          }
-          log.debug(
-            `chunked memory ${parentId} into ${chunkResult.chunks.length} chunks`,
-          );
-          trackPersistedId(targetStorage, parentId, {
-            pendingReview: postWriteGuard,
-          });
-          // #1576 (cursor Medium): keep pending_review ids out of threadEpisodeIdsForGraph — else later active facts build thread-predecessor edges to an unfaithful memory.
-          if (
-            !postWriteGuard &&
-            threadEpisodeIdsForGraph &&
-            !threadEpisodeIdsForGraph.includes(parentId)
-          ) {
-            threadEpisodeIdsForGraph.push(parentId);
-          }
-          // #1645: same gate as the non-chunked path — a blocked chunked parent
-          // must not enter the embedding-fallback index (resurrection).
-          if (!postWriteGuard) {
-            await this.indexPersistedMemory(targetStorage, parentId);
-          }
-          // PR #402 Thread 1 fix: run source-namespace temporal supersession for
-          // chunked writes, matching the non-chunked path.  Without this the
-          // source namespace retains stale facts that should have been superseded.
-          // Faithfulness gate (#1576, cursor High): skip supersession for a
-          // pending_review fact — an unfaithful extraction in the review queue
-          // must NOT retire older active memories.
-          if (!postWriteGuard) {
-            try {
-              const supersessionEntityRef =
-                typeof (fact as any).entityRef === "string"
-                  ? ((fact as any).entityRef as string)
-                  : undefined;
-              await applyTemporalSupersession({
-                storage: targetStorage,
-                newMemoryId: parentId,
-                entityRef: supersessionEntityRef,
-                structuredAttributes: fact.structuredAttributes,
-                createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
-                // #1578 r3: an extracted end-only bound (validFrom absent) is
-                // historical, not a new authoritative state — never let it
-                // supersede a later active fact (codex P1 on :15534).
-                enabled: lifecycleCaps.temporalSupersession &&
-                  !(biTemporal && !biTemporal.validFrom),
-              });
-            } catch (err) {
-              log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
-            }
-          }
-          // Faithfulness gate (#1576, chatgpt P2): do not promote a
-          // pending_review fact to shared/profile — it must enter the review
-          // queue without active copies that bypass the gate.
-          if (!postWriteGuard) await promoteMemoryToShared({
-            sourceStorage: targetStorage,
-            category: writeCategory,
-            content: fact.content,
-            confidence: fact.confidence,
-            tags: fact.tags,
-            entityRef: fact.entityRef,
-            structuredAttributes: fact.structuredAttributes,
-            sourceMemoryId: parentId,
-            importance,
-            intentGoal: inferredIntent?.goal,
-            intentActionType: inferredIntent?.actionType,
-            intentEntityTypes: inferredIntent?.entityTypes,
-            memoryKind,
-            validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
-            ...(biTemporal
-              ? {
-                  observedAt: biTemporal.observedAt,
-                  eventTimeSource: biTemporal.eventTimeSource,
-                  ...(biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}),
-                }
-              : {}),
-            source: extractionWriteSource,
-            ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
-            ...(fact.provenance ? { provenance: fact.provenance } : {}),
-          });
-          // Register chunked content in the target storage hash index too.
-          // Thread 3 fix: canonicalize by stripping any pre-existing citation
-          // so the stored hash matches what the dedup check computes.
-          try {
-            const canonicalChunkedContent =
-              citationEnabled &&
-              hasCitationForTemplate(fact.content, citationTemplate)
-                ? stripCitationForTemplate(fact.content, citationTemplate)
-                : fact.content;
-            // #1645: do NOT register a tombstone-blocked fact's content in the
-            // dedup index — writeMemory already skipped it (rule 44). Re-adding
-            // would let the next extraction dedup-skip the tombstone chokepoint
-            // and silently ban the retired content (no pending_review row).
-            if (!tombstoneBlocked) {
-              await this.addContentHashDedup(targetStorage, canonicalChunkedContent);
-            }
-          } catch (err) {
-            log.warn(
-              `content-hash dedup registration failed for chunked memory ${parentId}: ${err}`,
-            );
-          }
-
-          for (const chunk of chunkResult.chunks) {
-            const chunkId = `${parentId}-chunk-${chunk.index}`;
-            // Do NOT push chunkId into persistedIds — chunk IDs must not leak
-            // into boxBuilder.onExtraction() or threading.processTurn(), which
-            // only expect canonical parent memory IDs.  Call indexPersistedMemory
-            // directly for embedding-fallback sync of each chunk document.
-            // #1645: chunks inherit pending_review under postWriteGuard — don't
-            // index them into the embedding fallback (resurrection).
-            if (!postWriteGuard) {
-              await this.indexPersistedMemory(targetStorage, chunkId);
-            }
-          }
-          try {
-            if (
-              resolvePresentationCapabilities(this.config).verbatimArtifacts &&
-              this.config.verbatimArtifactCategories.includes(writeCategory) &&
-              fact.confidence >= this.config.verbatimArtifactsMinConfidence &&
-              !postWriteGuard
-            ) {
-              // Reuse citedChunkedContent so the artifact carries the same citation
-              // timestamp as the parent memory write above (Fix #3 — duplicate-citation).
-              await targetStorage.writeArtifact(citedChunkedContent, {
-                confidence: fact.confidence,
-                tags: [...fact.tags, "artifact", "chunked-parent"],
-                artifactType: this.artifactTypeForCategory(writeCategory),
-                sourceMemoryId: parentId,
-                intentGoal: inferredIntent?.goal,
-                intentActionType: inferredIntent?.actionType,
-                intentEntityTypes: inferredIntent?.entityTypes,
-              });
-            }
-            // v8.2: graph edge building for chunked memories. #1576: skip pending_review.
-            if (graphCaps.multiGraphMemory && !postWriteGuard) {
-              try {
-                const graphContext = await ensureGraphContext(targetStorage);
-                const entityRef =
-                  typeof (fact as any).entityRef === "string"
-                    ? (fact as any).entityRef
-                    : undefined;
-                const parentRelPath = resolvePersistedMemoryRelativePath({
-                  memoryId: parentId,
-                  pathById: graphContext.memoryPathById,
-                  category: writeCategory,
-                });
-                graphContext.memoryPathById.set(parentId, parentRelPath);
-                appendMemoryToGraphContext({
-                  allMemsForGraph: graphContext.allMemsForGraph,
-                  storageDir: targetStorage.dir,
-                  memoryRelPath: parentRelPath,
-                  memoryId: parentId,
-                  category: writeCategory,
-                  content: fact.content ?? "",
-                  entityRef,
-                });
-                await this.buildGraphEdge(
-                  targetStorage,
-                  parentRelPath,
-                  entityRef,
-                  parentId,
-                  fact.content ?? "",
-                  graphContext.allMemsForGraph,
-                  graphContext.memoryPathById,
-                  threadIdForExtraction ?? undefined,
-                  threadEpisodeIdsForGraph,
-                  graphContext.previousPersistedRelPath,
-                  graphCaps,
-                );
-                graphContext.previousPersistedRelPath = parentRelPath;
-              } catch {
-                /* fail-open */
-              }
-            }
-          } finally {
-            // Catalog touch (issue #1499): refresh AFTER later chunked
-            // source-namespace durable mutations — temporal supersession, shared
-            // promotion, optional artifact writes, and graph-edge writes — so
-            // `lastWriteAt` cannot precede later file changes on successful
-            // completion. Use the KNOWN routed name, not a dir-decoded guess.
-          }
-          trackBehaviorSignals(
-            targetStorage,
-            buildBehaviorSignalsForMemory({
-              memoryId: parentId,
-              category: writeCategory,
-              content: fact.content,
-              namespace: this.storageDirNamespace(targetStorage.dir),
-              confidence: fact.confidence,
-              source: "extraction",
-            }),
-          );
-          continue; // Skip the normal write below
-        }
-      }
-
-      // Suggest links for this memory (Phase 3A)
-      if (resolveRecallEnhancementCapabilities(this.config).memoryLinking && this.qmd.isAvailable()) {
-        const targetNamespace = this.storageDirNamespace(targetStorage.dir);
-        const suggestedLinks = await this.suggestLinksForMemory(
-          fact.content,
-          writeCategory,
-          targetNamespace,
-        );
-        if (suggestedLinks.length > 0) {
-          links.push(...suggestedLinks);
-        }
-      }
-
-      // Classify memory kind (v8.0 Phase 2B: HiMem episode/note dual store)
-      const memoryKind =
-        writeCategory === "procedure"
-          ? undefined
-          : resolvePresentationCapabilities(this.config).episodeNoteMode
-            ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory)
-            : undefined;
-
-      // Normal write (no chunking)
-      // Compute the cited content once so that writeMemory and writeArtifact
-      // (when verbatim artifacts are enabled) share the same citation timestamp.
-      // Calling applyInlineCitation twice on the same raw content would produce
-      // two different timestamps, creating duplicate citations with divergent
-      // provenance metadata on the memory and artifact copies of the same fact.
-      // Pass the RAW (pre-citation) fact as `contentHashSource` so the
-      // fact-content hash index records the hash of the canonical fact text
-      // rather than the citation-annotated variant. When inline attribution is
-      // enabled, `applyInlineCitation` appends a timestamp-bearing marker, so
-      // hashing the persisted body would produce a different hash on every
-      // write and defeat cross-session dedup (see `findDuplicateExplicitCapture`
-      // in explicit-capture.ts which calls `hasFactContentHash(candidate.content)`
-      // on raw content).
-      const rawPersistBody =
-        writeCategory === "procedure"
-          ? buildProcedurePersistBody(fact.content, fact.procedureSteps)
-          : fact.content;
-      const citedFactContent = applyInlineCitation(rawPersistBody);
-      const factWrite = await targetStorage.writeMemory(
-        writeCategory,
-        citedFactContent,
-        {
-          confidence: fact.confidence,
-          tags: fact.tags,
-          entityRef:
-            typeof (fact as any).entityRef === "string"
-              ? (fact as any).entityRef
-              : undefined,
-          source: extractionWriteSource,
-          importance,
-          supersedes,
-          links: links.length > 0 ? links : undefined,
-          intentGoal: inferredIntent?.goal,
-          intentActionType: inferredIntent?.actionType,
-          intentEntityTypes: inferredIntent?.entityTypes,
-          memoryKind,
-          structuredAttributes: fact.structuredAttributes,
-          validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
-          ...(biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...(biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}) } : {}),
-          contentHashSource: writeCategory === "fact" ? fact.content : undefined,
-          // Faithfulness gate (issue #1576).
-          ...(faithfulnessFm ? { faithfulness: faithfulnessFm } : {}),
-          ...(faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {}),
-          // Claim-level provenance spans (issue #1575 PR 2). Carry verified
-          // sources + the coarse strength tag from the extraction validator
-          // through to frontmatter so they survive end-to-end.
-          ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
-          ...(fact.provenance ? { provenance: fact.provenance } : {}),
-        },
-      );
-      const memoryId = factWrite.id;
-      // #1645: surface the tombstone block; gate active post-write paths like #1576
-      // so a blocked fact creates no active shared copy / supersession / graph entry.
-      const tombstoneBlocked = factWrite.tombstoneBlocked;
-      const postWriteGuard =
-        faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked;
-      // #1645: defer contradiction auto-resolve until tombstone status is
-      // known (see applyDeferredContradictionResolve).
-      await this.applyDeferredContradictionResolve(
-        contradiction,
-        targetStorage,
-        memoryId,
-        postWriteGuard,
-      );
-      if (routedRuleId) {
-        log.debug(
-          `routing applied for memory ${memoryId}: rule=${routedRuleId} category=${writeCategory} storage=${targetStorage.dir}`,
-        );
-      }
-      // Temporal supersession (issue #375): when the new fact has structured
-      // attributes, retire any older fact with the same entity + attribute
-      // key that has a conflicting value. Faithfulness gate (#1576, cursor
-      // High): skip for a pending_review fact — an unfaithful extraction in
-      // the review queue must NOT retire older active memories.
-      if (!postWriteGuard) {
-        try {
-          const supersessionEntityRef =
-            typeof (fact as any).entityRef === "string"
-              ? ((fact as any).entityRef as string)
-              : undefined;
-          await applyTemporalSupersession({
-            storage: targetStorage,
-            newMemoryId: memoryId,
-            entityRef: supersessionEntityRef,
-            structuredAttributes: fact.structuredAttributes,
-            createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
-            enabled: lifecycleCaps.temporalSupersession &&
-              !(biTemporal && !biTemporal.validFrom),
-          });
-        } catch (err) {
-          log.warn(`temporal-supersession: unexpected error: ${err}`);
-        }
-      }
-      try {
-        trackBehaviorSignals(
-          targetStorage,
-          buildBehaviorSignalsForMemory({
-            memoryId,
-            category: writeCategory,
-            content: fact.content,
-            namespace: this.storageDirNamespace(targetStorage.dir),
-            confidence: fact.confidence,
-            source: "extraction",
-          }),
-        );
-        trackPersistedId(targetStorage, memoryId, {
-          pendingReview: postWriteGuard,
-        });
-        if (
-          !postWriteGuard &&
-          threadEpisodeIdsForGraph &&
-          !threadEpisodeIdsForGraph.includes(memoryId)
-        ) {
-          threadEpisodeIdsForGraph.push(memoryId);
-        }
-        // #1645: a tombstone-blocked / pending_review fact must NOT enter the
-        // embedding-fallback index — otherwise embedding recall surfaces the
-        // pending_review row (resurrection). Gate on postWriteGuard like the
-        // surrounding supersession / promotion / graph paths.
-        if (!postWriteGuard) {
-          await this.indexPersistedMemory(targetStorage, memoryId);
-        }
-        // Faithfulness gate (#1576, chatgpt P2): skip promotion for a
-        // pending_review fact so no active shared/profile copy bypasses the gate.
-        if (!postWriteGuard) await promoteMemoryToShared({
-          sourceStorage: targetStorage,
-          category: writeCategory,
-          content: fact.content,
-          confidence: fact.confidence,
-          tags: fact.tags,
-          entityRef:
-            typeof (fact as any).entityRef === "string"
-              ? (fact as any).entityRef
-              : undefined,
-          structuredAttributes: fact.structuredAttributes,
-          sourceMemoryId: memoryId,
-          importance,
-          intentGoal: inferredIntent?.goal,
-          intentActionType: inferredIntent?.actionType,
-          intentEntityTypes: inferredIntent?.entityTypes,
-          memoryKind,
-          validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
-          ...(biTemporal
-            ? {
-                observedAt: biTemporal.observedAt,
-                eventTimeSource: biTemporal.eventTimeSource,
-                ...(biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}),
-              }
-            : {}),
-          source: extractionWriteSource,
-          ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
-          ...(fact.provenance ? { provenance: fact.provenance } : {}),
-        });
-        // v8.2: graph edge building (fail-open). #1576: skip pending_review facts.
-        if (graphCaps.multiGraphMemory && !postWriteGuard) {
-          try {
-            const graphContext = await ensureGraphContext(targetStorage);
-            const entityRef =
-              typeof (fact as any).entityRef === "string"
-                ? (fact as any).entityRef
-                : undefined;
-            const memoryRelPath = resolvePersistedMemoryRelativePath({
-              memoryId,
-              pathById: graphContext.memoryPathById,
-              category: writeCategory,
-            });
-            graphContext.memoryPathById.set(memoryId, memoryRelPath);
-            appendMemoryToGraphContext({
-              allMemsForGraph: graphContext.allMemsForGraph,
-              storageDir: targetStorage.dir,
-              memoryRelPath: memoryRelPath,
-              memoryId,
-              category: writeCategory,
-              content: fact.content ?? "",
-              entityRef,
-            });
-            await this.buildGraphEdge(
-              targetStorage,
-              memoryRelPath,
-              entityRef,
-              memoryId,
-              fact.content ?? "",
-              graphContext.allMemsForGraph,
-              graphContext.memoryPathById,
-              threadIdForExtraction ?? undefined,
-              threadEpisodeIdsForGraph,
-              graphContext.previousPersistedRelPath,
-              graphCaps,
-            );
-            graphContext.previousPersistedRelPath = memoryRelPath;
-          } catch {
-            /* fail-open */
-          }
-        }
-        if (
-          resolvePresentationCapabilities(this.config).verbatimArtifacts &&
-          this.config.verbatimArtifactCategories.includes(writeCategory) &&
-          fact.confidence >= this.config.verbatimArtifactsMinConfidence &&
-          !postWriteGuard
-        ) {
-          // Reuse citedFactContent so the artifact carries the same citation
-          // timestamp as the memory write above (Fix #3 — duplicate-citation).
-          await targetStorage.writeArtifact(citedFactContent, {
-            confidence: fact.confidence,
-            tags: [...fact.tags, "artifact"],
-            artifactType: this.artifactTypeForCategory(writeCategory),
-            sourceMemoryId: memoryId,
-            intentGoal: inferredIntent?.goal,
-            intentActionType: inferredIntent?.actionType,
-            intentEntityTypes: inferredIntent?.entityTypes,
-          });
-        }
-        // Register in the target storage content-hash index after successful
-        // write. Thread 3 fix: canonicalize by stripping any pre-existing
-        // citation so the stored hash matches what the dedup check computes.
-        try {
-          const canonicalFactContent =
-            citationEnabled &&
-            hasCitationForTemplate(fact.content, citationTemplate)
-              ? stripCitationForTemplate(fact.content, citationTemplate)
-              : fact.content;
-          const hashRegisterKey =
-            writeCategory === "procedure"
-              ? buildProcedurePersistBody(fact.content, fact.procedureSteps)
-              : canonicalFactContent;
-          // #1645: do NOT register a tombstone-blocked fact's content in the dedup
-          // index (rule 44 defeat) — see chunked path comment.
-          if (!tombstoneBlocked) {
-            await this.addContentHashDedup(targetStorage, hashRegisterKey);
-          }
-        } catch (err) {
-          log.warn(
-            `content-hash dedup registration failed for memory ${memoryId}: ${err}`,
-          );
-        }
-      } finally {
-        // Catalog touch (issue #1499): record AFTER every synchronous
-        // source-namespace mutation in the non-chunked path: writeMemory,
-        // temporal supersession, graph edges, and optional verbatim artifacts.
-        // The `finally` preserves the write touch when post-write indexing or
-        // promotion fails after the canonical memory is already durable. Use the
-        // KNOWN routed name, not a dir-decoded guess (NCQI0).
-      }
-    }
-
-    // Tracks whether THIS extraction persisted any durable, non-fact output to the
-    // BASE namespace's storage (entity / relationship / profile / question). The
-    // per-fact catalog touch (storage chokepoint #1522) only fires inside the fact write loop, so a
-    // fact-less extraction that still persists durable data must record exactly one
-    // base-namespace catalog touch after all writes complete (NHZEZ, codex P2).
-    let durableNonFactWritten = false;
-    let durableNonFactTouchRecorded = false;
-    const touchBaseNonFactNamespace = () => {
-      const baseTouchNamespace =
-        baseNamespace && baseNamespace.length > 0
-          ? baseNamespace
-          : this.storageDirNamespace(storage.dir);
-    };
-    const recordDurableNonFactWrite = () => {
-      durableNonFactWritten = true;
-      if (durableNonFactTouchRecorded) return;
-      durableNonFactTouchRecorded = true;
-      touchBaseNonFactNamespace();
-    };
-    for (const entity of entities) {
-      try {
-        const name = (entity as any)?.name;
-        const type = (entity as any)?.type;
-        if (
-          typeof name !== "string" ||
-          !name.trim() ||
-          typeof type !== "string" ||
-          !type.trim()
-        ) {
-          continue;
-        }
-        const safeFacts = Array.isArray((entity as any)?.facts)
-          ? (entity as any).facts.filter((f: any) => typeof f === "string")
-          : [];
-          const id = await storage.writeEntity(name, type, safeFacts, {
-            source: typeof (entity as any)?.source === "string" ? (entity as any).source : "extraction",
-            timestamp: sourceContext?.validAt,
-            sessionKey: sourceContext?.sessionKey,
-            principal: sourceContext?.principal,
-            structuredSections: Array.isArray((entity as any)?.structuredSections)
-            ? (entity as any).structuredSections
-            : undefined,
-        });
-        if (id) {
-          trackPersistedId(storage, id);
-          recordDurableNonFactWrite();
-        }
-      } catch (err) {
-        log.warn(`persistExtraction: entity write failed: ${err}`);
-      }
-    }
-
-    // Persist entity relationships (v7.0)
-    if (
-      resolveRecallEnhancementCapabilities(this.config).entityRelationships &&
-      Array.isArray(result.relationships)
-    ) {
-      for (const rel of result.relationships.slice(0, 5)) {
-        if (!rel.source || !rel.target || !rel.label) continue;
-        try {
-          // Add bidirectional relationship
-          await storage.addEntityRelationship(rel.source, {
-            target: rel.target,
-            label: rel.label,
-          });
-          recordDurableNonFactWrite();
-          await storage.addEntityRelationship(rel.target, {
-            target: rel.source,
-            label: `${rel.label} (reverse)`,
-          });
-          recordDurableNonFactWrite();
-        } catch (err) {
-          log.debug(`relationship persist failed: ${err}`);
-        }
-      }
-    }
-
-    // Persist entity activity (v7.0)
-    if (resolveRecallEnhancementCapabilities(this.config).entityActivityLog) {
-      const today = new Date().toISOString().slice(0, 10);
-      for (const entity of entities) {
-        const name = (entity as any)?.name;
-        const type = (entity as any)?.type;
-        if (typeof name !== "string" || typeof type !== "string") continue;
-        try {
-          const normalized = storage.normalizeEntityName(name, type);
-          await storage.addEntityActivity(
-            normalized,
-            { date: today, note: "Mentioned in conversation" },
-            this.config.entityActivityLogMaxEntries,
-          );
-        } catch (err) {
-          log.debug(`activity persist failed: ${err}`);
-        }
-      }
-    }
-
-    if (profileUpdates.length > 0) {
-      await storage.appendToProfile(profileUpdates);
-      recordDurableNonFactWrite();
-    }
-
-    // Persist questions
-    for (const q of questions) {
-      const id = await storage.writeQuestion(q.question, q.context, q.priority);
-      if (id) {
-        trackPersistedId(storage, id);
-        recordDurableNonFactWrite();
-      }
-    }
-
-    // Persist identity reflection. This writes durable namespace-local state, so
-    // an identity-ONLY extraction (no facts/entities/profile/questions) still
-    // counts as a durable non-fact write for the catalog touch below (NIIly).
-    // Only count it when the write actually succeeds (best-effort write); the
-    // touch is recorded AFTER this so a rolled-back/failed write never touches.
-    if (resolveRecallEnhancementCapabilities(this.config).identity && result.identityReflection) {
-      try {
-        await storage.appendIdentityReflection(result.identityReflection);
-        recordDurableNonFactWrite();
-      } catch (err) {
-        log.debug(`identity reflection write failed: ${err}`);
-      }
-    }
-
-    // Catalog touch for durable NON-FACT outputs (NHZEZ / NIIly, codex P2). The
-    // per-fact catalog touch (storage chokepoint #1522) above only fires inside the fact write loop, so
-    // an extraction that persists ONLY entities, relationships, profile updates,
-    // questions, or an identity reflection (no facts) would record durable data to
-    // the BASE namespace's storage without ever touching the catalog — leaving that
-    // namespace's `lastWriteAt` stale so `listNamespaces({writtenSince})` /
-    // write-recency QMD maintenance miss the write. All of these are written to the
-    // BASE `storage` (not the per-fact routed `targetStorage`), so we record ONE
-    // base-namespace touch here, AFTER every non-fact write completes. Use the
-    // KNOWN base namespace name, not a dir-decoded guess (NCQI0). One touch per
-    // namespace per extraction — `markWrite` is idempotent, so if the fact path
-    // already touched the base namespace this only refreshes `lastWriteAt`.
-    // Best-effort and failure-tolerant (storage chokepoint #1522 swallows errors).
-    if (durableNonFactWritten) {
-      touchBaseNonFactNamespace();
-    }
-
-    // Save any content-hash indexes touched during the batch.
-    await this.saveContentHashIndexes().catch((err) =>
-      log.warn(`content-hash index save failed: ${err}`),
-    );
-
-    for (const {
-      storage: targetStorage,
-      events,
-    } of behaviorSignalsByStorage.values()) {
-      const dedupedSignals = dedupeBehaviorSignalsByMemoryAndHash(events);
-      if (dedupedSignals.length === 0) continue;
-      await targetStorage
-        .appendBehaviorSignals(dedupedSignals)
-        .catch((err) =>
-          log.warn(`appendBehaviorSignals failed (non-fatal): ${err}`),
-        );
-    }
-
-    const dedupSuffix = dedupedCount > 0 ? ` (${dedupedCount} deduped)` : "";
-    const gatedSuffix =
-      importanceGatedCount > 0 ? ` (${importanceGatedCount} gated)` : "";
-    const judgeSuffix =
-      judgeGatedCount > 0 ? ` (${judgeGatedCount} judge-rejected)` : "";
-    const redactionSuffix =
-      redactionGatedCount > 0 ? ` (${redactionGatedCount} redacted)` : "";
-    log.info(
-      `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`,
-    );
-
-    // Update temporal + tag indexes (v8.1) — fire-and-forget, fail-open
-    void (async () => {
-      if (persistedIdsByStorage.size === 0) {
-        await this.updateTemporalTagIndexes(storage, []);
-        return;
-      }
-      for (const entry of persistedIdsByStorage.values()) {
-        await this.updateTemporalTagIndexes(entry.storage, entry.ids);
-      }
-    })().catch((err) =>
-      log.debug(`temporal-index update error (non-fatal): ${err}`),
-    );
-
-    // #1635: surface pending_review ids so the thread episode set excludes them.
-    this.lastPersistExtractionPendingReviewIds = pendingReviewPersistedIds;
-    // Return the persisted fact IDs for threading
-    return persistedIds;
   }
   /**
    * Append persisted ids to the thread episode set, excluding pending_review
@@ -15599,503 +12527,7 @@ export class Orchestrator {
     merged: number;
     invalidated: number;
   }> {
-    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-    log.info("running consolidation pass");
-    let merged = 0;
-    let invalidated = 0;
-    // Tracks whether any consolidation memory-item action (UPDATE / MERGE /
-    // INVALIDATE) durably rewrote memory state. A consolidation pass that only
-    // mutates memory items (no profile/entity updates) still changes the default
-    // namespace's data, so its catalog `lastWriteAt` must refresh too (NIBOi).
-    let memoryItemMutated = false;
-
-    // Flush access tracking buffer first
-    if (this.accessTrackingBuffer.size > 0) {
-      await this.flushAccessTracking();
-    }
-
-    let allMemories = await this.storage.readAllMemories();
-    if (allMemories.length < 5) {
-      return { memoriesProcessed: allMemories.length, merged, invalidated };
-    }
-
-    const recent = allMemories
-      .sort(
-        (a, b) =>
-          new Date(b.frontmatter.created).getTime() -
-          new Date(a.frontmatter.created).getTime(),
-      )
-      .slice(0, 20);
-
-    const older = allMemories.sort(
-      (a, b) =>
-        new Date(a.frontmatter.created).getTime() -
-        new Date(b.frontmatter.created).getTime(),
-    );
-
-    const profile = await this.storage.readProfile();
-    const result = await this.extraction.consolidate(recent, older, profile);
-
-    // Build a lookup map from the already-loaded corpus to avoid repeated
-    // readAllMemories() scans inside getMemoryById for pre-action deindex reads.
-    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": {
-          // Capture path/frontmatter before invalidation for index cleanup
-          const toInvalidate = resolveIndexingCapabilities(this.config).queryAwareIndexing
-            ? (memoryLookup?.get(item.existingId) ?? null)
-            : null;
-          if (await this.storage.invalidateMemory(item.existingId)) {
-            invalidated += 1;
-            memoryItemMutated = true;
-            await this.embeddingFallback.removeFromIndex(item.existingId);
-            if (toInvalidate?.path && toInvalidate.frontmatter?.created) {
-              deindexMemory(
-                this.config.memoryDir,
-                toInvalidate.path,
-                toInvalidate.frontmatter.created,
-                toInvalidate.frontmatter.tags ?? [],
-              );
-            }
-          }
-          break;
-        }
-        case "UPDATE":
-          if (item.updatedContent) {
-            await this.storage.updateMemory(
-              item.existingId,
-              item.updatedContent,
-              {
-                lineage: [item.existingId],
-              },
-            );
-            memoryItemMutated = true;
-            await this.indexPersistedMemory(this.storage, item.existingId);
-            // updateMemory() only changes content/updated/lineage — path, created, and tags
-            // are preserved, so the temporal/tag index entry is already correct; no reindex needed.
-          }
-          break;
-        case "MERGE":
-          if (item.updatedContent && item.mergeWith) {
-            await this.storage.updateMemory(
-              item.existingId,
-              item.updatedContent,
-              {
-                supersedes: item.mergeWith,
-                lineage: [item.existingId, item.mergeWith],
-              },
-            );
-            memoryItemMutated = true;
-            await this.indexPersistedMemory(this.storage, item.existingId);
-            // updateMemory() only changes content/updated/supersedes/lineage — path, created, and tags
-            // are preserved, so the temporal/tag index entry for the survivor is already correct.
-            // Capture before invalidation for index cleanup
-            const toMergeInvalidate = resolveIndexingCapabilities(this.config).queryAwareIndexing
-              ? (memoryLookup?.get(item.mergeWith) ?? null)
-              : null;
-            if (await this.storage.invalidateMemory(item.mergeWith)) {
-              invalidated += 1;
-              merged += 1;
-              await this.embeddingFallback.removeFromIndex(item.mergeWith);
-              if (
-                toMergeInvalidate?.path &&
-                toMergeInvalidate.frontmatter?.created
-              ) {
-                deindexMemory(
-                  this.config.memoryDir,
-                  toMergeInvalidate.path,
-                  toMergeInvalidate.frontmatter.created,
-                  toMergeInvalidate.frontmatter.tags ?? [],
-                );
-              }
-            }
-          }
-          break;
-      }
-    }
-
-    if (result.profileUpdates.length > 0) {
-      await this.storage.appendToProfile(result.profileUpdates);
-    }
-
-    for (const entity of result.entityUpdates) {
-      const safeFacts = Array.isArray((entity as any)?.facts)
-        ? (entity as any).facts.filter((f: any) => typeof f === "string")
-        : [];
-      await this.storage.writeEntity(entity.name, entity.type, safeFacts, {
-        source: "consolidation",
-        structuredSections: Array.isArray((entity as any)?.structuredSections)
-          ? (entity as any).structuredSections
-          : undefined,
-      });
-    }
-
-    // Catalog write touch accounting (issue #1499 sweep): consolidation persists
-    // durable mutations directly to the default-namespace `this.storage`, bypassing
-    // the extraction write path. We do NOT touch here — later maintenance steps in
-    // this same function (entity-file merges, expired-commitment / TTL cleanup,
-    // fact archival) can ALSO mutate the namespace on a run with no LLM outputs
-    // (NIjwl). So we accumulate every durable mutation into `memoryItemMutated` and
-    // record ONE consolidated touch AFTER all mutation-producing steps complete,
-    // just before returning (rule #25: touch after the write commits). LLM
-    // profile/entity updates and memory-item actions (UPDATE / MERGE / INVALIDATE)
-    // count here (NIBOi).
-    if (result.profileUpdates.length > 0 || result.entityUpdates.length > 0) {
-      memoryItemMutated = true;
-    }
-
-    // Merge fragmented entity files
-    const entitiesMerged = await this.storage.mergeFragmentedEntities();
-    if (entitiesMerged > 0) {
-      memoryItemMutated = true;
-      log.info(`merged ${entitiesMerged} fragmented entity files`);
-    }
-
-    if (resolvePresentationCapabilities(this.config).entitySummary) {
-      try {
-        const synthesized = await this.processEntitySynthesisQueue(
-          this.config.defaultNamespace,
-          5,
-        );
-        if (synthesized > 0) {
-          // Entity synthesis rewrites entity files — a durable namespace mutation,
-          // so record it for the catalog touch even when it is the only change in
-          // the pass (codex). Otherwise lastWriteAt goes stale.
-          memoryItemMutated = true;
-          log.info(`refreshed ${synthesized} entity syntheses`);
-        }
-      } catch (err) {
-        log.debug(`entity synthesis pass failed: ${err}`);
-      }
-    }
-
-    // Clean expired commitments
-    const deletedCommitments = await this.storage.cleanExpiredCommitments(
-      this.config.commitmentDecayDays,
-    );
-    if (deletedCommitments.length > 0) {
-      memoryItemMutated = true;
-      log.info(`cleaned ${deletedCommitments.length} expired commitments`);
-      if (resolveIndexingCapabilities(this.config).queryAwareIndexing) {
-        for (const m of deletedCommitments) {
-          deindexMemory(
-            this.config.memoryDir,
-            m.path,
-            m.frontmatter.created,
-            m.frontmatter.tags ?? [],
-          );
-        }
-      }
-    }
-
-    if (
-      resolveCreationMemoryCapabilities(this.config).creationMemory &&
-      resolveCreationMemoryCapabilities(this.config).commitmentLedger &&
-      resolveCreationMemoryCapabilities(this.config).commitmentLifecycle
-    ) {
-      try {
-        const lifecycle = await applyCommitmentLedgerLifecycle({
-          memoryDir: this.config.memoryDir,
-          commitmentLedgerDir: this.config.commitmentLedgerDir,
-          enabled: true,
-          decayDays: this.config.commitmentDecayDays,
-        });
-        if (
-          lifecycle.transitionedToExpired.length > 0 ||
-          lifecycle.deletedResolved.length > 0
-        ) {
-          memoryItemMutated = true;
-          log.info(
-            `commitment ledger lifecycle: expired ${lifecycle.transitionedToExpired.length}, cleaned ${lifecycle.deletedResolved.length}`,
-          );
-        }
-      } catch (err) {
-        log.debug(`commitment ledger lifecycle pass failed: ${err}`);
-      }
-    }
-
-    // Clean memories past their TTL (speculative memories auto-expire)
-    const deletedTTL = await this.storage.cleanExpiredTTL();
-    if (deletedTTL.length > 0) {
-      memoryItemMutated = true;
-      log.info(`cleaned ${deletedTTL.length} TTL-expired memories`);
-      if (resolveIndexingCapabilities(this.config).queryAwareIndexing) {
-        for (const m of deletedTTL) {
-          deindexMemory(
-            this.config.memoryDir,
-            m.path,
-            m.frontmatter.created,
-            m.frontmatter.tags ?? [],
-          );
-        }
-      }
-    }
-
-    // v8.3 Lifecycle policy pass — deterministic promotion/decay metadata
-    if (lifecycleCaps.lifecyclePolicy) {
-      try {
-        const lightSleepStartedAt = new Date().toISOString();
-        const lifecycleCorpus = await this.storage.readAllMemories();
-        // Lifecycle frontmatter writes count as durable mutations for the catalog
-        // touch below (codex NR-tS), even when no other consolidation step set
-        // memoryItemMutated.
-        if ((await this.runLifecyclePolicyPass(lifecycleCorpus)) > 0) {
-          memoryItemMutated = true;
-        }
-        await this.recordScheduledDreamsPhaseRun(
-          "lightSleep",
-          lifecycleCorpus.length,
-          `scheduled lifecycle policy pass assessed ${lifecycleCorpus.length} memories`,
-          {
-            startedAt: lightSleepStartedAt,
-            completedAt: new Date().toISOString(),
-          },
-        );
-      } catch (err) {
-        log.warn(`lifecycle policy pass failed (ignored): ${err}`);
-      }
-    }
-
-    // v8.3 Compression guideline learning pass (default off, fail-open).
-    await this.runCompressionGuidelineLearningPass();
-
-    try {
-      const deepSleepStartedAt = new Date().toISOString();
-      // Tier migrations move/rewrite memory files; count them as durable
-      // mutations for the catalog touch below (codex NThSW).
-      const tierMigration = await this.runTierMigrationCycle(this.storage, "maintenance");
-      if (tierMigration.migrated > 0) memoryItemMutated = true;
-      allMemories = await this.storage.readAllMemories();
-
-      // Fact archival pass (v6.0) — move old, low-importance, rarely-accessed facts to archive/
-      if (resolveRecallEnhancementCapabilities(this.config).factArchival) {
-        const archived = await this.runFactArchival(allMemories);
-        if (archived > 0) {
-          memoryItemMutated = true;
-          log.info(`archived ${archived} old low-importance facts`);
-        }
-      }
-      await this.recordScheduledDreamsPhaseRun(
-        "deepSleep",
-        allMemories.length,
-        `scheduled deep-sleep maintenance assessed ${allMemories.length} memories`,
-        {
-          startedAt: deepSleepStartedAt,
-          completedAt: new Date().toISOString(),
-        },
-      );
-    } catch (err) {
-      log.warn(`deep-sleep maintenance pass failed (ignored): ${err}`);
-      try {
-        allMemories = await this.storage.readAllMemories();
-      } catch (readErr) {
-        log.warn(`deep-sleep maintenance recovery read failed: ${readErr}`);
-        throw err;
-      }
-    }
-
-    // Semantic consolidation pass — find similar memories, synthesize canonical versions
-    if (resolveConsolidationCapabilities(this.config).semanticConsolidation) {
-      try {
-        const stateFilePath = path.join(
-          this.config.memoryDir,
-          "state",
-          "semantic-consolidation-last-run.json",
-        );
-        let shouldRun = true;
-        try {
-          const stateRaw = await readFile(stateFilePath, "utf-8");
-          const stateData = JSON.parse(stateRaw) as { lastRunAt?: string };
-          if (stateData.lastRunAt) {
-            const lastRunMs = new Date(stateData.lastRunAt).getTime();
-            const intervalMs =
-              this.config.semanticConsolidationIntervalHours * 60 * 60 * 1000;
-            if (Date.now() - lastRunMs < intervalMs) {
-              shouldRun = false;
-              log.debug(
-                "[semantic-consolidation] skipping — not enough time since last run",
-              );
-            }
-          }
-        } catch {
-          // No state file yet — first run
-        }
-
-        if (shouldRun) {
-          const remStartedAt = new Date().toISOString();
-          const semResult = await this.runSemanticConsolidation();
-          let remItemsProcessed = allMemories.length;
-          try {
-            allMemories = await this.storage.readAllMemories();
-            remItemsProcessed = allMemories.length;
-          } catch (err) {
-            log.warn(
-              `[semantic-consolidation] post-run telemetry refresh failed (non-fatal): ${err}`,
-            );
-          }
-          await this.recordScheduledDreamsPhaseRun(
-            "rem",
-            remItemsProcessed,
-            `scheduled REM consolidation found ${semResult.clustersFound} clusters`,
-            {
-              startedAt: remStartedAt,
-              completedAt: new Date().toISOString(),
-            },
-          );
-          if (semResult.memoriesArchived > 0) {
-            log.info(
-              `[semantic-consolidation] archived ${semResult.memoriesArchived} memories during maintenance`,
-            );
-          }
-          // Only persist last-run timestamp if the run succeeded (had no errors or made progress)
-          if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path.join(this.config.memoryDir, "state");
-            await mkdir(stateDir, { recursive: true });
-            await writeFile(
-              stateFilePath,
-              JSON.stringify({ lastRunAt: new Date().toISOString() }),
-              "utf-8",
-            );
-          }
-        }
-      } catch (err) {
-        log.warn(
-          `[semantic-consolidation] maintenance pass failed (non-fatal): ${err}`,
-        );
-      }
-    }
-
-    // Auto-consolidate IDENTITY.md if it's getting large
-    if (resolveRecallEnhancementCapabilities(this.config).identity) {
-      await this.autoConsolidateIdentity();
-    }
-
-    // Auto-consolidate profile.md if it exceeds max lines
-    const profileSection = this.getRecallSectionEntry("profile");
-    const profileConsolidationTriggerLines =
-      typeof profileSection?.consolidateTriggerLines === "number"
-        ? Math.max(0, Math.floor(profileSection.consolidateTriggerLines))
-        : undefined;
-    const profileConsolidationTargetLines =
-      typeof profileSection?.consolidateTargetLines === "number"
-        ? Math.max(0, Math.floor(profileSection.consolidateTargetLines))
-        : 50;
-    if (
-      await this.storage.profileNeedsConsolidation(
-        profileConsolidationTriggerLines,
-      )
-    ) {
-      log.info("profile.md exceeds max lines — running smart consolidation");
-      const currentProfile = await this.storage.readProfile();
-      if (currentProfile) {
-        const profileResult = await this.extraction.consolidateProfile(
-          currentProfile,
-          profileConsolidationTargetLines,
-        );
-        if (profileResult) {
-          await this.storage.writeProfile(profileResult.consolidatedProfile);
-          // Profile consolidation rewrites profile.md — a durable namespace
-          // mutation; record it for the catalog touch even when it is the only
-          // change in the pass (codex). Otherwise lastWriteAt goes stale.
-          memoryItemMutated = true;
-          log.info(
-            `profile.md consolidated: removed ${profileResult.removedCount} items — ${profileResult.summary}`,
-          );
-        }
-      }
-    }
-
-    // Memory Summarization (Phase 4A)
-    if (resolvePipelineProcessingCapabilities(this.config).summarization) {
-      await this.runSummarization(allMemories);
-    }
-
-    // Topic Extraction (Phase 4B)
-    if (resolvePipelineProcessingCapabilities(this.config).topicExtraction) {
-      await this.runTopicExtraction(allMemories);
-    }
-
-    const meta = await this.storage.loadMeta();
-    meta.lastConsolidationAt = new Date().toISOString();
-    await this.storage.saveMeta(meta);
-
-    // Temporal Memory Tree (v8.2) — rebuild nodes from all memories, fail-open
-    if (lifecycleCaps.temporalMemoryTree) {
-      try {
-        const tmtEntries = allMemories
-          .filter(
-            (m) =>
-              m.frontmatter.status !== "superseded" && m.frontmatter.status !== "archived" &&
-              m.frontmatter.status !== "forgotten" && m.frontmatter.status !== "pending_review", // #1576: unfaithful queue items must not feed TMT clusters
-          )
-          .map((m) => ({
-            path: m.path,
-            id: m.frontmatter.id,
-            created: m.frontmatter.created,
-            content: m.content,
-          }));
-        await this.tmtBuilder.maybeRebuildNodes(
-          tmtEntries,
-          async (texts, level) => {
-            const prompt = `You are a memory archivist. Summarize the following ${level}-level memories into 3–5 sentences, preserving key facts, decisions, and preferences.\n\n${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
-            const response = await this.fastChatCompletion(
-              [
-                {
-                  role: "system",
-                  content:
-                    "Respond with a 3–5 sentence narrative summary. No JSON, just plain prose.",
-                },
-                { role: "user", content: prompt },
-              ],
-              {
-                temperature: 0.3,
-                maxTokens: this.config.tmtSummaryMaxTokens,
-                operation: "tmt_summary",
-                priority: "background",
-              },
-            );
-            return response?.content?.trim() || texts.slice(0, 3).join(" ");
-          },
-        );
-      } catch (err) {
-        log.warn(`tmt: consolidation hook failed (ignored): ${err}`);
-      }
-    }
-
-    if (this.consolidationObservers.size > 0) {
-      const observation: ConsolidationObservation = {
-        runAt: new Date().toISOString(),
-        recentMemories: recent,
-        existingMemories: older.slice(-50),
-        profile,
-        result,
-        merged,
-        invalidated,
-      };
-      for (const observer of this.consolidationObservers) {
-        try {
-          await observer(observation);
-        } catch (err) {
-          log.warn(`consolidation observer failed (ignored): ${err}`);
-        }
-      }
-    }
-
-    // Consolidated catalog write touch — belt-and-suspenders for cleanup-only
-    // passes that mutate the store via delete-only paths (entity merges, TTL
-    // cleanup) without triggering the storage chokepoint's post-write hook.
-    // Gated on memoryItemMutated (set by every durable mutation including cleanup-only passes)
-    // Best-effort and failure-tolerant.
-    if (memoryItemMutated) {
-      this.storageRouter.recordWrite(this.config.defaultNamespace, this.storage.dir);
-    }
-
-    log.info("consolidation complete");
-    return { memoriesProcessed: allMemories.length, merged, invalidated };
+    return this.consolidationRunCoordinator.run();
   }
 
   async optimizeCompressionGuidelines(options?: {
@@ -16114,36 +12546,10 @@ export class Orchestrator {
 
   // Issue #1526 (seam 4): compression-guideline learning moved to
   // CompressionGuidelineCoordinator. Thin delegation keeps the
-  // consolidation-loop hook + recall-section hook call sites stable.
-  private async runCompressionGuidelineLearningPass(): Promise<void> {
-    return this.compressionGuidelineCoordinator.runCompressionGuidelineLearningPass();
-  }
-
   private async buildCompressionGuidelineRecallSection(): Promise<string | null> {
     return this.compressionGuidelineCoordinator.buildCompressionGuidelineRecallSection();
   }
 
-  private async recordScheduledDreamsPhaseRun(
-    phase: "lightSleep" | "rem" | "deepSleep",
-    itemsProcessed: number,
-    notes: string,
-    timing: { startedAt?: string; completedAt?: string } = {},
-  ): Promise<void> {
-    try {
-      const { recordDreamsPhaseRun } = await import("./maintenance/dreams-ledger.js");
-      await recordDreamsPhaseRun({
-        memoryDir: this.storage.dir,
-        phase,
-        trigger: "scheduled",
-        itemsProcessed,
-        notes,
-        startedAt: timing.startedAt,
-        completedAt: timing.completedAt,
-      });
-    } catch (error) {
-      log.debug(`dreams ledger scheduled ${phase} write failed (non-fatal): ${error}`);
-    }
-  }
 
   async runLifecyclePolicyNow(storage: StorageManager = this.storage): Promise<{ memoriesAssessed: number }> {
     const lifecycleCorpus = await storage.readAllMemories();
@@ -16159,21 +12565,6 @@ export class Orchestrator {
   ): Promise<number> {
     return this.lifecyclePolicyCoordinator.runLifecyclePolicyPass(allMemories, storage);
   }
-  private async runFactArchival(
-    allMemories: import("./types.js").MemoryFile[],
-  ): Promise<number> {
-    return this.lifecyclePolicyCoordinator.runFactArchival(allMemories);
-  }
-  private async runSummarization(
-    allMemories: import("./types.js").MemoryFile[],
-  ): Promise<void> {
-    return this.lifecyclePolicyCoordinator.runSummarization(allMemories);
-  }
-  private async runTopicExtraction(
-    allMemories: import("./types.js").MemoryFile[],
-  ): Promise<void> {
-    return this.lifecyclePolicyCoordinator.runTopicExtraction(allMemories);
-  }
   /** Threshold (bytes) at which IDENTITY.md reflections get auto-consolidated */
   private static readonly IDENTITY_CONSOLIDATE_THRESHOLD = 8_000;