@remnic/core 1.0.2 → 1.1.0

package/dist/{chunk-OTFNI3OO.js → chunk-DEPL3635.js}

@@ -2,36 +2,54 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-UYSKNO6E.js";
+} from "./chunk-DHHP2Z4X.js";
+import {
+  extractTopics
+} from "./chunk-UHGBNIOS.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
-} from "./chunk-IFFFR3MR.js";
+} from "./chunk-FSFEQI74.js";
+import {
+  HourlySummarizer
+} from "./chunk-N42IWANG.js";
+import {
+  applyTemporalSupersession,
+  normalizeSupersessionKey,
+  shouldFilterSupersededFromRecall
+} from "./chunk-W6SL7OFG.js";
 import {
   TierMigrationExecutor
 } from "./chunk-Z5AAYHUC.js";
 import {
   decideTierTransition
-} from "./chunk-4A24LIM2.js";
+} from "./chunk-S75M5ZRK.js";
 import {
   TmtBuilder
 } from "./chunk-TPB3I2AC.js";
-import {
-  extractTopics
-} from "./chunk-UHGBNIOS.js";
 import {
   SessionObserverState
-} from "./chunk-ZKYI7UVO.js";
+} from "./chunk-JR4ZC3G4.js";
 import {
-  HourlySummarizer
-} from "./chunk-LP47L3ZX.js";
+  semanticChunkContent
+} from "./chunk-KVE7R4CG.js";
+import {
+  findUnresolvedEntityRefs
+} from "./chunk-X7XN6YU4.js";
+import {
+  RelevanceStore
+} from "./chunk-5NPGSAVB.js";
+import {
+  RerankCache,
+  rerankLocalOrNoop
+} from "./chunk-C7VW7C3F.js";
 import {
   mergeWithAgentResults,
   runDirectAgent,
   runTemporalAgent,
   shouldRunAgent
-} from "./chunk-GPGBSNKM.js";
+} from "./chunk-K4FLSOR5.js";
 import {
   clearIndexes,
   deindexMemory,
@@ -46,101 +64,89 @@ import {
 } from "./chunk-V3RXWQIE.js";
 import {
   applyRuntimeRetrievalPolicy
-} from "./chunk-G3AG3KZN.js";
-import {
-  buildConsolidationPrompt,
-  findSimilarClusters,
-  parseConsolidationResponse
-} from "./chunk-2CJCWDMR.js";
-import {
-  LastRecallStore,
-  TierMigrationStatusStore,
-  clampGraphRecallExpandedEntries
-} from "./chunk-HG2NKWR2.js";
-import {
-  findUnresolvedEntityRefs
-} from "./chunk-X7XN6YU4.js";
-import {
-  RelevanceStore
-} from "./chunk-BRK4ODMI.js";
-import {
-  RerankCache,
-  rerankLocalOrNoop
-} from "./chunk-C7VW7C3F.js";
+} from "./chunk-5IZL4DCV.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
   setCachedQmdRecall
 } from "./chunk-YCN4BVDK.js";
+import {
+  reorderRecallResultsWithMmr
+} from "./chunk-YDBIWGNI.js";
 import {
   createRecallSectionMetricRecorder
-} from "./chunk-L5RPWGFK.js";
+} from "./chunk-7DHTMOND.js";
+import {
+  LastRecallStore,
+  TierMigrationStatusStore,
+  clampGraphRecallExpandedEntries
+} from "./chunk-47UU5PU2.js";
 import {
   NegativeExampleStore
-} from "./chunk-GJR6D6KC.js";
+} from "./chunk-D654IBA6.js";
 import {
   evaluateMemoryActionPolicy
 } from "./chunk-H63EDPFJ.js";
+import {
+  classifyMemoryKind
+} from "./chunk-YAZNBMNF.js";
 import {
   hasBroadGraphIntent,
   inferIntentFromText,
   intentCompatibilityScore,
+  isTaskInitiationIntent,
   planRecallMode
-} from "./chunk-WWIQTB2Y.js";
+} from "./chunk-GGD5W7TB.js";
+import {
+  createVerdictCache,
+  judgeFactDurability,
+  validateProcedureExtraction
+} from "./chunk-LAYN4LDC.js";
 import {
   ExtractionEngine
-} from "./chunk-6UJQNRIO.js";
+} from "./chunk-3SV6CQHO.js";
 import {
   parseMemoryActionEligibilityContext
-} from "./chunk-MWGVGUIS.js";
+} from "./chunk-UEYA6UC7.js";
 import {
   ProfilingCollector
-} from "./chunk-763GUIOU.js";
+} from "./chunk-NBNN5GOB.js";
 import {
   ModelRegistry
-} from "./chunk-ONRU4L2N.js";
+} from "./chunk-FEMOX5AD.js";
 import {
   LocalLlmClient
-} from "./chunk-MDDAA2AO.js";
-import {
-  classifyMemoryKind
-} from "./chunk-YAZNBMNF.js";
+} from "./chunk-JL2PU6AI.js";
 import {
   formatDaySummaryMemories
-} from "./chunk-2PO5ZRKV.js";
+} from "./chunk-GZCUW5IC.js";
 import {
   EmbeddingFallback
-} from "./chunk-QPKFPHOO.js";
+} from "./chunk-ALXMCZEU.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-V4YC4LUK.js";
+} from "./chunk-7WQ6SLIE.js";
 import {
   RoutingRulesStore,
   normalizeReplaySessionKey
-} from "./chunk-HLBYLYRD.js";
+} from "./chunk-PAORGQRI.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-UIYZ5T3I.js";
+} from "./chunk-6UJ47TVX.js";
 import {
   ThreadingManager
-} from "./chunk-UCYSTFZR.js";
+} from "./chunk-JRNQ3RNA.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-J47FNDR7.js";
+} from "./chunk-JIU55F3X.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-CULXMQJH.js";
 import {
   TranscriptManager
-} from "./chunk-UV2FO7J4.js";
-import {
-  PolicyRuntimeManager
-} from "./chunk-T4WRIV2C.js";
-import {
-  searchObjectiveStateSnapshots
-} from "./chunk-LOBRX7VD.js";
+} from "./chunk-E6K4NIEU.js";
 import {
   NamespaceSearchRouter,
   NamespaceStorageRouter,
@@ -148,33 +154,34 @@ import {
   createConversationIndexRuntime,
   createSearchBackend,
   writeConversationChunks
-} from "./chunk-IZME7KW2.js";
+} from "./chunk-ZVBB3T7V.js";
 import {
   parseQmdExplain
-} from "./chunk-TVVVQQAK.js";
+} from "./chunk-BLKTA7MM.js";
 import {
-  scoreImportance
-} from "./chunk-BDFZXRSO.js";
+  PolicyRuntimeManager
+} from "./chunk-EABGC2TL.js";
+import {
+  searchObjectiveStateSnapshots
+} from "./chunk-LOBRX7VD.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-AAI7JARD.js";
+} from "./chunk-HMDCOMYU.js";
+import {
+  isAboveImportanceThreshold,
+  scoreImportance
+} from "./chunk-J4IYOZZ5.js";
 import {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,
   searchNativeKnowledge
-} from "./chunk-Q6FETXJA.js";
+} from "./chunk-7SEAZFFB.js";
 import {
   recordEvalShadowRecall
 } from "./chunk-K6WK37A6.js";
 import {
-  GraphIndex
-} from "./chunk-SCHEKPYH.js";
-import {
-  searchCausalTrajectories
-} from "./chunk-ORZMT74A.js";
-import {
-  chunkContent
-} from "./chunk-B7LOFDVE.js";
+  CODEX_THREAD_KEY_PREFIX
+} from "./chunk-3PG3H5TD.js";
 import {
   applyCommitmentLedgerLifecycle
 } from "./chunk-FYIYMQ5N.js";
@@ -184,28 +191,64 @@ import {
   refineCompressionGuidelineCandidateSemantically,
   renderCompressionGuidelinesMarkdown
 } from "./chunk-2NMMFZ5T.js";
+import {
+  buildConsolidationPrompt,
+  buildExtensionsBlockForConsolidation,
+  findSimilarClusters,
+  materializeAfterSemanticConsolidation,
+  parseConsolidationResponse
+} from "./chunk-SYUK3VLY.js";
+import {
+  FallbackLlmClient
+} from "./chunk-44ICJRF3.js";
+import {
+  GraphIndex
+} from "./chunk-C2EFFULQ.js";
+import {
+  chunkContent
+} from "./chunk-4WMCPJWX.js";
+import {
+  buildRecallQueryPolicy
+} from "./chunk-6HZ6AO2P.js";
 import {
   buildBehaviorSignalsForMemory,
   dedupeBehaviorSignalsByMemoryAndHash
 } from "./chunk-JWPLJLDU.js";
 import {
   BootstrapEngine
-} from "./chunk-YNI4S5WT.js";
+} from "./chunk-N53K2EXC.js";
+import {
+  BoxBuilder
+} from "./chunk-URB2WSKZ.js";
 import {
   SmartBuffer
-} from "./chunk-DORBM6OB.js";
+} from "./chunk-UVJFDP7P.js";
 import {
   isDisagreementPrompt
 } from "./chunk-XYIK4LF6.js";
 import {
-  FallbackLlmClient
-} from "./chunk-XUHI52HK.js";
-import {
-  BoxBuilder
-} from "./chunk-M5KEYE5E.js";
+  abortError,
+  isAbortError,
+  throwIfAborted
+} from "./chunk-PVGDJXVK.js";
 import {
   resolveHomeDir
 } from "./chunk-MARWOCVP.js";
+import {
+  searchTrustZoneRecords
+} from "./chunk-EQINRHYR.js";
+import {
+  shouldSkipImplicitExtraction
+} from "./chunk-QDYXG4CS.js";
+import {
+  selectRouteRule
+} from "./chunk-QNJMBKFK.js";
+import {
+  buildProcedurePersistBody
+} from "./chunk-QDW3E4RD.js";
+import {
+  searchCausalTrajectories
+} from "./chunk-4NRAJUDS.js";
 import {
   canReadNamespace,
   defaultNamespaceForPrincipal,
@@ -213,16 +256,26 @@ import {
   resolvePrincipal
 } from "./chunk-N5AKDXAI.js";
 import {
-  searchTrustZoneRecords
-} from "./chunk-EQINRHYR.js";
+  decideLifecycleTransition,
+  resolveLifecycleState
+} from "./chunk-TBBDFYXW.js";
 import {
   ContentHashIndex,
   StorageManager,
-  normalizeEntityName
-} from "./chunk-QWUUMMIK.js";
+  compareEntityTimestamps,
+  fingerprintEntityStructuredFacts,
+  normalizeAttributePairs,
+  normalizeEntityName,
+  parseEntityFile
+} from "./chunk-GV6NLQ4X.js";
 import {
   confidenceTier
-} from "./chunk-U4PV25RD.js";
+} from "./chunk-3WHVNEN7.js";
+import {
+  attachCitation,
+  hasCitationForTemplate,
+  stripCitationForTemplate
+} from "./chunk-4KAN3GZ3.js";
 import {
   openBetterSqlite3
 } from "./chunk-BOUYNNYD.js";
@@ -231,26 +284,16 @@ import {
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
 import {
-  shouldSkipImplicitExtraction
-} from "./chunk-YNCQ7E4M.js";
-import {
-  selectRouteRule
-} from "./chunk-HLXVTBF3.js";
+  sanitizeMemoryContent
+} from "./chunk-M62O4P4T.js";
 import {
   log
-} from "./chunk-KWBU5S5U.js";
-import {
-  buildRecallQueryPolicy
-} from "./chunk-6HZ6AO2P.js";
-import {
-  decideLifecycleTransition,
-  resolveLifecycleState
-} from "./chunk-QCCCQT3O.js";
+} from "./chunk-2ODBA7MQ.js";
 
 // src/orchestrator.ts
 import path5 from "path";
 import os from "os";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash2, randomBytes } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 import {
   mkdir as mkdir4,
@@ -804,11 +847,66 @@ async function migrateFromEngram(options) {
   }
 }
 
+// src/procedural/procedure-recall.ts
+function tokenOverlapScore(prompt, memoryText) {
+  const norm = (s) => s.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 2);
+  const promptTokens = new Set(norm(prompt));
+  const memTokens = new Set(norm(memoryText));
+  if (promptTokens.size === 0 || memTokens.size === 0) return 0;
+  let inter = 0;
+  for (const t of promptTokens) {
+    if (memTokens.has(t)) inter++;
+  }
+  const union = /* @__PURE__ */ new Set([...promptTokens, ...memTokens]);
+  return inter / Math.max(1, union.size);
+}
+function scoreProcedureForPrompt(m, prompt, queryIntent) {
+  const memText = `${m.content}
+${(m.frontmatter.tags ?? []).join(" ")}`;
+  const jaccard = tokenOverlapScore(prompt, memText);
+  const memIntent = inferIntentFromText(m.content.slice(0, 2e3));
+  const intentScore = intentCompatibilityScore(queryIntent, memIntent);
+  return jaccard * 0.55 + intentScore * 0.45;
+}
+async function buildProcedureRecallSection(storage, prompt, config) {
+  if (config.procedural?.enabled !== true) return null;
+  const trimmed = typeof prompt === "string" ? prompt.trim() : "";
+  if (!trimmed) return null;
+  const queryIntent = inferIntentFromText(trimmed);
+  if (!isTaskInitiationIntent(queryIntent)) return null;
+  const maxN = Math.min(
+    10,
+    Math.max(
+      1,
+      typeof config.procedural.recallMaxProcedures === "number" && Number.isFinite(config.procedural.recallMaxProcedures) ? Math.floor(config.procedural.recallMaxProcedures) : 3
+    )
+  );
+  const all = await storage.readAllMemories();
+  const scored = all.filter(
+    (m) => m.frontmatter.category === "procedure" && m.frontmatter.status !== "pending_review" && m.frontmatter.status !== "rejected" && m.frontmatter.status !== "quarantined" && m.frontmatter.status !== "superseded" && m.frontmatter.status !== "archived"
+  ).map((m) => ({ m, score: scoreProcedureForPrompt(m, trimmed, queryIntent) })).filter((x) => x.score > 0.04).sort((a, b) => b.score - a.score).slice(0, maxN);
+  if (scored.length === 0) return null;
+  const blocks = scored.map(({ m, score }) => {
+    const id = m.frontmatter.id;
+    const flat = m.content.replace(/\s+/g, " ").trim();
+    const preview = flat.slice(0, 320);
+    const suffix = flat.length > 320 ? "\u2026" : "";
+    return `### ${id} (match ${score.toFixed(2)})
+
+${preview}${suffix}`;
+  });
+  return `## Relevant procedures
+
+${blocks.join("\n\n")}`;
+}
+
 // src/maintenance/memory-governance-cron.ts
 import { mkdir as mkdir2, readFile as readFile2, rename, rm as rm2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
 import path2 from "path";
 var DAY_SUMMARY_CRON_ID = "engram-day-summary";
 var GOVERNANCE_CRON_ID = "engram-nightly-governance";
+var PROCEDURAL_MINING_CRON_ID = "engram-procedural-mining";
+var CONTRADICTION_SCAN_CRON_ID = "engram-contradiction-scan";
 async function acquireCronJobsLock(jobsPath) {
   const lockPath2 = `${jobsPath}.lock`;
   const start = Date.now();
@@ -921,6 +1019,105 @@ async function ensureNightlyGovernanceCron(jobsPath, options) {
     delivery: { mode: "none" }
   }));
 }
+async function ensureProceduralMiningCron(jobsPath, options) {
+  const scheduleExpr = typeof options.scheduleExpr === "string" && options.scheduleExpr.trim().length > 0 ? options.scheduleExpr.trim() : "17 3 * * *";
+  const agentId = typeof options.agentId === "string" && options.agentId.trim().length > 0 ? options.agentId.trim() : "main";
+  return ensureCronJob(jobsPath, PROCEDURAL_MINING_CRON_ID, () => ({
+    id: PROCEDURAL_MINING_CRON_ID,
+    agentId,
+    name: "Remnic Procedural Mining (nightly)",
+    enabled: true,
+    schedule: {
+      kind: "cron",
+      expr: scheduleExpr,
+      tz: options.timezone
+    },
+    sessionTarget: "isolated",
+    wakeMode: "now",
+    payload: {
+      kind: "agentTurn",
+      timeoutSeconds: 900,
+      thinking: "off",
+      message: "You are OpenClaw automation. Call tool `engram.procedure_mining_run` with empty params. If successful output exactly NO_REPLY. On error output one concise line. Do NOT use message tool."
+    },
+    delivery: { mode: "none" }
+  }));
+}
+async function ensureContradictionScanCron(jobsPath, options) {
+  const scheduleExpr = typeof options.scheduleExpr === "string" && options.scheduleExpr.trim().length > 0 ? options.scheduleExpr.trim() : "37 3 * * *";
+  const agentId = typeof options.agentId === "string" && options.agentId.trim().length > 0 ? options.agentId.trim() : "main";
+  return ensureCronJob(jobsPath, CONTRADICTION_SCAN_CRON_ID, () => ({
+    id: CONTRADICTION_SCAN_CRON_ID,
+    agentId,
+    name: "Remnic Contradiction Scan (nightly)",
+    enabled: true,
+    schedule: {
+      kind: "cron",
+      expr: scheduleExpr,
+      tz: options.timezone
+    },
+    sessionTarget: "isolated",
+    wakeMode: "now",
+    payload: {
+      kind: "agentTurn",
+      timeoutSeconds: 900,
+      thinking: "off",
+      message: "You are OpenClaw automation. Call tool `engram.contradiction_scan_run` with empty params. If successful output exactly NO_REPLY. On error output one concise line. Do NOT use message tool."
+    },
+    delivery: { mode: "none" }
+  }));
+}
+
+// src/dedup/semantic.ts
+async function decideSemanticDedup(content, lookup, options) {
+  if (!options.enabled) {
+    return { action: "keep", reason: "disabled" };
+  }
+  if (options.candidates === 0) {
+    return { action: "keep", reason: "disabled" };
+  }
+  const trimmed = typeof content === "string" ? content.trim() : "";
+  if (!trimmed) {
+    return { action: "keep", reason: "no_near_duplicate" };
+  }
+  const candidates = Math.max(1, Math.floor(options.candidates));
+  let hits = [];
+  try {
+    hits = await lookup(trimmed, candidates);
+  } catch {
+    return { action: "keep", reason: "backend_unavailable" };
+  }
+  if (!Array.isArray(hits) || hits.length === 0) {
+    return { action: "keep", reason: "no_candidates" };
+  }
+  let top;
+  for (const hit of hits) {
+    if (!hit || typeof hit.score !== "number" || !Number.isFinite(hit.score)) {
+      continue;
+    }
+    if (!top || hit.score > top.score) {
+      top = hit;
+    }
+  }
+  if (!top) {
+    return { action: "keep", reason: "no_near_duplicate" };
+  }
+  if (top.score >= options.threshold) {
+    return {
+      action: "skip",
+      reason: "near_duplicate",
+      topScore: top.score,
+      topId: top.id,
+      topPath: top.path
+    };
+  }
+  return {
+    action: "keep",
+    reason: "no_near_duplicate",
+    topScore: top.score,
+    topId: top.id
+  };
+}
 
 // src/lcm/schema.ts
 import path3 from "path";
@@ -2233,15 +2430,72 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
 }
 
 // src/orchestrator.ts
-function abortRecallError(message) {
-  const err = new Error(message);
-  Object.defineProperty(err, "name", { value: "AbortError" });
-  return err;
+function dedupeEntitySynthesisEvidenceEntries(entries) {
+  const dedupedEvidenceEntries = [];
+  const evidenceByFact = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const normalizedFact = entry.text.trim();
+    if (!normalizedFact) continue;
+    const existing = evidenceByFact.get(normalizedFact);
+    if (!existing) {
+      evidenceByFact.set(normalizedFact, { newest: entry, oldest: entry });
+      continue;
+    }
+    if (compareEntityTimestamps(entry.timestamp, existing.newest.timestamp) > 0) {
+      existing.newest = entry;
+    }
+    if (compareEntityTimestamps(entry.timestamp, existing.oldest.timestamp) < 0) {
+      existing.oldest = entry;
+    }
+  }
+  for (const { newest, oldest } of evidenceByFact.values()) {
+    dedupedEvidenceEntries.push(newest);
+    const newestKey = [
+      newest.timestamp,
+      newest.source ?? "",
+      newest.sessionKey ?? "",
+      newest.principal ?? "",
+      newest.text
+    ].join("\0");
+    const oldestKey = [
+      oldest.timestamp,
+      oldest.source ?? "",
+      oldest.sessionKey ?? "",
+      oldest.principal ?? "",
+      oldest.text
+    ].join("\0");
+    if (oldestKey !== newestKey) {
+      dedupedEvidenceEntries.push(oldest);
+    }
+  }
+  return dedupedEvidenceEntries;
 }
+function flattenStructuredSectionEvidence(sections) {
+  return (sections ?? []).flatMap(
+    (section) => section.facts.map((fact) => fact.trim()).filter((fact) => fact.length > 0).map((fact) => ({
+      timestamp: "",
+      text: fact,
+      source: `section:${section.title}`
+    }))
+  );
+}
+function fingerprintEntitySynthesisEvidence(entity) {
+  const fingerprint = createHash2("sha256");
+  const timelineEntries = entity.timeline.map((entry) => [
+    entry.timestamp,
+    entry.source ?? "",
+    entry.sessionKey ?? "",
+    entry.principal ?? "",
+    entry.text
+  ].join("\0")).sort();
+  fingerprint.update(timelineEntries.join("
"));
+  fingerprint.update("");
+  fingerprint.update(fingerprintEntityStructuredFacts(entity) ?? "");
+  return fingerprint.digest("hex");
+}
+var abortRecallError = abortError;
 function throwIfRecallAborted(signal, message = "recall aborted") {
-  if (signal?.aborted) {
-    throw abortRecallError(message);
-  }
+  throwIfAborted(signal, message);
 }
 async function raceRecallAbort(promise, signal, message = "recall aborted") {
   throwIfRecallAborted(signal, message);
@@ -2501,7 +2755,8 @@ function parseMemoryIntentSnapshot(value) {
     actionType: typeof candidate.actionType === "string" ? candidate.actionType : "unknown",
     entityTypes: Array.isArray(candidate.entityTypes) ? candidate.entityTypes.filter(
       (item) => typeof item === "string"
-    ) : []
+    ) : [],
+    taskInitiation: candidate.taskInitiation === true
   };
 }
 function buildQmdIntentHint(intent) {
@@ -2515,6 +2770,9 @@ function buildQmdIntentHint(intent) {
   if (intent.entityTypes.length > 0) {
     parts.push(`entities:${intent.entityTypes.join(",")}`);
   }
+  if (intent.taskInitiation === true) {
+    parts.push("task_initiation");
+  }
   return parts.length > 0 ? parts.join(" ") : void 0;
 }
 function parseQmdRecallResults(value) {
@@ -2625,6 +2883,7 @@ var Orchestrator = class _Orchestrator {
   summarizer;
   localLlm;
   fastLlm;
+  judgeVerdictCache;
   fastGatewayLlm;
   modelRegistry;
   relevance;
@@ -2669,6 +2928,7 @@ var Orchestrator = class _Orchestrator {
   nonZeroExtractionsSinceConsolidation = 0;
   lastConsolidationRunAtMs = 0;
   consolidationInFlight = false;
+  consolidationObservers = /* @__PURE__ */ new Set();
   qmdMaintenanceTimer = null;
   qmdMaintenancePending = false;
   qmdMaintenanceInFlight = false;
@@ -2688,6 +2948,41 @@ var Orchestrator = class _Orchestrator {
   // Initialization gate: recall() awaits this before proceeding
   initPromise = null;
   resolveInit = null;
+  /**
+   * Resolves when deferred initialization (QMD probe, warmup, caches, cron)
+   * completes. CLI and http-serve callers that need `qmd.isAvailable()` to
+   * reflect reality should `await orchestrator.deferredReady` after
+   * `initialize()`. Gateway callers can ignore it — recall() degrades
+   * gracefully when QMD isn't ready yet.
+   *
+   * Also resolves (without error) when `initialize()` throws before reaching
+   * the deferred-init phase, so callers never hang on a permanently-pending
+   * promise.
+   *
+   * Host adapters that need to tie deferred init to their stop() lifecycle
+   * should `await orchestrator.deferredReady` before proceeding with teardown
+   * to prevent background QMD/warmup/cron tasks from racing with shutdown.
+   */
+  deferredReady = Promise.resolve();
+  resolveDeferredReady = null;
+  deferredInitAbort = null;
+  /**
+   * Whether the deferred init's QMD startup sync completed successfully.
+   * When false after deferredReady resolves, the server retry loop should
+   * attempt startupSearchSync() even if `qmd.isAvailable()` is true —
+   * availability only means probe succeeded, not that the index is current.
+   */
+  deferredSyncSucceeded = false;
+  /**
+   * Abort deferred initialization so background QMD sync/warmup stops
+   * promptly on shutdown. Safe to call multiple times or before init.
+   */
+  abortDeferredInit() {
+    if (this.deferredInitAbort) {
+      this.deferredInitAbort.abort();
+      this.deferredInitAbort = null;
+    }
+  }
   /** Set per-session workspace for the next recall() call (compaction reset). @internal */
   setRecallWorkspaceOverride(sessionKey, dir) {
     this._recallWorkspaceOverrides.set(sessionKey, dir);
@@ -2796,7 +3091,13 @@ var Orchestrator = class _Orchestrator {
       config,
       this.storageRouter
     );
-    this.storage = new StorageManager(config.memoryDir);
+    this.storage = new StorageManager(config.memoryDir, config.entitySchemas);
+    this.storage.citationTemplate = config.inlineSourceAttributionFormat;
+    this.storage.setVersioningConfig({
+      enabled: config.versioningEnabled,
+      maxVersionsPerPage: config.versioningMaxPerPage,
+      sidecarDir: config.versioningSidecarDir
+    });
     this.qmd = createSearchBackend(config);
     const conversationIndexRuntime = createConversationIndexRuntime(config, {
       getQmd: () => this.conversationQmd,
@@ -2832,7 +3133,9 @@ var Orchestrator = class _Orchestrator {
       this.modelRegistry,
       this.transcript
     );
+    this.judgeVerdictCache = createVerdictCache();
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
+    this.localLlm.disableThinking = config.localLlmDisableThinking;
     this.fastLlm = config.localLlmFastEnabled ? (() => {
       const client = new LocalLlmClient(
         {
@@ -3071,100 +3374,173 @@ var Orchestrator = class _Orchestrator {
     return this.fastLlm;
   }
   async initialize() {
-    await migrateFromEngram({
-      quiet: true,
-      logger: (message) => log.info(message)
+    this.deferredReady = new Promise((resolve) => {
+      this.resolveDeferredReady = resolve;
     });
-    await this.storage.ensureDirectories();
-    await this.storage.loadAliases();
-    if (this.config.namespacesEnabled) {
-      const namespaces = /* @__PURE__ */ new Set([
-        this.config.defaultNamespace,
-        this.config.sharedNamespace,
-        ...this.config.namespacePolicies.map((p) => p.name)
-      ]);
-      for (const ns of namespaces) {
-        const sm = await this.storageRouter.storageFor(ns);
-        await sm.ensureDirectories();
-        await sm.loadAliases().catch(() => void 0);
+    try {
+      await migrateFromEngram({
+        quiet: true,
+        logger: (message) => log.info(message)
+      });
+      await this.storage.ensureDirectories();
+      await this.storage.loadAliases();
+      if (this.config.namespacesEnabled) {
+        const namespaces = /* @__PURE__ */ new Set([
+          this.config.defaultNamespace,
+          this.config.sharedNamespace,
+          ...this.config.namespacePolicies.map((p) => p.name)
+        ]);
+        for (const ns of namespaces) {
+          const sm = await this.storageRouter.storageFor(ns);
+          await sm.ensureDirectories();
+          await sm.loadAliases().catch(() => void 0);
+        }
+      }
+      await this.relevance.load();
+      await this.negatives.load();
+      await this.lastRecall.load();
+      await this.tierMigrationStatus.load();
+      await this.sessionObserver.load();
+      this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
+      this.utilityRuntimeValues = await loadUtilityRuntimeValues({
+        memoryDir: this.config.memoryDir,
+        memoryUtilityLearningEnabled: this.config.memoryUtilityLearningEnabled,
+        promotionByOutcomeEnabled: this.config.promotionByOutcomeEnabled
+      });
+      if (this.config.factDeduplicationEnabled) {
+        const stateDir = path5.join(this.config.memoryDir, "state");
+        this.contentHashIndex = new ContentHashIndex(stateDir);
+        await this.contentHashIndex.load();
+        log.info(
+          `content-hash dedup: loaded ${this.contentHashIndex.size} hashes`
+        );
       }
-    }
-    await this.relevance.load();
-    await this.negatives.load();
-    await this.lastRecall.load();
-    await this.tierMigrationStatus.load();
-    await this.sessionObserver.load();
-    this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
-    this.utilityRuntimeValues = await loadUtilityRuntimeValues({
-      memoryDir: this.config.memoryDir,
-      memoryUtilityLearningEnabled: this.config.memoryUtilityLearningEnabled,
-      promotionByOutcomeEnabled: this.config.promotionByOutcomeEnabled
-    });
-    if (this.config.factDeduplicationEnabled) {
-      const stateDir = path5.join(this.config.memoryDir, "state");
-      this.contentHashIndex = new ContentHashIndex(stateDir);
-      await this.contentHashIndex.load();
-      log.info(
-        `content-hash dedup: loaded ${this.contentHashIndex.size} hashes`
-      );
-    }
-    await this.transcript.initialize();
-    await this.summarizer.initialize();
-    if (this.sharedContext) {
-      await this.sharedContext.ensureStructure();
-    }
-    if (this.compounding) {
-      await this.compounding.ensureDirs();
-    }
-    if (this.resolveInit) {
-      this.resolveInit();
-      this.resolveInit = null;
-      log.info("init gate opened (essential state loaded)");
-    }
-    {
-      const available = await this.qmd.probe();
-      if (available) {
-        log.info(`Search backend: available ${this.qmd.debugStatus()}`);
-        const namespaces = this.config.namespacesEnabled ? this.configuredNamespaces() : [this.config.defaultNamespace];
-        const states = await Promise.all(
-          namespaces.map(async (namespace) => ({
-            namespace,
-            state: this.config.namespacesEnabled ? await this.namespaceSearchRouter.ensureNamespaceCollection(
-              namespace
-            ) : await this.qmd.ensureCollection(this.config.memoryDir)
-          }))
+      await this.transcript.initialize();
+      await this.summarizer.initialize();
+      if (this.sharedContext) {
+        await this.sharedContext.ensureStructure();
+      }
+      if (this.compounding) {
+        await this.compounding.ensureDirs();
+      }
+      try {
+        await this.buffer.load();
+      } catch (bufErr) {
+        log.error(
+          `buffer.load() failed (init gate will still open): ${bufErr}`
         );
-        const defaultState = states.find(
-          (entry) => entry.namespace === this.config.defaultNamespace
-        )?.state ?? "unknown";
-        if (defaultState === "missing") {
-          this.qmd = new NoopSearchBackend();
-          log.warn(
-            "Search collection missing for Remnic memory store; disabling search retrieval for this runtime (fallback retrieval remains enabled)"
-          );
-        } else if (defaultState === "unknown") {
-          log.warn(
-            "Search collection check unavailable; keeping search retrieval enabled for fail-open behavior"
-          );
-        } else if (defaultState === "skipped") {
-          log.debug(
-            "Search collection check skipped (remote or daemon-only mode)"
-          );
+        this.buffer.resetToEmpty();
+      }
+      if (this.config.compactionResetEnabled) {
+        try {
+          const wsDir = this.config.workspaceDir || defaultWorkspaceDir();
+          const files = await readdir3(wsDir).catch(() => []);
+          for (const f of files) {
+            if (!f.startsWith(".compaction-reset-signal-")) continue;
+            const fp = path5.join(wsDir, f);
+            const s = await stat3(fp).catch(() => null);
+            if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
+              await unlink2(fp).catch(() => {
+              });
+              log.debug(`initialize: removed stale compaction signal ${f}`);
+            }
+          }
+        } catch (err) {
+          log.debug("initialize: stale signal sweep failed:", err);
         }
-        for (const entry of states) {
-          if (entry.namespace === this.config.defaultNamespace) continue;
-          if (entry.state === "missing") {
+      }
+      try {
+        const available = await this.qmd.probe();
+        if (available) {
+          log.info(`Search backend: available ${this.qmd.debugStatus()}`);
+          const namespaces = this.config.namespacesEnabled ? this.configuredNamespaces() : [this.config.defaultNamespace];
+          const states = await Promise.all(
+            namespaces.map(async (namespace) => ({
+              namespace,
+              state: this.config.namespacesEnabled ? await this.namespaceSearchRouter.ensureNamespaceCollection(
+                namespace
+              ) : await this.qmd.ensureCollection(this.config.memoryDir)
+            }))
+          );
+          const defaultState = states.find(
+            (entry) => entry.namespace === this.config.defaultNamespace
+          )?.state ?? "unknown";
+          if (defaultState === "missing") {
+            this.qmd = new NoopSearchBackend();
+            log.warn(
+              "Search collection missing for Remnic memory store; disabling search retrieval for this runtime (fallback retrieval remains enabled)"
+            );
+          } else if (defaultState === "unknown") {
             log.warn(
-              `Search collection missing for namespace '${entry.namespace}'; namespace retrieval will fail open to non-search paths`
+              "Search collection check unavailable; keeping search retrieval enabled for fail-open behavior"
+            );
+          } else if (defaultState === "skipped") {
+            log.debug(
+              "Search collection check skipped (remote or daemon-only mode)"
             );
           }
+          for (const entry of states) {
+            if (entry.namespace === this.config.defaultNamespace) continue;
+            if (entry.state === "missing") {
+              log.warn(
+                `Search collection missing for namespace '${entry.namespace}'; namespace retrieval will fail open to non-search paths`
+              );
+            }
+          }
+        } else if (this.qmd instanceof NoopSearchBackend) {
+          log.debug(`Search backend: noop (search intentionally disabled)`);
+        } else {
+          log.warn(`Search backend: not available ${this.qmd.debugStatus()}`);
         }
-      } else if (this.qmd instanceof NoopSearchBackend) {
-        log.debug(`Search backend: noop (search intentionally disabled)`);
-      } else {
-        log.warn(`Search backend: not available ${this.qmd.debugStatus()}`);
+      } catch (err) {
+        log.error(`QMD probe/collection check failed (non-fatal): ${err}`);
+      }
+      if (this.resolveInit) {
+        this.resolveInit();
+        this.resolveInit = null;
+        log.info("init gate opened (essential state + QMD state loaded)");
+      }
+      const resolveDeferred = this.resolveDeferredReady;
+      this.resolveDeferredReady = null;
+      this.deferredInitAbort = new AbortController();
+      this.deferredInitialize(this.deferredInitAbort.signal).catch((err) => {
+        log.error(`deferred initialization failed (non-fatal): ${err}`);
+      }).finally(() => {
+        resolveDeferred?.();
+      });
+    } catch (err) {
+      if (this.resolveInit) {
+        this.resolveInit();
+        this.resolveInit = null;
+      }
+      if (this.resolveDeferredReady) {
+        this.resolveDeferredReady();
+        this.resolveDeferredReady = null;
+      }
+      throw err;
+    }
+  }
+  async deferredInitialize(signal) {
+    if (this.qmd.isAvailable() && this.config.qmdMaintenanceEnabled) {
+      try {
+        log.info("QMD startup sync: updating index to match current disk state");
+        if (this.config.namespacesEnabled) {
+          await this.namespaceSearchRouter.updateNamespaces(
+            this.configuredNamespaces()
+          );
+        } else {
+          await this.qmd.update();
+        }
+        log.info("QMD startup sync: complete");
+        this.deferredSyncSucceeded = true;
+      } catch (err) {
+        log.warn(`QMD startup sync failed (non-fatal): ${err}`);
       }
+    } else if (!this.qmd.isAvailable()) {
+    } else {
+      this.deferredSyncSucceeded = true;
     }
+    if (signal.aborted) return;
     const warmupPromises = [];
     if (this.qmd.isAvailable()) {
       const warmupNs = this.config.defaultNamespace;
@@ -3189,68 +3565,180 @@ var Orchestrator = class _Orchestrator {
       );
     }
     await Promise.all(warmupPromises);
+    if (signal.aborted) return;
+    const cacheWarmups = [];
     if (this.config.knowledgeIndexEnabled) {
-      (async () => {
-        try {
-          const t0 = Date.now();
-          await this.storage.buildKnowledgeIndex(this.config);
-          log.info(`Knowledge Index warmup: complete in ${Date.now() - t0}ms`);
-        } catch (err) {
-          log.debug(`Knowledge Index warmup failed (non-fatal): ${err}`);
-        }
-      })().catch(() => {
-      });
-    }
-    this.storage.readAllMemories().catch(() => {
-    });
-    this.storage.readAllEntityFiles().catch(() => {
-    });
+      cacheWarmups.push(
+        (async () => {
+          try {
+            const t0 = Date.now();
+            await this.storage.buildKnowledgeIndex(this.config);
+            log.info(`Knowledge Index warmup: complete in ${Date.now() - t0}ms`);
+          } catch (err) {
+            log.debug(`Knowledge Index warmup failed (non-fatal): ${err}`);
+          }
+        })()
+      );
+    }
+    cacheWarmups.push(this.storage.readAllMemories().then(() => {
+    }).catch(() => {
+    }));
+    cacheWarmups.push(this.storage.readAllEntityFiles().then(() => {
+    }).catch(() => {
+    }));
+    await Promise.all(cacheWarmups);
+    if (signal.aborted) return;
     if (this.config.conversationIndexEnabled && this.conversationIndexBackend) {
-      const init = await this.conversationIndexBackend.initialize();
-      if (!init.enabled) {
+      try {
+        const init = await this.conversationIndexBackend.initialize();
+        if (!init.enabled) {
+          this.config.conversationIndexEnabled = false;
+        }
+        if (init.logLevel === "info") {
+          log.info(init.message);
+        } else if (init.logLevel === "warn") {
+          log.warn(init.message);
+        } else {
+          log.debug(init.message);
+        }
+      } catch (err) {
+        log.error(`Conversation index initialization failed (non-fatal): ${err}`);
         this.config.conversationIndexEnabled = false;
       }
-      if (init.logLevel === "info") {
-        log.info(init.message);
-      } else if (init.logLevel === "warn") {
-        log.warn(init.message);
-      } else {
-        log.debug(init.message);
-      }
     }
-    await this.buffer.load();
+    if (signal.aborted) return;
     if (this.config.localLlmEnabled) {
-      await this.validateLocalLlmModel();
-    }
-    if (this.config.compactionResetEnabled) {
       try {
-        const wsDir = this.config.workspaceDir || defaultWorkspaceDir();
-        const files = await readdir3(wsDir).catch(() => []);
-        for (const f of files) {
-          if (!f.startsWith(".compaction-reset-signal-")) continue;
-          const fp = path5.join(wsDir, f);
-          const s = await stat3(fp).catch(() => null);
-          if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
-            await unlink2(fp).catch(() => {
-            });
-            log.debug(`initialize: removed stale compaction signal ${f}`);
-          }
-        }
+        await this.validateLocalLlmModel();
       } catch (err) {
-        log.debug("initialize: stale signal sweep failed:", err);
+        log.error(`Local LLM validation failed (non-fatal): ${err}`);
       }
     }
-    log.info("orchestrator initialized (full)");
+    if (signal.aborted) return;
     if (this.config.daySummaryEnabled) {
-      this.autoRegisterDaySummaryCron().catch((err) => {
+      try {
+        await this.autoRegisterDaySummaryCron();
+      } catch (err) {
         log.debug(`day-summary cron auto-register failed (non-fatal): ${err}`);
-      });
+      }
     }
     if (this.config.nightlyGovernanceCronAutoRegister) {
-      this.autoRegisterNightlyGovernanceCron().catch((err) => {
+      try {
+        await this.autoRegisterNightlyGovernanceCron();
+      } catch (err) {
         log.debug(`nightly governance cron auto-register failed (non-fatal): ${err}`);
-      });
+      }
     }
+    if (this.config.procedural?.proceduralMiningCronAutoRegister) {
+      try {
+        await this.autoRegisterProceduralMiningCron();
+      } catch (err) {
+        log.debug(`procedural mining cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    if (this.config.contradictionScan?.enabled) {
+      try {
+        await this.autoRegisterContradictionScanCron();
+      } catch (err) {
+        log.debug(`contradiction scan cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    log.info("orchestrator initialized (full \u2014 deferred steps complete)");
+  }
+  /**
+   * Namespace-aware startup search sync. Re-probes QMD, ensures collections
+   * (namespace-aware when namespacesEnabled), runs update, and warms up search.
+   * Designed for server retry paths that run after the deferred init completes
+   * when QMD was not available during initial startup.
+   *
+   * Accepts an optional AbortSignal so callers can interrupt the sync during
+   * shutdown. The signal is checked between phases and forwarded into the QMD
+   * update and warmup search calls so a long-running `qmd update` subprocess
+   * is killed promptly rather than left in flight after `httpServer.stop()`.
+   *
+   * Returns true if the sync succeeded (QMD now available), false otherwise.
+   */
+  async startupSearchSync(signal) {
+    if (signal?.aborted) return false;
+    const available = await this.qmd.probe();
+    if (!available) return false;
+    if (signal?.aborted) {
+      log.debug("startupSearchSync: aborted after probe");
+      return false;
+    }
+    log.info(`startupSearchSync: backend now available ${this.qmd.debugStatus()}`);
+    if (this.config.namespacesEnabled) {
+      this.namespaceSearchRouter.clearCache();
+    }
+    const namespaces = this.config.namespacesEnabled ? this.configuredNamespaces() : [this.config.defaultNamespace];
+    const states = await Promise.all(
+      namespaces.map(async (namespace) => ({
+        namespace,
+        state: this.config.namespacesEnabled ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace) : await this.qmd.ensureCollection(this.config.memoryDir)
+      }))
+    );
+    if (signal?.aborted) {
+      log.debug("startupSearchSync: aborted after ensureCollection");
+      return false;
+    }
+    const defaultState = states.find((e) => e.namespace === this.config.defaultNamespace)?.state ?? "unknown";
+    if (defaultState === "missing") {
+      if ("available" in this.qmd) {
+        this.qmd.available = false;
+      }
+      this.qmd = new NoopSearchBackend();
+      log.warn("startupSearchSync: search collection missing; disabling search (fallback retrieval remains enabled)");
+      return false;
+    }
+    if (this.config.qmdMaintenanceEnabled) {
+      try {
+        const failTsBefore = "lastUpdateFailedAtMs" in this.qmd ? this.qmd.lastUpdateFailedAtMs : null;
+        const hasRunTs = "lastUpdateRanAtMs" in this.qmd;
+        if ("resetUpdateThrottles" in this.qmd) {
+          this.qmd.resetUpdateThrottles();
+        }
+        log.info("startupSearchSync: updating index to match current disk state");
+        let namespacesUpdated = 0;
+        if (this.config.namespacesEnabled) {
+          namespacesUpdated = await this.namespaceSearchRouter.updateNamespaces(namespaces);
+        } else {
+          await this.qmd.update(signal);
+        }
+        if (signal?.aborted) {
+          log.debug("startupSearchSync: aborted after update");
+          return false;
+        }
+        const failTsAfter = "lastUpdateFailedAtMs" in this.qmd ? this.qmd.lastUpdateFailedAtMs : null;
+        const runTsAfter = hasRunTs ? this.qmd.lastUpdateRanAtMs : null;
+        if (failTsAfter !== null && failTsAfter !== failTsBefore) {
+          log.warn("startupSearchSync: update silently failed (detected via fail timestamp)");
+          return false;
+        }
+        if (this.config.namespacesEnabled) {
+          if (namespacesUpdated === 0) {
+            log.warn("startupSearchSync: no namespace backends were eligible for update (all unavailable or collections missing)");
+            return false;
+          }
+          log.info(`startupSearchSync: namespace updates succeeded (${namespacesUpdated}/${namespaces.length} namespaces updated)`);
+        } else if (hasRunTs && runTsAfter === null) {
+          log.warn("startupSearchSync: update was throttled/skipped (run timestamp is null after reset + update)");
+          return false;
+        }
+        log.info("startupSearchSync: sync complete");
+      } catch (err) {
+        log.warn(`startupSearchSync: update failed: ${err}`);
+        return false;
+      }
+    }
+    if (!signal?.aborted) {
+      try {
+        await this.qmd.search("warmup", this.config.defaultNamespace, 1, void 0, { signal });
+        log.info("startupSearchSync: warmup complete");
+      } catch (err) {
+        log.debug(`startupSearchSync: warmup search failed (non-fatal): ${err}`);
+      }
+    }
+    return true;
   }
   /**
    * Auto-register the engram-day-summary cron job in OpenClaw if it doesn't exist.
@@ -3302,6 +3790,46 @@ var Orchestrator = class _Orchestrator {
       log.debug(`nightly governance cron auto-register error: ${err}`);
     }
   }
+  async autoRegisterProceduralMiningCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync2(jobsPath)) {
+        log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const created = await ensureProceduralMiningCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      if (created.created) {
+        log.info(`procedural mining cron auto-registered (${created.jobId})`);
+      } else {
+        log.debug("procedural mining cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`procedural mining cron auto-register error: ${err}`);
+    }
+  }
+  async autoRegisterContradictionScanCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync2(jobsPath)) {
+        log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const created = await ensureContradictionScanCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      if (created.created) {
+        log.info(`contradiction scan cron auto-registered (${created.jobId})`);
+      } else {
+        log.debug("contradiction scan cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`contradiction scan cron auto-register error: ${err}`);
+    }
+  }
   async applyBehaviorRuntimePolicy(state) {
     const result = await this.policyRuntime.applyFromBehaviorState(state);
     this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
@@ -3378,6 +3906,16 @@ var Orchestrator = class _Orchestrator {
   async runConsolidationNow() {
     return this.runConsolidation();
   }
+  async reindexMemoryById(id, options) {
+    await this.indexPersistedMemory(options?.storage ?? this.storage, id);
+    this.requestQmdMaintenance();
+  }
+  registerConsolidationObserver(observer) {
+    this.consolidationObservers.add(observer);
+    return () => {
+      this.consolidationObservers.delete(observer);
+    };
+  }
   async runSemanticConsolidationNow(options) {
     return this.runSemanticConsolidation({ ...options, force: true });
   }
@@ -3433,9 +3971,18 @@ var Orchestrator = class _Orchestrator {
       );
       return result;
     }
+    let extensionsBlock = "";
+    try {
+      extensionsBlock = await buildExtensionsBlockForConsolidation(this.config);
+    } catch (err) {
+      log.warn(`[semantic-consolidation] extension discovery failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
     for (const cluster of clusters) {
       try {
-        const prompt = buildConsolidationPrompt(cluster);
+        let prompt = buildConsolidationPrompt(cluster);
+        if (extensionsBlock.length > 0) {
+          prompt += "\n\n" + extensionsBlock;
+        }
         const messages = [
           {
             role: "system",
@@ -3496,7 +4043,14 @@ var Orchestrator = class _Orchestrator {
           });
           if (archiveResult) {
             if (this.contentHashIndex) {
-              this.contentHashIndex.remove(m.content);
+              if (m.frontmatter.contentHash) {
+                this.contentHashIndex.removeByHash(m.frontmatter.contentHash);
+              } else {
+                log.warn(
+                  `[semantic-consolidation] removing hash for legacy memory ${m.frontmatter.id ?? "(unknown)"} via content fallback \u2014 no contentHash in frontmatter`
+                );
+                this.contentHashIndex.remove(m.content);
+              }
             }
             await this.embeddingFallback.removeFromIndex(m.frontmatter.id);
             if (this.config.queryAwareIndexingEnabled && m.path && m.frontmatter?.created) {
@@ -3530,6 +4084,16 @@ var Orchestrator = class _Orchestrator {
     log.info(
       `[semantic-consolidation] complete: clusters=${result.clustersFound}, consolidated=${result.memoriesConsolidated}, archived=${result.memoriesArchived}, errors=${result.errors}`
     );
+    try {
+      await materializeAfterSemanticConsolidation({
+        config: this.config,
+        memoryDir: this.config.memoryDir
+      });
+    } catch (err) {
+      log.warn(
+        `[semantic-consolidation] Codex materialize post-hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     return result;
   }
   async waitForExtractionIdle(timeoutMs = 6e4) {
@@ -3558,6 +4122,116 @@ var Orchestrator = class _Orchestrator {
     const ns = namespace && namespace.length > 0 ? namespace : this.config.defaultNamespace;
     return this.storageRouter.storageFor(ns);
   }
+  async processEntitySynthesisQueue(namespace, maxEntities = 5) {
+    if (!this.config.entitySummaryEnabled || maxEntities <= 0 || this.config.entitySynthesisMaxTokens <= 0) return 0;
+    const storage = await this.getStorage(namespace);
+    const queued = await storage.refreshEntitySynthesisQueue();
+    let processed = 0;
+    let attempted = 0;
+    for (const entityName of queued) {
+      if (attempted >= maxEntities) break;
+      attempted += 1;
+      try {
+        const raw = await storage.readEntity(entityName);
+        if (!raw) continue;
+        const entity = parseEntityFile(raw, this.config.entitySchemas);
+        const previousSynthesis = entity.synthesis || entity.summary || "";
+        const sortedTimelineEntries = entity.timeline.slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
+        const newerTimelineEntries = sortedTimelineEntries.filter(
+          (entry) => !entity.synthesisUpdatedAt || compareEntityTimestamps(entry.timestamp, entity.synthesisUpdatedAt) > 0
+        );
+        const appendedTimelineEntries = entity.synthesisTimelineCount === void 0 ? [] : entity.timeline.slice(Math.max(0, entity.synthesisTimelineCount));
+        const structuredEvidenceEntries = flattenStructuredSectionEvidence(entity.structuredSections);
+        const structuredEvidenceCount = structuredEvidenceEntries.length;
+        const structuredEvidenceDigest = fingerprintEntityStructuredFacts(entity);
+        const structuredEvidenceDrifted = structuredEvidenceDigest !== (entity.synthesisStructuredFactDigest?.trim() || void 0);
+        const appendedStructuredEvidenceEntries = entity.synthesisStructuredFactCount === void 0 || structuredEvidenceDrifted ? structuredEvidenceEntries : structuredEvidenceEntries.slice(Math.max(0, entity.synthesisStructuredFactCount));
+        const candidateEvidenceEntries = [
+          ...newerTimelineEntries,
+          ...appendedTimelineEntries,
+          ...appendedStructuredEvidenceEntries
+        ].slice().sort((left, right) => compareEntityTimestamps(right.timestamp, left.timestamp));
+        const dedupedEvidenceEntries = dedupeEntitySynthesisEvidenceEntries(
+          candidateEvidenceEntries.length > 0 ? candidateEvidenceEntries : [...sortedTimelineEntries, ...structuredEvidenceEntries]
+        );
+        const chronologicalEvidenceEntries = dedupedEvidenceEntries.slice().sort((left, right) => compareEntityTimestamps(left.timestamp, right.timestamp));
+        if (chronologicalEvidenceEntries.length === 0) continue;
+        const latestEvidenceTimestamp = chronologicalEvidenceEntries.slice().reverse().map((entry) => entry.timestamp?.trim() || void 0).find((timestamp) => Boolean(timestamp));
+        const previousSynthesisUpdatedAt = entity.synthesisUpdatedAt?.trim() || void 0;
+        const nextSynthesisUpdatedAt = compareEntityTimestamps(
+          latestEvidenceTimestamp,
+          previousSynthesisUpdatedAt
+        ) >= 0 ? latestEvidenceTimestamp : previousSynthesisUpdatedAt;
+        const evidenceBatches = [];
+        for (let index = 0; index < chronologicalEvidenceEntries.length; index += 8) {
+          evidenceBatches.push(chronologicalEvidenceEntries.slice(index, index + 8));
+        }
+        let nextSynthesis = previousSynthesis;
+        let batchFailed = false;
+        for (const evidenceEntries of evidenceBatches) {
+          const evidenceText = evidenceEntries.map((entry) => {
+            const sectionTitle = entry.source?.startsWith("section:") ? entry.source.slice("section:".length) : "";
+            const metadata = [
+              `timestamp=${entry.timestamp}`,
+              sectionTitle ? `section=${sectionTitle}` : entry.source ? `source=${entry.source}` : "",
+              entry.sessionKey ? `session=${entry.sessionKey}` : "",
+              entry.principal ? `principal=${entry.principal}` : ""
+            ].filter(Boolean).join(", ");
+            return `- ${metadata}: ${entry.text}`;
+          }).join("\n");
+          const response = await this.fastChatCompletion(
+            [
+              {
+                role: "system",
+                content: "Rewrite the entity synthesis as compact current truth. Preserve uncertainty when evidence conflicts. Return plain text only."
+              },
+              {
+                role: "user",
+                content: [
+                  `Entity: ${entity.name} (${entity.type})`,
+                  nextSynthesis ? `Previous synthesis:
+${nextSynthesis}` : "Previous synthesis: none",
+                  `New evidence:
+${evidenceText}`
+                ].join("\n\n")
+              }
+            ],
+            {
+              temperature: 0.2,
+              maxTokens: this.config.entitySynthesisMaxTokens,
+              operation: "entity_summary",
+              priority: "background"
+            }
+          );
+          const synthesis = response?.content?.trim().replace(/^["']|["']$/g, "");
+          const maxSynthesisChars = Math.max(2e3, this.config.entitySynthesisMaxTokens * 8);
+          if (!synthesis || synthesis.length < 10 || synthesis.length > maxSynthesisChars) {
+            batchFailed = true;
+            break;
+          }
+          nextSynthesis = synthesis;
+        }
+        if (batchFailed || nextSynthesis.length === 0) continue;
+        const latestRaw = await storage.readEntity(entityName);
+        if (!latestRaw) continue;
+        const latestEntity = parseEntityFile(latestRaw, this.config.entitySchemas);
+        if (fingerprintEntitySynthesisEvidence(latestEntity) !== fingerprintEntitySynthesisEvidence(entity)) {
+          continue;
+        }
+        await storage.updateEntitySynthesis(entityName, nextSynthesis, {
+          entityUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          synthesisStructuredFactDigest: structuredEvidenceDigest,
+          synthesisStructuredFactCount: structuredEvidenceCount,
+          synthesisTimelineCount: entity.timeline.length,
+          updatedAt: nextSynthesisUpdatedAt
+        });
+        processed += 1;
+      } catch (err) {
+        log.debug(`entity synthesis refresh failed for ${entityName}: ${err}`);
+      }
+    }
+    return processed;
+  }
   async generateDaySummary(memories) {
     if (this.initPromise) {
       let initGateTimeoutHandle;
@@ -6555,6 +7229,22 @@ ${formatted}`;
         });
         return section;
       })();
+      const procedureRecallPromise = (async () => {
+        if (this.config.procedural?.enabled !== true) return null;
+        if (!this.isRecallSectionEnabled("procedure-recall", true)) return null;
+        try {
+          return await buildProcedureRecallSection(
+            profileStorage,
+            retrievalQuery,
+            this.config
+          );
+        } catch (err) {
+          log.debug(
+            `procedure-recall: failed open: ${err instanceof Error ? err.message : String(err)}`
+          );
+          return null;
+        }
+      })();
       const compoundingPromise = observeEnrichmentPromise(
         (async () => {
           const t0 = Date.now();
@@ -6619,6 +7309,7 @@ ${formatted}`;
         causalTrajectorySection,
         cmcCausalChainsSection,
         calibrationSection,
+        procedureRecallSection,
         trustZoneSection,
         verifiedRecallSection,
         verifiedRulesSection,
@@ -6640,6 +7331,7 @@ ${formatted}`;
             ["causalTraj", causalTrajectoryPromise],
             ["cmc", cmcRetrievalPromise],
             ["calibration", calibrationPromise],
+            ["procedureRecall", procedureRecallPromise],
             ["trustZone", trustZonePromise],
             ["verifiedRecall", verifiedRecallPromise],
             ["verifiedRules", verifiedRulesPromise],
@@ -6745,6 +7437,13 @@ ${profile}`
           calibrationSection
         );
       }
+      if (procedureRecallSection) {
+        this.appendRecallSection(
+          sectionBuckets,
+          "procedure-recall",
+          procedureRecallSection
+        );
+      }
       if (identityContinuity) {
         this.appendRecallSection(
           sectionBuckets,
@@ -7059,7 +7758,11 @@ ${tmtNode.summary}`
             confidenceGateRejected = true;
           }
         }
-        memoryResults = memoryResults.slice(0, recallResultLimit);
+        memoryResults = this.diversifyAndLimitRecallResults(
+          "memories",
+          memoryResults,
+          recallResultLimit
+        );
         if (this.config.memoryReconstructionEnabled && memoryResults.length > 0) {
           try {
             const snippets = memoryResults.map((r) => r.snippet);
@@ -7138,11 +7841,16 @@ ${tmtNode.summary}`
               limit: embeddingFetchLimit
             }
           );
-          const scoped = (await this.boostSearchResults(
+          const boostedScoped = await this.boostSearchResults(
             scopedCandidates,
             recallNamespaces,
             retrievalQuery
-          )).slice(0, recallResultLimit);
+          );
+          const scoped = this.diversifyAndLimitRecallResults(
+            "memories",
+            boostedScoped,
+            recallResultLimit
+          );
           if (scoped.length > 0) {
             if (shouldPersistGraphSnapshot) {
               graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -7253,11 +7961,16 @@ ${tmtNode.summary}`
             limit: embeddingFetchLimit
           }
         );
-        const scoped = (await this.boostSearchResults(
+        const boostedScoped = await this.boostSearchResults(
           scopedCandidates,
           recallNamespaces,
           retrievalQuery
-        )).slice(0, recallResultLimit);
+        );
+        const scoped = this.diversifyAndLimitRecallResults(
+          "memories",
+          boostedScoped,
+          recallResultLimit
+        );
         if (scoped.length > 0) {
           if (shouldPersistGraphSnapshot) {
             graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -7285,8 +7998,20 @@ ${tmtNode.summary}`
         } else {
           const memories = await this.readAllMemoriesForNamespaces(recallNamespaces);
           if (memories.length > 0) {
+            const supersessionOptions = {
+              enabled: this.config.temporalSupersessionEnabled,
+              includeInRecall: this.config.temporalSupersessionIncludeInRecall
+            };
             const activeMemories = memories.filter(
-              (m) => (!m.frontmatter.status || m.frontmatter.status === "active") && !isArtifactMemoryPath(m.path)
+              (m) => {
+                if (isArtifactMemoryPath(m.path)) return false;
+                const status = m.frontmatter.status;
+                if (!status || status === "active") return true;
+                if (status === "superseded") {
+                  return !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions);
+                }
+                return false;
+              }
             );
             const queryAwareScopedMemories = queryAwarePrefilter.candidatePaths ? activeMemories.filter(
               (memory) => queryAwarePrefilter.candidatePaths?.has(memory.path)
@@ -7334,12 +8059,17 @@ ${tmtNode.summary}`
                   score: 1 - i / Math.max(recentSorted.length, 1)
                 })
               );
-              const recent = (await this.boostSearchResults(
+              const boostedRecent = (await this.boostSearchResults(
                 recentAsResults,
                 recallNamespaces,
                 retrievalQuery,
                 preloadedMap
-              )).sort((a, b) => b.score - a.score).slice(0, recallResultLimit);
+              )).sort((a, b) => b.score - a.score);
+              const recent = this.diversifyAndLimitRecallResults(
+                "memories",
+                boostedRecent,
+                recallResultLimit
+              );
               if (recent.length > 0) {
                 if (shouldPersistGraphSnapshot) {
                   graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -7663,7 +8393,7 @@ _Context: ${topQuestion.context}_`
       closeProfileTrace();
     }
   }
-  async processTurn(role, content, sessionKey) {
+  async processTurn(role, content, sessionKey, options = {}) {
     if (role !== "user" && role !== "assistant") {
       log.debug(`processTurn: ignoring unsupported role=${String(role)}`);
       return;
@@ -7674,15 +8404,42 @@ _Context: ${topQuestion.context}_`
       );
       return;
     }
+    const bufferKey = typeof options.bufferKey === "string" && options.bufferKey.length > 0 ? options.bufferKey : typeof sessionKey === "string" && sessionKey.length > 0 ? sessionKey : "default";
     const turn = {
       role,
       content,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      sessionKey
+      sessionKey,
+      logicalSessionKey: options.logicalSessionKey ?? bufferKey,
+      providerThreadId: options.providerThreadId ?? null,
+      turnFingerprint: options.turnFingerprint,
+      persistProcessedFingerprint: options.persistProcessedFingerprint === true
     };
-    const decision = await this.buffer.addTurn(turn);
+    const decision = await this.buffer.addTurn(bufferKey, turn);
     if (decision === "keep_buffering") return;
-    await this.queueBufferedExtraction(this.buffer.getTurns(), "trigger_mode");
+    await this.queueBufferedExtraction(
+      this.buffer.getTurns(bufferKey),
+      "trigger_mode",
+      { bufferKey }
+    );
+  }
+  async flushSession(sessionKey, options) {
+    const explicitBufferKey = typeof options.bufferKey === "string" && options.bufferKey.length > 0 ? options.bufferKey : null;
+    const discoveredBufferKeys = explicitBufferKey || typeof sessionKey !== "string" || sessionKey.length === 0 || typeof this.buffer.findBufferKeysForSession !== "function" ? [] : await this.buffer.findBufferKeysForSession(sessionKey);
+    const bufferKeys = explicitBufferKey ? [explicitBufferKey] : discoveredBufferKeys.length > 0 ? discoveredBufferKeys : typeof sessionKey === "string" && sessionKey.length > 0 ? [sessionKey] : ["default"];
+    for (const bufferKey of bufferKeys) {
+      const turns = this.buffer.getTurns(bufferKey);
+      if (turns.length === 0) continue;
+      await new Promise((resolve, reject) => {
+        void this.queueBufferedExtraction(turns, "trigger_mode", {
+          bufferKey,
+          clearBufferAfterExtraction: true,
+          skipDedupeCheck: true,
+          abortSignal: options.abortSignal,
+          onTaskSettled: (error) => error ? reject(error) : resolve()
+        }).catch(reject);
+      });
+    }
   }
   async ingestReplayBatch(turns, options = {}) {
     if (!Array.isArray(turns) || turns.length === 0) return;
@@ -7706,7 +8463,7 @@ _Context: ${topQuestion.context}_`
       bySession.set(key, list);
     }
     const replayTasks = [];
-    for (const sessionTurns of bySession.values()) {
+    for (const [key, sessionTurns] of bySession.entries()) {
       if (sessionTurns.length === 0) continue;
       replayTasks.push(
         new Promise((resolve, reject) => {
@@ -7714,6 +8471,7 @@ _Context: ${topQuestion.context}_`
             skipDedupeCheck: true,
             clearBufferAfterExtraction: false,
             skipCharThreshold: true,
+            bufferKey: key,
             extractionDeadlineMs: options.deadlineMs,
             onTaskSettled: (err) => err ? reject(err) : resolve()
           }).catch(reject);
@@ -7730,25 +8488,113 @@ _Context: ${topQuestion.context}_`
       }
     }
   }
-  async observeSessionHeartbeat(sessionKey) {
+  /**
+   * Return the namespace that `ingestBulkImportBatch` writes into (#460).
+   *
+   * Exposed so host CLIs can snapshot the same storage root that extraction
+   * actually writes to, avoiding the "CLI counts files at namespace A while
+   * writes land in namespace B" footgun that a naïve
+   * `config.defaultNamespace` snapshot could hit when a namespace policy
+   * named `"default"` also exists.
+   *
+   * Today bulk-import is pinned to `config.defaultNamespace`; future
+   * per-invocation namespace routing would thread an explicit target here
+   * and through `ingestBulkImportBatch`.
+   */
+  bulkImportWriteNamespace() {
+    return this.config.defaultNamespace;
+  }
+  /**
+   * Ingest a batch of bulk-import turns (#460). Like ingestReplayBatch, this
+   * normalizes user/assistant turns into the extraction buffer and awaits
+   * settlement, but it intentionally bypasses the captureMode="explicit"
+   * gate because bulk-import is itself an explicit user action — the user
+   * ran `bulk-import --source <name> --file ...` and would be surprised to
+   * see the command silently no-op when capture is otherwise restricted.
+   *
+   * Turns with role="other" are skipped (not supported by the extraction
+   * pipeline).
+   *
+   * Two design decisions worth calling out:
+   *
+   * - **sessionKey is truthy and per-batch-unique.**
+   *   `ThreadingManager.shouldStartNewThread` only applies the session-key
+   *   boundary check when `turn.sessionKey` is truthy (threading.ts:82);
+   *   with an empty string, imported turns could attach to the current
+   *   live thread or merge across unrelated import batches. A unique
+   *   `bulk-import:batch:<timestamp>-<rand>` key forces a fresh thread per
+   *   batch without matching common prefix/map rules in
+   *   `principalFromSessionKeyRules`. (Catch-all regex rules could still
+   *   remap the principal, but that only affects metadata provenance —
+   *   see the next point for why write routing is unaffected.)
+   *
+   * - **writeNamespaceOverride pins the storage target.**
+   *   We pass `writeNamespaceOverride: this.bulkImportWriteNamespace()` to
+   *   `queueBufferedExtraction`, which tells `runExtraction` to skip
+   *   `defaultNamespaceForPrincipal` and write directly into the
+   *   orchestrator's declared bulk-import write namespace. This keeps
+   *   writes deterministic even when namespace policies named `"default"`
+   *   exist alongside a different `config.defaultNamespace`, and also
+   *   guards against regex-catch-all principal rules steering bulk-import
+   *   into an unexpected tenant.
+   *
+   * Per-invocation namespace routing (letting callers target a namespace
+   * other than `bulkImportWriteNamespace()`) is a separate feature tracked
+   * as a follow-up — the hook is the `writeNamespaceOverride` option, but
+   * the CLI surface does not yet expose a `--namespace` flag.
+   */
+  async ingestBulkImportBatch(turns, options = {}) {
+    if (!Array.isArray(turns) || turns.length === 0) return;
+    const sessionKey = `bulk-import:batch:${Date.now().toString(36)}-` + randomBytes(6).toString("hex");
+    const sessionTurns = [];
+    for (const turn of turns) {
+      if (turn.role !== "user" && turn.role !== "assistant") continue;
+      sessionTurns.push({
+        role: turn.role,
+        content: turn.content,
+        timestamp: turn.timestamp,
+        sessionKey
+      });
+    }
+    if (sessionTurns.length === 0) return;
+    await new Promise((resolve, reject) => {
+      void this.queueBufferedExtraction(sessionTurns, "trigger_mode", {
+        skipDedupeCheck: true,
+        clearBufferAfterExtraction: false,
+        skipCharThreshold: true,
+        bufferKey: sessionKey,
+        extractionDeadlineMs: options.deadlineMs,
+        writeNamespaceOverride: this.bulkImportWriteNamespace(),
+        onTaskSettled: (err) => err ? reject(err) : resolve()
+      }).catch(reject);
+    });
+  }
+  async observeSessionHeartbeat(sessionKey, options = {}) {
     if (this.config.sessionObserverEnabled !== true) return;
     if (!sessionKey || sessionKey.length === 0) return;
+    const bufferKey = typeof options.bufferKey === "string" && options.bufferKey.length > 0 ? options.bufferKey : sessionKey;
     const previous = this.heartbeatObserverChains.get(sessionKey) ?? Promise.resolve();
     const next = previous.catch(() => void 0).then(async () => {
-      const turns = this.buffer.getTurns();
+      const turns = this.buffer.getTurns(bufferKey);
       if (turns.length === 0) return;
-      const mixedSessionTurns = turns.some(
-        (turn) => turn.sessionKey !== sessionKey
+      const normalizedSessionKey = normalizeReplaySessionKey(sessionKey);
+      const allowSharedSessionBuffer = bufferKey.startsWith(
+        CODEX_THREAD_KEY_PREFIX
       );
-      if (mixedSessionTurns) {
+      if (!allowSharedSessionBuffer && turns.some(
+        (turn) => turn.sessionKey && normalizeReplaySessionKey(turn.sessionKey) !== normalizedSessionKey
+      )) {
         log.debug(
-          `heartbeat observer skipped: mixed session buffer for ${sessionKey}`
+          `heartbeat observer skipped: mixed-session buffer contents for ${bufferKey}`
         );
         return;
       }
-      if (!this.shouldQueueExtraction(turns, { commit: false })) {
+      if (!this.shouldQueueExtraction(turns, {
+        commit: false,
+        bufferKey
+      })) {
         log.debug(
-          `heartbeat observer skipped: extraction dedupe for ${sessionKey}`
+          `heartbeat observer skipped: extraction dedupe for ${bufferKey}`
         );
         return;
       }
@@ -7762,7 +8608,9 @@ _Context: ${topQuestion.context}_`
       log.debug(
         `heartbeat observer trigger: session=${sessionKey} deltaBytes=${decision.deltaBytes} deltaTokens=${decision.deltaTokens}`
       );
-      await this.queueBufferedExtraction(turns, "heartbeat_observer");
+      await this.queueBufferedExtraction(turns, "heartbeat_observer", {
+        bufferKey
+      });
     });
     this.heartbeatObserverChains.set(sessionKey, next);
     try {
@@ -7774,7 +8622,8 @@ _Context: ${topQuestion.context}_`
     }
   }
   async queueBufferedExtraction(turnsToExtract, reason, options = {}) {
-    if (!options.skipDedupeCheck && !this.shouldQueueExtraction(turnsToExtract)) {
+    const bufferKey = options.bufferKey ?? turnsToExtract[0]?.sessionKey ?? "default";
+    if (!options.skipDedupeCheck && !this.shouldQueueExtraction(turnsToExtract, { bufferKey })) {
       log.debug(`extraction dedupe skip: preserving buffer (${reason})`);
       options.onTaskSettled?.();
       return;
@@ -7784,7 +8633,10 @@ _Context: ${topQuestion.context}_`
         await this.runExtraction(turnsToExtract, {
           clearBufferAfterExtraction: options.clearBufferAfterExtraction ?? true,
           skipCharThreshold: options.skipCharThreshold ?? false,
-          deadlineMs: options.extractionDeadlineMs
+          deadlineMs: options.extractionDeadlineMs,
+          bufferKey,
+          abortSignal: options.abortSignal,
+          writeNamespaceOverride: options.writeNamespaceOverride
         });
         options.onTaskSettled?.();
       } catch (err) {
@@ -7795,20 +8647,33 @@ _Context: ${topQuestion.context}_`
     if (!this.queueProcessing) {
       this.queueProcessing = true;
       this.processQueue().catch((err) => {
-        log.error("background extraction queue processor failed", err);
+        this.logExtractionQueueFailure(err, "processor");
         this.queueProcessing = false;
       });
     }
     log.debug(`queued extraction from ${reason}`);
   }
+  normalizeExtractionFingerprintTurns(turns) {
+    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);
+  }
+  buildExtractionFingerprint(turns, bufferKey) {
+    const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
+    if (!normalized) return null;
+    return createHash2("sha256").update(`${bufferKey}
+${normalized}`).digest("hex");
+  }
   shouldQueueExtraction(turns, options = {}) {
     if (!this.config.extractionDedupeEnabled) return true;
     if (!Array.isArray(turns) || turns.length === 0) return false;
-    const normalized = turns.filter((t) => t.role === "user" || t.role === "assistant").map(
-      (t) => `${t.role}:${(t.content ?? "").trim().slice(0, this.config.extractionMaxTurnChars)}`
-    ).join("\n");
-    if (!normalized) return false;
-    const fingerprint = createHash2("sha256").update(normalized).digest("hex");
+    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) {
@@ -7840,25 +8705,58 @@ _Context: ${topQuestion.context}_`
         try {
           await task();
         } catch (err) {
-          log.error("background extraction task failed", err);
+          this.logExtractionQueueFailure(err, "task");
         }
       }
     }
     this.queueProcessing = false;
   }
+  /**
+   * Classify + log a failure from either the per-task catch inside
+   * `processQueue()` or the outer `processQueue().catch(...)` in
+   * `queueBufferedExtraction()`.  Issue #549: `throwIfRecallAborted`
+   * (used throughout `runExtraction`) raises an Error whose `name` is
+   * `"AbortError"`.  That path fires when `before_reset` aborts a
+   * queued task to avoid duplicate extraction — it is intentional
+   * cancellation, not a failure.  Downgrading the log to debug
+   * prevents spurious `error`-level lines that routinely appear
+   * right next to a successful `persisted: N facts, M entities` log
+   * and that confuse operators into thinking extraction is broken.
+   * Genuine extraction failures (network, parse, I/O) still log at
+   * `error`.
+   *
+   * Source differentiates the two call sites so the log message
+   * names the right layer (`task` vs `processor`).
+   */
+  logExtractionQueueFailure(err, source) {
+    const aborted = source === "task" ? "background extraction task aborted (session transition)" : "background extraction queue processor aborted (session transition)";
+    const failed = source === "task" ? "background extraction task failed" : "background extraction queue processor failed";
+    if (isAbortError(err)) {
+      log.debug(aborted);
+    } else {
+      log.error(failed, err);
+    }
+  }
   async runExtraction(turns, options = {}) {
     log.debug(`running extraction on ${turns.length} turns`);
     const clearBufferAfterExtraction = options.clearBufferAfterExtraction ?? true;
     const skipCharThreshold = options.skipCharThreshold ?? false;
     const deadlineMs = typeof options.deadlineMs === "number" && Number.isFinite(options.deadlineMs) ? options.deadlineMs : void 0;
+    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
     const throwIfDeadlineExceeded = (stage) => {
       if (typeof deadlineMs === "number" && Date.now() > deadlineMs) {
         throw new Error(`replay extraction deadline exceeded (${stage})`);
       }
     };
-    const clearBuffer = async () => {
+    const throwIfAborted2 = (stage) => {
+      throwIfRecallAborted(options.abortSignal, `extraction aborted (${stage})`);
+    };
+    const clearBuffer = async (options2) => {
+      if (options2?.ignoreAbort !== true) {
+        throwIfAborted2("before_clear_buffer");
+      }
       if (clearBufferAfterExtraction) {
-        await this.buffer.clearAfterExtraction();
+        await this.buffer.clearAfterExtraction(bufferKey);
       }
     };
     const sessionKey = turns[0]?.sessionKey ?? "";
@@ -7874,6 +8772,7 @@ _Context: ${topQuestion.context}_`
       content: t.content.trim().slice(0, this.config.extractionMaxTurnChars)
     })).filter((t) => t.content.length > 0);
     throwIfDeadlineExceeded("before_extract");
+    throwIfAborted2("before_extract");
     const userTurns = normalizedTurns.filter((t) => t.role === "user");
     const totalChars = normalizedTurns.reduce(
       (sum, t) => sum + t.content.length,
@@ -7889,14 +8788,36 @@ _Context: ${topQuestion.context}_`
       return;
     }
     const principal = resolvePrincipal(sessionKey, this.config);
-    const selfNamespace = defaultNamespaceForPrincipal(principal, this.config);
+    const selfNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : defaultNamespaceForPrincipal(principal, this.config);
     const storage = await this.storageRouter.storageFor(selfNamespace);
-    const existingEntities = await storage.listEntityNames();
-    const result = await this.extraction.extract(
+    const shouldPersistProcessedFingerprint = normalizedTurns.some(
+      (turn) => turn.persistProcessedFingerprint === true
+    );
+    const extractionFingerprint = this.buildExtractionFingerprint(
       normalizedTurns,
-      existingEntities
+      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;
+    }
+    const existingEntities = await storage.listEntityNames();
+    const result = await raceRecallAbort(
+      this.extraction.extract(
+        normalizedTurns,
+        existingEntities
+      ),
+      options.abortSignal,
+      "extraction aborted (during_extract)"
     );
     throwIfDeadlineExceeded("before_persist");
+    throwIfAborted2("before_persist");
     if (!result) {
       log.warn("runExtraction: extraction returned null/undefined");
       await clearBuffer();
@@ -7932,9 +8853,35 @@ _Context: ${topQuestion.context}_`
     const persistedIds = await this.persistExtraction(
       result,
       storage,
-      threadIdForExtraction
+      threadIdForExtraction,
+      { sessionKey, principal }
     );
-    await clearBuffer();
+    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
+        );
+      }
+    }
+    meta.extractionCount += 1;
+    meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
+    meta.totalMemories += Array.isArray(result?.facts) ? result.facts.length : 0;
+    meta.totalEntities += Array.isArray(result?.entities) ? result.entities.length : 0;
+    let postPersistMetaError;
+    try {
+      await storage.saveMeta(meta);
+    } catch (error) {
+      postPersistMetaError = error;
+    }
+    await clearBuffer({ ignoreAbort: true });
     if (this.config.memoryBoxesEnabled && persistedIds.length > 0) {
       const extractionTopics = deriveTopicsFromExtraction(result);
       const firstUserTurn = turns.find((t) => t.role === "user");
@@ -7971,14 +8918,26 @@ _Context: ${topQuestion.context}_`
     const nonZeroExtraction = result.facts.length > 0 || result.entities.length > 0 || result.questions.length > 0 || result.profileUpdates.length > 0;
     if (nonZeroExtraction) this.nonZeroExtractionsSinceConsolidation += 1;
     this.maybeScheduleConsolidation(nonZeroExtraction);
-    const meta = await storage.loadMeta();
-    meta.extractionCount += 1;
-    meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
-    meta.totalMemories += Array.isArray(result?.facts) ? result.facts.length : 0;
-    meta.totalEntities += Array.isArray(result?.entities) ? result.entities.length : 0;
-    await storage.saveMeta(meta);
     this.requestQmdMaintenance();
     await this.runTierMigrationCycle(storage, "extraction");
+    if (postPersistMetaError) {
+      throw postPersistMetaError;
+    }
+  }
+  async recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta) {
+    const meta = preloadedMeta ?? await storage.loadMeta();
+    const observedAt = (/* @__PURE__ */ 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);
+    }
   }
   async runTierMigrationCycle(storage, trigger, options) {
     const dryRun = options?.dryRun === true;
@@ -8222,7 +9181,22 @@ _Context: ${topQuestion.context}_`
       }
     }
   }
-  async persistExtraction(result, storage, threadIdForExtraction) {
+  async persistExtraction(result, storage, threadIdForExtraction, sourceContext) {
+    const citationEnabled = this.config.inlineSourceAttributionEnabled === true;
+    const citationTemplate = this.config.inlineSourceAttributionFormat;
+    const citationContextBase = citationEnabled ? {
+      agent: sourceContext?.principal,
+      session: sourceContext?.sessionKey
+    } : {};
+    const applyInlineCitation = (content) => {
+      if (!citationEnabled) return content;
+      if (typeof content !== "string" || content.length === 0) return content;
+      const citationContext = {
+        ...citationContextBase,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return attachCitation(content, citationContext, citationTemplate);
+    };
     const persistedIds = [];
     const persistedIdsByStorage = /* @__PURE__ */ new Map();
     const trackPersistedId = (targetStorage, id, options = {}) => {
@@ -8238,6 +9212,8 @@ _Context: ${topQuestion.context}_`
       persistedIdsByStorage.set(key, { storage: targetStorage, ids: [id] });
     };
     let dedupedCount = 0;
+    let importanceGatedCount = 0;
+    let batchBackendUnavailable = false;
     const behaviorSignalsByStorage = /* @__PURE__ */ new Map();
     const trackBehaviorSignals = (targetStorage, events) => {
       if (events.length === 0) return;
@@ -8284,16 +9260,70 @@ _Context: ${topQuestion.context}_`
         const sharedStorage = await this.storageRouter.storageFor(
           this.config.sharedNamespace
         );
-        if (options.category === "fact" && await sharedStorage.hasFactContentHash(options.content)) {
-          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}
+[Attributes: ${normalizeAttributePairs(options.structuredAttributes)}]` : sanitizedBase.text;
+        if (options.category === "fact" && await sharedStorage.hasFactContentHash(dedupContent)) {
+          if (this.config.temporalSupersessionEnabled && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
+            let hashDedupMatchingFact;
+            let hashDedupLookupComplete = false;
+            try {
+              const normalizedIncoming = ContentHashIndex.normalizeContent(dedupContent);
+              const allShared = await sharedStorage.readAllMemories();
+              const incomingEntityNorm = normalizeSupersessionKey(options.entityRef);
+              hashDedupMatchingFact = allShared.find((m) => {
+                if (m.frontmatter.category !== "fact") return false;
+                if ((m.frontmatter.status ?? "active") !== "active") return false;
+                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;
+                }
+                return ContentHashIndex.normalizeContent(m.content ?? "") === normalizedIncoming;
+              });
+              hashDedupLookupComplete = true;
+              if (hashDedupMatchingFact) {
+                await applyTemporalSupersession({
+                  storage: sharedStorage,
+                  newMemoryId: hashDedupMatchingFact.frontmatter.id,
+                  entityRef: options.entityRef,
+                  structuredAttributes: options.structuredAttributes,
+                  createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  enabled: true,
+                  useCallerTimestamp: true
+                });
+                return;
+              }
+              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}`
+              );
+              if (hashDedupLookupComplete && hashDedupMatchingFact) {
+                return;
+              }
+              log.debug(
+                `persistExtraction: hash-dedup catch: lookup incomplete or no candidate found for ${options.sourceMemoryId}; falling through to write`
+              );
+            }
+          } else {
+            return;
+          }
         }
         const promotedId = await sharedStorage.writeMemory(
           options.category,
-          options.content,
+          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],
@@ -8301,9 +9331,30 @@ _Context: ${topQuestion.context}_`
             intentGoal: options.intentGoal,
             intentActionType: options.intentActionType,
             intentEntityTypes: options.intentEntityTypes,
-            memoryKind: options.memoryKind
+            memoryKind: options.memoryKind,
+            // Index the RAW content hash so hasFactContentHash(rawContent)
+            // returns true on subsequent extractions. Without this, the index
+            // would record the hash of citedContent (which changes every call
+            // due to an updated timestamp), causing duplicate promotions.
+            contentHashSource: rawContent
           }
         );
+        if (this.config.temporalSupersessionEnabled && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
+          try {
+            await applyTemporalSupersession({
+              storage: sharedStorage,
+              newMemoryId: promotedId,
+              entityRef: options.entityRef,
+              structuredAttributes: options.structuredAttributes,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              enabled: true
+            });
+          } catch (sharedSupersessionErr) {
+            log.warn(
+              `persistExtraction: shared-namespace temporal supersession failed open for promoted ${promotedId}: ${sharedSupersessionErr}`
+            );
+          }
+        }
         trackPersistedId(sharedStorage, promotedId, {
           includeReturnedIds: false
         });
@@ -8391,7 +9442,86 @@ _Context: ${topQuestion.context}_`
     }
     const routeRules = await this.loadRoutingRules();
     const routeOptions = this.routeEngineOptions();
+    const preRoutedCategories = 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;
+          }
+        } catch {
+        }
+      }
+    }
+    let judgeVerdictsByFactIndex = null;
+    let judgeGatedCount = 0;
+    if (this.config.extractionJudgeEnabled) {
+      try {
+        const judgeCandidates = [];
+        const candidateToFactIndex = [];
+        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;
+          }
+          const judgeCategory = preRoutedCategories[fi] ?? f.category;
+          if (judgeCategory === "procedure") {
+            continue;
+          }
+          const tags = Array.isArray(f.tags) ? f.tags : [];
+          const imp = scoreImportance(
+            f.content,
+            judgeCategory,
+            tags
+          );
+          if (!isAboveImportanceThreshold(
+            imp.level,
+            this.config.extractionMinImportanceLevel
+          )) {
+            continue;
+          }
+          judgeCandidates.push({
+            text: f.content,
+            category: judgeCategory,
+            confidence: typeof f.confidence === "number" ? f.confidence : 0.7,
+            tags,
+            importanceLevel: imp.level
+          });
+          candidateToFactIndex.push(fi);
+        }
+        const judgeResult = await judgeFactDurability(
+          judgeCandidates,
+          this.config,
+          this.localLlm,
+          new FallbackLlmClient(this.config.gatewayConfig),
+          this.judgeVerdictCache
+        );
+        judgeVerdictsByFactIndex = /* @__PURE__ */ new Map();
+        for (const [candidateIdx, verdict] of judgeResult.verdicts) {
+          const factIdx = candidateToFactIndex[candidateIdx];
+          if (factIdx !== void 0) {
+            judgeVerdictsByFactIndex.set(factIdx, verdict);
+          }
+        }
+        log.info(
+          `extraction-judge: ${judgeResult.verdicts.size}/${judgeCandidates.length} facts evaluated, ${judgeResult.cached} cached, ${judgeResult.judged} judged, ${judgeResult.elapsed}ms`
+        );
+      } catch (err) {
+        log.warn(
+          `extraction-judge: pipeline error, proceeding without filtering (fail-open): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    let factLoopIndex = -1;
     for (const fact of facts) {
+      factLoopIndex++;
       if (!fact || typeof fact.content !== "string" || !fact.content.trim()) {
         continue;
       }
@@ -8400,13 +9530,6 @@ _Context: ${topQuestion.context}_`
       }
       fact.tags = Array.isArray(fact.tags) ? fact.tags.filter((t) => typeof t === "string") : [];
       fact.confidence = typeof fact.confidence === "number" ? fact.confidence : 0.7;
-      if (this.contentHashIndex && this.contentHashIndex.has(fact.content)) {
-        log.debug(
-          `dedup: skipping duplicate fact "${fact.content.slice(0, 60)}\u2026"`
-        );
-        dedupedCount++;
-        continue;
-      }
       let writeCategory = fact.category;
       let targetStorage = storage;
       let routedRuleId;
@@ -8431,33 +9554,187 @@ _Context: ${topQuestion.context}_`
           );
         }
       }
+      const canonicalContentForHash = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
+      const contentHashDedupKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalContentForHash;
+      if (this.contentHashIndex && this.contentHashIndex.has(contentHashDedupKey)) {
+        log.debug(
+          `dedup: skipping duplicate fact "${fact.content.slice(0, 60)}\u2026"`
+        );
+        dedupedCount++;
+        continue;
+      }
       const importance = scoreImportance(
         fact.content,
         writeCategory,
         fact.tags
       );
+      if (writeCategory === "procedure" && this.config.procedural?.enabled !== true) {
+        log.debug("persistExtraction: skip procedure memory (procedural.enabled is false)");
+        continue;
+      }
+      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.debug(
+          `metric:importance_gated level=${importance.level} threshold=${this.config.extractionMinImportanceLevel} category=${writeCategory} count=${importanceGatedCount}`
+        );
+        continue;
+      }
+      if (judgeVerdictsByFactIndex) {
+        const verdict = judgeVerdictsByFactIndex.get(factLoopIndex);
+        if (verdict && !verdict.durable) {
+          if (this.config.extractionJudgeShadow) {
+            log.info(
+              `extraction-judge[shadow]: would reject "${fact.content.slice(0, 60)}\u2026" reason="${verdict.reason}"`
+            );
+          } else {
+            judgeGatedCount++;
+            log.debug(
+              `extraction-judge: rejected "${fact.content.slice(0, 60)}\u2026" reason="${verdict.reason}"`
+            );
+            continue;
+          }
+        }
+      }
+      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)}\u2026" reason="${procGate.reason}"`
+          );
+          continue;
+        }
+      }
+      let pendingSemanticSkip = null;
+      if (this.config.semanticDedupEnabled) {
+        let semanticDecision;
+        if (batchBackendUnavailable) {
+          semanticDecision = { action: "keep", reason: "backend_unavailable" };
+        } else {
+          try {
+            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"
+            };
+          }
+          if (semanticDecision.reason === "backend_unavailable") {
+            batchBackendUnavailable = true;
+          }
+        }
+        if (semanticDecision.action === "skip") {
+          pendingSemanticSkip = semanticDecision;
+        }
+      }
       const inferredIntent = this.config.intentRoutingEnabled ? inferIntentFromText(
         `${writeCategory} ${fact.tags.join(" ")} ${fact.content}`
       ) : null;
       const extractionWriteSource = fact.source === "proactive" ? "extraction-proactive" : "extraction";
-      if (this.config.chunkingEnabled) {
-        const chunkResult = chunkContent(fact.content, chunkingConfig);
+      let supersedes;
+      let links = [];
+      let contradictionDetected = false;
+      if (this.config.contradictionDetectionEnabled && this.qmd.isAvailable()) {
+        const targetNamespace = this.namespaceFromStorageDir(targetStorage.dir);
+        const contradiction = await this.checkForContradiction(
+          fact.content,
+          writeCategory,
+          targetNamespace
+        );
+        if (contradiction) {
+          contradictionDetected = true;
+          if (this.config.contradictionAutoResolve) {
+            supersedes = contradiction.supersededId;
+          }
+          links.push({
+            targetId: contradiction.supersededId,
+            linkType: "contradicts",
+            strength: contradiction.confidence,
+            reason: contradiction.reason
+          });
+          if (this.config.contradictionAutoResolve && this.config.queryAwareIndexingEnabled && contradiction.supersededPath) {
+            deindexMemory(
+              this.config.memoryDir,
+              contradiction.supersededPath,
+              contradiction.supersededCreated,
+              contradiction.supersededTags
+            );
+          }
+        }
+      }
+      const isCorrection = writeCategory === "correction";
+      if (pendingSemanticSkip && !contradictionDetected && !isCorrection) {
+        log.debug(
+          `dedup: skipping semantic near-duplicate fact "${fact.content.slice(0, 60).replace(/\s+/g, " ")}\u2026" score=${pendingSemanticSkip.topScore.toFixed(
+            3
+          )} neighbor=${pendingSemanticSkip.topId}`
+        );
+        dedupedCount++;
+        continue;
+      }
+      if (this.config.chunkingEnabled && writeCategory !== "procedure") {
+        let chunkResult;
+        if (this.config.semanticChunkingEnabled) {
+          try {
+            const embedFn = this.embeddingFallback.embedTexts.bind(this.embeddingFallback);
+            const semanticResult = await semanticChunkContent(
+              fact.content,
+              embedFn,
+              this.config.semanticChunkingConfig
+            );
+            chunkResult = semanticResult;
+          } catch (err) {
+            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) {
           const memoryKind2 = this.config.episodeNoteModeEnabled ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory) : void 0;
+          const rawChunkedContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
+          const citedChunkedContent = applyInlineCitation(rawChunkedContent);
           const parentId = await targetStorage.writeMemory(
             writeCategory,
-            fact.content,
+            citedChunkedContent,
             {
               confidence: fact.confidence,
               tags: [...fact.tags, "chunked"],
               entityRef: fact.entityRef,
               source: extractionWriteSource,
               importance,
+              supersedes,
+              links: links.length > 0 ? links : void 0,
               intentGoal: inferredIntent?.goal,
               intentActionType: inferredIntent?.actionType,
               intentEntityTypes: inferredIntent?.entityTypes,
               memoryKind: memoryKind2,
-              structuredAttributes: fact.structuredAttributes
+              structuredAttributes: fact.structuredAttributes,
+              contentHashSource: rawChunkedContent
             }
           );
           for (const chunk of chunkResult.chunks) {
@@ -8472,7 +9749,9 @@ _Context: ${topQuestion.context}_`
               chunk.index,
               chunkResult.chunks.length,
               writeCategory,
-              chunk.content,
+              // 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,
@@ -8499,6 +9778,19 @@ _Context: ${topQuestion.context}_`
             threadEpisodeIdsForGraph.push(parentId);
           }
           await this.indexPersistedMemory(targetStorage, parentId);
+          try {
+            const supersessionEntityRef = typeof fact.entityRef === "string" ? fact.entityRef : void 0;
+            await applyTemporalSupersession({
+              storage: targetStorage,
+              newMemoryId: parentId,
+              entityRef: supersessionEntityRef,
+              structuredAttributes: fact.structuredAttributes,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              enabled: this.config.temporalSupersessionEnabled
+            });
+          } catch (err) {
+            log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
+          }
           await promoteMemoryToShared({
             sourceStorage: targetStorage,
             category: writeCategory,
@@ -8506,6 +9798,7 @@ _Context: ${topQuestion.context}_`
             confidence: fact.confidence,
             tags: fact.tags,
             entityRef: fact.entityRef,
+            structuredAttributes: fact.structuredAttributes,
             sourceMemoryId: parentId,
             importance,
             intentGoal: inferredIntent?.goal,
@@ -8515,14 +9808,15 @@ _Context: ${topQuestion.context}_`
             source: extractionWriteSource
           });
           if (this.contentHashIndex) {
-            this.contentHashIndex.add(fact.content);
+            const canonicalChunkedContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
+            this.contentHashIndex.add(canonicalChunkedContent);
           }
           for (const chunk of chunkResult.chunks) {
             const chunkId = `${parentId}-chunk-${chunk.index}`;
             await this.indexPersistedMemory(targetStorage, chunkId);
           }
           if (this.config.verbatimArtifactsEnabled && this.config.verbatimArtifactCategories.includes(writeCategory) && fact.confidence >= this.config.verbatimArtifactsMinConfidence) {
-            await targetStorage.writeArtifact(fact.content, {
+            await targetStorage.writeArtifact(citedChunkedContent, {
               confidence: fact.confidence,
               tags: [...fact.tags, "artifact", "chunked-parent"],
               artifactType: this.artifactTypeForCategory(writeCategory),
@@ -8581,33 +9875,6 @@ _Context: ${topQuestion.context}_`
           continue;
         }
       }
-      let supersedes;
-      let links = [];
-      if (this.config.contradictionDetectionEnabled && this.qmd.isAvailable()) {
-        const targetNamespace = this.namespaceFromStorageDir(targetStorage.dir);
-        const contradiction = await this.checkForContradiction(
-          fact.content,
-          writeCategory,
-          targetNamespace
-        );
-        if (contradiction) {
-          supersedes = contradiction.supersededId;
-          links.push({
-            targetId: contradiction.supersededId,
-            linkType: "contradicts",
-            strength: contradiction.confidence,
-            reason: contradiction.reason
-          });
-          if (this.config.queryAwareIndexingEnabled && contradiction.supersededPath) {
-            deindexMemory(
-              this.config.memoryDir,
-              contradiction.supersededPath,
-              contradiction.supersededCreated,
-              contradiction.supersededTags
-            );
-          }
-        }
-      }
       if (this.config.memoryLinkingEnabled && this.qmd.isAvailable()) {
         const targetNamespace = this.namespaceFromStorageDir(targetStorage.dir);
         const suggestedLinks = await this.suggestLinksForMemory(
@@ -8619,10 +9886,12 @@ _Context: ${topQuestion.context}_`
           links.push(...suggestedLinks);
         }
       }
-      const memoryKind = this.config.episodeNoteModeEnabled ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory) : void 0;
+      const memoryKind = writeCategory === "procedure" ? void 0 : this.config.episodeNoteModeEnabled ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory) : void 0;
+      const rawPersistBody = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : fact.content;
+      const citedFactContent = applyInlineCitation(rawPersistBody);
       const memoryId = await targetStorage.writeMemory(
         writeCategory,
-        fact.content,
+        citedFactContent,
         {
           confidence: fact.confidence,
           tags: fact.tags,
@@ -8635,7 +9904,8 @@ _Context: ${topQuestion.context}_`
           intentActionType: inferredIntent?.actionType,
           intentEntityTypes: inferredIntent?.entityTypes,
           memoryKind,
-          structuredAttributes: fact.structuredAttributes
+          structuredAttributes: fact.structuredAttributes,
+          contentHashSource: writeCategory === "fact" ? fact.content : void 0
         }
       );
       if (routedRuleId) {
@@ -8643,6 +9913,19 @@ _Context: ${topQuestion.context}_`
           `routing applied for memory ${memoryId}: rule=${routedRuleId} category=${writeCategory} storage=${targetStorage.dir}`
         );
       }
+      try {
+        const supersessionEntityRef = typeof fact.entityRef === "string" ? fact.entityRef : void 0;
+        await applyTemporalSupersession({
+          storage: targetStorage,
+          newMemoryId: memoryId,
+          entityRef: supersessionEntityRef,
+          structuredAttributes: fact.structuredAttributes,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          enabled: this.config.temporalSupersessionEnabled
+        });
+      } catch (err) {
+        log.warn(`temporal-supersession: unexpected error: ${err}`);
+      }
       trackBehaviorSignals(
         targetStorage,
         buildBehaviorSignalsForMemory({
@@ -8666,6 +9949,7 @@ _Context: ${topQuestion.context}_`
         confidence: fact.confidence,
         tags: fact.tags,
         entityRef: typeof fact.entityRef === "string" ? fact.entityRef : void 0,
+        structuredAttributes: fact.structuredAttributes,
         sourceMemoryId: memoryId,
         importance,
         intentGoal: inferredIntent?.goal,
@@ -8710,7 +9994,7 @@ _Context: ${topQuestion.context}_`
         }
       }
       if (this.config.verbatimArtifactsEnabled && this.config.verbatimArtifactCategories.includes(writeCategory) && fact.confidence >= this.config.verbatimArtifactsMinConfidence) {
-        await targetStorage.writeArtifact(fact.content, {
+        await targetStorage.writeArtifact(citedFactContent, {
           confidence: fact.confidence,
           tags: [...fact.tags, "artifact"],
           artifactType: this.artifactTypeForCategory(writeCategory),
@@ -8721,7 +10005,9 @@ _Context: ${topQuestion.context}_`
         });
       }
       if (this.contentHashIndex) {
-        this.contentHashIndex.add(fact.content);
+        const canonicalFactContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
+        const hashRegisterKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalFactContent;
+        this.contentHashIndex.add(hashRegisterKey);
       }
     }
     for (const entity of entities) {
@@ -8732,7 +10018,12 @@ _Context: ${topQuestion.context}_`
           continue;
         }
         const safeFacts = Array.isArray(entity?.facts) ? entity.facts.filter((f) => typeof f === "string") : [];
-        const id = await storage.writeEntity(name, type, safeFacts);
+        const id = await storage.writeEntity(name, type, safeFacts, {
+          source: typeof entity?.source === "string" ? entity.source : "extraction",
+          sessionKey: sourceContext?.sessionKey,
+          principal: sourceContext?.principal,
+          structuredSections: Array.isArray(entity?.structuredSections) ? entity.structuredSections : void 0
+        });
         if (id) trackPersistedId(storage, id);
       } catch (err) {
         log.warn(`persistExtraction: entity write failed: ${err}`);
@@ -8801,8 +10092,10 @@ _Context: ${topQuestion.context}_`
       );
     }
     const dedupSuffix = dedupedCount > 0 ? ` (${dedupedCount} deduped)` : "";
+    const gatedSuffix = importanceGatedCount > 0 ? ` (${importanceGatedCount} gated)` : "";
+    const judgeSuffix = judgeGatedCount > 0 ? ` (${judgeGatedCount} judge-rejected)` : "";
     log.info(
-      `persisted: ${facts.length - dedupedCount} facts${dedupSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
+      `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
     );
     void (async () => {
       if (persistedIdsByStorage.size === 0) {
@@ -9023,7 +10316,10 @@ _Context: ${topQuestion.context}_`
     }
     for (const entity of result.entityUpdates) {
       const safeFacts = Array.isArray(entity?.facts) ? entity.facts.filter((f) => typeof f === "string") : [];
-      await this.storage.writeEntity(entity.name, entity.type, safeFacts);
+      await this.storage.writeEntity(entity.name, entity.type, safeFacts, {
+        source: "consolidation",
+        structuredSections: Array.isArray(entity?.structuredSections) ? entity.structuredSections : void 0
+      });
     }
     const entitiesMerged = await this.storage.mergeFragmentedEntities();
     if (entitiesMerged > 0) {
@@ -9031,53 +10327,15 @@ _Context: ${topQuestion.context}_`
     }
     if (this.config.entitySummaryEnabled) {
       try {
-        const entityFiles = await this.storage.readAllEntityFiles();
-        const needsSummary = entityFiles.filter(
-          (e) => e.facts.length > 5 && !e.summary
+        const synthesized = await this.processEntitySynthesisQueue(
+          this.config.defaultNamespace,
+          5
         );
-        const toSummarize = needsSummary.slice(0, 5);
-        let summarized = 0;
-        for (const entity of toSummarize) {
-          try {
-            const factsText = entity.facts.slice(0, 10).join("; ");
-            const prompt = `Summarize this entity in one sentence. Entity: ${entity.name} (${entity.type}). Facts: ${factsText}`;
-            const response = await this.fastChatCompletion(
-              [
-                {
-                  role: "system",
-                  content: "Respond with a single concise sentence summarizing the entity. No JSON, just plain text."
-                },
-                { role: "user", content: prompt }
-              ],
-              {
-                temperature: 0.3,
-                maxTokens: 100,
-                operation: "entity_summary",
-                priority: "background"
-              }
-            );
-            if (response?.content) {
-              const summary = response.content.trim().replace(/^["']|["']$/g, "");
-              if (summary.length > 10 && summary.length < 500) {
-                const entityFileName = normalizeEntityName(
-                  entity.name,
-                  entity.type
-                );
-                await this.storage.updateEntitySummary(entityFileName, summary);
-                summarized++;
-              }
-            }
-          } catch (err) {
-            log.debug(
-              `entity summary generation failed for ${entity.name}: ${err}`
-            );
-          }
-        }
-        if (summarized > 0) {
-          log.info(`generated ${summarized} entity summaries`);
+        if (synthesized > 0) {
+          log.info(`refreshed ${synthesized} entity syntheses`);
         }
       } catch (err) {
-        log.debug(`entity summary pass failed: ${err}`);
+        log.debug(`entity synthesis pass failed: ${err}`);
       }
     }
     const deletedCommitments = await this.storage.cleanExpiredCommitments(
@@ -9262,6 +10520,24 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         log.warn(`tmt: consolidation hook failed (ignored): ${err}`);
       }
     }
+    if (this.consolidationObservers.size > 0) {
+      const observation = {
+        runAt: (/* @__PURE__ */ 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}`);
+        }
+      }
+    }
     log.info("consolidation complete");
     return { memoriesProcessed: allMemories.length, merged, invalidated };
   }
@@ -9666,7 +10942,14 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
       const result = await this.storage.archiveMemory(memory);
       if (result) {
         if (this.contentHashIndex) {
-          this.contentHashIndex.remove(memory.content);
+          if (memory.frontmatter.contentHash) {
+            this.contentHashIndex.removeByHash(memory.frontmatter.contentHash);
+          } else {
+            log.warn(
+              `[fact-archival] removing hash for legacy memory ${memory.frontmatter.id ?? "(unknown)"} via content fallback \u2014 no contentHash in frontmatter`
+            );
+            this.contentHashIndex.remove(memory.content);
+          }
         }
         await this.embeddingFallback.removeFromIndex(memory.frontmatter.id);
         if (this.config.queryAwareIndexingEnabled && memory.path && memory.frontmatter?.created) {
@@ -10115,14 +11398,59 @@ ${lines.join("\n\n")}`;
     });
   }
   publishRecallResults(options) {
+    const sectionId = "memories";
     const memoryIds = this.extractMemoryIdsFromResults(options.results);
     this.trackMemoryAccess(memoryIds);
     this.appendRecallSection(
       options.sectionBuckets,
-      "memories",
+      sectionId,
       this.formatQmdResults(options.title, options.results)
     );
   }
+  /**
+   * Apply MMR over the pre-truncation recall candidate pool and then slice
+   * the result to `limit`. This is the single place in the pipeline where
+   * MMR runs, and it must be called *before* callers throw away candidates
+   * that would otherwise sit below the final cutoff. Running MMR post-slice
+   * is a no-op in the cases we care about — diverse candidates just below
+   * the cutoff are already gone and can never be promoted.
+   *
+   * Callers must pass the full candidate pool (post-rerank, pre-slice).
+   */
+  diversifyAndLimitRecallResults(sectionId, results, limit) {
+    const safeLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
+    if (!Array.isArray(results) || results.length === 0) return [];
+    if (safeLimit === 0) return [];
+    const diversified = this.applyMmrToQmdResults(sectionId, results);
+    return diversified.slice(0, safeLimit);
+  }
+  /**
+   * Apply Maximal Marginal Relevance to a section's ordered candidate list.
+   *
+   * Operates per-section so one redundant cluster cannot dominate a section,
+   * and so one section's MMR pass cannot starve other sections. Returns the
+   * input unchanged when disabled, when there are fewer than 2 candidates, or
+   * when no budget information is available.
+   */
+  applyMmrToQmdResults(sectionId, results) {
+    if (this.config.recallMmrEnabled === false) return results;
+    if (!Array.isArray(results) || results.length < 2) return results;
+    const configuredTopN = this.config.recallMmrTopN;
+    const topN = typeof configuredTopN === "number" && Number.isFinite(configuredTopN) ? Math.max(0, Math.floor(configuredTopN)) : 40;
+    if (topN === 0) return results;
+    const lambda = this.config.recallMmrLambda ?? 0.7;
+    const { reordered, diversity } = reorderRecallResultsWithMmr(results, {
+      lambda,
+      topN
+    });
+    try {
+      log.info(
+        `recall_mmr: section=${sectionId} kept=${diversity.kept}/${diversity.considered} headReorderCount=${diversity.headReorderCount} avgSimBefore=${diversity.avgPairwiseSimBefore.toFixed(3)} avgSimAfter=${diversity.avgPairwiseSimAfter.toFixed(3)} lambda=${lambda.toFixed(2)}`
+      );
+    } catch {
+    }
+    return reordered;
+  }
   buildLastRecallBudgetSummary(options) {
     return {
       requestedTopK: options.requestedTopK,
@@ -10149,6 +11477,71 @@ ${lines.join("\n\n")}`;
     }
     return [...used];
   }
+  /**
+   * Issue #373 — nearest-neighbor lookup for the write-time semantic dedup
+   * guard. Returns the top-K embedding hits against the currently indexed
+   * memories, or an empty array when the embedding backend is unavailable.
+   * Intentionally does NOT throw; `decideSemanticDedup` treats both "empty"
+   * and "error" outcomes as fail-open (keep the candidate).
+   *
+   * PR #399 P1 fix: when namespaces are enabled the lookup must be scoped
+   * to the SAME namespace as the fact being written. Otherwise a
+   * high-similarity memory from another namespace can suppress a write in
+   * the target namespace — cross-tenant data loss. Callers pass the target
+   * storage so we can translate its root directory into the correct index
+   * path prefix (and, for the legacy default-namespace layout at
+   * `memoryDir` root, an exclusion list for `namespaces/*`).
+   */
+  async semanticDedupLookup(content, limit, targetStorage) {
+    if (!this.config.embeddingFallbackEnabled) {
+      throw new Error("semantic dedup: embedding backend not configured");
+    }
+    if (!await this.embeddingFallback.isAvailable()) {
+      log.debug("semantic dedup: embedding backend unavailable, skipping");
+      throw new Error("semantic dedup: embedding backend unavailable");
+    }
+    const scope = this.semanticDedupScopeFor(targetStorage);
+    const hits = await this.embeddingFallback.search(content, limit, { ...scope, throwOnTimeout: true });
+    if (!Array.isArray(hits) || hits.length === 0) return [];
+    return hits.map((hit) => ({
+      id: hit.id,
+      score: hit.score,
+      path: hit.path
+    }));
+  }
+  /**
+   * Resolve the namespace-scoped filter to pass into
+   * `EmbeddingFallback.search()` for semantic dedup. Returns an empty
+   * object (no filter) when namespaces are disabled, preserving the
+   * pre-PR #399 behavior for single-tenant installs.
+   *
+   * Index entries are stored as paths relative to `config.memoryDir`, so:
+   *   - A non-default namespace `ns` lives under `namespaces/<ns>/…` and
+   *     we include exactly that prefix.
+   *   - The default namespace may live at `memoryDir` root (legacy) or at
+   *     `memoryDir/namespaces/<default>/…` (migrated). When it lives at
+   *     root we include everything but EXCLUDE all `namespaces/…` entries
+   *     so facts from non-default namespaces can't cross-match.
+   */
+  semanticDedupScopeFor(targetStorage) {
+    if (!this.config.namespacesEnabled) return {};
+    const memoryDir = path5.resolve(this.config.memoryDir);
+    const storageDir = path5.resolve(targetStorage.dir);
+    if (storageDir === memoryDir) {
+      return { pathExcludePrefixes: ["namespaces/"] };
+    }
+    let rel = path5.relative(memoryDir, storageDir);
+    if (!rel || rel.startsWith("..")) {
+      log.debug(
+        `semantic dedup: target storage dir ${storageDir} is outside memoryDir ${memoryDir}; scoping lookup to absolute path prefix`
+      );
+      const absPrefix = storageDir.replace(/\\/g, "/");
+      return { pathPrefix: absPrefix.endsWith("/") ? absPrefix : `${absPrefix}/` };
+    }
+    rel = rel.replace(/\\/g, "/");
+    if (!rel.endsWith("/")) rel = `${rel}/`;
+    return { pathPrefix: rel };
+  }
   async searchEmbeddingFallback(query, limit) {
     if (!this.config.embeddingFallbackEnabled) return [];
     if (!await this.embeddingFallback.isAvailable()) return [];
@@ -10333,7 +11726,11 @@ ${lines.join("\n\n")}`;
         "rerankProvider=cloud is reserved/experimental in v2.2.0; skipping rerank"
       );
     }
-    return results.slice(0, options.recallResultLimit);
+    return this.diversifyAndLimitRecallResults(
+      "memories",
+      results,
+      options.recallResultLimit
+    );
   }
   // ---------------------------------------------------------------------------
   // Access Tracking (Phase 1A)
@@ -10449,6 +11846,8 @@ ${lines.join("\n\n")}`;
       }
     }
     let lifecycleFilteredCount = 0;
+    let temporalSupersededFilteredCount = 0;
+    let dedicatedSurfaceFilteredCount = 0;
     const boosted = [];
     const recencyWeight = this.effectiveRecencyWeight();
     for (const r of results) {
@@ -10462,6 +11861,17 @@ ${lines.join("\n\n")}`;
           lifecycleFilteredCount += 1;
           continue;
         }
+        if (shouldFilterSupersededFromRecall(memory.frontmatter, {
+          enabled: this.config.temporalSupersessionEnabled,
+          includeInRecall: this.config.temporalSupersessionIncludeInRecall
+        })) {
+          temporalSupersededFilteredCount += 1;
+          continue;
+        }
+        if (options?.allowDedicatedSurface !== true && (memory.frontmatter.memoryKind === "dream" || memory.frontmatter.memoryKind === "procedural")) {
+          dedicatedSurfaceFilteredCount += 1;
+          continue;
+        }
         if (recencyWeight > 0) {
           const createdAt = new Date(memory.frontmatter.created).getTime();
           const ageMs = now - createdAt;
@@ -10561,6 +11971,16 @@ ${lines.join("\n\n")}`;
         `lifecycle retrieval filter removed ${lifecycleFilteredCount} stale/archived candidates`
       );
     }
+    if (temporalSupersededFilteredCount > 0) {
+      log.debug(
+        `temporal supersession filter removed ${temporalSupersededFilteredCount} superseded candidates`
+      );
+    }
+    if (dedicatedSurfaceFilteredCount > 0) {
+      log.debug(
+        `dedicated surface filter removed ${dedicatedSurfaceFilteredCount} dream/procedural candidates from generic recall`
+      );
+    }
     return boosted.sort((a, b) => b.score - a.score);
   }
   /**
@@ -10623,27 +12043,31 @@ ${lines.join("\n\n")}`;
       );
       if (!verification) continue;
       if (verification.isContradiction && verification.confidence >= this.config.contradictionMinConfidence) {
+        if (verification.whichIsNewer === "first") {
+          log.info(
+            `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory \u2014 existing is newer, incoming fact is stale`
+          );
+          continue;
+        }
         if (this.config.contradictionAutoResolve) {
-          if (verification.whichIsNewer !== "first") {
-            await resultStorage.supersedeMemory(
-              existingMemory.frontmatter.id,
-              "pending-new",
-              // Will be updated after the new memory is written
-              verification.reasoning
-            );
-            return {
-              supersededId: existingMemory.frontmatter.id,
-              confidence: verification.confidence,
-              reason: verification.reasoning,
-              supersededPath: existingMemory.path,
-              supersededCreated: existingMemory.frontmatter.created,
-              supersededTags: existingMemory.frontmatter.tags ?? []
-            };
-          }
+          await resultStorage.supersedeMemory(
+            existingMemory.frontmatter.id,
+            "pending-new",
+            // Will be updated after the new memory is written
+            verification.reasoning
+          );
         }
         log.info(
-          `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory`
+          `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory${this.config.contradictionAutoResolve ? " (auto-resolved)" : " (queued for manual review)"}`
         );
+        return {
+          supersededId: existingMemory.frontmatter.id,
+          confidence: verification.confidence,
+          reason: verification.reasoning,
+          supersededPath: existingMemory.path,
+          supersededCreated: existingMemory.frontmatter.created,
+          supersededTags: existingMemory.frontmatter.tags ?? []
+        };
       }
     }
     return null;
@@ -10731,6 +12155,9 @@ ${lines.join("\n\n")}`;
 export {
   rollbackFromEngramMigration,
   migrateFromEngram,
+  buildProcedureRecallSection,
+  decideSemanticDedup,
+  dedupeEntitySynthesisEvidenceEntries,
   defaultWorkspaceDir,
   sanitizeSessionKeyForFilename,
   isArtifactMemoryPath,
@@ -10758,4 +12185,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-OTFNI3OO.js.map
+//# sourceMappingURL=chunk-DEPL3635.js.map