@remnic/core 1.1.0 → 1.1.2

package/dist/{chunk-DEPL3635.js → chunk-3YGHKTBF.js}

@@ -2,7 +2,7 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-DHHP2Z4X.js";
+} from "./chunk-XXVWLXSG.js";
 import {
   extractTopics
 } from "./chunk-UHGBNIOS.js";
@@ -11,9 +11,6 @@ import {
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-FSFEQI74.js";
-import {
-  HourlySummarizer
-} from "./chunk-N42IWANG.js";
 import {
   applyTemporalSupersession,
   normalizeSupersessionKey,
@@ -32,11 +29,8 @@ import {
   SessionObserverState
 } from "./chunk-JR4ZC3G4.js";
 import {
-  semanticChunkContent
-} from "./chunk-KVE7R4CG.js";
-import {
-  findUnresolvedEntityRefs
-} from "./chunk-X7XN6YU4.js";
+  HourlySummarizer
+} from "./chunk-DG6YMRDC.js";
 import {
   RelevanceStore
 } from "./chunk-5NPGSAVB.js";
@@ -66,10 +60,19 @@ import {
   applyRuntimeRetrievalPolicy
 } from "./chunk-5IZL4DCV.js";
 import {
-  buildQmdRecallCacheKey,
-  getCachedQmdRecall,
-  setCachedQmdRecall
-} from "./chunk-YCN4BVDK.js";
+  LastRecallStore,
+  TierMigrationStatusStore,
+  clampGraphRecallExpandedEntries
+} from "./chunk-VBVG2M5G.js";
+import {
+  buildXraySnapshot
+} from "./chunk-KVBLZUKV.js";
+import {
+  findUnresolvedEntityRefs
+} from "./chunk-X7XN6YU4.js";
+import {
+  applyReasoningTraceBoost
+} from "./chunk-ZZTOURJI.js";
 import {
   reorderRecallResultsWithMmr
 } from "./chunk-YDBIWGNI.js";
@@ -77,10 +80,10 @@ import {
   createRecallSectionMetricRecorder
 } from "./chunk-7DHTMOND.js";
 import {
-  LastRecallStore,
-  TierMigrationStatusStore,
-  clampGraphRecallExpandedEntries
-} from "./chunk-47UU5PU2.js";
+  buildQmdRecallCacheKey,
+  getCachedQmdRecall,
+  setCachedQmdRecall
+} from "./chunk-YCN4BVDK.js";
 import {
   NegativeExampleStore
 } from "./chunk-D654IBA6.js";
@@ -88,8 +91,9 @@ import {
   evaluateMemoryActionPolicy
 } from "./chunk-H63EDPFJ.js";
 import {
-  classifyMemoryKind
-} from "./chunk-YAZNBMNF.js";
+  applyMemoryWorthFilter,
+  buildMemoryWorthCounterMap
+} from "./chunk-3GPTTA4J.js";
 import {
   hasBroadGraphIntent,
   inferIntentFromText,
@@ -98,16 +102,28 @@ import {
   planRecallMode
 } from "./chunk-GGD5W7TB.js";
 import {
+  classifyMemoryKind
+} from "./chunk-YAZNBMNF.js";
+import {
+  EXTRACTION_JUDGE_VERDICT_CATEGORY,
+  recordJudgeVerdict
+} from "./chunk-AJU4PJGY.js";
+import {
+  recordJudgeTrainingPair
+} from "./chunk-DF3RVK3X.js";
+import {
+  createDeferCountMap,
   createVerdictCache,
+  getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-LAYN4LDC.js";
+} from "./chunk-C4SQJZAF.js";
 import {
   ExtractionEngine
-} from "./chunk-3SV6CQHO.js";
+} from "./chunk-DIXB44VE.js";
 import {
   parseMemoryActionEligibilityContext
-} from "./chunk-UEYA6UC7.js";
+} from "./chunk-NZLQTHS5.js";
 import {
   ProfilingCollector
 } from "./chunk-NBNN5GOB.js";
@@ -116,31 +132,35 @@ import {
 } from "./chunk-FEMOX5AD.js";
 import {
   LocalLlmClient
-} from "./chunk-JL2PU6AI.js";
+} from "./chunk-R2XRID2N.js";
 import {
-  formatDaySummaryMemories
-} from "./chunk-GZCUW5IC.js";
+  tryDirectAnswer
+} from "./chunk-6AUUAZEX.js";
 import {
   EmbeddingFallback
-} from "./chunk-ALXMCZEU.js";
+} from "./chunk-Z2E7VW55.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-7WQ6SLIE.js";
+} from "./chunk-FVA6TGI3.js";
+import {
+  formatDaySummaryMemories
+} from "./chunk-GZCUW5IC.js";
 import {
   RoutingRulesStore,
+  expandTildePath,
   normalizeReplaySessionKey
-} from "./chunk-PAORGQRI.js";
+} from "./chunk-GA5P7RST.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-6UJ47TVX.js";
+} from "./chunk-CUPFXL3J.js";
 import {
   ThreadingManager
 } from "./chunk-JRNQ3RNA.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-JIU55F3X.js";
+} from "./chunk-SPI27QT6.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-CULXMQJH.js";
@@ -154,10 +174,10 @@ import {
   createConversationIndexRuntime,
   createSearchBackend,
   writeConversationChunks
-} from "./chunk-ZVBB3T7V.js";
+} from "./chunk-NBVAS5MT.js";
 import {
   parseQmdExplain
-} from "./chunk-BLKTA7MM.js";
+} from "./chunk-4HQS2HPX.js";
 import {
   PolicyRuntimeManager
 } from "./chunk-EABGC2TL.js";
@@ -170,7 +190,10 @@ import {
 import {
   isAboveImportanceThreshold,
   scoreImportance
-} from "./chunk-J4IYOZZ5.js";
+} from "./chunk-JXS5PDQ7.js";
+import {
+  launchProcessSync
+} from "./chunk-OR64ZGRZ.js";
 import {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,
@@ -179,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";
@@ -191,22 +217,28 @@ import {
   refineCompressionGuidelineCandidateSemantically,
   renderCompressionGuidelinesMarkdown
 } from "./chunk-2NMMFZ5T.js";
+import {
+  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-SYUK3VLY.js";
+  parseConsolidationResponse,
+  parseOperatorAwareConsolidationResponse
+} from "./chunk-PVICZTKG.js";
 import {
   FallbackLlmClient
-} from "./chunk-44ICJRF3.js";
-import {
-  GraphIndex
-} from "./chunk-C2EFFULQ.js";
-import {
-  chunkContent
-} from "./chunk-4WMCPJWX.js";
+} from "./chunk-AYXIPSZO.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-6HZ6AO2P.js";
@@ -217,38 +249,33 @@ 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 {
+  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,
@@ -267,10 +294,10 @@ import {
   normalizeAttributePairs,
   normalizeEntityName,
   parseEntityFile
-} from "./chunk-GV6NLQ4X.js";
+} from "./chunk-F5VP6YCB.js";
 import {
   confidenceTier
-} from "./chunk-3WHVNEN7.js";
+} from "./chunk-LTCGGW2D.js";
 import {
   attachCitation,
   hasCitationForTemplate,
@@ -286,26 +313,28 @@ import {
 import {
   sanitizeMemoryContent
 } from "./chunk-M62O4P4T.js";
+import {
+  resolveHomeDir
+} from "./chunk-MARWOCVP.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.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
-import { execFileSync } from "child_process";
 import { createHash } from "crypto";
 import path from "path";
 import {
@@ -341,7 +370,14 @@ function resolveLogger(options) {
 }
 function resolveExec(options) {
   return options?.execCommand ?? ((command, args) => {
-    execFileSync(command, args, { stdio: "ignore" });
+    const result = launchProcessSync(command, args, { stdio: "ignore" });
+    if (result.error) {
+      throw result.error;
+    }
+    if (result.status !== 0) {
+      const reason = result.status === null ? `signal ${result.signal ?? "unknown"}` : `exit code ${result.status}`;
+      throw new Error(`migration command failed: ${command} ${args.join(" ")} (${reason})`);
+    }
   });
 }
 function remnicRoot(homeDir) {
@@ -878,7 +914,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();
@@ -1119,12 +1155,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");
@@ -1133,7 +1410,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();
@@ -2397,7 +2674,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;
@@ -2405,7 +2682,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;
@@ -2413,7 +2690,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 {
@@ -2429,6 +2706,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 = [];
@@ -2493,6 +3028,20 @@ function fingerprintEntitySynthesisEvidence(entity) {
   fingerprint.update(fingerprintEntityStructuredFacts(entity) ?? "");
   return fingerprint.digest("hex");
 }
+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") {
   throwIfAborted(signal, message);
@@ -2515,7 +3064,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, "_");
@@ -2683,11 +3232,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;
@@ -2829,7 +3378,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;
 }
@@ -2837,7 +3386,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,
@@ -2857,15 +3406,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;
@@ -2884,12 +3434,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;
@@ -2905,6 +3482,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
@@ -2912,6 +3499,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();
@@ -2945,6 +3540,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;
@@ -2983,6 +3582,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);
@@ -2995,10 +3597,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;
@@ -3083,7 +3771,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);
@@ -3110,7 +3798,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"
@@ -3134,6 +3822,7 @@ 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 ? (() => {
@@ -3149,7 +3838,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})` : "")
@@ -3163,7 +3852,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, {
@@ -3349,9 +4038,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 }
       );
@@ -3366,7 +4055,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 ?? {})
       };
@@ -3408,7 +4097,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(
@@ -3437,7 +4126,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(() => {
@@ -3466,6 +4155,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)"
@@ -3526,10 +4216,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;
@@ -3546,7 +4237,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}`);
@@ -3686,6 +4377,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;
@@ -3700,9 +4392,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");
@@ -3746,7 +4441,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(
@@ -3769,8 +4464,8 @@ var Orchestrator = class _Orchestrator {
     }
   }
   async autoRegisterNightlyGovernanceCron() {
-    const home = process.env.HOME || os.homedir();
-    const jobsPath = path5.join(home, ".openclaw", "cron", "jobs.json");
+    const home = resolveHomeDir();
+    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");
@@ -3792,7 +4487,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");
@@ -3812,7 +4507,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterContradictionScanCron() {
     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("contradiction scan cron: jobs.json not found, skipping auto-register");
@@ -3848,15 +4543,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,
@@ -3864,7 +4559,7 @@ var Orchestrator = class _Orchestrator {
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile3(abs, newContent, "utf-8");
+            await writeFile4(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -3881,8 +4576,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 = `
 
@@ -3891,11 +4586,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");
       }
     }
   }
@@ -3979,14 +4674,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 }
         ];
@@ -4012,13 +4708,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,
@@ -4031,7 +4745,9 @@ var Orchestrator = class _Orchestrator {
               )
             ],
             source: "semantic-consolidation",
-            lineage: lineageIds
+            lineage: lineageIds,
+            derivedFrom: derivedFromEntries.length > 0 ? derivedFromEntries : void 0,
+            derivedVia: operator
           }
         );
         result.memoriesConsolidated++;
@@ -4273,18 +4989,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];
@@ -4298,7 +5014,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",
@@ -4319,15 +5035,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());
             }
@@ -4423,13 +5139,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 {
@@ -4462,9 +5178,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;
@@ -4495,13 +5211,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 {
@@ -4647,7 +5363,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;
@@ -4918,11 +5634,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();
@@ -4931,6 +5660,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);
@@ -5334,7 +6240,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(
@@ -5344,7 +6250,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;
@@ -5368,7 +6274,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
@@ -5384,12 +6290,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;
@@ -5416,20 +6322,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"
@@ -5440,13 +6346,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"
@@ -5460,9 +6366,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"
@@ -5473,12 +6379,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
@@ -5486,11 +6392,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) => ({
@@ -5576,7 +6482,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);
@@ -5587,7 +6496,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);
@@ -5603,7 +6512,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: [],
@@ -5735,6 +6644,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;
@@ -5795,7 +6711,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,
@@ -5806,8 +6722,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;
@@ -5824,7 +6756,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))
@@ -5862,6 +6794,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,
@@ -7011,16 +7969,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`
@@ -7040,7 +7998,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 {
@@ -7747,7 +8705,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) {
@@ -7761,7 +8730,8 @@ ${tmtNode.summary}`
         memoryResults = this.diversifyAndLimitRecallResults(
           "memories",
           memoryResults,
-          recallResultLimit
+          recallResultLimit,
+          retrievalQuery
         );
         if (this.config.memoryReconstructionEnabled && memoryResults.length > 0) {
           try {
@@ -7846,10 +8816,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) {
@@ -7882,7 +8857,8 @@ ${tmtNode.summary}`
               recallResultLimit,
               recallMode,
               queryAwarePrefilter,
-              abortSignal: options.abortSignal
+              abortSignal: options.abortSignal,
+              xrayPoolSizeSink: xrayColdPoolSink
             });
             if (longTerm.length > 0) {
               if (shouldPersistGraphSnapshot) {
@@ -7966,10 +8942,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) {
@@ -8023,7 +9004,8 @@ ${tmtNode.summary}`
                 recallResultLimit,
                 recallMode,
                 queryAwarePrefilter,
-                abortSignal: options.abortSignal
+                abortSignal: options.abortSignal,
+                xrayPoolSizeSink: xrayColdPoolSink
               });
               if (longTerm.length > 0) {
                 recallSource = "cold_fallback";
@@ -8065,10 +9047,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) {
@@ -8101,7 +9088,8 @@ ${tmtNode.summary}`
                   recallResultLimit,
                   recallMode,
                   queryAwarePrefilter,
-                  abortSignal: options.abortSignal
+                  abortSignal: options.abortSignal,
+                  xrayPoolSizeSink: xrayColdPoolSink
                 });
                 if (longTerm.length > 0) {
                   if (shouldPersistGraphSnapshot) {
@@ -8137,7 +9125,8 @@ ${tmtNode.summary}`
               recallResultLimit,
               recallMode,
               queryAwarePrefilter,
-              abortSignal: options.abortSignal
+              abortSignal: options.abortSignal,
+              xrayPoolSizeSink: xrayColdPoolSink
             });
             if (longTerm.length > 0) {
               if (shouldPersistGraphSnapshot) {
@@ -8296,7 +9285,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,
@@ -8312,6 +9304,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({
@@ -8788,7 +9847,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
@@ -8881,6 +9943,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);
@@ -9013,7 +10093,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()
@@ -9462,6 +10542,7 @@ ${normalized}`).digest("hex");
     }
     let judgeVerdictsByFactIndex = null;
     let judgeGatedCount = 0;
+    this.lastPersistExtractionDeferredCount = 0;
     if (this.config.extractionJudgeEnabled) {
       try {
         const judgeCandidates = [];
@@ -9496,12 +10577,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) {
@@ -9511,8 +10636,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)}`
@@ -9587,10 +10713,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(
@@ -10133,7 +11266,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);
           }
         }
@@ -10404,14 +11537,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();
@@ -10434,9 +11567,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"
@@ -10908,13 +12041,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).
@@ -11417,11 +12550,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);
   }
   /**
@@ -11525,12 +12744,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`
@@ -11549,7 +12768,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({
@@ -11726,10 +12945,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
     );
   }
   // ---------------------------------------------------------------------------
@@ -12123,8 +13358,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[\\/]([^\\/]+)$/);
@@ -12157,6 +13392,21 @@ export {
   migrateFromEngram,
   buildProcedureRecallSection,
   decideSemanticDedup,
+  DEFAULT_TAXONOMY,
+  generateResolverDocument,
+  validateSlug,
+  validateTaxonomy,
+  loadTaxonomy,
+  saveTaxonomy,
+  getTaxonomyDir,
+  getTaxonomyFilePath,
+  stableHash,
+  normalizeOriginUrl,
+  resolveGitContext,
+  projectNamespaceName,
+  branchNamespaceName,
+  resolveCodingNamespaceOverlay,
+  describeCodingScope,
   dedupeEntitySynthesisEvidenceEntries,
   defaultWorkspaceDir,
   sanitizeSessionKeyForFilename,
@@ -12185,4 +13435,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-DEPL3635.js.map
+//# sourceMappingURL=chunk-3YGHKTBF.js.map