@remnic/core 9.30.0 → 9.31.0

package/dist/{chunk-PUS63Q3G.js → chunk-RUYJ7TWU.js}

@@ -7,22 +7,22 @@ import {
   syncWearableSource,
   wearableSourceLabel
 } from "./chunk-UV72DEZD.js";
-import {
-  runPeerProfileReasoner
-} from "./chunk-I74SUMNI.js";
 import {
   CompressionGuidelineCoordinator
 } from "./chunk-6LKEUCEM.js";
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-LBOD4U5B.js";
+} from "./chunk-YFOMN2II.js";
+import {
+  runPeerProfileReasoner
+} from "./chunk-I74SUMNI.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
 import {
   LcmEngine
-} from "./chunk-Z54EM5YZ.js";
+} from "./chunk-MAXVH44E.js";
 import {
   chunkTranscriptEntries
 } from "./chunk-TECVW3JP.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-VI2JQPNQ.js";
+} from "./chunk-E4PWACUN.js";
 import {
   SharedContextManager
 } from "./chunk-AS7YMSL6.js";
@@ -41,9 +41,6 @@ import {
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
 } from "./chunk-LXOM6IQU.js";
-import {
-  CODEX_THREAD_KEY_PREFIX
-} from "./chunk-4EX5WZ4M.js";
 import {
   TierMigrationExecutor
 } from "./chunk-VOUOLGIP.js";
@@ -56,16 +53,19 @@ import {
 import {
   extractTopics
 } from "./chunk-UHGBNIOS.js";
-import {
-  buildTargetedFactRecallSection,
-  shouldRecallTargetedFactEvidence
-} from "./chunk-T67LUYCR.js";
 import {
   buildTemporalTimelineRecallSection
 } from "./chunk-I6WYQSX4.js";
+import {
+  CODEX_THREAD_KEY_PREFIX
+} from "./chunk-4EX5WZ4M.js";
 import {
   HourlySummarizer
-} from "./chunk-AZ5BTEKX.js";
+} from "./chunk-NQUF7XKR.js";
+import {
+  buildTargetedFactRecallSection,
+  shouldRecallTargetedFactEvidence
+} from "./chunk-T67LUYCR.js";
 import {
   SessionObserverState
 } from "./chunk-QFN4U7AG.js";
@@ -108,9 +108,6 @@ import {
   reorderByRankedKeys,
   rerankLocalOrNoop
 } from "./chunk-LUDXM7MD.js";
-import {
-  createRecallSectionMetricRecorder
-} from "./chunk-C3AKM55W.js";
 import {
   LastRecallStore,
   RecallHandleHistoryStore,
@@ -128,6 +125,9 @@ import {
 import {
   reorderRecallResultsWithMmr
 } from "./chunk-YDBIWGNI.js";
+import {
+  createRecallSectionMetricRecorder
+} from "./chunk-C3AKM55W.js";
 import {
   applyReasoningTraceBoost
 } from "./chunk-ZZTOURJI.js";
@@ -147,35 +147,13 @@ import {
 import {
   runLiveConnectorsOnce
 } from "./chunk-HTIIXNJQ.js";
-import {
-  hasBroadGraphIntent,
-  inferIntentFromText,
-  intentCompatibilityScore,
-  isTaskInitiationIntent,
-  planRecallMode
-} from "./chunk-PD6O7AXF.js";
 import {
   classifyMemoryKind
 } from "./chunk-YAZNBMNF.js";
-import {
-  ExtractionEngine
-} from "./chunk-GBJ4RDFR.js";
-import {
-  parseMemoryActionEligibilityContext
-} from "./chunk-TGTTESJS.js";
-import {
-  ModelRegistry
-} from "./chunk-WLZYGLJ4.js";
-import {
-  LocalLlmClient
-} from "./chunk-PHWUFPCO.js";
 import {
   buildFocusedListRecallSection,
   shouldRecallFocusedListEvidence
 } from "./chunk-OH7QLI6W.js";
-import {
-  recordJudgeTrainingPair
-} from "./chunk-PWFCHOB3.js";
 import {
   createDeferCountMap,
   createVerdictCache,
@@ -188,9 +166,17 @@ import {
   loadRedactionRules
 } from "./chunk-LTHVM4XN.js";
 import {
-  buildEventOrderRecallSection,
-  shouldRecallEventOrderEvidence
-} from "./chunk-DEOYTFA6.js";
+  ExtractionEngine
+} from "./chunk-QIHIHZYC.js";
+import {
+  parseMemoryActionEligibilityContext
+} from "./chunk-TGTTESJS.js";
+import {
+  ModelRegistry
+} from "./chunk-WLZYGLJ4.js";
+import {
+  LocalLlmClient
+} from "./chunk-ZCPP5OW6.js";
 import {
   pickFactEventTimeAnchor,
   resolveFactEventTime
@@ -199,8 +185,8 @@ import {
   buildExplicitCueRecallSection
 } from "./chunk-TVIVY7KU.js";
 import {
-  tryDirectAnswer
-} from "./chunk-Q6IP2ARR.js";
+  recordJudgeTrainingPair
+} from "./chunk-PWFCHOB3.js";
 import {
   EmbeddingFallback
 } from "./chunk-E6EE5B67.js";
@@ -208,33 +194,40 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-66772WBP.js";
+} from "./chunk-NFXQJHJD.js";
+import {
+  buildEventOrderRecallSection,
+  shouldRecallEventOrderEvidence
+} from "./chunk-DEOYTFA6.js";
 import {
   formatDaySummaryMemories
 } from "./chunk-RPSYDM6C.js";
+import {
+  tryDirectAnswer
+} from "./chunk-Q6IP2ARR.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors
-} from "./chunk-6U7F52DE.js";
-import {
-  normalizeReplaySessionKey
-} from "./chunk-AJVLDJU6.js";
+} from "./chunk-4XHR3I67.js";
 import {
   RoutingRulesStore
 } from "./chunk-XL24QQ63.js";
+import {
+  normalizeReplaySessionKey
+} from "./chunk-AJVLDJU6.js";
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-2EUVEDF5.js";
+} from "./chunk-5XA7PQ5I.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-TH2LSRMG.js";
+} from "./chunk-XHDIB4T4.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -247,11 +240,11 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-M3C2V3PV.js";
+} from "./chunk-AJEMDQNA.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-H5CPS5JP.js";
+} from "./chunk-H36LJIPD.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -263,20 +256,20 @@ import {
   EXTRACTION_JUDGE_VERDICT_CATEGORY,
   recordJudgeVerdict
 } from "./chunk-OZKOPQCM.js";
-import {
-  recordEvalShadowRecall
-} from "./chunk-3PY7VHV7.js";
 import {
   collectNativeKnowledgeChunks,
   formatNativeKnowledgeSection,
   searchNativeKnowledge
 } from "./chunk-2DQ2XREU.js";
+import {
+  recordEvalShadowRecall
+} from "./chunk-3PY7VHV7.js";
 import {
   applyCommitmentLedgerLifecycle
 } from "./chunk-LMDRGRJ2.js";
 import {
-  buildCompressionGuidelinesMarkdown
-} from "./chunk-OD4FM2U7.js";
+  SmartBuffer
+} from "./chunk-TL4TO3EA.js";
 import {
   buildConsolidationPrompt,
   buildExtensionsBlockForConsolidation,
@@ -286,16 +279,26 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-FDAMS4PK.js";
+} from "./chunk-PNPOWBGC.js";
+import {
+  buildBehaviorSignalsForMemory,
+  dedupeBehaviorSignalsByMemoryAndHash
+} from "./chunk-KD3QD3A5.js";
+import {
+  BootstrapEngine
+} from "./chunk-MYVPLJOO.js";
+import {
+  isDisagreementPrompt
+} from "./chunk-H3FZVNRN.js";
+import {
+  BoxBuilder
+} from "./chunk-B7RWBZXW.js";
 import {
   semanticChunkContent
 } from "./chunk-P4BC54KI.js";
 import {
   chunkContent
 } from "./chunk-UQ7RN5HK.js";
-import {
-  SmartBuffer
-} from "./chunk-4A6YGWQN.js";
 import {
   detectMeetings
 } from "./chunk-IB26HVAJ.js";
@@ -313,22 +316,9 @@ import {
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
-import {
-  buildBehaviorSignalsForMemory,
-  dedupeBehaviorSignalsByMemoryAndHash
-} from "./chunk-KD3QD3A5.js";
-import {
-  BootstrapEngine
-} from "./chunk-MYVPLJOO.js";
-import {
-  isDisagreementPrompt
-} from "./chunk-H3FZVNRN.js";
-import {
-  BoxBuilder
-} from "./chunk-B7RWBZXW.js";
 import {
   MeetingsInputError
-} from "./chunk-6FUPCJUL.js";
+} from "./chunk-FI4F5X2V.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -342,17 +332,21 @@ import {
 } from "./chunk-CEN6DW6X.js";
 import {
   RecallResultFormatter,
+  SessionContextCoordinator,
   capturePassiveCorrections,
   clusterByKey,
-  createCorrectionService,
   detectPassiveCorrections
-} from "./chunk-4WKA6I65.js";
+} from "./chunk-OGCNZPKX.js";
 import {
   importCapsule
-} from "./chunk-ALSGMEJR.js";
+} from "./chunk-65ZPVYTA.js";
 import {
   isCodingGraphInstalled
 } from "./chunk-VQ7B2Q6M.js";
+import {
+  listTrustZoneRecords,
+  searchTrustZoneRecords
+} from "./chunk-JGSKJHF7.js";
 import {
   applyTrustScoreStage,
   buildTrustSignalsForRerank,
@@ -361,9 +355,8 @@ import {
   trustResultKey
 } from "./chunk-GNVZQ5JN.js";
 import {
-  listTrustZoneRecords,
-  searchTrustZoneRecords
-} from "./chunk-JGSKJHF7.js";
+  buildXraySnapshot
+} from "./chunk-BR2K43MK.js";
 import {
   boundRecallContextComposition,
   composeRecallContext,
@@ -371,21 +364,15 @@ import {
   formatCuriosityFooter,
   selectCuriosityQuestion
 } from "./chunk-AHVEHR6K.js";
-import {
-  buildXraySnapshot
-} from "./chunk-ACXPX4AG.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
 } from "./chunk-6HMYUWXR.js";
 import {
-  combineNamespaces,
   getConfiguredNamespaces,
-  resolveCodingNamespaceOverlay,
   resolveNamespaceFromStorageDir,
-  resolveScopePlan,
-  resolveScopeProfilePlan
-} from "./chunk-IYZ5K7MU.js";
+  resolveScopePlan
+} from "./chunk-ULARSG5Z.js";
 import {
   ProfilingCollector
 } from "./chunk-NLE6TSLG.js";
@@ -398,29 +385,80 @@ import {
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
-} from "./chunk-D2ANTDGO.js";
+} from "./chunk-E6BMSH7U.js";
 import {
   createConversationIndexRuntime,
   createSearchBackend
-} from "./chunk-D3LMYTBV.js";
+} from "./chunk-J7WZUL2K.js";
 import {
   NoopSearchBackend
 } from "./chunk-CYEPCZN5.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-IC6CBHCA.js";
+} from "./chunk-QGENAYVS.js";
 import {
   writeConversationChunks
 } from "./chunk-72A4L5JJ.js";
-import {
-  parseQmdExplain
-} from "./chunk-QJAQNXWI.js";
 import {
   GraphIndex
 } from "./chunk-L2DPF4DF.js";
+import {
+  BulkImportBatchPartialFailureError,
+  COMPACTION_SIGNAL_MAX_AGE_MS,
+  ExtractionDeadlineError,
+  ExtractionRunCoordinator,
+  abortRecallError,
+  appendMemoryToGraphContext,
+  applyQueryAwareCandidateFilter,
+  buildMemoryPathById,
+  buildQmdIntentHint,
+  computeArtifactCandidateFetchLimit,
+  computeArtifactRecallLimit,
+  computeQmdHybridFetchLimit,
+  defaultWorkspaceDir,
+  filterHourlySummaryMarkdownForLocalDay,
+  formatDateInTimeZone,
+  isActivityDigestPath,
+  isArtifactMemoryPath,
+  isMeetingRecordPath,
+  lifecycleRecallScoreAdjustment,
+  mapRecallSourceToXrayServedBy,
+  mergeArtifactRecallCandidates,
+  normalizeIanaTimeZone,
+  parseFiniteDate,
+  parseGraphRecallRankedResults,
+  parseMemoryIntentSnapshot,
+  parseQmdRecallResults,
+  qmdStartupCollectionCheckWithTimeout,
+  raceRecallAbort,
+  resolvePersistedMemoryRelativePath,
+  resolveRecallModeDecision,
+  resolveRecallModeDecisionAsync,
+  resolveRecentThreadMemoryPaths,
+  sanitizeSessionKeyForFilename,
+  shouldFilterLifecycleRecallCandidate,
+  splitTurnsBySourceValidAt,
+  summarizeGraphShadowComparison,
+  targetSourceValidAtSortMs,
+  throwIfRecallAborted,
+  tokenizeRecallQuery,
+  utcDateKeysForLocalDay
+} from "./chunk-YPC7W6GA.js";
+import {
+  resolveCodingNamespaceOverlay
+} from "./chunk-BUE5E2HL.js";
+import {
+  inferIntentFromText,
+  intentCompatibilityScore,
+  isTaskInitiationIntent,
+  planRecallMode
+} from "./chunk-PD6O7AXF.js";
+import {
+  searchCausalTrajectories
+} from "./chunk-NRV4Y3PM.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-CZRYLSSW.js";
+} from "./chunk-BUGVGH4N.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -439,7 +477,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-RGIWINDN.js";
+} from "./chunk-7G5MH4NT.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -470,28 +508,23 @@ import {
 } from "./chunk-J6A3CX5N.js";
 import {
   confidenceTier
-} from "./chunk-HUHX2OCX.js";
+} from "./chunk-7DRETLP5.js";
 import {
   namespaceIdentityFromToken,
   namespaceIdentityToken,
   normalizeNamespaceIdentity
 } from "./chunk-EGGE52UU.js";
-import {
-  assertPathInsideRoot
-} from "./chunk-GCASGYIO.js";
 import {
   inferMemoryStatus,
   isActiveMemoryStatus
 } from "./chunk-ILGC6JH6.js";
+import {
+  assertPathInsideRoot
+} from "./chunk-GCASGYIO.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
 } from "./chunk-DM2T26WE.js";
-import {
-  applyFaithfulnessVerdict,
-  createFaithfulnessCounters,
-  runFaithfulnessGateBatch
-} from "./chunk-JYIJNNN3.js";
 import {
   ContentHashIndex
 } from "./chunk-FBUE6PD3.js";
@@ -507,9 +540,14 @@ import {
 import {
   normalizeTags
 } from "./chunk-BT7NVCML.js";
+import {
+  applyFaithfulnessVerdict,
+  createFaithfulnessCounters,
+  runFaithfulnessGateBatch
+} from "./chunk-JYIJNNN3.js";
 import {
   bumpMemoryCorpusVersionForDir
-} from "./chunk-AITCS2RC.js";
+} from "./chunk-IJ7HK452.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -520,9 +558,6 @@ import {
   fallbackLlmRuntimeContextFromConfig,
   gatewayTaskChainOptions
 } from "./chunk-C23BYTJV.js";
-import {
-  searchCausalTrajectories
-} from "./chunk-W4FBGYGK.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -557,14 +592,9 @@ import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot
 } from "./chunk-GCGJW34D.js";
-import {
-  parseFlexibleIsoTimestamp
-} from "./chunk-P7FMDTKL.js";
 import {
   canReadNamespace,
-  canWriteNamespace,
   defaultNamespaceForPrincipal,
-  recallNamespacesForPrincipal,
   resolvePrincipal
 } from "./chunk-3GD2HFR6.js";
 import {
@@ -608,7 +638,6 @@ import {
   ALL_CATEGORY_DIRS,
   ALL_CATEGORY_KEYS,
   RECALL_FALLBACK_DIRS,
-  categoryDirName,
   getCategoryDir
 } from "./chunk-VS2IYZRU.js";
 import {
@@ -616,8 +645,8 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/orchestrator.ts
-import path17 from "path";
-import { createHash as createHash8 } from "crypto";
+import path16 from "path";
+import { createHash as createHash6 } from "crypto";
 
 // src/orchestration/tier-migration-coordinator.ts
 import path from "path";
@@ -2108,7 +2137,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path32, preferredNamespace) => {
+        readMemoryFrontmatter: async (path31, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2120,7 +2149,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path32,
+            path31,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -2719,1315 +2748,62 @@ var ContradictionLinkingCoordinator = class {
           contradiction.supersededCreated,
           contradiction.supersededTags
         );
-      }
-    } catch (err) {
-      log.warn(
-        `contradiction auto-resolve supersede failed for ${contradiction.supersededId}: ${err}`
-      );
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Memory Linking (Phase 3A)
-  // ---------------------------------------------------------------------------
-  /**
-   * Suggest links for a new memory based on similar existing memories.
-   */
-  async suggestLinksForMemory(content, category, namespaceScope) {
-    if (!this.isSearchAvailable()) return [];
-    const results = await this.searchAcrossNamespaces({
-      query: content,
-      namespaces: [namespaceScope],
-      maxResults: 5,
-      mode: "search"
-    });
-    if (results.length === 0) return [];
-    const candidates = [];
-    for (const result of results) {
-      const memoryId = this.extractMemoryIdsFromResults([result])[0];
-      if (!memoryId) continue;
-      const resultNamespace = this.namespaceFromPath(result.path);
-      if (resultNamespace !== namespaceScope) continue;
-      const resultStorage = await this.storageForNamespace(resultNamespace);
-      const memory = await resultStorage.getMemoryById(memoryId);
-      if (memory && memory.frontmatter.status !== "superseded" && memory.frontmatter.status !== "forgotten") {
-        candidates.push({
-          id: memory.frontmatter.id,
-          content: memory.content,
-          category: memory.frontmatter.category
-        });
-      }
-    }
-    if (candidates.length === 0) return [];
-    const extraction = this.getExtraction();
-    const suggestions = await extraction.suggestLinks(
-      { content, category },
-      candidates
-    );
-    if (!suggestions || suggestions.links.length === 0) return [];
-    return suggestions.links.map((link) => ({
-      targetId: link.targetId,
-      linkType: link.linkType,
-      strength: link.strength,
-      reason: link.reason || void 0
-    }));
-  }
-};
-
-// src/orchestration/extraction-run.ts
-import { createHash as createHash3 } from "crypto";
-
-// src/orchestration/orchestrator-helpers.ts
-import { createHash as createHash2 } from "crypto";
-import os from "os";
-import path4 from "path";
-var BulkImportBatchPartialFailureError = class extends Error {
-  partialResult;
-  originalError;
-  constructor(message, partialResult, originalError) {
-    super(message);
-    this.name = "BulkImportBatchPartialFailureError";
-    this.partialResult = partialResult;
-    this.originalError = originalError;
-  }
-};
-function mapRecallSourceToXrayServedBy(source) {
-  switch (source) {
-    case "recent_scan":
-      return "recent-scan";
-    case "hot_qmd":
-    case "hot_embedding":
-    case "cold_fallback":
-    case "none":
-      return "hybrid";
-  }
-  const _exhaustive = source;
-  void _exhaustive;
-  return "hybrid";
-}
-var abortRecallError = abortError;
-function throwIfRecallAborted(signal, message = "recall aborted") {
-  throwIfAborted(signal, message);
-}
-async function raceRecallAbort(promise, signal, message = "recall aborted") {
-  throwIfRecallAborted(signal, message);
-  if (!signal) return promise;
-  let onAbort = null;
-  const abortPromise = new Promise((_resolve, reject) => {
-    onAbort = () => reject(abortRecallError(message));
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-  try {
-    return await Promise.race([promise, abortPromise]);
-  } finally {
-    if (onAbort) {
-      signal.removeEventListener("abort", onAbort);
-    }
-  }
-}
-var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
-var DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = 1e4;
-function normalizeIanaTimeZone(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  if (!trimmed) return void 0;
-  try {
-    Intl.DateTimeFormat(void 0, { timeZone: trimmed });
-    return trimmed;
-  } catch {
-    return void 0;
-  }
-}
-function formatDateInTimeZone(date, timeZone) {
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  }).formatToParts(date);
-  const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
-  return `${get("year")}-${get("month")}-${get("day")}`;
-}
-function utcDateKey(date) {
-  return date.toISOString().slice(0, 10);
-}
-function utcDateKeysAround(date) {
-  const dayMs = 864e5;
-  const keys = [
-    utcDateKey(new Date(date.getTime() - dayMs)),
-    utcDateKey(date),
-    utcDateKey(new Date(date.getTime() + dayMs))
-  ];
-  return keys.filter((value, index, array) => array.indexOf(value) === index);
-}
-function utcDateKeysForLocalDay(date, timeZone) {
-  const targetLocalDate = formatDateInTimeZone(date, timeZone);
-  const keys = /* @__PURE__ */ new Set();
-  const hourMs = 36e5;
-  const scanStart = date.getTime() - 48 * hourMs;
-  const scanEnd = date.getTime() + 48 * hourMs;
-  for (let ms = scanStart; ms <= scanEnd; ms += hourMs) {
-    const candidate = new Date(ms);
-    if (formatDateInTimeZone(candidate, timeZone) === targetLocalDate) {
-      keys.add(utcDateKey(candidate));
-    }
-  }
-  return keys.size > 0 ? [...keys].sort() : utcDateKeysAround(date);
-}
-function parseFiniteDate(value) {
-  if (typeof value !== "string" || value.trim().length === 0) return null;
-  const parsed = new Date(value);
-  return Number.isFinite(parsed.getTime()) ? parsed : null;
-}
-function filterHourlySummaryMarkdownForLocalDay(raw, utcDate, timeZone, targetLocalDate) {
-  const hourHeaderPattern = /^## ([01]\d|2[0-3]):00[ \t]*$/gm;
-  const matches = Array.from(raw.matchAll(hourHeaderPattern));
-  if (matches.length === 0) return null;
-  const firstSectionStart = matches[0]?.index ?? 0;
-  const preamble = raw.slice(0, firstSectionStart).trim();
-  const sections = [];
-  for (let index = 0; index < matches.length; index += 1) {
-    const match = matches[index];
-    const hour = match[1];
-    if (!hour) continue;
-    const sectionTimestamp = parseFiniteDate(`${utcDate}T${hour}:00:00.000Z`);
-    if (!sectionTimestamp || formatDateInTimeZone(sectionTimestamp, timeZone) !== targetLocalDate) {
-      continue;
-    }
-    const sectionStart = match.index ?? 0;
-    const sectionEnd = matches[index + 1]?.index ?? raw.length;
-    const section = raw.slice(sectionStart, sectionEnd).trim();
-    if (section.length > 0) sections.push(section);
-  }
-  if (sections.length === 0) return null;
-  return [preamble, ...sections].filter((section) => section.length > 0).join("\n\n");
-}
-function qmdStartupCollectionCheckTimeoutMs() {
-  const raw = process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS ?? process.env.ENGRAM_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
-  if (raw === void 0) return DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
-  const parsed = Number(raw);
-  return Number.isFinite(parsed) && parsed >= 1e3 ? Math.floor(parsed) : DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
-}
-async function qmdStartupCollectionCheckWithTimeout(promise, controller, label) {
-  const timeoutMs = qmdStartupCollectionCheckTimeoutMs();
-  let timer;
-  let settled = false;
-  const timeoutPromise = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      if (settled) return;
-      controller.abort();
-      log.warn(
-        `QMD startup collection check for ${label} timed out after ${timeoutMs}ms; keeping search enabled fail-open`
-      );
-      resolve("unknown");
-    }, timeoutMs);
-    timer.unref?.();
-  });
-  const checkedPromise = promise.catch((err) => {
-    log.warn(
-      `QMD startup collection check for ${label} failed; keeping search enabled fail-open: ${err}`
-    );
-    return "unknown";
-  }).finally(() => {
-    settled = true;
-    if (timer) clearTimeout(timer);
-  });
-  return await Promise.race([checkedPromise, timeoutPromise]);
-}
-function defaultWorkspaceDir() {
-  return path4.join(os.homedir(), ".openclaw", "workspace");
-}
-function sanitizeSessionKeyForFilename(sessionKey) {
-  const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const hash = createHash2("sha256").update(sessionKey).digest("hex").slice(0, 12);
-  return `${readable}-${hash}`;
-}
-function sourceValidAtMs(turn) {
-  if (typeof turn.sourceValidAt !== "string") return null;
-  return parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
-}
-var SOURCE_VALID_AT_CONTEXT_TURNS = 2;
-function sourceValidAtSliceKey(turn, index) {
-  const validAtMs = sourceValidAtMs(turn);
-  return validAtMs === null ? `unknown:${index}` : String(validAtMs);
-}
-function asExtractionContextTurn(turn) {
-  return { ...turn, extractionContextOnly: true };
-}
-function asExtractionTargetTurn(turn) {
-  const { extractionContextOnly: _contextOnly, ...targetTurn } = turn;
-  return targetTurn;
-}
-function sourceValidAtContextTurns(turns, targetStart, targetEnd, targetValidAtMs) {
-  if (targetValidAtMs === null) return [];
-  return turns.flatMap((turn, index) => {
-    if (index >= targetStart && index < targetEnd) return [];
-    const contextValidAtMs = sourceValidAtMs(turn);
-    if (contextValidAtMs === null || contextValidAtMs > targetValidAtMs) {
-      return [];
-    }
-    return [{ turn, index, validAtMs: contextValidAtMs }];
-  }).sort((a, b) => {
-    if (a.validAtMs < b.validAtMs) return -1;
-    if (a.validAtMs > b.validAtMs) return 1;
-    if (a.index === b.index) return 0;
-    return a.index < b.index ? -1 : 1;
-  }).slice(-SOURCE_VALID_AT_CONTEXT_TURNS).map(({ turn }) => asExtractionContextTurn(turn));
-}
-function targetSourceValidAtSortMs(turns) {
-  let latestMs = null;
-  for (const turn of turns) {
-    if (turn.extractionContextOnly === true) continue;
-    const validAtMs = sourceValidAtMs(turn);
-    if (validAtMs === null) continue;
-    if (latestMs === null || validAtMs > latestMs) {
-      latestMs = validAtMs;
-    }
-  }
-  return latestMs ?? Number.POSITIVE_INFINITY;
-}
-function sortSourceValidAtSlicesChronologically(slices) {
-  return slices.map((turns, order) => ({
-    turns,
-    order,
-    targetValidAtMs: targetSourceValidAtSortMs(turns)
-  })).sort((a, b) => {
-    if (a.targetValidAtMs < b.targetValidAtMs) return -1;
-    if (a.targetValidAtMs > b.targetValidAtMs) return 1;
-    if (a.order === b.order) return 0;
-    return a.order < b.order ? -1 : 1;
-  }).map((slice) => slice.turns);
-}
-function splitTurnsBySourceValidAt(turns, options = {}) {
-  if (turns.length === 0) return [];
-  if (!turns.some((turn) => sourceValidAtMs(turn) !== null)) {
-    return [[...turns]];
-  }
-  const slices = [];
-  let start = 0;
-  while (start < turns.length) {
-    const targetValidAtMs = sourceValidAtMs(turns[start]);
-    const activeKey = sourceValidAtSliceKey(turns[start], start);
-    let end = start + 1;
-    while (end < turns.length && sourceValidAtSliceKey(turns[end], end) === activeKey) {
-      end += 1;
-    }
-    const contextTurns = options.includeContext === false ? [] : sourceValidAtContextTurns(turns, start, end, targetValidAtMs);
-    slices.push([
-      ...contextTurns,
-      ...turns.slice(start, end).map(asExtractionTargetTurn)
-    ]);
-    start = end;
-  }
-  return sortSourceValidAtSlicesChronologically(slices);
-}
-function isArtifactMemoryPath(filePath) {
-  return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(filePath);
-}
-function isMeetingRecordPath(filePath) {
-  return /(?:^|[\\/])meetings[\\/]\d{4}-\d{2}-\d{2}[\\/]mtg-\d{4}-\d{2}-\d{2}-[0-9a-f]{8}\.md$/i.test(filePath);
-}
-var ACTIVITY_DIGEST_TOPLEVEL = /^activity[\\/]\d{4}-\d{2}-\d{2}\.md$/i;
-var ACTIVITY_DIGEST_ANYWHERE = /(?:^|[\\/])activity[\\/]\d{4}-\d{2}-\d{2}\.md$/i;
-function isActivityDigestPath(filePath, memoryRoot) {
-  if (memoryRoot !== void 0 && memoryRoot.length > 0) {
-    const relative = path4.relative(memoryRoot, path4.resolve(memoryRoot, filePath));
-    return ACTIVITY_DIGEST_TOPLEVEL.test(relative);
-  }
-  return ACTIVITY_DIGEST_ANYWHERE.test(filePath);
-}
-function buildCompressionGuidelinesMarkdown2(events, generatedAtIso = (/* @__PURE__ */ new Date()).toISOString()) {
-  return buildCompressionGuidelinesMarkdown(events, generatedAtIso);
-}
-function applyQueryAwareCandidateFilter(candidates, candidatePaths) {
-  if (!candidatePaths) return candidates;
-  if (candidatePaths.size === 0) return [];
-  const filtered = candidates.filter(
-    (candidate) => candidatePaths.has(candidate.path)
-  );
-  return filtered.length > 0 ? filtered : candidates;
-}
-function tokenizeRecallQuery(prompt) {
-  return prompt.toLowerCase().split(/[^a-z0-9]+/i).map((t) => t.trim()).filter((t) => t.length >= 3);
-}
-function hasLifecycleMetadata(frontmatter) {
-  return frontmatter.lifecycleState !== void 0 || frontmatter.verificationState !== void 0 || frontmatter.policyClass !== void 0 || frontmatter.lastValidatedAt !== void 0 || frontmatter.decayScore !== void 0 || frontmatter.heatScore !== void 0;
-}
-function shouldFilterLifecycleRecallCandidate(frontmatter, options) {
-  if (!options.lifecyclePolicyEnabled || !options.lifecycleFilterStaleEnabled)
-    return false;
-  if (!hasLifecycleMetadata(frontmatter)) return false;
-  const lifecycleState = resolveLifecycleState(frontmatter);
-  return lifecycleState === "stale" || lifecycleState === "archived";
-}
-function lifecycleRecallScoreAdjustment(frontmatter, options) {
-  if (!options.lifecyclePolicyEnabled) return 0;
-  if (!hasLifecycleMetadata(frontmatter)) return 0;
-  let delta = 0;
-  const lifecycleState = resolveLifecycleState(frontmatter);
-  switch (lifecycleState) {
-    case "active":
-      delta += 0.05;
-      break;
-    case "validated":
-      delta += 0.03;
-      break;
-    case "candidate":
-      delta -= 0.01;
-      break;
-    case "stale":
-      delta -= 0.06;
-      break;
-    case "archived":
-      delta -= 0.08;
-      break;
-  }
-  if (frontmatter.verificationState === "disputed") {
-    delta -= 0.12;
-  }
-  return delta;
-}
-function computeArtifactRecallLimit(recallMode, recallResultLimit, verbatimArtifactsMaxRecall) {
-  if (recallMode === "no_recall") return 0;
-  if (Math.max(0, recallResultLimit) === 0) return 0;
-  const base = Math.max(0, verbatimArtifactsMaxRecall);
-  if (recallMode === "minimal") {
-    return Math.min(base, Math.max(0, recallResultLimit));
-  }
-  return base;
-}
-function resolveEffectiveRecallMode(options) {
-  return resolveRecallModeDecision(options).effectiveMode;
-}
-function finalizeRecallModeDecision(plannedModeRaw, options) {
-  let plannedMode = plannedModeRaw;
-  const graphExpandedIntentDetected = options.plannerEnabled && options.graphExpandedIntentEnabled === true && hasBroadGraphIntent(options.prompt);
-  if (plannedMode !== "graph_mode" && graphExpandedIntentDetected) {
-    plannedMode = "graph_mode";
-  }
-  if (plannedMode === "graph_mode" && (!options.graphRecallEnabled || !options.multiGraphMemoryEnabled)) {
-    return {
-      plannedMode,
-      effectiveMode: "full",
-      graphExpandedIntentDetected,
-      graphReason: !options.graphRecallEnabled ? "graph recall disabled by config" : "multi-graph memory disabled by config"
-    };
-  }
-  return {
-    plannedMode,
-    effectiveMode: plannedMode,
-    graphExpandedIntentDetected
-  };
-}
-function resolveRecallModeDecision(options) {
-  const plannedMode = options.plannerEnabled ? planRecallMode(options.prompt) : "full";
-  return finalizeRecallModeDecision(plannedMode, options);
-}
-async function resolveRecallModeDecisionAsync(options) {
-  const heuristicDecision = resolveRecallModeDecision(options);
-  const plannerLlmEnabled = options.caps.recallPlannerLlm;
-  if (!options.plannerEnabled || !plannerLlmEnabled) {
-    return heuristicDecision;
-  }
-  const { planRecallModeLLM } = await import("./recall-planner-llm.js");
-  const planned = await planRecallModeLLM(
-    options.prompt,
-    options.hints,
-    options.config,
-    options.caps,
-    options.llm,
-    options.signal
-  );
-  if (options.config.recallPlannerShadowMode) {
-    return {
-      ...heuristicDecision,
-      plannerSource: planned.source,
-      plannerReason: `shadow:${planned.reason}`,
-      plannerLatencyMs: planned.latencyMs,
-      plannerFallbackUsed: planned.fallbackUsed,
-      plannerModelUsed: planned.modelUsed,
-      plannerHeuristicMode: planned.heuristicMode,
-      shadowLlmMode: planned.mode
-    };
-  }
-  const llmDecision = finalizeRecallModeDecision(planned.mode, options);
-  return {
-    ...llmDecision,
-    plannerSource: planned.source,
-    plannerReason: planned.reason,
-    plannerLatencyMs: planned.latencyMs,
-    plannerFallbackUsed: planned.fallbackUsed,
-    plannerModelUsed: planned.modelUsed,
-    plannerHeuristicMode: planned.heuristicMode
-  };
-}
-function computeArtifactCandidateFetchLimit(targetCount) {
-  const cappedTarget = Math.max(0, targetCount);
-  if (cappedTarget === 0) return 0;
-  const headroom = Math.max(8, cappedTarget * 4);
-  return Math.min(200, cappedTarget + headroom);
-}
-function computeQmdHybridFetchLimit(recallFetchLimit, artifactsEnabled, maxArtifactRecall) {
-  const cappedRecallLimit = Math.max(0, recallFetchLimit);
-  if (cappedRecallLimit === 0) return 0;
-  if (!artifactsEnabled) return cappedRecallLimit;
-  const artifactHeadroom = Math.max(20, Math.max(0, maxArtifactRecall) * 8);
-  return Math.min(400, cappedRecallLimit + artifactHeadroom);
-}
-function summarizeGraphShadowComparison(baseline, merged, topN) {
-  const limit = Math.max(0, Math.floor(topN));
-  const baselineTop = limit > 0 ? baseline.slice(0, limit) : [];
-  const graphTop = limit > 0 ? merged.slice(0, limit) : [];
-  const baselineByPath = new Map(
-    baselineTop.map((item) => [item.path, item.score])
-  );
-  const graphByPath = new Map(graphTop.map((item) => [item.path, item.score]));
-  let overlapCount = 0;
-  let overlapDeltaSum = 0;
-  for (const [p, baselineScore] of baselineByPath.entries()) {
-    const graphScore = graphByPath.get(p);
-    if (typeof graphScore !== "number") continue;
-    overlapCount += 1;
-    overlapDeltaSum += graphScore - baselineScore;
-  }
-  const baselineCount = baselineTop.length;
-  return {
-    baselineCount,
-    graphCount: graphTop.length,
-    overlapCount,
-    overlapRatio: baselineCount > 0 ? overlapCount / baselineCount : 0,
-    averageOverlapDelta: overlapCount > 0 ? overlapDeltaSum / overlapCount : 0
-  };
-}
-function parseGraphRecallRankedResults(value) {
-  if (!Array.isArray(value)) return [];
-  const parsed = [];
-  for (const entry of value) {
-    if (!entry || typeof entry !== "object") continue;
-    const candidate = entry;
-    if (typeof candidate.path !== "string" || typeof candidate.score !== "number")
-      continue;
-    parsed.push({
-      path: candidate.path,
-      score: candidate.score,
-      docid: typeof candidate.docid === "string" ? candidate.docid : void 0,
-      sourceLabels: Array.isArray(candidate.sourceLabels) ? candidate.sourceLabels.filter(
-        (item) => typeof item === "string"
-      ) : []
-    });
-  }
-  return parsed.slice(0, 64);
-}
-function parseMemoryIntentSnapshot(value) {
-  const candidate = value && typeof value === "object" ? value : {};
-  return {
-    goal: typeof candidate.goal === "string" ? candidate.goal : "unknown",
-    actionType: typeof candidate.actionType === "string" ? candidate.actionType : "unknown",
-    entityTypes: Array.isArray(candidate.entityTypes) ? candidate.entityTypes.filter(
-      (item) => typeof item === "string"
-    ) : [],
-    taskInitiation: candidate.taskInitiation === true
-  };
-}
-function buildQmdIntentHint(intent) {
-  const parts = [];
-  if (intent.goal !== "unknown") {
-    parts.push(`goal:${intent.goal.replace(/_/g, " ")}`);
-  }
-  if (intent.actionType !== "unknown") {
-    parts.push(`action:${intent.actionType.replace(/_/g, " ")}`);
-  }
-  if (intent.entityTypes.length > 0) {
-    parts.push(`entities:${intent.entityTypes.join(",")}`);
-  }
-  if (intent.taskInitiation === true) {
-    parts.push("task_initiation");
-  }
-  return parts.length > 0 ? parts.join(" ") : void 0;
-}
-function parseQmdRecallResults(value) {
-  if (!Array.isArray(value)) return [];
-  const parsed = [];
-  for (const entry of value) {
-    if (!entry || typeof entry !== "object") continue;
-    const candidate = entry;
-    if (typeof candidate.path !== "string" || typeof candidate.score !== "number")
-      continue;
-    parsed.push({
-      docid: typeof candidate.docid === "string" ? candidate.docid : "",
-      path: candidate.path,
-      snippet: typeof candidate.snippet === "string" ? candidate.snippet : "",
-      score: candidate.score,
-      explain: parseQmdExplain(candidate.explain),
-      transport: candidate.transport === "daemon" || candidate.transport === "subprocess" || candidate.transport === "hybrid" || candidate.transport === "scoped_prefilter" ? candidate.transport : void 0
-    });
-  }
-  return parsed.slice(0, 32);
-}
-function mergeArtifactRecallCandidates(candidatesByNamespace, limit) {
-  const cappedLimit = Math.max(0, limit);
-  if (cappedLimit === 0) return [];
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  let offset = 0;
-  while (out.length < cappedLimit) {
-    let hasAnyCandidateAtOffset = false;
-    for (const list of candidatesByNamespace) {
-      if (offset >= list.length) continue;
-      hasAnyCandidateAtOffset = true;
-      const item = list[offset];
-      const dedupeKey = `${item.frontmatter.id}:${item.frontmatter.sourceMemoryId ?? ""}:${item.content}`;
-      if (seen.has(dedupeKey)) continue;
-      seen.add(dedupeKey);
-      out.push(item);
-      if (out.length >= cappedLimit) break;
-    }
-    if (!hasAnyCandidateAtOffset) break;
-    offset += 1;
-  }
-  return out;
-}
-function resolveRecentThreadMemoryPaths(options) {
-  const maxRecent = Math.max(0, options.maxRecent);
-  if (options.threadEpisodeIds.length === 0 || maxRecent === 0) return [];
-  const pathById = options.pathById ?? buildMemoryPathById(options.allMemsForGraph, options.storageDir);
-  if (pathById.size === 0) return [];
-  const pendingReviewIds = new Set(
-    (options.allMemsForGraph ?? []).filter((m) => m.frontmatter.status === "pending_review" && m.frontmatter.id).map((m) => m.frontmatter.id)
-  );
-  return options.threadEpisodeIds.filter((id) => id !== options.currentMemoryId).filter((id) => !pendingReviewIds.has(id)).slice(-maxRecent).map((id) => pathById.get(id)).filter((p) => typeof p === "string" && p.length > 0);
-}
-function buildMemoryPathById(allMemsForGraph, storageDir) {
-  const pathById = /* @__PURE__ */ new Map();
-  for (const mem of allMemsForGraph ?? []) {
-    const id = mem.frontmatter.id;
-    if (!id) continue;
-    pathById.set(id, path4.relative(storageDir, mem.path));
-  }
-  return pathById;
-}
-function appendMemoryToGraphContext(options) {
-  if (!Array.isArray(options.allMemsForGraph)) return;
-  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-  options.allMemsForGraph.push({
-    path: path4.join(options.storageDir, options.memoryRelPath),
-    content: options.content,
-    frontmatter: {
-      id: options.memoryId,
-      category: options.category,
-      created: nowIso,
-      updated: nowIso,
-      source: "extraction",
-      confidence: 0.8,
-      confidenceTier: "implied",
-      tags: [],
-      entityRef: options.entityRef,
-      status: "active"
-    }
-  });
-}
-function resolvePersistedMemoryRelativePath(options) {
-  const persisted = options.pathById.get(options.memoryId);
-  if (persisted) return persisted;
-  if (options.category === "correction") {
-    return path4.join("corrections", `${options.memoryId}.md`);
-  }
-  const subtree = categoryDirName(options.category);
-  const idParts = options.memoryId.split("-");
-  const maybeTimestamp = Number(idParts[1]);
-  if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
-    const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path4.join(subtree, day, `${options.memoryId}.md`);
-  }
-  return path4.join(subtree, `${options.memoryId}.md`);
-}
-
-// src/orchestration/extraction-run.ts
-function deriveTopicsFromExtraction(result) {
-  const topics = /* @__PURE__ */ new Set();
-  for (const fact of result.facts ?? []) {
-    for (const tag of fact.tags ?? []) {
-      if (tag && tag.length >= 2) topics.add(tag.toLowerCase());
-    }
-    if (fact.entityRef) topics.add(fact.entityRef.toLowerCase());
-    if (fact.category) topics.add(fact.category);
-  }
-  for (const entity of result.entities ?? []) {
-    if (typeof entity.name === "string" && entity.name.length >= 2) {
-      topics.add(entity.name.toLowerCase());
-    }
-  }
-  return [...topics].slice(0, 16);
-}
-var EXTRACTION_RETRY_STATE_MAX_ENTRIES = 500;
-function computeExtractionRetryNextEligibleMs(attempts, scheduleMs, maxBackoffMs, jitterRatio, now, rng = Math.random) {
-  const cap = Number.isFinite(maxBackoffMs) && maxBackoffMs > 0 ? maxBackoffMs : 0;
-  if (!Array.isArray(scheduleMs) || scheduleMs.length === 0) {
-    return now + cap;
-  }
-  const idx = Math.min(Math.max(attempts - 1, 0), scheduleMs.length - 1);
-  const step = scheduleMs[idx];
-  const base = Math.min(typeof step === "number" && step > 0 ? step : cap, cap);
-  const jitter = 1 + (rng() * 2 - 1) * jitterRatio;
-  return now + Math.max(0, Math.round(base * jitter));
-}
-function capExtractionRetryStateEntries(entries, maxEntries) {
-  if (maxEntries <= 0) return [];
-  const sorted = [...entries].sort((a, b) => a.firstFailedAt.localeCompare(b.firstFailedAt));
-  return sorted.slice(-maxEntries);
-}
-var ExtractionRunCoordinator = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  recentExtractionFingerprints = /* @__PURE__ */ new Map();
-  // Per-fingerprint extraction retry/backoff state (extraction hot-loop
-  // hardening). Outer key = namespace, inner key = fingerprint. Hydrated lazily
-  // from namespace-scoped meta so the hot path is a Map lookup; persisted back
-  // to meta on change (restart-safe, cross-process coherent via the shared
-  // meta.json). The breaker below is intentionally per-process in-memory
-  // (mirrors local-llm.cooldownUntilMs); a restart clears it but the persisted
-  // backoff still throttles, so a restart can't resurrect the hot loop.
-  extractionRetryState = /* @__PURE__ */ new Map();
-  hydratedRetryNamespaces = /* @__PURE__ */ new Set();
-  providerBreaker = { consecutiveFailures: 0, openUntilMs: 0, state: "closed", lastReason: "" };
-  get config() {
-    return this.deps.config;
-  }
-  // -------------------------------------------------------------------------
-  // Source-valid-at helpers (moved from orchestrator.ts module scope)
-  // -------------------------------------------------------------------------
-  latestSourceValidAtFromTurns(turns) {
-    let latestMs = null;
-    for (const turn of turns) {
-      if (turn.extractionContextOnly === true) continue;
-      if (typeof turn.sourceValidAt !== "string") continue;
-      const parsed = parseFlexibleIsoTimestamp(turn.sourceValidAt.trim());
-      if (parsed === null) continue;
-      if (latestMs === null || parsed > latestMs) {
-        latestMs = parsed;
-      }
-    }
-    return latestMs === null ? void 0 : new Date(latestMs).toISOString();
-  }
-  // -------------------------------------------------------------------------
-  // Extraction dedupe fingerprint helpers
-  // -------------------------------------------------------------------------
-  normalizeExtractionFingerprintTurns(turns) {
-    if (!Array.isArray(turns) || turns.length === 0) return [];
-    return turns.filter((turn) => turn.role === "user" || turn.role === "assistant").map((turn) => {
-      if (typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0) {
-        return `fp:${turn.turnFingerprint}`;
-      }
-      return `${turn.role}:${(turn.content ?? "").replace(/\s+/g, " ").trim().slice(0, this.config.extractionMaxTurnChars)}`;
-    }).filter((value) => value.length > 0);
-  }
-  buildExtractionFingerprint(turns, bufferKey) {
-    const normalized = this.normalizeExtractionFingerprintTurns(turns).join("\n");
-    if (!normalized) return null;
-    return createHash3("sha256").update(`${bufferKey}
-${normalized}`).digest("hex");
-  }
-  shouldQueueExtraction(turns, options = {}) {
-    const lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config);
-    if (!lifecycleCaps.extractionDedupe) return true;
-    if (!Array.isArray(turns) || turns.length === 0) return false;
-    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
-    const fingerprint = this.buildExtractionFingerprint(turns, bufferKey);
-    if (!fingerprint) return false;
-    const now = Date.now();
-    const seenAt = this.recentExtractionFingerprints.get(fingerprint);
-    if (seenAt && now - seenAt < this.config.extractionDedupeWindowMs) {
-      log.debug("extraction dedupe: skipped duplicate buffered turn set");
-      return false;
-    }
-    if (options.commit !== false) {
-      this.recentExtractionFingerprints.set(fingerprint, now);
-    }
-    if (options.commit !== false && this.recentExtractionFingerprints.size > 200) {
-      const entries = Array.from(this.recentExtractionFingerprints.entries()).sort((a, b) => a[1] - b[1]);
-      for (const [key] of entries.slice(0, entries.length - 200)) {
-        this.recentExtractionFingerprints.delete(key);
-      }
-    }
-    return true;
-  }
-  // -------------------------------------------------------------------------
-  // Processed-fingerprint recording
-  // -------------------------------------------------------------------------
-  async recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta) {
-    const meta = preloadedMeta ?? await storage.loadMeta();
-    const observedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const seen = new Map(
-      (meta.processedExtractionFingerprints ?? []).map((entry) => [entry.fingerprint, entry.observedAt])
-    );
-    seen.set(fingerprint, observedAt);
-    meta.processedExtractionFingerprints = Array.from(seen.entries()).map(([value, at2]) => ({ fingerprint: value, observedAt: at2 })).sort((left, right) => left.observedAt.localeCompare(right.observedAt)).slice(-500);
-    if (!preloadedMeta) {
-      await storage.saveMeta(meta);
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Extraction retry/backoff + circuit breaker (extraction hot-loop hardening)
-  // -------------------------------------------------------------------------
-  /** Lazily hydrate the in-memory retry-state mirror for a namespace from meta.
-   *  One-time per namespace per coordinator; the hot path is then a Map lookup.
-   *  Cross-process coherence: a fresh coordinator hydrates from the shared
-   *  meta.json, so a failure persisted by another process is honored here. */
-  hydrateRetryStateFromMeta(namespace, meta) {
-    if (this.hydratedRetryNamespaces.has(namespace)) return;
-    this.hydratedRetryNamespaces.add(namespace);
-    const nsMap = this.extractionRetryState.get(namespace) ?? /* @__PURE__ */ new Map();
-    for (const entry of meta.extractionRetryState ?? []) {
-      const nextEligibleAtMs = Date.parse(entry.nextEligibleAt);
-      const firstFailedAtMs = Date.parse(entry.firstFailedAt);
-      nsMap.set(entry.fingerprint, {
-        attempts: entry.attempts,
-        nextEligibleAtMs: Number.isFinite(nextEligibleAtMs) ? nextEligibleAtMs : 0,
-        firstFailedAtMs: Number.isFinite(firstFailedAtMs) ? firstFailedAtMs : Date.now(),
-        lastFailureClass: entry.lastFailureClass
-      });
-    }
-    this.extractionRetryState.set(namespace, nsMap);
-  }
-  logBreakerTransition(state) {
-    log.warn("extraction: provider circuit breaker transition", {
-      state,
-      consecutiveFailures: this.providerBreaker.consecutiveFailures,
-      lastReason: this.providerBreaker.lastReason,
-      openUntilMs: this.providerBreaker.openUntilMs
-    });
-  }
-  /** True while the breaker suppresses non-forced attempts. Flips an expired
-   *  `open` breaker to `half_open`, which allows exactly one probe (the next
-   *  non-forced attempt) because the extraction queue is a serial drain. */
-  isProviderBreakerOpen(now) {
-    if (now < this.providerBreaker.openUntilMs) return true;
-    if (this.providerBreaker.state === "open") {
-      this.providerBreaker.state = "half_open";
-      this.logBreakerTransition("half_open");
-    }
-    return false;
-  }
-  onProviderFailure(cls, now) {
-    this.providerBreaker.consecutiveFailures += 1;
-    const trip = cls === "auth_config" || // A failed half-open probe re-opens immediately (standard breaker
-    // semantics). Without this, an auth_config-opened breaker (which trips
-    // below the threshold) would get stuck half_open after a transient
-    // probe failure and stop suppressing (cursor review).
-    this.providerBreaker.state === "half_open" || this.providerBreaker.consecutiveFailures >= this.config.extractionBreakerFailureThreshold;
-    if (!trip) return;
-    const cooldown = cls === "auth_config" ? this.config.extractionBreakerAuthCooldownMs : this.config.extractionBreakerCooldownMs;
-    this.providerBreaker.openUntilMs = now + Math.max(0, cooldown);
-    this.providerBreaker.lastReason = cls;
-    if (this.providerBreaker.state !== "open") {
-      this.providerBreaker.state = "open";
-      this.logBreakerTransition("open");
-    }
-  }
-  resetProviderBreakerOnSuccess() {
-    const wasDisturbed = this.providerBreaker.state !== "closed" || this.providerBreaker.consecutiveFailures > 0 || this.providerBreaker.openUntilMs > 0;
-    if (!wasDisturbed) return;
-    const wasOpen = this.providerBreaker.state !== "closed";
-    this.providerBreaker.consecutiveFailures = 0;
-    this.providerBreaker.openUntilMs = 0;
-    this.providerBreaker.lastReason = "";
-    this.providerBreaker.state = "closed";
-    if (wasOpen) this.logBreakerTransition("closed");
-  }
-  /** Rebuild `meta.extractionRetryState` from the in-memory namespace mirror,
-   *  bounded to the newest entries, and prune the mirror to match. */
-  persistRetryStateToMeta(namespace, meta) {
-    const nsMap = this.extractionRetryState.get(namespace);
-    const entries = nsMap ? Array.from(nsMap.entries()).map(([fingerprint, st]) => ({
-      fingerprint,
-      attempts: st.attempts,
-      nextEligibleAt: new Date(st.nextEligibleAtMs).toISOString(),
-      firstFailedAt: new Date(st.firstFailedAtMs).toISOString(),
-      lastFailureClass: st.lastFailureClass
-    })) : [];
-    const capped = capExtractionRetryStateEntries(entries, EXTRACTION_RETRY_STATE_MAX_ENTRIES);
-    meta.extractionRetryState = capped;
-    if (nsMap && capped.length < nsMap.size) {
-      const kept = new Set(capped.map((e) => e.fingerprint));
-      for (const key of Array.from(nsMap.keys())) {
-        if (!kept.has(key)) nsMap.delete(key);
-      }
-    }
-  }
-  /** Record an extraction failure into per-fingerprint backoff state + breaker,
-   *  persisting to namespace meta. Fail-open: never throws upward. */
-  async recordExtractionFailure(storage, namespace, fingerprint, cls, meta, now) {
-    try {
-      this.hydrateRetryStateFromMeta(namespace, meta);
-      const nsMap = this.extractionRetryState.get(namespace) ?? /* @__PURE__ */ new Map();
-      const prev = nsMap.get(fingerprint);
-      const attempts = (prev?.attempts ?? 0) + 1;
-      const firstFailedAtMs = prev?.firstFailedAtMs ?? now;
-      let nextEligibleAtMs;
-      if (cls === "parse_empty" && attempts > this.config.extractionParseEmptyMaxAttempts) {
-        nextEligibleAtMs = now + Math.max(0, this.config.extractionRetryMaxBackoffMs);
-      } else {
-        nextEligibleAtMs = computeExtractionRetryNextEligibleMs(
-          attempts,
-          this.config.extractionRetryScheduleMs,
-          this.config.extractionRetryMaxBackoffMs,
-          this.config.extractionRetryJitterRatio,
-          now
-        );
-      }
-      nsMap.set(fingerprint, { attempts, nextEligibleAtMs, firstFailedAtMs, lastFailureClass: cls });
-      this.extractionRetryState.set(namespace, nsMap);
-      this.onProviderFailure(cls, now);
-      this.persistRetryStateToMeta(namespace, meta);
-      await storage.saveMeta(meta);
-    } catch (err) {
-      log.warn("runExtraction: failed to record extraction retry state (non-fatal)", err);
-    }
-  }
-  /** Delete a fingerprint's retry entry from the mirror + meta. Returns whether
-   *  meta changed (so the caller can decide to persist). Does not touch the
-   *  breaker — callers pair this with `resetProviderBreakerOnSuccess`. */
-  clearExtractionRetryEntry(namespace, fingerprint, meta) {
-    const nsMap = this.extractionRetryState.get(namespace);
-    if (!nsMap?.has(fingerprint)) return false;
-    nsMap.delete(fingerprint);
-    this.persistRetryStateToMeta(namespace, meta);
-    return true;
-  }
-  /** Live in-process resilience snapshot (breaker + backoff population). */
-  getExtractionResilienceStatus() {
-    let backoffFingerprintCount = 0;
-    for (const nsMap of this.extractionRetryState.values()) {
-      backoffFingerprintCount += nsMap.size;
-    }
-    return {
-      breaker: {
-        state: this.providerBreaker.state,
-        openUntilMs: this.providerBreaker.openUntilMs,
-        consecutiveFailures: this.providerBreaker.consecutiveFailures,
-        lastReason: this.providerBreaker.lastReason
-      },
-      backoffFingerprintCount
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Main extraction pipeline
-  // -------------------------------------------------------------------------
-  async runExtraction(turns, options = {}) {
-    log.debug(`running extraction on ${turns.length} turns`);
-    const clearBufferAfterExtraction = options.clearBufferAfterExtraction ?? true;
-    const skipCharThreshold = options.skipCharThreshold ?? false;
-    const skipUserTurnThreshold = options.skipUserTurnThreshold ?? false;
-    const deadlineMs = typeof options.deadlineMs === "number" && Number.isFinite(options.deadlineMs) ? options.deadlineMs : void 0;
-    const bufferKey = options.bufferKey ?? turns[0]?.sessionKey ?? "default";
-    const throwIfDeadlineExceeded = (stage) => {
-      if (typeof deadlineMs === "number" && Date.now() > deadlineMs) {
-        throw new Error(`replay extraction deadline exceeded (${stage})`);
-      }
-    };
-    const throwIfAborted2 = (stage) => {
-      throwIfRecallAborted(options.abortSignal, `extraction aborted (${stage})`);
-    };
-    const clearBuffer = async (options2) => {
-      if (options2?.ignoreAbort !== true) {
-        throwIfAborted2("before_clear_buffer");
-      }
-      if (clearBufferAfterExtraction) {
-        await this.deps.getBuffer().clearAfterExtraction(bufferKey, turns);
-      }
-    };
-    const sessionKey = turns[0]?.sessionKey ?? "";
-    if (sessionKey.includes(":cron:")) {
-      log.debug(`skipping extraction for cron session: ${sessionKey}`);
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "cron_session",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-    }
-    const normalizedTurns = turns.filter((t) => (t.role === "user" || t.role === "assistant") && typeof t.content === "string").map((t) => ({
-      ...t,
-      content: t.content.trim().slice(0, this.config.extractionMaxTurnChars)
-    })).filter((t) => t.content.length > 0);
-    const targetTurns = normalizedTurns.filter((turn) => turn.extractionContextOnly !== true);
-    if (targetTurns.length === 0) {
-      log.debug("skipping extraction: no non-context turns after normalization");
-      if (normalizedTurns.length > 0) {
-        await this.deps.maybeCapturePassiveCorrections(normalizedTurns, {
-          sessionKey,
-          principal: resolvePrincipal(sessionKey, this.config),
-          namespace: this.deps.resolveSelfNamespace(sessionKey),
-          bufferKey,
-          isLiveSession: clearBufferAfterExtraction
-        });
-      }
-      await clearBuffer();
-      return { status: "skipped", reason: "empty_normalized_turns", persistedCount: 0, durableOutputCount: 0 };
-    }
-    const sourceValidAt = this.latestSourceValidAtFromTurns(targetTurns);
-    throwIfDeadlineExceeded("before_extract");
-    throwIfAborted2("before_extract");
-    const userTurns = targetTurns.filter((t) => t.role === "user");
-    const totalChars = targetTurns.reduce((sum, t) => sum + t.content.length, 0);
-    const belowCharThreshold = totalChars < this.config.extractionMinChars;
-    const belowUserTurnThreshold = !skipUserTurnThreshold && userTurns.length < this.config.extractionMinUserTurns;
-    if (!skipCharThreshold && belowCharThreshold || belowUserTurnThreshold) {
-      log.debug(`skipping extraction: below threshold (totalChars=${totalChars}, userTurns=${userTurns.length})`);
-      await clearBuffer();
-      {
-        const capturePrincipal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-        const captureWO = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : void 0;
-        const captureCodingCtx = sessionKey ? this.deps.getCodingContextForSession(sessionKey) : null;
-        const captureCodingOv = resolveCodingNamespaceOverlay(
-          captureCodingCtx,
-          this.config.codingMode,
-          this.config.defaultNamespace
-        );
-        const captureScopePlan = resolveScopeProfilePlan({
-          config: this.config,
-          principal: capturePrincipal,
-          codingContext: captureCodingCtx,
-          codingOverlay: captureCodingOv
-        });
-        const captureNamespace = captureWO ?? captureScopePlan?.writeNamespace ?? this.deps.resolveSelfNamespace(sessionKey);
-        await this.deps.maybeCapturePassiveCorrections(normalizedTurns, {
-          sessionKey,
-          principal: capturePrincipal,
-          namespace: captureNamespace,
-          bufferKey,
-          isLiveSession: clearBufferAfterExtraction
-        });
-      }
-      return {
-        status: "skipped",
-        reason: "below_threshold",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-    }
-    const principal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
-    const explicitWriteNamespace = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : void 0;
-    const codingContextForWrite = sessionKey ? this.deps.getCodingContextForSession(sessionKey) : null;
-    const codingOverlayForWrite = resolveCodingNamespaceOverlay(
-      codingContextForWrite,
-      this.config.codingMode,
-      this.config.defaultNamespace
-    );
-    const scopeProfileGatePlan = resolveScopeProfilePlan({
-      config: this.config,
-      principal,
-      codingContext: codingContextForWrite,
-      codingOverlay: codingOverlayForWrite
-    });
-    const scopeProfileWritePlan = explicitWriteNamespace ? null : scopeProfileGatePlan;
-    if (scopeProfileWritePlan) {
-      const selectedLayer = scopeProfileWritePlan.layers.find((layer) => layer.id === scopeProfileWritePlan.writeLayer);
-      const writeNamespaceReadable = scopeProfileWritePlan.readNamespaces.includes(
-        scopeProfileWritePlan.writeNamespace
-      );
-      if (!selectedLayer?.writable || !writeNamespaceReadable) {
-        log.warn(
-          `runExtraction: skipping scope profile ${scopeProfileWritePlan.profileId} because write layer ${scopeProfileWritePlan.writeLayer} is not writable inside the profile read stack`
-        );
-        await clearBuffer();
-        return {
-          status: "skipped",
-          reason: "scope_profile_no_writable_layer",
-          persistedCount: 0,
-          durableOutputCount: 0
-        };
-      }
-    }
-    const selfNamespace = explicitWriteNamespace ?? scopeProfileWritePlan?.writeNamespace ?? this.deps.applyCodingNamespaceOverlay(sessionKey, defaultNamespaceForPrincipal(principal, this.config));
-    const storage = await this.deps.getStorageRouter().storageFor(selfNamespace);
-    const shouldPersistProcessedFingerprint = targetTurns.some((turn) => turn.persistProcessedFingerprint === true);
-    const extractionFingerprint = this.buildExtractionFingerprint(targetTurns, bufferKey);
-    let meta = extractionFingerprint && shouldPersistProcessedFingerprint ? await storage.loadMeta() : null;
-    if (extractionFingerprint && shouldPersistProcessedFingerprint && (meta?.processedExtractionFingerprints ?? []).some((entry) => entry.fingerprint === extractionFingerprint)) {
-      log.debug(`runExtraction: skipping already-processed extraction fingerprint for ${bufferKey}`);
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "processed_fingerprint",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-    }
-    const forcedExtractionAttempt = options.failOnExtractionFailure === true || options.forceExtractionAttempt === true;
-    const extractionRetryEnabled = resolveMemoryLifecycleCapabilities(this.config).extractionRetry;
-    if (extractionFingerprint && !forcedExtractionAttempt && extractionRetryEnabled) {
-      try {
-        meta ??= await storage.loadMeta();
-        this.hydrateRetryStateFromMeta(selfNamespace, meta);
-        const nowMs = Date.now();
-        let suppressReason = null;
-        if (this.isProviderBreakerOpen(nowMs)) {
-          suppressReason = "provider_circuit_open";
-        } else {
-          const st = this.extractionRetryState.get(selfNamespace)?.get(extractionFingerprint);
-          if (st && nowMs < st.nextEligibleAtMs) suppressReason = "extraction_backoff";
-        }
-        if (suppressReason) {
-          try {
-            await this.deps.maybeCapturePassiveCorrections(normalizedTurns, {
-              sessionKey,
-              principal,
-              namespace: selfNamespace,
-              bufferKey,
-              isLiveSession: clearBufferAfterExtraction
-            });
-          } catch (captureErr) {
-            log.warn("runExtraction: passive correction capture failed on suppressed attempt (non-fatal)", captureErr);
-          }
-          return { status: "skipped", reason: suppressReason, persistedCount: 0, durableOutputCount: 0 };
-        }
-      } catch (err) {
-        log.warn("runExtraction: extraction retry gate check failed; proceeding (fail-open)", err);
-      }
-    }
-    const existingEntities = await storage.listEntityNames();
-    const result = await raceRecallAbort(
-      this.deps.getExtraction().extract(normalizedTurns, existingEntities),
-      options.abortSignal,
-      "extraction aborted (during_extract)"
-    );
-    throwIfDeadlineExceeded("before_persist");
-    throwIfAborted2("before_persist");
-    if (!result) {
-      log.warn("runExtraction: extraction returned null/undefined");
-      if (options.failOnExtractionFailure) {
-        throw new Error("extraction failed: invalid_extraction_result");
-      }
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "invalid_extraction_result",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-    }
-    const invalidExtractionResultFields = [
-      ["facts", result.facts],
-      ["entities", result.entities],
-      ["questions", result.questions],
-      ["profileUpdates", result.profileUpdates]
-    ].filter(([, value]) => !Array.isArray(value)).map(([field]) => field);
-    if (invalidExtractionResultFields.length > 0) {
-      log.warn("runExtraction: extraction returned invalid collection fields", {
-        invalidFields: invalidExtractionResultFields,
-        resultKeys: typeof result === "object" && result !== null ? Object.keys(result) : []
-      });
-      if (options.failOnExtractionFailure) {
-        throw new Error("extraction failed: invalid_extraction_result");
-      }
-      await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "invalid_extraction_result",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
-    }
-    const extractionFailure = typeof result.extractionFailure === "string" && result.extractionFailure.trim().length > 0 ? result.extractionFailure : void 0;
-    let recordedRetryFailure = false;
-    if (extractionFingerprint && extractionRetryEnabled) {
-      if (extractionFailure) {
-        try {
-          meta ??= await storage.loadMeta();
-          await this.recordExtractionFailure(
-            storage,
-            selfNamespace,
-            extractionFingerprint,
-            result.extractionFailureClass ?? "provider_retryable",
-            meta,
-            Date.now()
-          );
-          recordedRetryFailure = true;
-        } catch (err) {
-          log.warn("runExtraction: failed to load meta for retry bookkeeping (non-fatal)", err);
-        }
-      } else {
-        this.resetProviderBreakerOnSuccess();
-        try {
-          meta ??= await storage.loadMeta();
-          this.hydrateRetryStateFromMeta(selfNamespace, meta);
-          if (this.clearExtractionRetryEntry(selfNamespace, extractionFingerprint, meta)) {
-            await storage.saveMeta(meta);
-          }
-        } catch (err) {
-          log.warn("runExtraction: failed to persist cleared retry state (non-fatal)", err);
-        }
-      }
-    }
-    if (options.failOnExtractionFailure && extractionFailure) {
-      throw new Error(`extraction failed: ${extractionFailure}`);
-    }
-    if (result.facts.length === 0 && result.entities.length === 0 && result.questions.length === 0 && result.profileUpdates.length === 0) {
-      log.debug("runExtraction: extraction produced no durable outputs; skipping persistence");
-      if (extractionFailure) {
-        log.warn(
-          "runExtraction: extraction reported failure with no durable outputs; not marking fingerprint processed",
-          { extractionFailure }
-        );
-      }
-      if (extractionFingerprint && shouldPersistProcessedFingerprint && !extractionFailure) {
-        meta ??= await storage.loadMeta();
-        await this.deps.recordProcessedExtractionFingerprint(storage, extractionFingerprint, meta);
-        meta.extractionCount += 1;
-        meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
-        await storage.saveMeta(meta);
-      }
-      await this.deps.maybeCapturePassiveCorrections(normalizedTurns, {
-        sessionKey,
-        principal,
-        namespace: selfNamespace,
-        bufferKey,
-        isLiveSession: clearBufferAfterExtraction
-      });
-      if (recordedRetryFailure) {
-        log.debug("runExtraction: retaining buffer for backoff retry after failure");
-      } else {
-        await clearBuffer();
-      }
-      return { status: "skipped", reason: "empty_extraction_result", persistedCount: 0, durableOutputCount: 0 };
-    }
-    let threadIdForExtraction = null;
-    if (resolvePresentationCapabilities(this.config).threading && turns.length > 0) {
-      const lastTurn = turns[turns.length - 1];
-      try {
-        threadIdForExtraction = await this.deps.getThreading().processTurn(lastTurn, []);
-      } catch (err) {
-        log.warn("[threading] processTurn failed before persistence (non-fatal)", err);
-      }
-    }
-    const { persistedIds } = await this.deps.persistExtraction(
-      result,
-      storage,
-      threadIdForExtraction,
-      { sessionKey, principal, validAt: sourceValidAt, sourceConnector: deriveSourceConnector(targetTurns) },
-      // Pass the KNOWN base namespace (NHIdx) so the catalog write touch records the
-      // real namespace rather than a guess decoded from the storage dir.
-      selfNamespace,
-      scopeProfileGatePlan,
-      // Verbatim source turns for the faithfulness gate (#1576) so it can
-      // locate a quote per fact when #1575 spans are absent.
-      normalizedTurns.map((t) => t.content).join("\n\n")
-    );
-    let postPersistMetadataFailed = false;
-    meta ??= await storage.loadMeta();
-    if (extractionFingerprint && shouldPersistProcessedFingerprint) {
-      try {
-        await this.deps.recordProcessedExtractionFingerprint(storage, extractionFingerprint, meta);
-      } catch (error) {
-        log.warn(
-          "runExtraction: failed to persist processed extraction fingerprint; continuing with buffer clear",
-          error
-        );
-        postPersistMetadataFailed = true;
-      }
-    }
-    meta.extractionCount += 1;
-    meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
-    meta.totalMemories += Array.isArray(result?.facts) ? result.facts.length : 0;
-    meta.totalEntities += Array.isArray(result?.entities) ? result.entities.length : 0;
-    try {
-      await storage.saveMeta(meta);
-    } catch (error) {
-      log.warn(
-        "runExtraction: failed to save extraction metadata after durable persistence; continuing with buffer clear",
-        error
-      );
-      postPersistMetadataFailed = true;
-    }
-    const durableOutputCount = result.facts.length + result.entities.length + result.questions.length + result.profileUpdates.length;
-    try {
-      if (clearBufferAfterExtraction && !this.config.extractionJudgeShadow) {
-        const deferredCount = this.deps.getLastPersistExtractionDeferredCount();
-        if (deferredCount > 0 && normalizedTurns.length > 0) {
-          await this.deps.getBuffer().retainDeferredTurns(bufferKey, normalizedTurns, 10);
-        } else {
-          await this.deps.getBuffer().retainDeferredTurns(bufferKey, [], 0);
-        }
-      }
-    } catch (err) {
-      log.debug(
-        `extraction-judge: defer retention failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    await clearBuffer({ ignoreAbort: true });
-    await this.deps.maybeCapturePassiveCorrections(normalizedTurns, {
-      sessionKey,
-      principal,
-      namespace: selfNamespace,
-      bufferKey,
-      isLiveSession: clearBufferAfterExtraction
-    });
-    if (resolvePresentationCapabilities(this.config).memoryBoxes && persistedIds.length > 0) {
-      const extractionTopics = deriveTopicsFromExtraction(result);
-      const firstUserTurn = turns.find((t) => t.role === "user");
-      const boxGoal = firstUserTurn?.content?.slice(0, 100)?.trim() || void 0;
-      await this.deps.boxBuilderFor(storage).onExtraction({
-        topics: extractionTopics,
-        memoryIds: persistedIds,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        goal: boxGoal
-      }).catch((err) => log.warn("[boxes] onExtraction failed (non-fatal)", err));
-    }
-    if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction && persistedIds.length > 0) {
-      await this.deps.appendPersistedThreadEpisodes(threadIdForExtraction, persistedIds);
-    }
-    if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction) {
-      const conversationContent = turns.map((t) => t.content).join(" ");
-      try {
-        await this.deps.getThreading().updateThreadTitle(threadIdForExtraction, conversationContent);
-      } catch (err) {
-        log.warn("[threading] updateThreadTitle failed after persistence (non-fatal)", err);
-      }
-    }
-    const nonZeroExtraction = durableOutputCount > 0;
-    try {
-      this.deps.maybeScheduleConsolidation(nonZeroExtraction);
-    } catch (err) {
-      log.warn("runExtraction: consolidation scheduling failed after persistence (non-fatal)", err);
-    }
-    try {
-      this.deps.requestQmdMaintenance();
-    } catch (err) {
-      log.warn("runExtraction: QMD maintenance scheduling failed after persistence (non-fatal)", err);
-    }
-    try {
-      await this.deps.runTierMigrationCycle(storage, "extraction");
+      }
     } catch (err) {
-      log.warn("runExtraction: tier migration failed after persistence (non-fatal)", err);
+      log.warn(
+        `contradiction auto-resolve supersede failed for ${contradiction.supersededId}: ${err}`
+      );
     }
-    return {
-      status: "completed",
-      persistedCount: persistedIds.length,
-      durableOutputCount,
-      postPersistMetadataFailed
-    };
   }
-};
-function deriveSourceConnector(turns) {
-  if (turns.length === 0) return void 0;
-  const connectors = /* @__PURE__ */ new Set();
-  let untaggedCount = 0;
-  for (const turn of turns) {
-    if (typeof turn.sourceConnector === "string" && turn.sourceConnector.length > 0) {
-      connectors.add(turn.sourceConnector);
-    } else {
-      untaggedCount += 1;
+  // ---------------------------------------------------------------------------
+  // Memory Linking (Phase 3A)
+  // ---------------------------------------------------------------------------
+  /**
+   * Suggest links for a new memory based on similar existing memories.
+   */
+  async suggestLinksForMemory(content, category, namespaceScope) {
+    if (!this.isSearchAvailable()) return [];
+    const results = await this.searchAcrossNamespaces({
+      query: content,
+      namespaces: [namespaceScope],
+      maxResults: 5,
+      mode: "search"
+    });
+    if (results.length === 0) return [];
+    const candidates = [];
+    for (const result of results) {
+      const memoryId = this.extractMemoryIdsFromResults([result])[0];
+      if (!memoryId) continue;
+      const resultNamespace = this.namespaceFromPath(result.path);
+      if (resultNamespace !== namespaceScope) continue;
+      const resultStorage = await this.storageForNamespace(resultNamespace);
+      const memory = await resultStorage.getMemoryById(memoryId);
+      if (memory && memory.frontmatter.status !== "superseded" && memory.frontmatter.status !== "forgotten") {
+        candidates.push({
+          id: memory.frontmatter.id,
+          content: memory.content,
+          category: memory.frontmatter.category
+        });
+      }
     }
+    if (candidates.length === 0) return [];
+    const extraction = this.getExtraction();
+    const suggestions = await extraction.suggestLinks(
+      { content, category },
+      candidates
+    );
+    if (!suggestions || suggestions.links.length === 0) return [];
+    return suggestions.links.map((link) => ({
+      targetId: link.targetId,
+      linkType: link.linkType,
+      strength: link.strength,
+      reason: link.reason || void 0
+    }));
   }
-  if (untaggedCount > 0) return void 0;
-  return connectors.size === 1 ? [...connectors][0] : void 0;
-}
+};
 
 // src/orchestration/consolidation-run.ts
-import path5 from "path";
+import path4 from "path";
 import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
 var ConsolidationRunCoordinator = class {
   constructor(deps) {
@@ -4258,7 +3034,7 @@ var ConsolidationRunCoordinator = class {
     }
     if (resolveConsolidationCapabilities(config).semanticConsolidation) {
       try {
-        const stateFilePath = path5.join(
+        const stateFilePath = path4.join(
           config.memoryDir,
           "state",
           "semantic-consolidation-last-run.json"
@@ -4306,7 +3082,7 @@ var ConsolidationRunCoordinator = class {
             );
           }
           if (semResult.errors === 0 || semResult.memoriesArchived > 0) {
-            const stateDir = path5.join(config.memoryDir, "state");
+            const stateDir = path4.join(config.memoryDir, "state");
             await mkdir2(stateDir, { recursive: true });
             await writeFile2(
               stateFilePath,
@@ -6229,14 +5005,14 @@ var ExtractionPersistCoordinator = class {
 };
 
 // src/orchestration/recall-internal.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { readFile as readFile2, stat, unlink } from "fs/promises";
-import path8 from "path";
+import path7 from "path";
 
 // src/orchestration/graph-recall-coordinator.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import path6 from "path";
+import path5 from "path";
 function mergeGraphExpandedResults(primary, expanded) {
   const mergedByNamespaceAndPath = /* @__PURE__ */ new Map();
   for (const item of [...primary, ...expanded]) {
@@ -6253,11 +5029,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByNamespaceAndPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path6.isAbsolute(candidatePath) ? candidatePath : path6.resolve(storageDir, candidatePath);
-  const rel = path6.relative(storageDir, absolutePath);
+  const absolutePath = path5.isAbsolute(candidatePath) ? candidatePath : path5.resolve(storageDir, candidatePath);
+  const rel = path5.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path6.sep).join("/");
+  return rel.split(path5.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -6328,7 +5104,7 @@ var GraphRecallCoordinator = class {
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path6.isAbsolute(resolvedPath)) {
+      if (!path5.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -6353,7 +5129,7 @@ var GraphRecallCoordinator = class {
         }
         continue;
       }
-      if (path6.isAbsolute(result.path)) {
+      if (path5.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -6396,7 +5172,7 @@ var GraphRecallCoordinator = class {
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path6.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path5.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -6412,7 +5188,7 @@ var GraphRecallCoordinator = class {
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (deadlineExpired()) break;
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path6.resolve(storage.dir, candidate.path);
+        const memoryPath = path5.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (deadlineExpired()) break;
         if (!memory) continue;
@@ -6440,7 +5216,7 @@ var GraphRecallCoordinator = class {
           path: memory.path,
           score,
           namespace,
-          seed: path6.resolve(storage.dir, candidate.seed),
+          seed: path5.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -6464,12 +5240,12 @@ var GraphRecallCoordinator = class {
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path6.join(
+      const snapshotPath = path5.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path6.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path5.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -6481,7 +5257,7 @@ var GraphRecallCoordinator = class {
       const payload = {
         recordedAt: now,
         mode: options.recallMode,
-        queryHash: createHash4("sha256").update(options.prompt).digest("hex"),
+        queryHash: createHash2("sha256").update(options.prompt).digest("hex"),
         queryLength: options.prompt.length,
         namespaces: options.recallNamespaces,
         seedCount: totalSeedCount,
@@ -6584,7 +5360,7 @@ ${blocks.join("\n\n")}`;
 }
 
 // src/orchestration/generic-recall-paths.ts
-import path7 from "path";
+import path6 from "path";
 var CATEGORY_MEMORY_ROOTS = Object.fromEntries(
   ALL_CATEGORY_DIRS.map((directory) => [directory, true])
 );
@@ -6609,7 +5385,7 @@ function normalizeQmdUriPath(relativePath, source) {
   }
 }
 function stripQmdCollectionPrefix(relativePath, policy, source) {
-  const normalized = path7.posix.normalize(normalizeQmdUriPath(relativePath, source).replace(/\\/g, "/"));
+  const normalized = path6.posix.normalize(normalizeQmdUriPath(relativePath, source).replace(/\\/g, "/"));
   const slashIndex = normalized.indexOf("/");
   if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return normalized;
   const prefix = normalized.slice(0, slashIndex);
@@ -6618,8 +5394,8 @@ function stripQmdCollectionPrefix(relativePath, policy, source) {
   return matchesHotCollection || matchesColdCollection ? normalized.slice(slashIndex + 1) : normalized;
 }
 function isTopLevelArchivePath(filePath, policy = {}, source = "filesystem") {
-  const isAbsolutePath = path7.isAbsolute(filePath);
-  const relative = policy.memoryDir && isAbsolutePath ? path7.relative(policy.memoryDir, path7.resolve(filePath)) : filePath;
+  const isAbsolutePath = path6.isAbsolute(filePath);
+  const relative = policy.memoryDir && isAbsolutePath ? path6.relative(policy.memoryDir, path6.resolve(filePath)) : filePath;
   const normalized = !isAbsolutePath ? stripQmdCollectionPrefix(relative, policy, source) : relative;
   return /^(?:archive|namespaces[\\/][^\\/]+[\\/]archive)(?:[\\/]|$)/i.test(normalized);
 }
@@ -6705,8 +5481,8 @@ var RecallInternalCoordinator = class {
         timings,
         logger: log
       });
-      const promptHash = createHash5("sha256").update(prompt).digest("hex");
-      const traceId = createHash5("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
+      const promptHash = createHash3("sha256").update(prompt).digest("hex");
+      const traceId = createHash3("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
       const sectionBuckets = /* @__PURE__ */ new Map();
       const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
         cronRecallPolicyEnabled: resolveRecallAuxiliaryCapabilities(this.deps.config).cronRecallPolicy,
@@ -6715,7 +5491,7 @@ var RecallInternalCoordinator = class {
         cronConversationRecallMode: this.deps.config.cronConversationRecallMode
       });
       const retrievalQuery = queryPolicy.retrievalQuery || prompt;
-      const retrievalQueryHash = createHash5("sha256").update(retrievalQuery).digest("hex");
+      const retrievalQueryHash = createHash3("sha256").update(retrievalQuery).digest("hex");
       const policyVersion = this.deps.currentPolicyVersion();
       let recallSource = "none";
       let recalledMemoryCount = 0;
@@ -6855,7 +5631,7 @@ var RecallInternalCoordinator = class {
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path8.sep).join("/");
+        const normalizedPath = resultPath.split(path7.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -7016,7 +5792,7 @@ var RecallInternalCoordinator = class {
         profileStorageNamespaces.map((namespace) => this.deps.storageRouter.storageFor(namespace))
       );
       const emptyProfileStorage = new Proxy(
-        { dir: path8.join(this.deps.config.memoryDir, ".empty-scope-profile") },
+        { dir: path7.join(this.deps.config.memoryDir, ".empty-scope-profile") },
         {
           get(target, prop) {
             if (prop in target) return target[prop];
@@ -8498,11 +7274,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.deps.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.deps.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path8.join(
+        const signalPath = path7.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path8.join(workspaceDir, "BOOT.md");
+        const bootPath = path7.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -10655,8 +9431,8 @@ ${tmtNode.summary}`
 };
 
 // src/orchestration/recall-search-pipeline.ts
-import { createHash as createHash6 } from "crypto";
-import path9 from "path";
+import { createHash as createHash4 } from "crypto";
+import path8 from "path";
 var RecallSearchPipelineCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -10821,7 +9597,7 @@ var RecallSearchPipelineCoordinator = class {
       if (!options.onDebugSnapshot) return;
       await options.onDebugSnapshot({
         recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        queryHash: createHash6("sha256").update(prompt).digest("hex"),
+        queryHash: createHash4("sha256").update(prompt).digest("hex"),
         queryLength: prompt.length,
         collection: options.collection,
         namespaces: options.recallNamespaces,
@@ -10964,7 +9740,7 @@ var RecallSearchPipelineCoordinator = class {
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path9.isAbsolute(hit.path) ? hit.path : path9.join(this.deps.config.memoryDir, hit.path);
+      const fullPath = path8.isAbsolute(hit.path) ? hit.path : path8.join(this.deps.config.memoryDir, hit.path);
       const memory = await this.deps.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -11127,7 +9903,7 @@ var RecallSearchPipelineCoordinator = class {
           const storage = await this.deps.storageRouter.storageFor(namespace);
           const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
           if (!storageDir) continue;
-          const recallRoot = path9.resolve(storageDir);
+          const recallRoot = path8.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -11151,8 +9927,8 @@ var RecallSearchPipelineCoordinator = class {
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path9.isAbsolute(result.path)) {
-          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path9.resolve(result.path)))) {
+        if (path8.isAbsolute(result.path)) {
+          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path8.resolve(result.path)))) {
             scopedResults.push(result);
           }
           continue;
@@ -11679,7 +10455,7 @@ var RecallSearchPipelineCoordinator = class {
 };
 
 // src/orchestration/turn-ingestion.ts
-import { createHash as createHash7, randomBytes } from "crypto";
+import { createHash as createHash5, randomBytes } from "crypto";
 var TurnIngestionCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -11742,6 +10518,7 @@ var TurnIngestionCoordinator = class {
         timestamp: turn.timestamp,
         sourceValidAt: turn.sourceValidAt,
         sessionKey: key,
+        ...options.sessionOwnerPrincipal ? { sessionOwnerPrincipal: options.sessionOwnerPrincipal } : {},
         parts: turn.parts,
         rawContent: turn.rawContent,
         sourceFormat: turn.sourceFormat,
@@ -11863,7 +10640,7 @@ var TurnIngestionCoordinator = class {
     const shouldUseStableBatchKey = turns.some(
       (turn) => turn.persistProcessedFingerprint === true || typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0
     );
-    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash7("sha256").update(
+    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash5("sha256").update(
       turns.map(
         (turn) => [
           turn.role,
@@ -12058,41 +10835,70 @@ var TurnIngestionCoordinator = class {
         timeout = void 0;
       }
     };
+    let abortHandler;
+    const clearAbortListener = () => {
+      if (abortHandler && options.abortSignal) {
+        options.abortSignal.removeEventListener("abort", abortHandler);
+        abortHandler = void 0;
+      }
+    };
     const settleTask = (error, result) => {
       if (settled) return false;
       settled = true;
       clearQueueWaitTimer();
+      clearAbortListener();
       options.onTaskSettled?.(error, result);
       return true;
     };
-    if (typeof extractionDeadlineMs === "number") {
-      const remainingMs = extractionDeadlineMs - Date.now();
-      if (remainingMs <= 0) {
-        settleTask(new Error("replay extraction deadline exceeded (queue_wait)"));
+    if (options.abortSignal) {
+      const signal = options.abortSignal;
+      abortHandler = () => settleTask(signal.reason ?? abortError("extraction aborted (queue_wait)"));
+      signal.addEventListener("abort", abortHandler, { once: true });
+      if (signal.aborted) {
+        settleTask(signal.reason ?? abortError("extraction aborted (queue_wait)"));
         return;
       }
-      timeout = setTimeout(() => {
-        settleTask(new Error("replay extraction deadline exceeded (queue_wait)"));
-      }, remainingMs);
+    }
+    if (typeof extractionDeadlineMs === "number") {
+      const deadline = extractionDeadlineMs;
+      const maxTimerDelayMs = 2147483647;
+      const scheduleQueueWaitTimeout = () => {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+          settleTask(new ExtractionDeadlineError("queue_wait"));
+          return;
+        }
+        timeout = setTimeout(() => {
+          if (Date.now() >= deadline) {
+            settleTask(new ExtractionDeadlineError("queue_wait"));
+          } else {
+            scheduleQueueWaitTimeout();
+          }
+        }, Math.min(remainingMs, maxTimerDelayMs));
+      };
+      scheduleQueueWaitTimeout();
     }
     this.deps.extractionQueueCoordinator.enqueue(async () => {
       if (settled) return;
       if (typeof extractionDeadlineMs === "number" && extractionDeadlineMs <= Date.now()) {
-        settleTask(new Error("replay extraction deadline exceeded (queue_wait)"));
+        settleTask(new ExtractionDeadlineError("queue_wait"));
         return;
       }
       clearQueueWaitTimer();
       try {
         const result = await this.deps.runExtraction(turnsToExtract, {
           clearBufferAfterExtraction: options.clearBufferAfterExtraction ?? true,
+          clearMatchingTurns: options.clearMatchingTurns === true,
           skipCharThreshold: options.skipCharThreshold ?? false,
           skipUserTurnThreshold: options.skipUserTurnThreshold ?? false,
           deadlineMs: extractionDeadlineMs,
           bufferKey,
+          onDurableCommit: options.onDurableCommit,
           abortSignal: options.abortSignal,
           failOnExtractionFailure: options.failOnExtractionFailure === true,
           writeNamespaceOverride: options.writeNamespaceOverride,
           principalOverride: options.principalOverride,
+          scopeProfileWritePlan: options.scopeProfileWritePlan,
           forceExtractionAttempt: options.forceExtractionAttempt === true
         });
         settleTask(void 0, result);
@@ -12138,11 +10944,12 @@ var TurnIngestionCoordinator = class {
           bufferKey: opts.bufferKey,
           sessionKey: opts.sessionKey,
           principal: opts.principal,
-          namespace: opts.namespace
+          namespace: opts.namespace,
+          abortSignal: opts.abortSignal
         },
         captureConfig,
         {
-          planCorrection: (req) => service.plan(req),
+          planCorrection: (req, planOpts) => service.plan(req, planOpts),
           applyCorrection: (planId, applyOpts) => service.apply(planId, applyOpts),
           storageDir: async (ns) => (await this.deps.getStorage(ns)).dir,
           // Resolve `[m:xxxx]` handles to concrete memory ids via the single
@@ -12175,7 +10982,7 @@ var TurnIngestionCoordinator = class {
 
 // src/orchestration/recall-introspection.ts
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import path11 from "path";
+import path10 from "path";
 
 // src/taxonomy/default-taxonomy.ts
 var DEFAULT_TAXONOMY = {
@@ -12298,7 +11105,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile as readFile3, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path10 from "path";
+import path9 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -12396,7 +11203,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path10.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path9.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile3(taxonomyPath, "utf-8");
@@ -12446,16 +11253,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path10.join(memoryDir, TAXONOMY_DIR);
+  const dir = path9.join(memoryDir, TAXONOMY_DIR);
   await mkdir4(dir, { recursive: true });
-  const filePath = path10.join(dir, TAXONOMY_FILE);
+  const filePath = path9.join(dir, TAXONOMY_FILE);
   await writeFile4(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path10.join(memoryDir, TAXONOMY_DIR);
+  return path9.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path10.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path9.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/orchestration/recall-introspection.ts
@@ -12479,7 +11286,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(
+    const snapshotPath = path10.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -12518,7 +11325,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path10.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile4(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -12551,7 +11358,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path11.join(
+    const snapshotPath = path10.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -12841,12 +11648,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path11.join(
+      const snapshotPath = path10.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12858,12 +11665,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path11.join(
+      const snapshotPath = path10.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12878,8 +11685,8 @@ var RecallIntrospectionCoordinator = class {
       const stateDir = await this.deps.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path11.join(stateDir, "last_intent.json");
-      await mkdir5(path11.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path10.join(stateDir, "last_intent.json");
+      await mkdir5(path10.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12893,7 +11700,7 @@ var RecallIntrospectionCoordinator = class {
 
 // src/orchestration/orchestrator-init.ts
 import { readdir as readdir2, stat as stat2, unlink as unlink2 } from "fs/promises";
-import path12 from "path";
+import path11 from "path";
 var OrchestratorInitCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -12989,7 +11796,7 @@ var OrchestratorInitCoordinator = class {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path12.join(wsDir, f);
+            const fp = path11.join(wsDir, f);
             const s = await stat2(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink2(fp).catch(() => {
@@ -13341,7 +12148,7 @@ var OrchestratorInitCoordinator = class {
 };
 
 // src/orchestration/persistence-index.ts
-import path13 from "path";
+import path12 from "path";
 var PersistenceIndexCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -13527,7 +12334,7 @@ var PersistenceIndexCoordinator = class {
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path13.relative(storage.dir, m.path);
+            const rel = path12.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -13676,7 +12483,7 @@ var PersistenceIndexCoordinator = class {
 
 // src/orchestration/workspace-ops.ts
 import { lstat, mkdir as mkdir6, readFile as readFile5, readdir as readdir3, realpath, writeFile as writeFile6 } from "fs/promises";
-import path14 from "path";
+import path13 from "path";
 
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
@@ -15575,8 +14382,8 @@ var MeetingsService = class {
 // src/orchestration/workspace-ops.ts
 var MEETINGS_BUILD_DEBOUNCE_MS = 5e3;
 function matchesMemoryPath(candidatePath, requestedPath, memoryDir) {
-  const normalizedCandidate = path14.resolve(candidatePath);
-  return normalizedCandidate === path14.resolve(requestedPath) || normalizedCandidate === path14.resolve(memoryDir, requestedPath);
+  const normalizedCandidate = path13.resolve(candidatePath);
+  return normalizedCandidate === path13.resolve(requestedPath) || normalizedCandidate === path13.resolve(memoryDir, requestedPath);
 }
 function accessTrackingPathCandidates(storageDir, memoryPath) {
   const candidates = qmdResultPathCandidates(storageDir, memoryPath);
@@ -15584,12 +14391,12 @@ function accessTrackingPathCandidates(storageDir, memoryPath) {
   if (!parts) return candidates;
   candidates.push(
     ...qmdResultPathCandidates(storageDir, parts.relativePath),
-    ...qmdResultPathCandidates(path14.join(storageDir, "cold"), parts.relativePath)
+    ...qmdResultPathCandidates(path13.join(storageDir, "cold"), parts.relativePath)
   );
   return [...new Set(candidates)];
 }
 function canonicalMemoryPath(memoryPath, memoryDir) {
-  return path14.resolve(path14.isAbsolute(memoryPath) ? memoryPath : path14.resolve(memoryDir, memoryPath));
+  return path13.resolve(path13.isAbsolute(memoryPath) ? memoryPath : path13.resolve(memoryDir, memoryPath));
 }
 var WorkspaceOpsCoordinator = class {
   constructor(deps) {
@@ -15671,15 +14478,15 @@ var WorkspaceOpsCoordinator = class {
     this.deps.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path14.isAbsolute(rel) ? rel : path14.join(this.deps.config.workspaceDir, rel);
+        const abs = path13.isAbsolute(rel) ? rel : path13.join(this.deps.config.workspaceDir, rel);
         try {
           const raw = await readFile5(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path14.join(
+            const archiveDir = path13.join(
               this.deps.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path14.basename(abs);
+            const base = path13.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -15704,8 +14511,8 @@ var WorkspaceOpsCoordinator = class {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path14.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path14.dirname(fp), { recursive: true });
+        const fp = path13.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path13.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -15745,7 +14552,7 @@ var WorkspaceOpsCoordinator = class {
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path14.join(storage.dir, categoryDir, date);
+        const dateDir = path13.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -15754,7 +14561,7 @@ var WorkspaceOpsCoordinator = class {
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path14.join(dateDir, entry.name);
+            const fullPath = path13.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath(fullPath), fullPath);
               const raw = await readFile5(fullPath, "utf-8");
@@ -15776,7 +14583,7 @@ var WorkspaceOpsCoordinator = class {
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path14.basename(entry.name, ".md"),
+                  id: fm.id || path13.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -15799,13 +14606,13 @@ var WorkspaceOpsCoordinator = class {
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path14.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path13.join(storage.dir, "summaries", "hourly");
     try {
       const sessionKeys = await readdir3(hourlyBaseDir, { withFileTypes: true });
       for (const sk of sessionKeys) {
         if (!sk.isDirectory()) continue;
         for (const date of datesToScan) {
-          const summaryFile = path14.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path13.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile5(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -16269,18 +15076,18 @@ ${reflectionsContent.trim()}
 // src/orchestration/namespace-read-fanout.ts
 import { existsSync, readFileSync } from "fs";
 import { stat as stat3 } from "fs/promises";
-import path16 from "path";
+import path15 from "path";
 
 // src/orchestration/orchestrator-namespace-scope.ts
-import path15 from "path";
+import path14 from "path";
 function computeSemanticDedupScope(targetStorage, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return {};
-  const memoryDir = path15.resolve(config.memoryDir);
-  const storageDir = path15.resolve(targetStorage.dir);
+  const memoryDir = path14.resolve(config.memoryDir);
+  const storageDir = path14.resolve(targetStorage.dir);
   if (storageDir === memoryDir) {
     return { pathExcludePrefixes: ["namespaces/"] };
   }
-  let rel = path15.relative(memoryDir, storageDir);
+  let rel = path14.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`
@@ -16333,7 +15140,7 @@ var NamespaceReadFanoutCoordinator = class {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.deps.namespaceStorageDirHintsLoaded || !this.deps.namespaceCatalog.enabled) return;
     this.deps.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path16.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path15.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -16370,7 +15177,7 @@ var NamespaceReadFanoutCoordinator = class {
       if (!this.deps.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path16.resolve(record.storageDir);
+      const resolvedStorageDir = path15.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -16551,12 +15358,12 @@ var NamespaceReadFanoutCoordinator = class {
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      return path16.join(this.deps.config.memoryDir, "state");
+      return path15.join(this.deps.config.memoryDir, "state");
     }
     if (namespace !== this.deps.config.defaultNamespace) {
-      return path16.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
+      return path15.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path16.join(
+    const candidate = path15.join(
       this.deps.config.memoryDir,
       "namespaces",
       this.deps.config.defaultNamespace
@@ -16564,11 +15371,11 @@ var NamespaceReadFanoutCoordinator = class {
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path16.join(candidate, "state");
+        return path15.join(candidate, "state");
       }
     } catch {
     }
-    return path16.join(this.deps.config.memoryDir, "state");
+    return path15.join(this.deps.config.memoryDir, "state");
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return this.deps.config.defaultNamespace;
@@ -16781,270 +15588,6 @@ var RecallEntryCoordinator = class {
   }
 };
 
-// src/orchestration/session-context.ts
-var SessionContextCoordinator = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  deps;
-  /**
-   * Effective namespace a same-session LCM/structured-history READER must use
-   * to find what the access `observe` surface WROTE (#1495 thread 2).
-   *
-   * This MUST mirror the `observe` scope plan's write-namespace resolution, NOT
-   * `resolveSelfNamespace`: when no coding overlay applies, `observe` archives
-   * under `config.defaultNamespace` (an unqualified observed turn is NOT moved
-   * to the principal self namespace — identical to
-   * `resolveCodingScopedWriteNamespace`/`memory_store`, rule 39). Only when a
-   * coding overlay actually changes the namespace does the writer (and so the
-   * reader) use the overlaid `project-*` namespace. Returning the self base for
-   * the no-overlay case would prefix the read key with a namespace the writer
-   * never used, so the reader would miss its own evidence.
-   *
-   * Honours the access-surface `principalOverride` (#1505 thread 2, codex): when
-   * a recall supplies an authenticated principal NOT encoded in the raw
-   * `sessionKey`, `observe` archived LCM under THAT principal's base namespace.
-   * Deriving the base from `resolvePrincipal(sessionKey)` alone could fall back
-   * to `default`, so principal `alice` observing `sess-1` would write under
-   * `alice` but READ under `default`. Threading the override here keeps the read
-   * base identical to the write base.
-   *
-   * READ-AUTHORIZATION gate (#1505 round 3, codex P2 "Gate LCM recall keys by
-   * readable namespaces"): the overlay LCM read key is a `<principal>-project-*`
-   * sub-namespace of the principal SELF base. The normal recall namespace set
-   * below only substitutes the coding overlay when the principal SELF base is
-   * actually in the readable recall set (`recallNamespacesForPrincipal` — gated
-   * by `defaultRecallNamespaces.includes("self")` AND `canReadNamespace`). If a
-   * principal can WRITE but not READ its self namespace (or `defaultRecall-
-   * Namespaces` omits `self`), QMD/file recall never touches those overlay rows,
-   * so neither may the LCM read key. When the self base is NOT readable, fall
-   * back to the default store — exactly what an unqualified, unauthorized recall
-   * resolves to — rather than injecting overlay rows the rest of recall excludes
-   * (rule 42 read/write parity; rule 48 least-privilege).
-   */
-  lcmReadNamespaceForSession(sessionKey, principalOverride) {
-    const principal = typeof principalOverride === "string" && principalOverride.length > 0 ? principalOverride : this.deps.resolvePrincipal(sessionKey);
-    const base = defaultNamespaceForPrincipal(principal, this.deps.config);
-    const overlaid = this.deps.applyCodingNamespaceOverlay(sessionKey, base);
-    if (overlaid === base) return this.deps.config.defaultNamespace;
-    const selfReadableInRecall = recallNamespacesForPrincipal(
-      principal,
-      this.deps.config
-    ).includes(base);
-    return selfReadableInRecall ? overlaid : this.deps.config.defaultNamespace;
-  }
-  /**
-   * Attach a coding-agent context to a session (issue #569). Called by the
-   * Claude Code / Codex / Cursor connectors at session start after
-   * `resolveGitContext(cwd)`. The context is consulted by the recall path
-   * and the write path so that memories route to a project- (and optionally
-   * branch-) scoped namespace.
-   *
-   * Pass `null` to clear.
-   */
-  setCodingContextForSession(sessionKey, codingContext) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return;
-    this.deps.ensureSessionBindingMaps();
-    if (codingContext === null) {
-      this.deps._codingContextBySession.delete(sessionKey);
-      return;
-    }
-    this.deps._codingContextBySession.set(sessionKey, codingContext);
-  }
-  /**
-   * Read-only accessor for the coding context attached to a session. Returns
-   * `null` when none is set. Used by `remnic doctor` and by tests.
-   *
-   * Defensive `_codingContextBySession` lookup — legacy orchestrator-flush
-   * tests use `Object.create(Orchestrator.prototype)` which does not run
-   * class-field initializers, so the Map may be undefined on stubs.
-   */
-  getCodingContextForSession(sessionKey) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return null;
-    return this.deps._codingContextBySession?.get(sessionKey) ?? null;
-  }
-  /**
-   * Shared helper used by both the recall path and the write path (rule 42).
-   *
-   * Given a base namespace computed from the principal, returns the overlaid
-   * coding namespace when the session has a coding context AND
-   * `codingMode.projectScope` is true AND `namespacesEnabled` is true.
-   * Otherwise returns `baseNamespace` unchanged — CLAUDE.md #30 escape hatch.
-   *
-   * Principal isolation (CLAUDE.md rule 42): the overlay is COMBINED with
-   * the principal-derived `baseNamespace` rather than replacing it, so two
-   * principals working in the same repository do not share memories through
-   * a common `project-*` namespace.
-   *
-   * Namespaces-disabled gate: when `namespacesEnabled` is false, the
-   * storage router maps every namespace to the same `memoryDir`. Returning
-   * `project-*` in that mode would create apparent route separation with
-   * no actual storage isolation — a false-isolation trap. In that mode we
-   * return `baseNamespace` unchanged so coding mode degrades to the existing
-   * unscoped behavior.
-   *
-   * @internal
-   */
-  applyCodingNamespaceOverlay(sessionKey, baseNamespace) {
-    if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return baseNamespace;
-    const codingContext = this.deps.getCodingContextForSession(sessionKey);
-    const overlay = resolveCodingNamespaceOverlay(codingContext, this.deps.config.codingMode, this.deps.config.defaultNamespace);
-    if (!overlay) return baseNamespace;
-    return combineNamespaces(baseNamespace, overlay.namespace);
-  }
-  /**
-   * Register a peer ID for a session so recall can inject the peer's
-   * profile into context (issue #679 PR 3/5). Pass `null` to clear.
-   *
-   * Connectors and the `before_agent_start` hook call this when the
-   * session's counter-party is known. The ID is validated against
-   * `PEER_ID_PATTERN` before storing.
-   *
-   * Fail-closed (Codex P1 review): an invalid peerId clears any
-   * previously registered mapping for the session rather than silently
-   * keeping stale data. This prevents a malformed metadata update from
-   * mixing one peer's profile context into another session.
-   *
-   * Defensive init (Cursor review + rule 16): `Object.create(
-   * Orchestrator.prototype)` stubs in legacy tests skip class-field
-   * initializers, so `_peerIdBySession` may be undefined. Mirror the
-   * same guard used by `setCodingContextForSession`.
-   */
-  setPeerIdForSession(sessionKey, peerId) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return;
-    this.deps.ensureSessionBindingMaps();
-    if (peerId === null) {
-      this.deps._peerIdBySession.delete(sessionKey);
-      return;
-    }
-    if (typeof peerId !== "string" || peerId.length === 0 || peerId.length > 64 || !/^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$/.test(peerId)) {
-      log.warn(`setPeerIdForSession: invalid peerId \u2014 clearing session mapping`);
-      this.deps._peerIdBySession.delete(sessionKey);
-      return;
-    }
-    this.deps._peerIdBySession.set(sessionKey, peerId);
-  }
-  /**
-   * Return the peer ID registered for a session, or `null` when none
-   * is set. Used by `recallInternal` to inject the peer profile section.
-   * Defensive `_peerIdBySession` lookup — legacy orchestrator-flush tests
-   * use `Object.create(Orchestrator.prototype)` which skips class-field
-   * initializers, so the Map may be undefined on stubs.
-   */
-  getPeerIdForSession(sessionKey) {
-    if (typeof sessionKey !== "string" || sessionKey.length === 0) return null;
-    return this.deps._peerIdBySession?.get(sessionKey) ?? null;
-  }
-  async runDeepSleepGovernanceNow(options) {
-    const targetStorage = options?.storage ?? this.deps.storage;
-    const { runMemoryGovernance } = await import("./maintenance/memory-governance.js");
-    const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-567VKVOU.js");
-    const govResult = await runMemoryGovernance({
-      memoryDir: targetStorage.dir,
-      mode: options?.dryRun === true ? "shadow" : "apply"
-    });
-    if (options?.dryRun !== true) {
-      try {
-        await this.deps.entitySynthesisCoordinator.processQueue(
-          this.deps.storageDirNamespace(targetStorage.dir),
-          5
-        );
-      } catch (error) {
-        log.debug(`deep-sleep governance: entity synthesis refresh failed after apply: ${error}`);
-      }
-    }
-    return summarizeGovernanceResultForDreams(govResult, options?.dryRun === true);
-  }
-  async generateDaySummary(memories) {
-    if (this.deps.initPromise) {
-      let initGateTimeoutHandle;
-      try {
-        await Promise.race([
-          this.deps.initPromise.catch(() => void 0),
-          new Promise((resolve) => {
-            initGateTimeoutHandle = setTimeout(
-              resolve,
-              this.deps.config.initGateTimeoutMs
-            );
-          })
-        ]);
-      } finally {
-        if (initGateTimeoutHandle) clearTimeout(initGateTimeoutHandle);
-      }
-    }
-    return this.deps.extraction.generateDaySummary(memories);
-  }
-  async flushSession(sessionKey, options) {
-    if (typeof this.deps.buffer.flushPendingSave === "function") {
-      await this.deps.buffer.flushPendingSave({ throwOnFailure: true });
-    }
-    const explicitBufferKey = typeof options.bufferKey === "string" && options.bufferKey.length > 0 ? options.bufferKey : null;
-    const discoveredBufferKeys = explicitBufferKey || typeof sessionKey !== "string" || sessionKey.length === 0 || typeof this.deps.buffer.findBufferKeysForSession !== "function" ? [] : await this.deps.buffer.findBufferKeysForSession(sessionKey);
-    const bufferKeys = explicitBufferKey ? [explicitBufferKey] : discoveredBufferKeys.length > 0 ? discoveredBufferKeys : typeof sessionKey === "string" && sessionKey.length > 0 ? [sessionKey] : ["default"];
-    for (const bufferKey of bufferKeys) {
-      const turns = this.deps.buffer.getTurns(bufferKey);
-      if (turns.length === 0) continue;
-      await new Promise((resolve, reject) => {
-        void this.deps.queueBufferedExtraction(turns, "trigger_mode", {
-          bufferKey,
-          clearBufferAfterExtraction: true,
-          skipDedupeCheck: true,
-          forceExtractionAttempt: true,
-          abortSignal: options.abortSignal,
-          onTaskSettled: (error) => error ? reject(error) : resolve()
-        }).catch(reject);
-      });
-    }
-  }
-  /** Lazily construct the CorrectionService for passive capture. Stateless
-   *  across requests (per #1580 design); cached for the orchestrator's life. */
-  passiveCorrectionService() {
-    if (this.deps._passiveCorrectionService) return this.deps._passiveCorrectionService;
-    this.deps._passiveCorrectionService = createCorrectionService({
-      orchestrator: this.deps.orchestratorSelf,
-      // Session-scoped write ACL (review: "passive capture bypasses write
-      // ACL"). A correction detected in session S plans only against S readable
-      // namespaces and applies only to writable ones (rule 42) — passive
-      // capture never becomes a cross-tenant mutation vector. Mirrors the
-      // access-service createCorrectionService wiring rather than bypassing it.
-      resolveAuthorizedNamespace: async (req) => {
-        const principal = req.principal || resolvePrincipal(req.sessionKey, this.deps.config);
-        const ns = req.namespace ?? defaultNamespaceForPrincipal(principal, this.deps.config);
-        if (!canWriteNamespace(principal, ns, this.deps.config)) {
-          throw new Error(
-            `passive correction: namespace "${ns}" is not writable for principal ${principal ?? "(none)"}`
-          );
-        }
-        return ns;
-      },
-      resolveReadableNamespaces: (req) => {
-        const principal = req.principal || resolvePrincipal(req.sessionKey, this.deps.config);
-        return recallNamespacesForPrincipal(principal, this.deps.config);
-      },
-      canWriteNamespace: async (req) => {
-        const principal = req.principal || resolvePrincipal(req.sessionKey, this.deps.config);
-        return canWriteNamespace(principal, req.namespace, this.deps.config);
-      },
-      llmComplete: async ({ system, user }) => {
-        const llmResult = await this.deps.localLlm.chatCompletion(
-          [
-            { role: "system", content: system },
-            { role: "user", content: user }
-          ],
-          { operation: "correction-classify", priority: "background" }
-        );
-        if (!llmResult) {
-          throw new Error(
-            "passive correction classify+draft: local LLM unavailable (disabled or in cooldown)"
-          );
-        }
-        return llmResult.content;
-      }
-    });
-    return this.deps._passiveCorrectionService;
-  }
-};
-
 // src/orchestration/recall-background-writes.ts
 var pendingWritesByOwner = /* @__PURE__ */ new WeakMap();
 function trackRecallWrite(owner, promise, label) {
@@ -17611,7 +16154,7 @@ var Orchestrator = class {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path17.resolve(storageDir);
+    const resolvedStorageDir = path16.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -17622,21 +16165,21 @@ var Orchestrator = class {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path17.resolve(storageDir);
-    const resolvedMemoryDir = path17.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path16.resolve(storageDir);
+    const resolvedMemoryDir = path16.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path17.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path16.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path17.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path17.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path16.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path16.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path17.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path16.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path17.basename(resolvedStorageDir);
+    const leaf = path16.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -17772,7 +16315,7 @@ var Orchestrator = class {
     StorageManager.setScopedCacheInvalidationDefault(config.memoryDir, scopedCacheInvalidationEnabled);
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path17.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path16.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -17859,7 +16402,7 @@ var Orchestrator = class {
     this.compounding = resolveConsolidationCapabilities(config).compounding ? new CompoundingEngine(config, this.storage) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path17.join(
+    this.conversationIndexDir = path16.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -18006,7 +16549,7 @@ var Orchestrator = class {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path17.join(config.memoryDir, "threads"),
+      path16.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -18086,7 +16629,7 @@ var Orchestrator = class {
       utilityPromoteThresholdDelta: this.utilityRuntimeValues?.promoteThresholdDelta ?? 0,
       utilityDemoteThresholdDelta: this.utilityRuntimeValues?.demoteThresholdDelta ?? 0
     };
-    return createHash8("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
+    return createHash6("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
   }
   effectiveLifecycleThresholds() {
     const archiveDecayThreshold = this.config.lifecycleArchiveDecayThreshold;
@@ -20112,9 +18655,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path32 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path31 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
   const kind = typeof rec.kind === "string" && rec.kind.length > 0 ? rec.kind : void 0;
-  const item = path32 !== void 0 && kind !== void 0 ? { symbol, path: path32, kind } : path32 !== void 0 ? { symbol, path: path32 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path31 !== void 0 && kind !== void 0 ? { symbol, path: path31, kind } : path31 !== void 0 ? { symbol, path: path31 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -20188,7 +18731,7 @@ var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
 import fsp from "fs/promises";
-import path18 from "path";
+import path17 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -20196,19 +18739,19 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = path18.resolve(basePath);
+    this.basePath = path17.resolve(basePath);
   }
   resolveRemotePath(remotePath) {
-    const resolved = path18.isAbsolute(remotePath) ? path18.resolve(remotePath) : path18.resolve(this.basePath, remotePath);
-    const relative = path18.relative(this.basePath, resolved);
-    if (relative === ".." || relative.startsWith(`..${path18.sep}`) || path18.isAbsolute(relative)) {
+    const resolved = path17.isAbsolute(remotePath) ? path17.resolve(remotePath) : path17.resolve(this.basePath, remotePath);
+    const relative = path17.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return resolved;
   }
   isInsideBase(candidate, realBase) {
-    const relative = path18.relative(realBase, candidate);
-    return relative === "" || relative !== ".." && !relative.startsWith(`..${path18.sep}`) && !path18.isAbsolute(relative);
+    const relative = path17.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path17.sep}`) && !path17.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
@@ -20237,13 +18780,13 @@ var FilesystemBackend = class {
   }
   async ensureSafeParentDirectory(dest) {
     const realBase = await this.ensureBaseDirectory();
-    const destDir = path18.dirname(dest);
-    const relativeDir = path18.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path18.sep);
+    const destDir = path17.dirname(dest);
+    const relativeDir = path17.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path17.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path18.join(current, segment);
+      current = path17.join(current, segment);
       try {
         const stat5 = await fsp.lstat(current);
         if (stat5.isSymbolicLink()) {
@@ -20271,13 +18814,13 @@ var FilesystemBackend = class {
     if (realBase === null) {
       return null;
     }
-    const destDir = path18.dirname(dest);
-    const relativeDir = path18.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path18.sep);
+    const destDir = path17.dirname(dest);
+    const relativeDir = path17.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path17.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path18.join(current, segment);
+      current = path17.join(current, segment);
       let stat5;
       try {
         stat5 = await fsp.lstat(current);
@@ -20325,7 +18868,7 @@ var FilesystemBackend = class {
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path18.isAbsolute(remotePath)) {
+    if (path17.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
@@ -20398,7 +18941,7 @@ function createBackend(cfg) {
 
 // src/binary-lifecycle/scanner.ts
 import fsp2 from "fs/promises";
-import path19 from "path";
+import path18 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -20423,8 +18966,8 @@ async function scanForBinaries(memoryDir, config, manifest) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path19.join(dir, entry.name);
-      const relativePath = path19.relative(memoryDir, fullPath).split(path19.sep).join("/");
+      const fullPath = path18.join(dir, entry.name);
+      const relativePath = path18.relative(memoryDir, fullPath).split(path18.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -20464,15 +19007,15 @@ async function hashFile(filePath) {
 
 // src/binary-lifecycle/manifest.ts
 import fsp3 from "fs/promises";
-import path20 from "path";
+import path19 from "path";
 import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
-  return path20.join(memoryDir, MANIFEST_DIR);
+  return path19.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path20.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path19.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
@@ -20524,12 +19067,12 @@ function emptyManifest() {
 
 // src/binary-lifecycle/pipeline.ts
 import fsp4 from "fs/promises";
-import path21 from "path";
+import path20 from "path";
 import crypto3 from "crypto";
 function isRecallCorpusMarkdown(mdPath, memoryDir) {
-  const rel = path21.relative(memoryDir, mdPath);
-  if (rel.startsWith("..") || path21.isAbsolute(rel)) return false;
-  const top = rel.split(path21.sep)[0];
+  const rel = path20.relative(memoryDir, mdPath);
+  if (rel.startsWith("..") || path20.isAbsolute(rel)) return false;
+  const top = rel.split(path20.sep)[0];
   return RECALL_FALLBACK_DIRS.includes(top);
 }
 async function hashFile2(filePath) {
@@ -20553,13 +19096,13 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function resolveManifestAssetPath(memoryDir, originalPath) {
-  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path21.isAbsolute(originalPath) || path21.win32.isAbsolute(originalPath)) {
+  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path20.isAbsolute(originalPath) || path20.win32.isAbsolute(originalPath)) {
     return null;
   }
-  const memoryRoot = path21.resolve(memoryDir);
-  const fullPath = path21.resolve(memoryRoot, originalPath);
-  const relative = path21.relative(memoryRoot, fullPath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path21.sep}`) || path21.isAbsolute(relative)) {
+  const memoryRoot = path20.resolve(memoryDir);
+  const fullPath = path20.resolve(memoryRoot, originalPath);
+  const relative = path20.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path20.sep}`) || path20.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -20570,7 +19113,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path21.sep).join("/");
+  const normalized = relPath.split(path20.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -20583,11 +19126,11 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
   for (const relPath of newPaths) {
-    const fullPath = path21.join(memoryDir, relPath);
+    const fullPath = path20.join(memoryDir, relPath);
     try {
       const stat5 = await fsp4.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path21.extname(relPath);
+      const ext = path20.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -20790,10 +19333,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path21.dirname(mdPath);
+  const mdDir = path20.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path21.sep).join("/");
+    const normalized = candidate.split(path20.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -20801,10 +19344,10 @@ function markdownReferencePattern(asset, assetAbsolute, mdPath) {
       candidates.add(`./${normalized}`);
     }
   };
-  addCandidate(path21.relative(mdDir, assetAbsolute));
-  const originalPath = asset.originalPath.split(path21.sep).join("/");
-  const originalAsFileRelative = path21.resolve(mdDir, ...originalPath.split("/"));
-  if (path21.resolve(originalAsFileRelative) === path21.resolve(assetAbsolute)) {
+  addCandidate(path20.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path20.sep).join("/");
+  const originalAsFileRelative = path20.resolve(mdDir, ...originalPath.split("/"));
+  if (path20.resolve(originalAsFileRelative) === path20.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -20900,7 +19443,7 @@ async function findMarkdownFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path21.join(current, entry.name);
+      const full = path20.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -20975,7 +19518,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path22 from "path";
+import path21 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -20990,8 +19533,8 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  const resolvedMemoryDir = path22.resolve(memoryDir);
-  const resolvedOutputDir = path22.resolve(outputDir);
+  const resolvedMemoryDir = path21.resolve(memoryDir);
+  const resolvedOutputDir = path21.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -21029,7 +19572,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path22.join(memoryDir, "entities");
+    const entitiesDir = path21.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -21041,7 +19584,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path22.basename(filePath, ".md");
+        const fileName = path21.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -21053,7 +19596,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path22.join(memoryDir, "questions");
+    const questionsDir = path21.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -21094,8 +19637,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path22.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path22.isAbsolute(relative);
+  const relative = path21.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -21132,12 +19675,12 @@ function assertSafeInputRoot(realMemoryDir, targetPath, label) {
 }
 function assertSafeOutputTarget(realOutputDir, outputPath) {
   let current = realOutputDir;
-  const relative = path22.relative(realOutputDir, outputPath);
-  if (relative.startsWith("..") || path22.isAbsolute(relative)) {
+  const relative = path21.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path21.isAbsolute(relative)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
-  for (const segment of relative.split(path22.sep).filter(Boolean)) {
-    current = path22.join(current, segment);
+  for (const segment of relative.split(path21.sep).filter(Boolean)) {
+    current = path21.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -21167,17 +19710,17 @@ function validateProjectionCategories(categories) {
   return validated;
 }
 function resolveContainedOutputPath(outputRoot, ...segments) {
-  const resolved = path22.resolve(outputRoot, ...segments);
-  const relative = path22.relative(outputRoot, resolved);
-  if (relative === "" || !relative.startsWith("..") && !path22.isAbsolute(relative)) {
+  const resolved = path21.resolve(outputRoot, ...segments);
+  const relative = path21.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path21.isAbsolute(relative)) {
     return resolved;
   }
   throw new Error(`context tree output path escapes outputDir: ${segments.join("/")}`);
 }
 function writeProjectedContent(realOutputDir, outputPath, generatedContent) {
   assertSafeOutputTarget(realOutputDir, outputPath);
-  fs.mkdirSync(path22.dirname(outputPath), { recursive: true });
-  const realParent = fs.realpathSync(path22.dirname(outputPath));
+  fs.mkdirSync(path21.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path21.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -21216,7 +19759,7 @@ function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path22.join(directory, entry.name);
+      const fullPath = path21.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -21269,13 +19812,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path22.basename(filePath, ".md");
-  const dateDir = path22.basename(path22.dirname(filePath));
+  const fileName = path21.basename(filePath, ".md");
+  const dateDir = path21.basename(path21.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path22.join(category, dateDir, `${fileName}.md`);
+    relPath = path21.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path22.join(category, `${fileName}.md`);
+    relPath = path21.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -21321,7 +19864,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path22.join("entities", `${fileName}.md`),
+    path: path21.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -21374,7 +19917,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path23 from "path";
+import path22 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -21476,7 +20019,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path23.resolve(options.directory ?? process.cwd());
+  const directory = path22.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -21518,7 +20061,7 @@ function walkDir(root, exclude, maxDepth) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path23.join(dir, entry.name);
+      const fullPath = path22.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -21533,11 +20076,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path23.extname(f).toLowerCase();
+    const ext = path22.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path23.dirname(f) === root).map((f) => path23.basename(f))
+    files.filter((f) => path22.dirname(f) === root).map((f) => path22.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -21581,7 +20124,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path23.dirname(f) === root).map((f) => path23.basename(f))
+    files.filter((f) => path22.dirname(f) === root).map((f) => path22.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -21592,7 +20135,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path23.join(root, "package.json"));
+    const pkg = readJsonSafe(path22.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -21606,13 +20149,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path23.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path22.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path23.join(root, "package.json"));
+    const pkg = readJsonSafe(path22.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -21646,8 +20189,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path23.basename(filePath).toLowerCase();
-    const relPath = path23.relative(root, filePath);
+    const basename = path22.basename(filePath).toLowerCase();
+    const relPath = path22.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -21659,7 +20202,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path23.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path22.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -21680,7 +20223,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path23.sep);
+  const parts = relPath.split(path22.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -21724,7 +20267,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path24 from "path";
+import path23 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -21815,12 +20358,12 @@ function resolveTargets(targetPath) {
   const extensions = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
   function walk(dir) {
     for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-      const fullPath = path24.join(dir, entry.name);
+      const fullPath = path23.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path24.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path23.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -21829,12 +20372,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path24.resolve(targetPath);
+  const resolvedTarget = path23.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path24.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path23.dirname(resolvedTarget) : resolvedTarget;
 }
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path24.relative(projectRoot, path24.resolve(filePath)) || path24.basename(filePath);
+  const relativePath = path23.relative(projectRoot, path23.resolve(filePath)) || path23.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);
@@ -21928,7 +20471,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs3.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path24.join(memoryDir, dir);
+    const fullDir = path23.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -21950,10 +20493,10 @@ function writeStatement(stmt, memoryDir) {
   const now = /* @__PURE__ */ new Date();
   const dateDir = now.toISOString().split("T")[0];
   const categoryDir = getCategoryDir(memoryDir, stmt.category);
-  const dir = path24.join(categoryDir, dateDir);
+  const dir = path23.join(categoryDir, dateDir);
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path24.join(dir, fileName);
+  const filePath = path23.join(dir, fileName);
   const frontmatter = [
     "---",
     `id: ${stmt.id}`,
@@ -22021,7 +20564,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path24.join(dir, entry.name);
+    const fullPath = path23.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -22032,7 +20575,7 @@ function walkFiles(dir, callback) {
 
 // src/dedup/index.ts
 import fs4 from "fs";
-import path25 from "path";
+import path24 from "path";
 import crypto5 from "crypto";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_LOAD = 1e4;
@@ -22174,7 +20717,7 @@ function loadMemories(memoryDir, categories, maxLoad = 1e4) {
   const memoryRootReal = fs4.realpathSync(memoryDir);
   for (const category of allCategories) {
     if (result.length >= maxLoad) break;
-    const dir = path25.join(memoryDir, category);
+    const dir = path24.join(memoryDir, category);
     if (!fs4.existsSync(dir)) continue;
     const categoryStat = fs4.lstatSync(dir);
     if (categoryStat.isSymbolicLink()) {
@@ -22235,15 +20778,15 @@ function extractBody3(content) {
   return match ? match[1].trim() : content.trim();
 }
 function assertPathInsideRoot2(rootReal, targetReal, sourcePath) {
-  const rel = path25.relative(rootReal, targetReal);
-  if (rel === "" || !rel.startsWith("..") && !path25.isAbsolute(rel)) {
+  const rel = path24.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path24.isAbsolute(rel)) {
     return;
   }
   throw new Error(`Refusing to scan memory path outside root: ${sourcePath}`);
 }
 function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
   for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path25.join(dir, entry.name);
+    const fullPath = path24.join(dir, entry.name);
     const entryStat = fs4.lstatSync(fullPath);
     if (entryStat.isSymbolicLink()) {
       throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
@@ -22261,7 +20804,7 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
 
 // src/review/index.ts
 import fs5 from "fs";
-import path26 from "path";
+import path25 from "path";
 var DEFAULT_CONFIDENCE_THRESHOLD = 0.7;
 function realMemoryRoot(memoryDir) {
   try {
@@ -22273,8 +20816,8 @@ function realMemoryRoot(memoryDir) {
   }
 }
 function isPathInside2(rootReal, candidateReal) {
-  const relative = path26.relative(rootReal, candidateReal);
-  return relative === "" || !!relative && !relative.startsWith("..") && !path26.isAbsolute(relative);
+  const relative = path25.relative(rootReal, candidateReal);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path25.isAbsolute(relative);
 }
 function isSafeDirectory(rootReal, dir) {
   try {
@@ -22317,7 +20860,7 @@ function listReviewItems(options) {
     if (filterReason && item.reviewReason !== filterReason) return;
     items.push(item);
   };
-  const suggestionsDir = path26.join(memoryDir, "suggestions");
+  const suggestionsDir = path25.join(memoryDir, "suggestions");
   if (!isLimitReached() && fs5.existsSync(suggestionsDir) && isSafeDirectory(rootReal, suggestionsDir)) {
     walkMd(rootReal, suggestionsDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -22338,7 +20881,7 @@ function listReviewItems(options) {
       return isLimitReached();
     });
   }
-  const reviewDir = path26.join(memoryDir, "review");
+  const reviewDir = path25.join(memoryDir, "review");
   if (!isLimitReached() && fs5.existsSync(reviewDir) && isSafeDirectory(rootReal, reviewDir)) {
     walkMd(rootReal, reviewDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -22363,7 +20906,7 @@ function listReviewItems(options) {
   const categories = ALL_CATEGORY_DIRS;
   for (const category of categories) {
     if (isLimitReached()) break;
-    const dir = path26.join(memoryDir, category);
+    const dir = path25.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     walkMd(rootReal, dir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -22443,8 +20986,8 @@ function approveItem(memoryDir, itemId, options) {
   const targetDir = getCategoryDir(memoryDir, category);
   const dateDir = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   ensureSafeDirectory(rootReal, targetDir);
-  const outputPath = path26.join(targetDir, dateDir, path26.basename(found.filePath));
-  ensureSafeDirectory(rootReal, path26.dirname(outputPath));
+  const outputPath = path25.join(targetDir, dateDir, path25.basename(found.filePath));
+  ensureSafeDirectory(rootReal, path25.dirname(outputPath));
   const promotedPath = writeFileWithoutClobber(outputPath, updatedContent, itemId);
   fs5.unlinkSync(found.filePath);
   return {
@@ -22502,13 +21045,13 @@ function findReviewFileById(memoryDir, id, options = {}) {
   const rootReal = realMemoryRoot(memoryDir);
   if (!rootReal) return null;
   for (const loc of ["suggestions", "review"]) {
-    const dir = path26.join(memoryDir, loc);
+    const dir = path25.join(memoryDir, loc);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id);
     if (found) return { filePath: found, location: "queue" };
   }
   for (const category of ALL_CATEGORY_DIRS) {
-    const dir = path26.join(memoryDir, category);
+    const dir = path25.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id, (fm) => isLowConfidenceReviewCandidate(fm, options));
     if (found) return { filePath: found, location: "category" };
@@ -22584,10 +21127,10 @@ function readFileSafe3(filePath) {
   }
 }
 function writeFileWithoutClobber(basePath, content, discriminator) {
-  const parsed = path26.parse(basePath);
+  const parsed = path25.parse(basePath);
   const safeDiscriminator = sanitizeFilePart(discriminator);
   for (let attempt = 0; attempt < 1e3; attempt++) {
-    const candidate = attempt === 0 ? basePath : path26.join(
+    const candidate = attempt === 0 ? basePath : path25.join(
       parsed.dir,
       `${parsed.name}-${safeDiscriminator}${attempt === 1 ? "" : `-${attempt}`}${parsed.ext || ".md"}`
     );
@@ -22643,7 +21186,7 @@ function extractBody4(content) {
 function walkMd(rootReal, dir, callback) {
   if (!isSafeDirectory(rootReal, dir)) return false;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path26.join(dir, entry.name);
+    const fullPath = path25.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       if (walkMd(rootReal, fullPath, callback)) return true;
@@ -22658,7 +21201,7 @@ function walkMdPaths(rootReal, dir) {
   const results = [];
   if (!isSafeDirectory(rootReal, dir)) return results;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path26.join(dir, entry.name);
+    const fullPath = path25.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       results.push(...walkMdPaths(rootReal, fullPath));
@@ -22671,7 +21214,7 @@ function walkMdPaths(rootReal, dir) {
 
 // src/sync/index.ts
 import fs6 from "fs";
-import path27 from "path";
+import path26 from "path";
 import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -22693,7 +21236,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path27.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path26.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -22709,7 +21252,7 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs6.mkdirSync(path27.dirname(stateFilePath), { recursive: true });
+    fs6.mkdirSync(path26.dirname(stateFilePath), { recursive: true });
     fs6.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -22775,13 +21318,13 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path27.join(dir, entry.name);
+      const fullPath = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path27.extname(entry.name).toLowerCase();
+        const ext = path26.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path27.relative(root, fullPath);
+        const relPath = path26.relative(root, fullPath);
         try {
           const content = fs6.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
@@ -22796,7 +21339,7 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path27.join(sourceDir, relPath);
+    const fullPath = path26.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -22829,7 +21372,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path27.join(sourceDir, relPath),
+        filePath: path26.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -22859,20 +21402,20 @@ function hashContent3(content) {
 import { spawnSync } from "child_process";
 import crypto7 from "crypto";
 import fs7 from "fs";
-import path28 from "path";
+import path27 from "path";
 var MANIFEST_VERSION = 1;
 var MANIFEST_LOCK_STALE_MS = 3e4;
 var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
 var MANIFEST_LOCK_SLEEP_MS = 20;
 function normalizeSpaceMemoryDir(memoryDir) {
-  return path28.resolve(memoryDir);
+  return path27.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path28.join(homeDir, ".config", "engram", "spaces");
+  return path27.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path28.join(getSpacesDir(baseDir), "manifest.json");
+  return path27.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   if (fs7.existsSync(getManifestPath(baseDir))) {
@@ -22919,9 +21462,9 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path28.dirname(manifestPath2);
+  const manifestDir2 = path27.dirname(manifestPath2);
   fs7.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path28.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const tempPath = path27.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
   try {
     fs7.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
@@ -22936,7 +21479,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs7.mkdirSync(path28.dirname(lockDir), { recursive: true });
+  fs7.mkdirSync(path27.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -22962,7 +21505,7 @@ function acquireManifestLock(lockDir) {
     try {
       fs7.mkdirSync(lockDir, { recursive: false });
       try {
-        fs7.writeFileSync(path28.join(lockDir, "owner"), `${owner}
+        fs7.writeFileSync(path27.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
         fs7.rmSync(lockDir, { recursive: true, force: true });
@@ -22992,7 +21535,7 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path28.join(lockDir, "owner");
+    const ownerPath = path27.join(lockDir, "owner");
     if (fs7.readFileSync(ownerPath, "utf8").trim() === owner) {
       fs7.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -23008,7 +21551,7 @@ function removeStaleManifestLock(lockDir) {
   try {
     fs7.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs7.writeFileSync(path28.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs7.writeFileSync(path27.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
       fs7.rmSync(reclaimDir, { recursive: true, force: true });
@@ -23083,7 +21626,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs7.readFileSync(path28.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs7.readFileSync(path27.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -23155,8 +21698,8 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path28.join(homeDir, ".engram", "memory");
-  const openclawPath = path28.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const standalonePath = path27.join(homeDir, ".engram", "memory");
+  const openclawPath = path27.join(homeDir, ".openclaw", "workspace", "memory", "local");
   const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs7.existsSync(standalonePath) ? standalonePath : fs7.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -23185,7 +21728,7 @@ function createSpace(options) {
   const id = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const memoryDir = normalizeSpaceMemoryDir(
-    options.memoryDir ?? path28.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path27.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -23406,14 +21949,14 @@ function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path28.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path27.join(getSpacesDir(baseDir), "audit.jsonl");
   if (!fs7.existsSync(auditPath)) return [];
   const lines = fs7.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path28.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs7.mkdirSync(path28.dirname(auditPath), { recursive: true });
+  const auditPath = path27.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs7.mkdirSync(path27.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -23445,8 +21988,8 @@ function copyMemories(sourceDir, targetDir, options) {
       continue;
     }
     const content = fs7.readFileSync(sourcePath, "utf8");
-    const relativePath = path28.relative(sourceRoot, sourceRealPath);
-    const targetPath = path28.resolve(targetRoot, relativePath);
+    const relativePath = path27.relative(sourceRoot, sourceRealPath);
+    const targetPath = path27.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
@@ -23488,8 +22031,8 @@ function copyMemories(sourceDir, targetDir, options) {
       skipped++;
       continue;
     }
-    fs7.mkdirSync(path28.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path28.dirname(targetPath));
+    fs7.mkdirSync(path27.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path27.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
@@ -23507,7 +22050,7 @@ function walkMd2(dir) {
   const results = [];
   function walk(d) {
     for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path28.join(d, entry.name);
+      const fullPath = path27.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -23536,8 +22079,8 @@ function safeRealpath(filePath) {
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path28.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path28.isAbsolute(relative);
+  const relative = path27.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path27.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -23657,22 +22200,22 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 
 // src/memory-extension/codex-publisher.ts
 import fs8 from "fs";
-import os2 from "os";
-import path29 from "path";
+import os from "os";
+import path28 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
-  return env.HOME?.trim() || env.USERPROFILE?.trim() || os2.homedir();
+  return env.HOME?.trim() || env.USERPROFILE?.trim() || os.homedir();
 }
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path29.join(homeDir, input.slice(2));
+    return path28.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path29.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path28.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -23686,12 +22229,12 @@ var CodexMemoryExtensionPublisher = class {
   async resolveExtensionRoot(env) {
     const homeDir = resolveEnvHome(env);
     const codexHomeInput = env === void 0 ? readEnvVar("CODEX_HOME")?.trim() : env.CODEX_HOME?.trim();
-    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path29.resolve(homeDir, ".codex");
-    return path29.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path28.resolve(homeDir, ".codex");
+    return path28.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path29.join(resolveHomeDir(), ".codex");
+      const home = readEnvVar("CODEX_HOME")?.trim() || path28.join(resolveHomeDir(), ".codex");
       return fs8.existsSync(home);
     } catch {
       return false;
@@ -23742,7 +22285,7 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path29.join(extensionRoot, "instructions.md");
+    const instructionsPath = path28.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -24116,9 +22659,9 @@ async function generateActivityMemories(date, digestBody, config, deps) {
 }
 
 // src/session-summaries/index.ts
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { lstat as lstat2, mkdir as mkdir7, readFile as readFile6, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path30 from "path";
+import path29 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -24618,12 +23161,12 @@ var DEFAULT_MAX_FILES = 5e3;
 var DEFAULT_MAX_SESSIONS = 500;
 var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".jsonl"]);
 function shortHash(value, length = 16) {
-  return createHash9("sha256").update(value).digest("hex").slice(0, length);
+  return createHash7("sha256").update(value).digest("hex").slice(0, length);
 }
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path30.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path29.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -24633,13 +23176,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path30.join(dir, entry.name);
+      const fullPath = path29.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path30.extname(entry.name).toLowerCase();
+      const ext = path29.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -24666,7 +23209,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path30.resolve(expandTildePath(inputDir.trim()));
+  return path29.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -24823,11 +23366,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path30.extname(filePath).toLowerCase();
+    const fileExtension = path29.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path30.basename(filePath),
+        fileName: path29.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -24883,7 +23426,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile6(path30.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile6(path29.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");
@@ -24896,15 +23439,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path30.join(
-    path30.resolve(expandTildePath(memoryDir)),
+  return path29.join(
+    path29.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path30.dirname(filePath), { recursive: true });
+  await mkdir7(path29.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -24922,7 +23465,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path30.resolve(expandTildePath(options.output));
+    const outputPath = path29.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -24957,19 +23500,19 @@ async function runLocalSessionSummaryCliCommand(options) {
 
 // src/transfer/capsule-fork.ts
 import { lstat as lstat3, mkdir as mkdir8, readFile as readFile7, realpath as realpath2, writeFile as writeFile8 } from "fs/promises";
-import path31 from "path";
+import path30 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path31.resolve(opts.targetRoot);
+  const rootAbs = path30.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path31.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path30.join(rootAbs, "forks", opts.forkId);
   const forkEntryExists = await pathEntryExists(forkDirAbs);
   if (forkEntryExists) {
     throw new Error(
       `forkCapsule: fork path already exists \u2014 forkId "${opts.forkId}" is already in use at: ${forkDirAbs}`
     );
   }
-  const archiveAbs = path31.resolve(opts.sourceArchive);
+  const archiveAbs = path30.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -24991,10 +23534,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path31.join(forkDirAbs, "lineage.json");
+  const lineagePath = path30.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath2(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path31.dirname(lineagePath), { recursive: true });
+  await mkdir8(path30.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -25008,11 +23551,11 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path31.resolve(targetRoot);
+  const rootAbs = path30.resolve(targetRoot);
   const rootReal = await realpath2(rootAbs).catch(() => rootAbs);
-  const lineagePath = path31.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path31.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path31.isAbsolute(rel)) {
+  const lineagePath = path30.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path30.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path30.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -25053,60 +23596,23 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path31.dirname(existing)) {
+  while (existing !== path30.dirname(existing)) {
     const st = await lstat3(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path31.basename(existing));
-    existing = path31.dirname(existing);
+    suffix.unshift(path30.basename(existing));
+    existing = path30.dirname(existing);
   }
   const existingReal = await realpath2(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path31.join(existingReal, ...suffix) : existingReal;
-  const rel = path31.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path30.join(existingReal, ...suffix) : existingReal;
+  const rel = path30.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path31.sep}`)) return false;
-  if (path31.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path30.sep}`)) return false;
+  if (path30.isAbsolute(rel)) return false;
   return true;
 }
 
 export {
-  BulkImportBatchPartialFailureError,
-  mapRecallSourceToXrayServedBy,
-  throwIfRecallAborted,
-  raceRecallAbort,
-  COMPACTION_SIGNAL_MAX_AGE_MS,
-  normalizeIanaTimeZone,
-  formatDateInTimeZone,
-  utcDateKeysForLocalDay,
-  parseFiniteDate,
-  filterHourlySummaryMarkdownForLocalDay,
-  qmdStartupCollectionCheckWithTimeout,
-  defaultWorkspaceDir,
-  sanitizeSessionKeyForFilename,
-  targetSourceValidAtSortMs,
-  splitTurnsBySourceValidAt,
-  isArtifactMemoryPath,
-  buildCompressionGuidelinesMarkdown2 as buildCompressionGuidelinesMarkdown,
-  applyQueryAwareCandidateFilter,
-  tokenizeRecallQuery,
-  shouldFilterLifecycleRecallCandidate,
-  lifecycleRecallScoreAdjustment,
-  computeArtifactRecallLimit,
-  resolveEffectiveRecallMode,
-  resolveRecallModeDecision,
-  resolveRecallModeDecisionAsync,
-  computeArtifactCandidateFetchLimit,
-  computeQmdHybridFetchLimit,
-  summarizeGraphShadowComparison,
-  parseGraphRecallRankedResults,
-  parseMemoryIntentSnapshot,
-  parseQmdRecallResults,
-  mergeArtifactRecallCandidates,
-  resolveRecentThreadMemoryPaths,
-  buildMemoryPathById,
-  appendMemoryToGraphContext,
-  resolvePersistedMemoryRelativePath,
-  deriveTopicsFromExtraction,
   buildProcedureRecallSection,
   RELAY_DEMO_MISSION_ID,
   RELAY_DEMO_NAMESPACE,
@@ -25222,4 +23728,4 @@ export {
   filterRecallCandidates,
   Orchestrator
 };
-//# sourceMappingURL=chunk-PUS63Q3G.js.map
+//# sourceMappingURL=chunk-RUYJ7TWU.js.map