@remnic/core 1.0.3 → 1.1.1

package/dist/{chunk-XMGSSBFX.js → chunk-VYM3VWOF.js}

@@ -2,7 +2,10 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-JROGC36Y.js";
+} from "./chunk-RGLL5SPU.js";
+import {
+  extractTopics
+} from "./chunk-UHGBNIOS.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
@@ -23,17 +26,14 @@ import {
   TmtBuilder
 } from "./chunk-TPB3I2AC.js";
 import {
-  extractTopics
-} from "./chunk-UHGBNIOS.js";
+  SessionObserverState
+} from "./chunk-JR4ZC3G4.js";
 import {
   HourlySummarizer
-} from "./chunk-BTY5RRRF.js";
-import {
-  semanticChunkContent
-} from "./chunk-KVE7R4CG.js";
+} from "./chunk-ZEM3OK2K.js";
 import {
-  SessionObserverState
-} from "./chunk-JR4ZC3G4.js";
+  RelevanceStore
+} from "./chunk-5NPGSAVB.js";
 import {
   RerankCache,
   rerankLocalOrNoop
@@ -59,23 +59,26 @@ import {
 import {
   applyRuntimeRetrievalPolicy
 } from "./chunk-5IZL4DCV.js";
-import {
-  reorderRecallResultsWithMmr
-} from "./chunk-YDBIWGNI.js";
-import {
-  createRecallSectionMetricRecorder
-} from "./chunk-7DHTMOND.js";
 import {
   LastRecallStore,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries
-} from "./chunk-S4LX5EBI.js";
+} from "./chunk-VBVG2M5G.js";
+import {
+  buildXraySnapshot
+} from "./chunk-KVBLZUKV.js";
 import {
   findUnresolvedEntityRefs
 } from "./chunk-X7XN6YU4.js";
 import {
-  RelevanceStore
-} from "./chunk-5NPGSAVB.js";
+  applyReasoningTraceBoost
+} from "./chunk-ZZTOURJI.js";
+import {
+  reorderRecallResultsWithMmr
+} from "./chunk-YDBIWGNI.js";
+import {
+  createRecallSectionMetricRecorder
+} from "./chunk-7DHTMOND.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -87,69 +90,83 @@ import {
 import {
   evaluateMemoryActionPolicy
 } from "./chunk-H63EDPFJ.js";
+import {
+  applyMemoryWorthFilter,
+  buildMemoryWorthCounterMap
+} from "./chunk-3GPTTA4J.js";
 import {
   hasBroadGraphIntent,
   inferIntentFromText,
   intentCompatibilityScore,
   isTaskInitiationIntent,
   planRecallMode
-} from "./chunk-BKQJBXXX.js";
+} from "./chunk-GGD5W7TB.js";
 import {
   classifyMemoryKind
 } from "./chunk-YAZNBMNF.js";
 import {
-  EmbeddingFallback
-} from "./chunk-ALXMCZEU.js";
+  EXTRACTION_JUDGE_VERDICT_CATEGORY,
+  recordJudgeVerdict
+} from "./chunk-AJU4PJGY.js";
 import {
-  buildEntityRecallSection,
-  entityRecentTranscriptLookbackHours,
-  readRecentEntityTranscriptEntries
-} from "./chunk-74JR4N5J.js";
+  recordJudgeTrainingPair
+} from "./chunk-DF3RVK3X.js";
 import {
+  createDeferCountMap,
   createVerdictCache,
+  getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-LAYN4LDC.js";
+} from "./chunk-C4SQJZAF.js";
 import {
   ExtractionEngine
-} from "./chunk-2VFW5K5U.js";
+} from "./chunk-S3EEFKNY.js";
 import {
   parseMemoryActionEligibilityContext
-} from "./chunk-UEYA6UC7.js";
+} from "./chunk-NZLQTHS5.js";
 import {
   ProfilingCollector
 } from "./chunk-NBNN5GOB.js";
-import {
-  LocalLlmClient
-} from "./chunk-UPMD5XND.js";
 import {
   ModelRegistry
 } from "./chunk-FEMOX5AD.js";
+import {
+  LocalLlmClient
+} from "./chunk-JL2PU6AI.js";
+import {
+  tryDirectAnswer
+} from "./chunk-6AUUAZEX.js";
+import {
+  EmbeddingFallback
+} from "./chunk-ALXMCZEU.js";
+import {
+  buildEntityRecallSection,
+  entityRecentTranscriptLookbackHours,
+  readRecentEntityTranscriptEntries
+} from "./chunk-FVA6TGI3.js";
+import {
+  formatDaySummaryMemories
+} from "./chunk-GZCUW5IC.js";
 import {
   RoutingRulesStore,
+  expandTildePath,
   normalizeReplaySessionKey
-} from "./chunk-PAORGQRI.js";
+} from "./chunk-EPQJM2GC.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-GJQPH5G3.js";
+} from "./chunk-CUPFXL3J.js";
 import {
   ThreadingManager
 } from "./chunk-JRNQ3RNA.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-MYQWXITD.js";
+} from "./chunk-SPI27QT6.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-CULXMQJH.js";
 import {
   TranscriptManager
 } from "./chunk-E6K4NIEU.js";
-import {
-  PolicyRuntimeManager
-} from "./chunk-EABGC2TL.js";
-import {
-  searchObjectiveStateSnapshots
-} from "./chunk-LOBRX7VD.js";
 import {
   NamespaceSearchRouter,
   NamespaceStorageRouter,
@@ -157,17 +174,26 @@ import {
   createConversationIndexRuntime,
   createSearchBackend,
   writeConversationChunks
-} from "./chunk-HITJFT7E.js";
+} from "./chunk-7I7FKFZH.js";
 import {
   parseQmdExplain
-} from "./chunk-7PA4OZEU.js";
+} from "./chunk-YNQKWQT4.js";
+import {
+  PolicyRuntimeManager
+} from "./chunk-EABGC2TL.js";
+import {
+  searchObjectiveStateSnapshots
+} from "./chunk-LOBRX7VD.js";
+import {
+  searchHarmonicRetrieval
+} from "./chunk-HMDCOMYU.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
-} from "./chunk-J4IYOZZ5.js";
+} from "./chunk-JXS5PDQ7.js";
 import {
-  searchHarmonicRetrieval
-} from "./chunk-AAI7JARD.js";
+  launchProcessSync
+} from "./chunk-LK6SGL53.js";
 import {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,
@@ -176,6 +202,9 @@ import {
 import {
   recordEvalShadowRecall
 } from "./chunk-K6WK37A6.js";
+import {
+  GraphIndex
+} from "./chunk-C2EFFULQ.js";
 import {
   CODEX_THREAD_KEY_PREFIX
 } from "./chunk-3PG3H5TD.js";
@@ -189,21 +218,27 @@ import {
   renderCompressionGuidelinesMarkdown
 } from "./chunk-2NMMFZ5T.js";
 import {
-  formatDaySummaryMemories
-} from "./chunk-GZCUW5IC.js";
+  semanticChunkContent
+} from "./chunk-KVE7R4CG.js";
+import {
+  chunkContent
+} from "./chunk-4WMCPJWX.js";
+import {
+  SmartBuffer
+} from "./chunk-JBMSGZEQ.js";
 import {
   buildConsolidationPrompt,
   buildExtensionsBlockForConsolidation,
+  buildOperatorAwareConsolidationPrompt,
+  chooseConsolidationOperator,
   findSimilarClusters,
   materializeAfterSemanticConsolidation,
-  parseConsolidationResponse
-} from "./chunk-RCICHSHL.js";
-import {
-  GraphIndex
-} from "./chunk-C2EFFULQ.js";
+  parseConsolidationResponse,
+  parseOperatorAwareConsolidationResponse
+} from "./chunk-BGJGXLZ7.js";
 import {
-  chunkContent
-} from "./chunk-4WMCPJWX.js";
+  FallbackLlmClient
+} from "./chunk-3GXCSUXR.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-6HZ6AO2P.js";
@@ -214,36 +249,42 @@ import {
 import {
   BootstrapEngine
 } from "./chunk-N53K2EXC.js";
-import {
-  BoxBuilder
-} from "./chunk-URB2WSKZ.js";
-import {
-  SmartBuffer
-} from "./chunk-UVJFDP7P.js";
 import {
   isDisagreementPrompt
 } from "./chunk-XYIK4LF6.js";
 import {
-  FallbackLlmClient
-} from "./chunk-QKAH5B6E.js";
+  BoxBuilder
+} from "./chunk-URB2WSKZ.js";
+import {
+  abortError,
+  isAbortError,
+  throwIfAborted
+} from "./chunk-PVGDJXVK.js";
 import {
   resolveHomeDir
 } from "./chunk-MARWOCVP.js";
 import {
+  listTrustZoneRecords,
   searchTrustZoneRecords
 } from "./chunk-EQINRHYR.js";
+import {
+  buildProcedurePersistBody
+} from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-QDYXG4CS.js";
+} from "./chunk-3FPTCC3Z.js";
 import {
   selectRouteRule
-} from "./chunk-QNJMBKFK.js";
-import {
-  buildProcedurePersistBody
-} from "./chunk-QDW3E4RD.js";
+} from "./chunk-2LGMW3DJ.js";
 import {
   searchCausalTrajectories
-} from "./chunk-4NRAJUDS.js";
+} from "./chunk-RBBWYEFJ.js";
+import {
+  canReadNamespace,
+  defaultNamespaceForPrincipal,
+  recallNamespacesForPrincipal,
+  resolvePrincipal
+} from "./chunk-N5AKDXAI.js";
 import {
   decideLifecycleTransition,
   resolveLifecycleState
@@ -256,10 +297,10 @@ import {
   normalizeAttributePairs,
   normalizeEntityName,
   parseEntityFile
-} from "./chunk-POMSFKTB.js";
+} from "./chunk-F5VP6YCB.js";
 import {
   confidenceTier
-} from "./chunk-U2IQTSBY.js";
+} from "./chunk-LTCGGW2D.js";
 import {
   attachCitation,
   hasCitationForTemplate,
@@ -278,25 +319,19 @@ import {
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
-import {
-  canReadNamespace,
-  defaultNamespaceForPrincipal,
-  recallNamespacesForPrincipal,
-  resolvePrincipal
-} from "./chunk-N5AKDXAI.js";
 
 // src/orchestrator.ts
-import path5 from "path";
+import path7 from "path";
 import os from "os";
 import { createHash as createHash2, randomBytes } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 import {
-  mkdir as mkdir4,
+  mkdir as mkdir5,
   readdir as readdir3,
-  readFile as readFile3,
+  readFile as readFile4,
   stat as stat3,
   unlink as unlink2,
-  writeFile as writeFile3
+  writeFile as writeFile4
 } from "fs/promises";
 
 // src/migrate/from-engram.ts
@@ -873,7 +908,7 @@ async function buildProcedureRecallSection(storage, prompt, config) {
     10,
     Math.max(
       1,
-      typeof config.procedural.recallMaxProcedures === "number" && Number.isFinite(config.procedural.recallMaxProcedures) ? Math.floor(config.procedural.recallMaxProcedures) : 3
+      typeof config.procedural.recallMaxProcedures === "number" && Number.isFinite(config.procedural.recallMaxProcedures) ? Math.floor(config.procedural.recallMaxProcedures) : 2
     )
   );
   const all = await storage.readAllMemories();
@@ -901,6 +936,7 @@ 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();
@@ -1037,6 +1073,30 @@ async function ensureProceduralMiningCron(jobsPath, options) {
     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) {
@@ -1089,12 +1149,253 @@ async function decideSemanticDedup(content, lookup, options) {
   };
 }
 
-// src/lcm/schema.ts
+// src/taxonomy/default-taxonomy.ts
+var DEFAULT_TAXONOMY = {
+  version: 1,
+  categories: [
+    {
+      id: "corrections",
+      name: "Corrections",
+      description: "Corrections to previously stored information",
+      filingRules: ["Any update that supersedes a prior fact"],
+      priority: 10,
+      memoryCategories: ["correction"]
+    },
+    {
+      id: "principles",
+      name: "Principles",
+      description: "Rules, guidelines, and recurring patterns",
+      filingRules: ["A guiding principle, rule, or skill"],
+      priority: 20,
+      memoryCategories: ["principle", "rule", "skill"]
+    },
+    {
+      id: "procedures",
+      name: "Procedures",
+      description: "Ordered multi-step workflows the user repeats",
+      filingRules: ["A repeatable sequence of steps or commands for a task"],
+      priority: 25,
+      memoryCategories: ["procedure"]
+    },
+    {
+      id: "entities",
+      name: "Entities",
+      description: "People, organizations, places, projects",
+      filingRules: ["Named entity with attributes"],
+      priority: 30,
+      memoryCategories: ["entity", "relationship"]
+    },
+    {
+      id: "decisions",
+      name: "Decisions",
+      description: "Choices made and their rationale",
+      filingRules: ["A decision or commitment with reasoning"],
+      priority: 35,
+      memoryCategories: ["decision", "commitment"]
+    },
+    {
+      id: "preferences",
+      name: "Preferences",
+      description: "User likes, dislikes, and style choices",
+      filingRules: ["Anything expressing a preference or taste"],
+      priority: 40,
+      memoryCategories: ["preference"]
+    },
+    {
+      id: "facts",
+      name: "Facts",
+      description: "Objective statements about the world",
+      filingRules: ["Any factual claim or piece of information"],
+      priority: 50,
+      memoryCategories: ["fact"]
+    },
+    {
+      id: "moments",
+      name: "Moments",
+      description: "Significant events or experiences",
+      filingRules: ["A specific event worth remembering"],
+      priority: 60,
+      memoryCategories: ["moment"]
+    },
+    {
+      id: "reasoning-traces",
+      name: "Reasoning Traces",
+      description: "Stored intermediate reasoning / solution chains for a problem the agent previously solved",
+      filingRules: [
+        "A multi-step reasoning chain or solution walkthrough the agent can replay for a similar problem"
+      ],
+      priority: 55,
+      memoryCategories: ["reasoning_trace"]
+    }
+  ]
+};
+
+// src/taxonomy/resolver-doc-generator.ts
+function generateResolverDocument(taxonomy) {
+  const sorted = [...taxonomy.categories].sort((a, b) => {
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    return a.id.localeCompare(b.id);
+  });
+  const lines = [
+    "# Memory Filing Resolver",
+    "",
+    "Given a new piece of knowledge, follow this tree to determine where it belongs.",
+    ""
+  ];
+  let step = 1;
+  for (const cat of sorted) {
+    lines.push(`## Step ${step}: ${cat.description}?`);
+    lines.push("");
+    for (const rule of cat.filingRules) {
+      lines.push(`- ${rule}`);
+    }
+    lines.push("");
+    lines.push(
+      `> YES: File under **${cat.id}/** (priority ${cat.priority})`
+    );
+    lines.push("");
+    step++;
+  }
+  lines.push("## Tie-breaking");
+  lines.push("");
+  lines.push(
+    "If a fact could go in multiple categories, file under the one with the **lowest priority number**."
+  );
+  lines.push("");
+  lines.push(`---`);
+  lines.push(`*Generated from taxonomy v${taxonomy.version}*`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/taxonomy/taxonomy-loader.ts
+import { readFile as readFile3, mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import path3 from "path";
-import { mkdir as mkdir3 } from "fs/promises";
+var TAXONOMY_DIR = ".taxonomy";
+var TAXONOMY_FILE = "taxonomy.json";
+var MAX_SLUG_LENGTH = 32;
+var SLUG_RE = /^[a-z][a-z0-9-]*$/;
+function validateSlug(slug) {
+  if (slug.length === 0) {
+    throw new Error("Taxonomy category ID must not be empty");
+  }
+  if (slug.length > MAX_SLUG_LENGTH) {
+    throw new Error(
+      `Taxonomy category ID "${slug}" exceeds ${MAX_SLUG_LENGTH} characters`
+    );
+  }
+  if (!SLUG_RE.test(slug)) {
+    throw new Error(
+      `Taxonomy category ID "${slug}" is invalid: must be lowercase letters, digits, and hyphens, starting with a letter`
+    );
+  }
+}
+function validateTaxonomy(taxonomy) {
+  if (typeof taxonomy.version !== "number" || taxonomy.version < 1) {
+    throw new Error("Taxonomy version must be a positive integer");
+  }
+  if (!Array.isArray(taxonomy.categories)) {
+    throw new Error("Taxonomy categories must be an array");
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const cat of taxonomy.categories) {
+    validateSlug(cat.id);
+    if (seenIds.has(cat.id)) {
+      throw new Error(`Duplicate taxonomy category ID: "${cat.id}"`);
+    }
+    seenIds.add(cat.id);
+    if (typeof cat.name !== "string" || cat.name.trim().length === 0) {
+      throw new Error(`Taxonomy category "${cat.id}" must have a non-empty name`);
+    }
+    if (typeof cat.description !== "string" || cat.description.trim().length === 0) {
+      throw new Error(`Taxonomy category "${cat.id}" must have a non-empty description`);
+    }
+    if (!Array.isArray(cat.filingRules)) {
+      throw new Error(`Taxonomy category "${cat.id}" filingRules must be an array`);
+    }
+    if (typeof cat.priority !== "number" || !Number.isFinite(cat.priority)) {
+      throw new Error(`Taxonomy category "${cat.id}" must have a finite numeric priority`);
+    }
+    if (!Array.isArray(cat.memoryCategories)) {
+      throw new Error(`Taxonomy category "${cat.id}" memoryCategories must be an array`);
+    }
+    if (cat.parentId !== void 0) {
+      if (typeof cat.parentId !== "string") {
+        throw new Error(`Taxonomy category "${cat.id}" parentId must be a string if set`);
+      }
+    }
+  }
+  for (const cat of taxonomy.categories) {
+    if (cat.parentId !== void 0 && !seenIds.has(cat.parentId)) {
+      throw new Error(
+        `Taxonomy category "${cat.id}" references unknown parentId "${cat.parentId}"`
+      );
+    }
+  }
+}
+async function loadTaxonomy(memoryDir) {
+  const taxonomyPath = path3.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  let raw;
+  try {
+    raw = await readFile3(taxonomyPath, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && err.code === "ENOENT") {
+      return structuredClone(DEFAULT_TAXONOMY);
+    }
+    throw err;
+  }
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("taxonomy.json must be a JSON object");
+  }
+  const obj = parsed;
+  const userVersion = typeof obj.version === "number" ? obj.version : DEFAULT_TAXONOMY.version;
+  const userCategories = Array.isArray(obj.categories) ? obj.categories : [];
+  const userIdCounts = /* @__PURE__ */ new Map();
+  for (const cat of userCategories) {
+    const id = typeof cat.id === "string" ? cat.id : String(cat.id);
+    userIdCounts.set(id, (userIdCounts.get(id) ?? 0) + 1);
+  }
+  const duplicateIds = [...userIdCounts.entries()].filter(([, count]) => count > 1).map(([id]) => id);
+  if (duplicateIds.length > 0) {
+    throw new Error(
+      `Duplicate category IDs in taxonomy.json: ${duplicateIds.map((id) => `"${id}"`).join(", ")}`
+    );
+  }
+  const mergedMap = /* @__PURE__ */ new Map();
+  for (const cat of DEFAULT_TAXONOMY.categories) {
+    mergedMap.set(cat.id, { ...cat });
+  }
+  for (const cat of userCategories) {
+    mergedMap.set(cat.id, cat);
+  }
+  const merged = {
+    version: userVersion,
+    categories: [...mergedMap.values()]
+  };
+  validateTaxonomy(merged);
+  return merged;
+}
+async function saveTaxonomy(memoryDir, taxonomy) {
+  validateTaxonomy(taxonomy);
+  const dir = path3.join(memoryDir, TAXONOMY_DIR);
+  await mkdir3(dir, { recursive: true });
+  const filePath = path3.join(dir, TAXONOMY_FILE);
+  await writeFile3(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
+}
+function getTaxonomyDir(memoryDir) {
+  return path3.join(memoryDir, TAXONOMY_DIR);
+}
+function getTaxonomyFilePath(memoryDir) {
+  return path3.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+}
+
+// src/lcm/schema.ts
+import path4 from "path";
+import { mkdir as mkdir4 } from "fs/promises";
 var LCM_SCHEMA_VERSION = 1;
 function openLcmDatabase(memoryDir) {
-  const dbPath = path3.join(memoryDir, "state", "lcm.sqlite");
+  const dbPath = path4.join(memoryDir, "state", "lcm.sqlite");
   const db = openBetterSqlite3(dbPath);
   db.pragma("journal_mode = WAL");
   db.pragma("busy_timeout = 5000");
@@ -1103,7 +1404,7 @@ function openLcmDatabase(memoryDir) {
   return db;
 }
 async function ensureLcmStateDir(memoryDir) {
-  await mkdir3(path3.join(memoryDir, "state"), { recursive: true });
+  await mkdir4(path4.join(memoryDir, "state"), { recursive: true });
 }
 function applySchema(db) {
   const versionRow = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='lcm_meta'").get();
@@ -2367,7 +2668,7 @@ function chunkTranscriptEntries(sessionKey, entries, opts) {
 
 // src/conversation-index/cleanup.ts
 import { readdir as readdir2, rm as rm3 } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 async function cleanupConversationChunks(rootDir, retentionDays) {
   if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
@@ -2375,7 +2676,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
     const sessions = await readdir2(rootDir, { withFileTypes: true });
     for (const s of sessions) {
       if (!s.isDirectory()) continue;
-      const sessionDir = path4.join(rootDir, s.name);
+      const sessionDir = path5.join(rootDir, s.name);
       const dayDirs = await readdir2(sessionDir, { withFileTypes: true });
       for (const d of dayDirs) {
         if (!d.isDirectory()) continue;
@@ -2383,7 +2684,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
         const dayMs = (/* @__PURE__ */ new Date(d.name + "T00:00:00.000Z")).getTime();
         if (!Number.isFinite(dayMs)) continue;
         if (dayMs < cutoffMs) {
-          await rm3(path4.join(sessionDir, d.name), { recursive: true, force: true });
+          await rm3(path5.join(sessionDir, d.name), { recursive: true, force: true });
         }
       }
       try {
@@ -2399,6 +2700,264 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
   }
 }
 
+// src/coding/git-context.ts
+import path6 from "path";
+var DEFAULT_GIT_TIMEOUT_MS = 2e3;
+function defaultGitInvoker() {
+  return (cwd, args) => {
+    const result = launchProcessSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: DEFAULT_GIT_TIMEOUT_MS,
+      shell: false
+    });
+    if (result.error) {
+      return { stdout: "", exitCode: 127 };
+    }
+    return {
+      stdout: typeof result.stdout === "string" ? result.stdout : "",
+      exitCode: typeof result.status === "number" ? result.status : 1
+    };
+  };
+}
+function stableHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function normalizeOriginUrl(rawUrl) {
+  let url = rawUrl.trim();
+  if (!url) return "";
+  if (/\.git$/i.test(url)) url = url.slice(0, -4);
+  if (/^[A-Za-z]:[\\/]/.test(url)) {
+    return url.toLowerCase();
+  }
+  const protoMatch = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?(\[[^\]]+\]|[^/:]*)(?::(\d+))?(\/.*)?$/i.exec(url);
+  if (protoMatch) {
+    let host = protoMatch[1] ?? "";
+    const wasBracketed = host.startsWith("[") && host.endsWith("]");
+    if (wasBracketed) host = host.slice(1, -1);
+    const port = protoMatch[2];
+    const repoPath = (protoMatch[3] ?? "").replace(/^\/+/, "");
+    const hostPort = port ? wasBracketed ? `[${host}]:${port}` : `${host}:${port}` : host;
+    const prefix = hostPort.length > 0 ? hostPort : "localhost";
+    return `${prefix}/${repoPath}`.toLowerCase();
+  }
+  const scpMatch = /^(?:([^@\s/]+)@)?(\[[^\]]+\]|[^:@\s/]+):(.+)$/.exec(url);
+  if (scpMatch) {
+    let host = scpMatch[2] ?? "";
+    if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+    const repoPath = scpMatch[3] ?? "";
+    if (repoPath.startsWith("//")) {
+      return url.toLowerCase();
+    }
+    return `${host}/${repoPath.replace(/^\/+/, "")}`.toLowerCase();
+  }
+  return url.toLowerCase();
+}
+async function resolveGitContext(cwd, options = {}) {
+  try {
+    if (typeof cwd !== "string" || cwd.length === 0) return null;
+    const expanded = expandTildePath(cwd);
+    if (!path6.isAbsolute(expanded)) return null;
+    const invoker = options.invoker ?? defaultGitInvoker();
+    const topLevel = invoker(expanded, ["rev-parse", "--show-toplevel"]);
+    if (topLevel.exitCode !== 0) return null;
+    const rootPath = topLevel.stdout.trim();
+    if (!rootPath) return null;
+    const branchResult = invoker(rootPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    let branch = null;
+    if (branchResult.exitCode === 0) {
+      const raw = branchResult.stdout.trim();
+      branch = raw && raw !== "HEAD" ? raw : null;
+    } else {
+      const unbornRef = invoker(rootPath, ["symbolic-ref", "--quiet", "HEAD"]);
+      if (unbornRef.exitCode === 0) {
+        const raw = unbornRef.stdout.trim();
+        const prefix = "refs/heads/";
+        if (raw.startsWith(prefix)) {
+          const candidate = raw.slice(prefix.length);
+          if (candidate) branch = candidate;
+        }
+      }
+    }
+    const originResult = invoker(rootPath, ["remote", "get-url", "origin"]);
+    let projectId;
+    if (originResult.exitCode === 0) {
+      const normalized = normalizeOriginUrl(originResult.stdout);
+      projectId = normalized ? `origin:${stableHash(normalized)}` : `root:${stableHash(rootPath)}`;
+    } else {
+      projectId = `root:${stableHash(rootPath)}`;
+    }
+    const headRef = invoker(rootPath, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+    let defaultBranch = null;
+    if (headRef.exitCode === 0) {
+      const raw = headRef.stdout.trim();
+      const prefix = "refs/remotes/origin/";
+      if (raw.startsWith(prefix)) {
+        const candidate = raw.slice(prefix.length);
+        if (candidate) defaultBranch = candidate;
+      }
+    }
+    return {
+      projectId,
+      branch,
+      rootPath,
+      defaultBranch
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/coding/coding-namespace.ts
+function sanitizeFragment(input) {
+  if (typeof input !== "string") return "";
+  const trimmed = input.trim().toLowerCase();
+  let out = "";
+  let prevIsDash = true;
+  for (let i = 0; i < trimmed.length; i += 1) {
+    const c = trimmed[i];
+    const cc = trimmed.charCodeAt(i);
+    const isSafe = cc >= 48 && cc <= 57 || cc >= 97 && cc <= 122 || cc === 46 || cc === 95;
+    if (isSafe) {
+      out += c;
+      prevIsDash = false;
+    } else if (!prevIsDash) {
+      out += "-";
+      prevIsDash = true;
+    }
+  }
+  if (out.endsWith("-")) out = out.slice(0, -1);
+  return out;
+}
+var MAX_NAMESPACE_LEN = 64;
+var HASH_SUFFIX_LEN = 9;
+function capLength(value) {
+  if (value.length <= MAX_NAMESPACE_LEN) return value;
+  const hash = stableHash(value);
+  let end = MAX_NAMESPACE_LEN - HASH_SUFFIX_LEN;
+  while (end > 0 && value.charCodeAt(end - 1) === 45) end -= 1;
+  return `${value.slice(0, end)}-${hash}`;
+}
+function projectNamespaceName(projectId) {
+  const frag = sanitizeFragment(projectId);
+  return capLength(`project-${frag || "unknown"}`);
+}
+function sanitizeBaseFragment(input) {
+  if (typeof input !== "string") return "";
+  const trimmed = input.trim();
+  let out = "";
+  let prevIsDash = true;
+  for (let i = 0; i < trimmed.length; i += 1) {
+    const c = trimmed[i];
+    const cc = trimmed.charCodeAt(i);
+    const isSafe = cc >= 48 && cc <= 57 || cc >= 65 && cc <= 90 || cc >= 97 && cc <= 122 || cc === 46 || cc === 95;
+    if (isSafe) {
+      out += c;
+      prevIsDash = false;
+    } else if (!prevIsDash) {
+      out += "-";
+      prevIsDash = true;
+    }
+  }
+  if (out.endsWith("-")) out = out.slice(0, -1);
+  return out;
+}
+function combineNamespaces(base, overlay) {
+  const baseFrag = sanitizeBaseFragment(base);
+  const overlayFrag = sanitizeFragment(overlay);
+  if (!baseFrag) return capLength(overlayFrag || "unknown");
+  if (!overlayFrag) return capLength(baseFrag);
+  return capLength(`${baseFrag}-${overlayFrag}`);
+}
+function branchNamespaceName(projectId, branch) {
+  const projectFrag = sanitizeFragment(projectId);
+  const trimmedBranch = branch.trim();
+  const branchFrag = sanitizeFragment(trimmedBranch);
+  const disambig = trimmedBranch.length > 0 && branchFrag !== trimmedBranch;
+  const base = `project-${projectFrag || "unknown"}-branch-${branchFrag || "unknown"}`;
+  const suffixed = disambig ? `${base}-${stableHash(trimmedBranch)}` : base;
+  return capLength(suffixed);
+}
+function resolveCodingNamespaceOverlay(codingContext, config) {
+  if (!codingContext) return null;
+  if (!config.projectScope) return null;
+  const projectId = typeof codingContext.projectId === "string" ? codingContext.projectId.trim() : "";
+  if (!projectId) return null;
+  const projectNs = projectNamespaceName(projectId);
+  if (config.branchScope && typeof codingContext.branch === "string" && codingContext.branch.length > 0) {
+    const branchNs = branchNamespaceName(projectId, codingContext.branch);
+    return {
+      namespace: branchNs,
+      readFallbacks: [projectNs],
+      scope: "branch"
+    };
+  }
+  return {
+    namespace: projectNs,
+    readFallbacks: [],
+    scope: "project"
+  };
+}
+function describeCodingScope(codingContext, config) {
+  const projectId = codingContext?.projectId ?? null;
+  const branch = codingContext?.branch ?? null;
+  if (!codingContext) {
+    return {
+      scope: "none",
+      projectId: null,
+      branch: null,
+      effectiveNamespace: null,
+      readFallbacks: [],
+      disabledReason: "no-context"
+    };
+  }
+  if (!config.projectScope) {
+    return {
+      scope: "none",
+      projectId,
+      branch,
+      effectiveNamespace: null,
+      readFallbacks: [],
+      disabledReason: "disabled"
+    };
+  }
+  const trimmedId = typeof projectId === "string" ? projectId.trim() : "";
+  if (!trimmedId) {
+    return {
+      scope: "none",
+      projectId,
+      branch,
+      effectiveNamespace: null,
+      readFallbacks: [],
+      disabledReason: "empty-project"
+    };
+  }
+  const overlay = resolveCodingNamespaceOverlay(codingContext, config);
+  if (!overlay) {
+    return {
+      scope: "none",
+      projectId,
+      branch,
+      effectiveNamespace: null,
+      readFallbacks: [],
+      disabledReason: "disabled"
+    };
+  }
+  return {
+    scope: overlay.scope,
+    projectId,
+    branch,
+    effectiveNamespace: overlay.namespace,
+    readFallbacks: overlay.readFallbacks,
+    disabledReason: null
+  };
+}
+
 // src/orchestrator.ts
 function dedupeEntitySynthesisEvidenceEntries(entries) {
   const dedupedEvidenceEntries = [];
@@ -2463,15 +3022,23 @@ function fingerprintEntitySynthesisEvidence(entity) {
   fingerprint.update(fingerprintEntityStructuredFacts(entity) ?? "");
   return fingerprint.digest("hex");
 }
-function abortRecallError(message) {
-  const err = new Error(message);
-  Object.defineProperty(err, "name", { value: "AbortError" });
-  return err;
+function mapRecallSourceToXrayServedBy(source) {
+  switch (source) {
+    case "recent_scan":
+      return "recent-scan";
+    case "hot_qmd":
+    case "hot_embedding":
+    case "cold_fallback":
+    case "none":
+      return "hybrid";
+  }
+  const _exhaustive = source;
+  void _exhaustive;
+  return "hybrid";
 }
+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);
@@ -2491,7 +3058,7 @@ async function raceRecallAbort(promise, signal, message = "recall aborted") {
 }
 var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
 function defaultWorkspaceDir() {
-  return path5.join(os.homedir(), ".openclaw", "workspace");
+  return path7.join(os.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -2659,11 +3226,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path5.isAbsolute(candidatePath) ? candidatePath : path5.resolve(storageDir, candidatePath);
-  const rel = path5.relative(storageDir, absolutePath);
+  const absolutePath = path7.isAbsolute(candidatePath) ? candidatePath : path7.resolve(storageDir, candidatePath);
+  const rel = path7.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path5.sep).join("/");
+  return rel.split(path7.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -2805,7 +3372,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path5.relative(storageDir, mem.path));
+    pathById.set(id, path7.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -2813,7 +3380,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path5.join(options.storageDir, options.memoryRelPath),
+    path: path7.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -2833,15 +3400,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path5.join("corrections", `${options.memoryId}.md`);
+    return path7.join("corrections", `${options.memoryId}.md`);
   }
+  const subtree = options.category === "procedure" ? "procedures" : options.category === "reasoning_trace" ? "reasoning-traces" : "facts";
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path5.join("facts", day, `${options.memoryId}.md`);
+    return path7.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path5.join("facts", `${options.memoryId}.md`);
+  return path7.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -2860,12 +3428,39 @@ var Orchestrator = class _Orchestrator {
   localLlm;
   fastLlm;
   judgeVerdictCache;
-  fastGatewayLlm;
+  /**
+   * Per-orchestrator defer-counter map (issue #562, PR 2). Tracks how many
+   * times the judge has returned `"defer"` for a given candidate content
+   * hash so the defer cap can be enforced.
+   */
+  judgeDeferCounts;
+  /**
+   * Side-channel: number of facts deferred in the most recent
+   * `persistExtraction` call (issue #562, PR 2). The caller reads this after
+   * `persistExtraction` returns to decide whether to retain buffer turns for
+   * the next extraction pass. Not part of the return signature because many
+   * callers already destructure `persistedIds` by position.
+   */
+  lastPersistExtractionDeferredCount = 0;
+  _fastGatewayLlm;
+  get fastGatewayLlm() {
+    return this._fastGatewayLlm;
+  }
   modelRegistry;
   relevance;
   negatives;
   lastRecall;
   tierMigrationStatus;
+  /**
+   * In-memory X-ray snapshot from the most recent `recall()` call that
+   * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
+   * per-process; later slices add CLI/HTTP/MCP surfaces that consume
+   * this via the shared renderer.  `null` until the first capture, and
+   * NEVER overwritten by a recall that did not request capture —
+   * requests without the flag leave prior captures intact so the
+   * capturing caller can still read their snapshot back.
+   */
+  lastXraySnapshot = null;
   embeddingFallback;
   conversationIndexDir;
   extraction;
@@ -2881,6 +3476,16 @@ var Orchestrator = class _Orchestrator {
   /** Lossless Context Management engine — proactive session archive + DAG summarization. */
   lcmEngine = null;
   rerankCache = new RerankCache();
+  /**
+   * Short-TTL cache for Memory Worth counter lookups so interactive recall
+   * doesn't trigger a full `readAllMemories` scan per query. Keyed by
+   * namespace; the filter unions across namespaces at query time. The TTL
+   * is intentionally short (seconds, not minutes) because counters are
+   * mutated by `recordMemoryOutcome` asynchronously and we'd rather serve
+   * a 30-second-stale worth score than a stable-but-wrong one.
+   */
+  memoryWorthCounterCache = /* @__PURE__ */ new Map();
+  static MEMORY_WORTH_CACHE_TTL_MS = 3e4;
   /**
    * Per-session workspace overrides keyed by sessionKey.
    * Set by the before_agent_start hook so recall() uses the correct
@@ -2888,6 +3493,14 @@ var Orchestrator = class _Orchestrator {
    * Using a Map prevents concurrent sessions from overwriting each other.
    */
   _recallWorkspaceOverrides = /* @__PURE__ */ new Map();
+  /**
+   * Per-session coding-agent context (issue #569). Populated by connectors at
+   * session-start (PRs 5/6/7) via `setCodingContextForSession`. Used by both
+   * the recall path and the write path so that memory routing respects the
+   * project/branch scope a session is operating in (rule 42 — read + write
+   * through the same namespace layer).
+   */
+  _codingContextBySession = /* @__PURE__ */ new Map();
   routingRulesStore = null;
   contentHashIndex = null;
   artifactSourceStatusCache = /* @__PURE__ */ new WeakMap();
@@ -2921,6 +3534,10 @@ var Orchestrator = class _Orchestrator {
   runtimePolicyValues = null;
   utilityRuntimeValues = null;
   evalShadowWriteChain = Promise.resolve();
+  // Pending background observation-mode direct-answer annotations (#518).
+  // Tracks fire-and-forget `annotateDirectAnswerTier` calls so callers (tests,
+  // waitForDirectAnswerObservationIdle) can await settlement.
+  directAnswerObservationChain = Promise.resolve();
   // Initialization gate: recall() awaits this before proceeding
   initPromise = null;
   resolveInit = null;
@@ -2959,6 +3576,9 @@ var Orchestrator = class _Orchestrator {
       this.deferredInitAbort = null;
     }
   }
+  async disposeSearchBackendIfNeeded() {
+    await this.qmd.dispose?.();
+  }
   /** Set per-session workspace for the next recall() call (compaction reset). @internal */
   setRecallWorkspaceOverride(sessionKey, dir) {
     this._recallWorkspaceOverrides.set(sessionKey, dir);
@@ -2971,10 +3591,96 @@ var Orchestrator = class _Orchestrator {
     return resolvePrincipal(sessionKey, this.config);
   }
   resolveSelfNamespace(sessionKey) {
-    return defaultNamespaceForPrincipal(
+    const base = defaultNamespaceForPrincipal(
       this.resolvePrincipal(sessionKey),
       this.config
     );
+    return this.applyCodingNamespaceOverlay(sessionKey, base);
+  }
+  /**
+   * Attach a coding-agent context to a session (issue #569). Called by the
+   * Claude Code / Codex / Cursor connectors at session start after
+   * `resolveGitContext(cwd)`. The context is consulted by the recall path
+   * and the write path so that memories route to a project- (and optionally
+   * branch-) scoped namespace.
+   *
+   * Pass `null` to clear.
+   */
+  setCodingContextForSession(sessionKey, codingContext) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return;
+    if (!this._codingContextBySession) {
+      this._codingContextBySession = /* @__PURE__ */ new Map();
+    }
+    if (codingContext === null) {
+      this._codingContextBySession.delete(sessionKey);
+      return;
+    }
+    this._codingContextBySession.set(sessionKey, codingContext);
+  }
+  /**
+   * Read-only accessor for the coding context attached to a session. Returns
+   * `null` when none is set. Used by `remnic doctor` and by tests.
+   *
+   * Defensive `_codingContextBySession` lookup — legacy orchestrator-flush
+   * tests use `Object.create(Orchestrator.prototype)` which does not run
+   * class-field initializers, so the Map may be undefined on stubs.
+   */
+  getCodingContextForSession(sessionKey) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return null;
+    return this._codingContextBySession?.get(sessionKey) ?? null;
+  }
+  /**
+   * Shared helper used by both the recall path and the write path (rule 42).
+   *
+   * Given a base namespace computed from the principal, returns the overlaid
+   * coding namespace when the session has a coding context AND
+   * `codingMode.projectScope` is true AND `namespacesEnabled` is true.
+   * Otherwise returns `baseNamespace` unchanged — CLAUDE.md #30 escape hatch.
+   *
+   * Principal isolation (CLAUDE.md rule 42): the overlay is COMBINED with
+   * the principal-derived `baseNamespace` rather than replacing it, so two
+   * principals working in the same repository do not share memories through
+   * a common `project-*` namespace.
+   *
+   * Namespaces-disabled gate: when `namespacesEnabled` is false, the
+   * storage router maps every namespace to the same `memoryDir`. Returning
+   * `project-*` in that mode would create apparent route separation with
+   * no actual storage isolation — a false-isolation trap. In that mode we
+   * return `baseNamespace` unchanged so coding mode degrades to the existing
+   * unscoped behavior.
+   *
+   * @internal
+   */
+  applyCodingNamespaceOverlay(sessionKey, baseNamespace) {
+    if (!this.config.namespacesEnabled) return baseNamespace;
+    const codingContext = this.getCodingContextForSession(sessionKey);
+    const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode);
+    if (!overlay) return baseNamespace;
+    return combineNamespaces(baseNamespace, overlay.namespace);
+  }
+  /**
+   * Read-side overlay: returns the list of namespaces a session should read
+   * from, including any read fallbacks (branch → project asymmetry lands in
+   * PR 3; PR 2 returns an empty fallbacks list).
+   *
+   * Returns `null` when:
+   *   - `namespacesEnabled` is false (overlay would create false isolation)
+   *   - no context attached to the session
+   *   - `codingMode.projectScope` is false (CLAUDE.md #30 escape hatch)
+   *
+   * The returned `namespace` / `readFallbacks` are RAW overlay fragments
+   * (e.g. `project-origin-ab12`). Callers MUST combine them with the
+   * principal-derived base through `combineNamespaces()` before passing to
+   * storage, so principal isolation is preserved (rule 42).
+   *
+   * @internal
+   */
+  applyCodingRecallOverlay(sessionKey) {
+    if (!this.config.namespacesEnabled) return null;
+    const codingContext = this.getCodingContextForSession(sessionKey);
+    const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode);
+    if (!overlay) return null;
+    return { namespace: overlay.namespace, readFallbacks: overlay.readFallbacks };
   }
   async getStorageForNamespace(namespace) {
     const ns = typeof namespace === "string" && namespace.trim().length > 0 ? namespace.trim() : this.config.defaultNamespace;
@@ -3059,7 +3765,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path5.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path7.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.storageRouter = new NamespaceStorageRouter(config);
@@ -3086,7 +3792,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = config.compoundingEnabled ? new CompoundingEngine(config) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path5.join(
+    this.conversationIndexDir = path7.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -3110,7 +3816,9 @@ var Orchestrator = class _Orchestrator {
       this.transcript
     );
     this.judgeVerdictCache = createVerdictCache();
+    this.judgeDeferCounts = createDeferCountMap();
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
+    this.localLlm.disableThinking = config.localLlmDisableThinking;
     this.fastLlm = config.localLlmFastEnabled ? (() => {
       const client = new LocalLlmClient(
         {
@@ -3124,7 +3832,7 @@ var Orchestrator = class _Orchestrator {
       client.disableThinking = true;
       return client;
     })() : this.localLlm;
-    this.fastGatewayLlm = config.modelSource === "gateway" ? new FallbackLlmClient(config.gatewayConfig) : null;
+    this._fastGatewayLlm = config.modelSource === "gateway" ? new FallbackLlmClient(config.gatewayConfig) : null;
     if (config.modelSource === "gateway") {
       log.debug(
         `orchestrator: gateway model source active` + (config.gatewayAgentId ? ` (primary: ${config.gatewayAgentId})` : "") + (config.fastGatewayAgentId ? ` (fast: ${config.fastGatewayAgentId})` : "")
@@ -3138,7 +3846,7 @@ var Orchestrator = class _Orchestrator {
       this.modelRegistry
     );
     this.threading = new ThreadingManager(
-      path5.join(config.memoryDir, "threads"),
+      path7.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -3324,9 +4032,9 @@ var Orchestrator = class _Orchestrator {
    * routes through the gateway chain. Otherwise uses the local fast LLM.
    */
   async fastChatCompletion(messages, options) {
-    if (this.fastGatewayLlm && this.config.modelSource === "gateway") {
+    if (this._fastGatewayLlm && this.config.modelSource === "gateway") {
       const agentId = this.config.fastGatewayAgentId || this.config.gatewayAgentId || void 0;
-      const result2 = await this.fastGatewayLlm.chatCompletion(
+      const result2 = await this._fastGatewayLlm.chatCompletion(
         messages,
         { temperature: options.temperature, maxTokens: options.maxTokens, timeoutMs: options.timeoutMs, agentId }
       );
@@ -3341,7 +4049,7 @@ var Orchestrator = class _Orchestrator {
    * Otherwise returns the local fast LLM directly.
    */
   get fastLlmForRerank() {
-    if (this.fastGatewayLlm && this.config.modelSource === "gateway") {
+    if (this._fastGatewayLlm && this.config.modelSource === "gateway") {
       return {
         chatCompletion: (messages, options) => this.fastChatCompletion(messages, options ?? {})
       };
@@ -3383,7 +4091,7 @@ var Orchestrator = class _Orchestrator {
         promotionByOutcomeEnabled: this.config.promotionByOutcomeEnabled
       });
       if (this.config.factDeduplicationEnabled) {
-        const stateDir = path5.join(this.config.memoryDir, "state");
+        const stateDir = path7.join(this.config.memoryDir, "state");
         this.contentHashIndex = new ContentHashIndex(stateDir);
         await this.contentHashIndex.load();
         log.info(
@@ -3412,7 +4120,7 @@ var Orchestrator = class _Orchestrator {
           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 fp = path7.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(() => {
@@ -3441,6 +4149,7 @@ var Orchestrator = class _Orchestrator {
             (entry) => entry.namespace === this.config.defaultNamespace
           )?.state ?? "unknown";
           if (defaultState === "missing") {
+            await this.disposeSearchBackendIfNeeded();
             this.qmd = new NoopSearchBackend();
             log.warn(
               "Search collection missing for Remnic memory store; disabling search retrieval for this runtime (fallback retrieval remains enabled)"
@@ -3501,10 +4210,11 @@ var Orchestrator = class _Orchestrator {
         log.info("QMD startup sync: updating index to match current disk state");
         if (this.config.namespacesEnabled) {
           await this.namespaceSearchRouter.updateNamespaces(
-            this.configuredNamespaces()
+            this.configuredNamespaces(),
+            { signal }
           );
         } else {
-          await this.qmd.update();
+          await this.qmd.update({ signal });
         }
         log.info("QMD startup sync: complete");
         this.deferredSyncSucceeded = true;
@@ -3521,7 +4231,7 @@ var Orchestrator = class _Orchestrator {
       const warmupNs = this.config.defaultNamespace;
       log.info("QMD warmup: pre-loading models with a test search");
       warmupPromises.push(
-        this.qmd.search("warmup", warmupNs, 1).then(() => {
+        this.qmd.search("warmup", warmupNs, 1, void 0, { signal }).then(() => {
           log.info("QMD warmup: complete");
         }).catch((err) => {
           log.debug(`QMD warmup search failed (non-fatal): ${err}`);
@@ -3611,6 +4321,13 @@ var Orchestrator = class _Orchestrator {
         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)");
   }
   /**
@@ -3654,6 +4371,7 @@ var Orchestrator = class _Orchestrator {
       if ("available" in this.qmd) {
         this.qmd.available = false;
       }
+      await this.disposeSearchBackendIfNeeded();
       this.qmd = new NoopSearchBackend();
       log.warn("startupSearchSync: search collection missing; disabling search (fallback retrieval remains enabled)");
       return false;
@@ -3668,9 +4386,12 @@ var Orchestrator = class _Orchestrator {
         log.info("startupSearchSync: updating index to match current disk state");
         let namespacesUpdated = 0;
         if (this.config.namespacesEnabled) {
-          namespacesUpdated = await this.namespaceSearchRouter.updateNamespaces(namespaces);
+          namespacesUpdated = await this.namespaceSearchRouter.updateNamespaces(
+            namespaces,
+            { signal }
+          );
         } else {
-          await this.qmd.update(signal);
+          await this.qmd.update({ signal });
         }
         if (signal?.aborted) {
           log.debug("startupSearchSync: aborted after update");
@@ -3714,7 +4435,7 @@ var Orchestrator = class _Orchestrator {
    */
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug(
@@ -3738,7 +4459,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterNightlyGovernanceCron() {
     const home = process.env.HOME || os.homedir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
@@ -3760,7 +4481,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
@@ -3778,6 +4499,26 @@ var Orchestrator = class _Orchestrator {
       log.debug(`procedural mining cron auto-register error: ${err}`);
     }
   }
+  async autoRegisterContradictionScanCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path7.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();
@@ -3796,15 +4537,15 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path5.isAbsolute(rel) ? rel : path5.join(this.config.workspaceDir, rel);
+        const abs = path7.isAbsolute(rel) ? rel : path7.join(this.config.workspaceDir, rel);
         try {
-          const raw = await readFile3(abs, "utf-8");
+          const raw = await readFile4(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path5.join(
+            const archiveDir = path7.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path5.basename(abs);
+            const base = path7.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -3812,7 +4553,7 @@ var Orchestrator = class _Orchestrator {
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile3(abs, newContent, "utf-8");
+            await writeFile4(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -3829,8 +4570,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path5.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir4(path5.dirname(fp), { recursive: true });
+        const fp = path7.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir5(path7.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -3839,11 +4580,11 @@ var Orchestrator = class _Orchestrator {
 ` + warnings.map((w) => `- ${w.message}`).join("\n") + "\n";
         let existing = "";
         try {
-          existing = await readFile3(fp, "utf-8");
+          existing = await readFile4(fp, "utf-8");
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile3(fp, existing + block, "utf-8");
+        await writeFile4(fp, existing + block, "utf-8");
       }
     }
   }
@@ -3927,14 +4668,15 @@ var Orchestrator = class _Orchestrator {
     }
     for (const cluster of clusters) {
       try {
-        let prompt = buildConsolidationPrompt(cluster);
+        const operatorAwareEnabled = this.config.operatorAwareConsolidationEnabled === true;
+        let prompt = operatorAwareEnabled ? buildOperatorAwareConsolidationPrompt(cluster) : buildConsolidationPrompt(cluster);
         if (extensionsBlock.length > 0) {
           prompt += "\n\n" + extensionsBlock;
         }
         const messages = [
           {
             role: "system",
-            content: "You are a memory consolidation system. Output only the consolidated memory text."
+            content: operatorAwareEnabled ? 'You are a memory consolidation system. Return ONLY a JSON object with two keys, "operator" and "output". The "operator" value MUST be one of the exact strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder, never prose. The "output" value is the canonical memory text.' : "You are a memory consolidation system. Output only the consolidated memory text."
           },
           { role: "user", content: prompt }
         ];
@@ -3960,13 +4702,31 @@ var Orchestrator = class _Orchestrator {
           result.errors++;
           continue;
         }
-        const canonicalContent = parseConsolidationResponse(response.content);
+        let canonicalContent;
+        let operator;
+        if (operatorAwareEnabled) {
+          const parsed = parseOperatorAwareConsolidationResponse(
+            response.content,
+            cluster
+          );
+          canonicalContent = parsed.output;
+          operator = parsed.operator;
+        } else {
+          canonicalContent = parseConsolidationResponse(response.content);
+          operator = chooseConsolidationOperator(cluster);
+        }
         cluster.canonicalContent = canonicalContent;
         const sorted = [...cluster.memories].sort(
           (a, b) => new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime()
         );
         const newest = sorted[0];
         const lineageIds = cluster.memories.map((m) => m.frontmatter.id);
+        const derivedFromEntries = [];
+        for (const m of cluster.memories) {
+          if (!m.path) continue;
+          const entry = await this.storage.snapshotForProvenance(m.path);
+          if (entry) derivedFromEntries.push(entry);
+        }
         const canonicalId = await this.storage.writeMemory(
           newest.frontmatter.category,
           canonicalContent,
@@ -3979,7 +4739,9 @@ var Orchestrator = class _Orchestrator {
               )
             ],
             source: "semantic-consolidation",
-            lineage: lineageIds
+            lineage: lineageIds,
+            derivedFrom: derivedFromEntries.length > 0 ? derivedFromEntries : void 0,
+            derivedVia: operator
           }
         );
         result.memoriesConsolidated++;
@@ -4221,18 +4983,18 @@ ${evidenceText}`
     const datesToScan = [yesterday, utcToday].filter(
       (v, i, a) => a.indexOf(v) === i
     );
-    const factsBaseDir = path5.join(storage.dir, "facts");
+    const factsBaseDir = path7.join(storage.dir, "facts");
     const MAX_CHARS = 1e5;
     const facts = [];
     for (const date of datesToScan) {
-      const factsDir = path5.join(factsBaseDir, date);
+      const factsDir = path7.join(factsBaseDir, date);
       try {
         const entries = await readdir3(factsDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.name.endsWith(".md")) continue;
-          const fullPath = path5.join(factsDir, entry.name);
+          const fullPath = path7.join(factsDir, entry.name);
           try {
-            const raw = await readFile3(fullPath, "utf-8");
+            const raw = await readFile4(fullPath, "utf-8");
             const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
             if (!fmMatch) continue;
             const fmBlock = fmMatch[1];
@@ -4246,7 +5008,7 @@ ${evidenceText}`
             facts.push({
               path: fullPath,
               frontmatter: {
-                id: fm.id || path5.basename(entry.name, ".md"),
+                id: fm.id || path7.basename(entry.name, ".md"),
                 category: fm.category || "fact",
                 created: fm.created || "unknown",
                 updated: fm.updated || fm.created || "unknown",
@@ -4267,15 +5029,15 @@ ${evidenceText}`
       (a, b) => a.frontmatter.created < b.frontmatter.created ? -1 : 1
     );
     const hourlySummaries = [];
-    const hourlyBaseDir = path5.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path7.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir3(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path5.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path7.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
-            const raw = await readFile3(summaryFile, "utf-8");
+            const raw = await readFile4(summaryFile, "utf-8");
             if (raw.trim().length > 0) {
               hourlySummaries.push(raw.trim());
             }
@@ -4371,13 +5133,13 @@ ${evidenceText}`
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(
+    const snapshotPath = path7.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
     );
     try {
-      const raw = await readFile3(snapshotPath, "utf-8");
+      const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -4410,9 +5172,9 @@ ${evidenceText}`
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path7.join(storage.dir, "state", "last_intent.json");
     try {
-      const raw = await readFile3(snapshotPath, "utf-8");
+      const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       const graphDecision = parsed.graphDecision && typeof parsed.graphDecision === "object" ? parsed.graphDecision : void 0;
@@ -4443,13 +5205,13 @@ ${evidenceText}`
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path5.join(
+    const snapshotPath = path7.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
     );
     try {
-      const raw = await readFile3(snapshotPath, "utf-8");
+      const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -4595,7 +5357,7 @@ ${r.snippet.trim()}
       const entries = await readdir3(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path5.join(dir, entry.name);
+        const fullPath = path7.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -4866,11 +5628,24 @@ ${r.snippet.trim()}
           reject(new Error("recall timeout"));
         }, RECALL_TIMEOUT_MS);
       });
+      let recallResult;
       try {
-        return await Promise.race([recallPromise, timeoutPromise]);
+        recallResult = await Promise.race([recallPromise, timeoutPromise]);
       } finally {
         if (timeoutHandle) clearTimeout(timeoutHandle);
       }
+      if (this.config.recallDirectAnswerEnabled && sessionKey) {
+        try {
+          this.enqueueDirectAnswerObservation(
+            prompt,
+            sessionKey,
+            options.namespace?.trim() || void 0
+          );
+        } catch (err) {
+          log.debug(`direct-answer observation setup failed: ${err}`);
+        }
+      }
+      return recallResult;
     } catch (err) {
       this.logRecallFailure(err);
       this.profiler.endTrace();
@@ -4879,6 +5654,183 @@ ${r.snippet.trim()}
       options.abortSignal?.removeEventListener("abort", onAbort);
     }
   }
+  /**
+   * Return the most recent X-ray snapshot captured during a
+   * `recall()` call that passed `xrayCapture: true` (issue #570 PR 1).
+   * Returns `null` when no such capture has occurred on this
+   * orchestrator instance.  Returned snapshot is a deep copy so
+   * caller mutation cannot tear the stored value.
+   */
+  getLastXraySnapshot() {
+    if (!this.lastXraySnapshot) return null;
+    return structuredClone(this.lastXraySnapshot);
+  }
+  /** Clear the captured X-ray snapshot.  Exposed for tests / explicit reset. */
+  clearLastXraySnapshot() {
+    this.lastXraySnapshot = null;
+  }
+  /**
+   * Await the in-flight observation-mode direct-answer annotation chain.
+   * Resolves to true when settled, false on timeout.
+   */
+  async waitForDirectAnswerObservationIdle(timeoutMs = 6e4) {
+    let timeoutHandle = null;
+    try {
+      const timeoutPromise = new Promise((resolve) => {
+        timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
+      });
+      const result = await Promise.race([
+        this.directAnswerObservationChain.then(() => "ok"),
+        timeoutPromise
+      ]);
+      if (result === "timeout") {
+        log.warn(
+          `waitForDirectAnswerObservationIdle timed out after ${timeoutMs}ms`
+        );
+        return false;
+      }
+      return true;
+    } finally {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+    }
+  }
+  enqueueDirectAnswerObservation(prompt, sessionKey, namespaceOverride) {
+    const expectedSnapshot = this.lastRecall.get(sessionKey);
+    if (expectedSnapshot === null) return;
+    if (expectedSnapshot.plannerMode === "no_recall") return;
+    const principal = resolvePrincipal(sessionKey, this.config);
+    const observationCodingOverlay = namespaceOverride && canReadNamespace(principal, namespaceOverride, this.config) ? null : this.applyCodingRecallOverlay(sessionKey);
+    const observationPrincipalSelf = defaultNamespaceForPrincipal(principal, this.config);
+    const observationCodingSelf = observationCodingOverlay ? combineNamespaces(observationPrincipalSelf, observationCodingOverlay.namespace) : null;
+    let observationNamespaces;
+    if (namespaceOverride && canReadNamespace(principal, namespaceOverride, this.config)) {
+      observationNamespaces = [namespaceOverride];
+    } else if (observationCodingOverlay && observationCodingSelf) {
+      const base = recallNamespacesForPrincipal(principal, this.config);
+      const mapped = base.map(
+        (ns) => ns === observationPrincipalSelf ? observationCodingSelf : ns
+      );
+      const fallbackNs = observationCodingOverlay.readFallbacks.map(
+        (fallback) => combineNamespaces(observationPrincipalSelf, fallback)
+      );
+      observationNamespaces = Array.from(/* @__PURE__ */ new Set([...mapped, ...fallbackNs]));
+    } else {
+      observationNamespaces = recallNamespacesForPrincipal(principal, this.config);
+    }
+    const observationQueryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
+      cronRecallPolicyEnabled: this.config.cronRecallPolicyEnabled,
+      cronRecallNormalizedQueryMaxChars: this.config.cronRecallNormalizedQueryMaxChars,
+      cronRecallInstructionHeavyTokenCap: this.effectiveCronRecallInstructionHeavyTokenCap(),
+      cronConversationRecallMode: this.config.cronConversationRecallMode
+    });
+    const observationQuery = observationQueryPolicy.retrievalQuery || prompt;
+    const expectedIdentity = {
+      writeNonce: expectedSnapshot.writeNonce,
+      traceId: expectedSnapshot.traceId,
+      recordedAt: expectedSnapshot.recordedAt
+    };
+    const previous = this.directAnswerObservationChain;
+    this.directAnswerObservationChain = previous.catch(() => void 0).then(async () => {
+      try {
+        await this.annotateDirectAnswerTier(
+          observationQuery,
+          sessionKey,
+          observationNamespaces,
+          expectedIdentity,
+          void 0
+        );
+      } catch (err) {
+        log.debug(`direct-answer observation chain error: ${err}`);
+      }
+    });
+  }
+  async annotateDirectAnswerTier(prompt, sessionKey, namespaces, expectedIdentity, _parentAbortSignal) {
+    const tierStart = Date.now();
+    try {
+      if (namespaces.length === 0) return;
+      const trustZoneByNsAndRecordId = /* @__PURE__ */ new Map();
+      const trustZoneKey = (ns, recordId) => `${ns}\0${recordId}`;
+      const scopedStorages = /* @__PURE__ */ new Map();
+      for (const ns of namespaces) {
+        const storage = await this.storageRouter.storageFor(ns);
+        scopedStorages.set(ns, storage);
+        const trustZones = await listTrustZoneRecords({
+          memoryDir: storage.dir,
+          trustZoneStoreDir: this.config.trustZoneStoreDir,
+          limit: 200
+        }).catch(() => ({
+          allRecords: []
+        }));
+        for (const record of trustZones.allRecords ?? []) {
+          trustZoneByNsAndRecordId.set(
+            trustZoneKey(ns, record.recordId),
+            record.zone
+          );
+        }
+      }
+      const memoryNamespaceByPath = /* @__PURE__ */ new Map();
+      const memoryNamespaceById = /* @__PURE__ */ new Map();
+      let candidatesConsidered = 0;
+      const sources = {
+        taxonomy: DEFAULT_TAXONOMY,
+        listCandidateMemories: async (options) => {
+          const targetNs = options.namespace;
+          const storage = scopedStorages.get(targetNs) ?? await this.storageRouter.storageFor(targetNs);
+          const all = await storage.readAllMemories();
+          const active = [];
+          for (const m of all) {
+            if ((m.frontmatter.status ?? "active") === "active") {
+              active.push(m);
+              memoryNamespaceByPath.set(m.path, targetNs);
+              if (m.frontmatter.id) {
+                memoryNamespaceById.set(m.frontmatter.id, targetNs);
+              }
+            }
+          }
+          candidatesConsidered += active.length;
+          return active;
+        },
+        trustZoneFor: async (memoryId) => {
+          const ns = memoryNamespaceById.get(memoryId);
+          if (!ns) return null;
+          return trustZoneByNsAndRecordId.get(
+            trustZoneKey(ns, memoryId)
+          ) ?? null;
+        },
+        importanceFor: (memory) => typeof memory.frontmatter.importance?.score === "number" ? memory.frontmatter.importance.score : 0
+      };
+      let result;
+      for (const ns of namespaces) {
+        const r = await tryDirectAnswer({
+          query: prompt,
+          namespace: ns,
+          config: this.config,
+          sources
+        });
+        if (r.eligible && r.winner) {
+          result = r;
+          break;
+        }
+      }
+      if (!result?.eligible || !result?.winner) return;
+      const explain = {
+        tier: "direct-answer",
+        tierReason: result.narrative,
+        filteredBy: result.filteredBy,
+        candidatesConsidered,
+        latencyMs: Date.now() - tierStart,
+        sourceAnchors: [{ path: result.winner.memory.path }]
+      };
+      await this.lastRecall.annotateTierExplain(
+        sessionKey,
+        explain,
+        expectedIdentity
+      );
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") return;
+      log.debug(`direct-answer observation failed: ${err}`);
+    }
+  }
   logRecallFailure(err) {
     const now = Date.now();
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -5282,7 +6234,7 @@ ${r.snippet.trim()}
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path5.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path7.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -5292,7 +6244,7 @@ ${r.snippet.trim()}
       if (expanded.length === 0) continue;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path5.resolve(storage.dir, candidate.path);
+        const memoryPath = path7.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -5316,7 +6268,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path5.resolve(storage.dir, candidate.seed),
+          seed: path7.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType
@@ -5332,12 +6284,12 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path7.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir4(path5.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path7.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -5364,20 +6316,20 @@ ${r.snippet.trim()}
         finalResults: (options.finalResults ?? []).slice(0, 64),
         shadowComparison: options.shadowComparison
       };
-      await writeFile3(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile4(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
     } catch (err) {
       log.debug(`last graph recall write failed: ${err}`);
     }
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path7.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir4(path5.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      await mkdir5(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -5388,13 +6340,13 @@ ${r.snippet.trim()}
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path7.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir4(path5.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      await mkdir5(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -5408,9 +6360,9 @@ ${r.snippet.trim()}
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path5.join(stateDir, "last_intent.json");
-      await mkdir4(path5.dirname(snapshotPath), { recursive: true });
-      await writeFile3(
+      const snapshotPath = path7.join(stateDir, "last_intent.json");
+      await mkdir5(path7.dirname(snapshotPath), { recursive: true });
+      await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
         "utf-8"
@@ -5421,12 +6373,12 @@ ${r.snippet.trim()}
   }
   async resolveStateDirForNamespace(namespace) {
     if (!this.config.namespacesEnabled) {
-      return path5.join(this.config.memoryDir, "state");
+      return path7.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path5.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path7.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path5.join(
+    const candidate = path7.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -5434,11 +6386,11 @@ ${r.snippet.trim()}
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path5.join(candidate, "state");
+        return path7.join(candidate, "state");
       }
     } catch {
     }
-    return path5.join(this.config.memoryDir, "state");
+    return path7.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -5524,7 +6476,10 @@ ${r.snippet.trim()}
     }
     return reserved;
   }
-  getRecallBudgetChars() {
+  getRecallBudgetChars(override) {
+    if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
+      return Math.floor(override);
+    }
     const configuredBudget = this.config.recallBudgetChars;
     if (typeof configuredBudget === "number" && Number.isFinite(configuredBudget) && configuredBudget >= 0) {
       return Math.floor(configuredBudget);
@@ -5535,7 +6490,7 @@ ${r.snippet.trim()}
     }
     return 0;
   }
-  assembleRecallSections(sectionBuckets) {
+  assembleRecallSections(sectionBuckets, budgetOverride) {
     const orderedEntries = [];
     const pipeline = Array.isArray(this.config.recallPipeline) ? this.config.recallPipeline : [];
     const orderedIds = pipeline.filter((entry) => entry.enabled !== false).map((entry) => entry.id);
@@ -5551,7 +6506,7 @@ ${r.snippet.trim()}
       if (chunks.length === 0) continue;
       orderedEntries.push({ id, content: chunks.join("\n\n") });
     }
-    const budget = this.getRecallBudgetChars();
+    const budget = this.getRecallBudgetChars(budgetOverride);
     if (budget === 0) {
       return {
         sections: [],
@@ -5683,6 +6638,13 @@ ${r.snippet.trim()}
       let recalledMemoryCount = 0;
       let recalledMemoryIds = [];
       let recalledMemoryPaths = [];
+      const xrayBranchPoolSize = {
+        hot_qmd: 0,
+        hot_embedding: 0,
+        cold_fallback: 0,
+        recent_scan: 0
+      };
+      const xrayColdPoolSink = { size: 0 };
       let identityInjectionModeUsed = "none";
       let identityInjectedChars = 0;
       let identityInjectionTruncated = false;
@@ -5743,7 +6705,7 @@ ${r.snippet.trim()}
         this.config.verbatimArtifactsMaxRecall
       );
       const embeddingFetchLimit = computedFetchLimit;
-      const principal = resolvePrincipal(sessionKey, this.config);
+      const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
       const namespaceOverride = options.namespace?.trim() || void 0;
       const readableRecallNamespaces = recallNamespacesForPrincipal(
         principal,
@@ -5754,8 +6716,24 @@ ${r.snippet.trim()}
           `namespace override is not readable: ${namespaceOverride}`
         );
       }
-      const selfNamespace = namespaceOverride ?? defaultNamespaceForPrincipal(principal, this.config);
-      const recallNamespaces = namespaceOverride ? [namespaceOverride] : readableRecallNamespaces;
+      const codingOverlay = namespaceOverride ? null : this.applyCodingRecallOverlay(sessionKey);
+      const principalSelfNamespace = defaultNamespaceForPrincipal(principal, this.config);
+      const codingSelfNamespace = codingOverlay ? combineNamespaces(principalSelfNamespace, codingOverlay.namespace) : null;
+      const selfNamespace = namespaceOverride ?? codingSelfNamespace ?? principalSelfNamespace;
+      let recallNamespaces;
+      if (namespaceOverride) {
+        recallNamespaces = [namespaceOverride];
+      } else if (codingOverlay && codingSelfNamespace) {
+        const mapped = readableRecallNamespaces.map(
+          (ns) => ns === principalSelfNamespace ? codingSelfNamespace : ns
+        );
+        const fallbackNs = codingOverlay.readFallbacks.map(
+          (fallback) => combineNamespaces(principalSelfNamespace, fallback)
+        );
+        recallNamespaces = Array.from(/* @__PURE__ */ new Set([...mapped, ...fallbackNs]));
+      } else {
+        recallNamespaces = readableRecallNamespaces;
+      }
       const qmdAvailable = this.qmd.isAvailable();
       let graphDecisionStatus = recallDecision.plannedMode === "graph_mode" ? "skipped" : "not_requested";
       let graphDecisionReason = recallDecision.graphReason;
@@ -5772,7 +6750,7 @@ ${r.snippet.trim()}
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path5.sep).join("/");
+        const normalizedPath = resultPath.split(path7.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -5810,6 +6788,32 @@ ${r.snippet.trim()}
         const earlySessionKey = sessionKey ?? "default";
         this._recallWorkspaceOverrides.delete(earlySessionKey);
         timings.total = `${Date.now() - recallStart}ms`;
+        if (options.xrayCapture === true && !options.abortSignal?.aborted) {
+          try {
+            this.lastXraySnapshot = buildXraySnapshot({
+              query: retrievalQuery,
+              tierExplain: null,
+              results: [],
+              filters: [
+                {
+                  name: "planner-mode",
+                  considered: 0,
+                  admitted: 0,
+                  reason: "no_recall"
+                }
+              ],
+              budget: {
+                chars: this.getRecallBudgetChars(options.budgetCharsOverride),
+                used: 0
+              },
+              sessionKey,
+              namespace: selfNamespace,
+              traceId
+            });
+          } catch (err) {
+            log.debug(`x-ray capture (no_recall) failed: ${err}`);
+          }
+        }
         if (sessionKey) {
           this.lastRecall.record({
             sessionKey,
@@ -6959,16 +7963,16 @@ ${formatted}`;
         if (!this.config.compactionResetEnabled) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path5.join(
+        const signalPath = path7.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path5.join(workspaceDir, "BOOT.md");
+        const bootPath = path7.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat3(signalPath).catch(() => null);
           if (!signalStat) return null;
           const signalAge = Date.now() - signalStat.mtimeMs;
-          const signalData = JSON.parse(await readFile3(signalPath, "utf-8"));
+          const signalData = JSON.parse(await readFile4(signalPath, "utf-8"));
           if (signalData.sessionKey !== effectiveSessionKey) {
             log.debug(
               `recall: compaction signal is for ${signalData.sessionKey}, not ${effectiveSessionKey} \u2014 skipping`
@@ -6988,7 +7992,7 @@ ${formatted}`;
 
 `;
           try {
-            const bootContent = await readFile3(bootPath, "utf-8");
+            const bootContent = await readFile4(bootPath, "utf-8");
             section += "### BOOT.md (working state before compaction)\n\n";
             section += bootContent + "\n";
           } catch {
@@ -7182,7 +8186,7 @@ ${formatted}`;
         if (!this.isRecallSectionEnabled("procedure-recall", true)) return null;
         try {
           return await buildProcedureRecallSection(
-            this.storage,
+            profileStorage,
             retrievalQuery,
             this.config
           );
@@ -7695,7 +8699,18 @@ ${tmtNode.summary}`
             "rerankProvider=cloud is reserved/experimental in v2.2.0; skipping rerank"
           );
         }
+        if (this.config.recallMemoryWorthFilterEnabled && memoryResults.length > 0) {
+          try {
+            memoryResults = await this.applyMemoryWorthRerank(memoryResults, recallNamespaces);
+          } catch (err) {
+            log.debug("memory-worth filter failed open", { error: err.message });
+          }
+        }
         const effectiveGateScore = preAugmentTopScore > 0 ? Math.max(preAugmentTopScore, maxSpecializedScore) : 0;
+        xrayBranchPoolSize.hot_qmd = Math.max(
+          xrayBranchPoolSize.hot_qmd,
+          memoryResults.length
+        );
         let confidenceGateRejected = false;
         if (this.config.recallConfidenceGateEnabled && effectiveGateScore > 0) {
           if (effectiveGateScore < this.config.recallConfidenceGateThreshold) {
@@ -7709,7 +8724,8 @@ ${tmtNode.summary}`
         memoryResults = this.diversifyAndLimitRecallResults(
           "memories",
           memoryResults,
-          recallResultLimit
+          recallResultLimit,
+          retrievalQuery
         );
         if (this.config.memoryReconstructionEnabled && memoryResults.length > 0) {
           try {
@@ -7794,10 +8810,15 @@ ${tmtNode.summary}`
             recallNamespaces,
             retrievalQuery
           );
+          xrayBranchPoolSize.hot_embedding = Math.max(
+            xrayBranchPoolSize.hot_embedding,
+            boostedScoped.length
+          );
           const scoped = this.diversifyAndLimitRecallResults(
             "memories",
             boostedScoped,
-            recallResultLimit
+            recallResultLimit,
+            retrievalQuery
           );
           if (scoped.length > 0) {
             if (shouldPersistGraphSnapshot) {
@@ -7830,7 +8851,8 @@ ${tmtNode.summary}`
               recallResultLimit,
               recallMode,
               queryAwarePrefilter,
-              abortSignal: options.abortSignal
+              abortSignal: options.abortSignal,
+              xrayPoolSizeSink: xrayColdPoolSink
             });
             if (longTerm.length > 0) {
               if (shouldPersistGraphSnapshot) {
@@ -7914,10 +8936,15 @@ ${tmtNode.summary}`
           recallNamespaces,
           retrievalQuery
         );
+        xrayBranchPoolSize.hot_embedding = Math.max(
+          xrayBranchPoolSize.hot_embedding,
+          boostedScoped.length
+        );
         const scoped = this.diversifyAndLimitRecallResults(
           "memories",
           boostedScoped,
-          recallResultLimit
+          recallResultLimit,
+          retrievalQuery
         );
         if (scoped.length > 0) {
           if (shouldPersistGraphSnapshot) {
@@ -7971,7 +8998,8 @@ ${tmtNode.summary}`
                 recallResultLimit,
                 recallMode,
                 queryAwarePrefilter,
-                abortSignal: options.abortSignal
+                abortSignal: options.abortSignal,
+                xrayPoolSizeSink: xrayColdPoolSink
               });
               if (longTerm.length > 0) {
                 recallSource = "cold_fallback";
@@ -8013,10 +9041,15 @@ ${tmtNode.summary}`
                 retrievalQuery,
                 preloadedMap
               )).sort((a, b) => b.score - a.score);
+              xrayBranchPoolSize.recent_scan = Math.max(
+                xrayBranchPoolSize.recent_scan,
+                boostedRecent.length
+              );
               const recent = this.diversifyAndLimitRecallResults(
                 "memories",
                 boostedRecent,
-                recallResultLimit
+                recallResultLimit,
+                retrievalQuery
               );
               if (recent.length > 0) {
                 if (shouldPersistGraphSnapshot) {
@@ -8049,7 +9082,8 @@ ${tmtNode.summary}`
                   recallResultLimit,
                   recallMode,
                   queryAwarePrefilter,
-                  abortSignal: options.abortSignal
+                  abortSignal: options.abortSignal,
+                  xrayPoolSizeSink: xrayColdPoolSink
                 });
                 if (longTerm.length > 0) {
                   if (shouldPersistGraphSnapshot) {
@@ -8085,7 +9119,8 @@ ${tmtNode.summary}`
               recallResultLimit,
               recallMode,
               queryAwarePrefilter,
-              abortSignal: options.abortSignal
+              abortSignal: options.abortSignal,
+              xrayPoolSizeSink: xrayColdPoolSink
             });
             if (longTerm.length > 0) {
               if (shouldPersistGraphSnapshot) {
@@ -8244,7 +9279,10 @@ _Context: ${topQuestion.context}_`
       );
       const timingParts = Object.entries(timings).map(([k, v]) => `${k}=${v}`).join(", ");
       log.info(`recall timings: ${timingParts}`);
-      const assembledRecall = this.assembleRecallSections(sectionBuckets);
+      const assembledRecall = this.assembleRecallSections(
+        sectionBuckets,
+        options.budgetCharsOverride
+      );
       const context = assembledRecall.sections.length === 0 ? "" : assembledRecall.sections.join("\n\n---\n\n");
       const sourcesUsed = this.collectLastRecallSources(
         sectionBuckets,
@@ -8260,6 +9298,73 @@ _Context: ${topQuestion.context}_`
         includedSections: assembledRecall.includedIds,
         omittedSections: assembledRecall.omittedIds
       });
+      if (options.xrayCapture === true && !options.abortSignal?.aborted) {
+        try {
+          const servedBy = mapRecallSourceToXrayServedBy(recallSource);
+          const idFromPath = (p) => {
+            const match = p.match(/([^/]+)\.md$/);
+            return match ? match[1] ?? null : null;
+          };
+          const results = [];
+          for (const recalledPath of recalledMemoryPaths) {
+            const derivedId = idFromPath(recalledPath);
+            if (!derivedId) continue;
+            results.push({
+              memoryId: derivedId,
+              path: recalledPath,
+              servedBy,
+              scoreDecomposition: { final: 0 },
+              admittedBy: []
+            });
+          }
+          let xrayConsidered;
+          switch (recallSource) {
+            case "hot_qmd":
+              xrayConsidered = xrayBranchPoolSize.hot_qmd;
+              break;
+            case "hot_embedding":
+              xrayConsidered = xrayBranchPoolSize.hot_embedding;
+              break;
+            case "cold_fallback":
+              xrayConsidered = xrayColdPoolSink.size;
+              break;
+            case "recent_scan":
+              xrayConsidered = xrayBranchPoolSize.recent_scan;
+              break;
+            case "none":
+              xrayConsidered = recalledMemoryCount;
+              break;
+            default: {
+              const _exhaustive = recallSource;
+              void _exhaustive;
+              xrayConsidered = recalledMemoryCount;
+            }
+          }
+          xrayConsidered = Math.max(xrayConsidered, recalledMemoryIds.length);
+          const filters = [
+            {
+              name: "recall-result-limit",
+              considered: xrayConsidered,
+              admitted: recalledMemoryIds.length
+            }
+          ];
+          this.lastXraySnapshot = buildXraySnapshot({
+            query: retrievalQuery,
+            tierExplain: null,
+            results,
+            filters,
+            budget: {
+              chars: this.getRecallBudgetChars(options.budgetCharsOverride),
+              used: assembledRecall.finalChars
+            },
+            sessionKey,
+            namespace: selfNamespace,
+            traceId
+          });
+        } catch (err) {
+          log.debug(`x-ray capture failed: ${err}`);
+        }
+      }
       if (sessionKey) {
         throwIfRecallAborted(options.abortSignal);
         this.lastRecall.record({
@@ -8595,7 +9700,7 @@ _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;
       });
     }
@@ -8653,12 +9758,38 @@ ${normalized}`).digest("hex");
         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;
@@ -8670,12 +9801,12 @@ ${normalized}`).digest("hex");
         throw new Error(`replay extraction deadline exceeded (${stage})`);
       }
     };
-    const throwIfAborted = (stage) => {
+    const throwIfAborted2 = (stage) => {
       throwIfRecallAborted(options.abortSignal, `extraction aborted (${stage})`);
     };
     const clearBuffer = async (options2) => {
       if (options2?.ignoreAbort !== true) {
-        throwIfAborted("before_clear_buffer");
+        throwIfAborted2("before_clear_buffer");
       }
       if (clearBufferAfterExtraction) {
         await this.buffer.clearAfterExtraction(bufferKey);
@@ -8694,7 +9825,7 @@ ${normalized}`).digest("hex");
       content: t.content.trim().slice(0, this.config.extractionMaxTurnChars)
     })).filter((t) => t.content.length > 0);
     throwIfDeadlineExceeded("before_extract");
-    throwIfAborted("before_extract");
+    throwIfAborted2("before_extract");
     const userTurns = normalizedTurns.filter((t) => t.role === "user");
     const totalChars = normalizedTurns.reduce(
       (sum, t) => sum + t.content.length,
@@ -8710,7 +9841,10 @@ ${normalized}`).digest("hex");
       return;
     }
     const principal = resolvePrincipal(sessionKey, this.config);
-    const selfNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : defaultNamespaceForPrincipal(principal, this.config);
+    const selfNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : this.applyCodingNamespaceOverlay(
+      sessionKey,
+      defaultNamespaceForPrincipal(principal, this.config)
+    );
     const storage = await this.storageRouter.storageFor(selfNamespace);
     const shouldPersistProcessedFingerprint = normalizedTurns.some(
       (turn) => turn.persistProcessedFingerprint === true
@@ -8739,7 +9873,7 @@ ${normalized}`).digest("hex");
       "extraction aborted (during_extract)"
     );
     throwIfDeadlineExceeded("before_persist");
-    throwIfAborted("before_persist");
+    throwIfAborted2("before_persist");
     if (!result) {
       log.warn("runExtraction: extraction returned null/undefined");
       await clearBuffer();
@@ -8803,6 +9937,24 @@ ${normalized}`).digest("hex");
     } catch (error) {
       postPersistMetaError = error;
     }
+    try {
+      if (clearBufferAfterExtraction && !this.config.extractionJudgeShadow) {
+        const deferredCount = this.lastPersistExtractionDeferredCount;
+        if (deferredCount > 0 && normalizedTurns.length > 0) {
+          await this.buffer.retainDeferredTurns(
+            bufferKey,
+            normalizedTurns,
+            10
+          );
+        } else {
+          await this.buffer.retainDeferredTurns(bufferKey, [], 0);
+        }
+      }
+    } catch (err) {
+      log.debug(
+        `extraction-judge: defer retention failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
     await clearBuffer({ ignoreAbort: true });
     if (this.config.memoryBoxesEnabled && persistedIds.length > 0) {
       const extractionTopics = deriveTopicsFromExtraction(result);
@@ -8935,7 +10087,7 @@ ${normalized}`).digest("hex");
     );
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path5.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path7.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -9384,6 +10536,7 @@ ${normalized}`).digest("hex");
     }
     let judgeVerdictsByFactIndex = null;
     let judgeGatedCount = 0;
+    this.lastPersistExtractionDeferredCount = 0;
     if (this.config.extractionJudgeEnabled) {
       try {
         const judgeCandidates = [];
@@ -9418,12 +10571,56 @@ ${normalized}`).digest("hex");
           });
           candidateToFactIndex.push(fi);
         }
+        const judgeTelemetryOpts = {
+          enabled: this.config.extractionJudgeTelemetryEnabled === true,
+          memoryDir: this.config.memoryDir
+        };
+        const judgeTrainingOpts = {
+          enabled: this.config.collectJudgeTrainingPairs === true,
+          ...this.config.judgeTrainingDir ? { directory: this.config.judgeTrainingDir } : {}
+        };
+        const judgeTelemetryHandler = judgeTelemetryOpts.enabled || judgeTrainingOpts.enabled ? (obs) => {
+          const ts = (/* @__PURE__ */ new Date()).toISOString();
+          const verdictKind = getVerdictKind(obs.verdict);
+          if (judgeTelemetryOpts.enabled) {
+            const event = {
+              version: 1,
+              category: EXTRACTION_JUDGE_VERDICT_CATEGORY,
+              ts,
+              verdictKind,
+              reason: obs.verdict.reason,
+              deferrals: obs.priorDeferrals,
+              elapsedMs: obs.elapsedMs,
+              candidateCategory: obs.candidate.category,
+              confidence: obs.candidate.confidence,
+              contentHash: obs.contentHash,
+              fromCache: obs.source === "cache",
+              ...obs.source === "llm-cap-rejected" ? { deferCapTriggered: true } : {}
+            };
+            void recordJudgeVerdict(event, judgeTelemetryOpts);
+          }
+          if (judgeTrainingOpts.enabled) {
+            const pair = {
+              version: 1,
+              ts,
+              candidateText: obs.candidate.text,
+              candidateCategory: obs.candidate.category,
+              ...typeof obs.candidate.confidence === "number" ? { candidateConfidence: obs.candidate.confidence } : {},
+              verdictKind,
+              reason: obs.verdict.reason,
+              priorDeferrals: obs.priorDeferrals
+            };
+            void recordJudgeTrainingPair(pair, judgeTrainingOpts);
+          }
+        } : void 0;
         const judgeResult = await judgeFactDurability(
           judgeCandidates,
           this.config,
           this.localLlm,
           new FallbackLlmClient(this.config.gatewayConfig),
-          this.judgeVerdictCache
+          this.judgeVerdictCache,
+          this.judgeDeferCounts,
+          judgeTelemetryHandler
         );
         judgeVerdictsByFactIndex = /* @__PURE__ */ new Map();
         for (const [candidateIdx, verdict] of judgeResult.verdicts) {
@@ -9433,8 +10630,9 @@ ${normalized}`).digest("hex");
           }
         }
         log.info(
-          `extraction-judge: ${judgeResult.verdicts.size}/${judgeCandidates.length} facts evaluated, ${judgeResult.cached} cached, ${judgeResult.judged} judged, ${judgeResult.elapsed}ms`
+          `extraction-judge: ${judgeResult.verdicts.size}/${judgeCandidates.length} facts evaluated, ${judgeResult.cached} cached, ${judgeResult.judged} judged, ${judgeResult.deferred} deferred` + (judgeResult.deferredCappedToReject > 0 ? ` (${judgeResult.deferredCappedToReject} cap-rejected)` : "") + `, ${judgeResult.elapsed}ms`
         );
+        this.lastPersistExtractionDeferredCount = judgeResult.deferred;
       } catch (err) {
         log.warn(
           `extraction-judge: pipeline error, proceeding without filtering (fail-open): ${err instanceof Error ? err.message : String(err)}`
@@ -9452,16 +10650,6 @@ ${normalized}`).digest("hex");
       }
       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) {
-        const canonicalContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
-        if (this.contentHashIndex.has(canonicalContent)) {
-          log.debug(
-            `dedup: skipping duplicate fact "${fact.content.slice(0, 60)}\u2026"`
-          );
-          dedupedCount++;
-          continue;
-        }
-      }
       let writeCategory = fact.category;
       let targetStorage = storage;
       let routedRuleId;
@@ -9486,6 +10674,15 @@ ${normalized}`).digest("hex");
           );
         }
       }
+      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,
@@ -9510,10 +10707,17 @@ ${normalized}`).digest("hex");
       if (judgeVerdictsByFactIndex) {
         const verdict = judgeVerdictsByFactIndex.get(factLoopIndex);
         if (verdict && !verdict.durable) {
+          const verdictKind = getVerdictKind(verdict);
           if (this.config.extractionJudgeShadow) {
             log.info(
-              `extraction-judge[shadow]: would reject "${fact.content.slice(0, 60)}\u2026" reason="${verdict.reason}"`
+              `extraction-judge[shadow]: would ${verdictKind} "${fact.content.slice(0, 60)}\u2026" reason="${verdict.reason}"`
+            );
+          } else if (verdictKind === "defer") {
+            judgeGatedCount++;
+            log.debug(
+              `extraction-judge: deferred "${fact.content.slice(0, 60)}\u2026" reason="${verdict.reason}"`
             );
+            continue;
           } else {
             judgeGatedCount++;
             log.debug(
@@ -9529,16 +10733,10 @@ ${normalized}`).digest("hex");
           procedureSteps: fact.procedureSteps
         });
         if (!procGate.durable) {
-          if (this.config.extractionJudgeShadow) {
-            log.info(
-              `extraction-procedure-gate[shadow]: would reject "${fact.content.slice(0, 60)}\u2026" reason="${procGate.reason}"`
-            );
-          } else {
-            log.debug(
-              `extraction-procedure-gate: rejected "${fact.content.slice(0, 60)}\u2026" reason="${procGate.reason}"`
-            );
-            continue;
-          }
+          log.debug(
+            `extraction-procedure-gate: rejected "${fact.content.slice(0, 60)}\u2026" reason="${procGate.reason}"`
+          );
+          continue;
         }
       }
       let pendingSemanticSkip = null;
@@ -9935,7 +11133,8 @@ ${normalized}`).digest("hex");
       }
       if (this.contentHashIndex) {
         const canonicalFactContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
-        this.contentHashIndex.add(canonicalFactContent);
+        const hashRegisterKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalFactContent;
+        this.contentHashIndex.add(hashRegisterKey);
       }
     }
     for (const entity of entities) {
@@ -10061,7 +11260,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path5.relative(storage.dir, m.path);
+            const rel = path7.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -10332,14 +11531,14 @@ ${normalized}`).digest("hex");
     }
     if (this.config.semanticConsolidationEnabled) {
       try {
-        const stateFilePath = path5.join(
+        const stateFilePath = path7.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
         );
         let shouldRun = true;
         try {
-          const stateRaw = await readFile3(stateFilePath, "utf-8");
+          const stateRaw = await readFile4(stateFilePath, "utf-8");
           const stateData = JSON.parse(stateRaw);
           if (stateData.lastRunAt) {
             const lastRunMs = new Date(stateData.lastRunAt).getTime();
@@ -10362,9 +11561,9 @@ ${normalized}`).digest("hex");
             allMemories = await this.storage.readAllMemories();
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path5.join(this.config.memoryDir, "state");
-            await mkdir4(stateDir, { recursive: true });
-            await writeFile3(
+            const stateDir = path7.join(this.config.memoryDir, "state");
+            await mkdir5(stateDir, { recursive: true });
+            await writeFile4(
               stateFilePath,
               JSON.stringify({ lastRunAt: (/* @__PURE__ */ new Date()).toISOString() }),
               "utf-8"
@@ -10836,13 +12035,13 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path5.join(
+    const metricsPath = path7.join(
       this.storage.dir,
       "state",
       "lifecycle-metrics.json"
     );
-    await mkdir4(path5.dirname(metricsPath), { recursive: true });
-    await writeFile3(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
+    await mkdir5(path7.dirname(metricsPath), { recursive: true });
+    await writeFile4(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
    * Archive old, low-importance, rarely-accessed facts (v6.0).
@@ -11345,11 +12544,97 @@ ${lines.join("\n\n")}`;
    *
    * Callers must pass the full candidate pool (post-rerank, pre-slice).
    */
-  diversifyAndLimitRecallResults(sectionId, results, limit) {
+  async applyMemoryWorthRerank(results, namespaces) {
+    const counters = /* @__PURE__ */ new Map();
+    const seenNamespaces = /* @__PURE__ */ new Set();
+    const nowMs = Date.now();
+    for (const [key, entry] of this.memoryWorthCounterCache) {
+      if (nowMs - entry.at >= _Orchestrator.MEMORY_WORTH_CACHE_TTL_MS) {
+        this.memoryWorthCounterCache.delete(key);
+      }
+    }
+    for (const ns of namespaces) {
+      if (seenNamespaces.has(ns)) continue;
+      seenNamespaces.add(ns);
+      try {
+        const cached = this.memoryWorthCounterCache.get(ns);
+        let nsMap;
+        if (cached && nowMs - cached.at < _Orchestrator.MEMORY_WORTH_CACHE_TTL_MS) {
+          nsMap = cached.counters;
+        } else {
+          const storage = await this.getStorage(ns);
+          const memories = await storage.readAllMemories();
+          nsMap = buildMemoryWorthCounterMap(memories);
+          this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
+        }
+        for (const [path8, c] of nsMap) counters.set(path8, c);
+      } catch (err) {
+        log.debug("memory-worth: failed to read namespace, skipping", {
+          namespace: ns,
+          error: err.message
+        });
+      }
+    }
+    const missing = results.filter((r) => !counters.has(r.path));
+    if (missing.length > 0) {
+      let reader = null;
+      for (const ns of namespaces) {
+        try {
+          reader = await this.getStorage(ns);
+          break;
+        } catch {
+        }
+      }
+      if (reader) {
+        for (const r of missing) {
+          try {
+            const memory = await reader.readMemoryByPath(r.path);
+            if (!memory) continue;
+            const fm = memory.frontmatter;
+            if (fm.mw_success === void 0 && fm.mw_fail === void 0) continue;
+            counters.set(r.path, {
+              mw_success: fm.mw_success,
+              mw_fail: fm.mw_fail,
+              lastAccessed: fm.lastAccessed
+            });
+          } catch (err) {
+            log.debug("memory-worth: direct path lookup failed", {
+              path: r.path,
+              error: err.message
+            });
+          }
+        }
+      }
+    }
+    if (counters.size === 0) return results;
+    const rankedInputs = results.map((r, i) => ({
+      path: r.path,
+      // Large positive rank score so multiplier math stays well-scaled and
+      // we never hit zero; descending so earlier items rank higher.
+      score: results.length - i
+    }));
+    const filtered = applyMemoryWorthFilter(rankedInputs, {
+      counters,
+      now: /* @__PURE__ */ new Date(),
+      halfLifeMs: this.config.recallMemoryWorthHalfLifeMs > 0 ? this.config.recallMemoryWorthHalfLifeMs : void 0
+    });
+    const byPath = new Map(results.map((r) => [r.path, r]));
+    const reordered = [];
+    for (const item of filtered) {
+      const original = byPath.get(item.path);
+      if (original) reordered.push(original);
+    }
+    return reordered;
+  }
+  diversifyAndLimitRecallResults(sectionId, results, limit, retrievalQuery) {
     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);
+    const boosted = this.config.recallReasoningTraceBoostEnabled && typeof retrievalQuery === "string" ? applyReasoningTraceBoost(results, {
+      enabled: true,
+      query: retrievalQuery
+    }) : results;
+    const diversified = this.applyMmrToQmdResults(sectionId, boosted);
     return diversified.slice(0, safeLimit);
   }
   /**
@@ -11453,12 +12738,12 @@ ${lines.join("\n\n")}`;
    */
   semanticDedupScopeFor(targetStorage) {
     if (!this.config.namespacesEnabled) return {};
-    const memoryDir = path5.resolve(this.config.memoryDir);
-    const storageDir = path5.resolve(targetStorage.dir);
+    const memoryDir = path7.resolve(this.config.memoryDir);
+    const storageDir = path7.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path5.relative(memoryDir, storageDir);
+    let rel = path7.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`
@@ -11477,7 +12762,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path5.isAbsolute(hit.path) ? hit.path : path5.join(this.config.memoryDir, hit.path);
+      const fullPath = path7.isAbsolute(hit.path) ? hit.path : path7.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -11654,10 +12939,26 @@ ${lines.join("\n\n")}`;
         "rerankProvider=cloud is reserved/experimental in v2.2.0; skipping rerank"
       );
     }
+    if (this.config.recallMemoryWorthFilterEnabled && results.length > 0) {
+      try {
+        results = await this.applyMemoryWorthRerank(results, options.recallNamespaces);
+      } catch (err) {
+        log.debug("memory-worth filter (cold) failed open", {
+          error: err.message
+        });
+      }
+    }
+    if (options.xrayPoolSizeSink) {
+      options.xrayPoolSizeSink.size = Math.max(
+        options.xrayPoolSizeSink.size,
+        results.length
+      );
+    }
     return this.diversifyAndLimitRecallResults(
       "memories",
       results,
-      options.recallResultLimit
+      options.recallResultLimit,
+      options.prompt
     );
   }
   // ---------------------------------------------------------------------------
@@ -12051,8 +13352,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path5.resolve(storageDir);
-    const resolvedMemoryDir = path5.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path7.resolve(storageDir);
+    const resolvedMemoryDir = path7.resolve(this.config.memoryDir);
     if (resolvedStorageDir === resolvedMemoryDir)
       return this.config.defaultNamespace;
     const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
@@ -12085,6 +13386,21 @@ export {
   migrateFromEngram,
   buildProcedureRecallSection,
   decideSemanticDedup,
+  DEFAULT_TAXONOMY,
+  generateResolverDocument,
+  validateSlug,
+  validateTaxonomy,
+  loadTaxonomy,
+  saveTaxonomy,
+  getTaxonomyDir,
+  getTaxonomyFilePath,
+  stableHash,
+  normalizeOriginUrl,
+  resolveGitContext,
+  projectNamespaceName,
+  branchNamespaceName,
+  resolveCodingNamespaceOverlay,
+  describeCodingScope,
   dedupeEntitySynthesisEvidenceEntries,
   defaultWorkspaceDir,
   sanitizeSessionKeyForFilename,
@@ -12113,4 +13429,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-XMGSSBFX.js.map
+//# sourceMappingURL=chunk-VYM3VWOF.js.map