@remnic/core 9.50.3 → 9.51.1

package/dist/{chunk-IK6X5QPO.js → chunk-ZHY5TMJG.js}

@@ -13,7 +13,7 @@ import {
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-75XOWNRS.js";
+} from "./chunk-OYESWJ43.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-Z54EM5YZ.js";
+} from "./chunk-MAXVH44E.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-YQ4IQ2GA.js";
+} from "./chunk-UT5BV5OG.js";
 import {
   SharedContextManager
 } from "./chunk-M23RF3LJ.js";
@@ -41,12 +41,6 @@ import {
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-SEF4IOFE.js";
-import {
-  TierMigrationExecutor
-} from "./chunk-YRFAYOFQ.js";
-import {
-  decideTierTransition
-} from "./chunk-S75M5ZRK.js";
 import {
   TmtBuilder
 } from "./chunk-ECZU5BJH.js";
@@ -59,6 +53,12 @@ import {
 import {
   CODEX_THREAD_KEY_PREFIX
 } from "./chunk-4EX5WZ4M.js";
+import {
+  TierMigrationExecutor
+} from "./chunk-YRFAYOFQ.js";
+import {
+  decideTierTransition
+} from "./chunk-S75M5ZRK.js";
 import {
   HourlySummarizer
 } from "./chunk-LLJMAULE.js";
@@ -69,6 +69,14 @@ import {
 import {
   SessionObserverState
 } from "./chunk-QFN4U7AG.js";
+import {
+  applyRuntimeRetrievalPolicy
+} from "./chunk-5IZL4DCV.js";
+import {
+  RerankCache,
+  reorderByRankedKeys,
+  rerankLocalOrNoop
+} from "./chunk-LUDXM7MD.js";
 import {
   buildResponseGuidanceRecallSection,
   shouldRecallResponseGuidance
@@ -94,26 +102,12 @@ import {
   recencyWindowFromPrompt,
   resolvePromptTagPrefilterAsync
 } from "./chunk-ZOKZIR5K.js";
-import {
-  applyRuntimeRetrievalPolicy
-} from "./chunk-5IZL4DCV.js";
 import {
   findUnresolvedEntityRefs
 } from "./chunk-X7XN6YU4.js";
 import {
   RelevanceStore
 } from "./chunk-KATEWTQJ.js";
-import {
-  RerankCache,
-  reorderByRankedKeys,
-  rerankLocalOrNoop
-} from "./chunk-LUDXM7MD.js";
-import {
-  LastRecallStore,
-  RecallHandleHistoryStore,
-  TierMigrationStatusStore,
-  clampGraphRecallExpandedEntries
-} from "./chunk-BJYET5TX.js";
 import {
   dedupeResultsByNamespace,
   hasMemoryForResult,
@@ -125,6 +119,12 @@ import {
 import {
   reorderRecallResultsWithMmr
 } from "./chunk-YDBIWGNI.js";
+import {
+  LastRecallStore,
+  RecallHandleHistoryStore,
+  TierMigrationStatusStore,
+  clampGraphRecallExpandedEntries
+} from "./chunk-PRDJMOST.js";
 import {
   applyReasoningTraceBoost
 } from "./chunk-ZZTOURJI.js";
@@ -144,6 +144,12 @@ import {
 import {
   runLiveConnectorsOnce
 } from "./chunk-HTIIXNJQ.js";
+import {
+  classifyMemoryKind
+} from "./chunk-YAZNBMNF.js";
+import {
+  scoreEvidencePathDetail
+} from "./chunk-XXSOVESA.js";
 import {
   deriveHarmonicRecords,
   harmonicEntityReferenceMatches,
@@ -151,16 +157,13 @@ import {
   normalizedHarmonicEntityIdentity,
   persistHarmonicRecords
 } from "./chunk-GXSOUIA4.js";
-import {
-  classifyMemoryKind
-} from "./chunk-YAZNBMNF.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
 } from "./chunk-OH7QLI6W.js";
 import {
   ExtractionEngine
-} from "./chunk-S3AYIQCU.js";
+} from "./chunk-AXIDQG5A.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-WFLBP5GC.js";
@@ -180,11 +183,14 @@ import {
   judgeFactDurability,
   validateProcedureExtraction
 } from "./chunk-K2TDK7GG.js";
+import {
+  buildExplicitCueRecallSection
+} from "./chunk-TVIVY7KU.js";
 import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-SV3PSA7Y.js";
+} from "./chunk-CV6BBVYV.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -193,44 +199,41 @@ import {
   pickFactEventTimeAnchor,
   resolveFactEventTime
 } from "./chunk-IAIPNEHD.js";
-import {
-  buildExplicitCueRecallSection
-} from "./chunk-TVIVY7KU.js";
 import {
   tryDirectAnswer
 } from "./chunk-CSOYVTRX.js";
 import {
   EmbeddingFallback
 } from "./chunk-YK6BDDHP.js";
+import {
+  refreshConvergedNamespaces
+} from "./chunk-W5XVQFLM.js";
 import {
   formatDaySummaryMemories
 } from "./chunk-RPSYDM6C.js";
-import {
-  refreshConvergedNamespaces
-} from "./chunk-V5H6OJCR.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors
-} from "./chunk-V7X767RT.js";
-import {
-  RoutingRulesStore
-} from "./chunk-XL24QQ63.js";
+} from "./chunk-DCZBSE4F.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
+import {
+  RoutingRulesStore
+} from "./chunk-XL24QQ63.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-7PKFPLLZ.js";
+} from "./chunk-FXTYIA46.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-GFIKG4FR.js";
+} from "./chunk-QGR6OVGT.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-WT6UL3UA.js";
@@ -243,18 +246,18 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-JPHEOE6Z.js";
+} from "./chunk-6MTSFX7A.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-7BAYBYY5.js";
+} from "./chunk-4PC4PRJE.js";
+import {
+  searchHarmonicRetrieval
+} from "./chunk-AZ2QBGYB.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
 } from "./chunk-JXS5PDQ7.js";
-import {
-  searchHarmonicRetrieval
-} from "./chunk-QN7NTKRC.js";
 import {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   recordJudgeVerdict
@@ -262,14 +265,14 @@ import {
 import {
   recordEvalShadowRecall
 } from "./chunk-MCA2X4WH.js";
-import {
-  pruneOrphanCueAnchors
-} from "./chunk-ACPCA4NO.js";
 import {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,
   searchNativeKnowledge
 } from "./chunk-2DQ2XREU.js";
+import {
+  pruneOrphanCueAnchors
+} from "./chunk-ACPCA4NO.js";
 import {
   applyCommitmentLedgerLifecycle
 } from "./chunk-NOB2T2FC.js";
@@ -282,7 +285,10 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-JB6D7EFB.js";
+} from "./chunk-VVG2BOKA.js";
+import {
+  BootstrapEngine
+} from "./chunk-MYVPLJOO.js";
 import {
   BoxBuilder
 } from "./chunk-B7RWBZXW.js";
@@ -294,10 +300,13 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   SmartBuffer
-} from "./chunk-64BHFFKZ.js";
+} from "./chunk-HLYR2TQL.js";
+import {
+  isDisagreementPrompt
+} from "./chunk-H3FZVNRN.js";
 import {
   detectMeetings
-} from "./chunk-A4QMKFFO.js";
+} from "./chunk-O5FFBO2M.js";
 import {
   compileCorrectionRule,
   correctionsFilePath,
@@ -320,15 +329,9 @@ import {
   buildBehaviorSignalsForMemory,
   dedupeBehaviorSignalsByMemoryAndHash
 } from "./chunk-KD3QD3A5.js";
-import {
-  BootstrapEngine
-} from "./chunk-MYVPLJOO.js";
-import {
-  isDisagreementPrompt
-} from "./chunk-H3FZVNRN.js";
 import {
   MeetingsInputError
-} from "./chunk-TQFHQPWD.js";
+} from "./chunk-XADV5IZ3.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -349,7 +352,7 @@ import {
   filterRecallCandidates,
   isGenericRecallExcludedPath,
   isTopLevelArchivePath
-} from "./chunk-5C2HNJMO.js";
+} from "./chunk-J5LLX6IL.js";
 import {
   importCapsule
 } from "./chunk-ZQOCRIGA.js";
@@ -367,9 +370,6 @@ import {
   listTrustZoneRecords,
   searchTrustZoneRecords
 } from "./chunk-KQS72GCR.js";
-import {
-  buildXraySnapshot
-} from "./chunk-NSGU76YO.js";
 import {
   boundRecallContextComposition,
   composeRecallContext,
@@ -377,6 +377,9 @@ import {
   formatCuriosityFooter,
   selectCuriosityQuestion
 } from "./chunk-AHVEHR6K.js";
+import {
+  buildXraySnapshot
+} from "./chunk-QHFV6VNU.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -393,34 +396,34 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-2HGUDBRJ.js";
+} from "./chunk-37ZO6LLJ.js";
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
-} from "./chunk-KMWYZTIE.js";
+} from "./chunk-VMMQDEN5.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend,
   isSearchBackendEnabled
-} from "./chunk-47J4EDGR.js";
+} from "./chunk-AZM4CCAC.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-6QPHF6RR.js";
+} from "./chunk-WQM326GS.js";
 import {
   writeConversationChunks
 } from "./chunk-72A4L5JJ.js";
-import {
-  GraphIndex
-} from "./chunk-L2DPF4DF.js";
 import {
   searchCausalTrajectories
-} from "./chunk-M4MP34AQ.js";
+} from "./chunk-AHZOMHWN.js";
+import {
+  GraphIndex
+} from "./chunk-BIJAWZYW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-VJXY5ZCT.js";
+} from "./chunk-52UKFTUK.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -439,10 +442,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-BOFVT6P3.js";
-import {
-  buildRetiredFactTombstoneInputs
-} from "./chunk-ENTCVTQR.js";
+} from "./chunk-VBHPOWBJ.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -453,6 +453,9 @@ import {
   saveSpeakerRegistry,
   speakerRegistryKey
 } from "./chunk-UHVXE24Y.js";
+import {
+  buildRetiredFactTombstoneInputs
+} from "./chunk-ENTCVTQR.js";
 import {
   canRecallToolScopedMemory,
   shouldPromoteGlobalFactToShared,
@@ -465,7 +468,7 @@ import {
 } from "./chunk-J6A3CX5N.js";
 import {
   confidenceTier
-} from "./chunk-LAQ33B5D.js";
+} from "./chunk-UU3G6GUP.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -506,6 +509,7 @@ import {
 } from "./chunk-M4A44LUA.js";
 import {
   applyTemporalSupersession,
+  lookupAttributeByNormalizedKey,
   normalizeSupersessionKey,
   propagateInvalidation,
   shouldFilterSupersededFromRecall,
@@ -515,6 +519,11 @@ import {
   isValidAsOf,
   isValidityExpiredNow
 } from "./chunk-6CIAGZ6X.js";
+import {
+  FallbackLlmClient,
+  fallbackLlmRuntimeContextFromConfig,
+  gatewayTaskChainOptions
+} from "./chunk-C23BYTJV.js";
 import {
   BulkImportBatchPartialFailureError,
   COMPACTION_SIGNAL_MAX_AGE_MS,
@@ -554,7 +563,7 @@ import {
   throwIfRecallAborted,
   tokenizeRecallQuery,
   utcDateKeysForLocalDay
-} from "./chunk-N3LL5NEU.js";
+} from "./chunk-ZMYDYNI4.js";
 import {
   inferIntentFromText,
   intentCompatibilityScore,
@@ -566,17 +575,15 @@ import {
   getCachedQmdRecall,
   setCachedQmdRecall
 } from "./chunk-42JKGUFJ.js";
-import {
-  FallbackLlmClient,
-  fallbackLlmRuntimeContextFromConfig,
-  gatewayTaskChainOptions
-} from "./chunk-C23BYTJV.js";
 import {
   assertExternalWikiRootOutsideMemoryDirCanonical
 } from "./chunk-JV3C2MNQ.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
+import {
+  coerceBool
+} from "./chunk-PQVCH2AE.js";
 import {
   MEMORY_ID_PATTERN,
   parseIdOrHandle,
@@ -616,7 +623,8 @@ import {
 } from "./chunk-GCASGYIO.js";
 import {
   inferMemoryStatus,
-  isActiveMemoryStatus
+  isActiveMemoryStatus,
+  toMemoryPathRel
 } from "./chunk-7RJUVTVF.js";
 import {
   ContentHashIndex
@@ -678,6 +686,9 @@ import {
 import {
   SecureStoreLockedError
 } from "./chunk-XQ3HXAQH.js";
+import {
+  isErrnoCode
+} from "./chunk-5UZXUTVO.js";
 import {
   ALL_CATEGORY_DIRS,
   ALL_CATEGORY_KEYS,
@@ -689,7 +700,7 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/orchestrator.ts
-import path17 from "path";
+import path19 from "path";
 import { createHash as createHash6 } from "crypto";
 
 // src/orchestration/tier-migration-coordinator.ts
@@ -2184,7 +2195,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path32, preferredNamespace) => {
+        readMemoryFrontmatter: async (path34, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2196,7 +2207,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path32,
+            path34,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -2701,6 +2712,113 @@ ${chunk.content}` : chunk.content;
   }
 };
 
+// src/orchestration/update-localization.ts
+function mergeMemorySnapshots(hot, cold, storageDir) {
+  const merged = [];
+  const indexById = /* @__PURE__ */ new Map();
+  for (const memory of [...hot, ...cold]) {
+    const id = memory.frontmatter.id;
+    const existingIndex = indexById.get(id);
+    if (existingIndex === void 0) {
+      indexById.set(id, merged.length);
+      merged.push(memory);
+      continue;
+    }
+    const existing = merged[existingIndex];
+    if (!isActiveMemoryStatus(inferLocalizationMemoryStatus(existing, storageDir)) && isActiveMemoryStatus(inferLocalizationMemoryStatus(memory, storageDir))) {
+      merged[existingIndex] = memory;
+    }
+  }
+  return merged;
+}
+function cap(value) {
+  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+function normalizeEntityRef(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = normalizeSupersessionKey(value);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function compareCandidates(left, right) {
+  const leftScore = Number.isFinite(left.score) ? left.score : Number.NEGATIVE_INFINITY;
+  const rightScore = Number.isFinite(right.score) ? right.score : Number.NEGATIVE_INFINITY;
+  if (leftScore !== rightScore) return leftScore > rightScore ? -1 : 1;
+  return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+function anchorScore(memory, anchor) {
+  const attributes = anchor.attributes;
+  if (attributes && Object.keys(attributes).length > 0) {
+    const candidateAttributes = memory.frontmatter.structuredAttributes;
+    if (!candidateAttributes) return 0;
+    let overlap = 0;
+    for (const key of Object.keys(attributes)) {
+      if (lookupAttributeByNormalizedKey(candidateAttributes, key) !== void 0) overlap++;
+    }
+    return overlap;
+  }
+  const created = Date.parse(memory.frontmatter.created);
+  return Number.isFinite(created) ? created : 0;
+}
+function toAnchorCandidate(memory, anchor) {
+  return {
+    id: memory.frontmatter.id,
+    content: memory.content,
+    category: memory.frontmatter.category,
+    source: "anchor",
+    score: anchorScore(memory, anchor)
+  };
+}
+function inferLocalizationMemoryStatus(memory, storageDir) {
+  const pathRel = storageDir ? toMemoryPathRel(storageDir, memory.path) : memory.path;
+  return inferMemoryStatus(memory.frontmatter, pathRel);
+}
+async function localizeUpdateCandidates(deps, anchor, newContent, options) {
+  const maxCandidates = cap(options.maxCandidates);
+  if (maxCandidates === 0) return [];
+  const anchorLimit = cap(options.anchorCandidates);
+  const searchLimit = cap(options.searchCandidates);
+  const anchorCandidates = [];
+  const normalizedAnchorEntityRef = normalizeEntityRef(anchor.entityRef);
+  if (normalizedAnchorEntityRef !== void 0 && anchorLimit > 0) {
+    const hot = await deps.storage.readAllMemories();
+    const cold = deps.storage.readAllColdMemories ? await deps.storage.readAllColdMemories() : [];
+    const memories = mergeMemorySnapshots(hot, cold, deps.storage.dir);
+    for (const memory of memories) {
+      if (inferLocalizationMemoryStatus(memory, deps.storage.dir) !== "active") continue;
+      const normalizedCandidateEntityRef = normalizeEntityRef(memory.frontmatter.entityRef);
+      if (normalizedCandidateEntityRef !== normalizedAnchorEntityRef) continue;
+      if (memory.frontmatter.category !== anchor.category) continue;
+      anchorCandidates.push(toAnchorCandidate(memory, anchor));
+    }
+    anchorCandidates.sort(compareCandidates);
+    anchorCandidates.splice(anchorLimit);
+  }
+  const searchCandidates = [];
+  if (searchLimit > 0) {
+    const searchHits = await deps.qmdSearch(newContent, searchLimit);
+    for (const hit of searchHits) {
+      searchCandidates.push({
+        id: hit.id,
+        content: hit.content,
+        category: hit.category,
+        source: "search",
+        score: hit.score
+      });
+    }
+    searchCandidates.sort(compareCandidates);
+    searchCandidates.splice(searchLimit);
+  }
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of [...anchorCandidates, ...searchCandidates]) {
+    if (seen.has(candidate.id)) continue;
+    seen.add(candidate.id);
+    merged.push(candidate);
+    if (merged.length >= maxCandidates) break;
+  }
+  return merged;
+}
+
 // src/orchestration/contradiction-linking-coordinator.ts
 var ContradictionLinkingCoordinator = class {
   getConfig;
@@ -2723,31 +2841,125 @@ var ContradictionLinkingCoordinator = class {
    * Check if a new memory contradicts an existing one.
    * Uses QMD to find similar memories, then LLM to verify contradiction.
    */
-  async checkForContradiction(content, category, namespaceScope) {
-    if (!this.isSearchAvailable()) return null;
+  async checkForContradiction(content, category, namespaceScope, anchor) {
     const config = this.getConfig();
-    const results = await this.searchAcrossNamespaces({
-      query: content,
-      namespaces: [namespaceScope],
-      maxResults: 5,
-      mode: "search"
-    });
-    for (const result of results) {
-      if (result.score < config.contradictionSimilarityThreshold) {
-        continue;
-      }
-      const memoryId = this.extractMemoryIdsFromResults([result])[0];
-      if (!memoryId) continue;
-      const resultNamespace = this.namespaceFromPath(result.path);
-      if (resultNamespace !== namespaceScope) continue;
-      const resultStorage = await this.storageForNamespace(resultNamespace);
-      const existingMemory = await resultStorage.getMemoryById(memoryId);
-      if (!existingMemory) continue;
-      if (existingMemory.frontmatter.status === "superseded" || existingMemory.frontmatter.status === "forgotten") {
-        continue;
+    const localization = config.contradictionLocalization;
+    const anchorEnabled = coerceBool(localization?.anchorEnabled) ?? true;
+    if (!anchorEnabled) {
+      if (!this.isSearchAvailable()) return null;
+      const results = await this.searchAcrossNamespaces({
+        query: content,
+        namespaces: [namespaceScope],
+        maxResults: 5,
+        mode: "search"
+      });
+      for (const result of results) {
+        if (result.score < config.contradictionSimilarityThreshold) continue;
+        const memoryId = this.extractMemoryIdsFromResults([result])[0];
+        if (!memoryId) continue;
+        const resultNamespace = this.namespaceFromPath(result.path);
+        if (resultNamespace !== namespaceScope) continue;
+        const resultStorage2 = await this.storageForNamespace(resultNamespace);
+        const existingMemory = await resultStorage2.getMemoryById(memoryId);
+        if (!existingMemory) continue;
+        if (inferLocalizationMemoryStatus(existingMemory, resultStorage2.dir) !== "active") continue;
+        const verification = await this.getExtraction().verifyContradiction(
+          { content, category },
+          {
+            id: existingMemory.frontmatter.id,
+            content: existingMemory.content,
+            category: existingMemory.frontmatter.category,
+            created: existingMemory.frontmatter.created
+          }
+        );
+        if (!verification) continue;
+        if (verification.isContradiction && verification.confidence >= config.contradictionMinConfidence) {
+          if (verification.whichIsNewer === "first") {
+            log.info(
+              `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory \u2014 existing is newer, incoming fact is stale`
+            );
+            continue;
+          }
+          log.info(
+            `detected contradiction (confidence: ${verification.confidence}): ${existingMemory.frontmatter.id} vs new memory${config.contradictionAutoResolve ? " (auto-resolved)" : " (queued for manual review)"}`
+          );
+          return {
+            supersededId: existingMemory.frontmatter.id,
+            confidence: verification.confidence,
+            reason: verification.reasoning,
+            supersededPath: existingMemory.path,
+            supersededCreated: existingMemory.frontmatter.created,
+            supersededTags: existingMemory.frontmatter.tags ?? []
+          };
+        }
       }
-      const extraction = this.getExtraction();
-      const verification = await extraction.verifyContradiction(
+      return null;
+    }
+    const localizationOptions = localization ?? {
+      anchorEnabled: true,
+      anchorCandidates: 5,
+      searchCandidates: 5,
+      maxCandidates: 8
+    };
+    const resultStorage = await this.storageForNamespace(namespaceScope);
+    let anchorSnapshot = anchor?.storageSnapshot;
+    const anchorLimit = localizationOptions.anchorCandidates;
+    if (!anchorSnapshot && Number.isInteger(anchorLimit) && anchorLimit > 0 && typeof anchor?.entityRef === "string" && anchor?.entityRef.trim().length > 0) {
+      const [hot, cold] = await Promise.all([
+        resultStorage.readAllMemories(),
+        typeof resultStorage.readAllColdMemories === "function" ? resultStorage.readAllColdMemories() : Promise.resolve([])
+      ]);
+      anchorSnapshot = mergeMemorySnapshots(hot, cold, resultStorage.dir);
+    }
+    const anchorMemoryById = anchorSnapshot ? new Map(anchorSnapshot.map((memory) => [memory.frontmatter.id, memory])) : void 0;
+    const candidates = await localizeUpdateCandidates(
+      {
+        storage: anchorSnapshot ? {
+          dir: resultStorage.dir,
+          readAllMemories: async () => anchorSnapshot ?? [],
+          readAllColdMemories: async () => []
+        } : resultStorage,
+        qmdSearch: async (query, limit) => {
+          if (!this.isSearchAvailable()) {
+            log.warn("[contradiction-linking] QMD unavailable; continuing with anchor candidates");
+            return [];
+          }
+          const results = await this.searchAcrossNamespaces({
+            query,
+            namespaces: [namespaceScope],
+            maxResults: limit,
+            mode: "search"
+          });
+          const hits = [];
+          for (const result of results) {
+            if (result.score < config.contradictionSimilarityThreshold) continue;
+            const memoryId = this.extractMemoryIdsFromResults([result])[0];
+            if (!memoryId) continue;
+            if (this.namespaceFromPath(result.path) !== namespaceScope) continue;
+            const existingMemory = anchorMemoryById?.get(memoryId) ?? await resultStorage.getMemoryById(memoryId);
+            if (!existingMemory || inferLocalizationMemoryStatus(existingMemory, resultStorage.dir) !== "active") continue;
+            hits.push({
+              id: memoryId,
+              content: existingMemory.content,
+              category: existingMemory.frontmatter.category,
+              score: result.score
+            });
+          }
+          return hits;
+        }
+      },
+      {
+        entityRef: anchor?.entityRef,
+        category,
+        attributes: anchor?.structuredAttributes ?? anchor?.attributes
+      },
+      content,
+      localizationOptions
+    );
+    for (const candidate of candidates) {
+      const existingMemory = anchorMemoryById?.get(candidate.id) ?? await resultStorage.getMemoryById(candidate.id);
+      if (!existingMemory || inferLocalizationMemoryStatus(existingMemory, resultStorage.dir) !== "active") continue;
+      const verification = await this.getExtraction().verifyContradiction(
         { content, category },
         {
           id: existingMemory.frontmatter.id,
@@ -2802,13 +3014,23 @@ var ContradictionLinkingCoordinator = class {
       }
     }
     if (!contradiction || !config.contradictionAutoResolve || postWriteGuard) {
-      return;
+      return postWriteGuard ? "blocked" : "not_attempted";
     }
     let oldMemory = null;
-    try {
-      oldMemory = await storage.getMemoryById(contradiction.supersededId);
-    } catch (err) {
-      log.warn(`contradiction propagation snapshot failed for ${contradiction.supersededId}: ${err}`);
+    if (coerceBool(config.dependencyPropagation?.enabled) === true) {
+      try {
+        const [hot, cold] = await Promise.all([
+          typeof storage.readAllMemories === "function" ? storage.readAllMemories() : storage.getMemoryById(contradiction.supersededId).then(
+            (memory) => memory ? [memory] : []
+          ),
+          typeof storage.readAllColdMemories === "function" ? storage.readAllColdMemories() : Promise.resolve([])
+        ]);
+        oldMemory = mergeMemorySnapshots(hot, cold, storage.dir).find(
+          (memory) => memory.frontmatter.id === contradiction.supersededId
+        ) ?? null;
+      } catch (err) {
+        log.warn(`contradiction propagation snapshot failed for ${contradiction.supersededId}: ${err}`);
+      }
     }
     try {
       const superseded = await storage.supersedeMemory(
@@ -2816,7 +3038,48 @@ var ContradictionLinkingCoordinator = class {
         newMemoryId,
         contradiction.reason
       );
-      if (!superseded) return;
+      if (!superseded) {
+        let mergedSnapshot;
+        try {
+          const [hot, cold] = await Promise.all([
+            typeof storage.readAllMemories === "function" ? storage.readAllMemories() : Promise.all([
+              storage.getMemoryById(contradiction.supersededId),
+              storage.getMemoryById(newMemoryId)
+            ]).then(
+              (memories) => memories.filter((memory) => memory !== null)
+            ),
+            typeof storage.readAllColdMemories === "function" ? storage.readAllColdMemories() : Promise.resolve([])
+          ]);
+          mergedSnapshot = mergeMemorySnapshots(hot, cold, storage.dir);
+        } catch (err) {
+          log.warn(
+            `contradiction auto-resolve race check failed for ${contradiction.supersededId}: ${err}`
+          );
+          return "supersede_failed";
+        }
+        const target = mergedSnapshot.find(
+          (memory) => memory.frontmatter.id === contradiction.supersededId
+        );
+        if (!target) return "supersede_failed";
+        const losingMemory = mergedSnapshot.find(
+          (memory) => memory.frontmatter.id === newMemoryId && inferLocalizationMemoryStatus(memory, storage.dir) === "active"
+        );
+        if (!losingMemory) return "supersede_failed";
+        try {
+          if (losingMemory.frontmatter.supersedes === contradiction.supersededId) {
+            const cleared = await storage.writeMemoryFrontmatter(losingMemory, {
+              supersedes: void 0
+            });
+            if (cleared === false) return "supersedes_clear_failed";
+          }
+        } catch (err) {
+          log.warn(
+            `contradiction auto-resolve losing supersedes clear failed for ${newMemoryId}: ${err}`
+          );
+          return "supersedes_clear_failed";
+        }
+        return inferLocalizationMemoryStatus(target, storage.dir) === "active" ? "supersede_failed" : "lost_race";
+      }
       if (oldMemory) {
         try {
           await propagateInvalidation(
@@ -2838,17 +3101,25 @@ var ContradictionLinkingCoordinator = class {
         }
       }
       if (resolveIndexingCapabilities(config).queryAwareIndexing && contradiction.supersededPath) {
-        await deindexMemoryAsync(
-          config.memoryDir,
-          contradiction.supersededPath,
-          contradiction.supersededCreated,
-          contradiction.supersededTags
-        );
+        try {
+          await deindexMemoryAsync(
+            config.memoryDir,
+            contradiction.supersededPath,
+            contradiction.supersededCreated,
+            contradiction.supersededTags
+          );
+        } catch (err) {
+          log.warn(
+            `contradiction auto-resolve deindex failed for ${contradiction.supersededId}: ${err}`
+          );
+        }
       }
+      return "resolved";
     } catch (err) {
       log.warn(
         `contradiction auto-resolve supersede failed for ${contradiction.supersededId}: ${err}`
       );
+      return "supersede_failed";
     }
   }
   // ---------------------------------------------------------------------------
@@ -3690,6 +3961,64 @@ async function persistConstructedHarmonicRecords(options) {
   }
 }
 
+// src/orchestration/extraction-anchor-snapshot.ts
+import path5 from "path";
+var ExtractionAnchorSnapshot = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  snapshots = /* @__PURE__ */ new WeakMap();
+  refreshFailed = /* @__PURE__ */ new WeakSet();
+  failOpenRead(storage, snapshot) {
+    return snapshot.catch((error) => {
+      this.refreshFailed.add(storage);
+      if (this.snapshots.get(storage) === snapshot) this.snapshots.delete(storage);
+      this.options.onRefreshError?.(error);
+      return [];
+    });
+  }
+  get(storage, entityRef) {
+    const candidateLimit = this.options.candidateLimit ?? 5;
+    if (this.options.enabled === false || !Number.isInteger(candidateLimit) || candidateLimit <= 0 || typeof entityRef !== "string" || entityRef.trim().length === 0) {
+      return Promise.resolve(void 0);
+    }
+    if (this.refreshFailed.has(storage)) return Promise.resolve([]);
+    const cached = this.snapshots.get(storage);
+    if (cached) return this.failOpenRead(storage, cached);
+    const snapshot = Promise.all([
+      storage.readAllMemories(),
+      storage.readAllColdMemories()
+    ]).then(([hot, cold]) => mergeMemorySnapshots(hot, cold, storage.dir));
+    this.snapshots.set(storage, snapshot);
+    return this.failOpenRead(storage, snapshot);
+  }
+  async replace(storage, memoryId, category, pathById) {
+    if (this.refreshFailed.has(storage)) return;
+    try {
+      const cached = this.snapshots.get(storage);
+      if (!cached) return;
+      const snapshot = await cached;
+      const relativePath = resolvePersistedMemoryRelativePath({ memoryId, pathById, category });
+      const memory = await storage.readMemoryByPath(path5.join(storage.dir, relativePath));
+      if (!memory) return;
+      const existingIndex = snapshot.findIndex((entry) => entry.frontmatter.id === memoryId);
+      if (existingIndex >= 0) snapshot.splice(existingIndex, 1);
+      snapshot.push(memory);
+    } catch (error) {
+      this.refreshFailed.add(storage);
+      this.options.onRefreshError?.(error);
+    }
+  }
+  async remove(storage, memoryId) {
+    const cached = this.snapshots.get(storage);
+    if (!cached) return;
+    const snapshot = await cached;
+    const index = snapshot.findIndex((entry) => entry.frontmatter.id === memoryId);
+    if (index >= 0) snapshot.splice(index, 1);
+  }
+};
+
 // src/orchestration/extraction-persist.ts
 var ExtractionPersistCoordinator = class {
   constructor(deps) {
@@ -3729,6 +4058,11 @@ var ExtractionPersistCoordinator = class {
     };
     const persistedIds = [];
     const memoryPathById = /* @__PURE__ */ new Map();
+    const anchorSnapshots = new ExtractionAnchorSnapshot({
+      enabled: coerceBool(this.deps.config.contradictionLocalization?.anchorEnabled) ?? true,
+      candidateLimit: this.deps.config.contradictionLocalization?.anchorCandidates,
+      onRefreshError: (error) => log.warn(`anchor snapshot update failed; using empty snapshot: ${error}`)
+    });
     const supersessionOrderingAt = (validAt) => validAt && validAt.length > 0 ? validAt : (/* @__PURE__ */ new Date()).toISOString();
     const pendingReviewPersistedIds = [];
     const persistedIdsByStorage = /* @__PURE__ */ new Map();
@@ -4753,12 +5087,19 @@ var ExtractionPersistCoordinator = class {
       let links = [];
       let contradictionDetected = false;
       let contradiction;
-      if (resolveRecallEnhancementCapabilities(this.deps.config).contradictionDetection && this.deps.getQmd().isAvailable() && faithfulnessEnforceStatus !== "pending_review") {
+      if (resolveRecallEnhancementCapabilities(this.deps.config).contradictionDetection && faithfulnessEnforceStatus !== "pending_review") {
         const targetNamespace = this.deps.storageDirNamespace(targetStorage.dir);
+        const candidateEntityRef = fact.entityRef;
+        const factEntityRef = typeof candidateEntityRef === "string" ? candidateEntityRef : void 0;
         contradiction = await this.deps.checkForContradiction(
           fact.content,
           writeCategory,
-          targetNamespace
+          targetNamespace,
+          {
+            entityRef: factEntityRef,
+            structuredAttributes: fact.structuredAttributes,
+            storageSnapshot: await anchorSnapshots.get(targetStorage, factEntityRef)
+          }
         );
         if (contradiction) {
           contradictionDetected = true;
@@ -4847,12 +5188,15 @@ var ExtractionPersistCoordinator = class {
           const parentId = parentWrite.id;
           const tombstoneBlocked2 = parentWrite.tombstoneBlocked;
           const postWriteGuard2 = faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked2;
-          await this.deps.applyDeferredContradictionResolve(
+          const contradictionOutcome = await this.deps.applyDeferredContradictionResolve(
             contradiction,
             targetStorage,
             parentId,
             postWriteGuard2
           );
+          if (contradictionOutcome === "resolved" || contradictionOutcome === "lost_race") {
+            await anchorSnapshots.remove(targetStorage, contradiction.supersededId);
+          }
           try {
             const chunkTags = parentWriteEnvelope.tags.filter((tag) => tag !== "chunked");
             for (const chunk of chunkResult.chunks) {
@@ -4922,6 +5266,7 @@ var ExtractionPersistCoordinator = class {
             category: writeCategory,
             harmonicFact
           });
+          await anchorSnapshots.replace(targetStorage, parentId, writeCategory, memoryPathById);
           if (!postWriteGuard2 && threadEpisodeIdsForGraph && !threadEpisodeIdsForGraph.includes(parentId)) {
             threadEpisodeIdsForGraph.push(parentId);
           }
@@ -4930,7 +5275,7 @@ var ExtractionPersistCoordinator = class {
           }
           if (!postWriteGuard2) {
             try {
-              await applyTemporalSupersession({
+              const temporalSupersession = await applyTemporalSupersession({
                 storage: targetStorage,
                 newMemoryId: parentId,
                 entityRef: parentWriteEnvelope.entityRef,
@@ -4944,6 +5289,9 @@ var ExtractionPersistCoordinator = class {
                 config: this.config,
                 namespaceScope: this.deps.storageDirNamespace(targetStorage.dir)
               });
+              for (const supersededId of temporalSupersession.supersededIds) {
+                await anchorSnapshots.remove(targetStorage, supersededId);
+              }
             } catch (err) {
               log.warn(`temporal-supersession (chunked): unexpected error: ${err}`);
             }
@@ -5111,7 +5459,15 @@ var ExtractionPersistCoordinator = class {
       const tombstoneBlocked = factWrite.tombstoneBlocked;
       const postWriteGuard = faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked;
       try {
-        await this.deps.applyDeferredContradictionResolve(contradiction, targetStorage, memoryId, postWriteGuard);
+        const contradictionOutcome = await this.deps.applyDeferredContradictionResolve(
+          contradiction,
+          targetStorage,
+          memoryId,
+          postWriteGuard
+        );
+        if (contradictionOutcome === "resolved" || contradictionOutcome === "lost_race") {
+          await anchorSnapshots.remove(targetStorage, contradiction.supersededId);
+        }
       } catch (err) {
         await flushDeferredFactHashOnFailure(() => this.deps.saveContentHashIndexes(), factDedupEnabled);
         throw err;
@@ -5123,7 +5479,7 @@ var ExtractionPersistCoordinator = class {
       }
       if (!postWriteGuard) {
         try {
-          await applyTemporalSupersession({
+          const temporalSupersession = await applyTemporalSupersession({
             storage: targetStorage,
             newMemoryId: memoryId,
             entityRef: factWriteEnvelope.entityRef,
@@ -5134,6 +5490,9 @@ var ExtractionPersistCoordinator = class {
             config: this.config,
             namespaceScope: this.deps.storageDirNamespace(targetStorage.dir)
           });
+          for (const supersededId of temporalSupersession.supersededIds) {
+            await anchorSnapshots.remove(targetStorage, supersededId);
+          }
         } catch (err) {
           log.warn(`temporal-supersession: unexpected error: ${err}`);
         }
@@ -5155,6 +5514,7 @@ var ExtractionPersistCoordinator = class {
           category: writeCategory,
           harmonicFact
         });
+        await anchorSnapshots.replace(targetStorage, memoryId, writeCategory, memoryPathById);
         if (!postWriteGuard && threadEpisodeIdsForGraph && !threadEpisodeIdsForGraph.includes(memoryId)) {
           threadEpisodeIdsForGraph.push(memoryId);
         }
@@ -5398,12 +5758,256 @@ var ExtractionPersistCoordinator = class {
 // src/orchestration/recall-internal.ts
 import { createHash as createHash3 } from "crypto";
 import { readFile as readFile2, stat, unlink } from "fs/promises";
-import path7 from "path";
+import path9 from "path";
+
+// src/orchestration/graph-path-state-loader.ts
+import { lstat, opendir, realpath } from "fs/promises";
+import path6 from "path";
+function isArchivePathIndexUnavailable(index) {
+  return "unavailable" in index;
+}
+var MAX_ARCHIVE_PATH_INDEXES = 32;
+var MAX_ARCHIVE_PATH_INDEX_BUILDS = 32;
+var MAX_ARCHIVE_PATH_INDEX_GENERATION_RETRIES = 1;
+var MAX_ARCHIVE_INDEX_ENTRIES = 1e5;
+function isArchiveScanAbsenceError(error) {
+  return isErrnoCode(error, "ENOENT") || isErrnoCode(error, "ENOTDIR");
+}
+var GraphPathStateLoader = class {
+  archivePathIndexes;
+  archivePathIndexBuilds = /* @__PURE__ */ new Map();
+  archiveLstat = lstat;
+  archiveRealpath = realpath;
+  openArchiveDirectory = opendir;
+  async readNode(storage, nodeId, deadlineAtMs, allowArchiveLookup) {
+    if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
+    const configuredStorageRoot = path6.resolve(storage.dir);
+    const storageRoot = await realpath(configuredStorageRoot).catch(() => null);
+    if (!storageRoot || storageRoot !== configuredStorageRoot) return null;
+    const logicalId = path6.basename(nodeId, path6.extname(nodeId));
+    const directRelativePaths = [nodeId, path6.join("cold", nodeId)];
+    let inactiveDirectMemory = null;
+    for (const relativePath of directRelativePaths) {
+      const safePath = await this.resolveContainedPath(storageRoot, relativePath);
+      if (!safePath) continue;
+      if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
+      const memory = await storage.readMemoryByPath(safePath);
+      if (!memory || memory.frontmatter.id !== logicalId) continue;
+      const inferredStatus = inferMemoryStatus(
+        memory.frontmatter,
+        toMemoryPathRel(storageRoot, safePath)
+      );
+      if (inferredStatus === "active") return memory;
+      inactiveDirectMemory ??= memory;
+    }
+    if (inactiveDirectMemory) return inactiveDirectMemory;
+    if (!allowArchiveLookup || typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) {
+      return null;
+    }
+    const archiveIndex = await this.getArchivePathIndex(storage, storageRoot, deadlineAtMs);
+    if (!archiveIndex || isArchivePathIndexUnavailable(archiveIndex) || typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) {
+      return null;
+    }
+    const archivePaths = archiveIndex.pathsByBasename.get(path6.basename(nodeId)) ?? [];
+    for (const archivePath of archivePaths) {
+      if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
+      const memory = await storage.readMemoryByPath(archivePath);
+      if (!memory) continue;
+      if (memory.frontmatter.id === logicalId) return memory;
+    }
+    return null;
+  }
+  async resolveContainedPath(storageRoot, relativePath) {
+    if (path6.isAbsolute(relativePath)) return null;
+    const rawSegments = relativePath.replace(/\\/g, "/").split("/");
+    if (rawSegments.includes("..")) return null;
+    const candidate = path6.resolve(storageRoot, relativePath);
+    const lexicalRelative = path6.relative(storageRoot, candidate);
+    if (lexicalRelative.length > 0 && (lexicalRelative.startsWith("..") || path6.isAbsolute(lexicalRelative))) {
+      return null;
+    }
+    const canonical = await realpath(candidate).catch(() => candidate);
+    const canonicalRelative = path6.relative(storageRoot, canonical);
+    if (canonicalRelative.length > 0 && (canonicalRelative.startsWith("..") || path6.isAbsolute(canonicalRelative))) {
+      return null;
+    }
+    return canonical;
+  }
+  async getArchivePathIndex(storage, storageRoot, deadlineAtMs) {
+    if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
+    if (!this.archivePathIndexes) this.archivePathIndexes = /* @__PURE__ */ new Map();
+    const archivePathIndexes = this.archivePathIndexes;
+    let generationRetries = 0;
+    while (true) {
+      const version = storage.getArchiveMutationVersion();
+      if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
+      const cacheKey = `${storageRoot}\0${version}`;
+      const cached = archivePathIndexes.get(cacheKey);
+      if (cached) {
+        archivePathIndexes.delete(cacheKey);
+        archivePathIndexes.set(cacheKey, cached);
+        return cached;
+      }
+      let build = this.archivePathIndexBuilds.get(cacheKey);
+      if (!build) {
+        if (this.archivePathIndexBuilds.size >= MAX_ARCHIVE_PATH_INDEX_BUILDS) {
+          const trackedBuilds = [...this.archivePathIndexBuilds.values()].map(
+            (pending) => pending.then(() => void 0, () => void 0)
+          );
+          const admitted = await this.waitForDeadline(Promise.race(trackedBuilds), deadlineAtMs);
+          if (admitted === null) return null;
+          continue;
+        }
+        build = this.buildArchivePathIndex(storageRoot, version).then((index2) => {
+          if (!index2) return null;
+          if (storage.getArchiveMutationVersion() !== version) return null;
+          const rootPrefix = `${storageRoot}\0`;
+          for (const key of archivePathIndexes.keys()) {
+            if (key.startsWith(rootPrefix)) archivePathIndexes.delete(key);
+          }
+          archivePathIndexes.set(cacheKey, index2);
+          while (archivePathIndexes.size > MAX_ARCHIVE_PATH_INDEXES) {
+            const oldestKey = archivePathIndexes.keys().next().value;
+            if (oldestKey === void 0) break;
+            archivePathIndexes.delete(oldestKey);
+          }
+          return index2;
+        }).finally(() => {
+          this.archivePathIndexBuilds.delete(cacheKey);
+        });
+        this.archivePathIndexBuilds.set(cacheKey, build);
+      }
+      const index = await this.waitForDeadline(build, deadlineAtMs);
+      if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
+      const currentVersion = storage.getArchiveMutationVersion();
+      if (index && currentVersion === version) return index;
+      if (index && currentVersion !== version) archivePathIndexes.delete(cacheKey);
+      if (currentVersion === version) return null;
+      if (generationRetries >= MAX_ARCHIVE_PATH_INDEX_GENERATION_RETRIES) return null;
+      generationRetries += 1;
+    }
+  }
+  async waitForDeadline(promise, deadlineAtMs) {
+    if (typeof deadlineAtMs !== "number") return promise;
+    const remainingMs = deadlineAtMs - Date.now();
+    if (remainingMs <= 0) return null;
+    const timeout = Promise.withResolvers();
+    const timer = setTimeout(() => timeout.resolve(null), remainingMs);
+    try {
+      return await Promise.race([promise, timeout.promise]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async buildArchivePathIndex(storageRoot, version) {
+    const pathsByBasename = /* @__PURE__ */ new Map();
+    const archiveRoot = path6.join(storageRoot, "archive");
+    let archiveRootStatus;
+    try {
+      archiveRootStatus = await this.archiveLstat(archiveRoot);
+    } catch (error) {
+      if (isArchiveScanAbsenceError(error)) return { version, pathsByBasename };
+      return null;
+    }
+    if (!archiveRootStatus || !archiveRootStatus.isDirectory() || archiveRootStatus.isSymbolicLink()) {
+      return { version, pathsByBasename };
+    }
+    let canonicalArchiveRoot;
+    try {
+      canonicalArchiveRoot = await this.archiveRealpath(archiveRoot);
+    } catch (error) {
+      if (isArchiveScanAbsenceError(error)) return { version, pathsByBasename };
+      return null;
+    }
+    const archiveRelative = path6.relative(storageRoot, canonicalArchiveRoot);
+    if (archiveRelative.length > 0 && (archiveRelative.startsWith("..") || path6.isAbsolute(archiveRelative))) {
+      return { version, pathsByBasename };
+    }
+    const pending = [canonicalArchiveRoot];
+    let indexedPathCount = 0;
+    let visitedEntryCount = 1;
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (!current) break;
+      let currentStatus;
+      try {
+        currentStatus = await this.archiveLstat(current);
+      } catch (error) {
+        if (isArchiveScanAbsenceError(error)) continue;
+        return null;
+      }
+      if (!currentStatus || !currentStatus.isDirectory() || currentStatus.isSymbolicLink()) {
+        continue;
+      }
+      let canonicalCurrent;
+      try {
+        canonicalCurrent = await this.archiveRealpath(current);
+      } catch (error) {
+        if (isArchiveScanAbsenceError(error)) continue;
+        return null;
+      }
+      const currentRelative = path6.relative(storageRoot, canonicalCurrent);
+      if (currentRelative.length > 0 && (currentRelative.startsWith("..") || path6.isAbsolute(currentRelative))) {
+        continue;
+      }
+      let directory;
+      try {
+        directory = await this.openArchiveDirectory(canonicalCurrent);
+      } catch (error) {
+        if (isArchiveScanAbsenceError(error)) continue;
+        return null;
+      }
+      try {
+        for await (const entry of directory) {
+          visitedEntryCount += 1;
+          if (visitedEntryCount > MAX_ARCHIVE_INDEX_ENTRIES) {
+            return { version, unavailable: "oversized" };
+          }
+          if (entry.isSymbolicLink()) continue;
+          const entryPath = path6.join(canonicalCurrent, entry.name);
+          if (entry.isDirectory()) {
+            pending.push(entryPath);
+            continue;
+          }
+          if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+          if (indexedPathCount >= MAX_ARCHIVE_INDEX_ENTRIES) {
+            return { version, unavailable: "oversized" };
+          }
+          let canonical;
+          try {
+            canonical = await this.archiveRealpath(entryPath);
+          } catch (error) {
+            if (isArchiveScanAbsenceError(error)) continue;
+            return null;
+          }
+          const relative = path6.relative(storageRoot, canonical);
+          if (relative.length > 0 && (relative.startsWith("..") || path6.isAbsolute(relative))) {
+            continue;
+          }
+          const paths = pathsByBasename.get(entry.name);
+          if (paths) paths.push(canonical);
+          else pathsByBasename.set(entry.name, [canonical]);
+          indexedPathCount += 1;
+        }
+      } catch {
+        return null;
+      }
+    }
+    for (const paths of pathsByBasename.values()) {
+      paths.sort((left, right) => {
+        const normalizedLeft = left.normalize("NFC");
+        const normalizedRight = right.normalize("NFC");
+        return normalizedRight < normalizedLeft ? -1 : normalizedRight > normalizedLeft ? 1 : 0;
+      });
+    }
+    return { version, pathsByBasename };
+  }
+};
 
 // src/orchestration/graph-recall-coordinator.ts
 import { createHash as createHash2 } from "crypto";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import path5 from "path";
+import path7 from "path";
 function mergeGraphExpandedResults(primary, expanded) {
   const mergedByNamespaceAndPath = /* @__PURE__ */ new Map();
   for (const item of [...primary, ...expanded]) {
@@ -5420,11 +6024,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByNamespaceAndPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path5.isAbsolute(candidatePath) ? candidatePath : path5.resolve(storageDir, candidatePath);
-  const rel = path5.relative(storageDir, absolutePath);
+  const absolutePath = path7.isAbsolute(candidatePath) ? candidatePath : path7.resolve(storageDir, candidatePath);
+  const rel = path7.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path5.sep).join("/");
+  return rel.split(path7.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -5441,6 +6045,19 @@ function blendGraphExpandedRecallScore(options) {
   const blended = graphNorm * weight + seedScore * (1 - weight);
   return Math.max(minBound, Math.min(maxBound, blended));
 }
+var KNOWN_PATH_NODE_STATUSES = {
+  active: true,
+  pending_review: true,
+  rejected: true,
+  quarantined: true,
+  superseded: true,
+  archived: true,
+  forgotten: true
+};
+function normalizeInferredPathNodeStatus(value) {
+  if (typeof value !== "string" || KNOWN_PATH_NODE_STATUSES[value] !== true) return null;
+  return value;
+}
 var GraphRecallCoordinator = class {
   getConfig;
   getStorage;
@@ -5450,6 +6067,7 @@ var GraphRecallCoordinator = class {
   resolveColdQmdResultForRecall;
   storageForAbsoluteQmdResultPath;
   readQmdResultMemory;
+  graphPathStateLoader = new GraphPathStateLoader();
   constructor(options) {
     this.getConfig = options.getConfig;
     this.getStorage = options.getStorage;
@@ -5462,6 +6080,21 @@ var GraphRecallCoordinator = class {
   }
   async expandResultsViaGraph(options) {
     const config = this.getConfig();
+    const parsedAsOfMs = typeof options.asOf === "string" ? Date.parse(options.asOf) : Number.NaN;
+    const hasHistoricalAsOf = Number.isFinite(parsedAsOfMs) || typeof options.asOfMs === "number" && Number.isFinite(options.asOfMs);
+    const effectiveAsOfMs = Number.isFinite(parsedAsOfMs) ? parsedAsOfMs : typeof options.asOfMs === "number" && Number.isFinite(options.asOfMs) ? options.asOfMs : Date.now();
+    const effectiveAsOf = new Date(effectiveAsOfMs).toISOString();
+    const isEligibleGraphCandidate = (memory, storageDir) => {
+      if (hasHistoricalAsOf && !isValidAsOf(memory.frontmatter, effectiveAsOfMs)) {
+        return false;
+      }
+      if (!hasHistoricalAsOf && config.temporalBiTemporal === true && config.temporalExpiredInInjection !== true && isValidityExpiredNow(memory.frontmatter, Date.now())) {
+        return false;
+      }
+      const lifecyclePath = toMemoryPathRel(storageDir, memory.path);
+      const status = inferMemoryStatus(memory.frontmatter, lifecyclePath);
+      return status === "active" || status === "superseded" && hasHistoricalAsOf;
+    };
     const deadlineExpired = () => typeof options.deadlineAtMs === "number" && Date.now() >= options.deadlineAtMs;
     const byNamespace = /* @__PURE__ */ new Map();
     const addResultForNamespace = (namespace, result) => {
@@ -5495,7 +6128,7 @@ var GraphRecallCoordinator = class {
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path5.isAbsolute(resolvedPath)) {
+      if (!path7.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -5520,7 +6153,7 @@ var GraphRecallCoordinator = class {
         }
         continue;
       }
-      if (path5.isAbsolute(result.path)) {
+      if (path7.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -5533,6 +6166,11 @@ var GraphRecallCoordinator = class {
     }
     const perNamespaceSeedCap = Math.max(3, options.recallResultLimit);
     const perNamespaceExpandedCap = Math.max(8, options.recallResultLimit * 2);
+    const graphPathStateLoadLimit = Math.min(
+      200,
+      perNamespaceExpandedCap + Math.max(8, perNamespaceExpandedCap * 4)
+    );
+    const graphCandidateScanLimit = hasHistoricalAsOf ? 200 : graphPathStateLoadLimit;
     const seedPaths = [];
     const seedResults = [];
     const expandedPaths = [];
@@ -5549,9 +6187,7 @@ var GraphRecallCoordinator = class {
         [namespace]
       ) : (await Promise.all(
         seedCandidates.map(
-          (result) => this.graphSeedPathRelativeToStorage(storage, result, [
-            namespace
-          ])
+          (result) => this.graphSeedPathRelativeToStorage(storage, result, [namespace])
         )
       )).filter(
         (value) => typeof value === "string" && value.length > 0
@@ -5563,61 +6199,168 @@ var GraphRecallCoordinator = class {
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path5.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path7.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
+      const nodeMemoryCache = /* @__PURE__ */ new Map();
+      const readGraphNode = async (nodeId, allowArchiveLookup) => {
+        if (nodeMemoryCache.has(nodeId)) return nodeMemoryCache.get(nodeId) ?? null;
+        const memory = await this.graphPathStateLoader.readNode(
+          storage,
+          nodeId,
+          options.deadlineAtMs,
+          allowArchiveLookup
+        );
+        nodeMemoryCache.set(nodeId, memory);
+        return memory;
+      };
+      const scoringEnabled = config.graphPathScoring.enabled;
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
         config.maxGraphTraversalSteps,
         {
           ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {},
+          ...scoringEnabled ? { recordPaths: true } : {},
           ...typeof options.deadlineAtMs === "number" ? { deadlineAtMs: options.deadlineAtMs } : {}
         }
       );
       if (expanded.length === 0) continue;
       if (deadlineExpired()) break;
-      for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
+      if (!scoringEnabled) {
+        let eligibleCount = 0;
+        for (const candidate of expanded.slice(0, graphCandidateScanLimit)) {
+          if (seedSet.has(candidate.path)) continue;
+          const memory = await readGraphNode(candidate.path, false);
+          if (deadlineExpired()) break;
+          if (!memory) continue;
+          if (/(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(memory.path)) continue;
+          if (!isEligibleGraphCandidate(memory, storage.dir)) continue;
+          const score = blendGraphExpandedRecallScore({
+            graphActivationScore: candidate.score,
+            seedRecallScore,
+            activationWeight: config.graphExpansionActivationWeight,
+            blendMin: config.graphExpansionBlendMin,
+            blendMax: config.graphExpansionBlendMax
+          });
+          expandedResults.push({
+            docid: memory.frontmatter.id,
+            path: memory.path,
+            namespace,
+            snippet: memory.content.slice(0, 400),
+            score
+          });
+          expandedPaths.push({
+            path: memory.path,
+            score,
+            namespace,
+            seed: path7.resolve(storage.dir, candidate.seed),
+            hopDepth: candidate.hopDepth,
+            decayedWeight: candidate.decayedWeight,
+            graphType: candidate.graphType,
+            edgeConfidence: candidate.edgeConfidence
+          });
+          eligibleCount += 1;
+          if (eligibleCount >= perNamespaceExpandedCap) break;
+        }
+        continue;
+      }
+      const nodeStates = /* @__PURE__ */ new Map();
+      const addState = (memory) => {
+        const relativePath = graphPathRelativeToStorage(storage.dir, memory.path);
+        const lifecyclePath = toMemoryPathRel(storage.dir, memory.path);
+        const state = {
+          id: memory.frontmatter.id,
+          status: normalizeInferredPathNodeStatus(
+            inferMemoryStatus(memory.frontmatter, lifecyclePath)
+          ),
+          created: memory.frontmatter.created,
+          valid_at: memory.frontmatter.valid_at,
+          invalid_at: memory.frontmatter.invalid_at,
+          supersededAt: memory.frontmatter.supersededAt,
+          eventTimeSource: memory.frontmatter.eventTimeSource
+        };
+        const add = (key) => {
+          if (!nodeStates.has(key)) nodeStates.set(key, state);
+        };
+        add(memory.frontmatter.id);
+        if (relativePath) {
+          add(relativePath);
+          if (relativePath.endsWith(".md")) add(path7.basename(relativePath, ".md"));
+        }
+        return state;
+      };
+      const scoredExpanded = [];
+      for (const candidate of expanded.slice(0, graphCandidateScanLimit)) {
         if (deadlineExpired()) break;
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path5.resolve(storage.dir, candidate.path);
-        const memory = await storage.readMemoryByPath(memoryPath);
+        const memory = await readGraphNode(candidate.path, true);
         if (deadlineExpired()) break;
         if (!memory) continue;
         if (/(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(memory.path)) continue;
-        if (memory.frontmatter.status && memory.frontmatter.status !== "active")
-          continue;
-        const snippet = memory.content.slice(0, 400);
-        const score = blendGraphExpandedRecallScore({
+        if (!isEligibleGraphCandidate(memory, storage.dir)) continue;
+        if (candidate.activationPath) {
+          for (const nodeId of candidate.activationPath.nodeIds.slice(1, -1)) {
+            if (deadlineExpired()) break;
+            const intermediate = await readGraphNode(nodeId, true);
+            if (deadlineExpired()) break;
+            if (!intermediate) {
+              log.debug(`graph path scoring missing intermediate memory state: ${nodeId}`);
+              continue;
+            }
+            const state = addState(intermediate);
+            nodeStates.set(nodeId, { ...state, id: nodeId });
+          }
+          if (deadlineExpired()) break;
+        }
+        const pathScoreDetail = scoreEvidencePathDetail(
+          candidate.activationPath ?? null,
+          nodeStates,
+          {
+            asOf: effectiveAsOf,
+            invalidNodePenalty: config.graphPathScoring.invalidNodePenalty
+          }
+        );
+        const blendedScore = blendGraphExpandedRecallScore({
           graphActivationScore: candidate.score,
           seedRecallScore,
           activationWeight: config.graphExpansionActivationWeight,
           blendMin: config.graphExpansionBlendMin,
           blendMax: config.graphExpansionBlendMax
         });
-        expandedResults.push({
-          docid: memory.frontmatter.id,
-          // Absolute path, matching the globally-unique identity of primary
-          // fanout hits, so the merge dedups a memory found by both (#2020).
-          path: memory.path,
-          namespace,
-          snippet,
-          score
-        });
-        expandedPaths.push({
+        const score = blendedScore * pathScoreDetail.score;
+        const entry = {
           path: memory.path,
           score,
           namespace,
-          seed: path5.resolve(storage.dir, candidate.seed),
+          seed: path7.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
-          // 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
+          edgeConfidence: candidate.edgeConfidence,
+          pathPenaltyApplied: pathScoreDetail.pathPenaltyApplied,
+          ...config.graphPathScoring.includePathInProvenance && candidate.activationPath ? { pathNodeIds: candidate.activationPath.nodeIds } : {}
+        };
+        scoredExpanded.push({
+          result: {
+            docid: memory.frontmatter.id,
+            path: memory.path,
+            namespace,
+            snippet: memory.content.slice(0, 400),
+            score,
+            pathPenaltyApplied: pathScoreDetail.pathPenaltyApplied,
+            ...config.graphPathScoring.includePathInProvenance && candidate.activationPath ? { pathNodeIds: candidate.activationPath.nodeIds } : {}
+          },
+          entry
         });
       }
+      scoredExpanded.sort((a, b) => {
+        if (a.result.score !== b.result.score) return a.result.score > b.result.score ? -1 : 1;
+        return a.result.path < b.result.path ? -1 : a.result.path > b.result.path ? 1 : 0;
+      });
+      for (const item of scoredExpanded.slice(0, perNamespaceExpandedCap)) {
+        expandedResults.push(item.result);
+        expandedPaths.push(item.entry);
+      }
     }
     const namespacedPrimaryResults = Array.from(byNamespace.entries()).flatMap(
       ([namespace, results]) => results.map((result) => ({ ...result, namespace }))
@@ -5631,12 +6374,12 @@ var GraphRecallCoordinator = class {
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path5.join(
+      const snapshotPath = path7.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path7.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -5751,11 +6494,11 @@ ${blocks.join("\n\n")}`;
 }
 
 // src/orchestration/recall-profile-storage.ts
-import path6 from "path";
+import path8 from "path";
 function resolveCompositeProfileStorage(options) {
   const { profileStorages, memoryDir } = options;
   const emptyProfileStorage = new Proxy(
-    { dir: path6.join(memoryDir, ".empty-scope-profile") },
+    { dir: path8.join(memoryDir, ".empty-scope-profile") },
     {
       get(target, prop) {
         if (prop in target) return Reflect.get(target, prop);
@@ -6132,7 +6875,7 @@ var RecallInternalCoordinator = class {
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path7.sep).join("/");
+        const normalizedPath = resultPath.split(path9.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -7649,11 +8392,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.deps.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.deps.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path7.join(
+        const signalPath = path9.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path7.join(workspaceDir, "BOOT.md");
+        const bootPath = path9.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -8618,7 +9361,8 @@ ${tmtNode.summary}`
                   recallNamespaces,
                   recallResultLimit,
                   deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
-                  ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
+                  ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {},
+                  ...typeof asOfMs === "number" ? { asOfMs } : {}
                 }),
                 null
               );
@@ -9691,6 +10435,8 @@ ${tmtNode.summary}`
               servedBy,
               scoreDecomposition,
               admittedBy: [],
+              ...xrayResult?.pathNodeIds ? { pathNodeIds: xrayResult.pathNodeIds } : {},
+              ...typeof xrayResult?.pathPenaltyApplied === "boolean" ? { pathPenaltyApplied: xrayResult.pathPenaltyApplied } : {},
               ...provenance ? { provenance } : {},
               ...sourceSpan ? { sourceSpan } : {},
               // Issue #1577 — per-result trust projection for X-ray visibility.
@@ -9885,10 +10631,10 @@ ${tmtNode.summary}`
 
 // src/orchestration/recall-search-pipeline.ts
 import { createHash as createHash4 } from "crypto";
-import path9 from "path";
+import path11 from "path";
 
 // src/orchestration/recall-search-prefilter.ts
-import path8 from "path";
+import path10 from "path";
 async function fetchActiveArtifactsForNamespace(deps, namespace, prompt, targetCount, options = {}) {
   const storage = await deps.storageRouter.storageFor(namespace);
   let fetchLimit = computeArtifactCandidateFetchLimit(targetCount);
@@ -10017,7 +10763,7 @@ async function searchEmbeddingFallback(deps, query, limit) {
   if (hits.length === 0) return [];
   const results = [];
   for (const hit of hits) {
-    const fullPath = path8.isAbsolute(hit.path) ? hit.path : path8.join(deps.config.memoryDir, hit.path);
+    const fullPath = path10.isAbsolute(hit.path) ? hit.path : path10.join(deps.config.memoryDir, hit.path);
     const memory = await deps.storage.readMemoryByPath(fullPath);
     if (!memory) continue;
     results.push({
@@ -10385,7 +11131,7 @@ var RecallSearchPipelineCoordinator = class {
           const storage = await this.deps.storageRouter.storageFor(namespace);
           const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
           if (!storageDir) continue;
-          const recallRoot = path9.resolve(storageDir);
+          const recallRoot = path11.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -10409,8 +11155,8 @@ var RecallSearchPipelineCoordinator = class {
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path9.isAbsolute(result.path)) {
-          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path9.resolve(result.path)))) {
+        if (path11.isAbsolute(result.path)) {
+          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path11.resolve(result.path)))) {
             scopedResults.push(result);
           }
           continue;
@@ -10429,7 +11175,8 @@ var RecallSearchPipelineCoordinator = class {
         recallNamespaces: options.recallNamespaces,
         recallResultLimit: options.recallResultLimit,
         deadlineAtMs: options.deadlineAtMs,
-        ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
+        ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {},
+        ...typeof options.asOfMs === "number" ? { asOfMs: options.asOfMs } : {}
       });
       results = merged;
     }
@@ -11499,7 +12246,7 @@ var TurnIngestionCoordinator = class {
 
 // src/orchestration/recall-introspection.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import path11 from "path";
+import path13 from "path";
 
 // src/taxonomy/default-taxonomy.ts
 var DEFAULT_TAXONOMY = {
@@ -11622,7 +12369,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile as readFile3, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path10 from "path";
+import path12 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -11720,7 +12467,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path10.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path12.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile3(taxonomyPath, "utf-8");
@@ -11770,16 +12517,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path10.join(memoryDir, TAXONOMY_DIR);
+  const dir = path12.join(memoryDir, TAXONOMY_DIR);
   await mkdir4(dir, { recursive: true });
-  const filePath = path10.join(dir, TAXONOMY_FILE);
+  const filePath = path12.join(dir, TAXONOMY_FILE);
   await writeFile4(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path10.join(memoryDir, TAXONOMY_DIR);
+  return path12.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path10.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path12.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/orchestration/recall-introspection.ts
@@ -11803,7 +12550,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(
+    const snapshotPath = path13.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -11842,7 +12589,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path13.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -11875,7 +12622,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(
+    const snapshotPath = path13.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -11938,7 +12685,9 @@ var RecallIntrospectionCoordinator = class {
       `Expanded paths (${snapshot.expandedCount}, showing ${expanded.length}):`,
       ...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})`;
+        const pathLabel = Array.isArray(e.pathNodeIds) && e.pathNodeIds.length > 0 ? `, path=${e.pathNodeIds.join("->")}` : "";
+        const penaltyLabel = typeof e.pathPenaltyApplied === "boolean" ? `, penalty=${e.pathPenaltyApplied ? "yes" : "no"}` : "";
+        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}${penaltyLabel}${pathLabel})`;
       }),
       `Final ranked results (${snapshot.finalResults?.length ?? 0}, showing ${finalResults.length}):`,
       ...finalResults.map(
@@ -12165,12 +12914,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path11.join(
+      const snapshotPath = path13.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path13.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12182,12 +12931,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path11.join(
+      const snapshotPath = path13.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path13.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12202,8 +12951,8 @@ var RecallIntrospectionCoordinator = class {
       const stateDir = await this.deps.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path11.join(stateDir, "last_intent.json");
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path13.join(stateDir, "last_intent.json");
+      await mkdir5(path13.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12217,7 +12966,7 @@ var RecallIntrospectionCoordinator = class {
 
 // src/orchestration/orchestrator-init.ts
 import { readdir as readdir2, stat as stat2, unlink as unlink2 } from "fs/promises";
-import path12 from "path";
+import path14 from "path";
 var OrchestratorInitCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -12321,7 +13070,7 @@ var OrchestratorInitCoordinator = class {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path12.join(wsDir, f);
+            const fp = path14.join(wsDir, f);
             const s = await stat2(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink2(fp).catch(() => {
@@ -12673,7 +13422,7 @@ var OrchestratorInitCoordinator = class {
 };
 
 // src/orchestration/persistence-index.ts
-import path13 from "path";
+import path15 from "path";
 var PersistenceIndexCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -12859,7 +13608,7 @@ var PersistenceIndexCoordinator = class {
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path13.relative(storage.dir, m.path);
+            const rel = path15.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -13007,8 +13756,8 @@ var PersistenceIndexCoordinator = class {
 };
 
 // src/orchestration/workspace-ops.ts
-import { lstat, mkdir as mkdir6, readFile as readFile5, readdir as readdir3, realpath, writeFile as writeFile6 } from "fs/promises";
-import path14 from "path";
+import { lstat as lstat2, mkdir as mkdir6, readFile as readFile5, readdir as readdir3, realpath as realpath2, writeFile as writeFile6 } from "fs/promises";
+import path16 from "path";
 
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
@@ -14915,8 +15664,8 @@ var MeetingsService = class {
 // src/orchestration/workspace-ops.ts
 var MEETINGS_BUILD_DEBOUNCE_MS = 5e3;
 function matchesMemoryPath(candidatePath, requestedPath, memoryDir) {
-  const normalizedCandidate = path14.resolve(candidatePath);
-  return normalizedCandidate === path14.resolve(requestedPath) || normalizedCandidate === path14.resolve(memoryDir, requestedPath);
+  const normalizedCandidate = path16.resolve(candidatePath);
+  return normalizedCandidate === path16.resolve(requestedPath) || normalizedCandidate === path16.resolve(memoryDir, requestedPath);
 }
 function accessTrackingPathCandidates(storageDir, memoryPath) {
   const candidates = qmdResultPathCandidates(storageDir, memoryPath);
@@ -14924,12 +15673,12 @@ function accessTrackingPathCandidates(storageDir, memoryPath) {
   if (!parts) return candidates;
   candidates.push(
     ...qmdResultPathCandidates(storageDir, parts.relativePath),
-    ...qmdResultPathCandidates(path14.join(storageDir, "cold"), parts.relativePath)
+    ...qmdResultPathCandidates(path16.join(storageDir, "cold"), parts.relativePath)
   );
   return [...new Set(candidates)];
 }
 function canonicalMemoryPath(memoryPath, memoryDir) {
-  return path14.resolve(path14.isAbsolute(memoryPath) ? memoryPath : path14.resolve(memoryDir, memoryPath));
+  return path16.resolve(path16.isAbsolute(memoryPath) ? memoryPath : path16.resolve(memoryDir, memoryPath));
 }
 var WorkspaceOpsCoordinator = class {
   constructor(deps) {
@@ -15011,15 +15760,15 @@ var WorkspaceOpsCoordinator = class {
     this.deps.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path14.isAbsolute(rel) ? rel : path14.join(this.deps.config.workspaceDir, rel);
+        const abs = path16.isAbsolute(rel) ? rel : path16.join(this.deps.config.workspaceDir, rel);
         try {
           const raw = await readFile5(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path14.join(
+            const archiveDir = path16.join(
               this.deps.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path14.basename(abs);
+            const base = path16.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -15044,8 +15793,8 @@ var WorkspaceOpsCoordinator = class {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path14.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path14.dirname(fp), { recursive: true });
+        const fp = path16.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path16.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -15078,25 +15827,25 @@ var WorkspaceOpsCoordinator = class {
     const facts = [];
     let memoryRootReal = null;
     try {
-      memoryRootReal = await realpath(storage.dir);
+      memoryRootReal = await realpath2(storage.dir);
     } catch {
       memoryRootReal = null;
     }
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path14.join(storage.dir, categoryDir, date);
+        const dateDir = path16.join(storage.dir, categoryDir, date);
         try {
-          const dirStat = await lstat(dateDir);
+          const dirStat = await lstat2(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
-          assertPathInsideRoot(memoryRootReal, await realpath(dateDir), dateDir);
+          assertPathInsideRoot(memoryRootReal, await realpath2(dateDir), dateDir);
           const entries = await readdir3(dateDir, { withFileTypes: true });
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path14.join(dateDir, entry.name);
+            const fullPath = path16.join(dateDir, entry.name);
             try {
-              assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
+              assertPathInsideRoot(memoryRootReal, await realpath2(fullPath), fullPath);
               const raw = await readFile5(fullPath, "utf-8");
               const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
               if (!fmMatch) continue;
@@ -15116,7 +15865,7 @@ var WorkspaceOpsCoordinator = class {
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path14.basename(entry.name, ".md"),
+                  id: fm.id || path16.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -15139,13 +15888,13 @@ var WorkspaceOpsCoordinator = class {
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path14.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path16.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 = path14.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path16.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile5(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -15609,18 +16358,18 @@ ${reflectionsContent.trim()}
 // src/orchestration/namespace-read-fanout.ts
 import { existsSync, readFileSync } from "fs";
 import { stat as stat3 } from "fs/promises";
-import path16 from "path";
+import path18 from "path";
 
 // src/orchestration/orchestrator-namespace-scope.ts
-import path15 from "path";
+import path17 from "path";
 function computeSemanticDedupScope(targetStorage, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return {};
-  const memoryDir = path15.resolve(config.memoryDir);
-  const storageDir = path15.resolve(targetStorage.dir);
+  const memoryDir = path17.resolve(config.memoryDir);
+  const storageDir = path17.resolve(targetStorage.dir);
   if (storageDir === memoryDir) {
     return { pathExcludePrefixes: ["namespaces/"] };
   }
-  let rel = path15.relative(memoryDir, storageDir);
+  let rel = path17.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`
@@ -15673,7 +16422,7 @@ var NamespaceReadFanoutCoordinator = class {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.deps.namespaceStorageDirHintsLoaded || !this.deps.namespaceCatalog.enabled) return;
     this.deps.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path16.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path18.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -15710,7 +16459,7 @@ var NamespaceReadFanoutCoordinator = class {
       if (!this.deps.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path16.resolve(record.storageDir);
+      const resolvedStorageDir = path18.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -15894,12 +16643,12 @@ var NamespaceReadFanoutCoordinator = class {
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      return path16.join(this.deps.config.memoryDir, "state");
+      return path18.join(this.deps.config.memoryDir, "state");
     }
     if (namespace !== this.deps.config.defaultNamespace) {
-      return path16.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
+      return path18.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path16.join(
+    const candidate = path18.join(
       this.deps.config.memoryDir,
       "namespaces",
       this.deps.config.defaultNamespace
@@ -15907,11 +16656,11 @@ var NamespaceReadFanoutCoordinator = class {
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path16.join(candidate, "state");
+        return path18.join(candidate, "state");
       }
     } catch {
     }
-    return path16.join(this.deps.config.memoryDir, "state");
+    return path18.join(this.deps.config.memoryDir, "state");
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return this.deps.config.defaultNamespace;
@@ -16461,7 +17210,7 @@ var Orchestrator = class {
         loadRoutingRules: () => this.loadRoutingRules(),
         routeEngineOptions: () => this.routeEngineOptions(),
         semanticDedupLookup: (content, limit, targetStorage) => this.semanticDedupLookup(content, limit, targetStorage),
-        checkForContradiction: (content, category, namespaceScope) => this.checkForContradiction(content, category, namespaceScope),
+        checkForContradiction: (content, category, namespaceScope, anchor) => this.checkForContradiction(content, category, namespaceScope, anchor),
         applyDeferredContradictionResolve: (contradiction, storage, newMemoryId, postWriteGuard) => this.applyDeferredContradictionResolve(contradiction, storage, newMemoryId, postWriteGuard),
         suggestLinksForMemory: (content, category, namespaceScope) => this.suggestLinksForMemory(content, category, namespaceScope),
         storageDirNamespace: (storageDir) => this.storageDirNamespace(storageDir),
@@ -16692,7 +17441,7 @@ var Orchestrator = class {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path17.resolve(storageDir);
+    const resolvedStorageDir = path19.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -16703,21 +17452,21 @@ var Orchestrator = class {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path17.resolve(storageDir);
-    const resolvedMemoryDir = path17.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path19.resolve(storageDir);
+    const resolvedMemoryDir = path19.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path17.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path19.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path17.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path17.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path19.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path19.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path17.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path19.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path17.basename(resolvedStorageDir);
+    const leaf = path19.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -16857,7 +17606,7 @@ var Orchestrator = class {
     StorageManager.setScopedCacheInvalidationDefault(config.memoryDir, scopedCacheInvalidationEnabled);
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path17.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path19.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -16944,7 +17693,7 @@ var Orchestrator = class {
     this.compounding = resolveConsolidationCapabilities(config).compounding ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path17.join(
+    this.conversationIndexDir = path19.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -17092,7 +17841,7 @@ var Orchestrator = class {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path17.join(config.memoryDir, "threads"),
+      path19.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -17655,8 +18404,8 @@ ${doc.content}` : doc.content,
     );
   }
   // Issue #1526 (seam 14): graph-recall expansion moved to
-  // GraphRecallCoordinator. Thin delegation keeps the private API stable
-  // for callers (recallInternal, cold-fallback pipeline) + tests.
+  // GraphRecallCoordinator. Keep this public seam so callers and tests can
+  // override graph expansion on the orchestrator instance.
   async expandResultsViaGraph(options) {
     return this.graphRecallCoordinator.expandResultsViaGraph(options);
   }
@@ -18383,11 +19132,12 @@ ${doc.content}` : doc.content,
    * Check if a new memory contradicts an existing one.
    * Uses QMD to find similar memories, then LLM to verify contradiction.
    */
-  async checkForContradiction(content, category, namespaceScope) {
+  async checkForContradiction(content, category, namespaceScope, anchor) {
     return this.contradictionLinkingCoordinator.checkForContradiction(
       content,
       category,
-      namespaceScope
+      namespaceScope,
+      anchor
     );
   }
   /**
@@ -19195,9 +19945,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path32 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path34 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
   const kind = typeof rec.kind === "string" && rec.kind.length > 0 ? rec.kind : void 0;
-  const item = path32 !== void 0 && kind !== void 0 ? { symbol, path: path32, kind } : path32 !== void 0 ? { symbol, path: path32 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path34 !== void 0 && kind !== void 0 ? { symbol, path: path34, kind } : path34 !== void 0 ? { symbol, path: path34 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -19271,7 +20021,7 @@ var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
 import fsp from "fs/promises";
-import path18 from "path";
+import path20 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -19279,19 +20029,19 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = path18.resolve(basePath);
+    this.basePath = path20.resolve(basePath);
   }
   resolveRemotePath(remotePath) {
-    const resolved = path18.isAbsolute(remotePath) ? path18.resolve(remotePath) : path18.resolve(this.basePath, remotePath);
-    const relative = path18.relative(this.basePath, resolved);
-    if (relative === ".." || relative.startsWith(`..${path18.sep}`) || path18.isAbsolute(relative)) {
+    const resolved = path20.isAbsolute(remotePath) ? path20.resolve(remotePath) : path20.resolve(this.basePath, remotePath);
+    const relative = path20.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path20.sep}`) || path20.isAbsolute(relative)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return resolved;
   }
   isInsideBase(candidate, realBase) {
-    const relative = path18.relative(realBase, candidate);
-    return relative === "" || relative !== ".." && !relative.startsWith(`..${path18.sep}`) && !path18.isAbsolute(relative);
+    const relative = path20.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path20.sep}`) && !path20.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
@@ -19320,13 +20070,13 @@ var FilesystemBackend = class {
   }
   async ensureSafeParentDirectory(dest) {
     const realBase = await this.ensureBaseDirectory();
-    const destDir = path18.dirname(dest);
-    const relativeDir = path18.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path18.sep);
+    const destDir = path20.dirname(dest);
+    const relativeDir = path20.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path20.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path18.join(current, segment);
+      current = path20.join(current, segment);
       try {
         const stat5 = await fsp.lstat(current);
         if (stat5.isSymbolicLink()) {
@@ -19354,13 +20104,13 @@ var FilesystemBackend = class {
     if (realBase === null) {
       return null;
     }
-    const destDir = path18.dirname(dest);
-    const relativeDir = path18.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path18.sep);
+    const destDir = path20.dirname(dest);
+    const relativeDir = path20.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path20.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path18.join(current, segment);
+      current = path20.join(current, segment);
       let stat5;
       try {
         stat5 = await fsp.lstat(current);
@@ -19408,7 +20158,7 @@ var FilesystemBackend = class {
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path18.isAbsolute(remotePath)) {
+    if (path20.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
@@ -19481,7 +20231,7 @@ function createBackend(cfg) {
 
 // src/binary-lifecycle/scanner.ts
 import fsp2 from "fs/promises";
-import path19 from "path";
+import path21 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -19506,8 +20256,8 @@ async function scanForBinaries(memoryDir, config, manifest) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path19.join(dir, entry.name);
-      const relativePath = path19.relative(memoryDir, fullPath).split(path19.sep).join("/");
+      const fullPath = path21.join(dir, entry.name);
+      const relativePath = path21.relative(memoryDir, fullPath).split(path21.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -19547,15 +20297,15 @@ async function hashFile(filePath) {
 
 // src/binary-lifecycle/manifest.ts
 import fsp3 from "fs/promises";
-import path20 from "path";
+import path22 from "path";
 import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
-  return path20.join(memoryDir, MANIFEST_DIR);
+  return path22.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path20.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path22.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
@@ -19607,13 +20357,13 @@ function emptyManifest() {
 
 // src/binary-lifecycle/pipeline.ts
 import fsp4 from "fs/promises";
-import path21 from "path";
+import path23 from "path";
 import crypto3 from "crypto";
 var historicalIdCache = new HistoricalEntityCanonicalIdCache();
 function isRecallCorpusMarkdown(mdPath, memoryDir) {
-  const rel = path21.relative(memoryDir, mdPath);
-  if (rel.startsWith("..") || path21.isAbsolute(rel)) return false;
-  const top = rel.split(path21.sep)[0];
+  const rel = path23.relative(memoryDir, mdPath);
+  if (rel.startsWith("..") || path23.isAbsolute(rel)) return false;
+  const top = rel.split(path23.sep)[0];
   return RECALL_FALLBACK_DIRS.includes(top);
 }
 async function hashFile2(filePath) {
@@ -19637,13 +20387,13 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function resolveManifestAssetPath(memoryDir, originalPath) {
-  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path21.isAbsolute(originalPath) || path21.win32.isAbsolute(originalPath)) {
+  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path23.isAbsolute(originalPath) || path23.win32.isAbsolute(originalPath)) {
     return null;
   }
-  const memoryRoot = path21.resolve(memoryDir);
-  const fullPath = path21.resolve(memoryRoot, originalPath);
-  const relative = path21.relative(memoryRoot, fullPath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path21.sep}`) || path21.isAbsolute(relative)) {
+  const memoryRoot = path23.resolve(memoryDir);
+  const fullPath = path23.resolve(memoryRoot, originalPath);
+  const relative = path23.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path23.sep}`) || path23.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -19654,7 +20404,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path21.sep).join("/");
+  const normalized = relPath.split(path23.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -19667,11 +20417,11 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
   for (const relPath of newPaths) {
-    const fullPath = path21.join(memoryDir, relPath);
+    const fullPath = path23.join(memoryDir, relPath);
     try {
       const stat5 = await fsp4.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path21.extname(relPath);
+      const ext = path23.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -19809,7 +20559,7 @@ async function stageRedirect(memoryDir, assets, log2, dryRun, readMarkdownFile,
     for (const update of updates) {
       try {
         await withRawEntityPageMutation(memoryDir, update.mdPath, async () => {
-          const stateDir = path21.join(memoryDir, "state");
+          const stateDir = path23.join(memoryDir, "state");
           const kind = classifyEntityRefWritePath(memoryDir, update.mdPath);
           if (kind === "memory") {
             const idsAtWrite = historicalIdCache.get(stateDir);
@@ -19903,10 +20653,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path21.dirname(mdPath);
+  const mdDir = path23.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path21.sep).join("/");
+    const normalized = candidate.split(path23.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -19914,10 +20664,10 @@ function markdownReferencePattern(asset, assetAbsolute, mdPath) {
       candidates.add(`./${normalized}`);
     }
   };
-  addCandidate(path21.relative(mdDir, assetAbsolute));
-  const originalPath = asset.originalPath.split(path21.sep).join("/");
-  const originalAsFileRelative = path21.resolve(mdDir, ...originalPath.split("/"));
-  if (path21.resolve(originalAsFileRelative) === path21.resolve(assetAbsolute)) {
+  addCandidate(path23.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path23.sep).join("/");
+  const originalAsFileRelative = path23.resolve(mdDir, ...originalPath.split("/"));
+  if (path23.resolve(originalAsFileRelative) === path23.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -20013,7 +20763,7 @@ async function findMarkdownFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path21.join(current, entry.name);
+      const full = path23.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -20088,7 +20838,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path22 from "path";
+import path24 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -20103,8 +20853,8 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  const resolvedMemoryDir = path22.resolve(memoryDir);
-  const resolvedOutputDir = path22.resolve(outputDir);
+  const resolvedMemoryDir = path24.resolve(memoryDir);
+  const resolvedOutputDir = path24.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -20142,7 +20892,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path22.join(memoryDir, "entities");
+    const entitiesDir = path24.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -20154,7 +20904,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path22.basename(filePath, ".md");
+        const fileName = path24.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -20166,7 +20916,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path22.join(memoryDir, "questions");
+    const questionsDir = path24.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -20207,8 +20957,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path22.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path22.isAbsolute(relative);
+  const relative = path24.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path24.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -20245,12 +20995,12 @@ function assertSafeInputRoot(realMemoryDir, targetPath, label) {
 }
 function assertSafeOutputTarget(realOutputDir, outputPath) {
   let current = realOutputDir;
-  const relative = path22.relative(realOutputDir, outputPath);
-  if (relative.startsWith("..") || path22.isAbsolute(relative)) {
+  const relative = path24.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path24.isAbsolute(relative)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
-  for (const segment of relative.split(path22.sep).filter(Boolean)) {
-    current = path22.join(current, segment);
+  for (const segment of relative.split(path24.sep).filter(Boolean)) {
+    current = path24.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -20280,17 +21030,17 @@ function validateProjectionCategories(categories) {
   return validated;
 }
 function resolveContainedOutputPath(outputRoot, ...segments) {
-  const resolved = path22.resolve(outputRoot, ...segments);
-  const relative = path22.relative(outputRoot, resolved);
-  if (relative === "" || !relative.startsWith("..") && !path22.isAbsolute(relative)) {
+  const resolved = path24.resolve(outputRoot, ...segments);
+  const relative = path24.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path24.isAbsolute(relative)) {
     return resolved;
   }
   throw new Error(`context tree output path escapes outputDir: ${segments.join("/")}`);
 }
 function writeProjectedContent(realOutputDir, outputPath, generatedContent) {
   assertSafeOutputTarget(realOutputDir, outputPath);
-  fs.mkdirSync(path22.dirname(outputPath), { recursive: true });
-  const realParent = fs.realpathSync(path22.dirname(outputPath));
+  fs.mkdirSync(path24.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path24.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -20329,7 +21079,7 @@ function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path22.join(directory, entry.name);
+      const fullPath = path24.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -20382,13 +21132,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path22.basename(filePath, ".md");
-  const dateDir = path22.basename(path22.dirname(filePath));
+  const fileName = path24.basename(filePath, ".md");
+  const dateDir = path24.basename(path24.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path22.join(category, dateDir, `${fileName}.md`);
+    relPath = path24.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path22.join(category, `${fileName}.md`);
+    relPath = path24.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -20434,7 +21184,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path22.join("entities", `${fileName}.md`),
+    path: path24.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -20487,7 +21237,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path23 from "path";
+import path25 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -20589,7 +21339,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path23.resolve(options.directory ?? process.cwd());
+  const directory = path25.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -20631,7 +21381,7 @@ function walkDir(root, exclude, maxDepth) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path23.join(dir, entry.name);
+      const fullPath = path25.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -20646,11 +21396,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path23.extname(f).toLowerCase();
+    const ext = path25.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path23.dirname(f) === root).map((f) => path23.basename(f))
+    files.filter((f) => path25.dirname(f) === root).map((f) => path25.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -20694,7 +21444,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path23.dirname(f) === root).map((f) => path23.basename(f))
+    files.filter((f) => path25.dirname(f) === root).map((f) => path25.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -20705,7 +21455,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path23.join(root, "package.json"));
+    const pkg = readJsonSafe(path25.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -20719,13 +21469,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path23.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path25.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path23.join(root, "package.json"));
+    const pkg = readJsonSafe(path25.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -20759,8 +21509,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path23.basename(filePath).toLowerCase();
-    const relPath = path23.relative(root, filePath);
+    const basename = path25.basename(filePath).toLowerCase();
+    const relPath = path25.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -20772,7 +21522,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path23.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path25.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -20793,7 +21543,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path23.sep);
+  const parts = relPath.split(path25.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -20837,7 +21587,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path24 from "path";
+import path26 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -20928,12 +21678,12 @@ function resolveTargets(targetPath) {
   const extensions = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
   function walk(dir) {
     for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-      const fullPath = path24.join(dir, entry.name);
+      const fullPath = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path24.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path26.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -20942,12 +21692,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path24.resolve(targetPath);
+  const resolvedTarget = path26.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path24.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path26.dirname(resolvedTarget) : resolvedTarget;
 }
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path24.relative(projectRoot, path24.resolve(filePath)) || path24.basename(filePath);
+  const relativePath = path26.relative(projectRoot, path26.resolve(filePath)) || path26.basename(filePath);
   const statements = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paragraphs = content.split(/\n{2,}/).map((p) => p.trim()).filter((p) => p.length > 20 && p.length < 2e3);
@@ -21041,7 +21791,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs3.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path24.join(memoryDir, dir);
+    const fullDir = path26.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -21064,11 +21814,11 @@ function writeStatement(stmt, memoryDir) {
   const now = /* @__PURE__ */ new Date();
   const dateDir = now.toISOString().split("T")[0];
   const categoryDir = getCategoryDir(memoryDir, stmt.category);
-  const dir = path24.join(categoryDir, dateDir);
+  const dir = path26.join(categoryDir, dateDir);
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path24.join(dir, fileName);
-  const historicalIds = historicalIdCache2.get(path24.join(memoryDir, "state"));
+  const filePath = path26.join(dir, fileName);
+  const historicalIds = historicalIdCache2.get(path26.join(memoryDir, "state"));
   const rawBody = `${[
     "---",
     `id: ${stmt.id}`,
@@ -21091,7 +21841,7 @@ ${stmt.content}
   fs3.writeFileSync(filePath, body);
   try {
     repairContentAfterJournalMoveSync({
-      stateDir: path24.join(memoryDir, "state"),
+      stateDir: path26.join(memoryDir, "state"),
       cache: historicalIdCache2,
       idsAtWrite: historicalIds,
       rawContent: rawBody,
@@ -21152,7 +21902,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path24.join(dir, entry.name);
+    const fullPath = path26.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -21163,7 +21913,7 @@ function walkFiles(dir, callback) {
 
 // src/dedup/index.ts
 import fs4 from "fs";
-import path25 from "path";
+import path27 from "path";
 import crypto5 from "crypto";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_LOAD = 1e4;
@@ -21305,7 +22055,7 @@ function loadMemories(memoryDir, categories, maxLoad = 1e4) {
   const memoryRootReal = fs4.realpathSync(memoryDir);
   for (const category of allCategories) {
     if (result.length >= maxLoad) break;
-    const dir = path25.join(memoryDir, category);
+    const dir = path27.join(memoryDir, category);
     if (!fs4.existsSync(dir)) continue;
     const categoryStat = fs4.lstatSync(dir);
     if (categoryStat.isSymbolicLink()) {
@@ -21366,15 +22116,15 @@ function extractBody3(content) {
   return match ? match[1].trim() : content.trim();
 }
 function assertPathInsideRoot2(rootReal, targetReal, sourcePath) {
-  const rel = path25.relative(rootReal, targetReal);
-  if (rel === "" || !rel.startsWith("..") && !path25.isAbsolute(rel)) {
+  const rel = path27.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path27.isAbsolute(rel)) {
     return;
   }
   throw new Error(`Refusing to scan memory path outside root: ${sourcePath}`);
 }
 function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
   for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path25.join(dir, entry.name);
+    const fullPath = path27.join(dir, entry.name);
     const entryStat = fs4.lstatSync(fullPath);
     if (entryStat.isSymbolicLink()) {
       throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
@@ -21392,10 +22142,10 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
 
 // src/review/index.ts
 import fs5 from "fs";
-import path26 from "path";
+import path28 from "path";
 var historicalIdCache3 = new HistoricalEntityCanonicalIdCache();
 function writeReviewFileCanonicalized(memoryDir, filePath, content) {
-  const stateDir = path26.join(memoryDir, "state");
+  const stateDir = path28.join(memoryDir, "state");
   const idsAtWrite = historicalIdCache3.get(stateDir);
   let originalBytes = null;
   try {
@@ -21437,8 +22187,8 @@ function realMemoryRoot(memoryDir) {
   }
 }
 function isPathInside2(rootReal, candidateReal) {
-  const relative = path26.relative(rootReal, candidateReal);
-  return relative === "" || !!relative && !relative.startsWith("..") && !path26.isAbsolute(relative);
+  const relative = path28.relative(rootReal, candidateReal);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path28.isAbsolute(relative);
 }
 function isSafeDirectory(rootReal, dir) {
   try {
@@ -21481,7 +22231,7 @@ function listReviewItems(options) {
     if (filterReason && item.reviewReason !== filterReason) return;
     items.push(item);
   };
-  const suggestionsDir = path26.join(memoryDir, "suggestions");
+  const suggestionsDir = path28.join(memoryDir, "suggestions");
   if (!isLimitReached() && fs5.existsSync(suggestionsDir) && isSafeDirectory(rootReal, suggestionsDir)) {
     walkMd(rootReal, suggestionsDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -21502,7 +22252,7 @@ function listReviewItems(options) {
       return isLimitReached();
     });
   }
-  const reviewDir = path26.join(memoryDir, "review");
+  const reviewDir = path28.join(memoryDir, "review");
   if (!isLimitReached() && fs5.existsSync(reviewDir) && isSafeDirectory(rootReal, reviewDir)) {
     walkMd(rootReal, reviewDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -21527,7 +22277,7 @@ function listReviewItems(options) {
   const categories = ALL_CATEGORY_DIRS;
   for (const category of categories) {
     if (isLimitReached()) break;
-    const dir = path26.join(memoryDir, category);
+    const dir = path28.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     walkMd(rootReal, dir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -21609,9 +22359,9 @@ function approveItem(memoryDir, itemId, options) {
   const targetDir = getCategoryDir(memoryDir, category);
   const dateDir = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   ensureSafeDirectory(rootReal, targetDir);
-  const outputPath = path26.join(targetDir, dateDir, path26.basename(found.filePath));
-  ensureSafeDirectory(rootReal, path26.dirname(outputPath));
-  const reviewStateDir = path26.join(memoryDir, "state");
+  const outputPath = path28.join(targetDir, dateDir, path28.basename(found.filePath));
+  ensureSafeDirectory(rootReal, path28.dirname(outputPath));
+  const reviewStateDir = path28.join(memoryDir, "state");
   const idsAtWrite = historicalIdCache3.get(reviewStateDir);
   const promotedWritten = canonicalizeEntityRefFrontmatter(updatedContent, idsAtWrite);
   const promotedPath = writeFileWithoutClobber(outputPath, promotedWritten, itemId);
@@ -21688,13 +22438,13 @@ function findReviewFileById(memoryDir, id, options = {}) {
   const rootReal = realMemoryRoot(memoryDir);
   if (!rootReal) return null;
   for (const loc of ["suggestions", "review"]) {
-    const dir = path26.join(memoryDir, loc);
+    const dir = path28.join(memoryDir, loc);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id);
     if (found) return { filePath: found, location: "queue" };
   }
   for (const category of ALL_CATEGORY_DIRS) {
-    const dir = path26.join(memoryDir, category);
+    const dir = path28.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id, (fm) => isLowConfidenceReviewCandidate(fm, options));
     if (found) return { filePath: found, location: "category" };
@@ -21770,10 +22520,10 @@ function readFileSafe3(filePath) {
   }
 }
 function writeFileWithoutClobber(basePath, content, discriminator) {
-  const parsed = path26.parse(basePath);
+  const parsed = path28.parse(basePath);
   const safeDiscriminator = sanitizeFilePart(discriminator);
   for (let attempt = 0; attempt < 1e3; attempt++) {
-    const candidate = attempt === 0 ? basePath : path26.join(
+    const candidate = attempt === 0 ? basePath : path28.join(
       parsed.dir,
       `${parsed.name}-${safeDiscriminator}${attempt === 1 ? "" : `-${attempt}`}${parsed.ext || ".md"}`
     );
@@ -21829,7 +22579,7 @@ function extractBody4(content) {
 function walkMd(rootReal, dir, callback) {
   if (!isSafeDirectory(rootReal, dir)) return false;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path26.join(dir, entry.name);
+    const fullPath = path28.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       if (walkMd(rootReal, fullPath, callback)) return true;
@@ -21844,7 +22594,7 @@ function walkMdPaths(rootReal, dir) {
   const results = [];
   if (!isSafeDirectory(rootReal, dir)) return results;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path26.join(dir, entry.name);
+    const fullPath = path28.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       results.push(...walkMdPaths(rootReal, fullPath));
@@ -21857,7 +22607,7 @@ function walkMdPaths(rootReal, dir) {
 
 // src/sync/index.ts
 import fs6 from "fs";
-import path27 from "path";
+import path29 from "path";
 import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -21879,7 +22629,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path27.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path29.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -21895,7 +22645,7 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs6.mkdirSync(path27.dirname(stateFilePath), { recursive: true });
+    fs6.mkdirSync(path29.dirname(stateFilePath), { recursive: true });
     fs6.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -21961,13 +22711,13 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path27.join(dir, entry.name);
+      const fullPath = path29.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path27.extname(entry.name).toLowerCase();
+        const ext = path29.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path27.relative(root, fullPath);
+        const relPath = path29.relative(root, fullPath);
         try {
           const content = fs6.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
@@ -21982,7 +22732,7 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path27.join(sourceDir, relPath);
+    const fullPath = path29.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -22015,7 +22765,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path27.join(sourceDir, relPath),
+        filePath: path29.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -22045,21 +22795,21 @@ function hashContent3(content) {
 import { spawnSync } from "child_process";
 import crypto7 from "crypto";
 import fs7 from "fs";
-import path28 from "path";
+import path30 from "path";
 var historicalIdCache4 = new HistoricalEntityCanonicalIdCache();
 var MANIFEST_VERSION = 1;
 var MANIFEST_LOCK_STALE_MS = 3e4;
 var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
 var MANIFEST_LOCK_SLEEP_MS = 20;
 function normalizeSpaceMemoryDir(memoryDir) {
-  return path28.resolve(memoryDir);
+  return path30.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path28.join(homeDir, ".config", "engram", "spaces");
+  return path30.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path28.join(getSpacesDir(baseDir), "manifest.json");
+  return path30.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   if (fs7.existsSync(getManifestPath(baseDir))) {
@@ -22106,9 +22856,9 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path28.dirname(manifestPath2);
+  const manifestDir2 = path30.dirname(manifestPath2);
   fs7.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path28.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const tempPath = path30.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
   try {
     fs7.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
@@ -22123,7 +22873,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs7.mkdirSync(path28.dirname(lockDir), { recursive: true });
+  fs7.mkdirSync(path30.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -22149,7 +22899,7 @@ function acquireManifestLock(lockDir) {
     try {
       fs7.mkdirSync(lockDir, { recursive: false });
       try {
-        fs7.writeFileSync(path28.join(lockDir, "owner"), `${owner}
+        fs7.writeFileSync(path30.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
         fs7.rmSync(lockDir, { recursive: true, force: true });
@@ -22179,7 +22929,7 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path28.join(lockDir, "owner");
+    const ownerPath = path30.join(lockDir, "owner");
     if (fs7.readFileSync(ownerPath, "utf8").trim() === owner) {
       fs7.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -22195,7 +22945,7 @@ function removeStaleManifestLock(lockDir) {
   try {
     fs7.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs7.writeFileSync(path28.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs7.writeFileSync(path30.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
       fs7.rmSync(reclaimDir, { recursive: true, force: true });
@@ -22270,7 +23020,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs7.readFileSync(path28.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs7.readFileSync(path30.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -22342,8 +23092,8 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path28.join(homeDir, ".engram", "memory");
-  const openclawPath = path28.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const standalonePath = path30.join(homeDir, ".engram", "memory");
+  const openclawPath = path30.join(homeDir, ".openclaw", "workspace", "memory", "local");
   const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs7.existsSync(standalonePath) ? standalonePath : fs7.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -22372,7 +23122,7 @@ function createSpace(options) {
   const id = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const memoryDir = normalizeSpaceMemoryDir(
-    options.memoryDir ?? path28.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path30.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -22593,14 +23343,14 @@ async function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path28.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path30.join(getSpacesDir(baseDir), "audit.jsonl");
   if (!fs7.existsSync(auditPath)) return [];
   const lines = fs7.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path28.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs7.mkdirSync(path28.dirname(auditPath), { recursive: true });
+  const auditPath = path30.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs7.mkdirSync(path30.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -22621,11 +23371,11 @@ async function copyMemories(sourceDir, targetDir, options) {
     sourceFiles.filter((p) => {
       const rp = safeRealpath(p);
       if (!rp || !isPathInsideRoot(rp, sourceRoot)) return false;
-      const rel = path28.relative(sourceRoot, rp);
-      const mapped = path28.resolve(targetRoot, rel);
+      const rel = path30.relative(sourceRoot, rp);
+      const mapped = path30.resolve(targetRoot, rel);
       if (!isPathInsideRoot(mapped, targetRoot)) return false;
       return classifyEntityRefWritePath(targetRoot, mapped) === "entity";
-    }).map((p) => path28.basename(p, ".md"))
+    }).map((p) => path30.basename(p, ".md"))
   );
   const firstEntityId = sourceEntityIds.values().next().value;
   if (firstEntityId === void 0) {
@@ -22633,7 +23383,7 @@ async function copyMemories(sourceDir, targetDir, options) {
   }
   return withRawEntityPageMutation(
     targetRoot,
-    path28.join(targetRoot, "entities", `${firstEntityId}.md`),
+    path30.join(targetRoot, "entities", `${firstEntityId}.md`),
     async () => copyPreparedMemories(
       sourceFiles,
       sourceRoot,
@@ -22660,14 +23410,14 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       continue;
     }
     const content = fs7.readFileSync(sourcePath, "utf8");
-    const relativePath = path28.relative(sourceRoot, sourceRealPath);
-    const targetPath = path28.resolve(targetRoot, relativePath);
+    const relativePath = path30.relative(sourceRoot, sourceRealPath);
+    const targetPath = path30.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
     }
     const targetKind = classifyEntityRefWritePath(targetRoot, targetPath);
-    const idsAtCompare = historicalIdCache4.get(path28.join(targetRoot, "state"));
+    const idsAtCompare = historicalIdCache4.get(path30.join(targetRoot, "state"));
     const sourceRef = targetKind === "memory" ? readEntityRefFromFrontmatter(content) : null;
     const refHasSourceClaimant = sourceRef !== null && sourceEntityIds.has(sourceRef);
     const canonicalContent = targetKind === "memory" && !refHasSourceClaimant ? canonicalizeEntityRefFrontmatter(content, idsAtCompare) : content;
@@ -22694,7 +23444,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     if (fs7.existsSync(targetPath) && !options?.force) {
       const targetContent = fs7.readFileSync(targetPath, "utf8");
       const targetHash = hashContent4(targetContent);
-      if (hashContent4(canonicalContent) === targetHash && historicalIdCache4.get(path28.join(targetRoot, "state")) === idsAtCompare) {
+      if (hashContent4(canonicalContent) === targetHash && historicalIdCache4.get(path30.join(targetRoot, "state")) === idsAtCompare) {
         skipped++;
         continue;
       }
@@ -22710,13 +23460,13 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    fs7.mkdirSync(path28.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path28.dirname(targetPath));
+    fs7.mkdirSync(path30.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path30.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
     }
-    const stateDir = path28.join(targetRoot, "state");
+    const stateDir = path30.join(targetRoot, "state");
     if (targetKind === "memory" && !refHasSourceClaimant) {
       const idsAtWrite = historicalIdCache4.get(stateDir);
       const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
@@ -22760,7 +23510,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     bumpMemoryCorpusVersionForDir(targetRoot);
   }
   if (reconcileNeeded) {
-    requestEntityCanonicalIdReconcileSync(path28.join(targetRoot, "state"));
+    requestEntityCanonicalIdReconcileSync(path30.join(targetRoot, "state"));
   }
   return { merged, conflicts, skipped };
 }
@@ -22771,7 +23521,7 @@ function walkMd2(dir) {
   const results = [];
   function walk(d) {
     for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path28.join(d, entry.name);
+      const fullPath = path30.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -22800,8 +23550,8 @@ function safeRealpath(filePath) {
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path28.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path28.isAbsolute(relative);
+  const relative = path30.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path30.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -22922,7 +23672,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 // src/memory-extension/codex-publisher.ts
 import fs8 from "fs";
 import os from "os";
-import path29 from "path";
+import path31 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -22931,12 +23681,12 @@ function resolveEnvHome(env) {
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path29.join(homeDir, input.slice(2));
+    return path31.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path29.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path31.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -22950,12 +23700,12 @@ var CodexMemoryExtensionPublisher = class {
   async resolveExtensionRoot(env) {
     const homeDir = resolveEnvHome(env);
     const codexHomeInput = env === void 0 ? readEnvVar("CODEX_HOME")?.trim() : env.CODEX_HOME?.trim();
-    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path29.resolve(homeDir, ".codex");
-    return path29.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path31.resolve(homeDir, ".codex");
+    return path31.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path29.join(resolveHomeDir(), ".codex");
+      const home = readEnvVar("CODEX_HOME")?.trim() || path31.join(resolveHomeDir(), ".codex");
       return fs8.existsSync(home);
     } catch {
       return false;
@@ -23006,7 +23756,7 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path29.join(extensionRoot, "instructions.md");
+    const instructionsPath = path31.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -23381,8 +24131,8 @@ async function generateActivityMemories(date, digestBody, config, deps) {
 
 // src/session-summaries/index.ts
 import { createHash as createHash7 } from "crypto";
-import { lstat as lstat2, mkdir as mkdir7, readFile as readFile6, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path30 from "path";
+import { lstat as lstat3, mkdir as mkdir7, readFile as readFile6, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
+import path32 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -23887,7 +24637,7 @@ function shortHash(value, length = 16) {
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path30.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path32.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -23897,13 +24647,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path30.join(dir, entry.name);
+      const fullPath = path32.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path30.extname(entry.name).toLowerCase();
+      const ext = path32.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -23930,7 +24680,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path30.resolve(expandTildePath(inputDir.trim()));
+  return path32.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -24025,7 +24775,7 @@ function buildDraft(options) {
 }
 async function collectLocalSessionSummaries(options) {
   const inputDir = normalizeInputDir(options.inputDir);
-  const inputLstat = await lstat2(inputDir);
+  const inputLstat = await lstat3(inputDir);
   if (inputLstat.isSymbolicLink()) {
     throw new Error(`inputDir must not be a symbolic link: ${options.inputDir}`);
   }
@@ -24087,11 +24837,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path30.extname(filePath).toLowerCase();
+    const fileExtension = path32.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path30.basename(filePath),
+        fileName: path32.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -24147,7 +24897,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile6(path30.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile6(path32.resolve(expandTildePath(pathLike)), "utf-8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("redaction config must be a JSON object");
@@ -24160,15 +24910,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path30.join(
-    path30.resolve(expandTildePath(memoryDir)),
+  return path32.join(
+    path32.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path30.dirname(filePath), { recursive: true });
+  await mkdir7(path32.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -24186,7 +24936,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path30.resolve(expandTildePath(options.output));
+    const outputPath = path32.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -24220,20 +24970,20 @@ async function runLocalSessionSummaryCliCommand(options) {
 }
 
 // src/transfer/capsule-fork.ts
-import { lstat as lstat3, mkdir as mkdir8, readFile as readFile7, realpath as realpath2, writeFile as writeFile8 } from "fs/promises";
-import path31 from "path";
+import { lstat as lstat4, mkdir as mkdir8, readFile as readFile7, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
+import path33 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path31.resolve(opts.targetRoot);
+  const rootAbs = path33.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path31.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path33.join(rootAbs, "forks", opts.forkId);
   const forkEntryExists = await pathEntryExists(forkDirAbs);
   if (forkEntryExists) {
     throw new Error(
       `forkCapsule: fork path already exists \u2014 forkId "${opts.forkId}" is already in use at: ${forkDirAbs}`
     );
   }
-  const archiveAbs = path31.resolve(opts.sourceArchive);
+  const archiveAbs = path33.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -24255,10 +25005,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path31.join(forkDirAbs, "lineage.json");
-  const rootReal = await realpath2(rootAbs);
+  const lineagePath = path33.join(forkDirAbs, "lineage.json");
+  const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path31.dirname(lineagePath), { recursive: true });
+  await mkdir8(path33.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -24272,11 +25022,11 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path31.resolve(targetRoot);
-  const rootReal = await realpath2(rootAbs).catch(() => rootAbs);
-  const lineagePath = path31.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path31.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path31.isAbsolute(rel)) {
+  const rootAbs = path33.resolve(targetRoot);
+  const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
+  const lineagePath = path33.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path33.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path33.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -24311,25 +25061,25 @@ function validateForkId(forkId) {
   }
 }
 async function pathEntryExists(absPath) {
-  const st = await lstat3(absPath).catch(() => null);
+  const st = await lstat4(absPath).catch(() => null);
   return st !== null;
 }
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path31.dirname(existing)) {
-    const st = await lstat3(existing).catch(() => null);
+  while (existing !== path33.dirname(existing)) {
+    const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path31.basename(existing));
-    existing = path31.dirname(existing);
+    suffix.unshift(path33.basename(existing));
+    existing = path33.dirname(existing);
   }
-  const existingReal = await realpath2(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path31.join(existingReal, ...suffix) : existingReal;
-  const rel = path31.relative(rootReal, targetReal);
+  const existingReal = await realpath3(existing).catch(() => existing);
+  const targetReal = suffix.length > 0 ? path33.join(existingReal, ...suffix) : existingReal;
+  const rel = path33.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path31.sep}`)) return false;
-  if (path31.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path33.sep}`)) return false;
+  if (path33.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -24448,4 +25198,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-IK6X5QPO.js.map
+//# sourceMappingURL=chunk-ZHY5TMJG.js.map