@remnic/core 9.69.22 → 9.69.24

package/dist/{chunk-VLAQV4HT.js → chunk-RJYJ7KR7.js}

@@ -6,23 +6,23 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-46QMN7I7.js";
+} from "./chunk-PAZY2ZKP.js";
+import {
+  runPeerProfileReasoner
+} from "./chunk-I74SUMNI.js";
 import {
   CompressionGuidelineCoordinator
 } from "./chunk-UXREWVW4.js";
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-PPOT6SPR.js";
-import {
-  runPeerProfileReasoner
-} from "./chunk-I74SUMNI.js";
+} from "./chunk-UNNPNBR2.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-X2NFFBTO.js";
+} from "./chunk-2L5FSNPC.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -32,27 +32,18 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-ZL3XX5LW.js";
+} from "./chunk-XM24CDZX.js";
 import {
   SharedContextManager
 } from "./chunk-IN673LEP.js";
-import {
-  cleanArchivedUserMessage
-} from "./chunk-47DU4SGJ.js";
 import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
-} from "./chunk-SEF4IOFE.js";
-import {
-  extractTopics
-} from "./chunk-KVDUKH5E.js";
+} from "./chunk-SWIKABKI.js";
 import {
-  buildTemporalTimelineRecallSection
-} from "./chunk-2NKY7OC6.js";
-import {
-  CODEX_THREAD_KEY_PREFIX
-} from "./chunk-4EX5WZ4M.js";
+  cleanArchivedUserMessage
+} from "./chunk-47DU4SGJ.js";
 import {
   TierMigrationExecutor
 } from "./chunk-YRFAYOFQ.js";
@@ -62,6 +53,15 @@ import {
 import {
   TmtBuilder
 } from "./chunk-ECZU5BJH.js";
+import {
+  extractTopics
+} from "./chunk-KVDUKH5E.js";
+import {
+  buildTemporalTimelineRecallSection
+} from "./chunk-2NKY7OC6.js";
+import {
+  CODEX_THREAD_KEY_PREFIX
+} from "./chunk-4EX5WZ4M.js";
 import {
   buildTargetedFactRecallSection,
   shouldRecallTargetedFactEvidence
@@ -69,10 +69,6 @@ import {
 import {
   SessionObserverState
 } from "./chunk-ODZKV2F7.js";
-import {
-  buildResponseGuidanceRecallSection,
-  shouldRecallResponseGuidance
-} from "./chunk-6TCXIRP5.js";
 import {
   mergeWithAgentResults,
   runDirectAgent,
@@ -97,9 +93,6 @@ import {
 import {
   applyRuntimeRetrievalPolicy
 } from "./chunk-5IZL4DCV.js";
-import {
-  findUnresolvedEntityRefs
-} from "./chunk-X7XN6YU4.js";
 import {
   RelevanceStore
 } from "./chunk-KATEWTQJ.js";
@@ -108,6 +101,13 @@ import {
   reorderByRankedKeys,
   rerankLocalOrNoop
 } from "./chunk-LUDXM7MD.js";
+import {
+  buildResponseGuidanceRecallSection,
+  shouldRecallResponseGuidance
+} from "./chunk-6TCXIRP5.js";
+import {
+  findUnresolvedEntityRefs
+} from "./chunk-X7XN6YU4.js";
 import {
   applyRecallStateViews
 } from "./chunk-FYDW33ZB.js";
@@ -137,14 +137,14 @@ import {
 } from "./chunk-3GPTTA4J.js";
 import {
   runLiveConnectorsOnce
-} from "./chunk-HTIIXNJQ.js";
+} from "./chunk-4FIH6MPS.js";
 import {
   deriveHarmonicRecords,
   harmonicEntityReferenceMatches,
   harmonicEntitySegment,
   normalizedHarmonicEntityIdentity,
   persistHarmonicRecords
-} from "./chunk-LDWIPYJ6.js";
+} from "./chunk-LS2FHUML.js";
 import {
   classifyMemoryKind
 } from "./chunk-YAZNBMNF.js";
@@ -153,7 +153,7 @@ import {
 } from "./chunk-XXSOVESA.js";
 import {
   ExtractionEngine
-} from "./chunk-7RRUHJPG.js";
+} from "./chunk-KB2G2I6Q.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-AJTG3CP7.js";
@@ -161,9 +161,6 @@ import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
 } from "./chunk-OH7QLI6W.js";
-import {
-  recordJudgeTrainingPair
-} from "./chunk-PWFCHOB3.js";
 import {
   createDeferCountMap,
   createVerdictCache,
@@ -171,12 +168,18 @@ import {
   judgeFactDurability,
   validateProcedureExtraction
 } from "./chunk-ODW5GDFE.js";
+import {
+  recordJudgeTrainingPair
+} from "./chunk-PWFCHOB3.js";
 import {
   buildExplicitCueRecallSection
 } from "./chunk-TVIVY7KU.js";
+import {
+  planEpisodeWindowsWithFallback
+} from "./chunk-T3GIETKV.js";
 import {
   buildEventOrderRecallSection
-} from "./chunk-H7BZBSP6.js";
+} from "./chunk-52II7PB6.js";
 import {
   shouldRecallEventOrderEvidence
 } from "./chunk-BUYVPUEM.js";
@@ -188,10 +191,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-FB7LAJQM.js";
-import {
-  planEpisodeWindowsWithFallback
-} from "./chunk-T3GIETKV.js";
+} from "./chunk-4TKJGOCJ.js";
 import {
   tryDirectAnswer
 } from "./chunk-VY47VI2T.js";
@@ -203,7 +203,7 @@ import {
 } from "./chunk-LVXBC6YB.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-KA2HZCMG.js";
+} from "./chunk-6NXSYYGP.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
@@ -212,27 +212,27 @@ import {
   runTimelinePublishCli,
   screenCandidateFact,
   summarizeVaultPublish
-} from "./chunk-45XVII3J.js";
-import {
-  RoutingRulesStore
-} from "./chunk-TBUEE7XF.js";
+} from "./chunk-SMWTZLHE.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
+import {
+  RoutingRulesStore
+} from "./chunk-TBUEE7XF.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-RO2X2EYM.js";
+} from "./chunk-R7RTXEYG.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-YVLENSNS.js";
+} from "./chunk-5ATKSPEQ.js";
 import {
   searchWorkProductLedgerEntries
-} from "./chunk-NRLELHAY.js";
+} from "./chunk-G7NYVKD6.js";
 import {
   TranscriptManager
 } from "./chunk-AM4T6CHX.js";
@@ -242,10 +242,10 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-ACZN5ZXD.js";
+} from "./chunk-H54VWRPS.js";
 import {
   planNamespaceMaintenance
-} from "./chunk-3LADWWMA.js";
+} from "./chunk-SJDQ5RSN.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -256,7 +256,7 @@ import {
 } from "./chunk-OZKOPQCM.js";
 import {
   recordEvalShadowRecall
-} from "./chunk-MCA2X4WH.js";
+} from "./chunk-4IHBN6WU.js";
 import {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,
@@ -264,7 +264,7 @@ import {
 } from "./chunk-2DQ2XREU.js";
 import {
   applyCommitmentLedgerLifecycle
-} from "./chunk-NOB2T2FC.js";
+} from "./chunk-NHLLKEKK.js";
 import {
   buildConsolidationPrompt,
   buildExtensionsBlockForConsolidation,
@@ -274,7 +274,10 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-F5UWQ4LX.js";
+} from "./chunk-W24T5YMW.js";
+import {
+  BoxBuilder
+} from "./chunk-B7RWBZXW.js";
 import {
   semanticChunkContent
 } from "./chunk-2GBFKHBZ.js";
@@ -283,7 +286,25 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   SmartBuffer
-} from "./chunk-4LG4CPOC.js";
+} from "./chunk-Z6COGHHN.js";
+import {
+  REFUSED_MERGE_CATEGORIES,
+  applyNoveltyGate,
+  connectorMatchesScope,
+  decideSemanticMerge,
+  detectMeetings,
+  embeddingsFromCosineHits,
+  normalizeConnectorScope
+} from "./chunk-2IOHTUP3.js";
+import {
+  compileCorrectionRule,
+  correctionsFilePath,
+  loadCorrectionsFile,
+  saveCorrectionsFile
+} from "./chunk-ZKOPY4WW.js";
+import {
+  resolveJournalSource
+} from "./chunk-OGUKSLYZ.js";
 import {
   AMBIENT_CAPTURE_PROMPT_RULE,
   isHighImpactPersonalFact
@@ -301,29 +322,12 @@ import {
 import {
   isDisagreementPrompt
 } from "./chunk-H3FZVNRN.js";
-import {
-  BoxBuilder
-} from "./chunk-B7RWBZXW.js";
 import {
   evaluateMemoryActionPolicy
 } from "./chunk-MI2OTWV5.js";
-import {
-  applyNoveltyGate,
-  detectMeetings,
-  embeddingsFromCosineHits
-} from "./chunk-FCATYKQA.js";
-import {
-  compileCorrectionRule,
-  correctionsFilePath,
-  loadCorrectionsFile,
-  saveCorrectionsFile
-} from "./chunk-ZKOPY4WW.js";
-import {
-  resolveJournalSource
-} from "./chunk-OGUKSLYZ.js";
 import {
   MeetingsInputError
-} from "./chunk-KK66P5GQ.js";
+} from "./chunk-C553ZTLF.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -335,9 +339,13 @@ import {
   foldQueueWaitTiming,
   recordRecallTiming
 } from "./chunk-CEN6DW6X.js";
+import {
+  removeNodeEdgesForRewrite,
+  rollbackNodeEdgeRewrite
+} from "./chunk-DGS34QSY.js";
 import {
   NamespaceCatalog
-} from "./chunk-GGYDJJBO.js";
+} from "./chunk-QOOBICJF.js";
 import {
   RecallResultFormatter,
   SessionContextCoordinator,
@@ -349,10 +357,10 @@ import {
   isTopLevelArchivePath,
   journalPath,
   writeJournalFile
-} from "./chunk-NQFCLAYT.js";
+} from "./chunk-ICKJ52PE.js";
 import {
   importCapsule
-} from "./chunk-J2R275FN.js";
+} from "./chunk-VVX5PZFS.js";
 import {
   isCodingGraphInstalled
 } from "./chunk-VQ7B2Q6M.js";
@@ -366,7 +374,7 @@ import {
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
-} from "./chunk-5QZR2RA3.js";
+} from "./chunk-ROBHL3GL.js";
 import {
   HourlySummarizer
 } from "./chunk-N3SS45OW.js";
@@ -375,17 +383,17 @@ import {
   RecallHandleHistoryStore,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries
-} from "./chunk-ZVZHG7AI.js";
+} from "./chunk-5UBH37SL.js";
 import {
   buildXraySnapshot
-} from "./chunk-JOYC4RYC.js";
+} from "./chunk-2JVJ7UHC.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
-} from "./chunk-HTP6XRUI.js";
+} from "./chunk-HM7RHKS4.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-ZZM476NV.js";
+} from "./chunk-6XL73HQ4.js";
 import {
   ProfilingCollector
 } from "./chunk-NLE6TSLG.js";
@@ -401,7 +409,7 @@ import {
 } from "./chunk-LTHVM4XN.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-X5YYSAZX.js";
+} from "./chunk-XUE46UYW.js";
 import {
   boundRecallContextComposition,
   composeRecallContext,
@@ -410,18 +418,21 @@ import {
   renderAuthorityBoundContent,
   selectCuriosityQuestion
 } from "./chunk-7ZNJN5WZ.js";
-import {
-  NamespaceStorageRouter
-} from "./chunk-UMEOXLIZ.js";
 import {
   pruneOrphanCueAnchors
-} from "./chunk-ACPCA4NO.js";
+} from "./chunk-BMWN7B3Y.js";
+import {
+  NamespaceStorageRouter
+} from "./chunk-E2P7TZTF.js";
 import {
   GraphIndex
-} from "./chunk-OLT3YTDH.js";
+} from "./chunk-5FAGCOZD.js";
+import {
+  GraphEdgeAppendError
+} from "./chunk-GKCXTSFF.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-LFK623SF.js";
+} from "./chunk-WJHGDE7X.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -440,7 +451,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-OGTKQ5MJ.js";
+} from "./chunk-XSGUMQQQ.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -453,16 +464,16 @@ import {
 } from "./chunk-UHVXE24Y.js";
 import {
   buildRetiredFactTombstoneInputs
-} from "./chunk-4ZWCQJNM.js";
+} from "./chunk-46WM6JX2.js";
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
-} from "./chunk-6FUMA6AA.js";
+} from "./chunk-2Z4GS5E6.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend,
   isSearchBackendEnabled
-} from "./chunk-D35XLYQ7.js";
+} from "./chunk-6CVNSDCZ.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
@@ -476,7 +487,7 @@ import {
 } from "./chunk-S2V7RUCL.js";
 import {
   confidenceTier
-} from "./chunk-XOQGUGJL.js";
+} from "./chunk-SO7SV523.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -494,6 +505,12 @@ import {
   dominantCorpusLanguage,
   planCrossScript
 } from "./chunk-3WU7XOFN.js";
+import {
+  createVersion,
+  pruneVersions,
+  recordStrandedCommit,
+  removeVersion
+} from "./chunk-JPKK466T.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-XCB6QDL6.js";
@@ -507,7 +524,7 @@ import {
   requestEntityCanonicalIdReconcile,
   requestEntityCanonicalIdReconcileSync,
   withRawEntityPageMutation
-} from "./chunk-NNZFPYYX.js";
+} from "./chunk-R7QY5ZVB.js";
 import {
   applyTemporalSupersession,
   applyTemporalSupersessionPrimaryMutation,
@@ -560,7 +577,7 @@ import {
   throwIfRecallAborted,
   tokenizeRecallQuery,
   utcDateKeysForLocalDay
-} from "./chunk-XQYTSZW3.js";
+} from "./chunk-L7Z57SID.js";
 import {
   inferIntentFromText,
   intentCompatibilityScore,
@@ -571,7 +588,7 @@ import {
   TAG_LIMITS,
   composeMemoryEnvelope,
   isMemoryCategory
-} from "./chunk-WKAXBXVA.js";
+} from "./chunk-3QQTXYZ6.js";
 import {
   normalizeTags
 } from "./chunk-BT7NVCML.js";
@@ -588,19 +605,6 @@ import {
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
-import {
-  createBoundedCoreSectionRunner,
-  createRecallSectionMetricRecorder,
-  resolveRecallCoreSectionDeadlineMs,
-  runRecallSectionWithinDeadline
-} from "./chunk-4O4TKIXQ.js";
-import {
-  decideLifecycleTransition,
-  resolveLifecycleState
-} from "./chunk-TBBDFYXW.js";
-import {
-  estimateTokenCount
-} from "./chunk-TOTT6S2V.js";
 import {
   assertExternalWikiRootOutsideMemoryDirCanonical
 } from "./chunk-JV3C2MNQ.js";
@@ -609,7 +613,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   searchCausalTrajectories
-} from "./chunk-2Z3DG5CQ.js";
+} from "./chunk-B3O3IRZN.js";
 import {
   activityDayWindow,
   assertValidTimezone,
@@ -621,13 +625,27 @@ import {
   evaluateSubjectGuard,
   isSharedPromotionTarget,
   resolveWriteSubject
-} from "./chunk-ME35HVDJ.js";
+} from "./chunk-VYCOJKSX.js";
 import {
+  isUntrustedOrigin,
   parseOriginClass
 } from "./chunk-6Q3ZTEF6.js";
+import {
+  createBoundedCoreSectionRunner,
+  createRecallSectionMetricRecorder,
+  resolveRecallCoreSectionDeadlineMs,
+  runRecallSectionWithinDeadline
+} from "./chunk-4O4TKIXQ.js";
+import {
+  decideLifecycleTransition,
+  resolveLifecycleState
+} from "./chunk-TBBDFYXW.js";
 import {
   normalizeRecallTokenSet
 } from "./chunk-YCVB7X56.js";
+import {
+  estimateTokenCount
+} from "./chunk-TOTT6S2V.js";
 import {
   coerceBool,
   coerceBooleanLike,
@@ -637,16 +655,6 @@ import {
   graphemeUnits,
   truncateGraphemeSafe
 } from "./chunk-PJKTFXE2.js";
-import {
-  CAPSULE_ID_PATTERN
-} from "./chunk-WEHSQBFR.js";
-import {
-  keyring_exports,
-  secureStoreDir
-} from "./chunk-BJMBJZ2Y.js";
-import {
-  buildRetrievedMemoryProvenance
-} from "./chunk-I4WBNM3M.js";
 import {
   getConfiguredNamespaces,
   resolveNamespaceFromStorageDir,
@@ -655,26 +663,27 @@ import {
 import {
   attachCitation,
   hasCitationForTemplate,
+  lastCitationMarkerForTemplate,
   stripCitationForTemplate
-} from "./chunk-J6A3CX5N.js";
+} from "./chunk-TG3FAM2S.js";
+import {
+  openBetterSqlite3
+} from "./chunk-RL6NEVXT.js";
+import {
+  assertPathInsideRoot
+} from "./chunk-C7HJ3NEI.js";
 import {
   inferMemoryStatus,
   isActiveMemoryStatus,
   toMemoryPathRel
 } from "./chunk-7RJUVTVF.js";
 import {
-  openBetterSqlite3
-} from "./chunk-RL6NEVXT.js";
-import {
-  assertPathInsideRoot
-} from "./chunk-GCASGYIO.js";
+  ContentHashIndex
+} from "./chunk-NB3LRY4T.js";
 import {
   excludeSupportPassportPrivateMemories,
   isSupportPassportPrivateMemory
 } from "./chunk-EEOUMG3J.js";
-import {
-  ContentHashIndex
-} from "./chunk-TVW4C7PV.js";
 import {
   normalizeAttributePairs,
   stripAttributesSuffix
@@ -688,6 +697,16 @@ import {
   resolveHandle,
   stripHandles
 } from "./chunk-JAKIDQB2.js";
+import {
+  CAPSULE_ID_PATTERN
+} from "./chunk-WEHSQBFR.js";
+import {
+  keyring_exports,
+  secureStoreDir
+} from "./chunk-BJMBJZ2Y.js";
+import {
+  buildRetrievedMemoryProvenance
+} from "./chunk-I4WBNM3M.js";
 import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot
@@ -755,14 +774,14 @@ import {
   listJsonFilesStrict,
   withJsonStoreMutationLock,
   writeJsonFileAtomic
-} from "./chunk-P77QX3ID.js";
+} from "./chunk-B6O2YLUR.js";
 import {
   isPathInsideStorageRoot,
   resolveSafeStoragePath
 } from "./chunk-FF4KLI5W.js";
 import {
   SecureStoreLockedError
-} from "./chunk-ET2CNMLD.js";
+} from "./chunk-JN72EPOE.js";
 import {
   ALL_CATEGORY_DIRS,
   ALL_CATEGORY_KEYS,
@@ -771,13 +790,13 @@ import {
 } from "./chunk-VS2IYZRU.js";
 import {
   isErrnoCode
-} from "./chunk-5UZXUTVO.js";
+} from "./chunk-KNA3BXXL.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
 
 // src/orchestrator.ts
-import path20 from "path";
+import path21 from "path";
 import { createHash as createHash8 } from "crypto";
 
 // src/orchestration/tier-migration-coordinator.ts
@@ -2328,7 +2347,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path38, preferredNamespace) => {
+        readMemoryFrontmatter: async (path39, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2340,7 +2359,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path38,
+            path39,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -4837,7 +4856,7 @@ async function decideSemanticDedup(content, lookup, options) {
   if (!Array.isArray(hits) || hits.length === 0) {
     return { action: "keep", reason: "no_candidates" };
   }
-  const candidateConnector = typeof options.sourceConnector === "string" && options.sourceConnector.trim().length > 0 ? options.sourceConnector.trim() : void 0;
+  const candidateConnector = normalizeConnectorScope(options.sourceConnector);
   let top;
   let sameConnectorTop;
   for (const hit of hits) {
@@ -4847,7 +4866,7 @@ async function decideSemanticDedup(content, lookup, options) {
     if (!top || hit.score > top.score) {
       top = hit;
     }
-    if (candidateConnector !== void 0 && typeof hit.sourceConnector === "string" && hit.sourceConnector.trim() === candidateConnector && (!sameConnectorTop || hit.score > sameConnectorTop.score)) {
+    if (candidateConnector !== void 0 && connectorMatchesScope(hit.sourceConnector, candidateConnector) && (!sameConnectorTop || hit.score > sameConnectorTop.score)) {
       sameConnectorTop = hit;
     }
   }
@@ -4882,122 +4901,1079 @@ async function decideSemanticDedup(content, lookup, options) {
     };
   }
   return {
-    action: "keep",
-    reason: "no_near_duplicate",
-    topScore: top.score,
-    topId: top.id
+    action: "keep",
+    reason: "no_near_duplicate",
+    topScore: top.score,
+    topId: top.id
+  };
+}
+
+// src/orchestration/extraction-persist-promotion.ts
+var confidenceTierOrder = [
+  "explicit",
+  "implied",
+  "inferred",
+  "speculative"
+];
+function profileAutoPromotionAllows(scopeProfileWritePlan, category, confidence) {
+  if (!scopeProfileWritePlan) return false;
+  const actualTier = confidenceTier(confidence);
+  const actualRank = confidenceTierOrder.indexOf(actualTier);
+  if (actualRank === -1) return false;
+  const autoPromote = scopeProfileWritePlan.profile.autoPromote;
+  if (!autoPromote.enabled) return false;
+  if (!autoPromote.categories.includes(category)) return false;
+  const minimumRank = confidenceTierOrder.indexOf(autoPromote.minConfidenceTier);
+  return minimumRank !== -1 && actualRank <= minimumRank;
+}
+function sharedAutoPromotionAllows(config, scopeProfileWritePlan, category, confidence) {
+  if (!scopeProfileWritePlan) {
+    const actualTier = confidenceTier(confidence);
+    const actualRank = confidenceTierOrder.indexOf(actualTier);
+    if (actualRank === -1) return false;
+    if (!resolveRecallEnhancementCapabilities(config).autoPromoteToShared) return false;
+    if (!config.autoPromoteToSharedCategories.includes(category))
+      return false;
+    const minimumRank = confidenceTierOrder.indexOf(
+      config.autoPromoteMinConfidenceTier
+    );
+    return minimumRank !== -1 && actualRank <= minimumRank;
+  }
+  return scopeProfileWritePlan.profile.autoPromote.targets.includes("serverShared") && profileAutoPromotionAllows(scopeProfileWritePlan, category, confidence);
+}
+function shouldPromoteToShared(config, scopeProfileWritePlan, profileAllowsSharedWrites, storageDirNamespace, targetStorage, category, confidence) {
+  if (!resolveNamespaceCapabilities(config).namespaces || !profileAllowsSharedWrites || !sharedAutoPromotionAllows(config, scopeProfileWritePlan, category, confidence))
+    return false;
+  if (storageDirNamespace(targetStorage.dir) === config.sharedNamespace)
+    return false;
+  return true;
+}
+async function readActiveMemoriesBothTiers(storage) {
+  const [hotMems, coldMems] = await Promise.all([
+    storage.readAllMemories(),
+    storage.readAllColdMemories()
+  ]);
+  return coldMems.length === 0 ? hotMems : [...hotMems, ...coldMems];
+}
+async function flushDeferredFactHashOnFailure(saveContentHashIndexes, deferred) {
+  if (!deferred) return;
+  await saveContentHashIndexes().catch(
+    (err) => log.warn(`content-hash flush after post-write failure failed: ${err}`)
+  );
+}
+function promotionWithholdsToolScope(options) {
+  return options.toolScoped === true || withholdToolScopedFromSharedNamespace(options);
+}
+function makeSubjectGuardAllows(config) {
+  return (subject, target, label) => {
+    const decision = evaluateSubjectGuard({
+      subject,
+      sharedTarget: isSharedPromotionTarget(target),
+      mode: config.subjectGuard
+    });
+    if (decision.action !== "allow") {
+      log.warn(`subject-guard(${decision.action}) ${label}: ${decision.reason}`);
+    }
+    return decision.action !== "reject";
+  };
+}
+function promotionScanNamespaces(config, scopeProfileWritePlan) {
+  const namespaces = [];
+  if (scopeProfileWritePlan) {
+    for (const target of scopeProfileWritePlan.promotionTargets) {
+      if (target.target !== "serverShared" && target.namespace) {
+        namespaces.push(target.namespace);
+      }
+    }
+    for (const layer of scopeProfileWritePlan.layers ?? []) {
+      if (layer.id !== "serverShared" && layer.namespace) {
+        namespaces.push(layer.namespace);
+      }
+    }
+  }
+  namespaces.push(config.sharedNamespace);
+  return [...new Set(namespaces)];
+}
+function createBatchPromotedCopyProbe(config, getStorageRouter, scopeProfileWritePlan) {
+  const scans = /* @__PURE__ */ new Map();
+  const scanNamespace = (namespace) => {
+    let entry = scans.get(namespace);
+    if (entry === void 0) {
+      entry = (async () => {
+        try {
+          const storage = await getStorageRouter().storageFor(namespace);
+          const active = await readActiveMemoriesBothTiers(storage);
+          return {
+            dir: storage.dir,
+            // Round N+11 (A): only ACTIVE copies count as promoted (§41 —
+            // enumerate the active set). readActiveMemoriesBothTiers returns
+            // every hot+cold copy, superseded ones included; a superseded
+            // copy serves no body, so counting it made targetHasPromotedCopies
+            // reject every later judge-approved merge and the supposedly
+            // mergeable updates accumulated as new fragments instead.
+            sourceIds: new Set(
+              active.filter(
+                (memory) => inferMemoryStatus(memory.frontmatter, toMemoryPathRel(storage.dir, memory.path)) === "active"
+              ).map((memory) => memory.frontmatter.sourceMemoryId).filter((id) => typeof id === "string")
+            )
+          };
+        } catch (err) {
+          log.warn(
+            `semantic-merge guard: promotion namespace "${namespace}" unreadable; bypassing the merge (finding C): ${err instanceof Error ? err.message : String(err)}`
+          );
+          return { dir: "", sourceIds: null };
+        }
+      })();
+      scans.set(namespace, entry);
+    }
+    return entry;
+  };
+  return {
+    check: async (sourceStorage, targetMemoryId) => {
+      for (const namespace of promotionScanNamespaces(config, scopeProfileWritePlan)) {
+        const entry = await scanNamespace(namespace);
+        if (entry.sourceIds === null) return true;
+        if (entry.dir === sourceStorage.dir) continue;
+        if (entry.sourceIds.has(targetMemoryId)) return true;
+      }
+      return false;
+    },
+    invalidate: () => {
+      scans.clear();
+    }
+  };
+}
+async function promoteAndReconcileMergedTarget(args) {
+  let promotedCopyId;
+  if (args.mergedPromotion) {
+    const payload = args.mergedPromotion;
+    const current = await args.sourceStorage.getMemoryByIdIncludingArchived(args.sourceMemoryId).catch(() => null);
+    if (!current || inferMemoryStatus(current.frontmatter, current.path) !== "active" || current.content !== payload.content || (current.frontmatter.updated ?? void 0) !== (payload.committedRevision ?? void 0)) {
+      log.warn(
+        `persistExtraction: merged-target promotion abandoned for ${args.sourceMemoryId} \u2014 the committed record advanced past the cached payload, so the newer writer's copy stands`
+      );
+      return;
+    }
+    try {
+      promotedCopyId = await args.promote(payload);
+    } catch (err) {
+      log.warn(
+        `persistExtraction: merged-target promotion failed open for ${args.sourceMemoryId}: ${err}`
+      );
+    }
+  }
+  try {
+    await retireStaleMergedTargetPromotionCopies({
+      config: args.config,
+      getStorageRouter: args.getStorageRouter,
+      scopeProfileWritePlan: args.scopeProfileWritePlan,
+      sourceStorage: args.sourceStorage,
+      sourceMemoryId: args.sourceMemoryId,
+      ...args.mergedPromotion ? { promotedContent: args.mergedPromotion.content } : {},
+      ...promotedCopyId !== void 0 ? { promotedMemoryId: promotedCopyId } : {},
+      normalize: args.normalize
+    });
+    args.onReconciled?.();
+  } catch (err) {
+    log.warn(
+      `persistExtraction: merged-target promotion reconciliation failed open for ${args.sourceMemoryId}: ${err}`
+    );
+  }
+}
+async function retireStaleMergedTargetPromotionCopies(args) {
+  const canonicalRecord = await args.sourceStorage.getMemoryByIdIncludingArchived(args.sourceMemoryId).catch(() => null);
+  const canonicalBody = canonicalRecord?.content;
+  if (typeof canonicalBody !== "string" || canonicalBody.length === 0) {
+    log.warn(
+      `persistExtraction: merged-target promotion reconciliation aborted for ${args.sourceMemoryId} \u2014 the canonical record could not be read, so no copy is retired`
+    );
+    return 0;
+  }
+  const canonicalForm = args.normalize(canonicalBody);
+  const supersessionTarget = args.promotedContent !== void 0 && args.promotedMemoryId !== void 0 && args.normalize(args.promotedContent) === canonicalForm ? args.promotedMemoryId : args.sourceMemoryId;
+  let retired = 0;
+  for (const namespace of promotionScanNamespaces(args.config, args.scopeProfileWritePlan)) {
+    try {
+      const storage = await args.getStorageRouter().storageFor(namespace);
+      if (storage.dir === args.sourceStorage.dir) continue;
+      const active = await readActiveMemoriesBothTiers(storage);
+      const stale = active.filter(
+        (memory) => memory.frontmatter.sourceMemoryId === args.sourceMemoryId && (memory.frontmatter.status ?? "active") === "active" && args.normalize(memory.content ?? "") !== canonicalForm
+      );
+      for (const memory of stale) {
+        const superseded = await storage.supersedeMemory(
+          memory.frontmatter.id,
+          supersessionTarget,
+          "merged-target promotion reconciliation"
+        );
+        if (superseded) {
+          retired++;
+          log.warn(
+            `persistExtraction: superseded stale promoted copy ${memory.frontmatter.id} of ${args.sourceMemoryId} \u2014 it carried the pre-merge body while ${supersessionTarget} serves the merged body`
+          );
+        }
+      }
+    } catch (err) {
+      log.warn(
+        `persistExtraction: merged-target promotion reconciliation failed open for namespace "${namespace}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return retired;
+}
+
+// src/orchestration/harmonic-construction-persist.ts
+function filterHarmonicEntityMentions(facts, entityMentions) {
+  const identitiesBySegment = /* @__PURE__ */ new Map();
+  for (const entity of entityMentions) {
+    const segment = harmonicEntitySegment(entity.name);
+    const identities = identitiesBySegment.get(segment) ?? /* @__PURE__ */ new Set();
+    identities.add(normalizedHarmonicEntityIdentity(entity.name));
+    identitiesBySegment.set(segment, identities);
+  }
+  return entityMentions.flatMap((entity) => {
+    const allowSegmentFallback = identitiesBySegment.get(harmonicEntitySegment(entity.name))?.size === 1;
+    const activeFacts = facts.filter(
+      (fact) => typeof fact.entityRef === "string" && harmonicEntityReferenceMatches(fact.entityRef, entity.name, allowSegmentFallback)
+    );
+    return activeFacts.length > 0 ? [{ ...entity, facts: activeFacts.map((fact) => fact.content) }] : [];
+  });
+}
+function enqueueMergedTargetForHarmonicConstruction(entries, storage, fact, memoryId, content, insertedAt) {
+  const entry = entries.get(storage.dir) ?? { storage, facts: [] };
+  const prior = entry.facts.findIndex((existing) => existing.memoryId === memoryId);
+  if (prior !== -1) {
+    entry.facts[prior] = {
+      ...fact,
+      content,
+      memoryId,
+      insertedAt,
+      cueAnchors: [
+        ...entry.facts[prior].cueAnchors ?? [],
+        ...fact.cueAnchors ?? []
+      ]
+    };
+  } else {
+    entry.facts.push({ ...fact, content, memoryId, insertedAt });
+  }
+  entries.set(storage.dir, entry);
+}
+async function persistConstructedHarmonicRecords(options) {
+  const sessionKey = options.sessionKey?.trim();
+  if (!sessionKey) {
+    log.warn("harmonic construction skipped: extraction session key is missing");
+    return;
+  }
+  const recordedAt = options.validAt && Number.isFinite(Date.parse(options.validAt)) ? new Date(options.validAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  const entries = [...options.entries];
+  const sharedEpisodeTitle = entries.length === 1 ? options.episodeTitle : void 0;
+  for (const entry of entries) {
+    try {
+      const records = deriveHarmonicRecords({
+        sessionKey,
+        recordedAt,
+        episodeTitle: sharedEpisodeTitle,
+        persistedFacts: entry.facts,
+        entityMentions: filterHarmonicEntityMentions(entry.facts, options.entityMentions).map((entity) => ({
+          name: entity.name,
+          type: entity.type,
+          facts: entity.facts
+        }))
+      });
+      await persistHarmonicRecords({
+        memoryDir: entry.storage.dir,
+        abstractionNodeStoreDir: entry.storage.dir === options.baseStorageDir ? options.abstractionNodeStoreDir : void 0,
+        nodes: records.nodes,
+        anchors: options.anchorsEnabled ? records.anchors : []
+      });
+    } catch (error) {
+      log.warn(
+        `harmonic construction failed open for namespace ${entry.storage.dir}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
+// src/orchestration/semantic-merge-persist.ts
+import path5 from "path";
+
+// src/orchestration/semantic-merge-commit-effects.ts
+import { readFile as readFile2 } from "fs/promises";
+async function stageMergedTargetSnapshot(target, versioning, memoryDir) {
+  const currentFile = await readFile2(target.path, "utf8");
+  const version = await createVersion(
+    target.path,
+    currentFile,
+    "semantic-merge",
+    versioning,
+    log,
+    "judge-mediated merge-on-write (issue #2330)",
+    memoryDir,
+    { deferPrune: true }
+  );
+  return String(version.versionId);
+}
+async function finalizeMergedVersionPrune(targetPath, versioning, memoryDir, targetId, versionId) {
+  await pruneVersions(targetPath, versioning, log, memoryDir, {
+    committedVersionId: versionId
+  }).catch(async (err) => {
+    log.warn(
+      `semantic-merge: version prune finalization failed for ${targetId} (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+    );
+    await recordStrandedCommit(targetPath, versioning, versionId, log, memoryDir);
+  });
+}
+async function discardMergedTargetSnapshot(targetPath, versioning, memoryDir, targetId, versionId) {
+  await removeVersion(targetPath, versionId, versioning, log, memoryDir).catch(
+    (err) => log.warn(
+      `semantic-merge: staged snapshot ${versionId} removal failed for ${targetId} (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+    )
+  );
+}
+async function readTargetSnapshot(storage, target) {
+  const current = await storage.readMemoryByPath(target.path);
+  if (!current || current.frontmatter.id !== target.frontmatter.id) return null;
+  return current;
+}
+async function revertMergedContent(storage, target, mergedContent) {
+  try {
+    const current = await readTargetSnapshot(storage, target);
+    if (!current) return false;
+    if (current.content !== mergedContent) return true;
+    return await storage.updateMemoryIfUnchanged(current, target.content, {
+      actor: "semantic-merge-rollback"
+    });
+  } catch {
+    return false;
+  }
+}
+async function persistMergedTargetThreadEpisode(threading, threadId, targetId) {
+  if (!threadId) return;
+  try {
+    const thread = await threading.loadThread(threadId);
+    if (!thread) return;
+    const existing = thread.episodeIds.lastIndexOf(targetId);
+    if (existing !== -1) thread.episodeIds.splice(existing, 1);
+    thread.episodeIds.push(targetId);
+    thread.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await threading.saveThread(thread);
+  } catch (err) {
+    log.warn(
+      `semantic-merge: thread episode persist failed for ${targetId} (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function rewriteMergedTargetGraphEdges(storage, input) {
+  const removedEdges = await removeNodeEdgesForRewrite(storage.dir, input.memoryRelPath, input.rewriteTypes);
+  let appended;
+  try {
+    appended = await input.build() ?? void 0;
+    const committedNow = await storage.getMemoryByIdIncludingArchived(input.targetId);
+    if (!committedNow || committedNow.content !== input.mergedContent || committedNow.frontmatter.updated !== input.revisionChecked) {
+      await rollbackNodeEdgeRewrite(storage.dir, input.memoryRelPath, input.rewriteTypes, removedEdges, input.targetId, appended);
+      return false;
+    }
+    return true;
+  } catch (buildErr) {
+    await rollbackNodeEdgeRewrite(
+      storage.dir,
+      input.memoryRelPath,
+      input.rewriteTypes,
+      removedEdges,
+      input.targetId,
+      appended ?? (buildErr instanceof GraphEdgeAppendError ? buildErr.appendedEdges : void 0)
+    );
+    throw buildErr;
+  }
+}
+function rawPreCitationMergedBody(deps, mergedContent) {
+  if (resolvePipelineProcessingCapabilities(deps.config).inlineSourceAttribution !== true) {
+    return mergedContent;
+  }
+  const template = deps.config.inlineSourceAttributionFormat;
+  return hasCitationForTemplate(mergedContent, template) ? stripCitationForTemplate(mergedContent, template) : mergedContent;
+}
+function committedMergedFactHash(deps, category, committedContent) {
+  if (category !== "fact") return void 0;
+  return ContentHashIndex.computeHash(sanitizeMemoryContent(rawPreCitationMergedBody(deps, committedContent)).text);
+}
+async function persistRepairedContentHash(storage, targetId, committedContent, contentHash) {
+  try {
+    const current = await storage.getMemoryByIdIncludingArchived(targetId);
+    if (!current || current.content !== committedContent) return;
+    if (inferMemoryStatus(current.frontmatter, current.path) !== "active") return;
+    if (current.frontmatter.contentHash === contentHash) return;
+    await storage.writeMemoryFrontmatterIfUnchanged(
+      current,
+      { contentHash },
+      { actor: "semantic-merge" }
+    );
+  } catch (err) {
+    log.warn(
+      `semantic-merge: durable content-hash repair failed for ${targetId} (non-fatal; the in-memory index holds the merged body until restart): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+// src/dedup/merge-provenance.ts
+var MERGE_DERIVED_VIA = "merge";
+var ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
+function assertIsoInstant(value, field) {
+  if (typeof value !== "string" || !ISO_TIMESTAMP.test(value)) {
+    throw new RangeError(`${field} must be a full ISO 8601 instant, got ${JSON.stringify(value)}`);
+  }
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) {
+    throw new RangeError(`${field} must be a full ISO 8601 instant, got ${JSON.stringify(value)}`);
+  }
+  if (!new Date(ms).toISOString().startsWith(value.slice(0, 10))) {
+    throw new RangeError(`${field} is not a real calendar date: ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function assertOffset(value, field) {
+  if (value === void 0) return;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new RangeError(`${field} must be a non-negative integer when present, got ${String(value)}`);
+  }
+}
+function normalizeSource(source, index) {
+  const label = `sources[${index}]`;
+  for (const field of ["sessionKey", "quote"]) {
+    const value = source[field];
+    if (typeof value !== "string" || value.trim() === "") {
+      throw new RangeError(`${label}.${field} must be a non-blank string`);
+    }
+  }
+  assertIsoInstant(source.observedAt, `${label}.observedAt`);
+  if (source.turnId !== void 0 && (typeof source.turnId !== "string" || source.turnId.trim() === "")) {
+    throw new RangeError(`${label}.turnId must be a non-blank string when present`);
+  }
+  assertOffset(source.charStart, `${label}.charStart`);
+  assertOffset(source.charEnd, `${label}.charEnd`);
+  if (source.charStart !== void 0 && source.charEnd !== void 0 && source.charEnd < source.charStart) {
+    throw new RangeError(`${label}.charEnd must be >= charStart`);
+  }
+  const copy = {
+    sessionKey: source.sessionKey,
+    observedAt: source.observedAt,
+    quote: source.quote
+  };
+  if (source.turnId !== void 0) copy.turnId = source.turnId;
+  if (source.charStart !== void 0) copy.charStart = source.charStart;
+  if (source.charEnd !== void 0) copy.charEnd = source.charEnd;
+  return copy;
+}
+function sourceKey(source) {
+  return JSON.stringify([
+    source.sessionKey,
+    source.turnId ?? null,
+    source.observedAt,
+    source.quote,
+    source.charStart ?? null,
+    source.charEnd ?? null
+  ]);
+}
+function buildMergeFrontmatterUpdate(input) {
+  const updated = assertIsoInstant(input.nowIso, "nowIso");
+  const previous = input.targetReinforcementCount;
+  if (previous !== void 0 && (typeof previous !== "number" || !Number.isInteger(previous) || previous < 0)) {
+    throw new RangeError(
+      `reinforcement_count must be a non-negative integer when supplied, got ${String(previous)}`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const sources = [];
+  const append = (source, index) => {
+    const copy = normalizeSource(source, index);
+    const key = sourceKey(copy);
+    if (seen.has(key)) return;
+    seen.add(key);
+    sources.push(copy);
+  };
+  const target = input.targetSources ?? [];
+  target.forEach(append);
+  input.incomingSources.forEach((source, i) => append(source, target.length + i));
+  return {
+    updated,
+    derived_via: MERGE_DERIVED_VIA,
+    reinforcement_count: (previous ?? 0) + 1,
+    sources
+  };
+}
+
+// src/dedup/merge-judge.ts
+import { z } from "zod";
+var MERGE_JUDGE_SYSTEM_PROMPT = `You maintain a long-term memory store. Given a NEW memory and up to N EXISTING
+memories about a similar topic, decide:
+- "merge": the new memory describes the SAME underlying concept/state as one
+  existing memory, and the two can be combined into one entry with no
+  information loss. Return targetId (one of the existing ids, verbatim) and
+  mergedContent: one entry containing EVERY concrete detail from BOTH texts
+  (names, numbers, dates, qualifiers). Do not paraphrase away specifics.
+- "contradicts": the new memory conflicts with an existing one (state change,
+  correction). Do NOT merge.
+- "create": different concept, or you are unsure.
+When unsure, choose "create".
+Respond with a single JSON object: {"decision": "merge"|"create"|"contradicts", "targetId": string|null, "mergedContent": string|null, "reason": string}`;
+var MergeVerdictSchema = z.object({
+  decision: z.enum(["merge", "create", "contradicts"]),
+  targetId: z.string().optional().nullable(),
+  mergedContent: z.string().optional().nullable(),
+  reason: z.string()
+});
+function parseVerdict(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    for (const candidate of extractJsonCandidates(raw)) {
+      try {
+        parsed = JSON.parse(candidate);
+        break;
+      } catch {
+        continue;
+      }
+    }
+  }
+  const checked = MergeVerdictSchema.safeParse(parsed);
+  if (!checked.success) return null;
+  return {
+    decision: checked.data.decision,
+    targetId: checked.data.targetId ?? null,
+    mergedContent: checked.data.mergedContent ?? null,
+    reason: checked.data.reason
+  };
+}
+async function callMergeJudge(options) {
+  const userPrompt = JSON.stringify({
+    new: { category: options.category, content: options.content },
+    existing: options.candidates.map((c) => ({
+      id: c.memoryId,
+      category: c.category,
+      similarity: Number(c.similarity.toFixed(4)),
+      content: c.content
+    }))
+  });
+  const messages = [
+    { role: "system", content: MERGE_JUDGE_SYSTEM_PROMPT },
+    { role: "user", content: userPrompt }
+  ];
+  const modelOverride = options.config.extractionJudgeModel || void 0;
+  const skipLocal = options.config.modelSource === "gateway";
+  const gatewayChain = gatewayTaskChainOptions(options.config);
+  const sharedCallOptions = {
+    temperature: 0.1,
+    maxTokens: 2048,
+    ...modelOverride ? { model: modelOverride } : {}
+  };
+  if (options.localLlm && !skipLocal) {
+    try {
+      const result = await options.localLlm.chatCompletion(messages, {
+        ...sharedCallOptions,
+        timeoutMs: 1500,
+        operation: "semantic-merge-judge",
+        responseFormat: { type: "json_object" }
+      });
+      if (result?.content) {
+        const verdict = parseVerdict(result.content);
+        if (verdict) return verdict;
+      }
+    } catch (err) {
+      log.debug(
+        `semantic-merge judge: local LLM failed, trying fallback: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (options.fallbackLlm) {
+    try {
+      const result = await options.fallbackLlm.chatCompletion(
+        messages,
+        { ...sharedCallOptions, timeoutMs: 1500, ...gatewayChain }
+      );
+      if (result?.content) {
+        const verdict = parseVerdict(result.content);
+        if (verdict) return verdict;
+      }
+    } catch (err) {
+      log.debug(
+        `semantic-merge judge: fallback LLM failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return null;
+}
+
+// src/orchestration/semantic-merge-persist.ts
+var REFUSED = REFUSED_MERGE_CATEGORIES;
+var PROVENANCE_STRENGTH_RANK = {
+  none: 0,
+  unverified: 1,
+  verified: 2
+};
+function provenanceRank(value) {
+  return PROVENANCE_STRENGTH_RANK[value ?? "none"] ?? 0;
+}
+function effectiveFaithfulness(verdict) {
+  if (verdict === void 0) return void 0;
+  return verdict === "skipped_no_span" ? "unchecked" : verdict;
+}
+function createPathMergeParity(input) {
+  const { target, untrustedOrigins } = input;
+  const md = input.incoming;
+  if (md?.structuredAttributes && Object.keys(md.structuredAttributes).length > 0) {
+    return { ok: false, field: "structuredAttributes" };
+  }
+  if (md?.biTemporal === true) return { ok: false, field: "biTemporal" };
+  if (md?.entityRef !== void 0 && md.entityRef !== target.frontmatter.entityRef) {
+    return { ok: false, field: "entityRef" };
+  }
+  if (md?.validAt !== void 0 && md.validAt !== target.frontmatter.valid_at) {
+    return { ok: false, field: "validAt" };
+  }
+  if (target.frontmatter.invalid_at !== void 0) {
+    return { ok: false, field: "validity_bounds" };
+  }
+  if (target.frontmatter.valid_at !== void 0 && md?.validAt === void 0) {
+    return { ok: false, field: "validity_bounds" };
+  }
+  const targetTags = new Set(target.frontmatter.tags ?? []);
+  if ((md?.tags ?? []).some((tag) => !targetTags.has(tag))) {
+    return { ok: false, field: "tags" };
+  }
+  if (md?.importanceScore !== void 0 && md.importanceScore > (target.frontmatter.importance?.score ?? 0)) {
+    return { ok: false, field: "importance" };
+  }
+  const incomingProvenanceRank = provenanceRank(md?.provenanceStrength);
+  const targetProvenanceRank = provenanceRank(target.frontmatter.provenance);
+  if (incomingProvenanceRank > targetProvenanceRank) {
+    return { ok: false, field: "provenance" };
+  }
+  const provenanceFloor = incomingProvenanceRank < targetProvenanceRank ? md?.provenanceStrength ?? "none" : void 0;
+  if (md?.confidence !== void 0) {
+    if (typeof md.confidence !== "number" || !Number.isFinite(md.confidence) || md.confidence < 0 || md.confidence > 1) {
+      return { ok: false, field: "confidence" };
+    }
+  }
+  const confidenceFloor = md?.confidence !== void 0 && md.confidence < (target.frontmatter.confidence ?? 0.8) ? md.confidence : void 0;
+  if (normalizeConnectorScope(target.frontmatter.sourceConnector) !== normalizeConnectorScope(input.sourceConnector)) {
+    return { ok: false, field: "sourceConnector" };
+  }
+  if (md?.toolScoped === true && target.frontmatter.toolScoped !== true) {
+    return { ok: false, field: "toolScoped" };
+  }
+  if ((md?.subject ?? "user") !== (target.frontmatter.subject ?? "user")) {
+    return { ok: false, field: "subject" };
+  }
+  if (md?.memoryKind !== void 0 && md.memoryKind !== target.frontmatter.memoryKind) {
+    return { ok: false, field: "memoryKind" };
+  }
+  if (isUntrustedOrigin(parseOriginClass(md?.origin), untrustedOrigins) && !isUntrustedOrigin(parseOriginClass(target.frontmatter.origin), untrustedOrigins)) {
+    return { ok: false, field: "origin" };
+  }
+  const incomingFaithfulness = effectiveFaithfulness(md?.faithfulness?.verdict);
+  const targetFaithfulness = effectiveFaithfulness(target.frontmatter.faithfulness?.verdict);
+  if (incomingFaithfulness !== targetFaithfulness) {
+    return { ok: false, field: "faithfulness" };
+  }
+  if (targetFaithfulness === "entailed") {
+    return { ok: false, field: "faithfulness" };
+  }
+  return {
+    ok: true,
+    ...provenanceFloor !== void 0 ? { provenanceFloor } : {},
+    ...confidenceFloor !== void 0 ? { confidenceFloor } : {}
+  };
+}
+function committedMergedBody(deps, mergedContent, incomingCitedContent) {
+  if (resolvePipelineProcessingCapabilities(deps.config).inlineSourceAttribution !== true || incomingCitedContent === void 0) {
+    return mergedContent;
+  }
+  const marker = lastCitationMarkerForTemplate(
+    incomingCitedContent,
+    deps.config.inlineSourceAttributionFormat
+  );
+  if (!marker || mergedContent.endsWith(marker)) return mergedContent;
+  return `${mergedContent} ${marker}`;
+}
+function versioningConfigFrom(deps) {
+  return {
+    enabled: resolveRecallAuxiliaryCapabilities(deps.config).versioning,
+    maxVersionsPerPage: deps.config.versioningMaxPerPage,
+    sidecarDir: deps.config.versioningSidecarDir
+  };
+}
+function mergeMemoryLinks(existing, incoming, survivingTargetId) {
+  if (!incoming || incoming.length === 0) return void 0;
+  const merged = [...existing ?? []];
+  for (const link of incoming) {
+    if (link.targetId === survivingTargetId) continue;
+    if (!merged.some((l) => l.targetId === link.targetId && l.linkType === link.linkType)) {
+      merged.push({ ...link });
+    }
+  }
+  return merged.length > 0 ? merged : void 0;
+}
+async function applySemanticMergeAtPersist(deps, options) {
+  const config = deps.config.semanticMerge;
+  if (config?.enabled !== true || options.skip === true) {
+    return { action: "created", reason: "disabled" };
+  }
+  if (REFUSED.includes(options.category)) {
+    return { action: "created", reason: "disabled" };
+  }
+  const decision = await decideSemanticMerge({
+    content: options.content,
+    category: options.category,
+    config,
+    sourceConnector: options.sourceConnector,
+    dedupThreshold: deps.config.semanticDedupThreshold,
+    lookup: (content, limit) => deps.semanticDedupLookup(content, limit, options.storage),
+    resolveCandidate: async (memoryId) => {
+      const memory = await options.storage.getMemoryByIdIncludingArchived(memoryId);
+      if (!memory) return null;
+      return {
+        content: memory.content,
+        category: memory.frontmatter.category,
+        status: inferMemoryStatus(memory.frontmatter, memory.path)
+      };
+    },
+    judge: async (input) => {
+      const call = options.judgeCall ?? callMergeJudge;
+      const verdict = await call({
+        ...input,
+        candidates: [...input.candidates],
+        config: deps.config,
+        localLlm: deps.getLocalLlm(),
+        fallbackLlm: new FallbackLlmClient(
+          deps.config.gatewayConfig,
+          fallbackLlmRuntimeContextFromConfig(deps.config)
+        )
+      });
+      if (!verdict) throw new Error("merge judge unavailable or unparseable");
+      return verdict;
+    }
+  });
+  if (decision.action === "create") {
+    if (config.shadowMode) {
+      log.info(
+        `semantic-merge[shadow]: would create category=${options.category} length=${options.content.length} reason="${decision.reason}"`
+      );
+    }
+    return { action: "created", reason: decision.reason };
+  }
+  if (config.shadowMode) {
+    log.info(
+      `semantic-merge[shadow]: would merge into ${decision.targetId} reason="judge_merge"`
+    );
+    return { action: "created", reason: "shadow_would_merge" };
+  }
+  const target = await options.storage.getMemoryByIdIncludingArchived(decision.targetId);
+  if (!target || inferMemoryStatus(target.frontmatter, target.path) !== "active") {
+    return { action: "created", reason: "target_inactive" };
+  }
+  if (target.content !== decision.targetContent) {
+    return { action: "created", reason: "target_changed" };
+  }
+  const committedContent = committedMergedBody(deps, decision.mergedContent, options.incomingCitedContent);
+  const parity = createPathMergeParity({
+    target,
+    incoming: options.incomingMetadata,
+    sourceConnector: options.sourceConnector,
+    untrustedOrigins: deps.config.untrustedOrigins
+  });
+  if (!parity.ok) {
+    return { action: "created", reason: "metadata_unpreservable" };
+  }
+  if (options.targetHasPromotedCopies && await options.targetHasPromotedCopies(decision.targetId)) {
+    return { action: "created", reason: "promoted_copy_present" };
+  }
+  const versioning = versioningConfigFrom(deps);
+  if (!versioning.enabled) {
+    return { action: "created", reason: "snapshot_unavailable" };
+  }
+  let versionId;
+  try {
+    versionId = await stageMergedTargetSnapshot(target, versioning, options.storage.dir);
+  } catch (err) {
+    log.warn(
+      `semantic-merge: snapshot failed for ${decision.targetId}; creating new fact instead: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return { action: "created", reason: "snapshot_failed" };
+  }
+  const repairIndexes = async (committedFactHash) => {
+    try {
+      await options.storage.removeFactContentHashesForMemories([target]);
+      if (committedFactHash !== void 0) {
+        await options.storage.registerFactContentHash(decision.targetId, committedFactHash, committedContent);
+        await persistRepairedContentHash(
+          options.storage,
+          decision.targetId,
+          committedContent,
+          committedFactHash
+        );
+      } else {
+        await options.storage.restoreFactHashAfterApproval(decision.targetId);
+      }
+    } catch (err) {
+      log.warn(
+        `semantic-merge: hash-index sync failed for ${decision.targetId} (non-fatal; index rebuilds from corpus): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    try {
+      await deps.indexPersistedMemory(options.storage, decision.targetId);
+    } catch (err) {
+      log.warn(
+        `semantic-merge: reindex failed for ${decision.targetId} (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  };
+  const nowIso = (options.now ? options.now() : /* @__PURE__ */ new Date()).toISOString();
+  let contentCommitted = false;
+  let mergePatch;
+  try {
+    mergePatch = buildMergeFrontmatterUpdate({
+      targetSources: target.frontmatter.sources ?? [],
+      incomingSources: options.sources ?? [],
+      targetReinforcementCount: target.frontmatter.reinforcement_count,
+      nowIso
+    });
+    const updated = await options.storage.updateMemoryIfUnchanged(target, committedContent, {
+      actor: "semantic-merge"
+    });
+    if (!updated) {
+      await discardMergedTargetSnapshot(
+        target.path,
+        versioning,
+        options.storage.dir,
+        decision.targetId,
+        versionId
+      );
+      return { action: "created", reason: "target_changed" };
+    }
+    contentCommitted = true;
+    const merged = await readTargetSnapshot(options.storage, target);
+    if (!merged || merged.content !== committedContent) {
+      throw new Error("target replaced before the provenance patch");
+    }
+    const mergedRawBody = rawPreCitationMergedBody(deps, committedContent);
+    const mergedIntent = resolveConversationContextCapabilities(deps.config).intentRouting ? inferIntentFromText(
+      `${merged.frontmatter.category} ${(merged.frontmatter.tags ?? []).join(" ")} ${mergedRawBody}`
+    ) : void 0;
+    const mergedFactHash = options.category === "fact" ? ContentHashIndex.computeHash(sanitizeMemoryContent(mergedRawBody).text) : void 0;
+    const mergedLinks = mergeMemoryLinks(
+      merged.frontmatter.links,
+      options.incomingLinks,
+      decision.targetId
+    );
+    const patched = await options.storage.writeMemoryFrontmatterIfUnchanged(
+      merged,
+      {
+        updated: mergePatch.updated,
+        derived_via: mergePatch.derived_via,
+        reinforcement_count: mergePatch.reinforcement_count,
+        sources: mergePatch.sources,
+        ...mergedFactHash !== void 0 ? { contentHash: mergedFactHash } : {},
+        // Finding B — a weaker incoming provenance retags the combined body
+        // to the least-trusted value instead of letting unverified new
+        // claims ride the target's stronger memory-level tag.
+        ...parity.ok && parity.provenanceFloor !== void 0 ? { provenance: parity.provenanceFloor } : {},
+        // Final round (A) — min(incoming, target) confidence: the merged
+        // record keeps the lower score, and the tier that score maps to,
+        // so lifecycle scoring and the committed-record promotion payload
+        // can never treat the combined body as higher-confidence than the
+        // create path would have stored for the incoming fact alone.
+        ...parity.ok && parity.confidenceFloor !== void 0 ? {
+          confidence: parity.confidenceFloor,
+          confidenceTier: confidenceTier(parity.confidenceFloor)
+        } : {},
+        ...mergedLinks !== void 0 ? { links: mergedLinks } : {},
+        ...mergedIntent !== void 0 ? {
+          intentGoal: mergedIntent.goal,
+          intentActionType: mergedIntent.actionType,
+          intentEntityTypes: mergedIntent.entityTypes
+        } : {}
+      },
+      { actor: "semantic-merge" }
+    );
+    if (!patched) throw new Error("frontmatter patch rejected (target changed)");
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    if (contentCommitted && !await revertMergedContent(options.storage, target, committedContent)) {
+      log.error(
+        `semantic-merge: ${decision.targetId} holds merged content without provenance metadata and the rollback failed (${detail}); snapshot ${versionId} holds the pre-merge state \u2014 recover with revertToVersion. Not creating a duplicate fact.`
+      );
+      await finalizeMergedVersionPrune(target.path, versioning, options.storage.dir, decision.targetId, versionId);
+      await repairIndexes(committedMergedFactHash(deps, options.category, committedContent));
+      return {
+        action: "merged",
+        targetId: decision.targetId,
+        mergedContent: committedContent,
+        provenancePatched: false
+      };
+    }
+    if (contentCommitted) {
+      await discardMergedTargetSnapshot(
+        target.path,
+        versioning,
+        options.storage.dir,
+        decision.targetId,
+        versionId
+      );
+    }
+    log.warn(
+      `semantic-merge: update failed for ${decision.targetId}${contentCommitted ? ` (content rolled back; snapshot ${versionId} rolled back out of history)` : ` (snapshot ${versionId} staged)`}: ${detail}`
+    );
+    return { action: "created", reason: "update_failed" };
+  }
+  await finalizeMergedVersionPrune(target.path, versioning, options.storage.dir, decision.targetId, versionId);
+  await repairIndexes();
+  log.info(
+    `semantic-merge: merged fact into ${decision.targetId} (version ${versionId})`
+  );
+  return {
+    action: "merged",
+    targetId: decision.targetId,
+    mergedContent: committedContent,
+    provenancePatched: true
   };
 }
-
-// src/orchestration/extraction-persist-promotion.ts
-var confidenceTierOrder = [
-  "explicit",
-  "implied",
-  "inferred",
-  "speculative"
-];
-function profileAutoPromotionAllows(scopeProfileWritePlan, category, confidence) {
-  if (!scopeProfileWritePlan) return false;
-  const actualTier = confidenceTier(confidence);
-  const actualRank = confidenceTierOrder.indexOf(actualTier);
-  if (actualRank === -1) return false;
-  const autoPromote = scopeProfileWritePlan.profile.autoPromote;
-  if (!autoPromote.enabled) return false;
-  if (!autoPromote.categories.includes(category)) return false;
-  const minimumRank = confidenceTierOrder.indexOf(autoPromote.minConfidenceTier);
-  return minimumRank !== -1 && actualRank <= minimumRank;
-}
-function sharedAutoPromotionAllows(config, scopeProfileWritePlan, category, confidence) {
-  if (!scopeProfileWritePlan) {
-    const actualTier = confidenceTier(confidence);
-    const actualRank = confidenceTierOrder.indexOf(actualTier);
-    if (actualRank === -1) return false;
-    if (!resolveRecallEnhancementCapabilities(config).autoPromoteToShared) return false;
-    if (!config.autoPromoteToSharedCategories.includes(category))
-      return false;
-    const minimumRank = confidenceTierOrder.indexOf(
-      config.autoPromoteMinConfidenceTier
+async function writeMergedVerbatimArtifact(deps, storage, targetId, input) {
+  if (!resolvePresentationCapabilities(deps.config).verbatimArtifacts) return;
+  if (!deps.config.verbatimArtifactCategories.includes(input.category)) {
+    return;
+  }
+  if (!(input.confidence >= deps.config.verbatimArtifactsMinConfidence)) return;
+  try {
+    await storage.writeArtifact(input.citedContent, {
+      confidence: input.confidence,
+      tags: [...input.tags, "artifact"],
+      artifactType: deps.artifactTypeForCategory(input.category),
+      sourceMemoryId: targetId,
+      intentGoal: input.intent?.goal,
+      intentActionType: input.intent?.actionType,
+      intentEntityTypes: input.intent?.entityTypes,
+      ...input.sourceConnector ? { sourceConnector: input.sourceConnector } : {},
+      ...input.origin ? { origin: input.origin } : {},
+      ...input.toolScoped ? { toolScoped: true } : {}
+    });
+  } catch (err) {
+    log.warn(
+      `semantic-merge: verbatim artifact write failed for ${targetId} (non-fatal; the committed target remains discoverable): ${err instanceof Error ? err.message : String(err)}`
     );
-    return minimumRank !== -1 && actualRank <= minimumRank;
   }
-  return scopeProfileWritePlan.profile.autoPromote.targets.includes("serverShared") && profileAutoPromotionAllows(scopeProfileWritePlan, category, confidence);
-}
-function shouldPromoteToShared(config, scopeProfileWritePlan, profileAllowsSharedWrites, storageDirNamespace, targetStorage, category, confidence) {
-  if (!resolveNamespaceCapabilities(config).namespaces || !profileAllowsSharedWrites || !sharedAutoPromotionAllows(config, scopeProfileWritePlan, category, confidence))
-    return false;
-  if (storageDirNamespace(targetStorage.dir) === config.sharedNamespace)
-    return false;
-  return true;
-}
-async function readActiveMemoriesBothTiers(storage) {
-  const [hotMems, coldMems] = await Promise.all([
-    storage.readAllMemories(),
-    storage.readAllColdMemories()
-  ]);
-  return coldMems.length === 0 ? hotMems : [...hotMems, ...coldMems];
 }
-async function flushDeferredFactHashOnFailure(saveContentHashIndexes, deferred) {
-  if (!deferred) return;
-  await saveContentHashIndexes().catch(
-    (err) => log.warn(`content-hash flush after post-write failure failed: ${err}`)
-  );
+async function runMergedTargetPostEffects(deps, storage, merge, input) {
+  const signals = buildBehaviorSignalsForMemory({
+    memoryId: merge.targetId,
+    category: input.category,
+    content: input.incomingContent,
+    namespace: input.namespace,
+    confidence: input.incomingConfidence,
+    source: "extraction"
+  });
+  if (input.threadEpisodeIdsForGraph) {
+    const episodes = input.threadEpisodeIdsForGraph;
+    const existing = episodes.lastIndexOf(merge.targetId);
+    if (existing !== -1) episodes.splice(existing, 1);
+    episodes.push(merge.targetId);
+  }
+  if (!input.graphCaps.multiGraphMemory) return signals;
+  try {
+    const committed = await storage.getMemoryByIdIncludingArchived(merge.targetId);
+    if (!committed || committed.content !== merge.mergedContent) return signals;
+    if (inferMemoryStatus(committed.frontmatter, committed.path) !== "active") return signals;
+    const entityRef = committed.frontmatter.entityRef;
+    const rawBody = rawPreCitationMergedBody(deps, merge.mergedContent);
+    const memoryRelPath = path5.relative(storage.dir, committed.path);
+    input.graphContext.memoryPathById.set(merge.targetId, memoryRelPath);
+    const all = input.graphContext.allMemsForGraph;
+    if (Array.isArray(all)) {
+      const entry = all.find((m) => path5.relative(storage.dir, m.path) === memoryRelPath);
+      if (entry) entry.content = rawBody;
+    }
+    const rewriteTypes = [];
+    if (input.graphCaps.entityGraph) rewriteTypes.push("entity");
+    if (input.graphCaps.timeGraph) rewriteTypes.push("time");
+    if (input.graphCaps.causalGraph) rewriteTypes.push("causal");
+    const installed = await rewriteMergedTargetGraphEdges(storage, {
+      targetId: merge.targetId,
+      memoryRelPath,
+      mergedContent: merge.mergedContent,
+      revisionChecked: committed.frontmatter.updated,
+      rewriteTypes,
+      build: () => deps.buildGraphEdge(
+        storage,
+        memoryRelPath,
+        entityRef,
+        merge.targetId,
+        rawBody,
+        all,
+        input.graphContext.memoryPathById,
+        input.threadIdForEdge,
+        input.threadEpisodeIdsForGraph,
+        input.graphContext.previousPersistedRelPath,
+        input.graphCaps
+      )
+    });
+    if (installed) input.graphContext.previousPersistedRelPath = memoryRelPath;
+  } catch {
+  }
+  return signals;
 }
 
-// src/orchestration/harmonic-construction-persist.ts
-function filterHarmonicEntityMentions(facts, entityMentions) {
-  const identitiesBySegment = /* @__PURE__ */ new Map();
-  for (const entity of entityMentions) {
-    const segment = harmonicEntitySegment(entity.name);
-    const identities = identitiesBySegment.get(segment) ?? /* @__PURE__ */ new Set();
-    identities.add(normalizedHarmonicEntityIdentity(entity.name));
-    identitiesBySegment.set(segment, identities);
+// src/orchestration/semantic-merge-promotion-payload.ts
+async function buildMergedTargetPromotionPayload(storage, merge) {
+  if (!merge.provenancePatched) {
+    log.warn(
+      `semantic-merge: skipping merged-target promotion for ${merge.targetId} \u2014 provenance patch did not land; the record still holds pre-merge trust metadata`
+    );
+    return null;
   }
-  return entityMentions.flatMap((entity) => {
-    const allowSegmentFallback = identitiesBySegment.get(harmonicEntitySegment(entity.name))?.size === 1;
-    const activeFacts = facts.filter(
-      (fact) => typeof fact.entityRef === "string" && harmonicEntityReferenceMatches(fact.entityRef, entity.name, allowSegmentFallback)
+  let committed;
+  try {
+    committed = await storage.getMemoryByIdIncludingArchived(merge.targetId);
+  } catch (err) {
+    log.warn(
+      `semantic-merge: merged-target promotion reread failed for ${merge.targetId} (non-fatal; promotion skipped, the committed merge stands): ${err instanceof Error ? err.message : String(err)}`
     );
-    return activeFacts.length > 0 ? [{ ...entity, facts: activeFacts.map((fact) => fact.content) }] : [];
-  });
-}
-async function persistConstructedHarmonicRecords(options) {
-  const sessionKey = options.sessionKey?.trim();
-  if (!sessionKey) {
-    log.warn("harmonic construction skipped: extraction session key is missing");
-    return;
+    return null;
   }
-  const recordedAt = options.validAt && Number.isFinite(Date.parse(options.validAt)) ? new Date(options.validAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
-  const entries = [...options.entries];
-  const sharedEpisodeTitle = entries.length === 1 ? options.episodeTitle : void 0;
-  for (const entry of entries) {
-    try {
-      const records = deriveHarmonicRecords({
-        sessionKey,
-        recordedAt,
-        episodeTitle: sharedEpisodeTitle,
-        persistedFacts: entry.facts,
-        entityMentions: filterHarmonicEntityMentions(entry.facts, options.entityMentions).map((entity) => ({
-          name: entity.name,
-          type: entity.type,
-          facts: entity.facts
-        }))
-      });
-      await persistHarmonicRecords({
-        memoryDir: entry.storage.dir,
-        abstractionNodeStoreDir: entry.storage.dir === options.baseStorageDir ? options.abstractionNodeStoreDir : void 0,
-        nodes: records.nodes,
-        anchors: options.anchorsEnabled ? records.anchors : []
-      });
-    } catch (error) {
-      log.warn(
-        `harmonic construction failed open for namespace ${entry.storage.dir}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
+  if (!committed || committed.content !== merge.mergedContent) return null;
+  if (inferMemoryStatus(committed.frontmatter, committed.path) !== "active") {
+    return null;
   }
+  const fm = committed.frontmatter;
+  return {
+    category: fm.category,
+    content: committed.content,
+    confidence: fm.confidence,
+    tags: fm.tags ?? [],
+    sourceMemoryId: fm.id,
+    origin: parseOriginClass(fm.origin),
+    source: fm.source,
+    ...fm.entityRef !== void 0 ? { entityRef: fm.entityRef } : {},
+    ...fm.structuredAttributes !== void 0 ? { structuredAttributes: { ...fm.structuredAttributes } } : {},
+    ...fm.importance !== void 0 ? { importance: fm.importance } : {},
+    ...fm.intentGoal !== void 0 ? { intentGoal: fm.intentGoal } : {},
+    ...fm.intentActionType !== void 0 ? { intentActionType: fm.intentActionType } : {},
+    ...fm.intentEntityTypes !== void 0 ? { intentEntityTypes: [...fm.intentEntityTypes] } : {},
+    ...fm.memoryKind !== void 0 ? { memoryKind: fm.memoryKind } : {},
+    ...fm.valid_at !== void 0 ? { validAt: fm.valid_at } : {},
+    ...fm.invalid_at !== void 0 ? { invalidAt: fm.invalid_at } : {},
+    ...fm.observedAt !== void 0 ? { observedAt: fm.observedAt } : {},
+    ...fm.eventTimeSource !== void 0 ? { eventTimeSource: fm.eventTimeSource } : {},
+    ...fm.sources && fm.sources.length > 0 ? { sources: fm.sources.map((source) => ({ ...source })) } : {},
+    ...fm.provenance !== void 0 ? { provenance: fm.provenance } : {},
+    ...fm.subject !== void 0 ? { subject: fm.subject } : {},
+    ...fm.toolScoped === true ? { toolScoped: true } : {},
+    ...fm.sourceConnector !== void 0 ? { sourceConnector: fm.sourceConnector } : {},
+    ...fm.updated !== void 0 ? { committedRevision: fm.updated } : {}
+  };
 }
 
 // src/orchestration/extraction-anchor-snapshot.ts
-import path5 from "path";
+import path6 from "path";
 var ExtractionAnchorSnapshot = class {
   constructor(options = {}) {
     this.options = options;
@@ -5035,7 +6011,8 @@ var ExtractionAnchorSnapshot = class {
       if (!cached) return;
       const snapshot = await cached;
       const relativePath = resolvePersistedMemoryRelativePath({ memoryId, pathById, category });
-      const memory = await storage.readMemoryByPath(path5.join(storage.dir, relativePath));
+      let memory = await storage.readMemoryByPath(path6.join(storage.dir, relativePath));
+      if (!memory) memory = await storage.getMemoryByIdIncludingArchived(memoryId);
       if (!memory) return;
       const existingIndex = snapshot.findIndex((entry) => entry.frontmatter.id === memoryId);
       if (existingIndex >= 0) snapshot.splice(existingIndex, 1);
@@ -5077,6 +6054,7 @@ var ExtractionPersistCoordinator = class {
     const harmonicFactsByStorage = /* @__PURE__ */ new Map();
     const harmonicSourceInsertedAtBase = Date.now();
     let harmonicSourceOrder = 0;
+    const promotedCopyProbe = createBatchPromotedCopyProbe(this.deps.config, this.deps.getStorageRouter, scopeProfileWritePlan);
     const normalizeStoredHashSource = (raw) => ContentHashIndex.normalizeContent(
       sanitizeMemoryContent(
         citationEnabled && hasCitationForTemplate(raw, citationTemplate) ? stripCitationForTemplate(raw, citationTemplate) : raw
@@ -5137,7 +6115,7 @@ var ExtractionPersistCoordinator = class {
         memoryPathById.set(id, relPath);
       }
     };
-    let dedupedCount = 0;
+    let dedupedCount = 0, semanticMergedCount = 0;
     let importanceGatedCount = 0;
     let batchBackendUnavailable = false;
     let redactionGatedCount = 0;
@@ -5180,28 +6158,19 @@ var ExtractionPersistCoordinator = class {
     const namespacesEnabled = resolveNamespaceCapabilities(this.deps.config).namespaces;
     const sourceConnector = sourceContext?.sourceConnector;
     const origin = classifyExtractionOrigin(sourceContext);
-    const subjectGuardAllows = (subject, target, label) => {
-      const decision = evaluateSubjectGuard({
-        subject,
-        sharedTarget: isSharedPromotionTarget(target),
-        mode: this.deps.config.subjectGuard
-      });
-      if (decision.action !== "allow") {
-        log.warn(`subject-guard(${decision.action}) ${label}: ${decision.reason}`);
-      }
-      return decision.action !== "reject";
-    };
+    const subjectGuardAllows = makeSubjectGuardAllows(this.deps.config);
     const promoteMemoryToProfileTargets = async (options) => {
       if (!scopeProfileWritePlan || !profileAutoPromotionAllows(scopeProfileWritePlan, options.category, options.confidence))
-        return;
+        return [];
       const autoTargets = new Set(scopeProfileWritePlan.profile.autoPromote.targets);
       const targets = scopeProfileWritePlan.promotionTargets.filter(
         (target) => target.target !== "serverShared" && autoTargets.has(target.target) && target.authorized && target.namespace
       );
-      if (targets.length === 0) return;
+      if (targets.length === 0) return [];
       const rawContent = citationEnabled && hasCitationForTemplate(options.content, citationTemplate) ? stripCitationForTemplate(options.content, citationTemplate) : options.content;
       const citedContent = applyInlineCitation(rawContent);
       const sanitizedBase = sanitizeMemoryContent(rawContent);
+      const writtenCopyIds = [];
       for (const target of targets) {
         if (!target.namespace) continue;
         try {
@@ -5212,7 +6181,7 @@ var ExtractionPersistCoordinator = class {
             {
               content: citedContent,
               category: options.category,
-              origin,
+              origin: options.origin ?? origin,
               confidence: options.confidence,
               tags: withReservedMarkerTag(options.tags, `${target.target}-promotion`),
               entityRef: options.entityRef,
@@ -5302,6 +6271,7 @@ var ExtractionPersistCoordinator = class {
             }
           }
           if (!targetPromotion.tombstoneBlocked) {
+            writtenCopyIds.push(promotedId);
             trackPersistedId(targetStorage, promotedId, {
               includeReturnedIds: false,
               category: options.category,
@@ -5326,14 +6296,15 @@ var ExtractionPersistCoordinator = class {
           );
         }
       }
+      return writtenCopyIds;
     };
     const promoteMemoryToShared = async (options) => {
-      const toolScoped = withholdToolScopedFromSharedNamespace(options);
-      await promoteMemoryToProfileTargets({
+      const toolScoped = promotionWithholdsToolScope(options);
+      let promotedCopyId = (await promoteMemoryToProfileTargets({
         ...options,
         ...toolScoped ? { toolScoped: true } : {}
-      });
-      if (lifecycleCaps.extractionScopeClassification && toolScoped) return;
+      })).at(-1);
+      if (lifecycleCaps.extractionScopeClassification && toolScoped) return promotedCopyId;
       if (!shouldPromoteToShared(
         this.deps.config,
         scopeProfileWritePlan,
@@ -5343,8 +6314,9 @@ var ExtractionPersistCoordinator = class {
         options.category,
         options.confidence
       ))
-        return;
-      if (!subjectGuardAllows(options.subject, "serverShared", "shared promotion")) return;
+        return promotedCopyId;
+      if (!subjectGuardAllows(options.subject, "serverShared", "shared promotion"))
+        return promotedCopyId;
       try {
         const sharedStorage = await this.deps.getStorageRouter().storageFor(
           this.deps.config.sharedNamespace
@@ -5356,7 +6328,7 @@ var ExtractionPersistCoordinator = class {
           {
             content: citedContent,
             category: options.category,
-            origin,
+            origin: options.origin ?? origin,
             confidence: options.confidence,
             tags: withReservedMarkerTag(options.tags, "shared-promotion"),
             entityRef: options.entityRef,
@@ -5443,7 +6415,7 @@ var ExtractionPersistCoordinator = class {
                 });
                 if (hashDedupSupersession.supersededIds.length > 0) {
                 }
-                return;
+                return promotedCopyId;
               }
               log.debug(
                 `persistExtraction: hash-dedup found no active same-entity shared fact for ${options.sourceMemoryId}; falling through to write`
@@ -5453,7 +6425,7 @@ var ExtractionPersistCoordinator = class {
                 `persistExtraction: shared-namespace supersession on hash-dedup path failed open for ${options.sourceMemoryId}: ${hashDedupSupersessionErr}`
               );
               if (hashDedupLookupComplete && hashDedupMatchingFact) {
-                return;
+                return promotedCopyId;
               }
               log.debug(
                 `persistExtraction: hash-dedup catch: lookup incomplete or no candidate found for ${options.sourceMemoryId}; falling through to write`
@@ -5478,7 +6450,7 @@ var ExtractionPersistCoordinator = class {
               skipSharedPromotion = false;
             }
             if (skipSharedPromotion) {
-              return;
+              return promotedCopyId;
             }
           }
         }
@@ -5538,10 +6510,13 @@ var ExtractionPersistCoordinator = class {
             })
           );
         }
+        promotedCopyId = promotedId;
+        return promotedId;
       } catch (err) {
         log.warn(
           `persistExtraction: shared promotion failed open for ${options.sourceMemoryId}: ${err}`
         );
+        return promotedCopyId;
       }
     };
     const backfillTemporalBoundsOnPromotionCopies = async (args) => {
@@ -6493,6 +7468,42 @@ var ExtractionPersistCoordinator = class {
       const memoryKind = writeCategory === "procedure" ? void 0 : resolvePresentationCapabilities(this.deps.config).episodeNoteMode ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory) : void 0;
       const rawPersistBody = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : fact.content;
       const citedFactContent = applyInlineCitation(rawPersistBody);
+      const semanticMerge = await applySemanticMergeAtPersist(this.deps, {
+        storage: targetStorage,
+        content: fact.content,
+        category: writeCategory,
+        sources: fact.sources,
+        sourceConnector: extractionSourceConnector,
+        incomingMetadata: { tags: [...fact.tags, ...injectionScreenTags], entityRef: fact.entityRef, structuredAttributes: fact.structuredAttributes, validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt, biTemporal: biTemporal !== void 0, importanceScore: importance.score, confidence: fact.confidence, provenanceStrength: fact.provenance, toolScoped: factToolScoped, subject: factSubject, origin, faithfulness: faithfulnessFm, memoryKind },
+        skip: contradictionDetected || faithfulnessEnforceStatus === "pending_review" || batchBackendUnavailable || novelty.decision === "add",
+        incomingLinks: links.length > 0 ? links : void 0,
+        incomingCitedContent: citedFactContent,
+        targetHasPromotedCopies: (targetId) => promotedCopyProbe.check(targetStorage, targetId)
+      });
+      if (semanticMerge.action === "created" && semanticMerge.reason === "backend_unavailable") batchBackendUnavailable = true;
+      if (semanticMerge.action === "merged") {
+        semanticMergedCount++;
+        await anchorSnapshots.replace(targetStorage, semanticMerge.targetId, writeCategory, memoryPathById);
+        const mergedPromotion = await buildMergedTargetPromotionPayload(targetStorage, semanticMerge);
+        await promoteAndReconcileMergedTarget({ promote: (payload) => promoteMemoryToShared({ sourceStorage: targetStorage, ...payload }), config: this.deps.config, getStorageRouter: this.deps.getStorageRouter, scopeProfileWritePlan, sourceStorage: targetStorage, sourceMemoryId: semanticMerge.targetId, mergedPromotion, normalize: normalizeStoredHashSource, onReconciled: () => promotedCopyProbe.invalidate() });
+        trackPersistedId(targetStorage, semanticMerge.targetId, { includeReturnedIds: false });
+        await persistMergedTargetThreadEpisode(this.deps.getThreading(), threadIdForExtraction, semanticMerge.targetId);
+        if (harmonicConstructionEnabled) {
+          enqueueMergedTargetForHarmonicConstruction(harmonicFactsByStorage, targetStorage, harmonicFact, semanticMerge.targetId, semanticMerge.mergedContent, new Date(harmonicSourceInsertedAtBase + harmonicSourceOrder++).toISOString());
+        }
+        trackBehaviorSignals(targetStorage, await runMergedTargetPostEffects(this.deps, targetStorage, semanticMerge, {
+          category: writeCategory,
+          incomingContent: fact.content,
+          incomingConfidence: fact.confidence,
+          namespace: this.deps.storageDirNamespace(targetStorage.dir),
+          graphCaps,
+          graphContext: await ensureGraphContext(targetStorage),
+          threadIdForEdge: threadIdForExtraction ?? void 0,
+          threadEpisodeIdsForGraph
+        }));
+        await writeMergedVerbatimArtifact(this.deps, targetStorage, semanticMerge.targetId, { category: writeCategory, citedContent: citedFactContent, confidence: fact.confidence, tags: fact.tags, intent: inferredIntent ?? void 0, sourceConnector: extractionSourceConnector, origin, toolScoped: factToolScoped });
+        continue;
+      }
       const factWriteEnvelope = composeSalvagedExtractionEnvelope(
         {
           content: citedFactContent,
@@ -6596,34 +7607,37 @@ var ExtractionPersistCoordinator = class {
         if (!postWriteGuard) {
           await this.deps.indexPersistedMemory(targetStorage, memoryId);
         }
-        if (!postWriteGuard) await promoteMemoryToShared({
-          sourceStorage: targetStorage,
-          category: writeCategory,
-          content: fact.content,
-          confidence: fact.confidence,
-          subject: factSubject,
-          tags: fact.tags,
-          entityRef: typeof fact.entityRef === "string" ? fact.entityRef : void 0,
-          structuredAttributes: fact.structuredAttributes,
-          sourceMemoryId: memoryId,
-          importance,
-          intentGoal: inferredIntent?.goal,
-          intentActionType: inferredIntent?.actionType,
-          intentEntityTypes: inferredIntent?.entityTypes,
-          memoryKind,
-          validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
-          ...biTemporal ? {
-            observedAt: biTemporal.observedAt,
-            eventTimeSource: biTemporal.eventTimeSource,
-            ...biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}
-          } : {},
-          source: extractionWriteSource,
-          ...extractionSourceConnector ? { sourceConnector: extractionSourceConnector } : {},
-          ...fact.procedureSteps && fact.procedureSteps.length ? { procedureSteps: fact.procedureSteps } : {},
-          ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
-          ...fact.provenance ? { provenance: fact.provenance } : {},
-          harmonicFact
-        });
+        if (!postWriteGuard) {
+          await promoteMemoryToShared({
+            sourceStorage: targetStorage,
+            category: writeCategory,
+            content: fact.content,
+            confidence: fact.confidence,
+            subject: factSubject,
+            tags: fact.tags,
+            entityRef: typeof fact.entityRef === "string" ? fact.entityRef : void 0,
+            structuredAttributes: fact.structuredAttributes,
+            sourceMemoryId: memoryId,
+            importance,
+            intentGoal: inferredIntent?.goal,
+            intentActionType: inferredIntent?.actionType,
+            intentEntityTypes: inferredIntent?.entityTypes,
+            memoryKind,
+            validAt: biTemporal ? biTemporal.validFrom : sourceContext?.validAt,
+            ...biTemporal ? {
+              observedAt: biTemporal.observedAt,
+              eventTimeSource: biTemporal.eventTimeSource,
+              ...biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {}
+            } : {},
+            source: extractionWriteSource,
+            ...extractionSourceConnector ? { sourceConnector: extractionSourceConnector } : {},
+            ...fact.procedureSteps && fact.procedureSteps.length ? { procedureSteps: fact.procedureSteps } : {},
+            ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
+            ...fact.provenance ? { provenance: fact.provenance } : {},
+            harmonicFact
+          });
+          promotedCopyProbe.invalidate();
+        }
         if (graphCaps.multiGraphMemory && !postWriteGuard) {
           try {
             const graphContext = await ensureGraphContext(targetStorage);
@@ -6688,7 +7702,6 @@ var ExtractionPersistCoordinator = class {
       } catch (err) {
         await flushDeferredFactHashOnFailure(() => this.deps.saveContentHashIndexes(), factDedupEnabled);
         throw err;
-      } finally {
       }
     }
     let durableNonFactWritten = false;
@@ -6815,12 +7828,12 @@ ${q.context ?? ""}`], entityScreenOn);
         (err) => log.warn(`appendBehaviorSignals failed (non-fatal): ${err}`)
       );
     }
-    const dedupSuffix = dedupedCount > 0 ? ` (${dedupedCount} deduped)` : "";
+    const dedupSuffix = `${dedupedCount > 0 ? ` (${dedupedCount} deduped)` : ""}${semanticMergedCount > 0 ? ` (${semanticMergedCount} merged)` : ""}`;
     const gatedSuffix = importanceGatedCount > 0 ? ` (${importanceGatedCount} gated)` : "";
     const judgeSuffix = judgeGatedCount > 0 ? ` (${judgeGatedCount} judge-rejected)` : "";
     const redactionSuffix = redactionGatedCount > 0 ? ` (${redactionGatedCount} redacted)` : "";
     log.info(
-      `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
+      `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount - semanticMergedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
     );
     if (harmonicConstructionEnabled && harmonicFactsByStorage.size > 0) {
       await persistConstructedHarmonicRecords({
@@ -6870,8 +7883,8 @@ async function drainExtractionAndShutdownDependencyPropagation(extractionQueue,
 
 // src/orchestration/dependency-propagation-delivery.ts
 import { randomUUID } from "crypto";
-import { readFile as readFile2, unlink } from "fs/promises";
-import path6 from "path";
+import { readFile as readFile3, unlink } from "fs/promises";
+import path7 from "path";
 
 // src/orchestration/dependency-propagation-recovery-replay.ts
 import { createHash as createHash3 } from "crypto";
@@ -7047,7 +8060,7 @@ var DependencyPropagationDelivery = class {
       }, delayMs);
       timer.unref();
     });
-    this.readQueueFile = options.readQueueFile ?? ((filePath) => readFile2(filePath, "utf8"));
+    this.readQueueFile = options.readQueueFile ?? ((filePath) => readFile3(filePath, "utf8"));
     this.writeQueueFile = options.writeQueueFile ?? ((filePath, content) => writeJsonFileAtomic(filePath, JSON.parse(content)));
     this.replayReconciliation = options.replayReconciliation;
   }
@@ -7554,13 +8567,13 @@ var DependencyPropagationDelivery = class {
         try {
           const job = validateJob(JSON.parse(await this.readQueueFile(filePath)), status);
           if (!job) {
-            log.warn(`dependency propagation ignored invalid job file ${path6.basename(filePath)}`);
+            log.warn(`dependency propagation ignored invalid job file ${path7.basename(filePath)}`);
             continue;
           }
           entries.push({ job, filePath });
         } catch (error) {
           if (error instanceof SyntaxError || isNotFound(error)) {
-            log.warn(`dependency propagation ignored unreadable job file ${path6.basename(filePath)}: ${error}`);
+            log.warn(`dependency propagation ignored unreadable job file ${path7.basename(filePath)}: ${error}`);
             continue;
           }
           throw error;
@@ -7631,7 +8644,7 @@ var DependencyPropagationDelivery = class {
     await this.writeQueueJob(targetPath, next);
     const terminal = status === "completed" || status === "dead_letter" || status === "canceled";
     for (const entry of entries) {
-      if (path6.resolve(entry.filePath) === path6.resolve(targetPath)) continue;
+      if (path7.resolve(entry.filePath) === path7.resolve(targetPath)) continue;
       await unlink(entry.filePath).catch((error) => {
         if (isNotFound(error)) return;
         if (terminal) {
@@ -7695,7 +8708,7 @@ var DependencyPropagationDelivery = class {
         allowMissingDirectory: true
       });
       for (const filePath of files) {
-        if (path6.basename(filePath, ".json") !== jobId) continue;
+        if (path7.basename(filePath, ".json") !== jobId) continue;
         try {
           await unlink(filePath);
         } catch (error) {
@@ -7895,12 +8908,12 @@ function createDependencyPropagationReplayReconciliation(host) {
 
 // src/orchestration/recall-internal.ts
 import { createHash as createHash5 } from "crypto";
-import { readFile as readFile3, stat, unlink as unlink2 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile4, stat, unlink as unlink2 } from "fs/promises";
+import path11 from "path";
 
 // src/orchestration/graph-path-state-loader.ts
 import { lstat, opendir, realpath } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 function isArchivePathIndexUnavailable(index) {
   return "unavailable" in index;
 }
@@ -7919,11 +8932,11 @@ var GraphPathStateLoader = class {
   openArchiveDirectory = opendir;
   async readNode(storage, nodeId, deadlineAtMs, allowArchiveLookup) {
     if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
-    const configuredStorageRoot = path7.resolve(storage.dir);
+    const configuredStorageRoot = path8.resolve(storage.dir);
     const storageRoot = await realpath(configuredStorageRoot).catch(() => null);
     if (!storageRoot || storageRoot !== configuredStorageRoot) return null;
-    const logicalId = path7.basename(nodeId, path7.extname(nodeId));
-    const directRelativePaths = [nodeId, path7.join("cold", nodeId)];
+    const logicalId = path8.basename(nodeId, path8.extname(nodeId));
+    const directRelativePaths = [nodeId, path8.join("cold", nodeId)];
     let inactiveDirectMemory = null;
     for (const relativePath of directRelativePaths) {
       const safePath = await this.resolveContainedPath(storageRoot, relativePath);
@@ -7946,7 +8959,7 @@ var GraphPathStateLoader = class {
     if (!archiveIndex || isArchivePathIndexUnavailable(archiveIndex) || typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) {
       return null;
     }
-    const archivePaths = archiveIndex.pathsByBasename.get(path7.basename(nodeId)) ?? [];
+    const archivePaths = archiveIndex.pathsByBasename.get(path8.basename(nodeId)) ?? [];
     for (const archivePath of archivePaths) {
       if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
       const memory = await storage.readMemoryByPath(archivePath);
@@ -7956,17 +8969,17 @@ var GraphPathStateLoader = class {
     return null;
   }
   async resolveContainedPath(storageRoot, relativePath) {
-    if (path7.isAbsolute(relativePath)) return null;
+    if (path8.isAbsolute(relativePath)) return null;
     const rawSegments = relativePath.replace(/\\/g, "/").split("/");
     if (rawSegments.includes("..")) return null;
-    const candidate = path7.resolve(storageRoot, relativePath);
-    const lexicalRelative = path7.relative(storageRoot, candidate);
-    if (lexicalRelative.length > 0 && (lexicalRelative.startsWith("..") || path7.isAbsolute(lexicalRelative))) {
+    const candidate = path8.resolve(storageRoot, relativePath);
+    const lexicalRelative = path8.relative(storageRoot, candidate);
+    if (lexicalRelative.length > 0 && (lexicalRelative.startsWith("..") || path8.isAbsolute(lexicalRelative))) {
       return null;
     }
     const canonical = await realpath(candidate).catch(() => candidate);
-    const canonicalRelative = path7.relative(storageRoot, canonical);
-    if (canonicalRelative.length > 0 && (canonicalRelative.startsWith("..") || path7.isAbsolute(canonicalRelative))) {
+    const canonicalRelative = path8.relative(storageRoot, canonical);
+    if (canonicalRelative.length > 0 && (canonicalRelative.startsWith("..") || path8.isAbsolute(canonicalRelative))) {
       return null;
     }
     return canonical;
@@ -8039,7 +9052,7 @@ var GraphPathStateLoader = class {
   }
   async buildArchivePathIndex(storageRoot, version) {
     const pathsByBasename = /* @__PURE__ */ new Map();
-    const archiveRoot = path7.join(storageRoot, "archive");
+    const archiveRoot = path8.join(storageRoot, "archive");
     let archiveRootStatus;
     try {
       archiveRootStatus = await this.archiveLstat(archiveRoot);
@@ -8057,8 +9070,8 @@ var GraphPathStateLoader = class {
       if (isArchiveScanAbsenceError(error)) return { version, pathsByBasename };
       return null;
     }
-    const archiveRelative = path7.relative(storageRoot, canonicalArchiveRoot);
-    if (archiveRelative.length > 0 && (archiveRelative.startsWith("..") || path7.isAbsolute(archiveRelative))) {
+    const archiveRelative = path8.relative(storageRoot, canonicalArchiveRoot);
+    if (archiveRelative.length > 0 && (archiveRelative.startsWith("..") || path8.isAbsolute(archiveRelative))) {
       return { version, pathsByBasename };
     }
     const pending = [canonicalArchiveRoot];
@@ -8084,8 +9097,8 @@ var GraphPathStateLoader = class {
         if (isArchiveScanAbsenceError(error)) continue;
         return null;
       }
-      const currentRelative = path7.relative(storageRoot, canonicalCurrent);
-      if (currentRelative.length > 0 && (currentRelative.startsWith("..") || path7.isAbsolute(currentRelative))) {
+      const currentRelative = path8.relative(storageRoot, canonicalCurrent);
+      if (currentRelative.length > 0 && (currentRelative.startsWith("..") || path8.isAbsolute(currentRelative))) {
         continue;
       }
       let directory;
@@ -8102,7 +9115,7 @@ var GraphPathStateLoader = class {
             return { version, unavailable: "oversized" };
           }
           if (entry.isSymbolicLink()) continue;
-          const entryPath = path7.join(canonicalCurrent, entry.name);
+          const entryPath = path8.join(canonicalCurrent, entry.name);
           if (entry.isDirectory()) {
             pending.push(entryPath);
             continue;
@@ -8118,8 +9131,8 @@ var GraphPathStateLoader = class {
             if (isArchiveScanAbsenceError(error)) continue;
             return null;
           }
-          const relative = path7.relative(storageRoot, canonical);
-          if (relative.length > 0 && (relative.startsWith("..") || path7.isAbsolute(relative))) {
+          const relative = path8.relative(storageRoot, canonical);
+          if (relative.length > 0 && (relative.startsWith("..") || path8.isAbsolute(relative))) {
             continue;
           }
           const paths = pathsByBasename.get(entry.name);
@@ -8145,7 +9158,7 @@ var GraphPathStateLoader = class {
 // src/orchestration/graph-recall-coordinator.ts
 import { createHash as createHash4 } from "crypto";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 function mergeGraphExpandedResults(primary, expanded) {
   const mergedByNamespaceAndPath = /* @__PURE__ */ new Map();
   for (const item of [...primary, ...expanded]) {
@@ -8162,11 +9175,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByNamespaceAndPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path8.isAbsolute(candidatePath) ? candidatePath : path8.resolve(storageDir, candidatePath);
-  const rel = path8.relative(storageDir, absolutePath);
+  const absolutePath = path9.isAbsolute(candidatePath) ? candidatePath : path9.resolve(storageDir, candidatePath);
+  const rel = path9.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path8.sep).join("/");
+  return rel.split(path9.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -8266,7 +9279,7 @@ var GraphRecallCoordinator = class {
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path8.isAbsolute(resolvedPath)) {
+      if (!path9.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -8291,7 +9304,7 @@ var GraphRecallCoordinator = class {
         }
         continue;
       }
-      if (path8.isAbsolute(result.path)) {
+      if (path9.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -8337,7 +9350,7 @@ var GraphRecallCoordinator = class {
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path8.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path9.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const nodeMemoryCache = /* @__PURE__ */ new Map();
@@ -8392,7 +9405,7 @@ var GraphRecallCoordinator = class {
             path: memory.path,
             score,
             namespace,
-            seed: path8.resolve(storage.dir, candidate.seed),
+            seed: path9.resolve(storage.dir, candidate.seed),
             hopDepth: candidate.hopDepth,
             decayedWeight: candidate.decayedWeight,
             graphType: candidate.graphType,
@@ -8424,7 +9437,7 @@ var GraphRecallCoordinator = class {
         add(memory.frontmatter.id);
         if (relativePath) {
           add(relativePath);
-          if (relativePath.endsWith(".md")) add(path8.basename(relativePath, ".md"));
+          if (relativePath.endsWith(".md")) add(path9.basename(relativePath, ".md"));
         }
         return state;
       };
@@ -8471,7 +9484,7 @@ var GraphRecallCoordinator = class {
           path: memory.path,
           score,
           namespace,
-          seed: path8.resolve(storage.dir, candidate.seed),
+          seed: path9.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -8514,12 +9527,12 @@ var GraphRecallCoordinator = class {
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path8.join(
+      const snapshotPath = path9.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path8.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path9.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -8814,11 +9827,11 @@ async function appendEpisodicContextSection(deps, options) {
 }
 
 // src/orchestration/recall-profile-storage.ts
-import path9 from "path";
+import path10 from "path";
 function resolveCompositeProfileStorage(options) {
   const { profileStorages, memoryDir } = options;
   const emptyProfileStorage = new Proxy(
-    { dir: path9.join(memoryDir, ".empty-scope-profile") },
+    { dir: path10.join(memoryDir, ".empty-scope-profile") },
     {
       get(target, prop) {
         if (prop in target) return Reflect.get(target, prop);
@@ -9197,7 +10210,7 @@ var RecallInternalCoordinator = class {
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path10.sep).join("/");
+        const normalizedPath = resultPath.split(path11.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -10733,16 +11746,16 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.deps.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.deps.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path10.join(
+        const signalPath = path11.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path10.join(workspaceDir, "BOOT.md");
+        const bootPath = path11.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
           const signalAge = Date.now() - signalStat.mtimeMs;
-          const signalData = JSON.parse(await readFile3(signalPath, "utf-8"));
+          const signalData = JSON.parse(await readFile4(signalPath, "utf-8"));
           if (signalData.sessionKey !== effectiveSessionKey) {
             log.debug(
               `recall: compaction signal is for ${signalData.sessionKey}, not ${effectiveSessionKey} \u2014 skipping`
@@ -10762,7 +11775,7 @@ ${formatted}`;
 
 `;
           try {
-            const bootContent = await readFile3(bootPath, "utf-8");
+            const bootContent = await readFile4(bootPath, "utf-8");
             section += "### BOOT.md (working state before compaction)\n\n";
             section += bootContent + "\n";
           } catch {
@@ -12996,10 +14009,10 @@ ${tmtNode.summary}`
 
 // src/orchestration/recall-search-pipeline.ts
 import { createHash as createHash6 } from "crypto";
-import path12 from "path";
+import path13 from "path";
 
 // src/orchestration/recall-search-prefilter.ts
-import path11 from "path";
+import path12 from "path";
 async function fetchActiveArtifactsForNamespace(deps, namespace, prompt, targetCount, options = {}) {
   const storage = await deps.storageRouter.storageFor(namespace);
   let fetchLimit = computeArtifactCandidateFetchLimit(targetCount);
@@ -13128,7 +14141,7 @@ async function searchEmbeddingFallback(deps, query, limit) {
   if (hits.length === 0) return [];
   const results = [];
   for (const hit of hits) {
-    const fullPath = path11.isAbsolute(hit.path) ? hit.path : path11.join(deps.config.memoryDir, hit.path);
+    const fullPath = path12.isAbsolute(hit.path) ? hit.path : path12.join(deps.config.memoryDir, hit.path);
     const memory = await deps.storage.readMemoryByPath(fullPath);
     if (!memory) continue;
     results.push({
@@ -13506,7 +14519,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 = path12.resolve(storageDir);
+          const recallRoot = path13.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -13530,8 +14543,8 @@ var RecallSearchPipelineCoordinator = class {
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path12.isAbsolute(result.path)) {
-          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path12.resolve(result.path)))) {
+        if (path13.isAbsolute(result.path)) {
+          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path13.resolve(result.path)))) {
             scopedResults.push(result);
           }
           continue;
@@ -14649,8 +15662,8 @@ var TurnIngestionCoordinator = class {
 };
 
 // src/orchestration/recall-introspection.ts
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path14 from "path";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import path15 from "path";
 
 // src/taxonomy/default-taxonomy.ts
 var DEFAULT_TAXONOMY = {
@@ -14772,8 +15785,8 @@ function generateResolverDocument(taxonomy) {
 }
 
 // src/taxonomy/taxonomy-loader.ts
-import { readFile as readFile4, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path13 from "path";
+import { readFile as readFile5, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import path14 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -14871,10 +15884,10 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path13.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path14.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
-    raw = await readFile4(taxonomyPath, "utf-8");
+    raw = await readFile5(taxonomyPath, "utf-8");
   } catch (err) {
     if (err instanceof Error && err.code === "ENOENT") {
       return structuredClone(DEFAULT_TAXONOMY);
@@ -14921,16 +15934,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path13.join(memoryDir, TAXONOMY_DIR);
+  const dir = path14.join(memoryDir, TAXONOMY_DIR);
   await mkdir4(dir, { recursive: true });
-  const filePath = path13.join(dir, TAXONOMY_FILE);
+  const filePath = path14.join(dir, TAXONOMY_FILE);
   await writeFile4(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path13.join(memoryDir, TAXONOMY_DIR);
+  return path14.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path13.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path14.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/orchestration/recall-introspection.ts
@@ -14954,13 +15967,13 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path14.join(
+    const snapshotPath = path15.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
     );
     try {
-      const raw = await readFile5(snapshotPath, "utf-8");
+      const raw = await readFile6(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -14993,9 +16006,9 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path14.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path15.join(storage.dir, "state", "last_intent.json");
     try {
-      const raw = await readFile5(snapshotPath, "utf-8");
+      const raw = await readFile6(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       const graphDecision = parsed.graphDecision && typeof parsed.graphDecision === "object" ? parsed.graphDecision : void 0;
@@ -15026,13 +16039,13 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path14.join(
+    const snapshotPath = path15.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
     );
     try {
-      const raw = await readFile5(snapshotPath, "utf-8");
+      const raw = await readFile6(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -15318,12 +16331,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path14.join(
+      const snapshotPath = path15.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir5(path14.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path15.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -15335,12 +16348,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path14.join(
+      const snapshotPath = path15.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir5(path14.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path15.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -15355,8 +16368,8 @@ var RecallIntrospectionCoordinator = class {
       const stateDir = await this.deps.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path14.join(stateDir, "last_intent.json");
-      await mkdir5(path14.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path15.join(stateDir, "last_intent.json");
+      await mkdir5(path15.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -15370,7 +16383,7 @@ var RecallIntrospectionCoordinator = class {
 
 // src/orchestration/orchestrator-init.ts
 import { readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 var OrchestratorInitCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -15474,7 +16487,7 @@ var OrchestratorInitCoordinator = class {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path15.join(wsDir, f);
+            const fp = path16.join(wsDir, f);
             const s = await stat2(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink3(fp).catch(() => {
@@ -15669,7 +16682,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (lifecycleCaps.lifecyclePolicy && resolveQmdCapabilities(this.deps.config).qmdTierMigration) {
       try {
-        const { runFirstStartMigration } = await import("./first-start-migration-KHIMCBIC.js");
+        const { runFirstStartMigration } = await import("./first-start-migration-RC345GPL.js");
         const result = await runFirstStartMigration({
           storage: this.deps.storage,
           config: this.deps.config,
@@ -15692,7 +16705,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (!this.deps.wearablesAutoSyncHandle && this.deps.config.wearables.enabled && this.deps.config.wearables.autoSyncEnabled && Object.values(this.deps.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-GRUJFD2F.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-WNGG2GC2.js");
         if (signal.aborted) return;
         this.deps.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -15826,7 +16839,7 @@ var OrchestratorInitCoordinator = class {
 };
 
 // src/orchestration/persistence-index.ts
-import path16 from "path";
+import path17 from "path";
 var PersistenceIndexCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -15992,7 +17005,13 @@ var PersistenceIndexCoordinator = class {
   async indexPersistedMemory(storage, memoryId) {
     if (!resolveMemoryLifecycleCapabilities(this.deps.config).embeddingFallback) return;
     if (!await this.deps.embeddingFallback.isAvailable()) return;
-    const memory = await storage.getMemoryById(memoryId);
+    let memory = await storage.getMemoryById(memoryId);
+    if (!memory) {
+      const coldAware = await storage.getMemoryByIdIncludingArchived(memoryId).catch(() => null);
+      if (coldAware && isActiveMemoryStatus(coldAware.frontmatter.status)) {
+        memory = coldAware;
+      }
+    }
     if (!memory) return;
     await this.deps.embeddingFallback.indexFile(
       memoryId,
@@ -16012,7 +17031,7 @@ var PersistenceIndexCoordinator = class {
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path16.relative(storage.dir, m.path);
+            const rel = path17.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -16039,7 +17058,7 @@ var PersistenceIndexCoordinator = class {
       recentInThread.push(fallbackCausalPredecessor);
     }
     const causalPredecessor = recentInThread[recentInThread.length - 1] ?? fallbackCausalPredecessor;
-    await this.deps.graphIndexFor(storage).onMemoryWritten({
+    return await this.deps.graphIndexFor(storage).onMemoryWritten({
       memoryPath: memoryRelPath,
       entityRef,
       content: factContent,
@@ -16078,9 +17097,15 @@ var PersistenceIndexCoordinator = class {
           ])
         )
       ) : await storage.readAllMemories();
-      const pool = needsFullRebuild ? allMemories.filter((m) => isActiveMemoryStatus(m.frontmatter.status)) : (() => {
+      const pool = needsFullRebuild ? allMemories.filter((m) => isActiveMemoryStatus(m.frontmatter.status)) : await (async () => {
         const idSet = new Set(persistedIds);
-        return allMemories.filter((m) => idSet.has(m.frontmatter.id));
+        const hot = allMemories.filter((m) => idSet.has(m.frontmatter.id));
+        for (const id of persistedIds) {
+          if (hot.some((m) => m.frontmatter.id === id)) continue;
+          const cold = await storage.getMemoryByIdIncludingArchived(id).catch(() => null);
+          if (cold) hot.push(cold);
+        }
+        return hot;
       })();
       const entries = [];
       for (const mem of pool) {
@@ -16160,8 +17185,8 @@ var PersistenceIndexCoordinator = class {
 };
 
 // src/orchestration/workspace-ops.ts
-import { lstat as lstat2, mkdir as mkdir6, readFile as readFile6, readdir as readdir3, realpath as realpath2, writeFile as writeFile6 } from "fs/promises";
-import path17 from "path";
+import { lstat as lstat2, mkdir as mkdir6, readFile as readFile7, readdir as readdir3, realpath as realpath2, writeFile as writeFile6 } from "fs/promises";
+import path18 from "path";
 
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
@@ -18064,8 +19089,8 @@ var MeetingsService = class {
 // src/orchestration/workspace-ops.ts
 var MEETINGS_BUILD_DEBOUNCE_MS = 5e3;
 function matchesMemoryPath(candidatePath, requestedPath, memoryDir) {
-  const normalizedCandidate = path17.resolve(candidatePath);
-  return normalizedCandidate === path17.resolve(requestedPath) || normalizedCandidate === path17.resolve(memoryDir, requestedPath);
+  const normalizedCandidate = path18.resolve(candidatePath);
+  return normalizedCandidate === path18.resolve(requestedPath) || normalizedCandidate === path18.resolve(memoryDir, requestedPath);
 }
 function accessTrackingPathCandidates(storageDir, memoryPath) {
   const candidates = qmdResultPathCandidates(storageDir, memoryPath);
@@ -18073,12 +19098,12 @@ function accessTrackingPathCandidates(storageDir, memoryPath) {
   if (!parts) return candidates;
   candidates.push(
     ...qmdResultPathCandidates(storageDir, parts.relativePath),
-    ...qmdResultPathCandidates(path17.join(storageDir, "cold"), parts.relativePath)
+    ...qmdResultPathCandidates(path18.join(storageDir, "cold"), parts.relativePath)
   );
   return [...new Set(candidates)];
 }
 function canonicalMemoryPath(memoryPath, memoryDir) {
-  return path17.resolve(path17.isAbsolute(memoryPath) ? memoryPath : path17.resolve(memoryDir, memoryPath));
+  return path18.resolve(path18.isAbsolute(memoryPath) ? memoryPath : path18.resolve(memoryDir, memoryPath));
 }
 var WorkspaceOpsCoordinator = class {
   constructor(deps) {
@@ -18160,15 +19185,15 @@ var WorkspaceOpsCoordinator = class {
     this.deps.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path17.isAbsolute(rel) ? rel : path17.join(this.deps.config.workspaceDir, rel);
+        const abs = path18.isAbsolute(rel) ? rel : path18.join(this.deps.config.workspaceDir, rel);
         try {
-          const raw = await readFile6(abs, "utf-8");
+          const raw = await readFile7(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path17.join(
+            const archiveDir = path18.join(
               this.deps.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path17.basename(abs);
+            const base = path18.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -18193,8 +19218,8 @@ var WorkspaceOpsCoordinator = class {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path17.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path17.dirname(fp), { recursive: true });
+        const fp = path18.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path18.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -18203,7 +19228,7 @@ var WorkspaceOpsCoordinator = class {
 ` + warnings.map((w) => `- ${w.message}`).join("\n") + "\n";
         let existing = "";
         try {
-          existing = await readFile6(fp, "utf-8");
+          existing = await readFile7(fp, "utf-8");
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
@@ -18234,7 +19259,7 @@ var WorkspaceOpsCoordinator = class {
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path17.join(storage.dir, categoryDir, date);
+        const dateDir = path18.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat2(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -18243,7 +19268,7 @@ var WorkspaceOpsCoordinator = class {
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path17.join(dateDir, entry.name);
+            const fullPath = path18.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath2(fullPath), fullPath);
               const memory = await storage.readMemoryByPath(fullPath);
@@ -18265,15 +19290,15 @@ var WorkspaceOpsCoordinator = class {
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path17.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path18.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 = path17.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path18.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
-            const raw = await readFile6(summaryFile, "utf-8");
+            const raw = await readFile7(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
               raw,
               date,
@@ -18735,18 +19760,18 @@ ${reflectionsContent.trim()}
 // src/orchestration/namespace-read-fanout.ts
 import { existsSync, readFileSync } from "fs";
 import { stat as stat3 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 
 // src/orchestration/orchestrator-namespace-scope.ts
-import path18 from "path";
+import path19 from "path";
 function computeSemanticDedupScope(targetStorage, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return {};
-  const memoryDir = path18.resolve(config.memoryDir);
-  const storageDir = path18.resolve(targetStorage.dir);
+  const memoryDir = path19.resolve(config.memoryDir);
+  const storageDir = path19.resolve(targetStorage.dir);
   if (storageDir === memoryDir) {
     return { pathExcludePrefixes: ["namespaces/"] };
   }
-  let rel = path18.relative(memoryDir, storageDir);
+  let rel = path19.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`
@@ -18799,7 +19824,7 @@ var NamespaceReadFanoutCoordinator = class {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.deps.namespaceStorageDirHintsLoaded || !this.deps.namespaceCatalog.enabled) return;
     this.deps.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path19.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path20.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -18836,7 +19861,7 @@ var NamespaceReadFanoutCoordinator = class {
       if (!this.deps.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path19.resolve(record.storageDir);
+      const resolvedStorageDir = path20.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -19021,12 +20046,12 @@ var NamespaceReadFanoutCoordinator = class {
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      return path19.join(this.deps.config.memoryDir, "state");
+      return path20.join(this.deps.config.memoryDir, "state");
     }
     if (namespace !== this.deps.config.defaultNamespace) {
-      return path19.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
+      return path20.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path19.join(
+    const candidate = path20.join(
       this.deps.config.memoryDir,
       "namespaces",
       this.deps.config.defaultNamespace
@@ -19034,11 +20059,11 @@ var NamespaceReadFanoutCoordinator = class {
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path19.join(candidate, "state");
+        return path20.join(candidate, "state");
       }
     } catch {
     }
-    return path19.join(this.deps.config.memoryDir, "state");
+    return path20.join(this.deps.config.memoryDir, "state");
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return this.deps.config.defaultNamespace;
@@ -19486,7 +20511,7 @@ var Orchestrator = class {
     if (this.destroyed) throw new Error("orchestrator has been destroyed");
     if (!this._dependencyPropagationDelivery) {
       this._dependencyPropagationDelivery = new DependencyPropagationDelivery({
-        queueRoot: path20.join(this.config.memoryDir, "state", "dependency-propagation"),
+        queueRoot: path21.join(this.config.memoryDir, "state", "dependency-propagation"),
         config: this.config,
         extraction: this.extraction,
         getStorage: (namespace) => this.getStorage(namespace),
@@ -19835,7 +20860,7 @@ var Orchestrator = class {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path20.resolve(storageDir);
+    const resolvedStorageDir = path21.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -19846,21 +20871,21 @@ var Orchestrator = class {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path20.resolve(storageDir);
-    const resolvedMemoryDir = path20.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path21.resolve(storageDir);
+    const resolvedMemoryDir = path21.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path20.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path21.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path20.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path20.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path21.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path21.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path20.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path21.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path20.basename(resolvedStorageDir);
+    const leaf = path21.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -20001,7 +21026,7 @@ var Orchestrator = class {
     StorageManager.setOkfConformanceDefault(config.memoryDir, config.okf?.conformanceEnabled);
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path20.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path21.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -20088,7 +21113,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 = path20.join(
+    this.conversationIndexDir = path21.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -20238,7 +21263,7 @@ var Orchestrator = class {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path20.join(config.memoryDir, "threads"),
+      path21.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -22342,9 +23367,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path38 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path39 = 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 = path38 !== void 0 && kind !== void 0 ? { symbol, path: path38, kind } : path38 !== void 0 ? { symbol, path: path38 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path39 !== void 0 && kind !== void 0 ? { symbol, path: path39, kind } : path39 !== void 0 ? { symbol, path: path39 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -22418,7 +23443,7 @@ var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
 import fsp from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -22426,19 +23451,19 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = path21.resolve(basePath);
+    this.basePath = path22.resolve(basePath);
   }
   resolveRemotePath(remotePath) {
-    const resolved = path21.isAbsolute(remotePath) ? path21.resolve(remotePath) : path21.resolve(this.basePath, remotePath);
-    const relative = path21.relative(this.basePath, resolved);
-    if (relative === ".." || relative.startsWith(`..${path21.sep}`) || path21.isAbsolute(relative)) {
+    const resolved = path22.isAbsolute(remotePath) ? path22.resolve(remotePath) : path22.resolve(this.basePath, remotePath);
+    const relative = path22.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path22.sep}`) || path22.isAbsolute(relative)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return resolved;
   }
   isInsideBase(candidate, realBase) {
-    const relative = path21.relative(realBase, candidate);
-    return relative === "" || relative !== ".." && !relative.startsWith(`..${path21.sep}`) && !path21.isAbsolute(relative);
+    const relative = path22.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path22.sep}`) && !path22.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
@@ -22467,13 +23492,13 @@ var FilesystemBackend = class {
   }
   async ensureSafeParentDirectory(dest) {
     const realBase = await this.ensureBaseDirectory();
-    const destDir = path21.dirname(dest);
-    const relativeDir = path21.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path21.sep);
+    const destDir = path22.dirname(dest);
+    const relativeDir = path22.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path22.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path21.join(current, segment);
+      current = path22.join(current, segment);
       try {
         const stat5 = await fsp.lstat(current);
         if (stat5.isSymbolicLink()) {
@@ -22501,13 +23526,13 @@ var FilesystemBackend = class {
     if (realBase === null) {
       return null;
     }
-    const destDir = path21.dirname(dest);
-    const relativeDir = path21.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path21.sep);
+    const destDir = path22.dirname(dest);
+    const relativeDir = path22.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path22.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path21.join(current, segment);
+      current = path22.join(current, segment);
       let stat5;
       try {
         stat5 = await fsp.lstat(current);
@@ -22525,7 +23550,7 @@ var FilesystemBackend = class {
       }
     }
     const realParent = await fsp.realpath(destDir).catch((err) => {
-      if (err.code === "ENOENT") return null;
+      if (isErrnoCode(err, "ENOENT")) return null;
       throw err;
     });
     if (realParent === null) {
@@ -22555,7 +23580,7 @@ var FilesystemBackend = class {
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path21.isAbsolute(remotePath)) {
+    if (path22.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
@@ -22628,7 +23653,7 @@ function createBackend(cfg) {
 
 // src/binary-lifecycle/scanner.ts
 import fsp2 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -22653,8 +23678,8 @@ async function scanForBinaries(memoryDir, config, manifest) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path22.join(dir, entry.name);
-      const relativePath = path22.relative(memoryDir, fullPath).split(path22.sep).join("/");
+      const fullPath = path23.join(dir, entry.name);
+      const relativePath = path23.relative(memoryDir, fullPath).split(path23.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -22694,15 +23719,15 @@ async function hashFile(filePath) {
 
 // src/binary-lifecycle/manifest.ts
 import fsp3 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
-  return path23.join(memoryDir, MANIFEST_DIR);
+  return path24.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path23.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path24.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
@@ -22754,13 +23779,13 @@ function emptyManifest() {
 
 // src/binary-lifecycle/pipeline.ts
 import fsp4 from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import crypto3 from "crypto";
 var historicalIdCache = new HistoricalEntityCanonicalIdCache();
 function isRecallCorpusMarkdown(mdPath, memoryDir) {
-  const rel = path24.relative(memoryDir, mdPath);
-  if (rel.startsWith("..") || path24.isAbsolute(rel)) return false;
-  const top = rel.split(path24.sep)[0];
+  const rel = path25.relative(memoryDir, mdPath);
+  if (rel.startsWith("..") || path25.isAbsolute(rel)) return false;
+  const top = rel.split(path25.sep)[0];
   return RECALL_FALLBACK_DIRS.includes(top);
 }
 async function hashFile2(filePath) {
@@ -22784,13 +23809,13 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function resolveManifestAssetPath(memoryDir, originalPath) {
-  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path24.isAbsolute(originalPath) || path24.win32.isAbsolute(originalPath)) {
+  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path25.isAbsolute(originalPath) || path25.win32.isAbsolute(originalPath)) {
     return null;
   }
-  const memoryRoot = path24.resolve(memoryDir);
-  const fullPath = path24.resolve(memoryRoot, originalPath);
-  const relative = path24.relative(memoryRoot, fullPath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path24.sep}`) || path24.isAbsolute(relative)) {
+  const memoryRoot = path25.resolve(memoryDir);
+  const fullPath = path25.resolve(memoryRoot, originalPath);
+  const relative = path25.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path25.sep}`) || path25.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -22801,7 +23826,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path24.sep).join("/");
+  const normalized = relPath.split(path25.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -22814,11 +23839,11 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
   for (const relPath of newPaths) {
-    const fullPath = path24.join(memoryDir, relPath);
+    const fullPath = path25.join(memoryDir, relPath);
     try {
       const stat5 = await fsp4.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path24.extname(relPath);
+      const ext = path25.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -22969,7 +23994,7 @@ async function stageRedirect(memoryDir, assets, log2, dryRun, readMarkdownFile,
     for (const update of updates) {
       try {
         await withRawEntityPageMutation(memoryDir, update.mdPath, async () => {
-          const stateDir = path24.join(memoryDir, "state");
+          const stateDir = path25.join(memoryDir, "state");
           const kind = classifyEntityRefWritePath(memoryDir, update.mdPath);
           if (kind === "memory") {
             const idsAtWrite = historicalIdCache.get(stateDir);
@@ -23062,10 +24087,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path24.dirname(mdPath);
+  const mdDir = path25.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path24.sep).join("/");
+    const normalized = candidate.split(path25.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -23073,10 +24098,10 @@ function markdownReferencePattern(asset, assetAbsolute, mdPath) {
       candidates.add(`./${normalized}`);
     }
   };
-  addCandidate(path24.relative(mdDir, assetAbsolute));
-  const originalPath = asset.originalPath.split(path24.sep).join("/");
-  const originalAsFileRelative = path24.resolve(mdDir, ...originalPath.split("/"));
-  if (path24.resolve(originalAsFileRelative) === path24.resolve(assetAbsolute)) {
+  addCandidate(path25.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path25.sep).join("/");
+  const originalAsFileRelative = path25.resolve(mdDir, ...originalPath.split("/"));
+  if (path25.resolve(originalAsFileRelative) === path25.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -23172,7 +24197,7 @@ async function findMarkdownFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path24.join(current, entry.name);
+      const full = path25.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -23247,7 +24272,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path25 from "path";
+import path26 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -23262,8 +24287,8 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  const resolvedMemoryDir = path25.resolve(memoryDir);
-  const resolvedOutputDir = path25.resolve(outputDir);
+  const resolvedMemoryDir = path26.resolve(memoryDir);
+  const resolvedOutputDir = path26.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -23301,7 +24326,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path25.join(memoryDir, "entities");
+    const entitiesDir = path26.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -23313,7 +24338,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path25.basename(filePath, ".md");
+        const fileName = path26.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -23325,7 +24350,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path25.join(memoryDir, "questions");
+    const questionsDir = path26.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -23366,8 +24391,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path25.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path25.isAbsolute(relative);
+  const relative = path26.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path26.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -23404,12 +24429,12 @@ function assertSafeInputRoot(realMemoryDir, targetPath, label) {
 }
 function assertSafeOutputTarget(realOutputDir, outputPath) {
   let current = realOutputDir;
-  const relative = path25.relative(realOutputDir, outputPath);
-  if (relative.startsWith("..") || path25.isAbsolute(relative)) {
+  const relative = path26.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path26.isAbsolute(relative)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
-  for (const segment of relative.split(path25.sep).filter(Boolean)) {
-    current = path25.join(current, segment);
+  for (const segment of relative.split(path26.sep).filter(Boolean)) {
+    current = path26.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -23439,17 +24464,17 @@ function validateProjectionCategories(categories) {
   return validated;
 }
 function resolveContainedOutputPath(outputRoot, ...segments) {
-  const resolved = path25.resolve(outputRoot, ...segments);
-  const relative = path25.relative(outputRoot, resolved);
-  if (relative === "" || !relative.startsWith("..") && !path25.isAbsolute(relative)) {
+  const resolved = path26.resolve(outputRoot, ...segments);
+  const relative = path26.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path26.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(path25.dirname(outputPath), { recursive: true });
-  const realParent = fs.realpathSync(path25.dirname(outputPath));
+  fs.mkdirSync(path26.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path26.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -23488,7 +24513,7 @@ function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path25.join(directory, entry.name);
+      const fullPath = path26.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -23541,13 +24566,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path25.basename(filePath, ".md");
-  const dateDir = path25.basename(path25.dirname(filePath));
+  const fileName = path26.basename(filePath, ".md");
+  const dateDir = path26.basename(path26.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path25.join(category, dateDir, `${fileName}.md`);
+    relPath = path26.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path25.join(category, `${fileName}.md`);
+    relPath = path26.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -23593,7 +24618,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path25.join("entities", `${fileName}.md`),
+    path: path26.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -23646,7 +24671,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path26 from "path";
+import path27 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -23748,7 +24773,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path26.resolve(options.directory ?? process.cwd());
+  const directory = path27.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -23790,7 +24815,7 @@ function walkDir(root, exclude, maxDepth) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path26.join(dir, entry.name);
+      const fullPath = path27.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -23805,11 +24830,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path26.extname(f).toLowerCase();
+    const ext = path27.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path26.dirname(f) === root).map((f) => path26.basename(f))
+    files.filter((f) => path27.dirname(f) === root).map((f) => path27.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -23853,7 +24878,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path26.dirname(f) === root).map((f) => path26.basename(f))
+    files.filter((f) => path27.dirname(f) === root).map((f) => path27.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -23864,7 +24889,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path26.join(root, "package.json"));
+    const pkg = readJsonSafe(path27.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -23878,13 +24903,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path26.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path27.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path26.join(root, "package.json"));
+    const pkg = readJsonSafe(path27.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -23918,8 +24943,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path26.basename(filePath).toLowerCase();
-    const relPath = path26.relative(root, filePath);
+    const basename = path27.basename(filePath).toLowerCase();
+    const relPath = path27.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -23931,7 +24956,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path26.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path27.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -23952,7 +24977,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path26.sep);
+  const parts = relPath.split(path27.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -23996,7 +25021,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path27 from "path";
+import path28 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -24087,12 +25112,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 = path27.join(dir, entry.name);
+      const fullPath = path28.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path27.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path28.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -24101,12 +25126,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path27.resolve(targetPath);
+  const resolvedTarget = path28.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path27.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path28.dirname(resolvedTarget) : resolvedTarget;
 }
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path27.relative(projectRoot, path27.resolve(filePath)) || path27.basename(filePath);
+  const relativePath = path28.relative(projectRoot, path28.resolve(filePath)) || path28.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);
@@ -24200,7 +25225,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs3.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path27.join(memoryDir, dir);
+    const fullDir = path28.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -24223,11 +25248,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 = path27.join(categoryDir, dateDir);
+  const dir = path28.join(categoryDir, dateDir);
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path27.join(dir, fileName);
-  const historicalIds = historicalIdCache2.get(path27.join(memoryDir, "state"));
+  const filePath = path28.join(dir, fileName);
+  const historicalIds = historicalIdCache2.get(path28.join(memoryDir, "state"));
   const rawBody = `${[
     "---",
     `id: ${stmt.id}`,
@@ -24250,7 +25275,7 @@ ${stmt.content}
   fs3.writeFileSync(filePath, body);
   try {
     repairContentAfterJournalMoveSync({
-      stateDir: path27.join(memoryDir, "state"),
+      stateDir: path28.join(memoryDir, "state"),
       cache: historicalIdCache2,
       idsAtWrite: historicalIds,
       rawContent: rawBody,
@@ -24311,7 +25336,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path27.join(dir, entry.name);
+    const fullPath = path28.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -24323,7 +25348,7 @@ function walkFiles(dir, callback) {
 // src/dedup/index.ts
 import crypto5 from "crypto";
 import fs4 from "fs";
-import path28 from "path";
+import path29 from "path";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_LOAD = 1e4;
 function normalizeThreshold(value, defaultValue) {
@@ -24530,7 +25555,7 @@ function loadMemories(memoryDir, categories, maxLoad = 1e4) {
   const memoryRootReal = fs4.realpathSync(memoryDir);
   for (const category of allCategories) {
     if (result.length >= maxLoad) break;
-    const dir = path28.join(memoryDir, category);
+    const dir = path29.join(memoryDir, category);
     if (!fs4.existsSync(dir)) continue;
     const categoryStat = fs4.lstatSync(dir);
     if (categoryStat.isSymbolicLink()) {
@@ -24591,15 +25616,15 @@ function extractBody3(content) {
   return match ? match[1].trim() : content.trim();
 }
 function assertPathInsideRoot2(rootReal, targetReal, sourcePath) {
-  const rel = path28.relative(rootReal, targetReal);
-  if (rel === "" || !rel.startsWith("..") && !path28.isAbsolute(rel)) {
+  const rel = path29.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path29.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 = path28.join(dir, entry.name);
+    const fullPath = path29.join(dir, entry.name);
     const entryStat = fs4.lstatSync(fullPath);
     if (entryStat.isSymbolicLink()) {
       throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
@@ -24617,7 +25642,7 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
 
 // src/sync/index.ts
 import fs5 from "fs";
-import path29 from "path";
+import path30 from "path";
 import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -24639,7 +25664,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path29.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path30.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -24655,7 +25680,7 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs5.mkdirSync(path29.dirname(stateFilePath), { recursive: true });
+    fs5.mkdirSync(path30.dirname(stateFilePath), { recursive: true });
     fs5.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -24721,13 +25746,13 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path29.join(dir, entry.name);
+      const fullPath = path30.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path29.extname(entry.name).toLowerCase();
+        const ext = path30.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path29.relative(root, fullPath);
+        const relPath = path30.relative(root, fullPath);
         try {
           const content = fs5.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
@@ -24742,7 +25767,7 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path29.join(sourceDir, relPath);
+    const fullPath = path30.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -24775,7 +25800,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path29.join(sourceDir, relPath),
+        filePath: path30.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -24805,21 +25830,21 @@ function hashContent3(content) {
 import { spawnSync } from "child_process";
 import crypto7 from "crypto";
 import fs6 from "fs";
-import path30 from "path";
+import path31 from "path";
 var historicalIdCache3 = 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 path30.resolve(memoryDir);
+  return path31.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path30.join(homeDir, ".config", "engram", "spaces");
+  return path31.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path30.join(getSpacesDir(baseDir), "manifest.json");
+  return path31.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   if (fs6.existsSync(getManifestPath(baseDir))) {
@@ -24866,9 +25891,9 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path30.dirname(manifestPath2);
+  const manifestDir2 = path31.dirname(manifestPath2);
   fs6.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path30.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const tempPath = path31.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
   try {
     fs6.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
@@ -24883,7 +25908,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs6.mkdirSync(path30.dirname(lockDir), { recursive: true });
+  fs6.mkdirSync(path31.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -24909,7 +25934,7 @@ function acquireManifestLock(lockDir) {
     try {
       fs6.mkdirSync(lockDir, { recursive: false });
       try {
-        fs6.writeFileSync(path30.join(lockDir, "owner"), `${owner}
+        fs6.writeFileSync(path31.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
         fs6.rmSync(lockDir, { recursive: true, force: true });
@@ -24939,7 +25964,7 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path30.join(lockDir, "owner");
+    const ownerPath = path31.join(lockDir, "owner");
     if (fs6.readFileSync(ownerPath, "utf8").trim() === owner) {
       fs6.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -24955,7 +25980,7 @@ function removeStaleManifestLock(lockDir) {
   try {
     fs6.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs6.writeFileSync(path30.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs6.writeFileSync(path31.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
       fs6.rmSync(reclaimDir, { recursive: true, force: true });
@@ -25030,7 +26055,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs6.readFileSync(path30.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs6.readFileSync(path31.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -25102,8 +26127,8 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path30.join(homeDir, ".engram", "memory");
-  const openclawPath = path30.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const standalonePath = path31.join(homeDir, ".engram", "memory");
+  const openclawPath = path31.join(homeDir, ".openclaw", "workspace", "memory", "local");
   const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs6.existsSync(standalonePath) ? standalonePath : fs6.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -25132,7 +26157,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 ?? path30.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path31.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -25378,14 +26403,14 @@ async function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path30.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path31.join(getSpacesDir(baseDir), "audit.jsonl");
   if (!fs6.existsSync(auditPath)) return [];
   const lines = fs6.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path30.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs6.mkdirSync(path30.dirname(auditPath), { recursive: true });
+  const auditPath = path31.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs6.mkdirSync(path31.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -25406,11 +26431,11 @@ async function copyMemories(sourceDir, targetDir, options) {
     sourceFiles.filter((p) => {
       const rp = safeRealpath(p);
       if (!rp || !isPathInsideRoot(rp, sourceRoot)) return false;
-      const rel = path30.relative(sourceRoot, rp);
-      const mapped = path30.resolve(targetRoot, rel);
+      const rel = path31.relative(sourceRoot, rp);
+      const mapped = path31.resolve(targetRoot, rel);
       if (!isPathInsideRoot(mapped, targetRoot)) return false;
       return classifyEntityRefWritePath(targetRoot, mapped) === "entity";
-    }).map((p) => path30.basename(p, ".md"))
+    }).map((p) => path31.basename(p, ".md"))
   );
   const firstEntityId = sourceEntityIds.values().next().value;
   if (firstEntityId === void 0) {
@@ -25418,7 +26443,7 @@ async function copyMemories(sourceDir, targetDir, options) {
   }
   return withRawEntityPageMutation(
     targetRoot,
-    path30.join(targetRoot, "entities", `${firstEntityId}.md`),
+    path31.join(targetRoot, "entities", `${firstEntityId}.md`),
     async () => copyPreparedMemories(
       sourceFiles,
       sourceRoot,
@@ -25445,14 +26470,14 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       continue;
     }
     const content = fs6.readFileSync(sourcePath, "utf8");
-    const relativePath = path30.relative(sourceRoot, sourceRealPath);
-    const targetPath = path30.resolve(targetRoot, relativePath);
+    const relativePath = path31.relative(sourceRoot, sourceRealPath);
+    const targetPath = path31.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
     }
     const targetKind = classifyEntityRefWritePath(targetRoot, targetPath);
-    const idsAtCompare = historicalIdCache3.get(path30.join(targetRoot, "state"));
+    const idsAtCompare = historicalIdCache3.get(path31.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;
@@ -25479,7 +26504,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     if (fs6.existsSync(targetPath) && !options?.force) {
       const targetContent = fs6.readFileSync(targetPath, "utf8");
       const targetHash = hashContent4(targetContent);
-      if (hashContent4(canonicalContent) === targetHash && historicalIdCache3.get(path30.join(targetRoot, "state")) === idsAtCompare) {
+      if (hashContent4(canonicalContent) === targetHash && historicalIdCache3.get(path31.join(targetRoot, "state")) === idsAtCompare) {
         skipped++;
         continue;
       }
@@ -25495,13 +26520,13 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    fs6.mkdirSync(path30.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path30.dirname(targetPath));
+    fs6.mkdirSync(path31.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path31.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
     }
-    const stateDir = path30.join(targetRoot, "state");
+    const stateDir = path31.join(targetRoot, "state");
     if (targetKind === "memory" && !refHasSourceClaimant) {
       const idsAtWrite = historicalIdCache3.get(stateDir);
       const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
@@ -25545,7 +26570,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     bumpMemoryCorpusVersionForDir(targetRoot);
   }
   if (reconcileNeeded) {
-    requestEntityCanonicalIdReconcileSync(path30.join(targetRoot, "state"));
+    requestEntityCanonicalIdReconcileSync(path31.join(targetRoot, "state"));
   }
   return { merged, conflicts, skipped };
 }
@@ -25556,7 +26581,7 @@ function walkMd(dir) {
   const results = [];
   function walk(d) {
     for (const entry of fs6.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path30.join(d, entry.name);
+      const fullPath = path31.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -25585,8 +26610,8 @@ function safeRealpath(filePath) {
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path30.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path30.isAbsolute(relative);
+  const relative = path31.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path31.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -25707,7 +26732,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 // src/memory-extension/codex-publisher.ts
 import fs7 from "fs";
 import os from "os";
-import path31 from "path";
+import path32 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -25716,12 +26741,12 @@ function resolveEnvHome(env) {
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path31.join(homeDir, input.slice(2));
+    return path32.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path31.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path32.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -25735,12 +26760,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) : path31.resolve(homeDir, ".codex");
-    return path31.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path32.resolve(homeDir, ".codex");
+    return path32.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path31.join(resolveHomeDir(), ".codex");
+      const home = readEnvVar("CODEX_HOME")?.trim() || path32.join(resolveHomeDir(), ".codex");
       return fs7.existsSync(home);
     } catch {
       return false;
@@ -25791,7 +26816,7 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path31.join(extensionRoot, "instructions.md");
+    const instructionsPath = path32.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -26239,9 +27264,9 @@ function serializeTimelineDay(day) {
 
 // src/activity/timeline/corrections.ts
 import { mkdirSync } from "fs";
-import path32 from "path";
+import path33 from "path";
 function timelineCorrectionDatabasePath(memoryDir) {
-  return path32.join(memoryDir, "state", "activity-timeline.sqlite");
+  return path33.join(memoryDir, "state", "activity-timeline.sqlite");
 }
 function rowToCorrection(row) {
   return {
@@ -26257,7 +27282,7 @@ var TimelineCorrectionStore = class _TimelineCorrectionStore {
     this.db = db;
   }
   static open(memoryDir) {
-    mkdirSync(path32.join(memoryDir, "state"), { recursive: true });
+    mkdirSync(path33.join(memoryDir, "state"), { recursive: true });
     const db = openBetterSqlite3(timelineCorrectionDatabasePath(memoryDir));
     db.pragma("journal_mode = WAL");
     db.pragma("busy_timeout = 5000");
@@ -26830,9 +27855,9 @@ function buildWeeklyActivitySummary(cards, options) {
 // src/activity/timeline/weekly-persist.ts
 import { randomBytes as randomBytes3 } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
-import path33 from "path";
+import path34 from "path";
 var WEEKLY_SNAPSHOT_FORMAT_VERSION = 1;
-var WEEKLY_SNAPSHOT_DIR = path33.join("activity", "weekly");
+var WEEKLY_SNAPSHOT_DIR = path34.join("activity", "weekly");
 function requireToken(value, name) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new TypeError(`${name} must be a non-empty string`);
@@ -26855,8 +27880,8 @@ function weeklySnapshotPath(input) {
   const identity = hashActivityBody(
     `${input.summary.weekStartUtc}\0${input.summary.weekEndUtc}\0${sourceRevision}\0${configHash}`
   );
-  return path33.join(
-    path33.resolve(memoryDir),
+  return path34.join(
+    path34.resolve(memoryDir),
     WEEKLY_SNAPSHOT_DIR,
     namespaceIdentityToken(namespace),
     `${weekDate}--${identity}.json`
@@ -26886,7 +27911,7 @@ function persistWeeklySnapshot(input) {
       throw error;
     }
   }
-  mkdirSync2(path33.dirname(filePath), { recursive: true, mode: 448 });
+  mkdirSync2(path34.dirname(filePath), { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.${process.pid}.${randomBytes3(8).toString("hex")}.tmp`;
   writeFileSync(tmpPath, text, { encoding: "utf8", mode: 384 });
   try {
@@ -28464,7 +29489,7 @@ function applyVaultFrontmatter(existingYaml, updates) {
 }
 
 // src/activity/vault-wikilink.ts
-import path34 from "path";
+import path35 from "path";
 function formatVaultWikilink(notePath) {
   if (typeof notePath !== "string" || notePath.trim().length === 0) {
     throw new RangeError("Vault wikilink path must be a non-empty relative path.");
@@ -28472,7 +29497,7 @@ function formatVaultWikilink(notePath) {
   if (notePath.includes("\n") || notePath.includes("\r")) {
     throw new RangeError("Vault wikilink path must not contain newlines.");
   }
-  if (path34.posix.isAbsolute(notePath) || path34.win32.isAbsolute(notePath)) {
+  if (path35.posix.isAbsolute(notePath) || path35.win32.isAbsolute(notePath)) {
     throw new RangeError("Vault wikilink path must be relative; absolute paths are rejected.");
   }
   if (notePath.split(/[\\/]/).some((segment) => segment === "..")) {
@@ -28494,7 +29519,7 @@ function stripVaultMdSuffix(notePath) {
 }
 
 // src/activity/vault-join.ts
-import path35 from "path";
+import path36 from "path";
 function joinVaultSegments(parts) {
   if (parts.length === 0) {
     throw new RangeError("Vault path parts must be a non-empty list.");
@@ -28509,7 +29534,7 @@ function joinVaultSegments(parts) {
     if (part.includes("\n") || part.includes("\r")) {
       throw new RangeError("Vault path part must not contain a newline.");
     }
-    if (path35.posix.isAbsolute(part) || path35.win32.isAbsolute(part)) {
+    if (path36.posix.isAbsolute(part) || path36.win32.isAbsolute(part)) {
       throw new RangeError("Vault path part must be relative.");
     }
     if (part.split("/").includes("..")) {
@@ -28563,8 +29588,8 @@ function planVaultDryRun(inputs) {
 
 // src/session-summaries/index.ts
 import { createHash as createHash10 } from "crypto";
-import { lstat as lstat3, mkdir as mkdir7, readFile as readFile7, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path36 from "path";
+import { lstat as lstat3, mkdir as mkdir7, readFile as readFile8, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
+import path37 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -29069,7 +30094,7 @@ function shortHash(value, length = 16) {
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path36.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path37.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -29079,13 +30104,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path36.join(dir, entry.name);
+      const fullPath = path37.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path36.extname(entry.name).toLowerCase();
+      const ext = path37.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -29112,7 +30137,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path36.resolve(expandTildePath(inputDir.trim()));
+  return path37.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -29258,7 +30283,7 @@ async function collectLocalSessionSummaries(options) {
     });
   }
   for (const filePath of files) {
-    const content = await readFile7(filePath, "utf-8");
+    const content = await readFile8(filePath, "utf-8");
     const fileHash = shortHash(content, 24);
     if (seenFileHashes.has(fileHash)) {
       warnings.push({
@@ -29269,11 +30294,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path36.extname(filePath).toLowerCase();
+    const fileExtension = path37.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path36.basename(filePath),
+        fileName: path37.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -29329,7 +30354,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile7(path36.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile8(path37.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");
@@ -29342,15 +30367,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path36.join(
-    path36.resolve(expandTildePath(memoryDir)),
+  return path37.join(
+    path37.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path36.dirname(filePath), { recursive: true });
+  await mkdir7(path37.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -29368,7 +30393,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path36.resolve(expandTildePath(options.output));
+    const outputPath = path37.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -29402,20 +30427,20 @@ async function runLocalSessionSummaryCliCommand(options) {
 }
 
 // src/transfer/capsule-fork.ts
-import { lstat as lstat4, mkdir as mkdir8, readFile as readFile8, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
-import path37 from "path";
+import { lstat as lstat4, mkdir as mkdir8, readFile as readFile9, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
+import path38 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path37.resolve(opts.targetRoot);
+  const rootAbs = path38.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path37.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path38.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 = path37.resolve(opts.sourceArchive);
+  const archiveAbs = path38.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -29437,10 +30462,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path37.join(forkDirAbs, "lineage.json");
+  const lineagePath = path38.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path37.dirname(lineagePath), { recursive: true });
+  await mkdir8(path38.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -29454,17 +30479,17 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path37.resolve(targetRoot);
+  const rootAbs = path38.resolve(targetRoot);
   const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
-  const lineagePath = path37.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path37.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path37.isAbsolute(rel)) {
+  const lineagePath = path38.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path38.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path38.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
     return null;
   }
-  const raw = await readFile8(lineagePath, "utf-8").catch(() => null);
+  const raw = await readFile9(lineagePath, "utf-8").catch(() => null);
   if (raw === null) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -29499,19 +30524,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path37.dirname(existing)) {
+  while (existing !== path38.dirname(existing)) {
     const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path37.basename(existing));
-    existing = path37.dirname(existing);
+    suffix.unshift(path38.basename(existing));
+    existing = path38.dirname(existing);
   }
   const existingReal = await realpath3(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path37.join(existingReal, ...suffix) : existingReal;
-  const rel = path37.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path38.join(existingReal, ...suffix) : existingReal;
+  const rel = path38.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path37.sep}`)) return false;
-  if (path37.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path38.sep}`)) return false;
+  if (path38.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -29709,4 +30734,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-VLAQV4HT.js.map
+//# sourceMappingURL=chunk-RJYJ7KR7.js.map