@remnic/core 9.3.719 → 9.3.721

package/dist/{chunk-NFRBADNR.js → chunk-LA3HZKES.js}

@@ -4,16 +4,16 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-DGTDRIUO.js";
+} from "./chunk-4T3BMHKD.js";
 import {
   MaintenanceScheduler
-} from "./chunk-APUJIMDM.js";
+} from "./chunk-Z4RU5VPM.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-773DPI6T.js";
+} from "./chunk-PKMQK2WY.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -23,7 +23,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-A66YRSOS.js";
+} from "./chunk-WQYSDPMA.js";
 import {
   SharedContextManager
 } from "./chunk-UFS7OXGL.js";
@@ -32,6 +32,12 @@ import {
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-LXOM6IQU.js";
+import {
+  TierMigrationExecutor
+} from "./chunk-VOUOLGIP.js";
+import {
+  decideTierTransition
+} from "./chunk-S75M5ZRK.js";
 import {
   TmtBuilder
 } from "./chunk-ECZU5BJH.js";
@@ -39,38 +45,26 @@ import {
   extractTopics
 } from "./chunk-UHGBNIOS.js";
 import {
-  CODEX_THREAD_KEY_PREFIX
-} from "./chunk-4EX5WZ4M.js";
+  applyTrustScoreStage,
+  buildTrustSignalsForRerank,
+  projectTrustForXray
+} from "./chunk-BCDKBDSY.js";
 import {
-  TierMigrationExecutor
-} from "./chunk-VOUOLGIP.js";
-import {
-  decideTierTransition
-} from "./chunk-S75M5ZRK.js";
-import {
-  HourlySummarizer
-} from "./chunk-IO5NQEGZ.js";
+  renderEpistemicHedge
+} from "./chunk-YN2UN7N3.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
 } from "./chunk-4SBW47WK.js";
 import {
-  SessionObserverState
-} from "./chunk-DKTSR7EK.js";
-import {
-  applyRuntimeRetrievalPolicy
-} from "./chunk-5IZL4DCV.js";
-import {
-  RelevanceStore
-} from "./chunk-GG6AJN7A.js";
+  CODEX_THREAD_KEY_PREFIX
+} from "./chunk-4EX5WZ4M.js";
 import {
-  RerankCache,
-  rerankLocalOrNoop
-} from "./chunk-E3VODCC3.js";
+  HourlySummarizer
+} from "./chunk-DKT3X5C3.js";
 import {
-  buildResponseGuidanceRecallSection,
-  shouldRecallResponseGuidance
-} from "./chunk-L6W77GWW.js";
+  SessionObserverState
+} from "./chunk-DKTSR7EK.js";
 import {
   mergeWithAgentResults,
   runDirectAgent,
@@ -89,27 +83,44 @@ import {
   recencyWindowFromPrompt,
   resolvePromptTagPrefilterAsync
 } from "./chunk-MGN7VHWQ.js";
+import {
+  applyRuntimeRetrievalPolicy
+} from "./chunk-5IZL4DCV.js";
+import {
+  findUnresolvedEntityRefs
+} from "./chunk-X7XN6YU4.js";
+import {
+  RelevanceStore
+} from "./chunk-GG6AJN7A.js";
+import {
+  RerankCache,
+  rerankLocalOrNoop
+} from "./chunk-E3VODCC3.js";
+import {
+  buildResponseGuidanceRecallSection,
+  shouldRecallResponseGuidance
+} from "./chunk-L6W77GWW.js";
+import {
+  createRecallSectionMetricRecorder
+} from "./chunk-VQ34TERH.js";
 import {
   LastRecallStore,
   RecallHandleHistoryStore,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries
 } from "./chunk-UC4YOAC2.js";
-import {
-  findUnresolvedEntityRefs
-} from "./chunk-X7XN6YU4.js";
 import {
   reorderRecallResultsWithMmr
 } from "./chunk-YDBIWGNI.js";
-import {
-  createRecallSectionMetricRecorder
-} from "./chunk-VQ34TERH.js";
 import {
   applyReasoningTraceBoost
 } from "./chunk-ZZTOURJI.js";
 import {
   NegativeExampleStore
 } from "./chunk-EXM3CQTZ.js";
+import {
+  evaluateMemoryActionPolicy
+} from "./chunk-H63EDPFJ.js";
 import {
   applyMemoryWorthFilter,
   buildMemoryWorthCounterMap
@@ -117,9 +128,6 @@ import {
 import {
   runLiveConnectorsOnce
 } from "./chunk-VU3SVYMA.js";
-import {
-  evaluateMemoryActionPolicy
-} from "./chunk-H63EDPFJ.js";
 import {
   hasBroadGraphIntent,
   inferIntentFromText,
@@ -136,10 +144,10 @@ import {
   getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-TH7WMHVK.js";
+} from "./chunk-3NN73CM7.js";
 import {
   ExtractionEngine
-} from "./chunk-2SXMCQEQ.js";
+} from "./chunk-GZQXOQQ2.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-5GSUBCZM.js";
@@ -176,7 +184,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-EH27LHML.js";
+} from "./chunk-5O42UKXI.js";
 import {
   formatDaySummaryMemories
 } from "./chunk-EO5QWINU.js";
@@ -189,34 +197,34 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-S35FX6MU.js";
+} from "./chunk-EBDA5TYA.js";
 import {
   ThreadingManager
 } from "./chunk-QRDOSYOR.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-OZ2KQ7HF.js";
+} from "./chunk-YEE5KJQQ.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
 import {
   TranscriptManager
 } from "./chunk-GY3SKOS4.js";
+import {
+  PolicyRuntimeManager
+} from "./chunk-33JBK2XP.js";
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-REWQAFSA.js";
+} from "./chunk-PD42EYQN.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-HLIR3RJ7.js";
+} from "./chunk-EXUCUPV2.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-DIFU33GU.js";
-import {
-  PolicyRuntimeManager
-} from "./chunk-33JBK2XP.js";
+} from "./chunk-OHTOPFRF.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -245,10 +253,6 @@ import {
   refineCompressionGuidelineCandidateSemantically,
   renderCompressionGuidelinesMarkdown
 } from "./chunk-OD4FM2U7.js";
-import {
-  resolveCapabilities,
-  resolveGraphConstructionCapabilities
-} from "./chunk-PBH4JUAB.js";
 import {
   buildConsolidationPrompt,
   buildExtensionsBlockForConsolidation,
@@ -258,7 +262,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-2VHMVWPU.js";
+} from "./chunk-NXRUUDUF.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -299,7 +303,7 @@ import {
   clusterByKey,
   createCorrectionService,
   detectPassiveCorrections
-} from "./chunk-OJU73BUX.js";
+} from "./chunk-VCLGUIFM.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -309,25 +313,25 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
-} from "./chunk-L5ASZA2F.js";
-import {
-  combineNamespaces,
-  getConfiguredNamespaces,
-  resolveCodingNamespaceOverlay,
-  resolveNamespaceFromStorageDir,
-  resolveScopePlan,
-  resolveScopeProfilePlan
-} from "./chunk-J6BH2OBA.js";
+} from "./chunk-GJSL4WG2.js";
 import {
   NamespaceSearchRouter
-} from "./chunk-CTOQEZSN.js";
+} from "./chunk-QR67FU5G.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-2KAYTPPT.js";
+} from "./chunk-HCVWF657.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
+import {
+  combineNamespaces,
+  getConfiguredNamespaces,
+  resolveCodingNamespaceOverlay,
+  resolveNamespaceFromStorageDir,
+  resolveScopePlan,
+  resolveScopeProfilePlan
+} from "./chunk-J6BH2OBA.js";
 import {
   namespaceIdentityFromToken,
   namespaceIdentityToken,
@@ -352,19 +356,23 @@ import {
 import {
   shouldSkipImplicitExtraction
 } from "./chunk-EH5ED3C6.js";
+import {
+  resolveCapabilities,
+  resolveGraphConstructionCapabilities
+} from "./chunk-DVRHLN2O.js";
 import {
   searchCausalTrajectories
-} from "./chunk-YI7RZO7Y.js";
+} from "./chunk-SQNED75R.js";
 import {
   GraphIndex
-} from "./chunk-YGKUAX2B.js";
+} from "./chunk-EHQ5HO5T.js";
 import {
   decideLifecycleTransition,
   resolveLifecycleState
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-2COL35PK.js";
+} from "./chunk-UO5ZHIIH.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -372,10 +380,10 @@ import {
   fingerprintEntityStructuredFacts,
   normalizeAttributePairs,
   parseEntityFile
-} from "./chunk-YYOK4GVF.js";
+} from "./chunk-EVPNWN7Z.js";
 import {
   buildRetiredFactTombstoneInputs
-} from "./chunk-3JJWNZTT.js";
+} from "./chunk-L2B3EE7B.js";
 import {
   isValidTranscriptDate,
   loadSpeakerRegistry,
@@ -406,16 +414,16 @@ import {
 } from "./chunk-SVOZFLIQ.js";
 import {
   confidenceTier
-} from "./chunk-N3DUH6OO.js";
-import {
-  inferMemoryStatus,
-  isActiveMemoryStatus
-} from "./chunk-RULE4VG5.js";
+} from "./chunk-ILFSEIRT.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
   setCachedQmdRecall
 } from "./chunk-42JKGUFJ.js";
+import {
+  inferMemoryStatus,
+  isActiveMemoryStatus
+} from "./chunk-RULE4VG5.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -424,12 +432,12 @@ import {
   applyFaithfulnessVerdict,
   createFaithfulnessCounters,
   runFaithfulnessGateBatch
-} from "./chunk-FEB7W5JG.js";
+} from "./chunk-6OIDDKAA.js";
 import {
   FallbackLlmClient,
   fallbackLlmRuntimeContextFromConfig,
   gatewayTaskChainOptions
-} from "./chunk-5J4OL7TJ.js";
+} from "./chunk-VUA4S7P6.js";
 import {
   keyring_exports,
   secureStoreDir
@@ -478,7 +486,7 @@ import {
 } from "./chunk-PVGDJXVK.js";
 
 // src/orchestrator.ts
-import path2 from "path";
+import path3 from "path";
 import os from "os";
 import { createHash, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
@@ -546,6 +554,192 @@ ${preview}${suffix}`;
 ${blocks.join("\n\n")}`;
 }
 
+// src/orchestration/tier-migration-coordinator.ts
+import path from "path";
+var TierMigrationCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  inFlight = false;
+  lastRunAtMs = 0;
+  /** Whether a migration cycle is currently executing (diagnostics). */
+  isInFlight() {
+    return this.inFlight;
+  }
+  /** Latest status snapshot (delegates to the status store). */
+  getStatus() {
+    return this.deps.tierMigrationStatus.get();
+  }
+  /**
+   * Run one tier-migration cycle. Behavior-preserving move of the
+   * orchestrator's former `runTierMigrationCycle`.
+   */
+  async runCycle(storage, trigger, options) {
+    const { config, tierMigrationStatus } = this.deps;
+    const dryRun = options?.dryRun === true;
+    const persistSkipped = options?.force === true || trigger === "manual";
+    if (!config.qmdTierMigrationEnabled && options?.force !== true) {
+      const skipped = {
+        trigger,
+        scanned: 0,
+        migrated: 0,
+        promoted: 0,
+        demoted: 0,
+        limit: 0,
+        dryRun,
+        skipped: "tier_migration_disabled"
+      };
+      if (persistSkipped) await tierMigrationStatus.recordCycle(skipped);
+      return skipped;
+    }
+    if (trigger === "maintenance" && !config.qmdTierAutoBackfillEnabled && options?.force !== true) {
+      const skipped = {
+        trigger,
+        scanned: 0,
+        migrated: 0,
+        promoted: 0,
+        demoted: 0,
+        limit: 0,
+        dryRun,
+        skipped: "maintenance_backfill_disabled"
+      };
+      if (persistSkipped) await tierMigrationStatus.recordCycle(skipped);
+      return skipped;
+    }
+    if (this.inFlight) {
+      const skipped = {
+        trigger,
+        scanned: 0,
+        migrated: 0,
+        promoted: 0,
+        demoted: 0,
+        limit: 0,
+        dryRun,
+        skipped: "migration_in_flight"
+      };
+      if (persistSkipped) await tierMigrationStatus.recordCycle(skipped);
+      return skipped;
+    }
+    const budgetTrigger = trigger === "manual" ? "maintenance" : trigger;
+    const budget = this.deps.getCompounding()?.tierMigrationCycleBudget(budgetTrigger) ?? defaultTierMigrationCycleBudget(config, budgetTrigger);
+    const limit = options?.limitOverride !== void 0 ? Math.max(0, Math.floor(options.limitOverride)) : budget.limit;
+    const nowMs = Date.now();
+    if (options?.force !== true && nowMs - this.lastRunAtMs < budget.minIntervalMs) {
+      const skipped = {
+        trigger,
+        scanned: 0,
+        migrated: 0,
+        promoted: 0,
+        demoted: 0,
+        limit,
+        dryRun,
+        skipped: "min_interval"
+      };
+      if (persistSkipped) await tierMigrationStatus.recordCycle(skipped);
+      return skipped;
+    }
+    const policy = applyUtilityPromotionRuntimePolicy(
+      {
+        enabled: config.qmdTierMigrationEnabled,
+        demotionMinAgeDays: config.qmdTierDemotionMinAgeDays,
+        demotionValueThreshold: config.qmdTierDemotionValueThreshold,
+        promotionValueThreshold: config.qmdTierPromotionValueThreshold
+      },
+      this.deps.getUtilityRuntimeValues()
+    );
+    this.inFlight = true;
+    try {
+      const coldStorage = this.deps.createColdStorage(
+        path.join(storage.dir, "cold")
+      );
+      const [hotMemories, coldMemories] = await Promise.all([
+        storage.readAllMemories(),
+        coldStorage.readAllMemories()
+      ]);
+      const now = /* @__PURE__ */ new Date();
+      const scanLimit = Math.max(0, Math.floor(budget.scanLimit));
+      const hotScanLimit = Math.min(
+        hotMemories.length,
+        Math.ceil(scanLimit * 0.75)
+      );
+      const coldScanLimit = Math.min(
+        coldMemories.length,
+        Math.max(0, scanLimit - hotScanLimit)
+      );
+      const toTimestamp = (memory) => Date.parse(memory.frontmatter.updated ?? memory.frontmatter.created);
+      const hotCandidates = hotMemories.map((memory) => ({ memory, tier: "hot" })).sort((a, b) => toTimestamp(a.memory) - toTimestamp(b.memory)).slice(0, hotScanLimit);
+      const coldCandidates = coldMemories.map((memory) => ({ memory, tier: "cold" })).sort((a, b) => toTimestamp(b.memory) - toTimestamp(a.memory)).slice(0, coldScanLimit);
+      const candidates = [...hotCandidates, ...coldCandidates];
+      const migration = new TierMigrationExecutor({
+        storage,
+        qmd: this.deps.getQmd(),
+        hotCollection: config.qmdCollection,
+        coldCollection: config.qmdColdCollection ?? `${config.qmdCollection}-cold`,
+        autoEmbed: config.qmdAutoEmbedEnabled
+      });
+      let migrated = 0;
+      let promoted = 0;
+      let demoted = 0;
+      for (const candidate of candidates) {
+        if (migrated >= limit) break;
+        const decision = decideTierTransition(
+          candidate.memory,
+          candidate.tier,
+          policy,
+          now
+        );
+        if (!decision.changed) continue;
+        if (!dryRun) {
+          const res = await migration.migrateMemory({
+            memory: candidate.memory,
+            fromTier: candidate.tier,
+            toTier: decision.nextTier,
+            reason: `${trigger}:${decision.reason}`
+          });
+          if (!res.changed) continue;
+        }
+        migrated += 1;
+        if (decision.nextTier === "cold") demoted += 1;
+        if (decision.nextTier === "hot") promoted += 1;
+      }
+      if (!dryRun) this.lastRunAtMs = Date.now();
+      log.debug(
+        `tier migration cycle completed: trigger=${trigger} scanned=${candidates.length} migrated=${migrated} limit=${limit}${dryRun ? " dryRun=true" : ""}`
+      );
+      const summary = {
+        trigger,
+        scanned: candidates.length,
+        migrated,
+        promoted,
+        demoted,
+        limit,
+        dryRun
+      };
+      const shouldPersistCycle = trigger === "manual" || migrated > 0;
+      if (shouldPersistCycle) await tierMigrationStatus.recordCycle(summary);
+      return summary;
+    } catch (err) {
+      this.lastRunAtMs = Date.now();
+      log.warn(`tier migration cycle failed (${trigger}, fail-open): ${err}`);
+      const failed = {
+        trigger,
+        scanned: 0,
+        migrated: 0,
+        promoted: 0,
+        demoted: 0,
+        limit,
+        dryRun,
+        errorCount: 1
+      };
+      await tierMigrationStatus.recordCycle(failed);
+      return failed;
+    } finally {
+      this.inFlight = false;
+    }
+  }
+};
+
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
   return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
@@ -879,7 +1073,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile, mkdir, writeFile } from "fs/promises";
-import path from "path";
+import path2 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -977,7 +1171,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path2.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile(taxonomyPath, "utf-8");
@@ -1027,16 +1221,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path.join(memoryDir, TAXONOMY_DIR);
+  const dir = path2.join(memoryDir, TAXONOMY_DIR);
   await mkdir(dir, { recursive: true });
-  const filePath = path.join(dir, TAXONOMY_FILE);
+  const filePath = path2.join(dir, TAXONOMY_FILE);
   await writeFile(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path.join(memoryDir, TAXONOMY_DIR);
+  return path2.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path2.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/wearables/registry.ts
@@ -1717,7 +1911,7 @@ async function raceRecallAbort(promise, signal, message = "recall aborted") {
   }
 }
 function qmdCollectionPathParts(resultPath) {
-  if (!resultPath || path2.isAbsolute(resultPath)) return null;
+  if (!resultPath || path3.isAbsolute(resultPath)) return null;
   const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
   const slashIndex = normalized.indexOf("/");
   if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
@@ -1730,9 +1924,9 @@ function qmdCollectionPathParts(resultPath) {
 }
 function qmdResultPathCandidates(storageDir, resultPath) {
   const candidates = /* @__PURE__ */ new Set();
-  const storageRoot = path2.resolve(storageDir);
+  const storageRoot = path3.resolve(storageDir);
   const addCandidate = (candidate) => {
-    const resolved = path2.resolve(candidate);
+    const resolved = path3.resolve(candidate);
     if (isPathInsideStorageRoot(storageRoot, resolved)) {
       candidates.add(resolved);
     }
@@ -1740,12 +1934,12 @@ function qmdResultPathCandidates(storageDir, resultPath) {
   const addRelativeCandidates = (relativePath) => {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
     if (!normalized) return;
-    addCandidate(path2.join(storageRoot, normalized));
+    addCandidate(path3.join(storageRoot, normalized));
     if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
-      addCandidate(path2.join(storageRoot, "facts", normalized));
+      addCandidate(path3.join(storageRoot, "facts", normalized));
     }
   };
-  if (path2.isAbsolute(resultPath)) {
+  if (path3.isAbsolute(resultPath)) {
     addCandidate(resultPath);
   } else {
     addRelativeCandidates(resultPath);
@@ -1862,7 +2056,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path2.join(os.homedir(), ".openclaw", "workspace");
+  return path3.join(os.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -2169,11 +2363,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path2.isAbsolute(candidatePath) ? candidatePath : path2.resolve(storageDir, candidatePath);
-  const rel = path2.relative(storageDir, absolutePath);
+  const absolutePath = path3.isAbsolute(candidatePath) ? candidatePath : path3.resolve(storageDir, candidatePath);
+  const rel = path3.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path2.sep).join("/");
+  return rel.split(path3.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -2318,7 +2512,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path2.relative(storageDir, mem.path));
+    pathById.set(id, path3.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -2326,7 +2520,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path2.join(options.storageDir, options.memoryRelPath),
+    path: path3.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -2346,16 +2540,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path2.join("corrections", `${options.memoryId}.md`);
+    return path3.join("corrections", `${options.memoryId}.md`);
   }
   const subtree = categoryDirName(options.category);
   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 path2.join(subtree, day, `${options.memoryId}.md`);
+    return path3.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path2.join(subtree, `${options.memoryId}.md`);
+  return path3.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -2432,6 +2626,7 @@ var Orchestrator = class _Orchestrator {
   lastRecall;
   handleHistory;
   tierMigrationStatus;
+  tierMigrationCoordinator;
   /**
    * In-memory X-ray snapshot from the most recent `recall()` call that
    * was invoked with `xrayCapture: true` (issue #570 PR 1).  Scope is
@@ -2467,6 +2662,15 @@ var Orchestrator = class _Orchestrator {
    */
   memoryWorthCounterCache = /* @__PURE__ */ new Map();
   static MEMORY_WORTH_CACHE_TTL_MS = 3e4;
+  /**
+   * Issue #1577 — per-namespace TrustScore signal map cache. Same TTL/shape
+   * discipline as {@link memoryWorthCounterCache}: seconds-scale, evicted on
+   * every call, keyed by namespace. Holds the frontmatter-derived signals
+   * (worth, provenance, faithfulness, corroboration, recency) so the trust
+   * stage doesn't trigger a fresh `readAllMemories` scan per query.
+   */
+  trustSignalCache = /* @__PURE__ */ new Map();
+  static TRUST_SIGNAL_CACHE_TTL_MS = 3e4;
   /**
    * Per-session workspace selections keyed by sessionKey.
    * Set by the before_agent_start hook so recall() uses the correct
@@ -2513,8 +2717,6 @@ var Orchestrator = class _Orchestrator {
   wearablesServiceInstance = null;
   wearablesAutoSyncHandle = null;
   lastQmdReprobeAtMs = 0;
-  tierMigrationInFlight = false;
-  lastTierMigrationRunAtMs = 0;
   conversationIndexLastUpdateAtMs = /* @__PURE__ */ new Map();
   lastFileHygieneRunAtMs = 0;
   // Pattern-reinforcement cadence gate (issue #687 PR 2/4).  Tracks the
@@ -2801,7 +3003,7 @@ var Orchestrator = class _Orchestrator {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path2.resolve(storageDir);
+    const resolvedStorageDir = path3.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -2812,21 +3014,21 @@ var Orchestrator = class _Orchestrator {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path2.resolve(storageDir);
-    const resolvedMemoryDir = path2.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path3.resolve(storageDir);
+    const resolvedMemoryDir = path3.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path2.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path3.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path2.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path2.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path3.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path3.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path2.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path3.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path2.basename(resolvedStorageDir);
+    const leaf = path3.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -2854,7 +3056,7 @@ var Orchestrator = class _Orchestrator {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.namespaceStorageDirHintsLoaded || !this.namespaceCatalog.enabled) return;
     this.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path2.join(this.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path3.join(this.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -2891,7 +3093,7 @@ var Orchestrator = class _Orchestrator {
       if (!this.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path2.resolve(record.storageDir);
+      const resolvedStorageDir = path3.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -3073,7 +3275,7 @@ var Orchestrator = class _Orchestrator {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path2.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path3.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -3141,7 +3343,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = config.compoundingEnabled ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path2.join(
+    this.conversationIndexDir = path3.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -3154,6 +3356,14 @@ var Orchestrator = class _Orchestrator {
       maxDepth: config.recallHandleSnapshotDepth
     });
     this.tierMigrationStatus = new TierMigrationStatusStore(config.memoryDir);
+    this.tierMigrationCoordinator = new TierMigrationCoordinator({
+      config,
+      getQmd: () => this.qmd,
+      tierMigrationStatus: this.tierMigrationStatus,
+      getUtilityRuntimeValues: () => this.utilityRuntimeValues,
+      getCompounding: () => this.compounding,
+      createColdStorage: (parentDir) => new StorageManager(parentDir)
+    });
     this.sessionObserver = new SessionObserverState({
       memoryDir: config.memoryDir,
       debounceMs: config.sessionObserverDebounceMs ?? 12e4,
@@ -3201,7 +3411,7 @@ var Orchestrator = class _Orchestrator {
       this.modelRegistry
     );
     this.threading = new ThreadingManager(
-      path2.join(config.memoryDir, "threads"),
+      path3.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -3504,7 +3714,7 @@ var Orchestrator = class _Orchestrator {
           const files = await readdir(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path2.join(wsDir, f);
+            const fp = path3.join(wsDir, f);
             const s = await stat(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink(fp).catch(() => {
@@ -3721,7 +3931,7 @@ var Orchestrator = class _Orchestrator {
     if (signal.aborted) return;
     if (!this.wearablesAutoSyncHandle && this.config.wearables.enabled && this.config.wearables.autoSyncEnabled && Object.values(this.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-24NNS3GU.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-F3KCSQFJ.js");
         if (signal.aborted) return;
         this.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -4011,15 +4221,15 @@ ${doc.content}` : doc.content,
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path2.isAbsolute(rel) ? rel : path2.join(this.config.workspaceDir, rel);
+        const abs = path3.isAbsolute(rel) ? rel : path3.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile2(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path2.join(
+            const archiveDir = path3.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path2.basename(abs);
+            const base = path3.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -4044,8 +4254,8 @@ ${doc.content}` : doc.content,
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path2.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir2(path2.dirname(fp), { recursive: true });
+        const fp = path3.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir2(path3.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -4530,7 +4740,7 @@ ${evidenceText}`
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path2.join(storage.dir, categoryDir, date);
+        const dateDir = path3.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -4539,7 +4749,7 @@ ${evidenceText}`
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path2.join(dateDir, entry.name);
+            const fullPath = path3.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile2(fullPath, "utf-8");
@@ -4561,7 +4771,7 @@ ${evidenceText}`
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path2.basename(entry.name, ".md"),
+                  id: fm.id || path3.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -4584,13 +4794,13 @@ ${evidenceText}`
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path2.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path3.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path2.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path3.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile2(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -4694,7 +4904,7 @@ ${evidenceText}`
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path2.join(
+    const snapshotPath = path3.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -4733,7 +4943,7 @@ ${evidenceText}`
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path2.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path3.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile2(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -4766,7 +4976,7 @@ ${evidenceText}`
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path2.join(
+    const snapshotPath = path3.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -4919,7 +5129,7 @@ ${r.snippet.trim()}
       const entries = await readdir(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
+        const fullPath = path3.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -5825,7 +6035,7 @@ ${r.snippet.trim()}
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path2.isAbsolute(resolvedPath)) {
+      if (!path3.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -5850,7 +6060,7 @@ ${r.snippet.trim()}
         }
         continue;
       }
-      if (path2.isAbsolute(result.path)) {
+      if (path3.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -5893,7 +6103,7 @@ ${r.snippet.trim()}
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path2.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path3.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -5909,7 +6119,7 @@ ${r.snippet.trim()}
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (deadlineExpired()) break;
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path2.resolve(storage.dir, candidate.path);
+        const memoryPath = path3.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (deadlineExpired()) break;
         if (!memory) continue;
@@ -5934,7 +6144,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path2.resolve(storage.dir, candidate.seed),
+          seed: path3.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -5955,12 +6165,12 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path2.join(
+      const snapshotPath = path3.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -5994,12 +6204,12 @@ ${r.snippet.trim()}
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path2.join(
+      const snapshotPath = path3.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6011,12 +6221,12 @@ ${r.snippet.trim()}
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path2.join(
+      const snapshotPath = path3.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
+      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6031,8 +6241,8 @@ ${r.snippet.trim()}
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path2.join(stateDir, "last_intent.json");
-      await mkdir2(path2.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path3.join(stateDir, "last_intent.json");
+      await mkdir2(path3.dirname(snapshotPath), { recursive: true });
       await writeFile2(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6044,12 +6254,12 @@ ${r.snippet.trim()}
   }
   async resolveStateDirForNamespace(namespace) {
     if (!this.config.namespacesEnabled) {
-      return path2.join(this.config.memoryDir, "state");
+      return path3.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path2.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path3.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path2.join(
+    const candidate = path3.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -6057,11 +6267,11 @@ ${r.snippet.trim()}
     try {
       const candidateStat = await stat(candidate);
       if (candidateStat.isDirectory()) {
-        return path2.join(candidate, "state");
+        return path3.join(candidate, "state");
       }
     } catch {
     }
-    return path2.join(this.config.memoryDir, "state");
+    return path3.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -6260,8 +6470,8 @@ ${r.snippet.trim()}
     const timings = {};
     const profileTraceId = this.profiler.startTrace("recall", sessionKey, {
       qmdEnabled: this.config.qmdEnabled,
-      rerankEnabled: this.config.rerankEnabled,
-      parallelRetrieval: this.config.parallelRetrievalEnabled
+      rerankEnabled: caps.rerank,
+      parallelRetrieval: caps.parallelRetrieval
     });
     this.profiler.startSpan("planning", profileTraceId);
     let profileTraceClosed = false;
@@ -6332,6 +6542,10 @@ ${r.snippet.trim()}
       let recalledMemoryIds = [];
       let recalledMemoryPaths = [];
       let xrayRecalledResults = [];
+      let recallTrustByPath = null;
+      const trustByPathSink = {
+        trustByPath: null
+      };
       const lcmStructuredXrayResults = [];
       const xrayBranchPoolSize = {
         hot_qmd: 0,
@@ -6459,7 +6673,7 @@ ${r.snippet.trim()}
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path2.sep).join("/");
+        const normalizedPath = resultPath.split(path3.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -6609,7 +6823,7 @@ ${r.snippet.trim()}
         profileStorageNamespaces.map((namespace) => this.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path2.join(this.config.memoryDir, ".empty-scope-profile") },
+        { dir: path3.join(this.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -7363,9 +7577,9 @@ ${rows.join("\n")}
       const harmonicRetrievalPromise = observeEnrichmentPromise(
         (async () => {
           const t0 = Date.now();
-          if (!this.config.harmonicRetrievalEnabled || !this.isRecallSectionEnabled(
+          if (!caps.harmonicRetrieval || !this.isRecallSectionEnabled(
             "harmonic-retrieval",
-            this.config.harmonicRetrievalEnabled === true
+            caps.harmonicRetrieval
           )) {
             recordRecallSectionMetric({
               section: "harmonicRetrieval",
@@ -7830,7 +8044,7 @@ ${rows.join("\n")}
             log.info(`QMD re-probe succeeded: ${this.qmd.debugStatus()}`);
           }
           const maxPerAgent = this.config.parallelMaxResultsPerAgent;
-          const specializedAgentPromise = !queryAwarePrefilterIsEmpty && this.config.parallelRetrievalEnabled && maxPerAgent > 0 ? Promise.all([
+          const specializedAgentPromise = !queryAwarePrefilterIsEmpty && caps.parallelRetrieval && maxPerAgent > 0 ? Promise.all([
             shouldRunAgent("direct", retrievalQuery, 0) ? Promise.all(
               profileStorageDirs.map(
                 (memoryDir) => runDirectAgent(
@@ -7903,7 +8117,7 @@ ${rows.join("\n")}
             const preAugmentTopScore = filteredResults.length > 0 ? Math.max(...filteredResults.map((r) => r.score)) : 0;
             let augmentedResults = filteredResults;
             let maxSpecializedScore = 0;
-            if (this.config.parallelRetrievalEnabled && specializedAgentPromise) {
+            if (caps.parallelRetrieval && specializedAgentPromise) {
               try {
                 const [directResults, temporalResults] = await specializedAgentPromise;
                 if (filteredResults.length > 0) {
@@ -8085,11 +8299,11 @@ ${formatted}`;
         if (!this.config.compactionResetEnabled) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path2.join(
+        const signalPath = path3.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path2.join(workspaceDir, "BOOT.md");
+        const bootPath = path3.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -9110,7 +9324,7 @@ ${tmtNode.summary}`
           ),
           qmdBoostInput.results
         );
-        if (this.config.rerankEnabled && this.config.rerankProvider === "local") {
+        if (caps.rerank && this.config.rerankProvider === "local") {
           const ranked = await rerankLocalOrNoop({
             query: retrievalQuery,
             candidates: memoryResults.slice(0, this.config.rerankMaxCandidates).map((r) => ({
@@ -9139,17 +9353,20 @@ ${tmtNode.summary}`
             memoryResults = reordered;
           }
         }
-        if (this.config.rerankEnabled && this.config.rerankProvider === "cloud") {
+        if (caps.rerank && this.config.rerankProvider === "cloud") {
           log.debug(
             "rerankProvider=cloud is reserved/experimental in v2.2.0; skipping rerank"
           );
         }
-        if (caps.recallMemoryWorthFilter && memoryResults.length > 0) {
-          try {
-            memoryResults = await this.applyMemoryWorthRerank(memoryResults, recallNamespaces);
-          } catch (err) {
-            log.debug("memory-worth filter failed open", { error: err.message });
-          }
+        {
+          const trustOutcome = await this.applyTrustScoreToBranch(
+            memoryResults,
+            recallNamespaces,
+            caps,
+            "hot-qmd"
+          );
+          memoryResults = trustOutcome.results;
+          recallTrustByPath = trustOutcome.trustByPath;
         }
         const effectiveGateScore = preAugmentTopScore > 0 ? Math.max(preAugmentTopScore, maxSpecializedScore) : 0;
         xrayBranchPoolSize.hot_qmd = Math.max(
@@ -9227,7 +9444,8 @@ ${tmtNode.summary}`
               mode: identityInjectionModeUsed,
               injectedChars: identityInjectedChars,
               truncated: identityInjectionTruncated
-            }
+            },
+            trustByPath: recallTrustByPath
           });
           recalledMemoryIds = this.extractMemoryIdsFromResults(memoryResults);
           recalledMemoryPaths = memoryResults.map((result) => result.path).filter(Boolean);
@@ -9236,7 +9454,7 @@ ${tmtNode.summary}`
         } else if (!confidenceGateRejected) {
           const queryAwarePrefilter = await queryAwarePrefilterPromise;
           if (queryAwarePrefilter.candidatePaths?.size !== 0) {
-            const scoped = await awaitAssemblyStep(
+            let scoped = await awaitAssemblyStep(
               "embedding-fallback",
               async () => {
                 const embeddingResults = await this.searchEmbeddingFallback(
@@ -9277,6 +9495,16 @@ ${tmtNode.summary}`
               },
               []
             );
+            {
+              const trustOutcome = await this.applyTrustScoreToBranch(
+                scoped,
+                recallNamespaces,
+                caps,
+                "embedding-fallback"
+              );
+              scoped = trustOutcome.results;
+              recallTrustByPath = trustOutcome.trustByPath;
+            }
             if (scoped.length > 0) {
               if (shouldPersistGraphSnapshot) {
                 graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -9296,7 +9524,8 @@ ${tmtNode.summary}`
                   mode: identityInjectionModeUsed,
                   injectedChars: identityInjectedChars,
                   truncated: identityInjectionTruncated
-                }
+                },
+                trustByPath: recallTrustByPath
               });
               recalledMemoryIds = this.extractMemoryIdsFromResults(scoped);
               recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
@@ -9316,10 +9545,12 @@ ${tmtNode.summary}`
                   backendDegradations.push(degradation);
                 },
                 xrayPoolSizeSink: xrayColdPoolSink,
+                trustByPathSink,
                 deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                 asOfMs,
                 ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
               });
+              recallTrustByPath = trustByPathSink.trustByPath;
               if (longTerm.length > 0) {
                 if (shouldPersistGraphSnapshot) {
                   graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -9339,7 +9570,8 @@ ${tmtNode.summary}`
                     mode: identityInjectionModeUsed,
                     injectedChars: identityInjectedChars,
                     truncated: identityInjectionTruncated
-                  }
+                  },
+                  trustByPath: recallTrustByPath
                 });
                 recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
                 recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
@@ -9353,7 +9585,7 @@ ${tmtNode.summary}`
           this.appendRecallSection(
             sectionBuckets,
             "workspace-context",
-            this.formatQmdResults("Workspace Context", globalResults, sessionKey)
+            this.formatQmdResults("Workspace Context", globalResults, sessionKey, recallTrustByPath)
           );
         }
         recordRecallSectionMetric({
@@ -9383,7 +9615,7 @@ ${tmtNode.summary}`
       } else if (recallResultLimit > 0 && !this.qmd.isAvailable()) {
         const queryAwarePrefilter = await queryAwarePrefilterPromise;
         if (queryAwarePrefilter.candidatePaths?.size !== 0) {
-          const scoped = await awaitAssemblyStep(
+          let scoped = await awaitAssemblyStep(
             "embedding-fallback",
             async () => {
               const embeddingResults = await this.searchEmbeddingFallback(
@@ -9424,6 +9656,16 @@ ${tmtNode.summary}`
             },
             []
           );
+          {
+            const trustOutcome = await this.applyTrustScoreToBranch(
+              scoped,
+              recallNamespaces,
+              caps,
+              "embedding-fallback"
+            );
+            scoped = trustOutcome.results;
+            recallTrustByPath = trustOutcome.trustByPath;
+          }
           if (scoped.length > 0) {
             if (shouldPersistGraphSnapshot) {
               graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -9443,7 +9685,8 @@ ${tmtNode.summary}`
                 mode: identityInjectionModeUsed,
                 injectedChars: identityInjectedChars,
                 truncated: identityInjectionTruncated
-              }
+              },
+              trustByPath: recallTrustByPath
             });
             recalledMemoryIds = this.extractMemoryIdsFromResults(scoped);
             recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
@@ -9490,10 +9733,12 @@ ${tmtNode.summary}`
                     backendDegradations.push(degradation);
                   },
                   xrayPoolSizeSink: xrayColdPoolSink,
+                  trustByPathSink,
                   deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                   asOfMs,
                   ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
                 });
+                recallTrustByPath = trustByPathSink.trustByPath;
                 if (longTerm.length > 0) {
                   recallSource = "cold_fallback";
                   recalledMemoryCount = longTerm.length;
@@ -9507,7 +9752,8 @@ ${tmtNode.summary}`
                       mode: identityInjectionModeUsed,
                       injectedChars: identityInjectedChars,
                       truncated: identityInjectionTruncated
-                    }
+                    },
+                    trustByPath: recallTrustByPath
                   });
                   recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
                   recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
@@ -9515,7 +9761,7 @@ ${tmtNode.summary}`
                   impressionRecorded = true;
                 }
               } else {
-                const recent = await awaitAssemblyStep(
+                let recent = await awaitAssemblyStep(
                   "recent-memory-scan",
                   async () => {
                     const recentSorted = queryAwareScopedMemories.sort(
@@ -9553,6 +9799,16 @@ ${tmtNode.summary}`
                   },
                   []
                 );
+                {
+                  const trustOutcome = await this.applyTrustScoreToBranch(
+                    recent,
+                    recallNamespaces,
+                    caps,
+                    "recent-scan"
+                  );
+                  recent = trustOutcome.results;
+                  recallTrustByPath = trustOutcome.trustByPath;
+                }
                 if (recent.length > 0) {
                   if (shouldPersistGraphSnapshot) {
                     graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -9572,7 +9828,8 @@ ${tmtNode.summary}`
                       mode: identityInjectionModeUsed,
                       injectedChars: identityInjectedChars,
                       truncated: identityInjectionTruncated
-                    }
+                    },
+                    trustByPath: recallTrustByPath
                   });
                   recalledMemoryIds = this.extractMemoryIdsFromResults(recent);
                   recalledMemoryPaths = recent.map((result) => result.path).filter(Boolean);
@@ -9592,10 +9849,12 @@ ${tmtNode.summary}`
                       backendDegradations.push(degradation);
                     },
                     xrayPoolSizeSink: xrayColdPoolSink,
+                    trustByPathSink,
                     deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                     asOfMs,
                     ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
                   });
+                  recallTrustByPath = trustByPathSink.trustByPath;
                   if (longTerm.length > 0) {
                     if (shouldPersistGraphSnapshot) {
                       graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -9615,7 +9874,8 @@ ${tmtNode.summary}`
                         mode: identityInjectionModeUsed,
                         injectedChars: identityInjectedChars,
                         truncated: identityInjectionTruncated
-                      }
+                      },
+                      trustByPath: recallTrustByPath
                     });
                     recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
                     recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
@@ -9638,10 +9898,12 @@ ${tmtNode.summary}`
                   backendDegradations.push(degradation);
                 },
                 xrayPoolSizeSink: xrayColdPoolSink,
+                trustByPathSink,
                 deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                 asOfMs,
                 ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
               });
+              recallTrustByPath = trustByPathSink.trustByPath;
               if (longTerm.length > 0) {
                 if (shouldPersistGraphSnapshot) {
                   graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
@@ -9661,7 +9923,8 @@ ${tmtNode.summary}`
                     mode: identityInjectionModeUsed,
                     injectedChars: identityInjectedChars,
                     truncated: identityInjectionTruncated
-                  }
+                  },
+                  trustByPath: recallTrustByPath
                 });
                 recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
                 recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
@@ -9864,6 +10127,7 @@ _Context: ${topQuestion.context}_`
               }
             } catch {
             }
+            const trustItem = recallTrustByPath?.get(recalledPath);
             results.push({
               memoryId: derivedId,
               path: recalledPath,
@@ -9871,9 +10135,27 @@ _Context: ${topQuestion.context}_`
               scoreDecomposition,
               admittedBy: [],
               ...provenance ? { provenance } : {},
-              ...sourceSpan ? { sourceSpan } : {}
+              ...sourceSpan ? { sourceSpan } : {},
+              // Issue #1577 — per-result trust projection for X-ray visibility.
+              ...trustItem ? { trust: projectTrustForXray(trustItem) } : {}
             });
           }
+          if (recallTrustByPath) {
+            for (const [qPath, qItem] of recallTrustByPath) {
+              if (!qItem.quarantined || recalledMemoryPaths.includes(qPath)) continue;
+              const qId = idFromPath(qPath);
+              if (!qId) continue;
+              results.push({
+                memoryId: qId,
+                path: qPath,
+                servedBy,
+                scoreDecomposition: { final: 0 },
+                admittedBy: [],
+                rejectedBy: "trust-score:quarantine",
+                trust: projectTrustForXray(qItem)
+              });
+            }
+          }
           let xrayConsidered;
           switch (recallSource) {
             case "hot_qmd":
@@ -11126,165 +11408,7 @@ ${normalized}`).digest("hex");
     }
   }
   async runTierMigrationCycle(storage, trigger, options) {
-    const dryRun = options?.dryRun === true;
-    const persistSkipped = options?.force === true || trigger === "manual";
-    if (!this.config.qmdTierMigrationEnabled && options?.force !== true) {
-      const skipped = {
-        trigger,
-        scanned: 0,
-        migrated: 0,
-        promoted: 0,
-        demoted: 0,
-        limit: 0,
-        dryRun,
-        skipped: "tier_migration_disabled"
-      };
-      if (persistSkipped) await this.tierMigrationStatus.recordCycle(skipped);
-      return skipped;
-    }
-    if (trigger === "maintenance" && !this.config.qmdTierAutoBackfillEnabled && options?.force !== true) {
-      const skipped = {
-        trigger,
-        scanned: 0,
-        migrated: 0,
-        promoted: 0,
-        demoted: 0,
-        limit: 0,
-        dryRun,
-        skipped: "maintenance_backfill_disabled"
-      };
-      if (persistSkipped) await this.tierMigrationStatus.recordCycle(skipped);
-      return skipped;
-    }
-    if (this.tierMigrationInFlight) {
-      const skipped = {
-        trigger,
-        scanned: 0,
-        migrated: 0,
-        promoted: 0,
-        demoted: 0,
-        limit: 0,
-        dryRun,
-        skipped: "migration_in_flight"
-      };
-      if (persistSkipped) await this.tierMigrationStatus.recordCycle(skipped);
-      return skipped;
-    }
-    const budgetTrigger = trigger === "manual" ? "maintenance" : trigger;
-    const budget = this.compounding?.tierMigrationCycleBudget(budgetTrigger) ?? defaultTierMigrationCycleBudget(this.config, budgetTrigger);
-    const limit = options?.limitOverride !== void 0 ? Math.max(0, Math.floor(options.limitOverride)) : budget.limit;
-    const nowMs = Date.now();
-    if (options?.force !== true && nowMs - this.lastTierMigrationRunAtMs < budget.minIntervalMs) {
-      const skipped = {
-        trigger,
-        scanned: 0,
-        migrated: 0,
-        promoted: 0,
-        demoted: 0,
-        limit,
-        dryRun,
-        skipped: "min_interval"
-      };
-      if (persistSkipped) await this.tierMigrationStatus.recordCycle(skipped);
-      return skipped;
-    }
-    const policy = applyUtilityPromotionRuntimePolicy(
-      {
-        enabled: this.config.qmdTierMigrationEnabled,
-        demotionMinAgeDays: this.config.qmdTierDemotionMinAgeDays,
-        demotionValueThreshold: this.config.qmdTierDemotionValueThreshold,
-        promotionValueThreshold: this.config.qmdTierPromotionValueThreshold
-      },
-      this.utilityRuntimeValues
-    );
-    this.tierMigrationInFlight = true;
-    try {
-      const coldStorage = new StorageManager(path2.join(storage.dir, "cold"));
-      const [hotMemories, coldMemories] = await Promise.all([
-        storage.readAllMemories(),
-        coldStorage.readAllMemories()
-      ]);
-      const now = /* @__PURE__ */ new Date();
-      const scanLimit = Math.max(0, Math.floor(budget.scanLimit));
-      const hotScanLimit = Math.min(
-        hotMemories.length,
-        Math.ceil(scanLimit * 0.75)
-      );
-      const coldScanLimit = Math.min(
-        coldMemories.length,
-        Math.max(0, scanLimit - hotScanLimit)
-      );
-      const toTimestamp = (memory) => Date.parse(memory.frontmatter.updated ?? memory.frontmatter.created);
-      const hotCandidates = hotMemories.map((memory) => ({ memory, tier: "hot" })).sort((a, b) => toTimestamp(a.memory) - toTimestamp(b.memory)).slice(0, hotScanLimit);
-      const coldCandidates = coldMemories.map((memory) => ({ memory, tier: "cold" })).sort((a, b) => toTimestamp(b.memory) - toTimestamp(a.memory)).slice(0, coldScanLimit);
-      const candidates = [...hotCandidates, ...coldCandidates];
-      const migration = new TierMigrationExecutor({
-        storage,
-        qmd: this.qmd,
-        hotCollection: this.config.qmdCollection,
-        coldCollection: this.config.qmdColdCollection ?? `${this.config.qmdCollection}-cold`,
-        autoEmbed: this.config.qmdAutoEmbedEnabled
-      });
-      let migrated = 0;
-      let promoted = 0;
-      let demoted = 0;
-      for (const candidate of candidates) {
-        if (migrated >= limit) break;
-        const decision = decideTierTransition(
-          candidate.memory,
-          candidate.tier,
-          policy,
-          now
-        );
-        if (!decision.changed) continue;
-        if (!dryRun) {
-          const res = await migration.migrateMemory({
-            memory: candidate.memory,
-            fromTier: candidate.tier,
-            toTier: decision.nextTier,
-            reason: `${trigger}:${decision.reason}`
-          });
-          if (!res.changed) continue;
-        }
-        migrated += 1;
-        if (decision.nextTier === "cold") demoted += 1;
-        if (decision.nextTier === "hot") promoted += 1;
-      }
-      if (!dryRun) this.lastTierMigrationRunAtMs = Date.now();
-      log.debug(
-        `tier migration cycle completed: trigger=${trigger} scanned=${candidates.length} migrated=${migrated} limit=${limit}${dryRun ? " dryRun=true" : ""}`
-      );
-      const summary = {
-        trigger,
-        scanned: candidates.length,
-        migrated,
-        promoted,
-        demoted,
-        limit,
-        dryRun
-      };
-      const shouldPersistCycle = trigger === "manual" || migrated > 0;
-      if (shouldPersistCycle)
-        await this.tierMigrationStatus.recordCycle(summary);
-      return summary;
-    } catch (err) {
-      this.lastTierMigrationRunAtMs = Date.now();
-      log.warn(`tier migration cycle failed (${trigger}, fail-open): ${err}`);
-      const failed = {
-        trigger,
-        scanned: 0,
-        migrated: 0,
-        promoted: 0,
-        demoted: 0,
-        limit,
-        dryRun,
-        errorCount: 1
-      };
-      await this.tierMigrationStatus.recordCycle(failed);
-      return failed;
-    } finally {
-      this.tierMigrationInFlight = false;
-    }
+    return this.tierMigrationCoordinator.runCycle(storage, trigger, options);
   }
   async getTierMigrationStatus() {
     return this.tierMigrationStatus.get();
@@ -12628,7 +12752,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path2.relative(storage.dir, m.path);
+            const rel = path3.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -12687,7 +12811,8 @@ ${normalized}`).digest("hex");
    * Fail-open: any error is logged but does not abort extraction.
    */
   async updateTemporalTagIndexes(storage, persistedIds) {
-    if (!this.config.queryAwareIndexingEnabled && !this.config.parallelRetrievalEnabled)
+    const caps = resolveCapabilities(this.config);
+    if (!this.config.queryAwareIndexingEnabled && !caps.parallelRetrieval)
       return;
     const needsFullRebuild = !indexesExist(this.config.memoryDir);
     if (!needsFullRebuild && persistedIds.length === 0) return;
@@ -12950,7 +13075,7 @@ ${normalized}`).digest("hex");
     }
     if (this.config.semanticConsolidationEnabled) {
       try {
-        const stateFilePath = path2.join(
+        const stateFilePath = path3.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -12998,7 +13123,7 @@ ${normalized}`).digest("hex");
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path2.join(this.config.memoryDir, "state");
+            const stateDir = path3.join(this.config.memoryDir, "state");
             await mkdir2(stateDir, { recursive: true });
             await writeFile2(
               stateFilePath,
@@ -13499,12 +13624,12 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path2.join(
+    const metricsPath = path3.join(
       storage.dir,
       "state",
       "lifecycle-metrics.json"
     );
-    await mkdir2(path2.dirname(metricsPath), { recursive: true });
+    await mkdir2(path3.dirname(metricsPath), { recursive: true });
     await writeFile2(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
     return updatedCount;
   }
@@ -13690,18 +13815,29 @@ ${reflectionsContent.trim()}
       );
     }
   }
-  formatQmdResults(title, results, sessionKey) {
+  formatQmdResults(title, results, sessionKey, trustByPath) {
     const handleByIndex = buildHandleIndexForResults(
       results,
       this.config.recallMemoryHandles === true && sessionKey != null
     );
+    const renderHedge = this.config.trustScoreEpistemicRendering && trustByPath !== null && trustByPath !== void 0;
+    const hedgeMap = renderHedge ? trustByPath : null;
     const lines = results.map((r, i) => {
       const snippet = r.snippet ? r.snippet.slice(0, 500).replace(/\n/g, " ") : "(no preview)";
       const source = typeof r.line === "number" ? `${r.path}:${r.line}` : r.path;
       const head = `[${i + 1}] ${source} (score: ${r.score.toFixed(3)})
 ${snippet}`;
       const handle = handleByIndex.get(i);
-      return handle ? `${head.replace(/\s+$/, "")} ${handle}` : head;
+      const hedged = head.replace(/\s+$/, "");
+      const withHandle = handle ? `${hedged} ${handle}` : hedged;
+      if (hedgeMap) {
+        const item = hedgeMap.get(r.path);
+        if (item) {
+          const hedge = renderEpistemicHedge(item.trust);
+          if (hedge.length > 0) return `${withHandle} ${hedge}`;
+        }
+      }
+      return withHandle;
     });
     return `## ${title}
 
@@ -13993,12 +14129,14 @@ ${lines.join("\n\n")}`;
   }
   publishRecallResults(options) {
     const sectionId = "memories";
-    const memoryIds = this.extractMemoryIdsFromResults(options.results);
+    const trustByPath = options.trustByPath ?? null;
+    const injectable = trustByPath ? options.results.filter((r) => !trustByPath.get(r.path)?.quarantined) : options.results;
+    const memoryIds = this.extractMemoryIdsFromResults(injectable);
     this.trackMemoryAccess(memoryIds);
     this.appendRecallSection(
       options.sectionBuckets,
       sectionId,
-      this.formatQmdResults(options.title, options.results, options.sessionKey)
+      this.formatQmdResults(options.title, injectable, options.sessionKey, trustByPath)
     );
   }
   /**
@@ -14034,7 +14172,7 @@ ${lines.join("\n\n")}`;
       const seenStorageDirs = /* @__PURE__ */ new Set();
       const addStorage = (storage) => {
         const storageDir = storageDirFor(storage);
-        const storageKey = storageDir ? path2.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        const storageKey = storageDir ? path3.resolve(storageDir) : `storage-without-dir-${storages.length}`;
         if (seenStorageDirs.has(storageKey)) return;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
@@ -14064,7 +14202,7 @@ ${lines.join("\n\n")}`;
           continue;
         }
         try {
-          const coldRoot = path2.join(storageDir, "cold");
+          const coldRoot = path3.join(storageDir, "cold");
           for (const candidate of qmdResultPathCandidates(
             coldRoot,
             parts.relativePath
@@ -14105,7 +14243,7 @@ ${lines.join("\n\n")}`;
         return null;
       }
     }
-    if (path2.isAbsolute(resultPath)) {
+    if (path3.isAbsolute(resultPath)) {
       if (!fallbackStorageDir) {
         return await fallbackStorage.readMemoryByPath(resultPath);
       }
@@ -14144,7 +14282,7 @@ ${lines.join("\n\n")}`;
     );
     if (!memory) return null;
     let ownerNamespace = null;
-    if (path2.isAbsolute(memory.path)) {
+    if (path3.isAbsolute(memory.path)) {
       const ownerStorage = await this.storageForAbsoluteQmdResultPath(
         memory.path,
         fallbackStorage,
@@ -14168,16 +14306,16 @@ ${lines.join("\n\n")}`;
     };
   }
   async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
-    const resolvedPath = path2.resolve(resultPath);
-    const memoryRoot = path2.resolve(this.config.memoryDir);
-    const namespacesRoot = path2.join(memoryRoot, "namespaces");
+    const resolvedPath = path3.resolve(resultPath);
+    const memoryRoot = path3.resolve(this.config.memoryDir);
+    const namespacesRoot = path3.join(memoryRoot, "namespaces");
     const fallbackStorageDir = typeof fallbackStorage.dir === "string" && fallbackStorage.dir ? fallbackStorage.dir : null;
     const matches = [];
     const seenDirs = /* @__PURE__ */ new Set();
     const maybeAddStorage = (storage, namespace) => {
       const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
       if (!storageDir) return;
-      const candidateRoot = path2.resolve(storageDir);
+      const candidateRoot = path3.resolve(storageDir);
       if (seenDirs.has(candidateRoot)) return;
       if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
       if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
@@ -14195,7 +14333,7 @@ ${lines.join("\n\n")}`;
       candidateNamespaces.add(ns);
     }
     if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
-      const relativeToNamespaces = path2.relative(namespacesRoot, resolvedPath);
+      const relativeToNamespaces = path3.relative(namespacesRoot, resolvedPath);
       const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
       if (namespaceSegment) {
         candidateNamespaces.add(
@@ -14240,7 +14378,7 @@ ${lines.join("\n\n")}`;
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path3, c] of nsMap) counters.set(path3, c);
+        for (const [path4, c] of nsMap) counters.set(path4, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -14299,6 +14437,99 @@ ${lines.join("\n\n")}`;
     }
     return reordered;
   }
+  /**
+   * Issue #1577 — unified TrustScore recall stage. Thin wiring over the pure
+   * {@link applyTrustScoreStage} scorer + the {@link buildTrustSignalsForRerank}
+   * signal builder. The stage subsumes the Memory Worth multiplier — the
+   * orchestrator runs exactly one of the two (mutual exclusion, rule 39; the
+   * double-multiplier test in trust-score-stage.test.ts pins it structurally).
+   *
+   * Returns the admitted results AND the per-path trust map (including
+   * quarantined items) so the caller can: (a) render epistemic hedges, (b)
+   * surface quarantined items in X-ray with a reason (rule 34), and (c) filter
+   * quarantined paths from fallback recall branches. The trust map is a
+   * per-recall local — never instance state — so concurrent recalls cannot
+   * race on it (review: shared-trust-map concurrency).
+   */
+  async applyTrustScoreRerank(results, namespaces) {
+    if (results.length === 0) return { results, trustByPath: null };
+    const now = /* @__PURE__ */ new Date();
+    const halfLifeDays = this.config.recallMemoryWorthHalfLifeMs > 0 ? this.config.recallMemoryWorthHalfLifeMs / (24 * 60 * 60 * 1e3) : void 0;
+    let fallbackReader = null;
+    const signals = await buildTrustSignalsForRerank(
+      results.map((r) => r.path),
+      namespaces,
+      {
+        readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
+        readMemoryFrontmatter: async (path4) => {
+          if (!fallbackReader) {
+            for (const ns of namespaces) {
+              try {
+                fallbackReader = await this.getStorage(ns);
+                break;
+              } catch {
+              }
+            }
+          }
+          if (!fallbackReader) return null;
+          const memory = await this.readQmdResultMemory(path4, fallbackReader, namespaces);
+          return memory ? memory.frontmatter : null;
+        }
+      },
+      { cache: this.trustSignalCache, ttlMs: _Orchestrator.TRUST_SIGNAL_CACHE_TTL_MS },
+      now,
+      {
+        recencyHalfLifeDays: halfLifeDays,
+        logDebug: (message, context) => log.debug(message, context)
+      }
+    );
+    if (signals.size === 0) {
+      return { results, trustByPath: null };
+    }
+    const rankedInputs = results.map((r, i) => ({ path: r.path, score: results.length - i }));
+    const stage = applyTrustScoreStage(rankedInputs, {
+      signals,
+      weights: this.config.trustScoreWeights,
+      minMultiplier: this.config.trustScoreMinMultiplier,
+      maxMultiplier: this.config.trustScoreMaxMultiplier,
+      quarantine: this.config.trustScoreQuarantine
+    });
+    const trustByPath = new Map(stage.all.map((item) => [item.path, item]));
+    const byPath = new Map(results.map((r) => [r.path, r]));
+    const admitted = stage.admitted.map((item) => byPath.get(item.path)).filter((r) => r !== void 0);
+    return { results: admitted, trustByPath };
+  }
+  /**
+   * Issue #1577 — apply the TrustScore stage (or, when trust is off, the Memory
+   * Worth multiplier fallback) to ONE recall branch's results, returning the
+   * scored results + the per-path trust map. Thin wiring over
+   * {@link applyTrustScoreRerank} so every recall path — hot QMD, embedding
+   * fallback, recent scan — applies the SAME multiplier gate (rule 41: a
+   * feature gate must apply across ALL parallel recall paths). TrustScore
+   * subsumes Memory Worth; exactly one runs (rule 39). Fail-open on lookup
+   * errors so a storage hiccup never breaks a fallback path.
+   */
+  async applyTrustScoreToBranch(results, namespaces, caps, label) {
+    if (caps.recallTrustScore && results.length > 0) {
+      try {
+        return await this.applyTrustScoreRerank(results, namespaces);
+      } catch (err) {
+        log.debug(`trust-score stage (${label}) failed open`, {
+          error: err.message
+        });
+      }
+    } else if (caps.recallMemoryWorthFilter && results.length > 0) {
+      try {
+        const filtered = await this.applyMemoryWorthRerank(results, namespaces);
+        return { results: filtered, trustByPath: null };
+      } catch (err) {
+        log.debug(`memory-worth filter (${label}) failed open`, {
+          error: err.message
+        });
+      }
+    }
+    return { results, trustByPath: null };
+  }
   diversifyAndLimitRecallResults(sectionId, results, limit, retrievalQuery, caps = resolveCapabilities(this.config)) {
     const safeLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
     if (!Array.isArray(results) || results.length === 0) return [];
@@ -14411,12 +14642,12 @@ ${lines.join("\n\n")}`;
    */
   semanticDedupScopeFor(targetStorage) {
     if (!this.config.namespacesEnabled) return {};
-    const memoryDir = path2.resolve(this.config.memoryDir);
-    const storageDir = path2.resolve(targetStorage.dir);
+    const memoryDir = path3.resolve(this.config.memoryDir);
+    const storageDir = path3.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path2.relative(memoryDir, storageDir);
+    let rel = path3.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`
@@ -14435,7 +14666,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path2.isAbsolute(hit.path) ? hit.path : path2.join(this.config.memoryDir, hit.path);
+      const fullPath = path3.isAbsolute(hit.path) ? hit.path : path3.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -14639,7 +14870,7 @@ ${lines.join("\n\n")}`;
           const storage = await this.storageRouter.storageFor(namespace);
           const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
           if (!storageDir) continue;
-          const recallRoot = path2.resolve(storageDir);
+          const recallRoot = path3.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -14663,8 +14894,8 @@ ${lines.join("\n\n")}`;
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path2.isAbsolute(result.path)) {
-          const resolvedPath = path2.resolve(result.path);
+        if (path3.isAbsolute(result.path)) {
+          const resolvedPath = path3.resolve(result.path);
           if (recallRoots.some(
             (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
           )) {
@@ -14745,7 +14976,7 @@ ${lines.join("\n\n")}`;
     } else {
       log.debug("cold-tier recall boost skipped: shared assembly deadline already expired");
     }
-    if (this.config.rerankEnabled && this.config.rerankProvider === "local") {
+    if (caps.rerank && this.config.rerankProvider === "local") {
       const ranked = await rerankLocalOrNoop({
         query: options.prompt,
         candidates: results.slice(0, this.config.rerankMaxCandidates).map((r) => ({
@@ -14774,12 +15005,22 @@ ${lines.join("\n\n")}`;
         results = reordered;
       }
     }
-    if (this.config.rerankEnabled && this.config.rerankProvider === "cloud") {
+    if (caps.rerank && this.config.rerankProvider === "cloud") {
       log.debug(
         "rerankProvider=cloud is reserved/experimental in v2.2.0; skipping rerank"
       );
     }
-    if (caps.recallMemoryWorthFilter && results.length > 0) {
+    if (caps.recallTrustScore && results.length > 0) {
+      try {
+        const trustOutcome = await this.applyTrustScoreRerank(results, options.recallNamespaces);
+        results = trustOutcome.results;
+        if (options.trustByPathSink) options.trustByPathSink.trustByPath = trustOutcome.trustByPath;
+      } catch (err) {
+        log.debug("trust-score stage (cold) failed open", {
+          error: err.message
+        });
+      }
+    } else if (caps.recallMemoryWorthFilter && results.length > 0) {
       try {
         results = await this.applyMemoryWorthRerank(results, options.recallNamespaces);
       } catch (err) {
@@ -15552,4 +15793,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-NFRBADNR.js.map
+//# sourceMappingURL=chunk-LA3HZKES.js.map