@remnic/core 1.1.1 → 1.1.3

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

@@ -2,20 +2,12 @@ import {
   CompoundingEngine,
   SharedContextManager,
   defaultTierMigrationCycleBudget
-} from "./chunk-RGLL5SPU.js";
-import {
-  extractTopics
-} from "./chunk-UHGBNIOS.js";
+} from "./chunk-LVYGDT5V.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-FSFEQI74.js";
-import {
-  applyTemporalSupersession,
-  normalizeSupersessionKey,
-  shouldFilterSupersededFromRecall
-} from "./chunk-W6SL7OFG.js";
 import {
   TierMigrationExecutor
 } from "./chunk-Z5AAYHUC.js";
@@ -25,12 +17,29 @@ import {
 import {
   TmtBuilder
 } from "./chunk-TPB3I2AC.js";
+import {
+  extractTopics
+} from "./chunk-UHGBNIOS.js";
+import {
+  HourlySummarizer
+} from "./chunk-B2TL6GA2.js";
+import {
+  applyTemporalSupersession,
+  normalizeSupersessionKey,
+  shouldFilterSupersededFromRecall
+} from "./chunk-ZTSE2ZJ6.js";
+import {
+  isValidAsOf
+} from "./chunk-MDYG7VI7.js";
 import {
   SessionObserverState
 } from "./chunk-JR4ZC3G4.js";
 import {
-  HourlySummarizer
-} from "./chunk-ZEM3OK2K.js";
+  applyRuntimeRetrievalPolicy
+} from "./chunk-5IZL4DCV.js";
+import {
+  findUnresolvedEntityRefs
+} from "./chunk-X7XN6YU4.js";
 import {
   RelevanceStore
 } from "./chunk-5NPGSAVB.js";
@@ -57,28 +66,19 @@ import {
   resolvePromptTagPrefilterAsync
 } from "./chunk-V3RXWQIE.js";
 import {
-  applyRuntimeRetrievalPolicy
-} from "./chunk-5IZL4DCV.js";
+  createRecallSectionMetricRecorder
+} from "./chunk-7DHTMOND.js";
 import {
   LastRecallStore,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries
-} from "./chunk-VBVG2M5G.js";
-import {
-  buildXraySnapshot
-} from "./chunk-KVBLZUKV.js";
-import {
-  findUnresolvedEntityRefs
-} from "./chunk-X7XN6YU4.js";
+} from "./chunk-WPGJYVUH.js";
 import {
   applyReasoningTraceBoost
 } from "./chunk-ZZTOURJI.js";
 import {
   reorderRecallResultsWithMmr
 } from "./chunk-YDBIWGNI.js";
-import {
-  createRecallSectionMetricRecorder
-} from "./chunk-7DHTMOND.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -87,13 +87,19 @@ import {
 import {
   NegativeExampleStore
 } from "./chunk-D654IBA6.js";
-import {
-  evaluateMemoryActionPolicy
-} from "./chunk-H63EDPFJ.js";
 import {
   applyMemoryWorthFilter,
   buildMemoryWorthCounterMap
 } from "./chunk-3GPTTA4J.js";
+import {
+  runLiveConnectorsOnce
+} from "./chunk-ASIQZXYO.js";
+import {
+  evaluateMemoryActionPolicy
+} from "./chunk-H63EDPFJ.js";
+import {
+  classifyMemoryKind
+} from "./chunk-YAZNBMNF.js";
 import {
   hasBroadGraphIntent,
   inferIntentFromText,
@@ -101,13 +107,6 @@ import {
   isTaskInitiationIntent,
   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";
@@ -120,10 +119,10 @@ import {
 } from "./chunk-C4SQJZAF.js";
 import {
   ExtractionEngine
-} from "./chunk-S3EEFKNY.js";
+} from "./chunk-N7X62G74.js";
 import {
   parseMemoryActionEligibilityContext
-} from "./chunk-NZLQTHS5.js";
+} from "./chunk-WW3QQF4H.js";
 import {
   ProfilingCollector
 } from "./chunk-NBNN5GOB.js";
@@ -132,41 +131,52 @@ import {
 } from "./chunk-FEMOX5AD.js";
 import {
   LocalLlmClient
-} from "./chunk-JL2PU6AI.js";
+} from "./chunk-R2XRID2N.js";
+import {
+  formatDaySummaryMemories
+} from "./chunk-GZCUW5IC.js";
 import {
   tryDirectAnswer
 } from "./chunk-6AUUAZEX.js";
 import {
   EmbeddingFallback
-} from "./chunk-ALXMCZEU.js";
+} from "./chunk-Z2E7VW55.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-FVA6TGI3.js";
+} from "./chunk-Y3WQ4ZWK.js";
 import {
-  formatDaySummaryMemories
-} from "./chunk-GZCUW5IC.js";
+  buildCompressionGuidelinesMarkdown,
+  computeCompressionGuidelineCandidate,
+  refineCompressionGuidelineCandidateSemantically,
+  renderCompressionGuidelinesMarkdown
+} from "./chunk-2NMMFZ5T.js";
 import {
   RoutingRulesStore,
-  expandTildePath,
   normalizeReplaySessionKey
-} from "./chunk-EPQJM2GC.js";
+} from "./chunk-VTJVUHRK.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-CUPFXL3J.js";
+} from "./chunk-DHRQHX36.js";
 import {
   ThreadingManager
 } from "./chunk-JRNQ3RNA.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-SPI27QT6.js";
+} from "./chunk-L5IIGA5V.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-CULXMQJH.js";
 import {
   TranscriptManager
 } from "./chunk-E6K4NIEU.js";
+import {
+  PolicyRuntimeManager
+} from "./chunk-EABGC2TL.js";
+import {
+  searchObjectiveStateSnapshots
+} from "./chunk-LOBRX7VD.js";
 import {
   NamespaceSearchRouter,
   NamespaceStorageRouter,
@@ -174,16 +184,10 @@ import {
   createConversationIndexRuntime,
   createSearchBackend,
   writeConversationChunks
-} from "./chunk-7I7FKFZH.js";
+} from "./chunk-R2L7SUX2.js";
 import {
   parseQmdExplain
-} from "./chunk-YNQKWQT4.js";
-import {
-  PolicyRuntimeManager
-} from "./chunk-EABGC2TL.js";
-import {
-  searchObjectiveStateSnapshots
-} from "./chunk-LOBRX7VD.js";
+} from "./chunk-WSZIHQBK.js";
 import {
   searchHarmonicRetrieval
 } from "./chunk-HMDCOMYU.js";
@@ -192,31 +196,23 @@ import {
   scoreImportance
 } from "./chunk-JXS5PDQ7.js";
 import {
-  launchProcessSync
-} from "./chunk-LK6SGL53.js";
+  recordEvalShadowRecall
+} from "./chunk-K6WK37A6.js";
+import {
+  EXTRACTION_JUDGE_VERDICT_CATEGORY,
+  recordJudgeVerdict
+} from "./chunk-AJU4PJGY.js";
 import {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,
   searchNativeKnowledge
 } from "./chunk-7SEAZFFB.js";
-import {
-  recordEvalShadowRecall
-} from "./chunk-K6WK37A6.js";
-import {
-  GraphIndex
-} from "./chunk-C2EFFULQ.js";
 import {
   CODEX_THREAD_KEY_PREFIX
 } from "./chunk-3PG3H5TD.js";
 import {
   applyCommitmentLedgerLifecycle
 } from "./chunk-FYIYMQ5N.js";
-import {
-  buildCompressionGuidelinesMarkdown,
-  computeCompressionGuidelineCandidate,
-  refineCompressionGuidelineCandidateSemantically,
-  renderCompressionGuidelinesMarkdown
-} from "./chunk-2NMMFZ5T.js";
 import {
   semanticChunkContent
 } from "./chunk-KVE7R4CG.js";
@@ -235,10 +231,10 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-BGJGXLZ7.js";
+} from "./chunk-55FXRRSJ.js";
 import {
   FallbackLlmClient
-} from "./chunk-3GXCSUXR.js";
+} from "./chunk-CRU27Q4J.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-6HZ6AO2P.js";
@@ -261,24 +257,34 @@ import {
   throwIfAborted
 } from "./chunk-PVGDJXVK.js";
 import {
-  resolveHomeDir
-} from "./chunk-MARWOCVP.js";
+  clusterByKey,
+  stableHash
+} from "./chunk-NN3TS5BM.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
 } from "./chunk-EQINRHYR.js";
 import {
-  buildProcedurePersistBody
-} from "./chunk-QDW3E4RD.js";
+  buildXraySnapshot
+} from "./chunk-USFPPRAF.js";
 import {
   shouldSkipImplicitExtraction
 } from "./chunk-3FPTCC3Z.js";
 import {
   selectRouteRule
 } from "./chunk-2LGMW3DJ.js";
+import {
+  launchProcessSync
+} from "./chunk-OR64ZGRZ.js";
+import {
+  buildProcedurePersistBody
+} from "./chunk-QDW3E4RD.js";
+import {
+  GraphIndex
+} from "./chunk-RK2Y4XOM.js";
 import {
   searchCausalTrajectories
-} from "./chunk-RBBWYEFJ.js";
+} from "./chunk-G2WADRQ3.js";
 import {
   canReadNamespace,
   defaultNamespaceForPrincipal,
@@ -297,15 +303,18 @@ import {
   normalizeAttributePairs,
   normalizeEntityName,
   parseEntityFile
-} from "./chunk-F5VP6YCB.js";
-import {
-  confidenceTier
-} from "./chunk-LTCGGW2D.js";
+} from "./chunk-DCE6SQLA.js";
 import {
   attachCitation,
   hasCitationForTemplate,
   stripCitationForTemplate
 } from "./chunk-4KAN3GZ3.js";
+import {
+  confidenceTier
+} from "./chunk-43EKP2UK.js";
+import {
+  isActiveMemoryStatus
+} from "./chunk-RULE4VG5.js";
 import {
   openBetterSqlite3
 } from "./chunk-BOUYNNYD.js";
@@ -316,12 +325,19 @@ import {
 import {
   sanitizeMemoryContent
 } from "./chunk-M62O4P4T.js";
+import {
+  resolveHomeDir
+} from "./chunk-MARWOCVP.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
+import {
+  keyring_exports,
+  secureStoreDir
+} from "./chunk-BJMBJZ2Y.js";
 
 // src/orchestrator.ts
-import path7 from "path";
+import path6 from "path";
 import os from "os";
 import { createHash as createHash2, randomBytes } from "crypto";
 import { existsSync as existsSync2 } from "fs";
@@ -335,7 +351,6 @@ import {
 } from "fs/promises";
 
 // src/migrate/from-engram.ts
-import { execFileSync } from "child_process";
 import { createHash } from "crypto";
 import path from "path";
 import {
@@ -371,7 +386,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) {
@@ -913,7 +935,7 @@ async function buildProcedureRecallSection(storage, prompt, config) {
   );
   const all = await storage.readAllMemories();
   const scored = all.filter(
-    (m) => m.frontmatter.category === "procedure" && m.frontmatter.status !== "pending_review" && m.frontmatter.status !== "rejected" && m.frontmatter.status !== "quarantined" && m.frontmatter.status !== "superseded" && m.frontmatter.status !== "archived"
+    (m) => m.frontmatter.category === "procedure" && isActiveMemoryStatus(m.frontmatter.status)
   ).map((m) => ({ m, score: scoreProcedureForPrompt(m, trimmed, queryIntent) })).filter((x) => x.score > 0.04).sort((a, b) => b.score - a.score).slice(0, maxN);
   if (scored.length === 0) return null;
   const blocks = scored.map(({ m, score }) => {
@@ -937,6 +959,8 @@ var DAY_SUMMARY_CRON_ID = "engram-day-summary";
 var GOVERNANCE_CRON_ID = "engram-nightly-governance";
 var PROCEDURAL_MINING_CRON_ID = "engram-procedural-mining";
 var CONTRADICTION_SCAN_CRON_ID = "engram-contradiction-scan";
+var PATTERN_REINFORCEMENT_CRON_ID = "engram-pattern-reinforcement";
+var GRAPH_EDGE_DECAY_CRON_ID = "engram-graph-edge-decay";
 async function acquireCronJobsLock(jobsPath) {
   const lockPath2 = `${jobsPath}.lock`;
   const start = Date.now();
@@ -1097,6 +1121,202 @@ async function ensureContradictionScanCron(jobsPath, options) {
     delivery: { mode: "none" }
   }));
 }
+async function ensurePatternReinforcementCron(jobsPath, options) {
+  const scheduleExpr = typeof options.scheduleExpr === "string" && options.scheduleExpr.trim().length > 0 ? options.scheduleExpr.trim() : "53 4 * * 0";
+  const agentId = typeof options.agentId === "string" && options.agentId.trim().length > 0 ? options.agentId.trim() : "main";
+  return ensureCronJob(jobsPath, PATTERN_REINFORCEMENT_CRON_ID, () => ({
+    id: PATTERN_REINFORCEMENT_CRON_ID,
+    agentId,
+    name: "Remnic Pattern Reinforcement (weekly)",
+    enabled: true,
+    schedule: {
+      kind: "cron",
+      expr: scheduleExpr,
+      tz: options.timezone
+    },
+    sessionTarget: "isolated",
+    wakeMode: "now",
+    payload: {
+      kind: "agentTurn",
+      timeoutSeconds: 900,
+      thinking: "off",
+      message: "You are OpenClaw automation. Call tool `engram.pattern_reinforcement_run` with empty params. If successful output exactly NO_REPLY. On error output one concise line. Do NOT use message tool."
+    },
+    delivery: { mode: "none" }
+  }));
+}
+async function ensureGraphEdgeDecayCron(jobsPath, options) {
+  const scheduleExpr = typeof options.scheduleExpr === "string" && options.scheduleExpr.trim().length > 0 ? options.scheduleExpr.trim() : "13 4 * * 0";
+  const agentId = typeof options.agentId === "string" && options.agentId.trim().length > 0 ? options.agentId.trim() : "main";
+  const scheduleLabel = graphEdgeDecayScheduleLabel(scheduleExpr);
+  return ensureCronJob(jobsPath, GRAPH_EDGE_DECAY_CRON_ID, () => ({
+    id: GRAPH_EDGE_DECAY_CRON_ID,
+    agentId,
+    // Schedule label reflects the actual cron expression (`daily` /
+    // `weekly` / `custom`) so cron dashboards do not show "weekly"
+    // when the schedule is in fact daily — Cursor review on PR #729.
+    name: `Remnic Graph Edge Decay (${scheduleLabel})`,
+    enabled: true,
+    schedule: {
+      kind: "cron",
+      expr: scheduleExpr,
+      tz: options.timezone
+    },
+    sessionTarget: "isolated",
+    wakeMode: "now",
+    payload: {
+      kind: "agentTurn",
+      timeoutSeconds: 900,
+      thinking: "off",
+      message: "You are OpenClaw automation. Call tool `engram.graph_edge_decay_run` with empty params. If successful output exactly NO_REPLY. On error output one concise line. Do NOT use message tool."
+    },
+    delivery: { mode: "none" }
+  }));
+}
+function graphEdgeDecayCadenceToCronExpr(cadenceMs) {
+  if (!Number.isFinite(cadenceMs) || cadenceMs <= 0) {
+    return "13 4 * * 0";
+  }
+  const day = 24 * 60 * 60 * 1e3;
+  if (cadenceMs < 7 * day) return "13 4 * * *";
+  return "13 4 * * 0";
+}
+function graphEdgeDecayScheduleLabel(scheduleExpr) {
+  if (scheduleExpr === "13 4 * * *") return "daily";
+  if (scheduleExpr === "13 4 * * 0") return "weekly";
+  return "custom";
+}
+
+// src/maintenance/pattern-reinforcement.ts
+function patternReinforcementKey(content) {
+  return content.trim().toLowerCase().replace(/\s+/g, " ").slice(0, 200);
+}
+function patternReinforcementClusterKey(category, content) {
+  return `${category}::${patternReinforcementKey(content)}`;
+}
+function pickCanonical(memories) {
+  let best = memories[0];
+  let bestInstant = memoryInstant(best);
+  let bestStamp = memoryStamp(best);
+  for (let i = 1; i < memories.length; i += 1) {
+    const candidate = memories[i];
+    const instant = memoryInstant(candidate);
+    const stamp = memoryStamp(candidate);
+    let cmp;
+    if (instant !== null && bestInstant !== null) {
+      cmp = instant - bestInstant;
+    } else {
+      cmp = stamp.localeCompare(bestStamp);
+    }
+    if (cmp > 0 || cmp === 0 && candidate.frontmatter.id > best.frontmatter.id) {
+      best = candidate;
+      bestInstant = instant;
+      bestStamp = stamp;
+    }
+  }
+  return best;
+}
+function memoryStamp(memory) {
+  return memory.frontmatter.updated || memory.frontmatter.created || "";
+}
+function memoryInstant(memory) {
+  const stamp = memoryStamp(memory);
+  if (stamp.length === 0) return null;
+  const parsed = Date.parse(stamp);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var ACTIVE_STATUS = "active";
+async function runPatternReinforcement(storage, options) {
+  const minCount = Math.max(2, Math.floor(options.minCount));
+  const targetCategories = new Set(options.categories);
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const nowIso = now().toISOString();
+  if (targetCategories.size === 0) {
+    return emptyResult();
+  }
+  const memories = await storage.readAllMemories();
+  const eligible = memories.filter((m) => {
+    if (!targetCategories.has(m.frontmatter.category)) return false;
+    const status = m.frontmatter.status ?? ACTIVE_STATUS;
+    return status === ACTIVE_STATUS || status === "superseded";
+  });
+  if (eligible.length === 0) return emptyResult();
+  const clusters = clusterByKey(
+    eligible,
+    (m) => patternReinforcementClusterKey(m.frontmatter.category, m.content)
+  );
+  const result = {
+    clustersFound: 0,
+    canonicalsUpdated: 0,
+    duplicatesSuperseded: 0,
+    clusters: []
+  };
+  for (const cluster of clusters.values()) {
+    if (cluster.length < minCount) continue;
+    const activeMembers = cluster.filter((m) => {
+      const status = m.frontmatter.status ?? ACTIVE_STATUS;
+      return status === ACTIVE_STATUS;
+    });
+    if (activeMembers.length === 0) continue;
+    result.clustersFound += 1;
+    const canonical = pickCanonical(activeMembers);
+    const activeDuplicates = activeMembers.filter((m) => m !== canonical);
+    const sourceIds = [...cluster].map((m) => m.frontmatter.id).filter((id) => typeof id === "string" && id.length > 0).sort();
+    const previousCount = canonical.frontmatter.reinforcement_count ?? 0;
+    const newCount = sourceIds.length;
+    const reinforcementBumped = newCount > previousCount;
+    const previousDerivedFrom = Array.isArray(canonical.frontmatter.derived_from) ? [...canonical.frontmatter.derived_from].sort() : [];
+    const sortedSourceIds = [...sourceIds].sort();
+    const membershipChanged = previousDerivedFrom.length !== sortedSourceIds.length || previousDerivedFrom.some((id, i) => id !== sortedSourceIds[i]);
+    const previousVia = canonical.frontmatter.derived_via;
+    const viaChanged = previousVia !== "pattern-reinforcement";
+    const canonicalNeedsRefresh = reinforcementBumped || membershipChanged || viaChanged;
+    if (canonicalNeedsRefresh) {
+      const patch = {
+        derived_from: sourceIds,
+        derived_via: "pattern-reinforcement",
+        updated: nowIso
+      };
+      if (reinforcementBumped) {
+        patch.reinforcement_count = newCount;
+        patch.last_reinforced_at = nowIso;
+      } else {
+        patch.reinforcement_count = canonical.frontmatter.reinforcement_count ?? newCount;
+        patch.last_reinforced_at = canonical.frontmatter.last_reinforced_at ?? nowIso;
+      }
+      await storage.writeMemoryFrontmatter(canonical, patch);
+      result.canonicalsUpdated += 1;
+    }
+    const supersededIds = [];
+    for (const dup of activeDuplicates) {
+      const patch = {
+        status: "superseded",
+        supersededBy: canonical.frontmatter.id,
+        supersededAt: nowIso,
+        updated: nowIso
+      };
+      await storage.writeMemoryFrontmatter(dup, patch);
+      supersededIds.push(dup.frontmatter.id);
+      result.duplicatesSuperseded += 1;
+    }
+    result.clusters.push({
+      canonicalId: canonical.frontmatter.id,
+      count: newCount,
+      sourceIds,
+      supersededIds,
+      reinforcementBumped
+    });
+  }
+  return result;
+}
+function emptyResult() {
+  return {
+    clustersFound: 0,
+    canonicalsUpdated: 0,
+    duplicatesSuperseded: 0,
+    clusters: []
+  };
+}
 
 // src/dedup/semantic.ts
 async function decideSemanticDedup(content, lookup, options) {
@@ -2700,119 +2920,6 @@ 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 "";
@@ -2883,27 +2990,30 @@ function branchNamespaceName(projectId, branch) {
   const suffixed = disambig ? `${base}-${stableHash(trimmedBranch)}` : base;
   return capLength(suffixed);
 }
-function resolveCodingNamespaceOverlay(codingContext, config) {
+function resolveCodingNamespaceOverlay(codingContext, config, defaultNamespace) {
   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);
+  const includeRoot = config.globalFallback === true;
   if (config.branchScope && typeof codingContext.branch === "string" && codingContext.branch.length > 0) {
     const branchNs = branchNamespaceName(projectId, codingContext.branch);
+    const fallbacks = [projectNs];
+    if (includeRoot) fallbacks.push("");
     return {
       namespace: branchNs,
-      readFallbacks: [projectNs],
+      readFallbacks: fallbacks,
       scope: "branch"
     };
   }
   return {
     namespace: projectNs,
-    readFallbacks: [],
+    readFallbacks: includeRoot ? [""] : [],
     scope: "project"
   };
 }
-function describeCodingScope(codingContext, config) {
+function describeCodingScope(codingContext, config, defaultNamespace) {
   const projectId = codingContext?.projectId ?? null;
   const branch = codingContext?.branch ?? null;
   if (!codingContext) {
@@ -2937,7 +3047,7 @@ function describeCodingScope(codingContext, config) {
       disabledReason: "empty-project"
     };
   }
-  const overlay = resolveCodingNamespaceOverlay(codingContext, config);
+  const overlay = resolveCodingNamespaceOverlay(codingContext, config, defaultNamespace);
   if (!overlay) {
     return {
       scope: "none",
@@ -3058,7 +3168,7 @@ async function raceRecallAbort(promise, signal, message = "recall aborted") {
 }
 var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
 function defaultWorkspaceDir() {
-  return path7.join(os.homedir(), ".openclaw", "workspace");
+  return path6.join(os.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -3226,11 +3336,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path7.isAbsolute(candidatePath) ? candidatePath : path7.resolve(storageDir, candidatePath);
-  const rel = path7.relative(storageDir, absolutePath);
+  const absolutePath = path6.isAbsolute(candidatePath) ? candidatePath : path6.resolve(storageDir, candidatePath);
+  const rel = path6.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path7.sep).join("/");
+  return rel.split(path6.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -3372,7 +3482,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path7.relative(storageDir, mem.path));
+    pathById.set(id, path6.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -3380,7 +3490,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path7.join(options.storageDir, options.memoryRelPath),
+    path: path6.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -3400,16 +3510,16 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path7.join("corrections", `${options.memoryId}.md`);
+    return path6.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 path7.join(subtree, day, `${options.memoryId}.md`);
+    return path6.join(subtree, day, `${options.memoryId}.md`);
   }
-  return path7.join(subtree, `${options.memoryId}.md`);
+  return path6.join(subtree, `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
@@ -3501,6 +3611,15 @@ var Orchestrator = class _Orchestrator {
    * through the same namespace layer).
    */
   _codingContextBySession = /* @__PURE__ */ new Map();
+  /**
+   * Per-session peer ID registry (issue #679 PR 3/5).
+   * Set by connectors / hooks via `setPeerIdForSession` so `recallInternal`
+   * can inject the peer's profile into recall context when
+   * `peerProfileRecallEnabled` is true. Cleared when the session ends.
+   * Keyed by sessionKey so concurrent sessions don't clobber each other
+   * (rule 11 — scope globals per plugin ID / session).
+   */
+  _peerIdBySession = /* @__PURE__ */ new Map();
   routingRulesStore = null;
   contentHashIndex = null;
   artifactSourceStatusCache = /* @__PURE__ */ new WeakMap();
@@ -3527,6 +3646,13 @@ var Orchestrator = class _Orchestrator {
   lastTierMigrationRunAtMs = 0;
   conversationIndexLastUpdateAtMs = /* @__PURE__ */ new Map();
   lastFileHygieneRunAtMs = 0;
+  // Pattern-reinforcement cadence gate (issue #687 PR 2/4).  Tracks the
+  // last successful run so `runPatternReinforcement` can short-circuit
+  // when the configured cadence has not elapsed.  Keyed by namespace
+  // so MCP-triggered runs in tenant A don't suppress runs in tenant B
+  // (PR #730 review feedback, Codex P2).  The default-tenant path
+  // uses the empty-string key.
+  lastPatternReinforcementAtByNs = /* @__PURE__ */ new Map();
   lastRecallFailureLogAtMs = 0;
   lastRecallFailureAtMs = 0;
   suppressedRecallFailures = 0;
@@ -3654,14 +3780,58 @@ var Orchestrator = class _Orchestrator {
   applyCodingNamespaceOverlay(sessionKey, baseNamespace) {
     if (!this.config.namespacesEnabled) return baseNamespace;
     const codingContext = this.getCodingContextForSession(sessionKey);
-    const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode);
+    const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode, this.config.defaultNamespace);
     if (!overlay) return baseNamespace;
     return combineNamespaces(baseNamespace, overlay.namespace);
   }
+  /**
+   * Register a peer ID for a session so recall can inject the peer's
+   * profile into context (issue #679 PR 3/5). Pass `null` to clear.
+   *
+   * Connectors and the `before_agent_start` hook call this when the
+   * session's counter-party is known. The ID is validated against
+   * `PEER_ID_PATTERN` before storing.
+   *
+   * Fail-closed (Codex P1 review): an invalid peerId clears any
+   * previously registered mapping for the session rather than silently
+   * keeping stale data. This prevents a malformed metadata update from
+   * mixing one peer's profile context into another session.
+   *
+   * Defensive init (Cursor review + rule 16): `Object.create(
+   * Orchestrator.prototype)` stubs in legacy tests skip class-field
+   * initializers, so `_peerIdBySession` may be undefined. Mirror the
+   * same guard used by `setCodingContextForSession`.
+   */
+  setPeerIdForSession(sessionKey, peerId) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return;
+    if (!this._peerIdBySession) {
+      this._peerIdBySession = /* @__PURE__ */ new Map();
+    }
+    if (peerId === null) {
+      this._peerIdBySession.delete(sessionKey);
+      return;
+    }
+    if (typeof peerId !== "string" || peerId.length === 0 || peerId.length > 64 || !/^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$/.test(peerId)) {
+      log.warn(`setPeerIdForSession: invalid peerId \u2014 clearing session mapping`);
+      this._peerIdBySession.delete(sessionKey);
+      return;
+    }
+    this._peerIdBySession.set(sessionKey, peerId);
+  }
+  /**
+   * Return the peer ID registered for a session, or `null` when none
+   * is set. Used by `recallInternal` to inject the peer profile section.
+   * Defensive `_peerIdBySession` lookup — legacy orchestrator-flush tests
+   * use `Object.create(Orchestrator.prototype)` which skips class-field
+   * initializers, so the Map may be undefined on stubs.
+   */
+  getPeerIdForSession(sessionKey) {
+    if (typeof sessionKey !== "string" || sessionKey.length === 0) return null;
+    return this._peerIdBySession?.get(sessionKey) ?? null;
+  }
   /**
    * 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).
+   * from, including any read fallbacks (branch → project, global root).
    *
    * Returns `null` when:
    *   - `namespacesEnabled` is false (overlay would create false isolation)
@@ -3678,7 +3848,7 @@ var Orchestrator = class _Orchestrator {
   applyCodingRecallOverlay(sessionKey) {
     if (!this.config.namespacesEnabled) return null;
     const codingContext = this.getCodingContextForSession(sessionKey);
-    const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode);
+    const overlay = resolveCodingNamespaceOverlay(codingContext, this.config.codingMode, this.config.defaultNamespace);
     if (!overlay) return null;
     return { namespace: overlay.namespace, readFallbacks: overlay.readFallbacks };
   }
@@ -3761,11 +3931,14 @@ var Orchestrator = class _Orchestrator {
     if (this.config.namespacesEnabled) return true;
     return this.qmd.isAvailable();
   }
+  invalidateLiveContentHashIndex() {
+    this.contentHashIndex = null;
+  }
   constructor(config) {
     this.config = config;
     this.profiler = new ProfilingCollector({
       enabled: config.profilingEnabled,
-      storageDir: config.profilingStorageDir || path7.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path6.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.storageRouter = new NamespaceStorageRouter(config);
@@ -3780,6 +3953,14 @@ var Orchestrator = class _Orchestrator {
       maxVersionsPerPage: config.versioningMaxPerPage,
       sidecarDir: config.versioningSidecarDir
     });
+    if (config.secureStoreEnabled) {
+      this.storage.setSecureStoreRequired(true);
+      const storeId = secureStoreDir(config.memoryDir);
+      const existingKey = keyring_exports.getKey(storeId);
+      if (existingKey) {
+        this.storage.setSecureStoreKey(existingKey, config.secureStoreEncryptOnWrite);
+      }
+    }
     this.qmd = createSearchBackend(config);
     const conversationIndexRuntime = createConversationIndexRuntime(config, {
       getQmd: () => this.conversationQmd,
@@ -3789,10 +3970,10 @@ var Orchestrator = class _Orchestrator {
     this.conversationFaiss = conversationIndexRuntime.faiss;
     this.conversationIndexBackend = conversationIndexRuntime.backend;
     this.sharedContext = config.sharedContextEnabled ? new SharedContextManager(config) : void 0;
-    this.compounding = config.compoundingEnabled ? new CompoundingEngine(config) : void 0;
+    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 = path7.join(
+    this.conversationIndexDir = path6.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -3846,7 +4027,7 @@ var Orchestrator = class _Orchestrator {
       this.modelRegistry
     );
     this.threading = new ThreadingManager(
-      path7.join(config.memoryDir, "threads"),
+      path6.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -4091,8 +4272,7 @@ var Orchestrator = class _Orchestrator {
         promotionByOutcomeEnabled: this.config.promotionByOutcomeEnabled
       });
       if (this.config.factDeduplicationEnabled) {
-        const stateDir = path7.join(this.config.memoryDir, "state");
-        this.contentHashIndex = new ContentHashIndex(stateDir);
+        this.contentHashIndex = this.storage.createContentHashIndex();
         await this.contentHashIndex.load();
         log.info(
           `content-hash dedup: loaded ${this.contentHashIndex.size} hashes`
@@ -4120,7 +4300,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 = path7.join(wsDir, f);
+            const fp = path6.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(() => {
@@ -4328,6 +4508,43 @@ var Orchestrator = class _Orchestrator {
         log.debug(`contradiction scan cron auto-register failed (non-fatal): ${err}`);
       }
     }
+    if (this.config.patternReinforcementEnabled) {
+      try {
+        await this.autoRegisterPatternReinforcementCron();
+      } catch (err) {
+        log.debug(`pattern reinforcement cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    if (this.config.graphEdgeDecayEnabled) {
+      try {
+        await this.autoRegisterGraphEdgeDecayCron();
+      } catch (err) {
+        log.debug(`graph edge decay cron auto-register failed (non-fatal): ${err}`);
+      }
+    }
+    if (signal.aborted) return;
+    if (this.config.lifecyclePolicyEnabled && this.config.qmdTierMigrationEnabled) {
+      try {
+        const { runFirstStartMigration } = await import("./first-start-migration-4MHQEOSD.js");
+        const result = await runFirstStartMigration({
+          storage: this.storage,
+          config: this.config,
+          qmd: this.qmd,
+          hotCollection: this.config.qmdCollection,
+          coldCollection: this.config.qmdColdCollection,
+          signal
+        });
+        if (!result.skipped) {
+          log.info(
+            `first-start lifecycle migration: demoted ${result.demotedCount} of ${result.candidateCount} candidates (cap=${result.cappedAt})`
+          );
+        } else {
+          log.debug(`first-start lifecycle migration skipped: ${result.skipReason}`);
+        }
+      } catch (err) {
+        log.warn(`first-start lifecycle migration failed (non-fatal): ${err}`);
+      }
+    }
     log.info("orchestrator initialized (full \u2014 deferred steps complete)");
   }
   /**
@@ -4435,7 +4652,7 @@ var Orchestrator = class _Orchestrator {
    */
   async autoRegisterDaySummaryCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug(
@@ -4458,8 +4675,8 @@ var Orchestrator = class _Orchestrator {
     }
   }
   async autoRegisterNightlyGovernanceCron() {
-    const home = process.env.HOME || os.homedir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const home = resolveHomeDir();
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("nightly governance cron: jobs.json not found, skipping auto-register");
@@ -4481,7 +4698,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterProceduralMiningCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("procedural mining cron: jobs.json not found, skipping auto-register");
@@ -4501,7 +4718,7 @@ var Orchestrator = class _Orchestrator {
   }
   async autoRegisterContradictionScanCron() {
     const home = resolveHomeDir();
-    const jobsPath = path7.join(home, ".openclaw", "cron", "jobs.json");
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
     try {
       if (!existsSync2(jobsPath)) {
         log.debug("contradiction scan cron: jobs.json not found, skipping auto-register");
@@ -4519,6 +4736,109 @@ var Orchestrator = class _Orchestrator {
       log.debug(`contradiction scan cron auto-register error: ${err}`);
     }
   }
+  async autoRegisterPatternReinforcementCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync2(jobsPath)) {
+        log.debug("pattern reinforcement cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const created = await ensurePatternReinforcementCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      if (created.created) {
+        log.info(`pattern reinforcement cron auto-registered (${created.jobId})`);
+      } else {
+        log.debug("pattern reinforcement cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`pattern reinforcement cron auto-register error: ${err}`);
+    }
+  }
+  /**
+   * Run the pattern-reinforcement maintenance job (issue #687 PR 2/4).
+   *
+   * Cadence-gated on `patternReinforcementCadenceMs` so every caller
+   * (orchestrator cron path, MCP tool, CLI) shares a single floor —
+   * none can call this on a hot loop and burn the corpus.  When the
+   * feature is disabled or the cadence has not elapsed, returns a
+   * synthetic "skipped" result rather than throwing.
+   *
+   * Cadence tracking is per-namespace so a tenant-scoped MCP run in
+   * one namespace does not silence a cron run in another (PR #730
+   * review feedback, Codex P2).  Pass `force: true` for ad-hoc
+   * operator runs that must bypass the cadence floor — mirrors the
+   * pattern used by other maintenance MCP tools.
+   *
+   * `force` deliberately does NOT bypass the master
+   * `patternReinforcementEnabled` flag (PR #730 review feedback,
+   * Cursor Medium).  Operators who have explicitly disabled the
+   * feature must not have their corpus mutated by an MCP tool call —
+   * the only way to run the job is to enable the feature in config.
+   */
+  async runPatternReinforcement(options = {}) {
+    const cadenceKey = options.namespace ?? "";
+    if (!this.config.patternReinforcementEnabled) {
+      return { ran: false, skippedReason: "disabled", namespace: cadenceKey };
+    }
+    const cadence = this.config.patternReinforcementCadenceMs;
+    const lastAt = this.lastPatternReinforcementAtByNs.get(cadenceKey);
+    if (!options.force && cadence > 0 && lastAt !== void 0 && Date.now() - lastAt < cadence) {
+      return { ran: false, skippedReason: "cadence", namespace: cadenceKey };
+    }
+    const storage = options.namespace ? await this.getStorage(options.namespace) : this.storage;
+    const result = await runPatternReinforcement(storage, {
+      categories: this.config.patternReinforcementCategories,
+      minCount: this.config.patternReinforcementMinCount
+    });
+    this.lastPatternReinforcementAtByNs.set(cadenceKey, Date.now());
+    log.debug(
+      `pattern reinforcement [ns=${cadenceKey || "(default)"}]: clusters=${result.clustersFound} canonicalsUpdated=${result.canonicalsUpdated} duplicatesSuperseded=${result.duplicatesSuperseded}`
+    );
+    return { ran: true, result, namespace: cadenceKey };
+  }
+  async autoRegisterGraphEdgeDecayCron() {
+    const home = resolveHomeDir();
+    const jobsPath = path6.join(home, ".openclaw", "cron", "jobs.json");
+    try {
+      if (!existsSync2(jobsPath)) {
+        log.debug("graph edge decay cron: jobs.json not found, skipping auto-register");
+        return;
+      }
+      const scheduleExpr = graphEdgeDecayCadenceToCronExpr(this.config.graphEdgeDecayCadenceMs);
+      const created = await ensureGraphEdgeDecayCron(jobsPath, {
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        scheduleExpr
+      });
+      if (created.created) {
+        log.info(`graph edge decay cron auto-registered (${created.jobId}, ${scheduleExpr})`);
+      } else {
+        log.debug("graph edge decay cron already exists, skipping auto-register");
+      }
+    } catch (err) {
+      log.debug(`graph edge decay cron auto-register error: ${err}`);
+    }
+  }
+  async runLiveConnectors(options = {}) {
+    return runLiveConnectorsOnce({
+      memoryDir: this.config.memoryDir,
+      connectors: this.config.connectors,
+      force: options.force === true,
+      abortSignal: options.abortSignal,
+      ingestDocuments: async (docs) => {
+        const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const turns = docs.map((doc) => ({
+          role: "assistant",
+          content: doc.title ? `# ${doc.title}
+
+${doc.content}` : doc.content,
+          timestamp: fetchedAt
+        }));
+        await this.ingestBulkImportBatch(turns);
+      }
+    });
+  }
   async applyBehaviorRuntimePolicy(state) {
     const result = await this.policyRuntime.applyFromBehaviorState(state);
     this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
@@ -4537,15 +4857,15 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path7.isAbsolute(rel) ? rel : path7.join(this.config.workspaceDir, rel);
+        const abs = path6.isAbsolute(rel) ? rel : path6.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile4(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path7.join(
+            const archiveDir = path6.join(
               this.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path7.basename(abs);
+            const base = path6.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -4570,8 +4890,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path7.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir5(path7.dirname(fp), { recursive: true });
+        const fp = path6.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir5(path6.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -4608,7 +4928,28 @@ var Orchestrator = class _Orchestrator {
   async runSemanticConsolidationNow(options) {
     return this.runSemanticConsolidation({ ...options, force: true });
   }
+  async runDeepSleepGovernanceNow(options) {
+    const targetStorage = options?.storage ?? this.storage;
+    const { runMemoryGovernance } = await import("./memory-governance-KG52RITE.js");
+    const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-LR2NBAZE.js");
+    const govResult = await runMemoryGovernance({
+      memoryDir: targetStorage.dir,
+      mode: options?.dryRun === true ? "shadow" : "apply"
+    });
+    if (options?.dryRun !== true) {
+      try {
+        await this.processEntitySynthesisQueue(
+          this.namespaceFromStorageDir(targetStorage.dir),
+          5
+        );
+      } catch (error) {
+        log.debug(`deep-sleep governance: entity synthesis refresh failed after apply: ${error}`);
+      }
+    }
+    return summarizeGovernanceResultForDreams(govResult, options?.dryRun === true);
+  }
   async runSemanticConsolidation(options) {
+    const targetStorage = options?.storage ?? this.storage;
     const result = {
       clustersFound: 0,
       memoriesConsolidated: 0,
@@ -4621,7 +4962,7 @@ var Orchestrator = class _Orchestrator {
       return result;
     }
     log.info("[semantic-consolidation] starting run");
-    const allMemories = await this.storage.readAllMemories();
+    const allMemories = await targetStorage.readAllMemories();
     if (allMemories.length < 10) {
       log.debug("[semantic-consolidation] too few memories, skipping");
       return result;
@@ -4724,10 +5065,10 @@ var Orchestrator = class _Orchestrator {
         const derivedFromEntries = [];
         for (const m of cluster.memories) {
           if (!m.path) continue;
-          const entry = await this.storage.snapshotForProvenance(m.path);
+          const entry = await targetStorage.snapshotForProvenance(m.path);
           if (entry) derivedFromEntries.push(entry);
         }
-        const canonicalId = await this.storage.writeMemory(
+        const canonicalId = await targetStorage.writeMemory(
           newest.frontmatter.category,
           canonicalContent,
           {
@@ -4746,7 +5087,7 @@ var Orchestrator = class _Orchestrator {
         );
         result.memoriesConsolidated++;
         for (const m of cluster.memories) {
-          const archiveResult = await this.storage.archiveMemory(m, {
+          const archiveResult = await targetStorage.archiveMemory(m, {
             actor: "semantic-consolidation",
             reasonCode: "semantic-consolidation",
             relatedMemoryIds: [canonicalId]
@@ -4765,7 +5106,7 @@ var Orchestrator = class _Orchestrator {
             await this.embeddingFallback.removeFromIndex(m.frontmatter.id);
             if (this.config.queryAwareIndexingEnabled && m.path && m.frontmatter?.created) {
               deindexMemory(
-                this.config.memoryDir,
+                targetStorage.dir,
                 m.path,
                 m.frontmatter.created,
                 m.frontmatter.tags ?? []
@@ -4797,13 +5138,39 @@ var Orchestrator = class _Orchestrator {
     try {
       await materializeAfterSemanticConsolidation({
         config: this.config,
-        memoryDir: this.config.memoryDir
+        memoryDir: targetStorage.dir
       });
     } catch (err) {
       log.warn(
         `[semantic-consolidation] Codex materialize post-hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
       );
     }
+    if (this.config.peerProfileReasonerEnabled) {
+      try {
+        const { runPeerProfileReasoner } = await import("./peers-6OSQ3NK6.js");
+        const llm2 = new FallbackLlmClient2(this.config.gatewayConfig);
+        const peerResult = await runPeerProfileReasoner({
+          memoryDir: targetStorage.dir,
+          enabled: true,
+          llm: llm2,
+          model: this.config.peerProfileReasonerModel,
+          minInteractions: this.config.peerProfileReasonerMinInteractions,
+          maxFieldsPerRun: this.config.peerProfileReasonerMaxFieldsPerRun,
+          log: {
+            debug: (msg) => log.debug(msg),
+            info: (msg) => log.info(msg),
+            warn: (msg) => log.warn(msg)
+          }
+        });
+        log.info(
+          `[peer-profile-reasoner] complete: peers=${peerResult.peersConsidered}, processed=${peerResult.peersProcessed}, fields=${peerResult.fieldsApplied}`
+        );
+      } catch (err) {
+        log.warn(
+          `[peer-profile-reasoner] post-consolidation hook failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
     return result;
   }
   async waitForExtractionIdle(timeoutMs = 6e4) {
@@ -4983,16 +5350,16 @@ ${evidenceText}`
     const datesToScan = [yesterday, utcToday].filter(
       (v, i, a) => a.indexOf(v) === i
     );
-    const factsBaseDir = path7.join(storage.dir, "facts");
+    const factsBaseDir = path6.join(storage.dir, "facts");
     const MAX_CHARS = 1e5;
     const facts = [];
     for (const date of datesToScan) {
-      const factsDir = path7.join(factsBaseDir, date);
+      const factsDir = path6.join(factsBaseDir, date);
       try {
         const entries = await readdir3(factsDir, { withFileTypes: true });
         for (const entry of entries) {
           if (!entry.name.endsWith(".md")) continue;
-          const fullPath = path7.join(factsDir, entry.name);
+          const fullPath = path6.join(factsDir, entry.name);
           try {
             const raw = await readFile4(fullPath, "utf-8");
             const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
@@ -5008,7 +5375,7 @@ ${evidenceText}`
             facts.push({
               path: fullPath,
               frontmatter: {
-                id: fm.id || path7.basename(entry.name, ".md"),
+                id: fm.id || path6.basename(entry.name, ".md"),
                 category: fm.category || "fact",
                 created: fm.created || "unknown",
                 updated: fm.updated || fm.created || "unknown",
@@ -5029,13 +5396,13 @@ ${evidenceText}`
       (a, b) => a.frontmatter.created < b.frontmatter.created ? -1 : 1
     );
     const hourlySummaries = [];
-    const hourlyBaseDir = path7.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path6.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 = path7.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path6.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile4(summaryFile, "utf-8");
             if (raw.trim().length > 0) {
@@ -5133,7 +5500,7 @@ ${evidenceText}`
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path7.join(
+    const snapshotPath = path6.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -5172,7 +5539,7 @@ ${evidenceText}`
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path7.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path6.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -5205,7 +5572,7 @@ ${evidenceText}`
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path7.join(
+    const snapshotPath = path6.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -5266,9 +5633,10 @@ ${evidenceText}`
       `Seed paths (${snapshot.seedCount}):`,
       ...snapshot.seeds.map((p) => `- ${p}`),
       `Expanded paths (${snapshot.expandedCount}, showing ${expanded.length}):`,
-      ...expanded.map(
-        (e) => `- ${e.path} (score=${e.score.toFixed(3)}, ns=${e.namespace}, seed=${e.seed || "unknown"}, hop=${e.hopDepth}, w=${e.decayedWeight.toFixed(3)}, type=${e.graphType})`
-      ),
+      ...expanded.map((e) => {
+        const confLabel = typeof e.edgeConfidence === "number" && Number.isFinite(e.edgeConfidence) ? e.edgeConfidence.toFixed(2) : "n/a";
+        return `- ${e.path} (score=${e.score.toFixed(3)}, ns=${e.namespace}, seed=${e.seed || "unknown"}, hop=${e.hopDepth}, w=${e.decayedWeight.toFixed(3)}, type=${e.graphType}, conf=${confLabel})`;
+      }),
       `Final ranked results (${snapshot.finalResults?.length ?? 0}, showing ${finalResults.length}):`,
       ...finalResults.map(
         (entry) => `- ${entry.path} (score=${entry.score.toFixed(3)}, sources=${entry.sourceLabels.join(",") || "baseline"})`
@@ -5357,7 +5725,7 @@ ${r.snippet.trim()}
       const entries = await readdir3(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path7.join(dir, entry.name);
+        const fullPath = path6.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -5612,6 +5980,11 @@ ${r.snippet.trim()}
         log.warn("recall: init gate timed out \u2014 proceeding without full init");
       }
     }
+    if (this.config.secureStoreEnabled && !this.storage.isSecureStoreUnlocked()) {
+      const lockedMsg = "[secure-store locked] Memory store is encrypted and locked. Run `remnic secure-store unlock` then restart the daemon to decrypt.";
+      log.warn("recall blocked: secure-store is locked");
+      return lockedMsg;
+    }
     try {
       const recallPromise = this.recallInternal(prompt, sessionKey, {
         ...options,
@@ -6234,17 +6607,18 @@ ${r.snippet.trim()}
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path7.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path6.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
-        this.config.maxGraphTraversalSteps
+        this.config.maxGraphTraversalSteps,
+        options.includeLowConfidence === true ? { includeLowConfidence: true } : void 0
       );
       if (expanded.length === 0) continue;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path7.resolve(storage.dir, candidate.path);
+        const memoryPath = path6.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -6268,10 +6642,15 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path7.resolve(storage.dir, candidate.seed),
+          seed: path6.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
-          graphType: candidate.graphType
+          graphType: candidate.graphType,
+          // Issue #681 PR 3/3 — surface the per-edge confidence used for
+          // PageRank weighting / floor pruning so downstream observability
+          // (recall_xray, memory_graph_explain) can attribute ranking and
+          // pruning decisions to specific edges.
+          edgeConfidence: candidate.edgeConfidence
         });
       }
     }
@@ -6284,12 +6663,12 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path7.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir5(path7.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path6.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -6323,12 +6702,12 @@ ${r.snippet.trim()}
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path7.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir5(path7.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path6.dirname(snapshotPath), { recursive: true });
       await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6340,12 +6719,12 @@ ${r.snippet.trim()}
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path7.join(
+      const snapshotPath = path6.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir5(path7.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path6.dirname(snapshotPath), { recursive: true });
       await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6360,8 +6739,8 @@ ${r.snippet.trim()}
       const stateDir = await this.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path7.join(stateDir, "last_intent.json");
-      await mkdir5(path7.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path6.join(stateDir, "last_intent.json");
+      await mkdir5(path6.dirname(snapshotPath), { recursive: true });
       await writeFile4(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -6373,12 +6752,12 @@ ${r.snippet.trim()}
   }
   async resolveStateDirForNamespace(namespace) {
     if (!this.config.namespacesEnabled) {
-      return path7.join(this.config.memoryDir, "state");
+      return path6.join(this.config.memoryDir, "state");
     }
     if (namespace !== this.config.defaultNamespace) {
-      return path7.join(this.config.memoryDir, "namespaces", namespace, "state");
+      return path6.join(this.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path7.join(
+    const candidate = path6.join(
       this.config.memoryDir,
       "namespaces",
       this.config.defaultNamespace
@@ -6386,11 +6765,11 @@ ${r.snippet.trim()}
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path7.join(candidate, "state");
+        return path6.join(candidate, "state");
       }
     } catch {
     }
-    return path7.join(this.config.memoryDir, "state");
+    return path6.join(this.config.memoryDir, "state");
   }
   buildGraphRecallRankedResults(results, sourceLabelResolver, limit = 64) {
     return results.slice(0, limit).map((result) => ({
@@ -6424,12 +6803,12 @@ ${r.snippet.trim()}
     return Math.max(0, Math.floor(value));
   }
   appendRecallSection(sectionBuckets, sectionId, content) {
-    if (!this.isRecallSectionEnabled(sectionId)) return;
+    if (!this.isRecallSectionEnabled(sectionId)) return false;
     const trimmed = content.trim();
-    if (trimmed.length === 0) return;
+    if (trimmed.length === 0) return false;
     const maxChars = this.getRecallSectionMaxChars(sectionId);
     let finalContent = trimmed;
-    if (maxChars === 0) return;
+    if (maxChars === 0) return false;
     if (typeof maxChars === "number" && finalContent.length > maxChars) {
       finalContent = `${finalContent.slice(0, maxChars)}
 
@@ -6439,6 +6818,7 @@ ${r.snippet.trim()}
     const existing = sectionBuckets.get(sectionId) ?? [];
     existing.push(finalContent);
     sectionBuckets.set(sectionId, existing);
+    return true;
   }
   truncateRecallSectionToBudget(content, maxChars) {
     if (maxChars <= 0) return "";
@@ -6564,6 +6944,11 @@ ${r.snippet.trim()}
   }
   async recallInternal(prompt, sessionKey, options = {}) {
     const recallStart = Date.now();
+    let asOfMs;
+    if (typeof options.asOf === "string" && options.asOf.length > 0) {
+      const parsed = Date.parse(options.asOf);
+      if (Number.isFinite(parsed)) asOfMs = parsed;
+    }
     const timings = {};
     const profileTraceId = this.profiler.startTrace("recall", sessionKey, {
       qmdEnabled: this.config.qmdEnabled,
@@ -6638,6 +7023,7 @@ ${r.snippet.trim()}
       let recalledMemoryCount = 0;
       let recalledMemoryIds = [];
       let recalledMemoryPaths = [];
+      let xrayRecalledResults = [];
       const xrayBranchPoolSize = {
         hot_qmd: 0,
         hot_embedding: 0,
@@ -6750,7 +7136,7 @@ ${r.snippet.trim()}
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path7.sep).join("/");
+        const normalizedPath = resultPath.split(path6.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -6974,6 +7360,71 @@ ${trimmedBody}`;
         });
         return profile2 || null;
       })();
+      let peerProfileXrayAnnotation = void 0;
+      const peerProfileRecallPromise = (async () => {
+        if (!this.config.peerProfileRecallEnabled) return null;
+        if (this.config.peerProfileRecallMaxFields <= 0) return null;
+        const peerId = this.getPeerIdForSession(sessionKey);
+        if (!peerId) return null;
+        const t0 = Date.now();
+        try {
+          const { readPeerProfile: _readPeerProfile } = await import("./peers-6OSQ3NK6.js");
+          const peerProfile = await _readPeerProfile(this.config.memoryDir, peerId);
+          recordRecallSectionMetric({
+            section: "peerProfile",
+            priority: "core",
+            durationMs: Date.now() - t0,
+            deadlineMs: recallSectionDeadlineMs,
+            source: "fresh",
+            success: true
+          });
+          if (!peerProfile) {
+            peerProfileXrayAnnotation = null;
+            return null;
+          }
+          const allFields = Object.entries(peerProfile.fields);
+          if (allFields.length === 0) {
+            peerProfileXrayAnnotation = null;
+            return null;
+          }
+          const fieldsByRecency = allFields.map(([key, value]) => {
+            const prov = peerProfile.provenance[key];
+            let latestMs = 0;
+            if (Array.isArray(prov) && prov.length > 0) {
+              for (const p of prov) {
+                if (typeof p.observedAt === "string") {
+                  const parsed = Date.parse(p.observedAt);
+                  if (Number.isFinite(parsed) && parsed > latestMs) {
+                    latestMs = parsed;
+                  }
+                }
+              }
+            }
+            return { key, value, latestMs };
+          }).sort((a, b) => {
+            if (b.latestMs !== a.latestMs) return b.latestMs - a.latestMs;
+            return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+          });
+          const capped = fieldsByRecency.slice(0, this.config.peerProfileRecallMaxFields);
+          const lines = capped.map(({ key, value }) => `**${key}**: ${value}`);
+          peerProfileXrayAnnotation = { peerId, fieldsInjected: capped.length };
+          return `## Peer Profile
+
+${lines.join("\n\n")}`;
+        } catch (err) {
+          recordRecallSectionMetric({
+            section: "peerProfile",
+            priority: "core",
+            durationMs: Date.now() - t0,
+            deadlineMs: recallSectionDeadlineMs,
+            source: "fresh",
+            success: false,
+            timing: `error(${err instanceof Error ? err.message : String(err)})`
+          });
+          log.debug(`peer profile recall injection failed (non-fatal): ${err}`);
+          return null;
+        }
+      })();
       const identityContinuityPromise = (async () => {
         if (!this.isRecallSectionEnabled(
           "identity-continuity",
@@ -7963,11 +8414,11 @@ ${formatted}`;
         if (!this.config.compactionResetEnabled) return null;
         const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path7.join(
+        const signalPath = path6.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path7.join(workspaceDir, "BOOT.md");
+        const bootPath = path6.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat3(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -8269,7 +8720,8 @@ ${formatted}`;
         transcriptSection,
         compactionSection,
         summariesSection,
-        conversationRecallSection
+        conversationRecallSection,
+        peerProfileSection
       ] = await raceRecallAbort(
         Promise.all(
           [
@@ -8291,7 +8743,8 @@ ${formatted}`;
             ["transcript", transcriptPromise],
             ["compaction", compactionPromise],
             ["summaries", summariesPromise],
-            ["convRecall", conversationRecallPromise]
+            ["convRecall", conversationRecallPromise],
+            ["peerProfile", peerProfileRecallPromise]
           ].map(
             ([name, p]) => p.then((v) => {
               log.debug(
@@ -8382,6 +8835,16 @@ ${formatted}`;
 
 ${profile}`
         );
+      if (peerProfileSection) {
+        const peerSectionAppended = this.appendRecallSection(
+          sectionBuckets,
+          "peer-profile",
+          peerProfileSection
+        );
+        if (!peerSectionAppended) {
+          peerProfileXrayAnnotation = null;
+        }
+      }
       if (calibrationSection) {
         this.appendRecallSection(
           sectionBuckets,
@@ -8609,7 +9072,8 @@ ${tmtNode.summary}`
               } = await this.expandResultsViaGraph({
                 memoryResults,
                 recallNamespaces,
-                recallResultLimit
+                recallResultLimit,
+                ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
               });
               graphSnapshotStatus = "completed";
               graphDecisionStatus = "completed";
@@ -8663,7 +9127,9 @@ ${tmtNode.summary}`
         memoryResults = await this.boostSearchResults(
           memoryResults,
           recallNamespaces,
-          retrievalQuery
+          retrievalQuery,
+          void 0,
+          { asOfMs }
         );
         if (this.config.rerankEnabled && this.config.rerankProvider === "local") {
           const ranked = await rerankLocalOrNoop({
@@ -8785,6 +9251,7 @@ ${tmtNode.summary}`
           });
           recalledMemoryIds = this.extractMemoryIdsFromResults(memoryResults);
           recalledMemoryPaths = memoryResults.map((result) => result.path).filter(Boolean);
+          xrayRecalledResults = memoryResults;
           impressionRecorded = true;
         } else if (!confidenceGateRejected) {
           const queryAwarePrefilter = await queryAwarePrefilterPromise;
@@ -8808,7 +9275,9 @@ ${tmtNode.summary}`
           const boostedScoped = await this.boostSearchResults(
             scopedCandidates,
             recallNamespaces,
-            retrievalQuery
+            retrievalQuery,
+            void 0,
+            { asOfMs }
           );
           xrayBranchPoolSize.hot_embedding = Math.max(
             xrayBranchPoolSize.hot_embedding,
@@ -8843,6 +9312,7 @@ ${tmtNode.summary}`
             });
             recalledMemoryIds = this.extractMemoryIdsFromResults(scoped);
             recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
+            xrayRecalledResults = scoped;
             impressionRecorded = true;
           } else {
             const longTerm = await this.applyColdFallbackPipeline({
@@ -8852,7 +9322,9 @@ ${tmtNode.summary}`
               recallMode,
               queryAwarePrefilter,
               abortSignal: options.abortSignal,
-              xrayPoolSizeSink: xrayColdPoolSink
+              xrayPoolSizeSink: xrayColdPoolSink,
+              asOfMs,
+              ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
             });
             if (longTerm.length > 0) {
               if (shouldPersistGraphSnapshot) {
@@ -8877,6 +9349,7 @@ ${tmtNode.summary}`
               });
               recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
               recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
+              xrayRecalledResults = longTerm;
               impressionRecorded = true;
             }
           }
@@ -8934,7 +9407,9 @@ ${tmtNode.summary}`
         const boostedScoped = await this.boostSearchResults(
           scopedCandidates,
           recallNamespaces,
-          retrievalQuery
+          retrievalQuery,
+          void 0,
+          { asOfMs }
         );
         xrayBranchPoolSize.hot_embedding = Math.max(
           xrayBranchPoolSize.hot_embedding,
@@ -8969,6 +9444,7 @@ ${tmtNode.summary}`
           });
           recalledMemoryIds = this.extractMemoryIdsFromResults(scoped);
           recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
+          xrayRecalledResults = scoped;
           impressionRecorded = true;
         } else {
           const memories = await this.readAllMemoriesForNamespaces(recallNamespaces);
@@ -8977,12 +9453,14 @@ ${tmtNode.summary}`
               enabled: this.config.temporalSupersessionEnabled,
               includeInRecall: this.config.temporalSupersessionIncludeInRecall
             };
+            const asOfActive = typeof asOfMs === "number" && Number.isFinite(asOfMs);
             const activeMemories = memories.filter(
               (m) => {
                 if (isArtifactMemoryPath(m.path)) return false;
                 const status = m.frontmatter.status;
                 if (!status || status === "active") return true;
                 if (status === "superseded") {
+                  if (asOfActive) return true;
                   return !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions);
                 }
                 return false;
@@ -8999,7 +9477,9 @@ ${tmtNode.summary}`
                 recallMode,
                 queryAwarePrefilter,
                 abortSignal: options.abortSignal,
-                xrayPoolSizeSink: xrayColdPoolSink
+                xrayPoolSizeSink: xrayColdPoolSink,
+                asOfMs,
+                ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
               });
               if (longTerm.length > 0) {
                 recallSource = "cold_fallback";
@@ -9018,6 +9498,7 @@ ${tmtNode.summary}`
                 });
                 recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
                 recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
+                xrayRecalledResults = longTerm;
                 impressionRecorded = true;
               }
             } else {
@@ -9039,7 +9520,8 @@ ${tmtNode.summary}`
                 recentAsResults,
                 recallNamespaces,
                 retrievalQuery,
-                preloadedMap
+                preloadedMap,
+                { asOfMs }
               )).sort((a, b) => b.score - a.score);
               xrayBranchPoolSize.recent_scan = Math.max(
                 xrayBranchPoolSize.recent_scan,
@@ -9074,6 +9556,7 @@ ${tmtNode.summary}`
                 });
                 recalledMemoryIds = this.extractMemoryIdsFromResults(recent);
                 recalledMemoryPaths = recent.map((result) => result.path).filter(Boolean);
+                xrayRecalledResults = recent;
                 impressionRecorded = true;
               } else {
                 const longTerm = await this.applyColdFallbackPipeline({
@@ -9083,7 +9566,9 @@ ${tmtNode.summary}`
                   recallMode,
                   queryAwarePrefilter,
                   abortSignal: options.abortSignal,
-                  xrayPoolSizeSink: xrayColdPoolSink
+                  xrayPoolSizeSink: xrayColdPoolSink,
+                  asOfMs,
+                  ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
                 });
                 if (longTerm.length > 0) {
                   if (shouldPersistGraphSnapshot) {
@@ -9108,6 +9593,7 @@ ${tmtNode.summary}`
                   });
                   recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
                   recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
+                  xrayRecalledResults = longTerm;
                   impressionRecorded = true;
                 }
               }
@@ -9120,7 +9606,9 @@ ${tmtNode.summary}`
               recallMode,
               queryAwarePrefilter,
               abortSignal: options.abortSignal,
-              xrayPoolSizeSink: xrayColdPoolSink
+              xrayPoolSizeSink: xrayColdPoolSink,
+              asOfMs,
+              ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
             });
             if (longTerm.length > 0) {
               if (shouldPersistGraphSnapshot) {
@@ -9145,6 +9633,7 @@ ${tmtNode.summary}`
               });
               recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
               recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
+              xrayRecalledResults = longTerm;
               impressionRecorded = true;
             }
           }
@@ -9305,15 +9794,25 @@ _Context: ${topQuestion.context}_`
             const match = p.match(/([^/]+)\.md$/);
             return match ? match[1] ?? null : null;
           };
+          const xrayResultByPath = new Map(
+            xrayRecalledResults.map((xr) => [xr.path, xr])
+          );
           const results = [];
           for (const recalledPath of recalledMemoryPaths) {
             const derivedId = idFromPath(recalledPath);
             if (!derivedId) continue;
+            const xrayResult = xrayResultByPath.get(recalledPath);
+            const scoreDecomposition = {
+              final: xrayResult?.score ?? 0
+            };
+            if (xrayResult?.explain?.reinforcementBoost !== void 0 && xrayResult.explain.reinforcementBoost > 0) {
+              scoreDecomposition.reinforcementBoost = xrayResult.explain.reinforcementBoost;
+            }
             results.push({
               memoryId: derivedId,
               path: recalledPath,
               servedBy,
-              scoreDecomposition: { final: 0 },
+              scoreDecomposition,
               admittedBy: []
             });
           }
@@ -9359,7 +9858,14 @@ _Context: ${topQuestion.context}_`
             },
             sessionKey,
             namespace: selfNamespace,
-            traceId
+            traceId,
+            // Issue #679 completion: record peer-profile injection in the
+            // xray snapshot. peerProfileXrayAnnotation is set inside
+            // peerProfileRecallPromise when injection actually occurred,
+            // and stays null otherwise. By the time xray capture runs,
+            // phase-1 parallel work is complete so the annotation is
+            // guaranteed to be populated.
+            peerProfileInjection: peerProfileXrayAnnotation
           });
         } catch (err) {
           log.debug(`x-ray capture failed: ${err}`);
@@ -10087,7 +10593,7 @@ ${normalized}`).digest("hex");
     );
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path7.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path6.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -10653,6 +11159,7 @@ ${normalized}`).digest("hex");
       let writeCategory = fact.category;
       let targetStorage = storage;
       let routedRuleId;
+      let routedNamespaceExplicit = false;
       if (routeRules.length > 0) {
         try {
           const routeText = `${fact.category} ${fact.tags.join(" ")} ${fact.content}`;
@@ -10663,6 +11170,7 @@ ${normalized}`).digest("hex");
               writeCategory = selected.target.category;
             }
             if (selected.target.namespace) {
+              routedNamespaceExplicit = true;
               targetStorage = await this.storageRouter.storageFor(
                 selected.target.namespace
               );
@@ -10674,6 +11182,23 @@ ${normalized}`).digest("hex");
           );
         }
       }
+      if (this.config.extractionScopeClassificationEnabled && this.config.namespacesEnabled && fact.scope === "global" && !routedNamespaceExplicit) {
+        const currentNs = this.namespaceFromStorageDir(targetStorage.dir);
+        if (currentNs !== this.config.sharedNamespace) {
+          try {
+            targetStorage = await this.storageRouter.storageFor(
+              this.config.sharedNamespace
+            );
+            log.debug(
+              `scope-routing: fact "${fact.content.slice(0, 60)}\u2026" routed to shared namespace (scope=global)`
+            );
+          } catch (scopeRouteErr) {
+            log.warn(
+              `scope-routing: failed to resolve shared namespace storage; writing to session namespace (fail-open): ${scopeRouteErr}`
+            );
+          }
+        }
+      }
       const canonicalContentForHash = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
       const contentHashDedupKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalContentForHash;
       if (this.contentHashIndex && this.contentHashIndex.has(contentHashDedupKey)) {
@@ -11260,7 +11785,7 @@ ${normalized}`).digest("hex");
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path7.relative(storage.dir, m.path);
+            const rel = path6.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -11327,8 +11852,7 @@ ${normalized}`).digest("hex");
           ])
         )
       ) : await storage.readAllMemories();
-      const isActive = (m) => !m.frontmatter.status || m.frontmatter.status === "active";
-      const pool = needsFullRebuild ? allMemories.filter(isActive) : (() => {
+      const pool = needsFullRebuild ? allMemories.filter((m) => isActiveMemoryStatus(m.frontmatter.status)) : (() => {
         const idSet = new Set(persistedIds);
         return allMemories.filter((m) => idSet.has(m.frontmatter.id));
       })();
@@ -11514,24 +12038,54 @@ ${normalized}`).digest("hex");
     }
     if (this.config.lifecyclePolicyEnabled) {
       try {
+        const lightSleepStartedAt = (/* @__PURE__ */ new Date()).toISOString();
         const lifecycleCorpus = await this.storage.readAllMemories();
         await this.runLifecyclePolicyPass(lifecycleCorpus);
+        await this.recordScheduledDreamsPhaseRun(
+          "lightSleep",
+          lifecycleCorpus.length,
+          `scheduled lifecycle policy pass assessed ${lifecycleCorpus.length} memories`,
+          {
+            startedAt: lightSleepStartedAt,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        );
       } catch (err) {
         log.warn(`lifecycle policy pass failed (ignored): ${err}`);
       }
     }
     await this.runCompressionGuidelineLearningPass();
-    await this.runTierMigrationCycle(this.storage, "maintenance");
-    allMemories = await this.storage.readAllMemories();
-    if (this.config.factArchivalEnabled) {
-      const archived = await this.runFactArchival(allMemories);
-      if (archived > 0) {
-        log.info(`archived ${archived} old low-importance facts`);
+    try {
+      const deepSleepStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.runTierMigrationCycle(this.storage, "maintenance");
+      allMemories = await this.storage.readAllMemories();
+      if (this.config.factArchivalEnabled) {
+        const archived = await this.runFactArchival(allMemories);
+        if (archived > 0) {
+          log.info(`archived ${archived} old low-importance facts`);
+        }
+      }
+      await this.recordScheduledDreamsPhaseRun(
+        "deepSleep",
+        allMemories.length,
+        `scheduled deep-sleep maintenance assessed ${allMemories.length} memories`,
+        {
+          startedAt: deepSleepStartedAt,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      );
+    } catch (err) {
+      log.warn(`deep-sleep maintenance pass failed (ignored): ${err}`);
+      try {
+        allMemories = await this.storage.readAllMemories();
+      } catch (readErr) {
+        log.warn(`deep-sleep maintenance recovery read failed: ${readErr}`);
+        throw err;
       }
     }
     if (this.config.semanticConsolidationEnabled) {
       try {
-        const stateFilePath = path7.join(
+        const stateFilePath = path6.join(
           this.config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -11553,15 +12107,33 @@ ${normalized}`).digest("hex");
         } catch {
         }
         if (shouldRun) {
+          const remStartedAt = (/* @__PURE__ */ new Date()).toISOString();
           const semResult = await this.runSemanticConsolidation();
+          let remItemsProcessed = allMemories.length;
+          try {
+            allMemories = await this.storage.readAllMemories();
+            remItemsProcessed = allMemories.length;
+          } catch (err) {
+            log.warn(
+              `[semantic-consolidation] post-run telemetry refresh failed (non-fatal): ${err}`
+            );
+          }
+          await this.recordScheduledDreamsPhaseRun(
+            "rem",
+            remItemsProcessed,
+            `scheduled REM consolidation found ${semResult.clustersFound} clusters`,
+            {
+              startedAt: remStartedAt,
+              completedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          );
           if (semResult.memoriesArchived > 0) {
             log.info(
               `[semantic-consolidation] archived ${semResult.memoriesArchived} memories during maintenance`
             );
-            allMemories = await this.storage.readAllMemories();
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path7.join(this.config.memoryDir, "state");
+            const stateDir = path6.join(this.config.memoryDir, "state");
             await mkdir5(stateDir, { recursive: true });
             await writeFile4(
               stateFilePath,
@@ -11612,7 +12184,7 @@ ${normalized}`).digest("hex");
     if (this.config.temporalMemoryTreeEnabled) {
       try {
         const tmtEntries = allMemories.filter(
-          (m) => m.frontmatter.status !== "superseded" && m.frontmatter.status !== "archived"
+          (m) => m.frontmatter.status !== "superseded" && m.frontmatter.status !== "archived" && m.frontmatter.status !== "forgotten"
         ).map((m) => ({
           path: m.path,
           id: m.frontmatter.id,
@@ -11927,8 +12499,8 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         return 0;
     }
   }
-  async buildLifecycleActionPriors() {
-    const events = await this.storage.readMemoryActionEvents(1200);
+  async buildLifecycleActionPriors(storage = this.storage) {
+    const events = await storage.readMemoryActionEvents(1200);
     if (events.length === 0) return /* @__PURE__ */ new Map();
     const nowMs = Date.now();
     const windowMs = 14 * 24 * 60 * 60 * 1e3;
@@ -11965,7 +12537,28 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
     }
     return out;
   }
-  async runLifecyclePolicyPass(allMemories) {
+  async recordScheduledDreamsPhaseRun(phase, itemsProcessed, notes, timing = {}) {
+    try {
+      const { recordDreamsPhaseRun } = await import("./dreams-ledger-LR2NBAZE.js");
+      await recordDreamsPhaseRun({
+        memoryDir: this.storage.dir,
+        phase,
+        trigger: "scheduled",
+        itemsProcessed,
+        notes,
+        startedAt: timing.startedAt,
+        completedAt: timing.completedAt
+      });
+    } catch (error) {
+      log.debug(`dreams ledger scheduled ${phase} write failed (non-fatal): ${error}`);
+    }
+  }
+  async runLifecyclePolicyNow(storage = this.storage) {
+    const lifecycleCorpus = await storage.readAllMemories();
+    await this.runLifecyclePolicyPass(lifecycleCorpus, storage);
+    return { memoriesAssessed: lifecycleCorpus.length };
+  }
+  async runLifecyclePolicyPass(allMemories, storage = this.storage) {
     const now = /* @__PURE__ */ new Date();
     const nowIso = now.toISOString();
     const countsByState = {
@@ -11986,9 +12579,9 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
       archiveDecayThreshold: thresholds.archiveDecayThreshold,
       protectedCategories: this.config.lifecycleProtectedCategories
     };
-    const actionPriors = await this.buildLifecycleActionPriors();
+    const actionPriors = await this.buildLifecycleActionPriors(storage);
     for (const memory of allMemories) {
-      if (memory.frontmatter.status === "superseded") {
+      if (memory.frontmatter.status === "superseded" || memory.frontmatter.status === "forgotten") {
         continue;
       }
       evaluatedCount += 1;
@@ -12010,7 +12603,7 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
       const scoreDelta = Math.abs((prevHeat ?? -1) - decision.heatScore) + Math.abs((prevDecay ?? -1) - decision.decayScore);
       const shouldPersist = memory.frontmatter.lifecycleState !== nextState || memory.frontmatter.heatScore === void 0 || memory.frontmatter.decayScore === void 0 || memory.frontmatter.lastValidatedAt === void 0 || scoreDelta >= 0.01;
       if (!shouldPersist) continue;
-      const wrote = await this.storage.writeMemoryFrontmatter(memory, {
+      const wrote = await storage.writeMemoryFrontmatter(memory, {
         lifecycleState: nextState,
         heatScore: decision.heatScore,
         decayScore: decision.decayScore,
@@ -12035,12 +12628,12 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path7.join(
-      this.storage.dir,
+    const metricsPath = path6.join(
+      storage.dir,
       "state",
       "lifecycle-metrics.json"
     );
-    await mkdir5(path7.dirname(metricsPath), { recursive: true });
+    await mkdir5(path6.dirname(metricsPath), { recursive: true });
     await writeFile4(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
@@ -12102,7 +12695,7 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
    */
   async runSummarization(allMemories) {
     const activeMemories = allMemories.filter(
-      (m) => !m.frontmatter.status || m.frontmatter.status === "active"
+      (m) => isActiveMemoryStatus(m.frontmatter.status)
     );
     if (activeMemories.length < this.config.summarizationTriggerCount) {
       return;
@@ -12167,7 +12760,7 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
    */
   async runTopicExtraction(allMemories) {
     const activeMemories = allMemories.filter(
-      (m) => !m.frontmatter.status || m.frontmatter.status === "active"
+      (m) => isActiveMemoryStatus(m.frontmatter.status)
     );
     if (activeMemories.length === 0) return;
     const topics = extractTopics(
@@ -12567,7 +13160,7 @@ ${lines.join("\n\n")}`;
           nsMap = buildMemoryWorthCounterMap(memories);
           this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
         }
-        for (const [path8, c] of nsMap) counters.set(path8, c);
+        for (const [path7, c] of nsMap) counters.set(path7, c);
       } catch (err) {
         log.debug("memory-worth: failed to read namespace, skipping", {
           namespace: ns,
@@ -12738,12 +13331,12 @@ ${lines.join("\n\n")}`;
    */
   semanticDedupScopeFor(targetStorage) {
     if (!this.config.namespacesEnabled) return {};
-    const memoryDir = path7.resolve(this.config.memoryDir);
-    const storageDir = path7.resolve(targetStorage.dir);
+    const memoryDir = path6.resolve(this.config.memoryDir);
+    const storageDir = path6.resolve(targetStorage.dir);
     if (storageDir === memoryDir) {
       return { pathExcludePrefixes: ["namespaces/"] };
     }
-    let rel = path7.relative(memoryDir, storageDir);
+    let rel = path6.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`
@@ -12762,7 +13355,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path7.isAbsolute(hit.path) ? hit.path : path7.join(this.config.memoryDir, hit.path);
+      const fullPath = path6.isAbsolute(hit.path) ? hit.path : path6.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -12894,7 +13487,8 @@ ${lines.join("\n\n")}`;
       const { merged } = await this.expandResultsViaGraph({
         memoryResults: results,
         recallNamespaces: options.recallNamespaces,
-        recallResultLimit: options.recallResultLimit
+        recallResultLimit: options.recallResultLimit,
+        ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
       });
       results = merged;
     }
@@ -12903,7 +13497,7 @@ ${lines.join("\n\n")}`;
       options.recallNamespaces,
       options.prompt,
       void 0,
-      { allowLifecycleFiltered: true }
+      { allowLifecycleFiltered: true, asOfMs: options.asOfMs }
     );
     if (this.config.rerankEnabled && this.config.rerankProvider === "local") {
       const ranked = await rerankLocalOrNoop({
@@ -13077,12 +13671,17 @@ ${lines.join("\n\n")}`;
     let lifecycleFilteredCount = 0;
     let temporalSupersededFilteredCount = 0;
     let dedicatedSurfaceFilteredCount = 0;
+    let forgottenFilteredCount = 0;
     const boosted = [];
     const recencyWeight = this.effectiveRecencyWeight();
     for (const r of results) {
       const memory = memoryByPath.get(r.path);
       let score = r.score;
       if (memory) {
+        if (memory.frontmatter.status === "forgotten") {
+          forgottenFilteredCount += 1;
+          continue;
+        }
         if (options?.allowLifecycleFiltered !== true && shouldFilterLifecycleRecallCandidate(memory.frontmatter, {
           lifecyclePolicyEnabled: this.config.lifecyclePolicyEnabled,
           lifecycleFilterStaleEnabled: this.config.lifecycleFilterStaleEnabled
@@ -13090,10 +13689,28 @@ ${lines.join("\n\n")}`;
           lifecycleFilteredCount += 1;
           continue;
         }
-        if (shouldFilterSupersededFromRecall(memory.frontmatter, {
-          enabled: this.config.temporalSupersessionEnabled,
-          includeInRecall: this.config.temporalSupersessionIncludeInRecall
-        })) {
+        const asOfActive = typeof options?.asOfMs === "number" && Number.isFinite(options.asOfMs);
+        if (asOfActive) {
+          if (!isValidAsOf(memory.frontmatter, options.asOfMs)) {
+            temporalSupersededFilteredCount += 1;
+            continue;
+          }
+        } else if (
+          // Temporal supersession filter (issue #375): drop memories that
+          // a newer fact has retired, unless the caller opted in to history.
+          // NOTE: This check is intentionally independent of
+          // allowLifecycleFiltered (Finding A fix) — cold fallback sets
+          // allowLifecycleFiltered=true to include archived/retired
+          // candidates, but superseded memories must still be filtered
+          // unless temporalSupersessionIncludeInRecall is set.
+          // Skipped entirely when `as_of` is active (above branch); the
+          // half-open `[valid_at, invalid_at)` evaluation in isValidAsOf
+          // is the authoritative gate for historical recall.
+          shouldFilterSupersededFromRecall(memory.frontmatter, {
+            enabled: this.config.temporalSupersessionEnabled,
+            includeInRecall: this.config.temporalSupersessionIncludeInRecall
+          })
+        ) {
           temporalSupersededFilteredCount += 1;
           continue;
         }
@@ -13192,6 +13809,22 @@ ${lines.join("\n\n")}`;
           this.utilityRuntimeValues,
           lifecycleDelta >= 0 ? "boost" : "suppress"
         );
+        let reinforcementBoost = 0;
+        if (this.config.reinforcementRecallBoostEnabled && typeof memory.frontmatter.reinforcement_count === "number" && memory.frontmatter.reinforcement_count > 0) {
+          reinforcementBoost = Math.min(
+            memory.frontmatter.reinforcement_count * this.config.reinforcementRecallBoostWeight,
+            this.config.reinforcementRecallBoostMax
+          );
+          score += reinforcementBoost;
+        }
+        if (reinforcementBoost > 0) {
+          boosted.push({
+            ...r,
+            score,
+            explain: { ...r.explain ?? {}, reinforcementBoost }
+          });
+          continue;
+        }
       }
       boosted.push({ ...r, score });
     }
@@ -13210,6 +13843,11 @@ ${lines.join("\n\n")}`;
         `dedicated surface filter removed ${dedicatedSurfaceFilteredCount} dream/procedural candidates from generic recall`
       );
     }
+    if (forgottenFilteredCount > 0) {
+      log.debug(
+        `forgotten status filter removed ${forgottenFilteredCount} candidates from recall`
+      );
+    }
     return boosted.sort((a, b) => b.score - a.score);
   }
   /**
@@ -13260,7 +13898,9 @@ ${lines.join("\n\n")}`;
       const resultStorage = await this.storageRouter.storageFor(resultNamespace);
       const existingMemory = await resultStorage.getMemoryById(memoryId);
       if (!existingMemory) continue;
-      if (existingMemory.frontmatter.status === "superseded") continue;
+      if (existingMemory.frontmatter.status === "superseded" || existingMemory.frontmatter.status === "forgotten") {
+        continue;
+      }
       const verification = await this.extraction.verifyContradiction(
         { content, category },
         {
@@ -13324,7 +13964,7 @@ ${lines.join("\n\n")}`;
       if (resultNamespace !== namespaceScope) continue;
       const resultStorage = await this.storageRouter.storageFor(resultNamespace);
       const memory = await resultStorage.getMemoryById(memoryId);
-      if (memory && memory.frontmatter.status !== "superseded") {
+      if (memory && memory.frontmatter.status !== "superseded" && memory.frontmatter.status !== "forgotten") {
         candidates.push({
           id: memory.frontmatter.id,
           content: memory.content,
@@ -13352,8 +13992,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path7.resolve(storageDir);
-    const resolvedMemoryDir = path7.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path6.resolve(storageDir);
+    const resolvedMemoryDir = path6.resolve(this.config.memoryDir);
     if (resolvedStorageDir === resolvedMemoryDir)
       return this.config.defaultNamespace;
     const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
@@ -13394,9 +14034,6 @@ export {
   saveTaxonomy,
   getTaxonomyDir,
   getTaxonomyFilePath,
-  stableHash,
-  normalizeOriginUrl,
-  resolveGitContext,
   projectNamespaceName,
   branchNamespaceName,
   resolveCodingNamespaceOverlay,
@@ -13429,4 +14066,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-VYM3VWOF.js.map
+//# sourceMappingURL=chunk-IM3JSE73.js.map