@remnic/core 10.0.66 → 10.0.68

package/dist/{chunk-XMBDI725.js → chunk-FAF4A76Q.js}

@@ -13,7 +13,7 @@ import {
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-HFEGRMFG.js";
+} from "./chunk-JLGBJ4AX.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-5JABRT5G.js";
+} from "./chunk-GHHQLSSY.js";
 import {
   SharedContextManager
 } from "./chunk-5KBIOI4G.js";
@@ -175,7 +175,7 @@ import {
 } from "./chunk-VA3GNAWQ.js";
 import {
   ExtractionEngine
-} from "./chunk-A5FOXI3B.js";
+} from "./chunk-LN4X2NDA.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-JHU4EYDV.js";
@@ -210,7 +210,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-KO224R36.js";
+} from "./chunk-NCZGGGWI.js";
 import {
   planEpisodeWindowsWithFallback
 } from "./chunk-T3GIETKV.js";
@@ -225,7 +225,7 @@ import {
 } from "./chunk-7G5NTS7F.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-WWH7GJ42.js";
+} from "./chunk-OCK4D5PC.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
@@ -234,7 +234,7 @@ import {
   runTimelinePublishCli,
   screenCandidateFact,
   summarizeVaultPublish
-} from "./chunk-KFPJIKUW.js";
+} from "./chunk-75DCOS6I.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
@@ -244,14 +244,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-SHHZWSSE.js";
+} from "./chunk-KZZ5EZ7O.js";
 import {
   ThreadingManager
 } from "./chunk-VHSQU3RO.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-SNS3DWG6.js";
+} from "./chunk-TVE7W67N.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-B2NXOVZN.js";
@@ -264,10 +264,10 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-5ZHFPUBC.js";
+} from "./chunk-MOIJWWNA.js";
 import {
   planNamespaceMaintenance
-} from "./chunk-434E4BTO.js";
+} from "./chunk-HH73M65H.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -296,10 +296,10 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-ECF627KC.js";
+} from "./chunk-AYJQ644F.js";
 import {
   SmartBuffer
-} from "./chunk-3H25IRJJ.js";
+} from "./chunk-4MPAKYZU.js";
 import {
   semanticChunkContent
 } from "./chunk-2GBFKHBZ.js";
@@ -335,7 +335,7 @@ import {
   embeddingsFromCosineHits,
   normalizeConnectorScope,
   runSeedGraduationPass
-} from "./chunk-NM2II57L.js";
+} from "./chunk-PRKNAIGZ.js";
 import {
   compileCorrectionRule,
   correctionsFilePath,
@@ -373,7 +373,7 @@ import {
 } from "./chunk-QW27DOHG.js";
 import {
   MeetingsInputError
-} from "./chunk-3NJJQAL3.js";
+} from "./chunk-H5DIRCZP.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -391,7 +391,7 @@ import {
 } from "./chunk-W7K5BP3M.js";
 import {
   NamespaceCatalog
-} from "./chunk-5UEGL5BF.js";
+} from "./chunk-CI3MAAIY.js";
 import {
   RecallResultFormatter,
   SessionContextCoordinator,
@@ -400,7 +400,7 @@ import {
   detectPassiveCorrections,
   renderSessionExperiencePreview,
   scoreSessionExperienceForPrompt
-} from "./chunk-RAU25Q6J.js";
+} from "./chunk-6WKWL53V.js";
 import {
   importCapsule
 } from "./chunk-QDZWQBLU.js";
@@ -429,7 +429,7 @@ import {
 } from "./chunk-MUHGYV2V.js";
 import {
   buildXraySnapshot
-} from "./chunk-25QK3LR2.js";
+} from "./chunk-7O2MC42R.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -443,7 +443,7 @@ import {
 } from "./chunk-BJLCV2P3.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-BOZQAUAJ.js";
+} from "./chunk-EXQJMFRF.js";
 import {
   ProfilingCollector
 } from "./chunk-DOWACHYO.js";
@@ -466,7 +466,7 @@ import {
 } from "./chunk-NVKO5YKP.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-ZPLQ27MY.js";
+} from "./chunk-5UM4H64E.js";
 import {
   pruneOrphanCueAnchors
 } from "./chunk-LXATZLSC.js";
@@ -480,7 +480,7 @@ import {
   ExtractionDeadlineError,
   ExtractionRunCoordinator,
   classifyExtractionOrigin
-} from "./chunk-QNZPYH36.js";
+} from "./chunk-R2BIVU2Z.js";
 import {
   ARTIFACT_STATUS_CACHE_TTL_MS,
   BulkImportBatchPartialFailureError,
@@ -532,7 +532,7 @@ import {
 } from "./chunk-74AY3S7U.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-E4QIX2OB.js";
+} from "./chunk-IAGVM7EY.js";
 import {
   decideLifecycleTransition,
   resolveLifecycleState
@@ -577,7 +577,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-XVQVF2TK.js";
+} from "./chunk-NHWDTOBN.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -707,7 +707,7 @@ import {
 } from "./chunk-PJKTFXE2.js";
 import {
   confidenceTier
-} from "./chunk-SEA56G6S.js";
+} from "./chunk-V4XE263I.js";
 import {
   extractJsonCandidates
 } from "./chunk-YBA52OKG.js";
@@ -796,6 +796,7 @@ import {
   assertRealpathInsideRoot
 } from "./chunk-GCGJW34D.js";
 import {
+  serializeMutations,
   withHeldFileLock
 } from "./chunk-EBV6VXKF.js";
 import {
@@ -890,7 +891,7 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/orchestrator.ts
-import path23 from "path";
+import path24 from "path";
 import { createHash as createHash10 } from "crypto";
 
 // src/orchestration/buffer-swap.ts
@@ -1077,35 +1078,51 @@ var TierMigrationCoordinator = class {
 
 // src/orchestration/extraction-queue-coordinator.ts
 var ExtractionQueueCoordinator = class {
+  /** Maximum tasks that run at the same time (config `extractionQueueConcurrency`). */
+  concurrency;
   /**
-   * Background serial queue for extractions (agent_end optimization).
-   * Queue stores tasks that resolve when extraction should run.
+   * Background queue for extractions (agent_end optimization). Queue stores
+   * tasks that resolve when extraction should run.
    */
   queue = [];
-  /** Whether the serial drain loop is currently running. */
+  /** Whether the drain loop is currently running. */
   processing = false;
   accepting = true;
-  runningPreempt;
+  /** Buffer keys with a task currently running (per-key exclusion). */
+  activeKeys = /* @__PURE__ */ new Set();
+  /** Preempt slots of the currently running tasks, keyed by slot identity. */
+  preemptSlots = /* @__PURE__ */ new Map();
+  preemptSeq = 0;
+  /** Resolves the processor's park while a new task arrives mid-drain. */
+  wake;
+  constructor(concurrency = 1) {
+    this.concurrency = Number.isInteger(concurrency) && concurrency >= 1 ? concurrency : 1;
+  }
   /** Current queue depth (idle-wait + test seam). */
   get length() {
     return this.queue.length;
   }
-  /** Whether the serial drain loop is currently running (idle-wait + test seam). */
+  /** Whether the drain loop is currently running (idle-wait + test seam). */
   get isProcessing() {
     return this.processing;
   }
+  /** How many tasks may run at once (test seam + diagnostics). */
+  get maxConcurrency() {
+    return this.concurrency;
+  }
   /**
-   * Enqueue a task and start the serial processor if it is idle. This is
+   * Enqueue a task and start the processor when capacity is free. This is
    * the production entry point — the orchestrator's `queueBufferedExtraction`
-   * builds each task closure and hands it here.
+   * builds each task closure and hands it here with its buffer key.
    */
   enqueue(task, options) {
     if (!this.accepting) return false;
+    const entry = { run: task, key: options?.key };
     if (options?.front) {
-      this.preemptRunning();
-      this.queue.unshift(task);
+      this.preemptRunning(options.key);
+      this.queue.unshift(entry);
     } else {
-      this.queue.push(task);
+      this.queue.push(entry);
     }
     if (!this.processing) {
       this.processing = true;
@@ -1113,27 +1130,28 @@ var ExtractionQueueCoordinator = class {
         this.logExtractionQueueFailure(err, "processor");
         this.processing = false;
       });
+    } else {
+      this.wake?.();
     }
     return true;
   }
-  /** Automatic extraction registers this so a fail-closed flush can abort it. */
-  beginPreemptable(abort) {
-    this.runningPreempt = abort;
-  }
-  endPreemptable() {
-    this.runningPreempt = void 0;
-  }
-  preemptRunning() {
-    const abort = this.runningPreempt;
-    this.runningPreempt = void 0;
+  preemptRunning(preferredKey) {
+    const armed = Array.from(this.preemptSlots.values()).filter((slot) => slot.armed !== void 0);
+    if (armed.length === 0) return;
+    const preferred = preferredKey !== void 0 ? armed.find((slot) => slot.key === preferredKey) : void 0;
+    const chosen = preferred ?? armed.reduce((a, b) => (b.armed?.seq ?? -1) > (a.armed?.seq ?? -1) ? b : a);
+    const abort = chosen.armed?.abort;
+    chosen.armed = void 0;
     abort?.();
   }
-  runPreemptable(preemptable, parent, run) {
-    const preempt = new AbortController();
-    if (preemptable) this.beginPreemptable(() => preempt.abort(preemptedExtractionError()));
-    const signal = parent ? AbortSignal.any([parent, preempt.signal]) : preempt.signal;
+  runPreemptable(preempt, preemptable, parent, run) {
+    const preemptController = new AbortController();
+    if (preemptable && preempt) {
+      preempt.arm(() => preemptController.abort(preemptedExtractionError()));
+    }
+    const signal = parent ? AbortSignal.any([parent, preemptController.signal]) : preemptController.signal;
     return Promise.resolve(run(signal)).finally(() => {
-      if (preemptable) this.endPreemptable();
+      if (preemptable && preempt) preempt.disarm();
     });
   }
   /** Stop new producers from entering the queue. */
@@ -1153,28 +1171,75 @@ var ExtractionQueueCoordinator = class {
     return true;
   }
   /**
-   * Background serial queue processor.
-   * Processes extractions one at a time to avoid race conditions.
-   * Called automatically when items are queued via `enqueue`; also exposed
-   * for the characterization tests that push raw tasks and assert drain
-   * semantics directly.
+   * Background queue processor. Runs up to `concurrency` tasks at a time,
+   * never two tasks with the same entry key. Called automatically when items
+   * are queued via `enqueue`; also exposed for the characterization tests
+   * that push raw tasks and assert drain semantics directly.
    */
   async processQueue() {
-    while (this.queue.length > 0) {
-      const task = this.queue.shift();
-      if (task) {
+    const inFlight = /* @__PURE__ */ new Set();
+    try {
+      while (this.queue.length > 0 || inFlight.size > 0) {
+        while (inFlight.size < this.concurrency) {
+          const entry = this.takeRunnable();
+          if (!entry) break;
+          const running = this.runEntry(entry).finally(() => {
+            inFlight.delete(running);
+          });
+          inFlight.add(running);
+        }
+        if (inFlight.size === 0) break;
+        const { promise: wakePromise, resolve: wake } = Promise.withResolvers();
+        this.wake = wake;
         try {
-          await task();
-        } catch (err) {
-          this.logExtractionQueueFailure(err, "task");
+          await Promise.race([wakePromise, ...inFlight]);
+        } finally {
+          this.wake = void 0;
         }
       }
+    } finally {
+      this.processing = false;
+    }
+  }
+  /** Take the next queue entry whose key is not already running (FIFO within a key). */
+  takeRunnable() {
+    for (let index = 0; index < this.queue.length; index += 1) {
+      const entry = this.queue[index];
+      if (entry.key !== void 0 && this.activeKeys.has(entry.key)) continue;
+      this.queue.splice(index, 1);
+      if (entry.key !== void 0) this.activeKeys.add(entry.key);
+      return entry;
+    }
+    return void 0;
+  }
+  /** Run one entry with its own preempt slot; failures are classified + logged. */
+  async runEntry(entry) {
+    const slot = {};
+    this.preemptSlots.set(slot, { key: entry.key });
+    try {
+      await entry.run(this.createPreemptHandle(slot));
+    } catch (err) {
+      this.logExtractionQueueFailure(err, "task");
+    } finally {
+      this.preemptSlots.delete(slot);
+      if (entry.key !== void 0) this.activeKeys.delete(entry.key);
     }
-    this.processing = false;
+  }
+  createPreemptHandle(slot) {
+    return {
+      arm: (abort) => {
+        const state = this.preemptSlots.get(slot);
+        if (state) state.armed = { abort, seq: this.preemptSeq++ };
+      },
+      disarm: () => {
+        const state = this.preemptSlots.get(slot);
+        if (state) state.armed = void 0;
+      }
+    };
   }
   /**
    * Classify + log a failure from either the per-task catch inside
-   * `processQueue()` or the outer `processQueue().catch(...)` in
+   * `runEntry` or the outer `processQueue().catch(...)` in
    * `enqueue()`.  Issue #549: `throwIfRecallAborted`
    * (used throughout `runExtraction`) raises an Error whose `name` is
    * `"AbortError"`.  That path fires when `before_reset` aborts a
@@ -1227,12 +1292,13 @@ var ExtractionQueueCoordinator = class {
    * pre-extraction `this.extractionQueue.push(...)` used by the
    * characterization tests that drive the drain manually via `processQueue`.
    */
-  pushRaw(task) {
-    this.queue.push(task);
+  pushRaw(task, options) {
+    this.queue.push({ run: task, key: options?.key });
+    this.wake?.();
   }
   /** Remove + return the front task (test seam for the flush deadline tests). */
   shift() {
-    return this.queue.shift();
+    return this.queue.shift()?.run;
   }
   /**
    * Force the processor-busy flag so `enqueue` does not auto-start the
@@ -2495,7 +2561,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path41, preferredNamespace) => {
+        readMemoryFrontmatter: async (path42, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2507,7 +2573,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path41,
+            path42,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -4798,11 +4864,20 @@ var ConsolidationRunCoordinator = class {
           profileConsolidationTargetLines
         );
         if (profileResult) {
-          await storage.writeProfile(profileResult.consolidatedProfile);
-          memoryItemMutated = true;
-          log.info(
-            `profile.md consolidated: removed ${profileResult.removedCount} items \u2014 ${profileResult.summary}`
+          const outcome = await storage.commitConsolidatedProfile(
+            currentProfile,
+            profileResult.consolidatedProfile
           );
+          if (outcome === "conflict") {
+            log.info(
+              "profile.md changed during consolidation \u2014 skipping stale rewrite (retries next pass)"
+            );
+          } else {
+            memoryItemMutated = true;
+            log.info(
+              `profile.md consolidated: removed ${profileResult.removedCount} items \u2014 ${profileResult.summary}`
+            );
+          }
         }
       }
     }
@@ -4895,6 +4970,78 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
   }
 };
 
+// src/orchestration/fact-dedup-window.ts
+import path5 from "path";
+
+// src/orchestration/extraction-persist-citation.ts
+function normalizeStoredHashSource(raw, citationEnabled, citationTemplate) {
+  return ContentHashIndex.normalizeContent(
+    sanitizeMemoryContent(
+      citationEnabled && hasCitationForTemplate(raw, citationTemplate) ? stripCitationForTemplate(raw, citationTemplate) : raw
+    ).text
+  );
+}
+function applyInlineCitation(content, citationEnabled, citationTemplate, citationContextBase) {
+  if (!citationEnabled) return content;
+  if (typeof content !== "string" || content.length === 0) return content;
+  const citationContext = {
+    ...citationContextBase,
+    ts: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return attachCitation(content, citationContext, citationTemplate);
+}
+
+// src/orchestration/fact-dedup-window.ts
+function matchesActiveConnectorDuplicate(memory, opts) {
+  if (memory.frontmatter.category !== opts.category) return false;
+  if ((memory.frontmatter.status ?? "active") !== "active") return false;
+  if (normalizeStoredHashSource(stripAttributesSuffix(memory.content ?? ""), opts.citationEnabled, opts.citationTemplate) !== ContentHashIndex.normalizeContent(opts.contentHashDedupKey)) return false;
+  return (memory.frontmatter.sourceConnector?.trim() || void 0) === opts.connector;
+}
+async function confirmActiveFactDuplicate(probe, storage, opts) {
+  let needsCorpusConfirm;
+  try {
+    if (!await probe.hasContentHashDedup(storage, opts.contentHashDedupKey)) {
+      if (await storage.isFactContentHashAuthoritative()) return false;
+      needsCorpusConfirm = true;
+    } else {
+      needsCorpusConfirm = true;
+    }
+  } catch {
+    needsCorpusConfirm = true;
+  }
+  try {
+    const [hotMems, coldMems] = await Promise.all([
+      storage.readAllMemories(),
+      storage.readAllColdMemories()
+    ]);
+    return hotMems.some((m) => matchesActiveConnectorDuplicate(m, opts)) || coldMems.some((m) => matchesActiveConnectorDuplicate(m, opts));
+  } catch (err) {
+    log.warn(
+      `connector-aware dedup scan failed for storage ${storage.dir}; writing fail-open: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return false;
+  }
+}
+async function persistUnderFactDedupWindow(storageDir, recheck, write) {
+  return serializeMutations(
+    `fact-dedup:${storageDir}`,
+    () => withHeldFileLock(
+      path5.join(storageDir, "fact-dedup.lock"),
+      // Bounded: the window holds one corpus confirm + one memory write, not a
+      // scan-length lock (catalog round 5 adoption note).
+      { staleMs: 5e3, maxWaitMs: 2e3, pollMs: 50 },
+      async (acquired) => {
+        if (!acquired) {
+          throw new Error(`fact write skipped: fact-dedup.lock not acquired (${storageDir})`);
+        }
+        if (await recheck()) return { suppressed: true };
+        return { suppressed: false, result: await write() };
+      }
+    )
+  );
+}
+
 // src/orchestration/extraction-injection-gate.ts
 function serializeInjectionScreenCandidate(candidate) {
   const body = candidate.category === "procedure" ? buildProcedurePersistBody(candidate.content, candidate.procedureSteps) : candidate.content;
@@ -5571,7 +5718,7 @@ async function retireStaleMergedTargetPromotionCopies(args) {
 }
 
 // src/orchestration/semantic-merge-persist.ts
-import path5 from "path";
+import path6 from "path";
 
 // src/orchestration/semantic-merge-commit-effects.ts
 import { readFile as readFile3 } from "fs/promises";
@@ -6291,11 +6438,11 @@ async function runMergedTargetPostEffects(deps, storage, merge, input) {
     if (inferMemoryStatus(committed.frontmatter, committed.path) !== "active") return signals;
     const entityRef = committed.frontmatter.entityRef;
     const rawBody = rawPreCitationMergedBody(deps, merge.mergedContent);
-    const memoryRelPath = path5.relative(storage.dir, committed.path);
+    const memoryRelPath = path6.relative(storage.dir, committed.path);
     input.graphContext.memoryPathById.set(merge.targetId, memoryRelPath);
     const all = input.graphContext.allMemsForGraph;
     if (Array.isArray(all)) {
-      const entry = all.find((m) => path5.relative(storage.dir, m.path) === memoryRelPath);
+      const entry = all.find((m) => path6.relative(storage.dir, m.path) === memoryRelPath);
       if (entry) entry.content = rawBody;
     }
     const rewriteTypes = [];
@@ -6339,7 +6486,7 @@ async function runMergedTargetPostEffects(deps, storage, merge, input) {
 }
 
 // src/orchestration/extraction-anchor-snapshot.ts
-import path6 from "path";
+import path7 from "path";
 var ExtractionAnchorSnapshot = class {
   constructor(options = {}) {
     this.options = options;
@@ -6377,7 +6524,7 @@ var ExtractionAnchorSnapshot = class {
       if (!cached) return;
       const snapshot = await cached;
       const relativePath = resolvePersistedMemoryRelativePath({ memoryId, pathById, category });
-      let memory = await storage.readMemoryByPath(path6.join(storage.dir, relativePath));
+      let memory = await storage.readMemoryByPath(path7.join(storage.dir, relativePath));
       if (!memory) memory = await storage.getMemoryByIdIncludingArchived(memoryId);
       if (!memory) return;
       const existingIndex = snapshot.findIndex((entry) => entry.frontmatter.id === memoryId);
@@ -6397,24 +6544,6 @@ var ExtractionAnchorSnapshot = class {
   }
 };
 
-// src/orchestration/extraction-persist-citation.ts
-function normalizeStoredHashSource(raw, citationEnabled, citationTemplate) {
-  return ContentHashIndex.normalizeContent(
-    sanitizeMemoryContent(
-      citationEnabled && hasCitationForTemplate(raw, citationTemplate) ? stripCitationForTemplate(raw, citationTemplate) : raw
-    ).text
-  );
-}
-function applyInlineCitation(content, citationEnabled, citationTemplate, citationContextBase) {
-  if (!citationEnabled) return content;
-  if (typeof content !== "string" || content.length === 0) return content;
-  const citationContext = {
-    ...citationContextBase,
-    ts: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  return attachCitation(content, citationContext, citationTemplate);
-}
-
 // src/orchestration/extraction-persist.ts
 var ExtractionPersistCoordinator = class {
   constructor(deps) {
@@ -7322,81 +7451,83 @@ var ExtractionPersistCoordinator = class {
         fact.tags
       );
       let exactDuplicate = false;
-      let needsCorpusConfirm = false;
       try {
         exactDuplicate = await this.deps.hasContentHashDedup(targetStorage, contentHashDedupKey);
-        if (factDedupEnabled && !exactDuplicate) {
-          if (await targetStorage.isFactContentHashAuthoritative()) {
-            exactDuplicate = await this.deps.hasContentHashDedup(targetStorage, contentHashDedupKey);
-          } else {
-            needsCorpusConfirm = true;
-          }
-        }
       } catch (err) {
-        needsCorpusConfirm = true;
+        exactDuplicate = false;
         log.warn(
           `content-hash dedup lookup unavailable for storage ${targetStorage.dir}; confirming against corpus: ${err}`
         );
       }
-      if (factDedupEnabled && (exactDuplicate || needsCorpusConfirm)) {
-        try {
-          const [hotMems, coldMems] = await Promise.all([
-            targetStorage.readAllMemories(),
-            targetStorage.readAllColdMemories()
-          ]);
-          const nc = sourceContext?.sourceConnector?.trim() || void 0;
-          const matchesActiveDuplicate = (m) => {
-            if (m.frontmatter.category !== writeCategory) return false;
-            if ((m.frontmatter.status ?? "active") !== "active") return false;
-            if (normalizeStoredHashSource2(stripAttributesSuffix(m.content ?? "")) !== ContentHashIndex.normalizeContent(contentHashDedupKey)) return false;
-            return (m.frontmatter.sourceConnector?.trim() || void 0) === nc;
-          };
-          exactDuplicate = hotMems.some(matchesActiveDuplicate) || coldMems.some(matchesActiveDuplicate);
-        } catch (err) {
-          log.warn(
-            `connector-aware dedup scan failed for storage ${targetStorage.dir}; writing fail-open: ${err instanceof Error ? err.message : String(err)}`
-          );
-          exactDuplicate = false;
-        }
+      const raceDedupOpts = (key) => ({
+        category: writeCategory,
+        contentHashDedupKey: key,
+        connector: sourceContext?.sourceConnector?.trim() || void 0,
+        citationEnabled,
+        citationTemplate
+      });
+      if (factDedupEnabled) {
+        exactDuplicate = await confirmActiveFactDuplicate(
+          { hasContentHashDedup: (storage2, key) => this.deps.hasContentHashDedup(storage2, key) },
+          targetStorage,
+          raceDedupOpts(contentHashDedupKey)
+        );
       }
-      if (exactDuplicate && injectionScreenStatus !== "pending_review") {
-        if (biTemporal && writeCategory === "fact" && (biTemporal.validUntil || biTemporal.validFrom)) {
-          const fr = faithfulnessResultsByFactIndex?.get(factLoopIndex);
-          const faithfulnessWouldPending = faithfulnessMode === "enforce" && fr?.ok === true && (fr.verdict === "unsupported" || fr.verdict === "contradicted");
-          const requireSpansWouldPending = this.deps.config.provenance?.requireSpans === true && fact.requireSpansPending === true;
-          const judgeVerdict = judgeVerdictsByFactIndex?.get(factLoopIndex);
-          const judgeWouldGate = !this.deps.config.extractionJudgeShadow && judgeVerdict !== void 0 && !judgeVerdict.durable;
-          if (isAboveImportanceThreshold(importance.level, this.deps.config.extractionMinImportanceLevel) && !faithfulnessWouldPending && !requireSpansWouldPending && !judgeWouldGate) {
-            await this.deps.backfillTemporalBoundsOnDedupHit(
-              targetStorage,
-              contentHashDedupKey,
-              {
-                invalidAt: biTemporal.validUntil,
-                // #1707 thread 2 — carry the corrected start bound too.
-                validFrom: biTemporal.validFrom,
-                observedAt: biTemporal.observedAt,
-                eventTimeSource: biTemporal.eventTimeSource
-              },
-              fact.entityRef,
-              sourceContext?.sourceConnector
-            );
-            await backfillTemporalBoundsOnPromotionCopies({
-              sourceStorage: targetStorage,
-              content: fact.content,
-              category: writeCategory,
-              confidence: fact.confidence,
-              entityRef: fact.entityRef,
-              structuredAttributes: fact.structuredAttributes,
-              sourceConnector: sourceContext?.sourceConnector,
-              bounds: {
-                invalidAt: biTemporal.validUntil,
-                validFrom: biTemporal.validFrom,
-                observedAt: biTemporal.observedAt,
-                eventTimeSource: biTemporal.eventTimeSource
-              }
-            });
-          }
+      const finalizeOnWindowFailure = async (err) => {
+        await finalizeCommittedWrites(true).catch(
+          (finalizeErr) => log.warn(`committed-write finalization after fact-dedup window failure failed: ${finalizeErr}`)
+        );
+        throw err;
+      };
+      const raceRecheck = (storage2, key) => () => {
+        if (!factDedupEnabled || injectionScreenStatus === "pending_review") return Promise.resolve(false);
+        return confirmActiveFactDuplicate(
+          { hasContentHashDedup: (s, k) => this.deps.hasContentHashDedup(s, k) },
+          storage2,
+          raceDedupOpts(key)
+        );
+      };
+      const backfillDuplicateTemporalBounds = async () => {
+        if (!(biTemporal && writeCategory === "fact" && (biTemporal.validUntil || biTemporal.validFrom))) return;
+        const fr = faithfulnessResultsByFactIndex?.get(factLoopIndex);
+        const faithfulnessWouldPending = faithfulnessMode === "enforce" && fr?.ok === true && (fr.verdict === "unsupported" || fr.verdict === "contradicted");
+        const requireSpansWouldPending = this.deps.config.provenance?.requireSpans === true && fact.requireSpansPending === true;
+        const judgeVerdict = judgeVerdictsByFactIndex?.get(factLoopIndex);
+        const judgeWouldGate = !this.deps.config.extractionJudgeShadow && judgeVerdict !== void 0 && !judgeVerdict.durable;
+        if (!isAboveImportanceThreshold(importance.level, this.deps.config.extractionMinImportanceLevel) || faithfulnessWouldPending || requireSpansWouldPending || judgeWouldGate) {
+          return;
         }
+        await this.deps.backfillTemporalBoundsOnDedupHit(
+          targetStorage,
+          contentHashDedupKey,
+          {
+            invalidAt: biTemporal.validUntil,
+            // #1707 thread 2 — carry the corrected start bound too.
+            validFrom: biTemporal.validFrom,
+            observedAt: biTemporal.observedAt,
+            eventTimeSource: biTemporal.eventTimeSource
+          },
+          fact.entityRef,
+          sourceContext?.sourceConnector
+        );
+        await backfillTemporalBoundsOnPromotionCopies({
+          sourceStorage: targetStorage,
+          content: fact.content,
+          category: writeCategory,
+          confidence: fact.confidence,
+          entityRef: fact.entityRef,
+          structuredAttributes: fact.structuredAttributes,
+          sourceConnector: sourceContext?.sourceConnector,
+          bounds: {
+            invalidAt: biTemporal.validUntil,
+            validFrom: biTemporal.validFrom,
+            observedAt: biTemporal.observedAt,
+            eventTimeSource: biTemporal.eventTimeSource
+          }
+        });
+      };
+      if (exactDuplicate && injectionScreenStatus !== "pending_review") {
+        await backfillDuplicateTemporalBounds();
         log.debug(
           `dedup: skipping duplicate fact "${fact.content.slice(0, 60)}\u2026" in storage ${targetStorage.dir}`
         );
@@ -7605,27 +7736,38 @@ var ExtractionPersistCoordinator = class {
             },
             { source: extractionWriteSource }
           );
-          const parentWrite = await targetStorage.writeSealedMemory(parentWriteEnvelope, {
-            importance,
-            supersedes,
-            links: links.length > 0 ? links : void 0,
-            intentGoal: inferredIntent?.goal,
-            intentActionType: inferredIntent?.actionType,
-            intentEntityTypes: inferredIntent?.entityTypes,
-            memoryKind: memoryKind2,
-            ...biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {} } : {},
-            contentHashSource: rawChunkedContent,
-            // Faithfulness gate (issue #1576).
-            ...faithfulnessFm ? { faithfulness: faithfulnessFm } : {},
-            ...faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {},
-            // Claim-level provenance spans (issue #1575 PR 2).
-            ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
-            ...fact.provenance ? { provenance: fact.provenance } : {},
-            // PR #2016: never defer here — fallible chunk/artifact writes follow this
-            // durable parent .md; flush the hash now so a throw can't strand it (dup).
-            deferHashIndexSave: false,
-            ...factToolScoped ? { toolScoped: true } : {}
-          });
+          const parentWriteOutcome = await persistUnderFactDedupWindow(
+            targetStorage.dir,
+            raceRecheck(targetStorage, contentHashDedupKey),
+            async () => targetStorage.writeSealedMemory(parentWriteEnvelope, {
+              importance,
+              supersedes,
+              links: links.length > 0 ? links : void 0,
+              intentGoal: inferredIntent?.goal,
+              intentActionType: inferredIntent?.actionType,
+              intentEntityTypes: inferredIntent?.entityTypes,
+              memoryKind: memoryKind2,
+              ...biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {} } : {},
+              contentHashSource: rawChunkedContent,
+              // Faithfulness gate (issue #1576).
+              ...faithfulnessFm ? { faithfulness: faithfulnessFm } : {},
+              ...faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {},
+              // Claim-level provenance spans (issue #1575 PR 2).
+              ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
+              ...fact.provenance ? { provenance: fact.provenance } : {},
+              // PR #2016: never defer here — fallible chunk/artifact writes follow this
+              // durable parent .md; flush the hash now so a throw can't strand it (dup).
+              deferHashIndexSave: false,
+              ...factToolScoped ? { toolScoped: true } : {}
+            })
+          ).catch(finalizeOnWindowFailure);
+          if (parentWriteOutcome.suppressed) {
+            await backfillDuplicateTemporalBounds();
+            log.info(`dedup: raced duplicate suppressed in fact-dedup window (chunked parent) for storage ${targetStorage.dir}`);
+            dedupedCount++;
+            continue;
+          }
+          const parentWrite = parentWriteOutcome.result;
           const parentId = parentWrite.id;
           const tombstoneBlocked2 = parentWrite.tombstoneBlocked;
           const postWriteGuard2 = faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked2;
@@ -7914,29 +8056,51 @@ var ExtractionPersistCoordinator = class {
         },
         { source: extractionWriteSource }
       );
-      const factWrite = await targetStorage.writeSealedMemory(factWriteEnvelope, {
-        importance,
-        supersedes,
-        links: links.length > 0 ? links : void 0,
-        intentGoal: inferredIntent?.goal,
-        intentActionType: inferredIntent?.actionType,
-        intentEntityTypes: inferredIntent?.entityTypes,
-        memoryKind,
-        ...biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {} } : {},
-        contentHashSource: writeCategory === "fact" ? fact.content : void 0,
-        // Faithfulness gate (issue #1576).
-        ...faithfulnessFm ? { faithfulness: faithfulnessFm } : {},
-        ...faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {},
-        // Claim-level provenance spans (issue #1575 PR 2). Carry verified
-        // sources + the coarse strength tag from the extraction validator
-        // through to frontmatter so they survive end-to-end.
-        ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
-        ...fact.provenance ? { provenance: fact.provenance } : {},
-        // #1909: defer the per-fact index flush to the batch save only when
-        // fact dedup is on (the batch saver is a no-op otherwise).
-        deferHashIndexSave: factDedupEnabled,
-        ...factToolScoped ? { toolScoped: true } : {}
-      });
+      const factWriteOutcome = await persistUnderFactDedupWindow(
+        targetStorage.dir,
+        raceRecheck(targetStorage, contentHashDedupKey),
+        async () => {
+          const factWrite2 = await targetStorage.writeSealedMemory(factWriteEnvelope, {
+            importance,
+            supersedes,
+            links: links.length > 0 ? links : void 0,
+            intentGoal: inferredIntent?.goal,
+            intentActionType: inferredIntent?.actionType,
+            intentEntityTypes: inferredIntent?.entityTypes,
+            memoryKind,
+            ...biTemporal ? { observedAt: biTemporal.observedAt, eventTimeSource: biTemporal.eventTimeSource, ...biTemporal.validUntil ? { invalidAt: biTemporal.validUntil } : {} } : {},
+            contentHashSource: writeCategory === "fact" ? fact.content : void 0,
+            // Faithfulness gate (issue #1576).
+            ...faithfulnessFm ? { faithfulness: faithfulnessFm } : {},
+            ...faithfulnessEnforceStatus ? { status: faithfulnessEnforceStatus } : {},
+            // Claim-level provenance spans (issue #1575 PR 2). Carry verified
+            // sources + the coarse strength tag from the extraction validator
+            // through to frontmatter so they survive end-to-end.
+            ...fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {},
+            ...fact.provenance ? { provenance: fact.provenance } : {},
+            // PR #2016: never defer inside the commit window (chunked-path
+            // rule): a peer loading an authoritative index after the release
+            // must see this hash, or its recheck misses and duplicates it.
+            deferHashIndexSave: false,
+            ...factToolScoped ? { toolScoped: true } : {}
+          });
+          if (!factWrite2.tombstoneBlocked) {
+            try {
+              await this.deps.addContentHashDedup(targetStorage, contentHashDedupKey);
+            } catch (err) {
+              log.warn(`content-hash dedup registration failed for memory ${factWrite2.id}: ${err}`);
+            }
+          }
+          return factWrite2;
+        }
+      ).catch(finalizeOnWindowFailure);
+      if (factWriteOutcome.suppressed) {
+        await backfillDuplicateTemporalBounds();
+        log.info(`dedup: raced duplicate suppressed in fact-dedup window for storage ${targetStorage.dir}`);
+        dedupedCount++;
+        continue;
+      }
+      const factWrite = factWriteOutcome.result;
       const memoryId = factWrite.id;
       const tombstoneBlocked = factWrite.tombstoneBlocked;
       const postWriteGuard = faithfulnessEnforceStatus === "pending_review" || tombstoneBlocked;
@@ -8085,17 +8249,6 @@ var ExtractionPersistCoordinator = class {
             ...factToolScoped ? { toolScoped: true } : {}
           });
         }
-        try {
-          const canonicalFactContent = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
-          const hashRegisterKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalFactContent;
-          if (!tombstoneBlocked) {
-            await this.deps.addContentHashDedup(targetStorage, hashRegisterKey);
-          }
-        } catch (err) {
-          log.warn(
-            `content-hash dedup registration failed for memory ${memoryId}: ${err}`
-          );
-        }
       } catch (err) {
         await finalizeCommittedWrites(true).catch(
           (finalizeErr) => log.warn(`committed-write finalization after post-write failure failed: ${finalizeErr}`)
@@ -8251,7 +8404,7 @@ async function drainExtractionAndShutdownDependencyPropagation(extractionQueue,
 // src/orchestration/dependency-propagation-delivery.ts
 import { randomUUID } from "crypto";
 import { readFile as readFile4, unlink } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 
 // src/orchestration/dependency-propagation-recovery-replay.ts
 import { createHash as createHash4 } from "crypto";
@@ -8934,13 +9087,13 @@ var DependencyPropagationDelivery = class {
         try {
           const job = validateJob(JSON.parse(await this.readQueueFile(filePath)), status);
           if (!job) {
-            log.warn(`dependency propagation ignored invalid job file ${path7.basename(filePath)}`);
+            log.warn(`dependency propagation ignored invalid job file ${path8.basename(filePath)}`);
             continue;
           }
           entries.push({ job, filePath });
         } catch (error) {
           if (error instanceof SyntaxError || isNotFound(error)) {
-            log.warn(`dependency propagation ignored unreadable job file ${path7.basename(filePath)}: ${error}`);
+            log.warn(`dependency propagation ignored unreadable job file ${path8.basename(filePath)}: ${error}`);
             continue;
           }
           throw error;
@@ -9011,7 +9164,7 @@ var DependencyPropagationDelivery = class {
     await this.writeQueueJob(targetPath, next);
     const terminal = status === "completed" || status === "dead_letter" || status === "canceled";
     for (const entry of entries) {
-      if (path7.resolve(entry.filePath) === path7.resolve(targetPath)) continue;
+      if (path8.resolve(entry.filePath) === path8.resolve(targetPath)) continue;
       await unlink(entry.filePath).catch((error) => {
         if (isNotFound(error)) return;
         if (terminal) {
@@ -9075,7 +9228,7 @@ var DependencyPropagationDelivery = class {
         allowMissingDirectory: true
       });
       for (const filePath of files) {
-        if (path7.basename(filePath, ".json") !== jobId) continue;
+        if (path8.basename(filePath, ".json") !== jobId) continue;
         try {
           await unlink(filePath);
         } catch (error) {
@@ -9276,11 +9429,11 @@ function createDependencyPropagationReplayReconciliation(host) {
 // src/orchestration/recall-internal.ts
 import { createHash as createHash6 } from "crypto";
 import { readFile as readFile5, stat, unlink as unlink2 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 
 // src/orchestration/graph-path-state-loader.ts
 import { lstat, opendir, realpath } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 function isArchivePathIndexUnavailable(index) {
   return "unavailable" in index;
 }
@@ -9299,11 +9452,11 @@ var GraphPathStateLoader = class {
   openArchiveDirectory = opendir;
   async readNode(storage, nodeId, deadlineAtMs, allowArchiveLookup) {
     if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
-    const configuredStorageRoot = path8.resolve(storage.dir);
+    const configuredStorageRoot = path9.resolve(storage.dir);
     const storageRoot = await realpath(configuredStorageRoot).catch(() => null);
     if (!storageRoot || storageRoot !== configuredStorageRoot) return null;
-    const logicalId = path8.basename(nodeId, path8.extname(nodeId));
-    const directRelativePaths = [nodeId, path8.join("cold", nodeId)];
+    const logicalId = path9.basename(nodeId, path9.extname(nodeId));
+    const directRelativePaths = [nodeId, path9.join("cold", nodeId)];
     let inactiveDirectMemory = null;
     for (const relativePath of directRelativePaths) {
       const safePath = await this.resolveContainedPath(storageRoot, relativePath);
@@ -9326,7 +9479,7 @@ var GraphPathStateLoader = class {
     if (!archiveIndex || isArchivePathIndexUnavailable(archiveIndex) || typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) {
       return null;
     }
-    const archivePaths = archiveIndex.pathsByBasename.get(path8.basename(nodeId)) ?? [];
+    const archivePaths = archiveIndex.pathsByBasename.get(path9.basename(nodeId)) ?? [];
     for (const archivePath of archivePaths) {
       if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
       const memory = await storage.readMemoryByPath(archivePath);
@@ -9336,17 +9489,17 @@ var GraphPathStateLoader = class {
     return null;
   }
   async resolveContainedPath(storageRoot, relativePath) {
-    if (path8.isAbsolute(relativePath)) return null;
+    if (path9.isAbsolute(relativePath)) return null;
     const rawSegments = relativePath.replace(/\\/g, "/").split("/");
     if (rawSegments.includes("..")) return null;
-    const candidate = path8.resolve(storageRoot, relativePath);
-    const lexicalRelative = path8.relative(storageRoot, candidate);
-    if (lexicalRelative.length > 0 && (lexicalRelative.startsWith("..") || path8.isAbsolute(lexicalRelative))) {
+    const candidate = path9.resolve(storageRoot, relativePath);
+    const lexicalRelative = path9.relative(storageRoot, candidate);
+    if (lexicalRelative.length > 0 && (lexicalRelative.startsWith("..") || path9.isAbsolute(lexicalRelative))) {
       return null;
     }
     const canonical = await realpath(candidate).catch(() => candidate);
-    const canonicalRelative = path8.relative(storageRoot, canonical);
-    if (canonicalRelative.length > 0 && (canonicalRelative.startsWith("..") || path8.isAbsolute(canonicalRelative))) {
+    const canonicalRelative = path9.relative(storageRoot, canonical);
+    if (canonicalRelative.length > 0 && (canonicalRelative.startsWith("..") || path9.isAbsolute(canonicalRelative))) {
       return null;
     }
     return canonical;
@@ -9419,7 +9572,7 @@ var GraphPathStateLoader = class {
   }
   async buildArchivePathIndex(storageRoot, version) {
     const pathsByBasename = /* @__PURE__ */ new Map();
-    const archiveRoot = path8.join(storageRoot, "archive");
+    const archiveRoot = path9.join(storageRoot, "archive");
     let archiveRootStatus;
     try {
       archiveRootStatus = await this.archiveLstat(archiveRoot);
@@ -9437,8 +9590,8 @@ var GraphPathStateLoader = class {
       if (isArchiveScanAbsenceError(error)) return { version, pathsByBasename };
       return null;
     }
-    const archiveRelative = path8.relative(storageRoot, canonicalArchiveRoot);
-    if (archiveRelative.length > 0 && (archiveRelative.startsWith("..") || path8.isAbsolute(archiveRelative))) {
+    const archiveRelative = path9.relative(storageRoot, canonicalArchiveRoot);
+    if (archiveRelative.length > 0 && (archiveRelative.startsWith("..") || path9.isAbsolute(archiveRelative))) {
       return { version, pathsByBasename };
     }
     const pending = [canonicalArchiveRoot];
@@ -9464,8 +9617,8 @@ var GraphPathStateLoader = class {
         if (isArchiveScanAbsenceError(error)) continue;
         return null;
       }
-      const currentRelative = path8.relative(storageRoot, canonicalCurrent);
-      if (currentRelative.length > 0 && (currentRelative.startsWith("..") || path8.isAbsolute(currentRelative))) {
+      const currentRelative = path9.relative(storageRoot, canonicalCurrent);
+      if (currentRelative.length > 0 && (currentRelative.startsWith("..") || path9.isAbsolute(currentRelative))) {
         continue;
       }
       let directory;
@@ -9482,7 +9635,7 @@ var GraphPathStateLoader = class {
             return { version, unavailable: "oversized" };
           }
           if (entry.isSymbolicLink()) continue;
-          const entryPath = path8.join(canonicalCurrent, entry.name);
+          const entryPath = path9.join(canonicalCurrent, entry.name);
           if (entry.isDirectory()) {
             pending.push(entryPath);
             continue;
@@ -9498,8 +9651,8 @@ var GraphPathStateLoader = class {
             if (isArchiveScanAbsenceError(error)) continue;
             return null;
           }
-          const relative = path8.relative(storageRoot, canonical);
-          if (relative.length > 0 && (relative.startsWith("..") || path8.isAbsolute(relative))) {
+          const relative = path9.relative(storageRoot, canonical);
+          if (relative.length > 0 && (relative.startsWith("..") || path9.isAbsolute(relative))) {
             continue;
           }
           const paths = pathsByBasename.get(entry.name);
@@ -9525,7 +9678,7 @@ var GraphPathStateLoader = class {
 // src/orchestration/graph-recall-coordinator.ts
 import { createHash as createHash5 } from "crypto";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 function mergeGraphExpandedResults(primary, expanded) {
   const mergedByNamespaceAndPath = /* @__PURE__ */ new Map();
   for (const item of [...primary, ...expanded]) {
@@ -9542,11 +9695,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByNamespaceAndPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path9.isAbsolute(candidatePath) ? candidatePath : path9.resolve(storageDir, candidatePath);
-  const rel = path9.relative(storageDir, absolutePath);
+  const absolutePath = path10.isAbsolute(candidatePath) ? candidatePath : path10.resolve(storageDir, candidatePath);
+  const rel = path10.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path9.sep).join("/");
+  return rel.split(path10.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -9646,7 +9799,7 @@ var GraphRecallCoordinator = class {
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path9.isAbsolute(resolvedPath)) {
+      if (!path10.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -9671,7 +9824,7 @@ var GraphRecallCoordinator = class {
         }
         continue;
       }
-      if (path9.isAbsolute(result.path)) {
+      if (path10.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -9717,7 +9870,7 @@ var GraphRecallCoordinator = class {
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path9.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path10.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const nodeMemoryCache = /* @__PURE__ */ new Map();
@@ -9772,7 +9925,7 @@ var GraphRecallCoordinator = class {
             path: memory.path,
             score,
             namespace,
-            seed: path9.resolve(storage.dir, candidate.seed),
+            seed: path10.resolve(storage.dir, candidate.seed),
             hopDepth: candidate.hopDepth,
             decayedWeight: candidate.decayedWeight,
             graphType: candidate.graphType,
@@ -9804,7 +9957,7 @@ var GraphRecallCoordinator = class {
         add(memory.frontmatter.id);
         if (relativePath) {
           add(relativePath);
-          if (relativePath.endsWith(".md")) add(path9.basename(relativePath, ".md"));
+          if (relativePath.endsWith(".md")) add(path10.basename(relativePath, ".md"));
         }
         return state;
       };
@@ -9851,7 +10004,7 @@ var GraphRecallCoordinator = class {
           path: memory.path,
           score,
           namespace,
-          seed: path9.resolve(storage.dir, candidate.seed),
+          seed: path10.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -9894,12 +10047,12 @@ var GraphRecallCoordinator = class {
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path9.join(
+      const snapshotPath = path10.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path9.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path10.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -10199,11 +10352,11 @@ async function appendEpisodicContextSection(deps, options) {
 }
 
 // src/orchestration/recall-profile-storage.ts
-import path10 from "path";
+import path11 from "path";
 function resolveCompositeProfileStorage(options) {
   const { profileStorages, memoryDir } = options;
   const emptyProfileStorage = new Proxy(
-    { dir: path10.join(memoryDir, ".empty-scope-profile") },
+    { dir: path11.join(memoryDir, ".empty-scope-profile") },
     {
       get(target, prop) {
         if (prop in target) return Reflect.get(target, prop);
@@ -10351,7 +10504,7 @@ function resolveCompositeProfileStorage(options) {
 }
 
 // src/orchestration/recall-recognition-search.ts
-import path11 from "path";
+import path12 from "path";
 async function fetchQmdMemoryResultsWithRecognitionSwap(deps, prompt, qmdFetchLimit, qmdHybridFetchLimit, options) {
   if (deps.config.recallRecognitionTier !== true || options.collection || options.namespacesEnabled !== true) {
     return deps.fetchQmdMemoryResultsWithArtifactTopUp(
@@ -10438,7 +10591,7 @@ async function hitsFromIds(namespace, storage, index, ids) {
   for (const [offset, id] of ids.entries()) {
     const absPath = pathsById.get(id)?.[0];
     if (!absPath) continue;
-    const rel = path11.relative(storage.dir, absPath).split(path11.sep).join("/");
+    const rel = path12.relative(storage.dir, absPath).split(path12.sep).join("/");
     if (!rel || rel.startsWith("..")) continue;
     hits.push({
       docid: `${namespace}:${rel}`,
@@ -10686,7 +10839,7 @@ var RecallInternalCoordinator = class {
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path12.sep).join("/");
+        const normalizedPath = resultPath.split(path13.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -12223,11 +12376,11 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.deps.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.deps.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path12.join(
+        const signalPath = path13.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path12.join(workspaceDir, "BOOT.md");
+        const bootPath = path13.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
@@ -14507,10 +14660,10 @@ ${tmtNode.summary}`
 
 // src/orchestration/recall-search-pipeline.ts
 import { createHash as createHash7 } from "crypto";
-import path14 from "path";
+import path15 from "path";
 
 // src/orchestration/recall-search-prefilter.ts
-import path13 from "path";
+import path14 from "path";
 async function fetchActiveArtifactsForNamespace(deps, namespace, prompt, targetCount, options = {}) {
   const storage = await deps.storageRouter.storageFor(namespace);
   let fetchLimit = computeArtifactCandidateFetchLimit(targetCount);
@@ -14639,7 +14792,7 @@ async function searchEmbeddingFallback(deps, query, limit) {
   if (hits.length === 0) return [];
   const results = [];
   for (const hit of hits) {
-    const fullPath = path13.isAbsolute(hit.path) ? hit.path : path13.join(deps.config.memoryDir, hit.path);
+    const fullPath = path14.isAbsolute(hit.path) ? hit.path : path14.join(deps.config.memoryDir, hit.path);
     const memory = await deps.storage.readMemoryByPath(fullPath);
     if (!memory) continue;
     results.push({
@@ -15017,7 +15170,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 = path14.resolve(storageDir);
+          const recallRoot = path15.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -15041,8 +15194,8 @@ var RecallSearchPipelineCoordinator = class {
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path14.isAbsolute(result.path)) {
-          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path14.resolve(result.path)))) {
+        if (path15.isAbsolute(result.path)) {
+          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path15.resolve(result.path)))) {
             scopedResults.push(result);
           }
           continue;
@@ -15763,8 +15916,10 @@ var ExtractionDrain = class {
    * persist step ends the host's preemption registration, so the drain registers
    * it again before every later chunk; a fail-closed flush can then abort the
    * next chunk's model request instead of waiting behind the whole window.
+   * `preemptHandle`: the queue task's own preemption slot (per task, so two
+   * concurrent automatic extractions cannot clobber each other's registration).
    */
-  async run(turns, runOptions, preemptable = false) {
+  async run(turns, runOptions, preemptable = false, preemptHandle) {
     const budgetChars = this.deps.extractionWindowBudgetChars?.() ?? Number.POSITIVE_INFINITY;
     const chunkable = runOptions.clearBufferAfterExtraction && !runOptions.forceExtractionAttempt && !runOptions.failOnExtractionFailure && !turns.some((turn) => turn.acceptedCapture === true) && Number.isFinite(budgetChars) && budgetChars > 0;
     const chunks = chunkable ? chunkExtractionWindow(turns, budgetChars) : [];
@@ -15789,7 +15944,7 @@ var ExtractionDrain = class {
       if (preemptable && position > 0) {
         const local = new AbortController();
         preempt = local;
-        this.deps.extractionQueueCoordinator.beginPreemptable(() => local.abort(preemptedExtractionError()));
+        preemptHandle?.arm(() => local.abort(preemptedExtractionError()));
         chunkOptions = {
           ...chunkOptions,
           abortSignal: runOptions.abortSignal ? AbortSignal.any([runOptions.abortSignal, local.signal]) : local.signal
@@ -15851,8 +16006,8 @@ var ExtractionDrain = class {
     const reason = `dropped after ${dropAfter} repeated extraction failures (last result: status=${result.status} reason=${result.reason ?? "n/a"})`;
     try {
       const storage = await this.deps.getStorage();
-      const path41 = await storage.saveDroppedExtractionChunk(bufferKey, reason, chunk);
-      log.warn(`buffer[${bufferKey}]: dropping ${chunk.length} turns \u2014 ${reason}; copy saved to ${path41}`);
+      const path42 = await storage.saveDroppedExtractionChunk(bufferKey, reason, chunk);
+      log.warn(`buffer[${bufferKey}]: dropping ${chunk.length} turns \u2014 ${reason}; copy saved to ${path42}`);
     } catch (err) {
       log.warn(
         `buffer[${bufferKey}]: could not save the dropped-chunk recovery copy; keeping the chunk in the buffer: ${describeError(err)}`
@@ -16420,8 +16575,8 @@ var TurnIngestionCoordinator = class {
     }
     if (settled) return;
     const preemptable = options.preemptable === true && options.preemptRunning !== true;
-    const accepted = this.deps.extractionQueueCoordinator.enqueue(async () => {
-      await this.deps.extractionQueueCoordinator.runPreemptable(preemptable, options.abortSignal, async (abortSignal) => {
+    const accepted = this.deps.extractionQueueCoordinator.enqueue(async (preemptHandle) => {
+      await this.deps.extractionQueueCoordinator.runPreemptable(preemptHandle, preemptable, options.abortSignal, async (abortSignal) => {
         if (settled) return;
         if (typeof extractionDeadlineMs === "number" && extractionDeadlineMs <= Date.now()) {
           settleTask(new ExtractionDeadlineError("queue_wait"));
@@ -16527,14 +16682,14 @@ var TurnIngestionCoordinator = class {
             deadlineMs: extractionDeadlineMs,
             bufferKey,
             onDurableCommit: options.onDurableCommit,
-            onBeforePersist: () => this.deps.extractionQueueCoordinator.endPreemptable(),
+            onBeforePersist: () => preemptHandle?.disarm(),
             abortSignal,
             failOnExtractionFailure: options.failOnExtractionFailure === true,
             writeNamespaceOverride: options.writeNamespaceOverride,
             principalOverride: options.principalOverride,
             scopeProfileWritePlan: effectiveScopePlan,
             forceExtractionAttempt: options.forceExtractionAttempt === true
-          }, preemptable);
+          }, preemptable, preemptHandle);
           settleTask(void 0, result);
         } catch (err) {
           const reason2 = abortSignal.reason;
@@ -16544,7 +16699,7 @@ var TurnIngestionCoordinator = class {
           }
         }
       });
-    }, { front: options.preemptRunning === true });
+    }, { front: options.preemptRunning === true, key: bufferKey });
     if (!accepted) {
       settleTask(new Error("extraction queue is stopped"));
       return;
@@ -16623,7 +16778,7 @@ var TurnIngestionCoordinator = class {
 
 // src/orchestration/recall-introspection.ts
 import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 
 // src/taxonomy/default-taxonomy.ts
 var DEFAULT_TAXONOMY = {
@@ -16746,7 +16901,7 @@ function generateResolverDocument(taxonomy) {
 
 // src/taxonomy/taxonomy-loader.ts
 import { readFile as readFile6, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -16844,7 +16999,7 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path15.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path16.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
     raw = await readFile6(taxonomyPath, "utf-8");
@@ -16894,16 +17049,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path15.join(memoryDir, TAXONOMY_DIR);
+  const dir = path16.join(memoryDir, TAXONOMY_DIR);
   await mkdir4(dir, { recursive: true });
-  const filePath = path15.join(dir, TAXONOMY_FILE);
+  const filePath = path16.join(dir, TAXONOMY_FILE);
   await writeFile4(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path15.join(memoryDir, TAXONOMY_DIR);
+  return path16.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path15.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path16.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/orchestration/recall-introspection.ts
@@ -16927,7 +17082,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path16.join(
+    const snapshotPath = path17.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
@@ -16966,7 +17121,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path16.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path17.join(storage.dir, "state", "last_intent.json");
     try {
       const raw = await readFile7(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -16999,7 +17154,7 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path16.join(
+    const snapshotPath = path17.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
@@ -17291,12 +17446,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path16.join(
+      const snapshotPath = path17.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir5(path16.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path17.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -17308,12 +17463,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path16.join(
+      const snapshotPath = path17.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir5(path16.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path17.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -17328,8 +17483,8 @@ var RecallIntrospectionCoordinator = class {
       const stateDir = await this.deps.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path16.join(stateDir, "last_intent.json");
-      await mkdir5(path16.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path17.join(stateDir, "last_intent.json");
+      await mkdir5(path17.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -17343,7 +17498,7 @@ var RecallIntrospectionCoordinator = class {
 
 // src/orchestration/orchestrator-init.ts
 import { readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 
 // src/orchestration/startup-collection-checks.ts
 async function startupDiscoveryWithTimeout(discover, configuredFallback, timeoutMs = qmdStartupCollectionCheckTimeoutMs()) {
@@ -17679,7 +17834,7 @@ var OrchestratorInitCoordinator = class {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path17.join(wsDir, f);
+            const fp = path18.join(wsDir, f);
             const s = await stat2(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
               await unlink3(fp).catch(() => {
@@ -18099,11 +18254,11 @@ var OrchestratorInitCoordinator = class {
 };
 
 // src/orchestration/persistence-index.ts
-import path19 from "path";
+import path20 from "path";
 
 // src/orchestration/recall-recognition-index.ts
 import { promises as fsp } from "fs";
-import path18 from "path";
+import path19 from "path";
 import { setTimeout as delay } from "timers/promises";
 var writeChains = /* @__PURE__ */ new Map();
 var LOCK_POLL_MS = 10;
@@ -18154,7 +18309,7 @@ async function withRecognitionIndexLock(memoryDir, op) {
     } catch (error) {
       const code = error?.code;
       if (code === "ENOENT") {
-        await fsp.mkdir(path18.dirname(lockDir), { recursive: true }).catch(() => void 0);
+        await fsp.mkdir(path19.dirname(lockDir), { recursive: true }).catch(() => void 0);
         continue;
       }
       if (code !== "EEXIST") throw error;
@@ -18405,7 +18560,7 @@ var PersistenceIndexCoordinator = class {
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path19.relative(storage.dir, m.path);
+            const rel = path20.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -18601,7 +18756,7 @@ var PersistenceIndexCoordinator = class {
 
 // src/orchestration/workspace-ops.ts
 import { lstat as lstat2, mkdir as mkdir6, readFile as readFile8, readdir as readdir3, realpath as realpath2, writeFile as writeFile6 } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
@@ -20505,8 +20660,8 @@ var MeetingsService = class {
 // src/orchestration/workspace-ops.ts
 var MEETINGS_BUILD_DEBOUNCE_MS = 5e3;
 function matchesMemoryPath(candidatePath, requestedPath, memoryDir) {
-  const normalizedCandidate = path20.resolve(candidatePath);
-  return normalizedCandidate === path20.resolve(requestedPath) || normalizedCandidate === path20.resolve(memoryDir, requestedPath);
+  const normalizedCandidate = path21.resolve(candidatePath);
+  return normalizedCandidate === path21.resolve(requestedPath) || normalizedCandidate === path21.resolve(memoryDir, requestedPath);
 }
 function accessTrackingPathCandidates(storageDir, memoryPath) {
   const candidates = qmdResultPathCandidates(storageDir, memoryPath);
@@ -20514,12 +20669,12 @@ function accessTrackingPathCandidates(storageDir, memoryPath) {
   if (!parts) return candidates;
   candidates.push(
     ...qmdResultPathCandidates(storageDir, parts.relativePath),
-    ...qmdResultPathCandidates(path20.join(storageDir, "cold"), parts.relativePath)
+    ...qmdResultPathCandidates(path21.join(storageDir, "cold"), parts.relativePath)
   );
   return [...new Set(candidates)];
 }
 function canonicalMemoryPath(memoryPath, memoryDir) {
-  return path20.resolve(path20.isAbsolute(memoryPath) ? memoryPath : path20.resolve(memoryDir, memoryPath));
+  return path21.resolve(path21.isAbsolute(memoryPath) ? memoryPath : path21.resolve(memoryDir, memoryPath));
 }
 var WorkspaceOpsCoordinator = class {
   constructor(deps) {
@@ -20601,15 +20756,15 @@ var WorkspaceOpsCoordinator = class {
     this.deps.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path20.isAbsolute(rel) ? rel : path20.join(this.deps.config.workspaceDir, rel);
+        const abs = path21.isAbsolute(rel) ? rel : path21.join(this.deps.config.workspaceDir, rel);
         try {
           const raw = await readFile8(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path20.join(
+            const archiveDir = path21.join(
               this.deps.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path20.basename(abs);
+            const base = path21.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -20634,8 +20789,8 @@ var WorkspaceOpsCoordinator = class {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path20.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path20.dirname(fp), { recursive: true });
+        const fp = path21.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path21.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -20675,7 +20830,7 @@ var WorkspaceOpsCoordinator = class {
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path20.join(storage.dir, categoryDir, date);
+        const dateDir = path21.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat2(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -20684,7 +20839,7 @@ var WorkspaceOpsCoordinator = class {
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path20.join(dateDir, entry.name);
+            const fullPath = path21.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath2(fullPath), fullPath);
               const memory = await storage.readMemoryByPath(fullPath);
@@ -20706,13 +20861,13 @@ var WorkspaceOpsCoordinator = class {
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path20.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path21.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 = path20.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path21.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
             const raw = await readFile8(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
@@ -21189,18 +21344,18 @@ ${reflectionsContent.trim()}
 // src/orchestration/namespace-read-fanout.ts
 import { existsSync, readFileSync } from "fs";
 import { stat as stat3 } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 
 // src/orchestration/orchestrator-namespace-scope.ts
-import path21 from "path";
+import path22 from "path";
 function computeSemanticDedupScope(targetStorage, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return {};
-  const memoryDir = path21.resolve(config.memoryDir);
-  const storageDir = path21.resolve(targetStorage.dir);
+  const memoryDir = path22.resolve(config.memoryDir);
+  const storageDir = path22.resolve(targetStorage.dir);
   if (storageDir === memoryDir) {
     return { pathExcludePrefixes: ["namespaces/"] };
   }
-  let rel = path21.relative(memoryDir, storageDir);
+  let rel = path22.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`
@@ -21253,7 +21408,7 @@ var NamespaceReadFanoutCoordinator = class {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.deps.namespaceStorageDirHintsLoaded || !this.deps.namespaceCatalog.enabled) return;
     this.deps.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path22.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path23.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -21290,7 +21445,7 @@ var NamespaceReadFanoutCoordinator = class {
       if (!this.deps.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path22.resolve(record.storageDir);
+      const resolvedStorageDir = path23.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -21475,12 +21630,12 @@ var NamespaceReadFanoutCoordinator = class {
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      return path22.join(this.deps.config.memoryDir, "state");
+      return path23.join(this.deps.config.memoryDir, "state");
     }
     if (namespace !== this.deps.config.defaultNamespace) {
-      return path22.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
+      return path23.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path22.join(
+    const candidate = path23.join(
       this.deps.config.memoryDir,
       "namespaces",
       this.deps.config.defaultNamespace
@@ -21488,11 +21643,11 @@ var NamespaceReadFanoutCoordinator = class {
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path22.join(candidate, "state");
+        return path23.join(candidate, "state");
       }
     } catch {
     }
-    return path22.join(this.deps.config.memoryDir, "state");
+    return path23.join(this.deps.config.memoryDir, "state");
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return this.deps.config.defaultNamespace;
@@ -21972,7 +22127,7 @@ var Orchestrator = class {
     if (this.destroyed) throw new Error("orchestrator has been destroyed");
     if (!this._dependencyPropagationDelivery) {
       this._dependencyPropagationDelivery = new DependencyPropagationDelivery({
-        queueRoot: path23.join(this.config.memoryDir, "state", "dependency-propagation"),
+        queueRoot: path24.join(this.config.memoryDir, "state", "dependency-propagation"),
         config: this.config,
         extraction: this.extraction,
         getStorage: (namespace) => this.getStorage(namespace),
@@ -22323,7 +22478,7 @@ var Orchestrator = class {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path23.resolve(storageDir);
+    const resolvedStorageDir = path24.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -22334,21 +22489,21 @@ var Orchestrator = class {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path23.resolve(storageDir);
-    const resolvedMemoryDir = path23.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path24.resolve(storageDir);
+    const resolvedMemoryDir = path24.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path23.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path24.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path23.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path23.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path24.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path24.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path23.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path24.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path23.basename(resolvedStorageDir);
+    const leaf = path24.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -22489,7 +22644,7 @@ var Orchestrator = class {
     StorageManager.setOkfConformanceDefault(config.memoryDir, config.okf?.conformanceEnabled);
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path23.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path24.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -22567,7 +22722,7 @@ var Orchestrator = class {
     bindStorage(this.storage, this.config.defaultNamespace);
     this.storageRouter.onStorageCreated = bindStorage;
     this.storageRouter.forEachCachedStorage(bindStorage);
-    this.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+    this.extractionQueueCoordinator = new ExtractionQueueCoordinator(config.extractionQueueConcurrency);
     this.recallResultFormatter = new RecallResultFormatter(this.config);
     const conversationIndexRuntime = createConversationIndexRuntime(config, {
       getQmd: () => this.conversationQmd,
@@ -22580,7 +22735,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 = path23.join(
+    this.conversationIndexDir = path24.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -22731,7 +22886,7 @@ var Orchestrator = class {
       getHandleHistory: () => this.handleHistory
     });
     this.threading = new ThreadingManager(
-      path23.join(config.memoryDir, "threads"),
+      path24.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -24845,9 +25000,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path41 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path42 = 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 = path41 !== void 0 && kind !== void 0 ? { symbol, path: path41, kind } : path41 !== void 0 ? { symbol, path: path41 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path42 !== void 0 && kind !== void 0 ? { symbol, path: path42, kind } : path42 !== void 0 ? { symbol, path: path42 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -24921,7 +25076,7 @@ var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
 import fsp2 from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -24929,19 +25084,19 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = path24.resolve(basePath);
+    this.basePath = path25.resolve(basePath);
   }
   resolveRemotePath(remotePath) {
-    const resolved = path24.isAbsolute(remotePath) ? path24.resolve(remotePath) : path24.resolve(this.basePath, remotePath);
-    const relative = path24.relative(this.basePath, resolved);
-    if (relative === ".." || relative.startsWith(`..${path24.sep}`) || path24.isAbsolute(relative)) {
+    const resolved = path25.isAbsolute(remotePath) ? path25.resolve(remotePath) : path25.resolve(this.basePath, remotePath);
+    const relative = path25.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path25.sep}`) || path25.isAbsolute(relative)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return resolved;
   }
   isInsideBase(candidate, realBase) {
-    const relative = path24.relative(realBase, candidate);
-    return relative === "" || relative !== ".." && !relative.startsWith(`..${path24.sep}`) && !path24.isAbsolute(relative);
+    const relative = path25.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path25.sep}`) && !path25.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
@@ -24970,13 +25125,13 @@ var FilesystemBackend = class {
   }
   async ensureSafeParentDirectory(dest) {
     const realBase = await this.ensureBaseDirectory();
-    const destDir = path24.dirname(dest);
-    const relativeDir = path24.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path24.sep);
+    const destDir = path25.dirname(dest);
+    const relativeDir = path25.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path25.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path24.join(current, segment);
+      current = path25.join(current, segment);
       try {
         const stat5 = await fsp2.lstat(current);
         if (stat5.isSymbolicLink()) {
@@ -25004,13 +25159,13 @@ var FilesystemBackend = class {
     if (realBase === null) {
       return null;
     }
-    const destDir = path24.dirname(dest);
-    const relativeDir = path24.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path24.sep);
+    const destDir = path25.dirname(dest);
+    const relativeDir = path25.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path25.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path24.join(current, segment);
+      current = path25.join(current, segment);
       let stat5;
       try {
         stat5 = await fsp2.lstat(current);
@@ -25058,7 +25213,7 @@ var FilesystemBackend = class {
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path24.isAbsolute(remotePath)) {
+    if (path25.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
@@ -25131,7 +25286,7 @@ function createBackend(cfg) {
 
 // src/binary-lifecycle/scanner.ts
 import fsp3 from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -25156,8 +25311,8 @@ async function scanForBinaries(memoryDir, config, manifest) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path25.join(dir, entry.name);
-      const relativePath = path25.relative(memoryDir, fullPath).split(path25.sep).join("/");
+      const fullPath = path26.join(dir, entry.name);
+      const relativePath = path26.relative(memoryDir, fullPath).split(path26.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -25197,15 +25352,15 @@ async function hashFile(filePath) {
 
 // src/binary-lifecycle/manifest.ts
 import fsp4 from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
-  return path26.join(memoryDir, MANIFEST_DIR);
+  return path27.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path26.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path27.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
@@ -25257,13 +25412,13 @@ function emptyManifest() {
 
 // src/binary-lifecycle/pipeline.ts
 import fsp5 from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import crypto3 from "crypto";
 var historicalIdCache = new HistoricalEntityCanonicalIdCache();
 function isRecallCorpusMarkdown(mdPath, memoryDir) {
-  const rel = path27.relative(memoryDir, mdPath);
-  if (rel.startsWith("..") || path27.isAbsolute(rel)) return false;
-  const top = rel.split(path27.sep)[0];
+  const rel = path28.relative(memoryDir, mdPath);
+  if (rel.startsWith("..") || path28.isAbsolute(rel)) return false;
+  const top = rel.split(path28.sep)[0];
   return RECALL_FALLBACK_DIRS.includes(top);
 }
 async function hashFile2(filePath) {
@@ -25287,13 +25442,13 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function resolveManifestAssetPath(memoryDir, originalPath) {
-  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path27.isAbsolute(originalPath) || path27.win32.isAbsolute(originalPath)) {
+  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path28.isAbsolute(originalPath) || path28.win32.isAbsolute(originalPath)) {
     return null;
   }
-  const memoryRoot = path27.resolve(memoryDir);
-  const fullPath = path27.resolve(memoryRoot, originalPath);
-  const relative = path27.relative(memoryRoot, fullPath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path27.sep}`) || path27.isAbsolute(relative)) {
+  const memoryRoot = path28.resolve(memoryDir);
+  const fullPath = path28.resolve(memoryRoot, originalPath);
+  const relative = path28.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path28.sep}`) || path28.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -25304,7 +25459,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path27.sep).join("/");
+  const normalized = relPath.split(path28.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -25317,11 +25472,11 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
   for (const relPath of newPaths) {
-    const fullPath = path27.join(memoryDir, relPath);
+    const fullPath = path28.join(memoryDir, relPath);
     try {
       const stat5 = await fsp5.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path27.extname(relPath);
+      const ext = path28.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -25472,7 +25627,7 @@ async function stageRedirect(memoryDir, assets, log2, dryRun, readMarkdownFile,
     for (const update of updates) {
       try {
         await withRawEntityPageMutation(memoryDir, update.mdPath, async () => {
-          const stateDir = path27.join(memoryDir, "state");
+          const stateDir = path28.join(memoryDir, "state");
           const kind = classifyEntityRefWritePath(memoryDir, update.mdPath);
           if (kind === "memory") {
             const idsAtWrite = historicalIdCache.get(stateDir);
@@ -25565,10 +25720,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path27.dirname(mdPath);
+  const mdDir = path28.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path27.sep).join("/");
+    const normalized = candidate.split(path28.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -25576,10 +25731,10 @@ function markdownReferencePattern(asset, assetAbsolute, mdPath) {
       candidates.add(`./${normalized}`);
     }
   };
-  addCandidate(path27.relative(mdDir, assetAbsolute));
-  const originalPath = asset.originalPath.split(path27.sep).join("/");
-  const originalAsFileRelative = path27.resolve(mdDir, ...originalPath.split("/"));
-  if (path27.resolve(originalAsFileRelative) === path27.resolve(assetAbsolute)) {
+  addCandidate(path28.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path28.sep).join("/");
+  const originalAsFileRelative = path28.resolve(mdDir, ...originalPath.split("/"));
+  if (path28.resolve(originalAsFileRelative) === path28.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -25675,7 +25830,7 @@ async function findMarkdownFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path27.join(current, entry.name);
+      const full = path28.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -25750,7 +25905,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path28 from "path";
+import path29 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -25765,8 +25920,8 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  const resolvedMemoryDir = path28.resolve(memoryDir);
-  const resolvedOutputDir = path28.resolve(outputDir);
+  const resolvedMemoryDir = path29.resolve(memoryDir);
+  const resolvedOutputDir = path29.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -25804,7 +25959,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path28.join(memoryDir, "entities");
+    const entitiesDir = path29.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -25816,7 +25971,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path28.basename(filePath, ".md");
+        const fileName = path29.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -25828,7 +25983,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path28.join(memoryDir, "questions");
+    const questionsDir = path29.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -25869,8 +26024,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path28.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path28.isAbsolute(relative);
+  const relative = path29.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path29.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -25907,12 +26062,12 @@ function assertSafeInputRoot(realMemoryDir, targetPath, label) {
 }
 function assertSafeOutputTarget(realOutputDir, outputPath) {
   let current = realOutputDir;
-  const relative = path28.relative(realOutputDir, outputPath);
-  if (relative.startsWith("..") || path28.isAbsolute(relative)) {
+  const relative = path29.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path29.isAbsolute(relative)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
-  for (const segment of relative.split(path28.sep).filter(Boolean)) {
-    current = path28.join(current, segment);
+  for (const segment of relative.split(path29.sep).filter(Boolean)) {
+    current = path29.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -25942,17 +26097,17 @@ function validateProjectionCategories(categories) {
   return validated;
 }
 function resolveContainedOutputPath(outputRoot, ...segments) {
-  const resolved = path28.resolve(outputRoot, ...segments);
-  const relative = path28.relative(outputRoot, resolved);
-  if (relative === "" || !relative.startsWith("..") && !path28.isAbsolute(relative)) {
+  const resolved = path29.resolve(outputRoot, ...segments);
+  const relative = path29.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path29.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(path28.dirname(outputPath), { recursive: true });
-  const realParent = fs.realpathSync(path28.dirname(outputPath));
+  fs.mkdirSync(path29.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path29.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -25991,7 +26146,7 @@ function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path28.join(directory, entry.name);
+      const fullPath = path29.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -26044,13 +26199,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path28.basename(filePath, ".md");
-  const dateDir = path28.basename(path28.dirname(filePath));
+  const fileName = path29.basename(filePath, ".md");
+  const dateDir = path29.basename(path29.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path28.join(category, dateDir, `${fileName}.md`);
+    relPath = path29.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path28.join(category, `${fileName}.md`);
+    relPath = path29.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -26096,7 +26251,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path28.join("entities", `${fileName}.md`),
+    path: path29.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -26149,7 +26304,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path29 from "path";
+import path30 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -26251,7 +26406,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path29.resolve(options.directory ?? process.cwd());
+  const directory = path30.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -26293,7 +26448,7 @@ function walkDir(root, exclude, maxDepth) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path29.join(dir, entry.name);
+      const fullPath = path30.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -26308,11 +26463,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path29.extname(f).toLowerCase();
+    const ext = path30.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path29.dirname(f) === root).map((f) => path29.basename(f))
+    files.filter((f) => path30.dirname(f) === root).map((f) => path30.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -26356,7 +26511,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path29.dirname(f) === root).map((f) => path29.basename(f))
+    files.filter((f) => path30.dirname(f) === root).map((f) => path30.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -26367,7 +26522,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path29.join(root, "package.json"));
+    const pkg = readJsonSafe(path30.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -26381,13 +26536,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path29.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path30.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path29.join(root, "package.json"));
+    const pkg = readJsonSafe(path30.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -26421,8 +26576,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path29.basename(filePath).toLowerCase();
-    const relPath = path29.relative(root, filePath);
+    const basename = path30.basename(filePath).toLowerCase();
+    const relPath = path30.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -26434,7 +26589,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path29.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path30.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -26455,7 +26610,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path29.sep);
+  const parts = relPath.split(path30.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -26499,7 +26654,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path30 from "path";
+import path31 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -26590,12 +26745,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 = path30.join(dir, entry.name);
+      const fullPath = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path30.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path31.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -26604,12 +26759,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path30.resolve(targetPath);
+  const resolvedTarget = path31.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path30.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path31.dirname(resolvedTarget) : resolvedTarget;
 }
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path30.relative(projectRoot, path30.resolve(filePath)) || path30.basename(filePath);
+  const relativePath = path31.relative(projectRoot, path31.resolve(filePath)) || path31.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);
@@ -26703,7 +26858,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs3.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path30.join(memoryDir, dir);
+    const fullDir = path31.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -26726,11 +26881,11 @@ function writeStatement(stmt, memoryDir) {
   const now = /* @__PURE__ */ new Date();
   const dateDir = now.toISOString().split("T")[0];
   const categoryDir = getCategoryDir(memoryDir, stmt.category);
-  const dir = path30.join(categoryDir, dateDir);
+  const dir = path31.join(categoryDir, dateDir);
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path30.join(dir, fileName);
-  const historicalIds = historicalIdCache2.get(path30.join(memoryDir, "state"));
+  const filePath = path31.join(dir, fileName);
+  const historicalIds = historicalIdCache2.get(path31.join(memoryDir, "state"));
   const rawBody = `${[
     "---",
     `id: ${stmt.id}`,
@@ -26753,7 +26908,7 @@ ${stmt.content}
   fs3.writeFileSync(filePath, body);
   try {
     repairContentAfterJournalMoveSync({
-      stateDir: path30.join(memoryDir, "state"),
+      stateDir: path31.join(memoryDir, "state"),
       cache: historicalIdCache2,
       idsAtWrite: historicalIds,
       rawContent: rawBody,
@@ -26814,7 +26969,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path30.join(dir, entry.name);
+    const fullPath = path31.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -26825,7 +26980,7 @@ function walkFiles(dir, callback) {
 
 // src/sync/index.ts
 import fs4 from "fs";
-import path31 from "path";
+import path32 from "path";
 import crypto5 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -26847,7 +27002,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path31.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path32.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -26863,7 +27018,7 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs4.mkdirSync(path31.dirname(stateFilePath), { recursive: true });
+    fs4.mkdirSync(path32.dirname(stateFilePath), { recursive: true });
     fs4.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -26929,13 +27084,13 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path31.join(dir, entry.name);
+      const fullPath = path32.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path31.extname(entry.name).toLowerCase();
+        const ext = path32.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path31.relative(root, fullPath);
+        const relPath = path32.relative(root, fullPath);
         try {
           const content = fs4.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent2(content);
@@ -26950,7 +27105,7 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path31.join(sourceDir, relPath);
+    const fullPath = path32.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -26983,7 +27138,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path31.join(sourceDir, relPath),
+        filePath: path32.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -27013,21 +27168,21 @@ function hashContent2(content) {
 import { spawnSync } from "child_process";
 import crypto6 from "crypto";
 import fs5 from "fs";
-import path32 from "path";
+import path33 from "path";
 var historicalIdCache3 = new HistoricalEntityCanonicalIdCache();
 var MANIFEST_VERSION = 1;
 var MANIFEST_LOCK_STALE_MS = 3e4;
 var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
 var MANIFEST_LOCK_SLEEP_MS = 20;
 function normalizeSpaceMemoryDir(memoryDir) {
-  return path32.resolve(memoryDir);
+  return path33.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path32.join(homeDir, ".config", "engram", "spaces");
+  return path33.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path32.join(getSpacesDir(baseDir), "manifest.json");
+  return path33.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   if (fs5.existsSync(getManifestPath(baseDir))) {
@@ -27074,9 +27229,9 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path32.dirname(manifestPath2);
+  const manifestDir2 = path33.dirname(manifestPath2);
   fs5.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path32.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto6.randomUUID()}.tmp`);
+  const tempPath = path33.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto6.randomUUID()}.tmp`);
   try {
     fs5.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
@@ -27091,7 +27246,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs5.mkdirSync(path32.dirname(lockDir), { recursive: true });
+  fs5.mkdirSync(path33.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -27117,7 +27272,7 @@ function acquireManifestLock(lockDir) {
     try {
       fs5.mkdirSync(lockDir, { recursive: false });
       try {
-        fs5.writeFileSync(path32.join(lockDir, "owner"), `${owner}
+        fs5.writeFileSync(path33.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
         fs5.rmSync(lockDir, { recursive: true, force: true });
@@ -27147,7 +27302,7 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path32.join(lockDir, "owner");
+    const ownerPath = path33.join(lockDir, "owner");
     if (fs5.readFileSync(ownerPath, "utf8").trim() === owner) {
       fs5.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -27163,7 +27318,7 @@ function removeStaleManifestLock(lockDir) {
   try {
     fs5.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs5.writeFileSync(path32.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs5.writeFileSync(path33.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
       fs5.rmSync(reclaimDir, { recursive: true, force: true });
@@ -27238,7 +27393,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs5.readFileSync(path32.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs5.readFileSync(path33.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -27310,8 +27465,8 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path32.join(homeDir, ".engram", "memory");
-  const openclawPath = path32.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const standalonePath = path33.join(homeDir, ".engram", "memory");
+  const openclawPath = path33.join(homeDir, ".openclaw", "workspace", "memory", "local");
   const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs5.existsSync(standalonePath) ? standalonePath : fs5.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -27340,7 +27495,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 ?? path32.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path33.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -27586,14 +27741,14 @@ async function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path32.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path33.join(getSpacesDir(baseDir), "audit.jsonl");
   if (!fs5.existsSync(auditPath)) return [];
   const lines = fs5.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path32.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs5.mkdirSync(path32.dirname(auditPath), { recursive: true });
+  const auditPath = path33.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs5.mkdirSync(path33.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto6.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -27614,11 +27769,11 @@ async function copyMemories(sourceDir, targetDir, options) {
     sourceFiles.filter((p) => {
       const rp = safeRealpath(p);
       if (!rp || !isPathInsideRoot(rp, sourceRoot)) return false;
-      const rel = path32.relative(sourceRoot, rp);
-      const mapped = path32.resolve(targetRoot, rel);
+      const rel = path33.relative(sourceRoot, rp);
+      const mapped = path33.resolve(targetRoot, rel);
       if (!isPathInsideRoot(mapped, targetRoot)) return false;
       return classifyEntityRefWritePath(targetRoot, mapped) === "entity";
-    }).map((p) => path32.basename(p, ".md"))
+    }).map((p) => path33.basename(p, ".md"))
   );
   const firstEntityId = sourceEntityIds.values().next().value;
   if (firstEntityId === void 0) {
@@ -27626,7 +27781,7 @@ async function copyMemories(sourceDir, targetDir, options) {
   }
   return withRawEntityPageMutation(
     targetRoot,
-    path32.join(targetRoot, "entities", `${firstEntityId}.md`),
+    path33.join(targetRoot, "entities", `${firstEntityId}.md`),
     async () => copyPreparedMemories(
       sourceFiles,
       sourceRoot,
@@ -27653,14 +27808,14 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       continue;
     }
     const content = fs5.readFileSync(sourcePath, "utf8");
-    const relativePath = path32.relative(sourceRoot, sourceRealPath);
-    const targetPath = path32.resolve(targetRoot, relativePath);
+    const relativePath = path33.relative(sourceRoot, sourceRealPath);
+    const targetPath = path33.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
     }
     const targetKind = classifyEntityRefWritePath(targetRoot, targetPath);
-    const idsAtCompare = historicalIdCache3.get(path32.join(targetRoot, "state"));
+    const idsAtCompare = historicalIdCache3.get(path33.join(targetRoot, "state"));
     const sourceRef = targetKind === "memory" ? readEntityRefFromFrontmatter(content) : null;
     const refHasSourceClaimant = sourceRef !== null && sourceEntityIds.has(sourceRef);
     const canonicalContent = targetKind === "memory" && !refHasSourceClaimant ? canonicalizeEntityRefFrontmatter(content, idsAtCompare) : content;
@@ -27687,7 +27842,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     if (fs5.existsSync(targetPath) && !options?.force) {
       const targetContent = fs5.readFileSync(targetPath, "utf8");
       const targetHash = hashContent3(targetContent);
-      if (hashContent3(canonicalContent) === targetHash && historicalIdCache3.get(path32.join(targetRoot, "state")) === idsAtCompare) {
+      if (hashContent3(canonicalContent) === targetHash && historicalIdCache3.get(path33.join(targetRoot, "state")) === idsAtCompare) {
         skipped++;
         continue;
       }
@@ -27703,13 +27858,13 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    fs5.mkdirSync(path32.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path32.dirname(targetPath));
+    fs5.mkdirSync(path33.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path33.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
     }
-    const stateDir = path32.join(targetRoot, "state");
+    const stateDir = path33.join(targetRoot, "state");
     if (targetKind === "memory" && !refHasSourceClaimant) {
       const idsAtWrite = historicalIdCache3.get(stateDir);
       const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
@@ -27753,7 +27908,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     bumpMemoryCorpusVersionForDir(targetRoot);
   }
   if (reconcileNeeded) {
-    requestEntityCanonicalIdReconcileSync(path32.join(targetRoot, "state"));
+    requestEntityCanonicalIdReconcileSync(path33.join(targetRoot, "state"));
   }
   return { merged, conflicts, skipped };
 }
@@ -27764,7 +27919,7 @@ function walkMd(dir) {
   const results = [];
   function walk(d) {
     for (const entry of fs5.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path32.join(d, entry.name);
+      const fullPath = path33.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -27793,8 +27948,8 @@ function safeRealpath(filePath) {
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path32.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path32.isAbsolute(relative);
+  const relative = path33.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path33.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -27915,7 +28070,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 // src/memory-extension/codex-publisher.ts
 import fs6 from "fs";
 import os from "os";
-import path33 from "path";
+import path34 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -27924,12 +28079,12 @@ function resolveEnvHome(env) {
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path33.join(homeDir, input.slice(2));
+    return path34.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path33.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path34.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -27943,12 +28098,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) : path33.resolve(homeDir, ".codex");
-    return path33.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path34.resolve(homeDir, ".codex");
+    return path34.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path33.join(resolveHomeDir(), ".codex");
+      const home = readEnvVar("CODEX_HOME")?.trim() || path34.join(resolveHomeDir(), ".codex");
       return fs6.existsSync(home);
     } catch {
       return false;
@@ -27999,7 +28154,7 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path33.join(extensionRoot, "instructions.md");
+    const instructionsPath = path34.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -28631,9 +28786,9 @@ function buildWeeklyActivitySummary(cards, options) {
 // src/activity/timeline/weekly-persist.ts
 import { randomBytes as randomBytes3 } from "crypto";
 import { mkdirSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
-import path34 from "path";
+import path35 from "path";
 var WEEKLY_SNAPSHOT_FORMAT_VERSION = 1;
-var WEEKLY_SNAPSHOT_DIR = path34.join("activity", "weekly");
+var WEEKLY_SNAPSHOT_DIR = path35.join("activity", "weekly");
 function requireToken(value, name) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new TypeError(`${name} must be a non-empty string`);
@@ -28656,8 +28811,8 @@ function weeklySnapshotPath(input) {
   const identity = hashActivityBody(
     `${input.summary.weekStartUtc}\0${input.summary.weekEndUtc}\0${sourceRevision}\0${configHash}`
   );
-  return path34.join(
-    path34.resolve(memoryDir),
+  return path35.join(
+    path35.resolve(memoryDir),
     WEEKLY_SNAPSHOT_DIR,
     namespaceIdentityToken(namespace),
     `${weekDate}--${identity}.json`
@@ -28687,7 +28842,7 @@ function persistWeeklySnapshot(input) {
       throw error;
     }
   }
-  mkdirSync(path34.dirname(filePath), { recursive: true, mode: 448 });
+  mkdirSync(path35.dirname(filePath), { recursive: true, mode: 448 });
   const tmpPath = `${filePath}.${process.pid}.${randomBytes3(8).toString("hex")}.tmp`;
   writeFileSync(tmpPath, text, { encoding: "utf8", mode: 384 });
   try {
@@ -29339,7 +29494,7 @@ function selectRecapForDay(input) {
 
 // src/activity/journal-read.ts
 import { closeSync, constants as fsConstants, fstatSync, lstatSync, openSync, readFileSync as readFileSync3, realpathSync, statSync as statSync2 } from "fs";
-import path35 from "path";
+import path36 from "path";
 
 // src/activity/journal-section.ts
 function parseAtxHeading(line) {
@@ -29530,8 +29685,8 @@ function readJournalForDate(input) {
   const relative = resolveVaultNotePath(input.vault.dailyNotePath, input.date, {
     timezone: input.timezone
   });
-  const root = path35.resolve(expandTildePath(input.vault.vaultPath));
-  const filePath = path35.join(root, relative);
+  const root = path36.resolve(expandTildePath(input.vault.vaultPath));
+  const filePath = path36.join(root, relative);
   try {
     const rootStat = lstatSync(root);
     if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
@@ -29540,8 +29695,8 @@ function readJournalForDate(input) {
   } catch {
     return { ok: true, exists: false, reason: "missing_file", filePath };
   }
-  const lexical = path35.relative(root, filePath);
-  if (lexical.length === 0 || lexical === ".." || lexical.startsWith(`..${path35.sep}`) || path35.isAbsolute(lexical)) {
+  const lexical = path36.relative(root, filePath);
+  if (lexical.length === 0 || lexical === ".." || lexical.startsWith(`..${path36.sep}`) || path36.isAbsolute(lexical)) {
     return { ok: false, reason: "path_escape", filePath };
   }
   if (!containedBySymlinks(root, filePath)) {
@@ -29574,11 +29729,11 @@ function containedBySymlinks(root, dest) {
     try {
       if (statSync2(probe).isFile() || statSync2(probe).isDirectory()) {
         const real = realpathSync(probe);
-        return real === realRoot || real.startsWith(`${realRoot}${path35.sep}`);
+        return real === realRoot || real.startsWith(`${realRoot}${path36.sep}`);
       }
     } catch {
     }
-    const parent = path35.dirname(probe);
+    const parent = path36.dirname(probe);
     if (parent === probe) return false;
     probe = parent;
   }
@@ -29589,15 +29744,15 @@ function symlinkRejected() {
   return err;
 }
 function readVerifiedDailyNote(root, filePath) {
-  const relative = path35.relative(root, filePath);
-  const parts = relative.split(path35.sep).filter((part) => part.length > 0 && part !== ".");
+  const relative = path36.relative(root, filePath);
+  const parts = relative.split(path36.sep).filter((part) => part.length > 0 && part !== ".");
   let cursor = root;
   for (const part of parts) {
-    cursor = path35.join(cursor, part);
+    cursor = path36.join(cursor, part);
     const st = lstatSync(cursor);
     if (st.isSymbolicLink()) throw symlinkRejected();
   }
-  const parent = path35.dirname(filePath);
+  const parent = path36.dirname(filePath);
   const parentLstat = lstatSync(parent);
   if (parentLstat.isSymbolicLink() || !parentLstat.isDirectory()) throw symlinkRejected();
   const nofollow = fsConstants.O_NOFOLLOW ?? 0;
@@ -29621,7 +29776,7 @@ function readVerifiedDailyNote(root, filePath) {
     try {
       const fdPath = realpathSync(`/proc/self/fd/${fd}`);
       const realRoot = realpathSync(root);
-      if (fdPath !== realRoot && !fdPath.startsWith(`${realRoot}${path35.sep}`)) {
+      if (fdPath !== realRoot && !fdPath.startsWith(`${realRoot}${path36.sep}`)) {
         throw symlinkRejected();
       }
     } catch (err) {
@@ -29636,11 +29791,11 @@ function readVerifiedDailyNote(root, filePath) {
 // src/activity/journal-state.ts
 import { createHash as createHash11, randomBytes as randomBytes4 } from "crypto";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
-import path36 from "path";
+import path37 from "path";
 var STATE_DIR_NAME = "state";
 var STATE_FILE_NAME = "timeline.json";
 function timelineStatePath(memoryDir) {
-  return path36.join(memoryDir, STATE_DIR_NAME, STATE_FILE_NAME);
+  return path37.join(memoryDir, STATE_DIR_NAME, STATE_FILE_NAME);
 }
 function hashJournalText(text) {
   return createHash11("sha256").update(text, "utf8").digest("hex");
@@ -29666,14 +29821,14 @@ function readTimelineState(memoryDir) {
 }
 function writeTimelineState(memoryDir, state) {
   const filePath = timelineStatePath(memoryDir);
-  mkdirSync2(path36.dirname(filePath), { recursive: true });
+  mkdirSync2(path37.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${randomBytes4(8).toString("hex")}.tmp`;
   writeFileSync2(tempPath, `${JSON.stringify(state, null, 2)}
 `);
   renameSync2(tempPath, filePath);
 }
 function journalDateLockPath(memoryDir, date) {
-  return path36.join(memoryDir, STATE_DIR_NAME, `journal-extract-${date}.lock`);
+  return path37.join(memoryDir, STATE_DIR_NAME, `journal-extract-${date}.lock`);
 }
 function timelineStateLockPath(memoryDir) {
   return `${timelineStatePath(memoryDir)}.lock`;
@@ -30381,7 +30536,7 @@ function normalizeDropKeys(keys) {
 }
 
 // src/activity/vault-wikilink.ts
-import path37 from "path";
+import path38 from "path";
 function formatVaultWikilink(notePath) {
   if (typeof notePath !== "string" || notePath.trim().length === 0) {
     throw new RangeError("Vault wikilink path must be a non-empty relative path.");
@@ -30389,7 +30544,7 @@ function formatVaultWikilink(notePath) {
   if (notePath.includes("\n") || notePath.includes("\r")) {
     throw new RangeError("Vault wikilink path must not contain newlines.");
   }
-  if (path37.posix.isAbsolute(notePath) || path37.win32.isAbsolute(notePath)) {
+  if (path38.posix.isAbsolute(notePath) || path38.win32.isAbsolute(notePath)) {
     throw new RangeError("Vault wikilink path must be relative; absolute paths are rejected.");
   }
   if (notePath.split(/[\\/]/).some((segment) => segment === "..")) {
@@ -30411,7 +30566,7 @@ function stripVaultMdSuffix(notePath) {
 }
 
 // src/activity/vault-join.ts
-import path38 from "path";
+import path39 from "path";
 function joinVaultSegments(parts) {
   if (parts.length === 0) {
     throw new RangeError("Vault path parts must be a non-empty list.");
@@ -30426,7 +30581,7 @@ function joinVaultSegments(parts) {
     if (part.includes("\n") || part.includes("\r")) {
       throw new RangeError("Vault path part must not contain a newline.");
     }
-    if (path38.posix.isAbsolute(part) || path38.win32.isAbsolute(part)) {
+    if (path39.posix.isAbsolute(part) || path39.win32.isAbsolute(part)) {
       throw new RangeError("Vault path part must be relative.");
     }
     if (part.split("/").includes("..")) {
@@ -30481,7 +30636,7 @@ function planVaultDryRun(inputs) {
 // src/session-summaries/index.ts
 import { createHash as createHash12 } from "crypto";
 import { lstat as lstat3, mkdir as mkdir7, readFile as readFile9, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -30986,7 +31141,7 @@ function shortHash(value, length = 16) {
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path39.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path40.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -30996,13 +31151,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path39.join(dir, entry.name);
+      const fullPath = path40.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path39.extname(entry.name).toLowerCase();
+      const ext = path40.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -31029,7 +31184,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path39.resolve(expandTildePath(inputDir.trim()));
+  return path40.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -31186,11 +31341,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path39.extname(filePath).toLowerCase();
+    const fileExtension = path40.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path39.basename(filePath),
+        fileName: path40.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -31246,7 +31401,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile9(path39.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile9(path40.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");
@@ -31259,15 +31414,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path39.join(
-    path39.resolve(expandTildePath(memoryDir)),
+  return path40.join(
+    path40.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path39.dirname(filePath), { recursive: true });
+  await mkdir7(path40.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -31285,7 +31440,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path39.resolve(expandTildePath(options.output));
+    const outputPath = path40.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -31320,19 +31475,19 @@ async function runLocalSessionSummaryCliCommand(options) {
 
 // src/transfer/capsule-fork.ts
 import { lstat as lstat4, mkdir as mkdir8, readFile as readFile10, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
-import path40 from "path";
+import path41 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path40.resolve(opts.targetRoot);
+  const rootAbs = path41.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path40.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path41.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 = path40.resolve(opts.sourceArchive);
+  const archiveAbs = path41.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -31354,10 +31509,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path40.join(forkDirAbs, "lineage.json");
+  const lineagePath = path41.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path40.dirname(lineagePath), { recursive: true });
+  await mkdir8(path41.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -31371,11 +31526,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 = path40.resolve(targetRoot);
+  const rootAbs = path41.resolve(targetRoot);
   const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
-  const lineagePath = path40.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path40.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path40.isAbsolute(rel)) {
+  const lineagePath = path41.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path41.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path41.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
@@ -31416,19 +31571,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path40.dirname(existing)) {
+  while (existing !== path41.dirname(existing)) {
     const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path40.basename(existing));
-    existing = path40.dirname(existing);
+    suffix.unshift(path41.basename(existing));
+    existing = path41.dirname(existing);
   }
   const existingReal = await realpath3(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path40.join(existingReal, ...suffix) : existingReal;
-  const rel = path40.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path41.join(existingReal, ...suffix) : existingReal;
+  const rel = path41.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path40.sep}`)) return false;
-  if (path40.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path41.sep}`)) return false;
+  if (path41.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -31621,4 +31776,4 @@ export {
   qmdStartupCollectionChecksWithTimeout,
   Orchestrator
 };
-//# sourceMappingURL=chunk-XMBDI725.js.map
+//# sourceMappingURL=chunk-FAF4A76Q.js.map