@remnic/core 9.51.0 → 9.52.0

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

@@ -13,7 +13,7 @@ import {
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-OYESWJ43.js";
+} from "./chunk-WLRD2TXF.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UT5BV5OG.js";
+} from "./chunk-7HXZJAID.js";
 import {
   SharedContextManager
 } from "./chunk-M23RF3LJ.js";
@@ -190,7 +190,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-CV6BBVYV.js";
+} from "./chunk-TEMSWHQD.js";
 import {
   buildEventOrderRecallSection,
   shouldRecallEventOrderEvidence
@@ -207,7 +207,7 @@ import {
 } from "./chunk-YK6BDDHP.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-W5XVQFLM.js";
+} from "./chunk-GXFSQ6SD.js";
 import {
   formatDaySummaryMemories
 } from "./chunk-RPSYDM6C.js";
@@ -216,7 +216,7 @@ import {
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors
-} from "./chunk-DCZBSE4F.js";
+} from "./chunk-D5YOZ66N.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
@@ -226,14 +226,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-FXTYIA46.js";
+} from "./chunk-J272WKX2.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-QGR6OVGT.js";
+} from "./chunk-VFSAWRMZ.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-WT6UL3UA.js";
@@ -246,14 +246,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-6MTSFX7A.js";
+} from "./chunk-X7XEDOSL.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-4PC4PRJE.js";
+} from "./chunk-BKIFTXHR.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-AZ2QBGYB.js";
+} from "./chunk-W7Y5JDVB.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -285,7 +285,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-VVG2BOKA.js";
+} from "./chunk-BMEYMKWX.js";
 import {
   BootstrapEngine
 } from "./chunk-MYVPLJOO.js";
@@ -331,7 +331,7 @@ import {
 } from "./chunk-KD3QD3A5.js";
 import {
   MeetingsInputError
-} from "./chunk-XADV5IZ3.js";
+} from "./chunk-HDIUYMSB.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -352,10 +352,10 @@ import {
   filterRecallCandidates,
   isGenericRecallExcludedPath,
   isTopLevelArchivePath
-} from "./chunk-J5LLX6IL.js";
+} from "./chunk-BF6SXNQJ.js";
 import {
   importCapsule
-} from "./chunk-ZQOCRIGA.js";
+} from "./chunk-QYN5PXDZ.js";
 import {
   isCodingGraphInstalled
 } from "./chunk-VQ7B2Q6M.js";
@@ -396,7 +396,7 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-37ZO6LLJ.js";
+} from "./chunk-RYLEDKQ2.js";
 import {
   NamespaceSearchRouter,
   namespaceCollectionName
@@ -411,7 +411,7 @@ import {
 } from "./chunk-CYEPCZN5.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-WQM326GS.js";
+} from "./chunk-2LY6GIIE.js";
 import {
   writeConversationChunks
 } from "./chunk-72A4L5JJ.js";
@@ -423,7 +423,7 @@ import {
 } from "./chunk-BIJAWZYW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-52UKFTUK.js";
+} from "./chunk-F4EU6VUC.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -442,7 +442,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-VBHPOWBJ.js";
+} from "./chunk-WD5B5AIE.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -455,7 +455,7 @@ import {
 } from "./chunk-UHVXE24Y.js";
 import {
   buildRetiredFactTombstoneInputs
-} from "./chunk-ENTCVTQR.js";
+} from "./chunk-JJRVPWFY.js";
 import {
   canRecallToolScopedMemory,
   shouldPromoteGlobalFactToShared,
@@ -506,15 +506,15 @@ import {
   requestEntityCanonicalIdReconcile,
   requestEntityCanonicalIdReconcileSync,
   withRawEntityPageMutation
-} from "./chunk-M4A44LUA.js";
+} from "./chunk-GSTIBXBW.js";
 import {
   applyTemporalSupersession,
+  applyTemporalSupersessionPrimaryMutation,
   lookupAttributeByNormalizedKey,
   normalizeSupersessionKey,
-  propagateInvalidation,
   shouldFilterSupersededFromRecall,
   supersessionKeysForFact
-} from "./chunk-EWMTOVMY.js";
+} from "./chunk-5WITETWU.js";
 import {
   isValidAsOf,
   isValidityExpiredNow
@@ -681,7 +681,16 @@ import {
   throwIfAborted
 } from "./chunk-BTTPKDIL.js";
 import {
-  isPathInsideStorageRoot
+  isRecord
+} from "./chunk-A2IYSXDQ.js";
+import {
+  listJsonFilesStrict,
+  withJsonStoreMutationLock,
+  writeJsonFileAtomic
+} from "./chunk-P77QX3ID.js";
+import {
+  isPathInsideStorageRoot,
+  resolveSafeStoragePath
 } from "./chunk-FF4KLI5W.js";
 import {
   SecureStoreLockedError
@@ -700,8 +709,8 @@ import {
 } from "./chunk-3WCASNQZ.js";
 
 // src/orchestrator.ts
-import path19 from "path";
-import { createHash as createHash6 } from "crypto";
+import path20 from "path";
+import { createHash as createHash8 } from "crypto";
 
 // src/orchestration/tier-migration-coordinator.ts
 import path from "path";
@@ -898,6 +907,7 @@ var ExtractionQueueCoordinator = class {
   queue = [];
   /** Whether the serial drain loop is currently running. */
   processing = false;
+  accepting = true;
   /** Current queue depth (idle-wait + test seam). */
   get length() {
     return this.queue.length;
@@ -912,6 +922,7 @@ var ExtractionQueueCoordinator = class {
    * builds each task closure and hands it here.
    */
   enqueue(task) {
+    if (!this.accepting) return false;
     this.queue.push(task);
     if (!this.processing) {
       this.processing = true;
@@ -920,6 +931,23 @@ var ExtractionQueueCoordinator = class {
         this.processing = false;
       });
     }
+    return true;
+  }
+  /** Stop new producers from entering the queue. */
+  stopAccepting() {
+    this.accepting = false;
+  }
+  /** Resume producer acceptance after an orchestrator re-initializes. */
+  resumeAccepting() {
+    this.accepting = true;
+  }
+  /** Stop new producers and wait for all accepted work to finish. */
+  async pauseAndDrain(timeoutMs = 6e4) {
+    this.stopAccepting();
+    if (await this.waitForIdle(timeoutMs)) return true;
+    log.warn("extraction queue drain exceeded timeout; waiting for accepted work to settle");
+    await this.waitForIdle(Number.POSITIVE_INFINITY);
+    return true;
   }
   /**
    * Background serial queue processor.
@@ -2195,7 +2223,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
       namespaces,
       {
         readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path34, preferredNamespace) => {
+        readMemoryFrontmatter: async (path35, preferredNamespace) => {
           if (!fallbackReader) {
             for (const ns of namespaces) {
               try {
@@ -2207,7 +2235,7 @@ var RecallRerankCoordinator = class _RecallRerankCoordinator {
           }
           if (!fallbackReader) return null;
           const memory = await this.readQmdResultMemory(
-            path34,
+            path35,
             fallbackReader,
             namespaces,
             preferredNamespace
@@ -2819,6 +2847,214 @@ async function localizeUpdateCandidates(deps, anchor, newContent, options) {
   return merged;
 }
 
+// src/orchestration/dependency-propagation.ts
+function isDependencyPropagationEnabled(config) {
+  const parsed = propagationConfig(config);
+  return isEnabled(parsed.enabled) && parsed.maxDependents > 0;
+}
+function propagationConfig(config) {
+  return config.dependencyPropagation;
+}
+function isEnabled(value) {
+  if (value === true) return true;
+  if (typeof value !== "string") return false;
+  return ["true", "1", "yes", "on"].includes(value.trim().toLowerCase());
+}
+var ACTIVE_STATUS = "active";
+function findDependents(memories, oldMemory, linkTypes = ["supports", "follows"]) {
+  const allowed = new Set(linkTypes);
+  const ids = /* @__PURE__ */ new Set();
+  const byId = new Map(memories.map((memory) => [memory.frontmatter.id, memory]));
+  for (const link of oldMemory.frontmatter.links ?? []) {
+    if (link.linkType !== "supports" && link.linkType !== "references") continue;
+    if (!allowed.has(link.linkType)) continue;
+    const dependent = byId.get(link.targetId);
+    if (dependent && (dependent.frontmatter.status ?? ACTIVE_STATUS) === ACTIVE_STATUS) {
+      ids.add(dependent.frontmatter.id);
+    }
+  }
+  const oldId = oldMemory.frontmatter.id;
+  for (const memory of memories) {
+    if ((memory.frontmatter.status ?? ACTIVE_STATUS) !== ACTIVE_STATUS) continue;
+    if (memory.frontmatter.id === oldId) continue;
+    for (const link of memory.frontmatter.links ?? []) {
+      if (link.targetId !== oldId) continue;
+      if (link.linkType !== "follows" && link.linkType !== "references") continue;
+      if (!allowed.has(link.linkType)) continue;
+      ids.add(memory.frontmatter.id);
+    }
+  }
+  return Array.from(ids).map((id) => byId.get(id)).filter((memory) => memory !== void 0).sort((a, b) => {
+    const left = a.frontmatter.id;
+    const right = b.frontmatter.id;
+    return left < right ? -1 : left > right ? 1 : 0;
+  });
+}
+function emptyResult(skipped, durationMs, route = null, dependentsFound = 0) {
+  return { dependentsFound, invalidated: 0, stillValid: 0, uncertain: 0, skipped, route, durationMs };
+}
+function logResult(event, result) {
+  const oldId = event.oldMemory.frontmatter.id;
+  log.info(
+    `dependency-propagation ${JSON.stringify({
+      cause: event.cause,
+      oldId,
+      dependentsFound: result.dependentsFound,
+      invalidated: result.invalidated,
+      stillValid: result.stillValid,
+      uncertain: result.uncertain,
+      skipped: result.skipped,
+      route: result.route,
+      durationMs: result.durationMs
+    })}`
+  );
+}
+var PropagationTimeoutError = class extends Error {
+  constructor() {
+    super("dependency propagation timed out");
+    this.name = "PropagationTimeoutError";
+  }
+};
+function isTimeoutError(error, signal) {
+  return signal.aborted || error instanceof PropagationTimeoutError || error instanceof Error && (error.name === "AbortError" || /timeout|timed out/i.test(error.message));
+}
+async function propagateInvalidation(deps, event) {
+  const startedAt = Date.now();
+  const config = propagationConfig(deps.config);
+  if (!isEnabled(config.enabled)) {
+    const result2 = emptyResult("disabled", Date.now() - startedAt);
+    logResult(event, result2);
+    return result2;
+  }
+  const maxDependents = config.maxDependents;
+  if (maxDependents <= 0) {
+    const result2 = emptyResult("no_dependents", Date.now() - startedAt);
+    logResult(event, result2);
+    return result2;
+  }
+  let memories;
+  try {
+    memories = await deps.storage.readAllMemories();
+  } catch (error) {
+    log.warn(`dependency propagation discovery failed for ${event.oldMemory.frontmatter.id}: ${error}`);
+    const result2 = emptyResult("llm_error", Date.now() - startedAt);
+    logResult(event, result2);
+    return result2;
+  }
+  const discovered = findDependents(
+    memories,
+    event.oldMemory,
+    config.linkTypes
+  ).filter((memory) => memory.frontmatter.id !== event.replacementId);
+  const dependents = discovered.slice(0, Math.max(0, Math.floor(maxDependents)));
+  if (dependents.length === 0) {
+    const result2 = emptyResult("no_dependents", Date.now() - startedAt);
+    logResult(event, result2);
+    return result2;
+  }
+  const controller = new AbortController();
+  const timeoutMs = config.timeoutMs;
+  let timedOut = false;
+  let timeout;
+  const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? new Promise((_, reject) => {
+    timeout = setTimeout(() => {
+      timedOut = true;
+      const error = new PropagationTimeoutError();
+      controller.abort(error);
+      reject(error);
+    }, timeoutMs);
+  }) : void 0;
+  const revalidation = Promise.resolve().then(() => deps.extraction.revalidateDependents(
+    { id: event.oldMemory.frontmatter.id, content: event.oldMemory.content },
+    event.replacementId && event.replacementContent !== null ? { id: event.replacementId, content: event.replacementContent } : null,
+    dependents.map((memory) => ({
+      id: memory.frontmatter.id,
+      category: memory.frontmatter.category,
+      content: memory.content
+    })),
+    controller.signal
+  ));
+  let verdicts;
+  try {
+    const response = deadline ? await Promise.race([revalidation, deadline]) : await revalidation;
+    if (timedOut || controller.signal.aborted) {
+      const result2 = emptyResult(
+        "timeout",
+        Date.now() - startedAt,
+        "fast-completion",
+        dependents.length
+      );
+      logResult(event, result2);
+      return result2;
+    }
+    verdicts = response.verdicts;
+  } catch (error) {
+    const result2 = emptyResult(
+      timedOut || isTimeoutError(error, controller.signal) ? "timeout" : "llm_error",
+      Date.now() - startedAt,
+      "fast-completion",
+      dependents.length
+    );
+    log.warn(`dependency propagation revalidation failed for ${event.oldMemory.frontmatter.id}: ${error}`);
+    logResult(event, result2);
+    return result2;
+  } finally {
+    clearTimeout(timeout);
+  }
+  let invalidated = 0;
+  let stillValid = 0;
+  let uncertain = 0;
+  for (const dependent of dependents) {
+    const verdict = verdicts.find((candidate) => candidate.memoryId === dependent.frontmatter.id);
+    if (verdict?.verdict === "invalidated") {
+      if (config.dryRun) {
+        invalidated += 1;
+        continue;
+      }
+      try {
+        const replacementId = event.replacementId ?? event.oldMemory.frontmatter.id;
+        const write = () => deps.storage.supersedeMemory(
+          dependent.frontmatter.id,
+          replacementId,
+          `dependency_propagation:${event.cause}`,
+          {
+            supersessionCause: "dependency",
+            invalidatedBy: event.oldMemory.frontmatter.id
+          },
+          {
+            requireActive: true,
+            acceptExactReplay: true,
+            expectedSnapshot: dependent
+          }
+        );
+        const superseded = deps.writeFence ? await deps.writeFence(write) : await write();
+        if (superseded !== true) continue;
+        invalidated += 1;
+      } catch (error) {
+        log.warn(`dependency propagation write failed for ${dependent.frontmatter.id}: ${error}`);
+      }
+      continue;
+    }
+    if (verdict?.verdict === "still_valid") {
+      stillValid += 1;
+    } else {
+      uncertain += 1;
+      log.info(`dependency propagation uncertain for ${dependent.frontmatter.id}`);
+    }
+  }
+  const result = {
+    dependentsFound: dependents.length,
+    invalidated,
+    stillValid,
+    uncertain,
+    skipped: null,
+    route: "fast-completion",
+    durationMs: Date.now() - startedAt
+  };
+  logResult(event, result);
+  return result;
+}
+
 // src/orchestration/contradiction-linking-coordinator.ts
 var ContradictionLinkingCoordinator = class {
   getConfig;
@@ -2828,6 +3064,8 @@ var ContradictionLinkingCoordinator = class {
   namespaceFromPath;
   storageForNamespace;
   getExtraction;
+  storageDirNamespace;
+  getDependencyPropagationDelivery;
   constructor(options) {
     this.getConfig = options.getConfig;
     this.isSearchAvailable = options.isSearchAvailable;
@@ -2836,6 +3074,10 @@ var ContradictionLinkingCoordinator = class {
     this.namespaceFromPath = options.namespaceFromPath;
     this.storageForNamespace = options.storageForNamespace;
     this.getExtraction = options.getExtraction;
+    this.storageDirNamespace = options.storageDirNamespace ?? (() => "default");
+    this.getDependencyPropagationDelivery = options.getDependencyPropagationDelivery ?? (() => {
+      throw new Error("dependency propagation delivery is unavailable");
+    });
   }
   /**
    * Check if a new memory contradicts an existing one.
@@ -3017,28 +3259,165 @@ var ContradictionLinkingCoordinator = class {
       return postWriteGuard ? "blocked" : "not_attempted";
     }
     let oldMemory = null;
-    if (coerceBool(config.dependencyPropagation?.enabled) === true) {
+    let replacementContent = null;
+    let propagationEvent = null;
+    try {
+      const [hot, cold] = await Promise.all([
+        typeof storage.readAllMemories === "function" ? storage.readAllMemories() : Promise.resolve([]),
+        typeof storage.readAllColdMemories === "function" ? storage.readAllColdMemories() : Promise.resolve([])
+      ]);
+      const memories = mergeMemorySnapshots(hot, cold, storage.dir);
+      const captured = memories.find(
+        (memory) => memory.frontmatter.id === contradiction.supersededId && inferLocalizationMemoryStatus(memory, storage.dir) === "active"
+      );
+      if (captured) {
+        oldMemory = {
+          content: captured.content,
+          frontmatter: {
+            ...captured.frontmatter,
+            ...captured.frontmatter.tags ? { tags: [...captured.frontmatter.tags] } : {},
+            ...captured.frontmatter.links ? { links: captured.frontmatter.links.map((link) => ({ ...link })) } : {}
+          },
+          path: captured.path
+        };
+      }
+      replacementContent = memories.find((memory) => memory.frontmatter.id === newMemoryId)?.content ?? (await storage.getMemoryById(newMemoryId))?.content ?? null;
+    } catch (err) {
+      log.warn(
+        `contradiction propagation snapshot failed for ${contradiction.supersededId}: ${err}`
+      );
+    }
+    if (oldMemory && replacementContent !== null) {
       try {
-        const [hot, cold] = await Promise.all([
-          typeof storage.readAllMemories === "function" ? storage.readAllMemories() : storage.getMemoryById(contradiction.supersededId).then(
-            (memory) => memory ? [memory] : []
-          ),
-          typeof storage.readAllColdMemories === "function" ? storage.readAllColdMemories() : Promise.resolve([])
-        ]);
-        oldMemory = mergeMemorySnapshots(hot, cold, storage.dir).find(
-          (memory) => memory.frontmatter.id === contradiction.supersededId
-        ) ?? null;
+        propagationEvent = {
+          oldMemory,
+          replacementId: newMemoryId,
+          replacementContent,
+          cause: "contradiction",
+          namespaceScope: this.storageDirNamespace(storage.dir)
+        };
+      } catch (err) {
+        log.warn(
+          `contradiction dependency propagation event failed for ${contradiction.supersededId}: ${err}`
+        );
+      }
+    } else if (oldMemory) {
+      log.warn(
+        `contradiction dependency propagation skipped for ${contradiction.supersededId}: replacement content was not captured`
+      );
+    }
+    const propagationEnabled = isDependencyPropagationEnabled(config);
+    let delivery = null;
+    if (propagationEvent && propagationEnabled) {
+      try {
+        delivery = this.getDependencyPropagationDelivery();
+      } catch (err) {
+        log.warn(
+          `contradiction dependency propagation delivery unavailable for ${contradiction.supersededId}: ${err}`
+        );
+      }
+    }
+    let preparation = null;
+    if (delivery && propagationEvent) {
+      try {
+        preparation = await delivery.prepare(propagationEvent);
       } catch (err) {
-        log.warn(`contradiction propagation snapshot failed for ${contradiction.supersededId}: ${err}`);
+        log.warn(
+          `contradiction dependency propagation prepare failed for ${contradiction.supersededId}: ${err}`
+        );
       }
     }
+    const supersessionCommitted = async () => {
+      try {
+        const current = await storage.getMemoryById(contradiction.supersededId);
+        if (!current) return null;
+        return current.frontmatter.status === "superseded" && current.frontmatter.supersededBy === newMemoryId;
+      } catch (err) {
+        log.warn(
+          `contradiction supersession state read failed for ${contradiction.supersededId}: ${err}`
+        );
+        return null;
+      }
+    };
+    const settleFailedPropagation = async (commitState2) => {
+      let token = preparation;
+      if (commitState2 === false) {
+        if (token !== null) {
+          try {
+            await delivery?.cancel(token);
+          } catch (err) {
+            log.warn(
+              `contradiction dependency propagation cancel failed for ${contradiction.supersededId}: ${err}`
+            );
+          }
+        }
+        return;
+      }
+      if (commitState2 === null && token === null && delivery && propagationEvent) {
+        try {
+          token = await delivery.prepare(propagationEvent);
+        } catch (err) {
+          log.warn(
+            `contradiction dependency propagation recovery prepare failed for ${contradiction.supersededId}: ${err}`
+          );
+        }
+      }
+      if (token !== null) {
+        try {
+          await delivery?.deferPrepared(token);
+        } catch (err) {
+          log.warn(
+            `contradiction dependency propagation defer failed for ${contradiction.supersededId}: ${err}`
+          );
+        }
+        return;
+      }
+      if (commitState2 === true && delivery && propagationEvent) {
+        try {
+          await delivery.afterMutation(null, propagationEvent);
+        } catch (err) {
+          log.warn(
+            `contradiction dependency propagation fallback failed for ${contradiction.supersededId}: ${err}`
+          );
+        }
+      }
+    };
+    const readyPreparedPropagation = async () => {
+      if (!propagationEvent || !propagationEnabled) return;
+      if (!delivery) {
+        await propagateInvalidation(
+          { storage, extraction: this.getExtraction(), config },
+          propagationEvent
+        );
+        return;
+      }
+      let token = preparation;
+      if (token === null) {
+        try {
+          token = await delivery.prepare(propagationEvent);
+        } catch (err) {
+          log.warn(
+            `contradiction dependency propagation recovery prepare failed for ${contradiction.supersededId}: ${err}`
+          );
+        }
+      }
+      try {
+        await delivery.afterMutation(token, propagationEvent);
+      } catch (err) {
+        log.warn(
+          `contradiction dependency propagation failed for ${contradiction.supersededId}: ${err}`
+        );
+      }
+    };
+    let commitState = false;
     try {
-      const superseded = await storage.supersedeMemory(
+      const committed = await storage.supersedeMemory(
         contradiction.supersededId,
         newMemoryId,
         contradiction.reason
       );
-      if (!superseded) {
+      commitState = committed ? true : await supersessionCommitted();
+      if (!committed || commitState !== true) {
         let mergedSnapshot;
         try {
           const [hot, cold] = await Promise.all([
@@ -3055,72 +3434,74 @@ var ContradictionLinkingCoordinator = class {
           log.warn(
             `contradiction auto-resolve race check failed for ${contradiction.supersededId}: ${err}`
           );
+          await settleFailedPropagation(commitState);
           return "supersede_failed";
         }
         const target = mergedSnapshot.find(
           (memory) => memory.frontmatter.id === contradiction.supersededId
         );
-        if (!target) return "supersede_failed";
+        if (!target) {
+          await settleFailedPropagation(commitState);
+          return "supersede_failed";
+        }
         const losingMemory = mergedSnapshot.find(
           (memory) => memory.frontmatter.id === newMemoryId && inferLocalizationMemoryStatus(memory, storage.dir) === "active"
         );
-        if (!losingMemory) return "supersede_failed";
+        if (!losingMemory) {
+          await settleFailedPropagation(commitState);
+          return "supersede_failed";
+        }
         try {
           if (losingMemory.frontmatter.supersedes === contradiction.supersededId) {
             const cleared = await storage.writeMemoryFrontmatter(losingMemory, {
               supersedes: void 0
             });
-            if (cleared === false) return "supersedes_clear_failed";
+            if (cleared === false) {
+              await settleFailedPropagation(commitState);
+              return "supersedes_clear_failed";
+            }
           }
         } catch (err) {
           log.warn(
             `contradiction auto-resolve losing supersedes clear failed for ${newMemoryId}: ${err}`
           );
+          await settleFailedPropagation(commitState);
           return "supersedes_clear_failed";
         }
-        return inferLocalizationMemoryStatus(target, storage.dir) === "active" ? "supersede_failed" : "lost_race";
-      }
-      if (oldMemory) {
-        try {
-          await propagateInvalidation(
-            {
-              storage,
-              extraction: this.getExtraction(),
-              config
-            },
-            {
-              oldMemory,
-              replacementId: newMemoryId,
-              replacementContent: (await storage.getMemoryById(newMemoryId))?.content ?? null,
-              cause: "contradiction",
-              namespaceScope: this.namespaceFromPath(storage.dir)
-            }
-          );
-        } catch (err) {
-          log.warn(`contradiction dependency propagation failed for ${contradiction.supersededId}: ${err}`);
-        }
-      }
-      if (resolveIndexingCapabilities(config).queryAwareIndexing && contradiction.supersededPath) {
-        try {
-          await deindexMemoryAsync(
-            config.memoryDir,
-            contradiction.supersededPath,
-            contradiction.supersededCreated,
-            contradiction.supersededTags
-          );
-        } catch (err) {
-          log.warn(
-            `contradiction auto-resolve deindex failed for ${contradiction.supersededId}: ${err}`
-          );
+        const outcome = inferLocalizationMemoryStatus(target, storage.dir) === "active" ? "supersede_failed" : "lost_race";
+        if (commitState === true) {
+          await readyPreparedPropagation();
+        } else {
+          await settleFailedPropagation(commitState);
         }
+        return outcome;
       }
-      return "resolved";
     } catch (err) {
+      commitState = await supersessionCommitted();
       log.warn(
         `contradiction auto-resolve supersede failed for ${contradiction.supersededId}: ${err}`
       );
-      return "supersede_failed";
+      if (commitState !== true) {
+        await settleFailedPropagation(commitState);
+        return "supersede_failed";
+      }
+    }
+    await readyPreparedPropagation();
+    if (resolveIndexingCapabilities(config).queryAwareIndexing && contradiction.supersededPath) {
+      try {
+        await deindexMemoryAsync(
+          config.memoryDir,
+          contradiction.supersededPath,
+          contradiction.supersededCreated,
+          contradiction.supersededTags
+        );
+      } catch (err) {
+        log.warn(
+          `contradiction auto-resolve deindex failed for ${contradiction.supersededId}: ${err}`
+        );
+      }
     }
+    return "resolved";
   }
   // ---------------------------------------------------------------------------
   // Memory Linking (Phase 3A)
@@ -3172,46 +3553,326 @@ var ContradictionLinkingCoordinator = class {
 // src/orchestration/consolidation-run.ts
 import path4 from "path";
 import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
+
+// src/orchestration/dependency-propagation-queue-state.ts
+import { createHash as createHash2 } from "crypto";
+var JOB_STATES = [
+  "prepared",
+  "ready",
+  "leased",
+  "retryable",
+  "completed",
+  "dead_letter",
+  "canceled"
+];
+var CAUSES = {
+  contradiction: true,
+  temporal_supersession: true,
+  consolidation_invalidate: true,
+  consolidation_merge: true
+};
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isPropagationEvent(value) {
+  if (!isRecord(value) || !isRecord(value.oldMemory)) return false;
+  const oldMemory = value.oldMemory;
+  if (!isRecord(oldMemory.frontmatter)) return false;
+  const frontmatter = oldMemory.frontmatter;
+  if (typeof oldMemory.content !== "string" || typeof frontmatter.id !== "string") return false;
+  if (!(value.replacementId === null || typeof value.replacementId === "string") || !(value.replacementContent === null || typeof value.replacementContent === "string") || typeof value.namespaceScope !== "string" || value.namespaceScope.length === 0 || typeof value.cause !== "string" || !Object.hasOwn(CAUSES, value.cause)) {
+    return false;
+  }
+  const temporalMutation = value.temporalMutation;
+  if (temporalMutation !== void 0 && (!isRecord(temporalMutation) || typeof temporalMutation.supersededAt !== "string" || temporalMutation.invalidAt !== void 0 && typeof temporalMutation.invalidAt !== "string" || !Array.isArray(temporalMutation.matchedKeys) || temporalMutation.matchedKeys.some((key) => typeof key !== "string"))) {
+    return false;
+  }
+  if (frontmatter.links !== void 0) {
+    if (!Array.isArray(frontmatter.links)) return false;
+    for (const link of frontmatter.links) {
+      if (!isRecord(link) || typeof link.targetId !== "string" || typeof link.linkType !== "string") return false;
+    }
+  }
+  return true;
+}
+function validateJob(value, expectedState) {
+  if (!isRecord(value)) return null;
+  const status = value.status;
+  const event = value.event;
+  const attempts = value.attempts;
+  const createdAt = value.createdAt;
+  const updatedAt = value.updatedAt;
+  if (typeof value.jobId !== "string" || value.jobId.length === 0 || typeof value.namespace !== "string" || value.namespace.length === 0 || typeof value.sourceId !== "string" || value.sourceId.length === 0 || !isPropagationEvent(event) || value.jobId !== eventJobId(event) || value.namespace !== event.namespaceScope || value.sourceId !== event.oldMemory.frontmatter.id || typeof status !== "string" || !JOB_STATES.includes(status) || expectedState !== void 0 && status !== expectedState || typeof attempts !== "number" || !Number.isInteger(attempts) || attempts < 0 || !isFiniteNumber(createdAt) || !isFiniteNumber(updatedAt)) {
+    return null;
+  }
+  const revision = value.revision === void 0 ? 0 : value.revision;
+  if (typeof revision !== "number" || !Number.isInteger(revision) || revision < 0) return null;
+  const reservationIdsValue = value.reservationIds;
+  if (!Array.isArray(reservationIdsValue)) return null;
+  const reservationIds = reservationIdsValue;
+  if (reservationIds.some(
+    (reservationId) => typeof reservationId !== "string" || reservationId.trim().length === 0
+  ) || new Set(reservationIds).size !== reservationIds.length) {
+    return null;
+  }
+  const reservations = value.reservations;
+  if (typeof reservations !== "number" || !Number.isInteger(reservations) || reservations < 0 || reservations !== reservationIds.length) {
+    return null;
+  }
+  const nextAttemptAt = value.nextAttemptAt;
+  const leaseOwner = value.leaseOwner;
+  const leaseExpiresAt = value.leaseExpiresAt;
+  const lastError = value.lastError;
+  const preparedReplacementFingerprint = value.preparedReplacementFingerprint;
+  if (nextAttemptAt !== void 0 && !isFiniteNumber(nextAttemptAt)) return null;
+  if (leaseOwner !== void 0 && typeof leaseOwner !== "string") return null;
+  if (leaseExpiresAt !== void 0 && !isFiniteNumber(leaseExpiresAt)) return null;
+  if (lastError !== void 0 && typeof lastError !== "string") return null;
+  if (preparedReplacementFingerprint !== void 0 && (typeof preparedReplacementFingerprint !== "string" || preparedReplacementFingerprint.length === 0)) {
+    return null;
+  }
+  if (status === "retryable" && nextAttemptAt === void 0) return null;
+  if (status === "leased" && (typeof leaseOwner !== "string" || leaseExpiresAt === void 0)) return null;
+  return {
+    jobId: value.jobId,
+    namespace: value.namespace,
+    sourceId: value.sourceId,
+    event,
+    status,
+    attempts,
+    createdAt,
+    updatedAt,
+    reservations,
+    reservationIds: [...reservationIds],
+    revision,
+    ...nextAttemptAt === void 0 ? {} : { nextAttemptAt },
+    ...leaseOwner === void 0 ? {} : { leaseOwner },
+    ...leaseExpiresAt === void 0 ? {} : { leaseExpiresAt },
+    ...lastError === void 0 ? {} : { lastError },
+    ...preparedReplacementFingerprint === void 0 ? {} : { preparedReplacementFingerprint }
+  };
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map((item) => canonicalize(item));
+  if (isRecord(value)) {
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+      if (value[key] === void 0) continue;
+      result[key] = canonicalize(value[key]);
+    }
+    return result;
+  }
+  return value === void 0 ? null : value;
+}
+function compareByteStable(left, right) {
+  return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
+}
+function canonicalEvent(event) {
+  return canonicalize(event);
+}
+function stableLinks(links) {
+  if (!Array.isArray(links)) return links;
+  return [...links].sort((left, right) => {
+    const leftKey = JSON.stringify(canonicalize(left));
+    const rightKey = JSON.stringify(canonicalize(right));
+    return compareByteStable(leftKey, rightKey);
+  });
+}
+function matchesPreparedSource(current, prepared) {
+  const { accessCount: _currentAccessCount, lastAccessed: _currentLastAccessed, ...currentSemantic } = current.frontmatter;
+  const { accessCount: _preparedAccessCount, lastAccessed: _preparedLastAccessed, ...preparedSemantic } = prepared.frontmatter;
+  const normalizedCurrent = { ...currentSemantic, links: stableLinks(currentSemantic.links) };
+  const normalizedPrepared = { ...preparedSemantic, links: stableLinks(preparedSemantic.links) };
+  return current.content === prepared.content && JSON.stringify(canonicalize(normalizedCurrent)) === JSON.stringify(canonicalize(normalizedPrepared));
+}
+function eventJobId(event) {
+  const { accessCount: _accessCount, lastAccessed: _lastAccessed, links, ...semanticFrontmatter } = event.oldMemory.frontmatter;
+  const semanticEvent = {
+    ...event,
+    oldMemory: {
+      ...event.oldMemory,
+      frontmatter: { ...semanticFrontmatter, links: stableLinks(links) }
+    }
+  };
+  return createHash2("sha256").update(JSON.stringify(canonicalize(semanticEvent))).digest("hex");
+}
+function isNotFound(error) {
+  return isRecord(error) && error.code === "ENOENT";
+}
+
+// src/orchestration/consolidation-run.ts
 var MAX_HARMONIC_NAMESPACE_STORES = 50;
 var HARMONIC_CATALOG_CURSOR_FILE = "harmonic-catalog-cursor.json";
-var ConsolidationRunCoordinator = class {
-  constructor(deps) {
-    this.deps = deps;
+async function prepareDependencyPropagation(getDelivery, event, enabled) {
+  if (!enabled) return null;
+  let delivery;
+  try {
+    delivery = getDelivery();
+  } catch (error) {
+    log.warn(`consolidation dependency propagation getter failed: ${error}`);
+    return null;
   }
-  deps;
-  async readHarmonicCatalogCursor(defaultDir) {
-    const cursorPath = path4.join(defaultDir, "state", HARMONIC_CATALOG_CURSOR_FILE);
+  let preparation = null;
+  try {
+    preparation = await delivery.prepare(event);
+  } catch (error) {
+    log.warn(`consolidation dependency propagation preparation failed: ${error}`);
+  }
+  return { delivery, event, preparation };
+}
+function clonePropagationMemory(memory) {
+  return structuredClone(memory);
+}
+function sameMemorySnapshot(a, b) {
+  return a.content === b.content && JSON.stringify(canonicalize(a.frontmatter)) === JSON.stringify(canonicalize(b.frontmatter));
+}
+async function prepareCurrentDependencyPropagation(storage, getDelivery, sourceId, buildEvent, enabled) {
+  const loaded = await storage.getMemoryById(sourceId);
+  if (!loaded) return null;
+  let source = clonePropagationMemory(loaded);
+  let pending = await prepareDependencyPropagation(getDelivery, buildEvent(source), enabled);
+  if (!pending) return { source, pending: null };
+  let latest;
+  try {
+    latest = await storage.getMemoryById(sourceId);
+  } catch (error) {
+    await cancelDependencyPropagation(pending);
+    throw error;
+  }
+  if (!latest) {
+    await cancelDependencyPropagation(pending);
+    return null;
+  }
+  if (!sameMemorySnapshot(source, latest)) {
+    await cancelDependencyPropagation(pending);
+    source = clonePropagationMemory(latest);
+    pending = await prepareDependencyPropagation(getDelivery, buildEvent(source), enabled);
+  }
+  return { source, pending };
+}
+async function cancelDependencyPropagation(pending) {
+  if (!pending.preparation?.ownsPreparedJob) return;
+  try {
+    await pending.delivery.cancel(pending.preparation);
+  } catch (error) {
+    log.warn(`consolidation dependency propagation cancellation failed: ${error}`);
+  }
+}
+async function deferDependencyPropagation(pending) {
+  if (!pending) return;
+  let token = pending.preparation;
+  if (token === null) {
     try {
-      const raw = await readFile(cursorPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      return typeof parsed.nextStorageDir === "string" && parsed.nextStorageDir.length > 0 ? path4.resolve(parsed.nextStorageDir) : void 0;
+      token = await pending.delivery.prepare(pending.event);
     } catch (error) {
-      if (error.code !== "ENOENT") {
-        log.warn(
-          `harmonic namespace catalog cursor read failed open: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-      return void 0;
+      log.warn(`consolidation dependency propagation recovery preparation failed: ${error}`);
     }
   }
-  async writeHarmonicCatalogCursor(defaultDir, nextStorageDir) {
-    const stateDir = path4.join(defaultDir, "state");
-    await mkdir2(stateDir, { recursive: true });
-    await writeFile2(
-      path4.join(stateDir, HARMONIC_CATALOG_CURSOR_FILE),
-      JSON.stringify({ nextStorageDir }, null, 2),
-      "utf-8"
-    );
+  if (token === null) return;
+  try {
+    await pending.delivery.deferPrepared(token);
+  } catch (error) {
+    log.warn(`consolidation dependency propagation defer failed: ${error}`);
   }
-  async pruneHarmonicStores(storage) {
-    const config = this.deps.config;
-    if (!resolveCapabilities(config).harmonicRetrieval || !resolveConsolidationCapabilities(config).abstractionAnchors) {
-      return;
-    }
-    const stores = /* @__PURE__ */ new Map();
-    const defaultDir = path4.resolve(storage.dir);
-    stores.set(defaultDir, {
-      memoryDir: storage.dir,
+}
+async function afterDependencyPropagationMutation(pending) {
+  try {
+    await pending.delivery.afterMutation(pending.preparation, pending.event);
+  } catch (error) {
+    log.warn(`consolidation dependency propagation delivery failed: ${error}`);
+  }
+}
+async function classifyInvalidation(storage, memoryId, expectedSnapshot, options = {}) {
+  if (options.checkInvalidationProof !== false && expectedSnapshot) {
+    if (!storage.hasCommittedInvalidation) {
+      log.warn(`consolidation invalidation proof capability missing for ${memoryId}`);
+    } else {
+      try {
+        if (await storage.hasCommittedInvalidation(expectedSnapshot)) return "committed";
+      } catch (error) {
+        log.warn(`consolidation invalidation proof read failed for ${memoryId}: ${error}`);
+      }
+    }
+  }
+  try {
+    const current = await storage.getMemoryById(memoryId);
+    if (!current) {
+      if (options.missingMeansCommitted === false) return "not-committed";
+      if (expectedSnapshot && !storage.hasCommittedInvalidation) return "unknown";
+      return "committed";
+    }
+    if (options.matchesCommitted?.(current)) return "committed";
+    if (expectedSnapshot && sameMemorySnapshot(current, expectedSnapshot)) {
+      return "not-committed";
+    }
+    return "unknown";
+  } catch (error) {
+    log.warn(`consolidation invalidation state read failed for ${memoryId}: ${error}`);
+    return "unknown";
+  }
+}
+async function settleFailedConsolidationPropagation(pending, commitState, memoryId) {
+  if (!pending) return;
+  let token = pending.preparation;
+  if (commitState === "not-committed") {
+    if (token !== null) await cancelDependencyPropagation({ ...pending, preparation: token });
+    return;
+  }
+  if (token === null && (commitState === "committed" || commitState === "unknown")) {
+    try {
+      token = await pending.delivery.prepare(pending.event);
+    } catch (error) {
+      log.warn(
+        `consolidation dependency propagation recovery preparation failed for ${memoryId}: ${error}`
+      );
+    }
+  }
+  if (token !== null) {
+    try {
+      await pending.delivery.deferPrepared(token);
+    } catch (error) {
+      log.warn(`consolidation dependency propagation defer failed for ${memoryId}: ${error}`);
+    }
+  }
+}
+var ConsolidationRunCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async readHarmonicCatalogCursor(defaultDir) {
+    const cursorPath = path4.join(defaultDir, "state", HARMONIC_CATALOG_CURSOR_FILE);
+    try {
+      const raw = await readFile(cursorPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      return typeof parsed.nextStorageDir === "string" && parsed.nextStorageDir.length > 0 ? path4.resolve(parsed.nextStorageDir) : void 0;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        log.warn(
+          `harmonic namespace catalog cursor read failed open: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      return void 0;
+    }
+  }
+  async writeHarmonicCatalogCursor(defaultDir, nextStorageDir) {
+    const stateDir = path4.join(defaultDir, "state");
+    await mkdir2(stateDir, { recursive: true });
+    await writeFile2(
+      path4.join(stateDir, HARMONIC_CATALOG_CURSOR_FILE),
+      JSON.stringify({ nextStorageDir }, null, 2),
+      "utf-8"
+    );
+  }
+  async pruneHarmonicStores(storage) {
+    const config = this.deps.config;
+    if (!resolveCapabilities(config).harmonicRetrieval || !resolveConsolidationCapabilities(config).abstractionAnchors) {
+      return;
+    }
+    const stores = /* @__PURE__ */ new Map();
+    const defaultDir = path4.resolve(storage.dir);
+    stores.set(defaultDir, {
+      memoryDir: storage.dir,
       abstractionNodeStoreDir: config.abstractionNodeStoreDir
     });
     try {
@@ -3297,49 +3958,65 @@ var ConsolidationRunCoordinator = class {
     );
     const profile = await storage.readProfile();
     const result = await this.deps.getExtraction().consolidate(recent, older, profile);
-    const memoryLookup = resolveIndexingCapabilities(config).queryAwareIndexing ? new Map(allMemories.map((m) => [m.frontmatter.id, m])) : null;
     const itemsDeindexBatch = [];
     try {
       for (const item of result.items) {
         switch (item.action) {
           case "INVALIDATE": {
-            const toInvalidate = resolveIndexingCapabilities(config).queryAwareIndexing ? memoryLookup?.get(item.existingId) ?? null : null;
-            const propagationOld = allMemories.find(
-              (memory) => memory.frontmatter.id === item.existingId
+            const propagationEnabled = config.dependencyPropagation.enabled && config.dependencyPropagation.maxDependents > 0;
+            const prepared = await prepareCurrentDependencyPropagation(
+              storage,
+              this.deps.getDependencyPropagationDelivery,
+              item.existingId,
+              (propagationOld2) => ({
+                oldMemory: propagationOld2,
+                replacementId: null,
+                replacementContent: null,
+                cause: "consolidation_invalidate",
+                namespaceScope: this.deps.storageDirNamespace(storage.dir)
+              }),
+              propagationEnabled
             );
-            if (await storage.invalidateMemory(item.existingId)) {
-              invalidated += 1;
-              memoryItemMutated = true;
-              await this.deps.embeddingFallback.removeFromIndex(item.existingId);
-              if (propagationOld) {
-                try {
-                  await propagateInvalidation(
-                    {
-                      storage,
-                      extraction: this.deps.getExtraction(),
-                      config
-                    },
-                    {
-                      oldMemory: propagationOld,
-                      replacementId: null,
-                      replacementContent: null,
-                      cause: "consolidation_invalidate",
-                      namespaceScope: config.defaultNamespace
-                    }
-                  );
-                } catch (propagationErr) {
-                  log.warn(
-                    `consolidation dependency propagation failed for ${item.existingId}: ${propagationErr}`
-                  );
-                }
-              }
-              if (toInvalidate?.path && toInvalidate.frontmatter?.created) {
-                itemsDeindexBatch.push({
-                  path: toInvalidate.path,
-                  createdAt: toInvalidate.frontmatter.created,
-                  tags: toInvalidate.frontmatter.tags ?? []
-                });
-              }
+            const propagationOld = prepared?.source ?? null;
+            const pending = prepared?.pending ?? null;
+            const expectedSnapshot = pending ? propagationOld : null;
+            const toInvalidate = resolveIndexingCapabilities(config).queryAwareIndexing ? propagationOld : null;
+            const recordCommitProof = pending?.preparation?.ownsPreparedJob === true;
+            let didInvalidate;
+            try {
+              didInvalidate = await storage.invalidateMemory(
+                item.existingId,
+                expectedSnapshot ?? void 0,
+                { recordCommitProof }
+              );
+            } catch (error) {
+              const commitState = await classifyInvalidation(storage, item.existingId, expectedSnapshot);
+              await settleFailedConsolidationPropagation(
+                pending,
+                commitState,
+                item.existingId
+              );
+              throw error;
+            }
+            if (!didInvalidate) {
+              const commitState = await classifyInvalidation(storage, item.existingId, expectedSnapshot);
+              await settleFailedConsolidationPropagation(
+                pending,
+                commitState,
+                item.existingId
+              );
+              break;
+            }
+            invalidated += 1;
+            memoryItemMutated = true;
+            if (pending) await afterDependencyPropagationMutation(pending);
+            await this.deps.embeddingFallback.removeFromIndex(item.existingId);
+            if (toInvalidate?.path && toInvalidate.frontmatter?.created) {
+              itemsDeindexBatch.push({
+                path: toInvalidate.path,
+                createdAt: toInvalidate.frontmatter.created,
+                tags: toInvalidate.frontmatter.tags ?? []
+              });
             }
             break;
           }
@@ -3358,53 +4035,81 @@ var ConsolidationRunCoordinator = class {
             break;
           case "MERGE":
             if (item.updatedContent && item.mergeWith) {
-              await storage.updateMemory(
-                item.existingId,
-                item.updatedContent,
-                {
-                  supersedes: item.mergeWith,
-                  lineage: [item.existingId, item.mergeWith]
-                }
+              const updatedContent = item.updatedContent;
+              const mergeWith = item.mergeWith;
+              const propagationEnabled = config.dependencyPropagation.enabled && config.dependencyPropagation.maxDependents > 0;
+              const prepared = await prepareCurrentDependencyPropagation(
+                storage,
+                this.deps.getDependencyPropagationDelivery,
+                item.mergeWith,
+                (propagationOld2) => ({
+                  oldMemory: propagationOld2,
+                  replacementId: item.existingId,
+                  replacementContent: updatedContent,
+                  cause: "consolidation_merge",
+                  namespaceScope: this.deps.storageDirNamespace(storage.dir)
+                }),
+                propagationEnabled
               );
+              const propagationOld = prepared?.source ?? null;
+              const pending = prepared?.pending ?? null;
+              const expectedSnapshot = pending ? propagationOld : null;
+              const toMergeInvalidate = resolveIndexingCapabilities(config).queryAwareIndexing ? propagationOld : null;
+              let didUpdate;
+              try {
+                didUpdate = await storage.updateMemory(
+                  item.existingId,
+                  updatedContent,
+                  {
+                    supersedes: item.mergeWith,
+                    lineage: [item.existingId, item.mergeWith]
+                  }
+                );
+              } catch (error) {
+                await deferDependencyPropagation(pending);
+                throw error;
+              }
+              if (!didUpdate) {
+                if (pending) await cancelDependencyPropagation(pending);
+                break;
+              }
               memoryItemMutated = true;
               await this.deps.indexPersistedMemory(storage, item.existingId);
-              const toMergeInvalidate = resolveIndexingCapabilities(config).queryAwareIndexing ? memoryLookup?.get(item.mergeWith) ?? null : null;
-              const propagationOld = allMemories.find(
-                (memory) => memory.frontmatter.id === item.mergeWith
-              );
-              if (await storage.invalidateMemory(item.mergeWith)) {
-                invalidated += 1;
-                merged += 1;
-                await this.deps.embeddingFallback.removeFromIndex(item.mergeWith);
-                if (propagationOld) {
-                  try {
-                    await propagateInvalidation(
-                      {
-                        storage,
-                        extraction: this.deps.getExtraction(),
-                        config
-                      },
-                      {
-                        oldMemory: propagationOld,
-                        replacementId: item.existingId,
-                        replacementContent: item.updatedContent,
-                        cause: "consolidation_merge",
-                        namespaceScope: config.defaultNamespace
-                      }
-                    );
-                  } catch (propagationErr) {
-                    log.warn(
-                      `consolidation dependency propagation failed for ${item.mergeWith}: ${propagationErr}`
-                    );
-                  }
-                }
-                if (toMergeInvalidate?.path && toMergeInvalidate.frontmatter?.created) {
-                  itemsDeindexBatch.push({
-                    path: toMergeInvalidate.path,
-                    createdAt: toMergeInvalidate.frontmatter.created,
-                    tags: toMergeInvalidate.frontmatter.tags ?? []
-                  });
-                }
+              let didInvalidate;
+              try {
+                didInvalidate = await storage.invalidateMemory(
+                  item.mergeWith,
+                  expectedSnapshot ?? void 0,
+                  { recordCommitProof: pending?.preparation?.ownsPreparedJob === true }
+                );
+              } catch (error) {
+                const commitState = await classifyInvalidation(storage, item.mergeWith, expectedSnapshot);
+                await settleFailedConsolidationPropagation(
+                  pending,
+                  commitState,
+                  item.mergeWith
+                );
+                throw error;
+              }
+              if (!didInvalidate) {
+                const commitState = await classifyInvalidation(storage, item.mergeWith, expectedSnapshot);
+                await settleFailedConsolidationPropagation(
+                  pending,
+                  commitState,
+                  item.mergeWith
+                );
+                break;
+              }
+              invalidated += 1;
+              merged += 1;
+              if (pending) await afterDependencyPropagationMutation(pending);
+              await this.deps.embeddingFallback.removeFromIndex(item.mergeWith);
+              if (toMergeInvalidate?.path && toMergeInvalidate.frontmatter?.created) {
+                itemsDeindexBatch.push({
+                  path: toMergeInvalidate.path,
+                  createdAt: toMergeInvalidate.frontmatter.created,
+                  tags: toMergeInvalidate.frontmatter.tags ?? []
+                });
               }
             }
             break;
@@ -4028,6 +4733,10 @@ var ExtractionPersistCoordinator = class {
   get config() {
     return this.deps.config;
   }
+  get dependencyPropagationDelivery() {
+    if (!isDependencyPropagationEnabled(this.config)) return void 0;
+    return this.deps.getDependencyPropagationDelivery();
+  }
   async persistExtraction(result, storage, threadIdForExtraction, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps = resolveGraphConstructionCapabilities(this.deps.config), lifecycleCaps = resolveMemoryLifecycleCapabilities(this.deps.config)) {
     const citationEnabled = resolvePipelineProcessingCapabilities(this.deps.config).inlineSourceAttribution === true;
     const citationTemplate = this.deps.config.inlineSourceAttributionFormat;
@@ -4238,8 +4947,7 @@ var ExtractionPersistCoordinator = class {
                 structuredAttributes: { ...targetSurvivingAttrs },
                 createdAt: supersessionOrderingAt(options.validAt),
                 enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
-                extraction: this.deps.getExtraction(),
-                config: this.config,
+                dependencyPropagationDelivery: this.dependencyPropagationDelivery,
                 namespaceScope: this.deps.storageDirNamespace(targetStorage.dir)
               });
             } catch (profileSupersessionErr) {
@@ -4380,10 +5088,9 @@ var ExtractionPersistCoordinator = class {
                   entityRef: sharedPromotionEnvelope.entityRef,
                   structuredAttributes: { ...sharedSurvivingAttrs },
                   createdAt: supersessionOrderingAt(options.validAt),
-                  enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
                   useCallerTimestamp: true,
-                  extraction: this.deps.getExtraction(),
-                  config: this.config,
+                  enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
+                  dependencyPropagationDelivery: this.dependencyPropagationDelivery,
                   namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir)
                 });
                 if (hashDedupSupersession.supersededIds.length > 0) {
@@ -4455,8 +5162,7 @@ var ExtractionPersistCoordinator = class {
               structuredAttributes: { ...sharedSurvivingAttrs },
               createdAt: supersessionOrderingAt(options.validAt),
               enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
-              extraction: this.deps.getExtraction(),
-              config: this.config,
+              dependencyPropagationDelivery: this.dependencyPropagationDelivery,
               namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir)
             });
           } catch (sharedSupersessionErr) {
@@ -5280,13 +5986,12 @@ var ExtractionPersistCoordinator = class {
                 newMemoryId: parentId,
                 entityRef: parentWriteEnvelope.entityRef,
                 structuredAttributes: parentWriteEnvelope.rawStructuredAttributes ? { ...parentWriteEnvelope.rawStructuredAttributes } : void 0,
-                createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
                 // #1578 r3: an extracted end-only bound (validFrom absent) is
                 // historical, not a new authoritative state — never let it
                 // supersede a later active fact (codex P1 on :15534).
+                createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
                 enabled: lifecycleCaps.temporalSupersession && !(biTemporal && !biTemporal.validFrom),
-                extraction: this.deps.getExtraction(),
-                config: this.config,
+                dependencyPropagationDelivery: this.dependencyPropagationDelivery,
                 namespaceScope: this.deps.storageDirNamespace(targetStorage.dir)
               });
               for (const supersededId of temporalSupersession.supersededIds) {
@@ -5486,8 +6191,7 @@ var ExtractionPersistCoordinator = class {
             structuredAttributes: factWriteEnvelope.rawStructuredAttributes ? { ...factWriteEnvelope.rawStructuredAttributes } : void 0,
             createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
             enabled: lifecycleCaps.temporalSupersession && !(biTemporal && !biTemporal.validFrom),
-            extraction: this.deps.getExtraction(),
-            config: this.config,
+            dependencyPropagationDelivery: this.dependencyPropagationDelivery,
             namespaceScope: this.deps.storageDirNamespace(targetStorage.dir)
           });
           for (const supersededId of temporalSupersession.supersededIds) {
@@ -5685,84 +6389,1127 @@ var ExtractionPersistCoordinator = class {
         }
       }
     }
-    if (profileUpdates.length > 0) {
-      await storage.appendToProfile(profileUpdates);
-      recordDurableNonFactWrite();
+    if (profileUpdates.length > 0) {
+      await storage.appendToProfile(profileUpdates);
+      recordDurableNonFactWrite();
+    }
+    for (const q of questions) {
+      const id = await storage.writeQuestion(q.question, q.context, q.priority);
+      if (id) {
+        trackPersistedId(storage, id);
+        recordDurableNonFactWrite();
+      }
+    }
+    if (resolveRecallEnhancementCapabilities(this.deps.config).identity && result.identityReflection) {
+      try {
+        await storage.appendIdentityReflection(result.identityReflection);
+        recordDurableNonFactWrite();
+      } catch (err) {
+        log.debug(`identity reflection write failed: ${err}`);
+      }
+    }
+    if (durableNonFactWritten) {
+      touchBaseNonFactNamespace();
+    }
+    await this.deps.saveContentHashIndexes().catch((err) => {
+      log.warn(`content-hash index save failed: ${err}`);
+    });
+    for (const {
+      storage: targetStorage,
+      events
+    } of behaviorSignalsByStorage.values()) {
+      const dedupedSignals = dedupeBehaviorSignalsByMemoryAndHash(events);
+      if (dedupedSignals.length === 0) continue;
+      await targetStorage.appendBehaviorSignals(dedupedSignals).catch(
+        (err) => log.warn(`appendBehaviorSignals failed (non-fatal): ${err}`)
+      );
+    }
+    const dedupSuffix = dedupedCount > 0 ? ` (${dedupedCount} deduped)` : "";
+    const gatedSuffix = importanceGatedCount > 0 ? ` (${importanceGatedCount} gated)` : "";
+    const judgeSuffix = judgeGatedCount > 0 ? ` (${judgeGatedCount} judge-rejected)` : "";
+    const redactionSuffix = redactionGatedCount > 0 ? ` (${redactionGatedCount} redacted)` : "";
+    log.info(
+      `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
+    );
+    if (harmonicConstructionEnabled && harmonicFactsByStorage.size > 0) {
+      await persistConstructedHarmonicRecords({
+        entries: harmonicFactsByStorage.values(),
+        baseStorageDir: storage.dir,
+        abstractionNodeStoreDir: !scopeProfileWritePlan && harmonicBaseNamespace === this.deps.config.defaultNamespace ? this.deps.config.abstractionNodeStoreDir : void 0,
+        sessionKey: sourceContext?.sessionKey,
+        validAt: sourceContext?.validAt,
+        episodeTitle: result.episodeTitle,
+        anchorsEnabled: harmonicAnchorsEnabled,
+        entityMentions: entities
+      });
+    }
+    void (async () => {
+      if (persistedIdsByStorage.size === 0) {
+        await this.deps.updateTemporalTagIndexes(storage, []);
+        return;
+      }
+      for (const entry of persistedIdsByStorage.values()) {
+        await this.deps.updateTemporalTagIndexes(entry.storage, entry.ids);
+      }
+    })().catch(
+      (err) => log.debug(`temporal-index update error (non-fatal): ${err}`)
+    );
+    this.deps.setLastPersistExtractionPendingReviewIds(pendingReviewPersistedIds);
+    return { persistedIds, memoryPathById };
+  }
+};
+
+// src/orchestration/extraction-shutdown.ts
+async function drainExtractionAndShutdownDependencyPropagation(extractionQueue, dependencyPropagationDelivery) {
+  let extractionDrainError;
+  try {
+    if (!await extractionQueue.pauseAndDrain()) {
+      extractionDrainError = new Error("orchestrator.destroy: extraction queue did not drain before teardown");
+    }
+  } catch (error) {
+    extractionDrainError = error;
+  }
+  try {
+    await dependencyPropagationDelivery?.shutdown();
+  } catch (error) {
+    log.warn(`orchestrator.destroy: dependency propagation shutdown failed: ${error}`);
+  }
+  return extractionDrainError;
+}
+
+// src/orchestration/dependency-propagation-delivery.ts
+import { randomUUID } from "crypto";
+import { readFile as readFile2, unlink } from "fs/promises";
+import path6 from "path";
+
+// src/orchestration/dependency-propagation-recovery-replay.ts
+import { createHash as createHash3 } from "crypto";
+function memoryFingerprint(memory) {
+  const { accessCount: _accessCount, lastAccessed: _lastAccessed, ...frontmatter } = memory.frontmatter;
+  return createHash3("sha256").update(JSON.stringify(canonicalize({ content: memory.content, frontmatter }))).digest("hex");
+}
+async function findRecoverySource(storage, sourceId) {
+  const hot = await storage.getMemoryById(sourceId);
+  if (hot?.frontmatter.id === sourceId) return hot;
+  if (storage.readAllColdMemories) {
+    const cold = await storage.readAllColdMemories();
+    const coldMatch = cold.find((memory) => memory.frontmatter.id === sourceId);
+    if (coldMatch) return coldMatch;
+  }
+  if (storage.readArchivedMemories) {
+    const archived = await storage.readArchivedMemories();
+    const archivedMatch = archived.find((memory) => memory.frontmatter.id === sourceId);
+    if (archivedMatch) return archivedMatch;
+  }
+  return null;
+}
+async function readCurrentReplacementEvent(storage, event) {
+  if (event.replacementId === null) return event;
+  const replacement = await findRecoverySource(
+    storage,
+    event.replacementId
+  );
+  if (!replacement) return null;
+  return {
+    ...event,
+    replacementContent: replacement.content
+  };
+}
+async function replayPrimaryMutation(sourceStorage, event, preparedReplacementFingerprint) {
+  const storage = sourceStorage;
+  const source = await findRecoverySource(storage, event.oldMemory.frontmatter.id);
+  const primaryApplied = source?.frontmatter.status === "superseded" && source.frontmatter.supersededBy === event.replacementId;
+  if (event.cause === "temporal_supersession") {
+    if (!event.replacementId || !event.temporalMutation || !source) return false;
+    const temporalPrimaryApplied = primaryApplied && source.frontmatter.supersededAt === event.temporalMutation.supersededAt && (event.temporalMutation.invalidAt === void 0 || source.frontmatter.invalid_at === event.temporalMutation.invalidAt);
+    if (!temporalPrimaryApplied) {
+      const replacement2 = await findRecoverySource(storage, event.replacementId);
+      if (event.replacementContent === null || !replacement2 || replacement2.frontmatter.id !== event.replacementId || replacement2.content !== event.replacementContent)
+        return false;
+      if (!matchesPreparedSource(source, event.oldMemory)) return false;
+    }
+    return await applyTemporalSupersessionPrimaryMutation({
+      storage: sourceStorage,
+      oldMemory: source,
+      replacementId: event.replacementId,
+      mutation: event.temporalMutation
+    });
+  }
+  if (event.cause === "contradiction") {
+    if (!event.replacementId || !source) return false;
+    if (primaryApplied) return true;
+    const replacement2 = await findRecoverySource(storage, event.replacementId);
+    if (event.replacementContent === null || !replacement2 || replacement2.frontmatter.id !== event.replacementId || replacement2.content !== event.replacementContent)
+      return false;
+    if (!matchesPreparedSource(source, event.oldMemory)) return false;
+    return await storage.supersedeMemory(
+      event.oldMemory.frontmatter.id,
+      event.replacementId,
+      `dependency_propagation:${event.cause}`,
+      void 0,
+      { requireActive: true, acceptExactReplay: true, expectedSnapshot: source }
+    );
+  }
+  if (event.cause === "consolidation_invalidate") {
+    if (!source) {
+      return storage.hasCommittedInvalidation ? await storage.hasCommittedInvalidation(event.oldMemory) : false;
+    }
+    if (!storage.invalidateMemory || !matchesPreparedSource(source, event.oldMemory)) return false;
+    return await storage.invalidateMemory(source.frontmatter.id, source, {
+      recordCommitProof: true
+    });
+  }
+  if (!event.replacementId || event.replacementContent === null || !storage.updateMemoryIfUnchanged) {
+    return false;
+  }
+  const replacement = await findRecoverySource(storage, event.replacementId);
+  const persistedReplacementContent = sanitizeMemoryContent(event.replacementContent).text;
+  if (replacement && replacement.frontmatter.supersedes === event.oldMemory.frontmatter.id && replacement.content !== persistedReplacementContent) {
+    return false;
+  }
+  const mergeAlreadyApplied = replacement !== null && replacement.frontmatter.supersedes === event.oldMemory.frontmatter.id && replacement.content === persistedReplacementContent;
+  if (!source) {
+    if (!storage.hasCommittedInvalidation) return false;
+    return await storage.hasCommittedInvalidation(event.oldMemory);
+  }
+  if (preparedReplacementFingerprint && source && !mergeAlreadyApplied && (!replacement || memoryFingerprint(replacement) !== preparedReplacementFingerprint)) {
+    return false;
+  }
+  if (!replacement || !matchesPreparedSource(source, event.oldMemory)) return false;
+  if (!mergeAlreadyApplied) {
+    const updated = await storage.updateMemoryIfUnchanged(
+      replacement,
+      event.replacementContent,
+      {
+        supersedes: event.oldMemory.frontmatter.id,
+        lineage: [event.replacementId, event.oldMemory.frontmatter.id]
+      }
+    );
+    if (!updated) return false;
+  }
+  if (!storage.invalidateMemory) return false;
+  return await storage.invalidateMemory(source.frontmatter.id, source, {
+    recordCommitProof: true
+  });
+}
+
+// src/orchestration/dependency-propagation-delivery.ts
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+var DEFAULT_LEASE_MS = 6e4;
+var DEFAULT_MAX_ATTEMPTS = 3;
+var TERMINAL_RETENTION_COUNT = 32;
+var MAX_SERIALIZED_QUEUE_JOB_BYTES = 64 * 1024;
+var MAX_STORED_ERROR_LENGTH = 1024;
+var QueueJobTooLargeError = class extends Error {
+  constructor(bytes) {
+    super(`dependency propagation queue job exceeds ${MAX_SERIALIZED_QUEUE_JOB_BYTES} bytes (${bytes})`);
+    this.name = "QueueJobTooLargeError";
+  }
+};
+function formatStoredError(error) {
+  const text = String(error);
+  return text.length > MAX_STORED_ERROR_LENGTH ? text.slice(0, MAX_STORED_ERROR_LENGTH) : text;
+}
+function chooseEntry(entries) {
+  return [...entries].sort((left, right) => {
+    if (left.job.revision !== right.job.revision) return right.job.revision - left.job.revision;
+    if (left.job.updatedAt !== right.job.updatedAt) return right.job.updatedAt - left.job.updatedAt;
+    return left.filePath < right.filePath ? -1 : left.filePath > right.filePath ? 1 : 0;
+  })[0];
+}
+var DependencyPropagationDelivery = class {
+  queueRoot;
+  getStorage;
+  config;
+  extraction;
+  workerId;
+  clock;
+  retryDelayMs;
+  leaseMs;
+  maxAttempts;
+  autoStart;
+  schedule;
+  readQueueFile;
+  writeQueueFile;
+  replayReconciliation;
+  backgroundScheduled = false;
+  recoveryScheduled = false;
+  backgroundRun = null;
+  activeRuns = /* @__PURE__ */ new Set();
+  stopped = false;
+  constructor(options) {
+    this.queueRoot = options.queueRoot;
+    this.config = options.config;
+    this.extraction = options.extraction;
+    this.getStorage = options.getStorage;
+    this.workerId = options.workerId ?? `worker-${process.pid}-${randomUUID()}`;
+    this.clock = options.clock ?? Date.now;
+    this.retryDelayMs = Math.max(0, options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS);
+    this.leaseMs = Math.max(1, options.leaseMs ?? DEFAULT_LEASE_MS);
+    this.maxAttempts = Math.max(1, Math.floor(options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS));
+    this.autoStart = options.autoStart ?? false;
+    this.schedule = options.schedule ?? ((run, delayMs) => {
+      const timer = setTimeout(() => {
+        void run().catch((error) => {
+          log.warn(`dependency propagation scheduled run failed: ${error}`);
+        });
+      }, delayMs);
+      timer.unref();
+    });
+    this.readQueueFile = options.readQueueFile ?? ((filePath) => readFile2(filePath, "utf8"));
+    this.writeQueueFile = options.writeQueueFile ?? ((filePath, content) => writeJsonFileAtomic(filePath, JSON.parse(content)));
+    this.replayReconciliation = options.replayReconciliation;
+  }
+  async prepare(event) {
+    if (this.stopped) return null;
+    if (!isDependencyPropagationEnabled(this.config)) return null;
+    const reservationId = randomUUID();
+    try {
+      if (!isPropagationEvent(event)) throw new Error("invalid dependency propagation event");
+      const snapshot = canonicalEvent(event);
+      const jobId = eventJobId(snapshot);
+      let preparedReplacementFingerprint;
+      if (snapshot.cause === "consolidation_merge" && snapshot.replacementId !== null) {
+        try {
+          const storage = await this.getStorage(snapshot.namespaceScope);
+          const replacement = await storage.getMemoryById(snapshot.replacementId);
+          if (!replacement) {
+            log.warn(
+              `dependency propagation survivor lookup returned no record for ${snapshot.replacementId}`
+            );
+            return null;
+          }
+          preparedReplacementFingerprint = memoryFingerprint(replacement);
+        } catch (error) {
+          log.warn(`dependency propagation survivor fingerprint capture failed: ${error}`);
+          return null;
+        }
+      }
+      let token = null;
+      await withJsonStoreMutationLock(this.queueRoot, async () => {
+        const entries = await this.readEntries();
+        const existing = chooseEntry(entries.filter((entry) => entry.job.jobId === jobId));
+        if (existing && existing.job.status === "canceled") {
+          const reopened = {
+            ...existing.job,
+            status: "prepared",
+            attempts: 0,
+            reservations: 1,
+            reservationIds: [reservationId],
+            nextAttemptAt: void 0,
+            leaseOwner: void 0,
+            leaseExpiresAt: void 0,
+            lastError: void 0,
+            updatedAt: this.clock(),
+            revision: existing.job.revision + 1
+          };
+          await this.writeQueueJob(await this.jobPath("prepared", jobId), reopened);
+          await unlink(existing.filePath).catch((error) => {
+            if (!isNotFound(error)) throw error;
+          });
+          token = {
+            jobId,
+            revision: reopened.revision,
+            ownsPreparedJob: true,
+            reservationId
+          };
+          return;
+        }
+        if (existing && existing.job.status === "prepared") {
+          const reservationIds = existing.job.reservationIds ?? [];
+          const next = {
+            ...existing.job,
+            reservations: reservationIds.length + 1,
+            reservationIds: [...reservationIds, reservationId],
+            updatedAt: this.clock()
+          };
+          await this.writeQueueJob(existing.filePath, next);
+          token = {
+            jobId,
+            revision: existing.job.revision,
+            ownsPreparedJob: true,
+            reservationId
+          };
+          return;
+        }
+        if (existing) {
+          token = {
+            jobId,
+            revision: existing.job.revision,
+            ownsPreparedJob: false,
+            reservationId
+          };
+          return;
+        }
+        const now = this.clock();
+        const job = {
+          jobId,
+          namespace: snapshot.namespaceScope,
+          sourceId: snapshot.oldMemory.frontmatter.id,
+          event: snapshot,
+          status: "prepared",
+          attempts: 0,
+          createdAt: now,
+          updatedAt: now,
+          reservations: 1,
+          reservationIds: [reservationId],
+          revision: 0,
+          ...preparedReplacementFingerprint ? { preparedReplacementFingerprint } : {}
+        };
+        await this.writeQueueJob(await this.jobPath(job.status, job.jobId), job);
+        token = {
+          jobId,
+          revision: job.revision,
+          ownsPreparedJob: true,
+          reservationId
+        };
+      });
+      return token;
+    } catch (error) {
+      log.warn(`dependency propagation queue preparation failed: ${error}`);
+      if (error instanceof QueueJobTooLargeError) return null;
+      try {
+        if (isPropagationEvent(event)) {
+          const snapshot = canonicalEvent(event);
+          const jobId = eventJobId(snapshot);
+          return await withJsonStoreMutationLock(this.queueRoot, async () => {
+            const existing = chooseEntry(
+              (await this.readEntries()).filter((entry) => entry.job.jobId === jobId)
+            );
+            if (!existing || existing.job.status !== "prepared") return null;
+            const reservationIds = existing.job.reservationIds ?? [];
+            if (!reservationIds.includes(reservationId)) {
+              reservationIds.push(reservationId);
+              await this.writeQueueJob(existing.filePath, {
+                ...existing.job,
+                reservationIds,
+                reservations: reservationIds.length,
+                updatedAt: this.clock()
+              });
+            }
+            return {
+              jobId,
+              revision: existing.job.revision,
+              ownsPreparedJob: true,
+              reservationId
+            };
+          });
+        }
+      } catch (readbackError) {
+        log.warn(`dependency propagation queue preparation readback failed: ${readbackError}`);
+      }
+      return null;
+    }
+  }
+  async afterMutation(token, event) {
+    if (this.stopped) return;
+    if (token !== null) {
+      try {
+        await withJsonStoreMutationLock(this.queueRoot, async () => {
+          const entries = await this.readEntries();
+          const matching = entries.filter((entry) => entry.job.jobId === token.jobId);
+          const current = chooseEntry(matching);
+          if (!current) throw new Error(`dependency propagation job ${token.jobId} is missing`);
+          if (current.job.status === "prepared" && current.job.revision === token.revision) {
+            const reservationIds = current.job.reservationIds;
+            if (reservationIds && !reservationIds.includes(token.reservationId)) return;
+            await this.transitionUnlocked(matching, current.job, "ready", {
+              ...reservationIds ? {
+                reservationIds: reservationIds.filter((id) => id !== token.reservationId),
+                reservations: Math.max(0, reservationIds.length - 1)
+              } : {}
+            });
+          }
+        });
+        this.scheduleBackgroundRun();
+        return;
+      } catch (error) {
+        log.warn(`dependency propagation ready transition failed: ${error}`);
+        this.scheduleBackgroundRecovery();
+        return;
+      }
+    }
+    await this.propagateDirect(event);
+  }
+  async cancel(token) {
+    if (token === null) return;
+    try {
+      let terminalJob = null;
+      await withJsonStoreMutationLock(this.queueRoot, async () => {
+        const entries = await this.readEntries();
+        const matching = entries.filter((entry) => entry.job.jobId === token.jobId);
+        const current = chooseEntry(matching);
+        if (!current || current.job.status !== "prepared" || current.job.revision !== token.revision) {
+          return;
+        }
+        const reservationIds = current.job.reservationIds;
+        if (reservationIds && !reservationIds.includes(token.reservationId)) return;
+        if (reservationIds && reservationIds.length > 1) {
+          const remaining = reservationIds.filter((id) => id !== token.reservationId);
+          await this.writeQueueJob(current.filePath, {
+            ...current.job,
+            reservationIds: remaining,
+            reservations: remaining.length,
+            updatedAt: this.clock()
+          });
+          return;
+        }
+        terminalJob = await this.transitionUnlocked(matching, current.job, "canceled", {
+          reservationIds: [],
+          reservations: 0,
+          lastError: void 0
+        });
+      });
+      if (terminalJob !== null && !await this.finalizeTerminalJob(terminalJob)) {
+        this.scheduleBackgroundRecovery();
+      }
+    } catch (error) {
+      log.warn(`dependency propagation cancellation failed for ${token.jobId}: ${error}`);
+    }
+  }
+  async deferPrepared(token) {
+    if (this.stopped || token === null) return;
+    try {
+      const shouldSchedule = await withJsonStoreMutationLock(this.queueRoot, async () => {
+        const entries = await this.readEntries();
+        const current = chooseEntry(
+          entries.filter((entry) => entry.job.jobId === token.jobId)
+        );
+        if (!current || current.job.status !== "prepared" || current.job.revision !== token.revision) {
+          return false;
+        }
+        const reservationIds = current.job.reservationIds;
+        return !reservationIds || reservationIds.includes(token.reservationId);
+      });
+      if (shouldSchedule) this.scheduleBackgroundRecovery();
+    } catch (error) {
+      log.warn(`dependency propagation prepared-job deferral failed for ${token.jobId}: ${error}`);
+    }
+  }
+  trackRun(run) {
+    this.activeRuns.add(run);
+    void run.finally(() => this.activeRuns.delete(run)).catch(() => void 0);
+    return run;
+  }
+  recover() {
+    return this.trackRun(this.recoverInternal());
+  }
+  async recoverInternal() {
+    let jobs;
+    try {
+      jobs = await this.listJobs();
+    } catch (error) {
+      log.warn(`dependency propagation recovery scan failed: ${error}`);
+      this.scheduleBackgroundRecovery();
+      return;
+    }
+    let retryPreparedRecovery = false;
+    for (const job of jobs) {
+      if (job.status === "completed" || job.status === "dead_letter" || job.status === "canceled") {
+        retryPreparedRecovery ||= !await this.finalizeTerminalJob(job);
+      }
+    }
+    const now = this.clock();
+    for (const job of jobs) {
+      if (job.status !== "leased" || job.leaseOwner === void 0 || !job.leaseOwner.includes(":recovery:") || (job.leaseExpiresAt ?? Number.POSITIVE_INFINITY) > now)
+        continue;
+      let claimed;
+      try {
+        claimed = await this.claimExpiredRecoveryLease(job);
+      } catch (error) {
+        retryPreparedRecovery = true;
+        log.warn(`dependency propagation expired recovery lease claim failed: ${error}`);
+        continue;
+      }
+      if (!claimed) continue;
+      const outcome = await this.recoverPrimaryMutation(claimed);
+      retryPreparedRecovery ||= outcome.retry;
+    }
+    for (const job of jobs) {
+      if (job.status !== "prepared") continue;
+      let claimed;
+      try {
+        claimed = await this.claimPrepared(job);
+      } catch (error) {
+        retryPreparedRecovery = true;
+        log.warn(`dependency propagation prepared-job claim failed: ${error}`);
+        continue;
+      }
+      if (!claimed) continue;
+      const outcome = await this.recoverPrimaryMutation(claimed);
+      retryPreparedRecovery ||= outcome.retry;
+    }
+    if (retryPreparedRecovery) this.scheduleBackgroundRecovery();
+    await this.scheduleNextPendingRun();
+  }
+  async claimPrepared(job) {
+    return withJsonStoreMutationLock(this.queueRoot, async () => {
+      const entries = await this.readEntries();
+      const matching = entries.filter((entry) => entry.job.jobId === job.jobId);
+      const current = chooseEntry(matching);
+      if (!current || current.job.status !== "prepared" || current.job.revision !== job.revision) {
+        return null;
+      }
+      return this.transitionUnlocked(matching, current.job, "leased", {
+        leaseOwner: `${this.workerId}:recovery:${randomUUID()}`,
+        leaseExpiresAt: this.clock() + this.leaseMs,
+        nextAttemptAt: void 0,
+        lastError: void 0
+      });
+    });
+  }
+  async claimExpiredRecoveryLease(job) {
+    return withJsonStoreMutationLock(this.queueRoot, async () => {
+      const entries = await this.readEntries();
+      const matching = entries.filter((entry) => entry.job.jobId === job.jobId);
+      const current = chooseEntry(matching);
+      if (!current || current.job.status !== "leased" || current.job.leaseOwner !== job.leaseOwner) {
+        return null;
+      }
+      if ((current.job.leaseExpiresAt ?? Number.POSITIVE_INFINITY) > this.clock()) {
+        return null;
+      }
+      return this.transitionUnlocked(matching, current.job, "leased", {
+        leaseOwner: `${this.workerId}:recovery:${randomUUID()}`,
+        leaseExpiresAt: this.clock() + this.leaseMs,
+        nextAttemptAt: void 0,
+        lastError: void 0
+      });
+    });
+  }
+  async recoverPrimaryMutation(claimed) {
+    try {
+      const storage = await this.getStorage(claimed.event.namespaceScope);
+      const replayed = await this.withCurrentLease(
+        claimed,
+        () => replayPrimaryMutation(
+          storage,
+          claimed.event,
+          claimed.preparedReplacementFingerprint
+        )
+      );
+      if (replayed !== true) {
+        return {
+          retry: await this.retainPreparedJob(
+            claimed,
+            new Error("primary mutation replay incomplete")
+          )
+        };
+      }
+      if (this.replayReconciliation) {
+        if (claimed.event.cause === "consolidation_merge" && claimed.event.replacementId) {
+          await this.replayReconciliation.reindex(
+            claimed.event,
+            claimed.event.replacementId
+          );
+        }
+        await this.replayReconciliation.deindex(
+          claimed.event,
+          [claimed.event.oldMemory.frontmatter.id]
+        );
+      }
+      await withJsonStoreMutationLock(this.queueRoot, async () => {
+        const entries = await this.readEntries();
+        const matching = entries.filter((entry) => entry.job.jobId === claimed.jobId);
+        const current = chooseEntry(matching);
+        if (current && current.job.status === "leased" && current.job.leaseOwner === claimed.leaseOwner && (current.job.leaseExpiresAt ?? Number.NEGATIVE_INFINITY) > this.clock()) {
+          await this.transitionUnlocked(matching, current.job, "ready", {
+            leaseOwner: void 0,
+            leaseExpiresAt: void 0
+          });
+        }
+      });
+      return { retry: false };
+    } catch (error) {
+      log.warn(`dependency propagation prepared-job recovery failed: ${error}`);
+      return { retry: await this.retainPreparedJob(claimed, error) };
+    }
+  }
+  runUntilIdle() {
+    return this.trackRun(this.runUntilIdleInternal());
+  }
+  async runUntilIdleInternal() {
+    let processed = 0;
+    while (true) {
+      let claimed;
+      try {
+        claimed = await this.claimNext();
+      } catch (error) {
+        log.warn(`dependency propagation claim failed: ${error}`);
+        this.scheduleBackgroundRecovery();
+        break;
+      }
+      if (!claimed) break;
+      processed += 1;
+      await this.processClaimed(claimed);
+    }
+    return processed;
+  }
+  scheduleBackgroundRun(delayMs = 0) {
+    if (!this.autoStart || this.stopped || this.backgroundScheduled) return;
+    this.backgroundScheduled = true;
+    this.schedule(async () => {
+      this.backgroundScheduled = false;
+      if (this.stopped) return;
+      if (this.backgroundRun !== null) {
+        await this.backgroundRun.catch(() => void 0);
+        this.scheduleBackgroundRun();
+        return;
+      }
+      const run = this.runUntilIdle();
+      this.backgroundRun = run;
+      try {
+        await run;
+      } finally {
+        this.backgroundRun = null;
+      }
+      await this.scheduleNextPendingRun();
+    }, delayMs);
+  }
+  scheduleBackgroundRecovery(delayMs = this.retryDelayMs) {
+    if (!this.autoStart || this.stopped || this.recoveryScheduled) return;
+    this.recoveryScheduled = true;
+    this.schedule(async () => {
+      this.recoveryScheduled = false;
+      if (this.stopped) return;
+      await this.recover();
+    }, delayMs);
+  }
+  async scheduleNextPendingRun() {
+    if (!this.autoStart || this.stopped || this.backgroundScheduled) return;
+    let jobs;
+    try {
+      jobs = await this.listJobs();
+    } catch (error) {
+      log.warn(`dependency propagation scheduling scan failed: ${error}`);
+      this.scheduleBackgroundRecovery();
+      return;
+    }
+    const now = this.clock();
+    let nextDelayMs = Number.POSITIVE_INFINITY;
+    for (const job of jobs) {
+      if (job.status === "ready") {
+        nextDelayMs = 0;
+        break;
+      }
+      if (job.status === "retryable" && job.nextAttemptAt !== void 0) {
+        nextDelayMs = Math.min(nextDelayMs, Math.max(0, job.nextAttemptAt - now));
+      }
+      if (job.status === "leased" && job.leaseExpiresAt !== void 0) {
+        nextDelayMs = Math.min(nextDelayMs, Math.max(0, job.leaseExpiresAt - now));
+      }
+    }
+    if (Number.isFinite(nextDelayMs)) this.scheduleBackgroundRun(nextDelayMs);
+  }
+  async listJobs() {
+    const entries = await this.readEntries();
+    const grouped = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const group = grouped.get(entry.job.jobId) ?? [];
+      group.push(entry);
+      grouped.set(entry.job.jobId, group);
+    }
+    return [...grouped.values()].map((group) => chooseEntry(group)?.job).filter((job) => job !== void 0).sort((left, right) => compareByteStable(left.jobId, right.jobId));
+  }
+  async shutdown() {
+    this.stopped = true;
+    while (true) {
+      const activeRuns = [...this.activeRuns];
+      if (activeRuns.length > 0) {
+        await Promise.all(activeRuns.map((run) => run.catch(() => 0)));
+        continue;
+      }
+      if (this.backgroundScheduled) {
+        this.backgroundScheduled = false;
+        await this.runUntilIdle();
+        continue;
+      }
+      break;
+    }
+    for (let pass = 0; pass <= this.maxAttempts; pass += 1) {
+      await this.recover();
+      await this.runUntilIdle();
+      const jobs = await this.listJobs();
+      const now = this.clock();
+      const actionable = jobs.some(
+        (job) => job.status === "prepared" || job.status === "ready" || job.status === "retryable" && (job.nextAttemptAt === void 0 || job.nextAttemptAt <= now) || job.status === "leased" && job.leaseExpiresAt !== void 0 && job.leaseExpiresAt <= now
+      );
+      if (!actionable) return;
+    }
+  }
+  async stateDir(status) {
+    return resolveSafeStoragePath(this.queueRoot, status);
+  }
+  async jobPath(status, jobId) {
+    return resolveSafeStoragePath(this.queueRoot, status, `${jobId}.json`);
+  }
+  async writeQueueJob(filePath, job) {
+    const serialized = JSON.stringify(job, null, 2);
+    const bytes = Buffer.byteLength(serialized, "utf8");
+    if (bytes > MAX_SERIALIZED_QUEUE_JOB_BYTES) throw new QueueJobTooLargeError(bytes);
+    await this.writeQueueFile(filePath, serialized);
+  }
+  async readEntries() {
+    const entries = [];
+    for (const status of JOB_STATES) {
+      let files;
+      try {
+        files = await listJsonFilesStrict(await this.stateDir(status), { allowMissingDirectory: true });
+      } catch (error) {
+        log.warn(`dependency propagation state scan failed for ${status}: ${error}`);
+        throw error;
+      }
+      for (const filePath of files) {
+        try {
+          const job = validateJob(JSON.parse(await this.readQueueFile(filePath)), status);
+          if (!job) {
+            log.warn(`dependency propagation ignored invalid job file ${path6.basename(filePath)}`);
+            continue;
+          }
+          entries.push({ job, filePath });
+        } catch (error) {
+          if (error instanceof SyntaxError || isNotFound(error)) {
+            log.warn(`dependency propagation ignored unreadable job file ${path6.basename(filePath)}: ${error}`);
+            continue;
+          }
+          throw error;
+        }
+      }
+    }
+    return entries;
+  }
+  async clearCommittedInvalidationProof(job) {
+    if (job.event.cause !== "consolidation_invalidate" && job.event.cause !== "consolidation_merge") {
+      return true;
     }
-    for (const q of questions) {
-      const id = await storage.writeQuestion(q.question, q.context, q.priority);
-      if (id) {
-        trackPersistedId(storage, id);
-        recordDurableNonFactWrite();
+    try {
+      const storage = await this.getStorage(job.event.namespaceScope);
+      if (!storage.clearCommittedInvalidation) {
+        log.warn("dependency propagation invalidation proof cleanup capability missing");
+        return false;
       }
+      await storage.clearCommittedInvalidation(job.event.oldMemory);
+      return true;
+    } catch (error) {
+      log.warn(`dependency propagation invalidation proof cleanup failed: ${error}`);
+      return false;
     }
-    if (resolveRecallEnhancementCapabilities(this.deps.config).identity && result.identityReflection) {
-      try {
-        await storage.appendIdentityReflection(result.identityReflection);
-        recordDurableNonFactWrite();
-      } catch (err) {
-        log.debug(`identity reflection write failed: ${err}`);
+  }
+  async retainPreparedJob(job, error) {
+    try {
+      let terminalJob = null;
+      const retained = await withJsonStoreMutationLock(this.queueRoot, async () => {
+        const entries = await this.readEntries();
+        const matching = entries.filter((entry) => entry.job.jobId === job.jobId);
+        const current = chooseEntry(matching);
+        if (!current || current.job.status !== "leased" || current.job.leaseOwner !== job.leaseOwner) {
+          return false;
+        }
+        const attempts = current.job.attempts + 1;
+        if (attempts >= this.maxAttempts) {
+          terminalJob = await this.transitionUnlocked(matching, current.job, "dead_letter", {
+            attempts,
+            lastError: formatStoredError(error)
+          });
+          return false;
+        }
+        await this.transitionUnlocked(matching, current.job, "prepared", {
+          attempts,
+          lastError: formatStoredError(error)
+        });
+        return true;
+      });
+      if (terminalJob !== null && !await this.finalizeTerminalJob(terminalJob)) {
+        this.scheduleBackgroundRecovery();
       }
+      return retained;
+    } catch (retainError) {
+      log.warn(`dependency propagation prepared-job retention failed: ${retainError}`);
+      return true;
     }
-    if (durableNonFactWritten) {
-      touchBaseNonFactNamespace();
+  }
+  async transitionUnlocked(entries, job, status, patch = {}) {
+    const next = {
+      ...job,
+      ...patch,
+      status,
+      updatedAt: this.clock(),
+      revision: job.revision + 1
+    };
+    const targetPath = await this.jobPath(status, next.jobId);
+    await this.writeQueueJob(targetPath, next);
+    const terminal = status === "completed" || status === "dead_letter" || status === "canceled";
+    for (const entry of entries) {
+      if (path6.resolve(entry.filePath) === path6.resolve(targetPath)) continue;
+      await unlink(entry.filePath).catch((error) => {
+        if (isNotFound(error)) return;
+        if (terminal) {
+          log.warn(`dependency propagation old terminal state unlink failed: ${error}`);
+          return;
+        }
+        throw error;
+      });
     }
-    await this.deps.saveContentHashIndexes().catch((err) => {
-      log.warn(`content-hash index save failed: ${err}`);
-    });
-    for (const {
-      storage: targetStorage,
-      events
-    } of behaviorSignalsByStorage.values()) {
-      const dedupedSignals = dedupeBehaviorSignalsByMemoryAndHash(events);
-      if (dedupedSignals.length === 0) continue;
-      await targetStorage.appendBehaviorSignals(dedupedSignals).catch(
-        (err) => log.warn(`appendBehaviorSignals failed (non-fatal): ${err}`)
+    return next;
+  }
+  async finalizeTerminalJob(job) {
+    if (!await this.clearCommittedInvalidationProof(job)) return false;
+    try {
+      return await withJsonStoreMutationLock(
+        this.queueRoot,
+        () => this.pruneTerminalStatusUnlocked(job.status)
       );
+    } catch (error) {
+      log.warn(`dependency propagation terminal finalization failed: ${error}`);
+      return false;
     }
-    const dedupSuffix = dedupedCount > 0 ? ` (${dedupedCount} deduped)` : "";
-    const gatedSuffix = importanceGatedCount > 0 ? ` (${importanceGatedCount} gated)` : "";
-    const judgeSuffix = judgeGatedCount > 0 ? ` (${judgeGatedCount} judge-rejected)` : "";
-    const redactionSuffix = redactionGatedCount > 0 ? ` (${redactionGatedCount} redacted)` : "";
-    log.info(
-      `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
-    );
-    if (harmonicConstructionEnabled && harmonicFactsByStorage.size > 0) {
-      await persistConstructedHarmonicRecords({
-        entries: harmonicFactsByStorage.values(),
-        baseStorageDir: storage.dir,
-        abstractionNodeStoreDir: !scopeProfileWritePlan && harmonicBaseNamespace === this.deps.config.defaultNamespace ? this.deps.config.abstractionNodeStoreDir : void 0,
-        sessionKey: sourceContext?.sessionKey,
-        validAt: sourceContext?.validAt,
-        episodeTitle: result.episodeTitle,
-        anchorsEnabled: harmonicAnchorsEnabled,
-        entityMentions: entities
+  }
+  async pruneTerminalStatusUnlocked(status) {
+    try {
+      const latestByJobId = /* @__PURE__ */ new Map();
+      for (const entry of (await this.readEntries()).filter((item) => item.job.status === status)) {
+        const current = latestByJobId.get(entry.job.jobId);
+        if (!current || chooseEntry([current, entry]) === entry) {
+          latestByJobId.set(entry.job.jobId, entry);
+        }
+      }
+      const entries = [...latestByJobId.values()].sort((left, right) => {
+        if (left.job.updatedAt !== right.job.updatedAt) {
+          return right.job.updatedAt > left.job.updatedAt ? 1 : -1;
+        }
+        if (left.job.revision !== right.job.revision) {
+          return right.job.revision > left.job.revision ? 1 : -1;
+        }
+        return compareByteStable(left.filePath, right.filePath);
       });
+      const oldJobs = entries.slice(TERMINAL_RETENTION_COUNT);
+      for (const entry of oldJobs) {
+        if (!await this.clearCommittedInvalidationProof(entry.job)) return false;
+      }
+      let removed = true;
+      for (const entry of oldJobs) {
+        const jobRemoved = await this.removeAllQueueFilesForJobUnlocked(entry.job.jobId);
+        removed = jobRemoved && removed;
+      }
+      return removed;
+    } catch (error) {
+      log.warn(`dependency propagation terminal retention failed: ${error}`);
+      return false;
     }
-    void (async () => {
-      if (persistedIdsByStorage.size === 0) {
-        await this.deps.updateTemporalTagIndexes(storage, []);
+  }
+  async removeAllQueueFilesForJobUnlocked(jobId) {
+    let removed = true;
+    for (const status of JOB_STATES) {
+      const files = await listJsonFilesStrict(await this.stateDir(status), {
+        allowMissingDirectory: true
+      });
+      for (const filePath of files) {
+        if (path6.basename(filePath, ".json") !== jobId) continue;
+        try {
+          await unlink(filePath);
+        } catch (error) {
+          if (!isNotFound(error)) {
+            removed = false;
+            log.warn(`dependency propagation queue cleanup unlink failed: ${error}`);
+          }
+        }
+      }
+    }
+    return removed;
+  }
+  async claimNext() {
+    return withJsonStoreMutationLock(this.queueRoot, async () => {
+      const now = this.clock();
+      const entries = await this.readEntries();
+      const candidates = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        const group = candidates.get(entry.job.jobId) ?? [];
+        group.push(entry);
+        candidates.set(entry.job.jobId, group);
+      }
+      const jobs = [...candidates.values()].map((group) => ({ group, current: chooseEntry(group) })).filter((item) => item.current !== void 0).sort((left, right) => compareByteStable(left.current.job.jobId, right.current.job.jobId));
+      for (const item of jobs) {
+        const current = item.current.job;
+        const expiredLease = current.status === "leased" && (current.leaseExpiresAt ?? Number.POSITIVE_INFINITY) <= now;
+        const ready = current.status === "ready";
+        const retryable = current.status === "retryable" && (current.nextAttemptAt ?? Number.POSITIVE_INFINITY) <= now;
+        if (!ready && !retryable && !expiredLease) continue;
+        return this.transitionUnlocked(item.group, current, "leased", {
+          attempts: current.attempts + 1,
+          leaseOwner: `${this.workerId}:${randomUUID()}`,
+          leaseExpiresAt: now + this.leaseMs,
+          nextAttemptAt: void 0,
+          lastError: void 0
+        });
+      }
+      return null;
+    });
+  }
+  async processClaimed(job) {
+    let renewal = Promise.resolve();
+    const heartbeatMs = Math.max(1, Math.floor(this.leaseMs / 3));
+    const heartbeat = setInterval(() => {
+      renewal = renewal.then(() => this.renewLease(job)).catch((error) => {
+        log.warn(`dependency propagation lease renewal failed: ${error}`);
+      });
+    }, heartbeatMs);
+    heartbeat.unref();
+    try {
+      const storage = await this.getStorage(job.event.namespaceScope);
+      const currentEvent = await readCurrentReplacementEvent(storage, job.event);
+      if (currentEvent === null) {
+        await this.finishAttempt(job, new Error("persisted replacement is missing"));
         return;
       }
-      for (const entry of persistedIdsByStorage.values()) {
-        await this.deps.updateTemporalTagIndexes(entry.storage, entry.ids);
+      const result = await propagateInvalidation(
+        {
+          storage,
+          extraction: this.extraction,
+          config: this.config,
+          writeFence: (write) => this.withCurrentLease(job, write)
+        },
+        currentEvent
+      );
+      const accountedDependents = result.invalidated + result.stillValid + result.uncertain;
+      if (result.skipped === "timeout" || result.skipped === "llm_error") {
+        await this.finishAttempt(job, new Error(`propagation skipped: ${result.skipped}`));
+      } else if (accountedDependents < result.dependentsFound) {
+        await this.finishAttempt(job, new Error("one or more dependent writes did not commit"));
+      } else {
+        await this.finishAttempt(job, null);
       }
-    })().catch(
-      (err) => log.debug(`temporal-index update error (non-fatal): ${err}`)
-    );
-    this.deps.setLastPersistExtractionPendingReviewIds(pendingReviewPersistedIds);
-    return { persistedIds, memoryPathById };
+    } catch (error) {
+      await this.finishAttempt(job, error);
+    } finally {
+      clearInterval(heartbeat);
+      await renewal;
+    }
+  }
+  async withCurrentLease(job, write) {
+    return withJsonStoreMutationLock(this.queueRoot, async () => {
+      const entries = await this.readEntries();
+      const current = chooseEntry(entries.filter((entry) => entry.job.jobId === job.jobId));
+      if (current?.job.status !== "leased" || current.job.leaseOwner !== job.leaseOwner || (current.job.leaseExpiresAt ?? Number.NEGATIVE_INFINITY) <= this.clock()) {
+        return void 0;
+      }
+      const result = await write();
+      const renewedEntries = await this.readEntries();
+      const renewedMatching = renewedEntries.filter((entry) => entry.job.jobId === job.jobId);
+      const renewedCurrent = chooseEntry(renewedMatching);
+      if (renewedCurrent && renewedCurrent.job.status === "leased" && renewedCurrent.job.leaseOwner === job.leaseOwner) {
+        await this.transitionUnlocked(renewedMatching, renewedCurrent.job, "leased", {
+          leaseExpiresAt: this.clock() + this.leaseMs
+        });
+      }
+      return result;
+    });
+  }
+  async renewLease(job) {
+    await withJsonStoreMutationLock(this.queueRoot, async () => {
+      const entries = await this.readEntries();
+      const matching = entries.filter((entry) => entry.job.jobId === job.jobId);
+      const current = chooseEntry(matching);
+      if (!current || current.job.status !== "leased" || current.job.leaseOwner !== job.leaseOwner || (current.job.leaseExpiresAt ?? Number.NEGATIVE_INFINITY) <= this.clock()) {
+        return;
+      }
+      await this.transitionUnlocked(matching, current.job, "leased", {
+        leaseExpiresAt: this.clock() + this.leaseMs
+      });
+    });
+  }
+  async finishAttempt(job, error) {
+    let retryDelayMs = null;
+    let terminalJob = null;
+    try {
+      await withJsonStoreMutationLock(this.queueRoot, async () => {
+        const entries = await this.readEntries();
+        const matching = entries.filter((entry) => entry.job.jobId === job.jobId);
+        const current = chooseEntry(matching);
+        if (!current || current.job.status !== "leased" || current.job.leaseOwner !== job.leaseOwner || (current.job.leaseExpiresAt ?? Number.NEGATIVE_INFINITY) <= this.clock()) {
+          return;
+        }
+        if (error === null) {
+          terminalJob = await this.transitionUnlocked(matching, current.job, "completed", {
+            leaseOwner: void 0,
+            leaseExpiresAt: void 0,
+            nextAttemptAt: void 0,
+            lastError: void 0
+          });
+          return;
+        }
+        if (current.job.attempts >= this.maxAttempts) {
+          terminalJob = await this.transitionUnlocked(matching, current.job, "dead_letter", {
+            leaseOwner: void 0,
+            leaseExpiresAt: void 0,
+            nextAttemptAt: void 0,
+            lastError: formatStoredError(error)
+          });
+          return;
+        }
+        retryDelayMs = this.retryDelayMs * 2 ** Math.max(0, current.job.attempts - 1);
+        await this.transitionUnlocked(matching, current.job, "retryable", {
+          leaseOwner: void 0,
+          leaseExpiresAt: void 0,
+          nextAttemptAt: this.clock() + retryDelayMs,
+          lastError: formatStoredError(error)
+        });
+      });
+      if (terminalJob !== null && !await this.finalizeTerminalJob(terminalJob)) {
+        this.scheduleBackgroundRecovery();
+      }
+      if (retryDelayMs !== null) this.scheduleBackgroundRun(retryDelayMs);
+    } catch (finishError) {
+      log.warn(`dependency propagation attempt finalization failed: ${finishError}`);
+    }
+  }
+  async propagateDirect(event) {
+    try {
+      const storage = await this.getStorage(event.namespaceScope);
+      await propagateInvalidation(
+        { storage, extraction: this.extraction, config: this.config },
+        event
+      );
+    } catch (error) {
+      log.warn(`dependency propagation direct fallback failed: ${error}`);
+    }
   }
 };
 
+// src/orchestration/dependency-propagation-replay-reconciliation.ts
+function createDependencyPropagationReplayReconciliation(host) {
+  return {
+    reindex: async (event, survivorId) => {
+      if (event.cause !== "consolidation_merge") return;
+      const storage = await host.getStorage(event.namespaceScope);
+      await host.indexPersistedMemory(storage, survivorId);
+    },
+    deindex: async (event, memoryIds) => {
+      if (event.cause !== "consolidation_merge" && event.cause !== "consolidation_invalidate") {
+        return;
+      }
+      await Promise.all(
+        memoryIds.map((memoryId) => host.removeFromIndex(memoryId))
+      );
+      if (!resolveIndexingCapabilities(host.config).queryAwareIndexing) return;
+      if (!event.oldMemory.path || !event.oldMemory.frontmatter.created) return;
+      const storage = await host.getStorage(event.namespaceScope);
+      await deindexMemoriesBatchAsync(storage.dir, [{
+        path: event.oldMemory.path,
+        createdAt: event.oldMemory.frontmatter.created,
+        tags: event.oldMemory.frontmatter.tags ?? []
+      }]);
+    }
+  };
+}
+
 // src/orchestration/recall-internal.ts
-import { createHash as createHash3 } from "crypto";
-import { readFile as readFile2, stat, unlink } from "fs/promises";
-import path9 from "path";
+import { createHash as createHash5 } from "crypto";
+import { readFile as readFile3, stat, unlink as unlink2 } from "fs/promises";
+import path10 from "path";
 
 // src/orchestration/graph-path-state-loader.ts
 import { lstat, opendir, realpath } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 function isArchivePathIndexUnavailable(index) {
   return "unavailable" in index;
 }
@@ -5781,11 +7528,11 @@ var GraphPathStateLoader = class {
   openArchiveDirectory = opendir;
   async readNode(storage, nodeId, deadlineAtMs, allowArchiveLookup) {
     if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
-    const configuredStorageRoot = path6.resolve(storage.dir);
+    const configuredStorageRoot = path7.resolve(storage.dir);
     const storageRoot = await realpath(configuredStorageRoot).catch(() => null);
     if (!storageRoot || storageRoot !== configuredStorageRoot) return null;
-    const logicalId = path6.basename(nodeId, path6.extname(nodeId));
-    const directRelativePaths = [nodeId, path6.join("cold", nodeId)];
+    const logicalId = path7.basename(nodeId, path7.extname(nodeId));
+    const directRelativePaths = [nodeId, path7.join("cold", nodeId)];
     let inactiveDirectMemory = null;
     for (const relativePath of directRelativePaths) {
       const safePath = await this.resolveContainedPath(storageRoot, relativePath);
@@ -5808,7 +7555,7 @@ var GraphPathStateLoader = class {
     if (!archiveIndex || isArchivePathIndexUnavailable(archiveIndex) || typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) {
       return null;
     }
-    const archivePaths = archiveIndex.pathsByBasename.get(path6.basename(nodeId)) ?? [];
+    const archivePaths = archiveIndex.pathsByBasename.get(path7.basename(nodeId)) ?? [];
     for (const archivePath of archivePaths) {
       if (typeof deadlineAtMs === "number" && Date.now() >= deadlineAtMs) return null;
       const memory = await storage.readMemoryByPath(archivePath);
@@ -5818,17 +7565,17 @@ var GraphPathStateLoader = class {
     return null;
   }
   async resolveContainedPath(storageRoot, relativePath) {
-    if (path6.isAbsolute(relativePath)) return null;
+    if (path7.isAbsolute(relativePath)) return null;
     const rawSegments = relativePath.replace(/\\/g, "/").split("/");
     if (rawSegments.includes("..")) return null;
-    const candidate = path6.resolve(storageRoot, relativePath);
-    const lexicalRelative = path6.relative(storageRoot, candidate);
-    if (lexicalRelative.length > 0 && (lexicalRelative.startsWith("..") || path6.isAbsolute(lexicalRelative))) {
+    const candidate = path7.resolve(storageRoot, relativePath);
+    const lexicalRelative = path7.relative(storageRoot, candidate);
+    if (lexicalRelative.length > 0 && (lexicalRelative.startsWith("..") || path7.isAbsolute(lexicalRelative))) {
       return null;
     }
     const canonical = await realpath(candidate).catch(() => candidate);
-    const canonicalRelative = path6.relative(storageRoot, canonical);
-    if (canonicalRelative.length > 0 && (canonicalRelative.startsWith("..") || path6.isAbsolute(canonicalRelative))) {
+    const canonicalRelative = path7.relative(storageRoot, canonical);
+    if (canonicalRelative.length > 0 && (canonicalRelative.startsWith("..") || path7.isAbsolute(canonicalRelative))) {
       return null;
     }
     return canonical;
@@ -5901,7 +7648,7 @@ var GraphPathStateLoader = class {
   }
   async buildArchivePathIndex(storageRoot, version) {
     const pathsByBasename = /* @__PURE__ */ new Map();
-    const archiveRoot = path6.join(storageRoot, "archive");
+    const archiveRoot = path7.join(storageRoot, "archive");
     let archiveRootStatus;
     try {
       archiveRootStatus = await this.archiveLstat(archiveRoot);
@@ -5919,8 +7666,8 @@ var GraphPathStateLoader = class {
       if (isArchiveScanAbsenceError(error)) return { version, pathsByBasename };
       return null;
     }
-    const archiveRelative = path6.relative(storageRoot, canonicalArchiveRoot);
-    if (archiveRelative.length > 0 && (archiveRelative.startsWith("..") || path6.isAbsolute(archiveRelative))) {
+    const archiveRelative = path7.relative(storageRoot, canonicalArchiveRoot);
+    if (archiveRelative.length > 0 && (archiveRelative.startsWith("..") || path7.isAbsolute(archiveRelative))) {
       return { version, pathsByBasename };
     }
     const pending = [canonicalArchiveRoot];
@@ -5946,8 +7693,8 @@ var GraphPathStateLoader = class {
         if (isArchiveScanAbsenceError(error)) continue;
         return null;
       }
-      const currentRelative = path6.relative(storageRoot, canonicalCurrent);
-      if (currentRelative.length > 0 && (currentRelative.startsWith("..") || path6.isAbsolute(currentRelative))) {
+      const currentRelative = path7.relative(storageRoot, canonicalCurrent);
+      if (currentRelative.length > 0 && (currentRelative.startsWith("..") || path7.isAbsolute(currentRelative))) {
         continue;
       }
       let directory;
@@ -5964,7 +7711,7 @@ var GraphPathStateLoader = class {
             return { version, unavailable: "oversized" };
           }
           if (entry.isSymbolicLink()) continue;
-          const entryPath = path6.join(canonicalCurrent, entry.name);
+          const entryPath = path7.join(canonicalCurrent, entry.name);
           if (entry.isDirectory()) {
             pending.push(entryPath);
             continue;
@@ -5980,8 +7727,8 @@ var GraphPathStateLoader = class {
             if (isArchiveScanAbsenceError(error)) continue;
             return null;
           }
-          const relative = path6.relative(storageRoot, canonical);
-          if (relative.length > 0 && (relative.startsWith("..") || path6.isAbsolute(relative))) {
+          const relative = path7.relative(storageRoot, canonical);
+          if (relative.length > 0 && (relative.startsWith("..") || path7.isAbsolute(relative))) {
             continue;
           }
           const paths = pathsByBasename.get(entry.name);
@@ -6005,9 +7752,9 @@ var GraphPathStateLoader = class {
 };
 
 // src/orchestration/graph-recall-coordinator.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 function mergeGraphExpandedResults(primary, expanded) {
   const mergedByNamespaceAndPath = /* @__PURE__ */ new Map();
   for (const item of [...primary, ...expanded]) {
@@ -6024,11 +7771,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByNamespaceAndPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path7.isAbsolute(candidatePath) ? candidatePath : path7.resolve(storageDir, candidatePath);
-  const rel = path7.relative(storageDir, absolutePath);
+  const absolutePath = path8.isAbsolute(candidatePath) ? candidatePath : path8.resolve(storageDir, candidatePath);
+  const rel = path8.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path7.sep).join("/");
+  return rel.split(path8.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -6128,7 +7875,7 @@ var GraphRecallCoordinator = class {
         resolvedPath = resolvedCold.result.path;
         resolvedResult = resolvedCold.result;
       }
-      if (!path7.isAbsolute(resolvedPath)) {
+      if (!path8.isAbsolute(resolvedPath)) {
         resolvedAmbiguousSeeds.set(result.path, null);
         return null;
       }
@@ -6153,7 +7900,7 @@ var GraphRecallCoordinator = class {
         }
         continue;
       }
-      if (path7.isAbsolute(result.path)) {
+      if (path8.isAbsolute(result.path)) {
         const resolved = await resolveAmbiguousSeedOwner(result, null);
         if (resolved) {
           addResultForNamespace(resolved.namespace, resolved.result);
@@ -6199,7 +7946,7 @@ var GraphRecallCoordinator = class {
         0
       );
       seedPaths.push(
-        ...seedRelativePaths.map((rel) => path7.join(storage.dir, rel))
+        ...seedRelativePaths.map((rel) => path8.join(storage.dir, rel))
       );
       const seedSet = new Set(seedRelativePaths);
       const nodeMemoryCache = /* @__PURE__ */ new Map();
@@ -6253,7 +8000,7 @@ var GraphRecallCoordinator = class {
             path: memory.path,
             score,
             namespace,
-            seed: path7.resolve(storage.dir, candidate.seed),
+            seed: path8.resolve(storage.dir, candidate.seed),
             hopDepth: candidate.hopDepth,
             decayedWeight: candidate.decayedWeight,
             graphType: candidate.graphType,
@@ -6285,7 +8032,7 @@ var GraphRecallCoordinator = class {
         add(memory.frontmatter.id);
         if (relativePath) {
           add(relativePath);
-          if (relativePath.endsWith(".md")) add(path7.basename(relativePath, ".md"));
+          if (relativePath.endsWith(".md")) add(path8.basename(relativePath, ".md"));
         }
         return state;
       };
@@ -6332,7 +8079,7 @@ var GraphRecallCoordinator = class {
           path: memory.path,
           score,
           namespace,
-          seed: path7.resolve(storage.dir, candidate.seed),
+          seed: path8.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType,
@@ -6374,12 +8121,12 @@ var GraphRecallCoordinator = class {
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path7.join(
+      const snapshotPath = path8.join(
         options.storage.dir,
         "state",
         "last_graph_recall.json"
       );
-      await mkdir3(path7.dirname(snapshotPath), { recursive: true });
+      await mkdir3(path8.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -6391,7 +8138,7 @@ var GraphRecallCoordinator = class {
       const payload = {
         recordedAt: now,
         mode: options.recallMode,
-        queryHash: createHash2("sha256").update(options.prompt).digest("hex"),
+        queryHash: createHash4("sha256").update(options.prompt).digest("hex"),
         queryLength: options.prompt.length,
         namespaces: options.recallNamespaces,
         seedCount: totalSeedCount,
@@ -6494,11 +8241,11 @@ ${blocks.join("\n\n")}`;
 }
 
 // src/orchestration/recall-profile-storage.ts
-import path8 from "path";
+import path9 from "path";
 function resolveCompositeProfileStorage(options) {
   const { profileStorages, memoryDir } = options;
   const emptyProfileStorage = new Proxy(
-    { dir: path8.join(memoryDir, ".empty-scope-profile") },
+    { dir: path9.join(memoryDir, ".empty-scope-profile") },
     {
       get(target, prop) {
         if (prop in target) return Reflect.get(target, prop);
@@ -6724,8 +8471,8 @@ var RecallInternalCoordinator = class {
         record: recordRecallSectionMetric,
         logger: log
       });
-      const promptHash = createHash3("sha256").update(prompt).digest("hex");
-      const traceId = createHash3("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
+      const promptHash = createHash5("sha256").update(prompt).digest("hex");
+      const traceId = createHash5("sha256").update(`${sessionKey ?? "default"}:${recallStart}:${promptHash}`).digest("hex").slice(0, 16);
       const sectionBuckets = /* @__PURE__ */ new Map();
       const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
         cronRecallPolicyEnabled: resolveRecallAuxiliaryCapabilities(this.deps.config).cronRecallPolicy,
@@ -6734,7 +8481,7 @@ var RecallInternalCoordinator = class {
         cronConversationRecallMode: this.deps.config.cronConversationRecallMode
       });
       const retrievalQuery = queryPolicy.retrievalQuery || prompt;
-      const retrievalQueryHash = createHash3("sha256").update(retrievalQuery).digest("hex");
+      const retrievalQueryHash = createHash5("sha256").update(retrievalQuery).digest("hex");
       const policyVersion = this.deps.currentPolicyVersion();
       let recallSource = "none";
       let recalledMemoryCount = 0;
@@ -6875,7 +8622,7 @@ var RecallInternalCoordinator = class {
       const graphExpandedResultPaths = /* @__PURE__ */ new Set();
       const graphSourceLabelsForPath = (resultPath) => {
         const labels = [];
-        const normalizedPath = resultPath.split(path9.sep).join("/");
+        const normalizedPath = resultPath.split(path10.sep).join("/");
         const isEntityPath = normalizedPath.startsWith("entities/") || normalizedPath.includes("/entities/");
         if (graphBaselinePaths.has(resultPath)) labels.push("baseline");
         if (graphExpandedResultPaths.has(resultPath))
@@ -8392,16 +10139,16 @@ ${formatted}`;
         if (!resolveRecallAuxiliaryCapabilities(this.deps.config).compactionReset) return null;
         const workspaceDir = compactionWorkspaceDir || this.deps.config.workspaceDir || defaultWorkspaceDir();
         const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-        const signalPath = path9.join(
+        const signalPath = path10.join(
           workspaceDir,
           `.compaction-reset-signal-${safeSessionKey}`
         );
-        const bootPath = path9.join(workspaceDir, "BOOT.md");
+        const bootPath = path10.join(workspaceDir, "BOOT.md");
         try {
           const signalStat = await stat(signalPath).catch(() => null);
           if (!signalStat) return null;
           const signalAge = Date.now() - signalStat.mtimeMs;
-          const signalData = JSON.parse(await readFile2(signalPath, "utf-8"));
+          const signalData = JSON.parse(await readFile3(signalPath, "utf-8"));
           if (signalData.sessionKey !== effectiveSessionKey) {
             log.debug(
               `recall: compaction signal is for ${signalData.sessionKey}, not ${effectiveSessionKey} \u2014 skipping`
@@ -8412,7 +10159,7 @@ ${formatted}`;
             log.debug(
               `recall: stale compaction signal (${Math.round(signalAge / 1e3)}s old), skipping`
             );
-            await unlink(signalPath).catch(() => {
+            await unlink2(signalPath).catch(() => {
             });
             return null;
           }
@@ -8421,7 +10168,7 @@ ${formatted}`;
 
 `;
           try {
-            const bootContent = await readFile2(bootPath, "utf-8");
+            const bootContent = await readFile3(bootPath, "utf-8");
             section += "### BOOT.md (working state before compaction)\n\n";
             section += bootContent + "\n";
           } catch {
@@ -8432,12 +10179,12 @@ ${formatted}`;
           log.info(
             `recall: injected compaction reset context for ${effectiveSessionKey}`
           );
-          await unlink(signalPath).catch(() => {
+          await unlink2(signalPath).catch(() => {
           });
           return section;
         } catch (err) {
           log.debug("recall: compaction signal check failed:", err);
-          await unlink(signalPath).catch(() => {
+          await unlink2(signalPath).catch(() => {
           });
           return null;
         }
@@ -10630,11 +12377,11 @@ ${tmtNode.summary}`
 };
 
 // src/orchestration/recall-search-pipeline.ts
-import { createHash as createHash4 } from "crypto";
-import path11 from "path";
+import { createHash as createHash6 } from "crypto";
+import path12 from "path";
 
 // src/orchestration/recall-search-prefilter.ts
-import path10 from "path";
+import path11 from "path";
 async function fetchActiveArtifactsForNamespace(deps, namespace, prompt, targetCount, options = {}) {
   const storage = await deps.storageRouter.storageFor(namespace);
   let fetchLimit = computeArtifactCandidateFetchLimit(targetCount);
@@ -10763,7 +12510,7 @@ async function searchEmbeddingFallback(deps, query, limit) {
   if (hits.length === 0) return [];
   const results = [];
   for (const hit of hits) {
-    const fullPath = path10.isAbsolute(hit.path) ? hit.path : path10.join(deps.config.memoryDir, hit.path);
+    const fullPath = path11.isAbsolute(hit.path) ? hit.path : path11.join(deps.config.memoryDir, hit.path);
     const memory = await deps.storage.readMemoryByPath(fullPath);
     if (!memory) continue;
     results.push({
@@ -10851,7 +12598,7 @@ var RecallSearchPipelineCoordinator = class {
       if (!options.onDebugSnapshot) return;
       await options.onDebugSnapshot({
         recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        queryHash: createHash4("sha256").update(prompt).digest("hex"),
+        queryHash: createHash6("sha256").update(prompt).digest("hex"),
         queryLength: prompt.length,
         collection: options.collection,
         namespaces: options.recallNamespaces,
@@ -11131,7 +12878,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 = path11.resolve(storageDir);
+          const recallRoot = path12.resolve(storageDir);
           if (seenRecallRoots.has(recallRoot)) continue;
           seenRecallRoots.add(recallRoot);
           recallRoots.push(recallRoot);
@@ -11155,8 +12902,8 @@ var RecallSearchPipelineCoordinator = class {
           if (resolvedCold) scopedResults.push(resolvedCold.result);
           continue;
         }
-        if (path11.isAbsolute(result.path)) {
-          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path11.resolve(result.path)))) {
+        if (path12.isAbsolute(result.path)) {
+          if (recallRoots.some((recallRoot) => isPathInsideStorageRoot(recallRoot, path12.resolve(result.path)))) {
             scopedResults.push(result);
           }
           continue;
@@ -11719,7 +13466,7 @@ var RecallSearchPipelineCoordinator = class {
 };
 
 // src/orchestration/turn-ingestion.ts
-import { createHash as createHash5, randomBytes } from "crypto";
+import { createHash as createHash7, randomBytes } from "crypto";
 var TurnIngestionCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -11904,7 +13651,7 @@ var TurnIngestionCoordinator = class {
     const shouldUseStableBatchKey = turns.some(
       (turn) => turn.persistProcessedFingerprint === true || typeof turn.turnFingerprint === "string" && turn.turnFingerprint.length > 0
     );
-    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash5("sha256").update(
+    const stableBatchFingerprint = shouldUseStableBatchKey ? createHash7("sha256").update(
       turns.map(
         (turn) => [
           turn.role,
@@ -12142,7 +13889,7 @@ var TurnIngestionCoordinator = class {
       };
       scheduleQueueWaitTimeout();
     }
-    this.deps.extractionQueueCoordinator.enqueue(async () => {
+    const accepted = this.deps.extractionQueueCoordinator.enqueue(async () => {
       if (settled) return;
       if (typeof extractionDeadlineMs === "number" && extractionDeadlineMs <= Date.now()) {
         settleTask(new ExtractionDeadlineError("queue_wait"));
@@ -12172,6 +13919,10 @@ var TurnIngestionCoordinator = class {
         }
       }
     });
+    if (!accepted) {
+      settleTask(new Error("extraction queue is stopped"));
+      return;
+    }
     log.debug(`queued extraction from ${reason}`);
   }
   /**
@@ -12245,8 +13996,8 @@ var TurnIngestionCoordinator = class {
 };
 
 // src/orchestration/recall-introspection.ts
-import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
-import path13 from "path";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import path14 from "path";
 
 // src/taxonomy/default-taxonomy.ts
 var DEFAULT_TAXONOMY = {
@@ -12368,8 +14119,8 @@ function generateResolverDocument(taxonomy) {
 }
 
 // src/taxonomy/taxonomy-loader.ts
-import { readFile as readFile3, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
-import path12 from "path";
+import { readFile as readFile4, mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import path13 from "path";
 var TAXONOMY_DIR = ".taxonomy";
 var TAXONOMY_FILE = "taxonomy.json";
 var MAX_SLUG_LENGTH = 32;
@@ -12467,10 +14218,10 @@ function validateTaxonomy(taxonomy) {
   }
 }
 async function loadTaxonomy(memoryDir) {
-  const taxonomyPath = path12.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  const taxonomyPath = path13.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
   let raw;
   try {
-    raw = await readFile3(taxonomyPath, "utf-8");
+    raw = await readFile4(taxonomyPath, "utf-8");
   } catch (err) {
     if (err instanceof Error && err.code === "ENOENT") {
       return structuredClone(DEFAULT_TAXONOMY);
@@ -12517,16 +14268,16 @@ async function loadTaxonomy(memoryDir) {
 }
 async function saveTaxonomy(memoryDir, taxonomy) {
   validateTaxonomy(taxonomy);
-  const dir = path12.join(memoryDir, TAXONOMY_DIR);
+  const dir = path13.join(memoryDir, TAXONOMY_DIR);
   await mkdir4(dir, { recursive: true });
-  const filePath = path12.join(dir, TAXONOMY_FILE);
+  const filePath = path13.join(dir, TAXONOMY_FILE);
   await writeFile4(filePath, JSON.stringify(taxonomy, null, 2) + "\n", "utf-8");
 }
 function getTaxonomyDir(memoryDir) {
-  return path12.join(memoryDir, TAXONOMY_DIR);
+  return path13.join(memoryDir, TAXONOMY_DIR);
 }
 function getTaxonomyFilePath(memoryDir) {
-  return path12.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
+  return path13.join(memoryDir, TAXONOMY_DIR, TAXONOMY_FILE);
 }
 
 // src/orchestration/recall-introspection.ts
@@ -12550,13 +14301,13 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path13.join(
+    const snapshotPath = path14.join(
       storage.dir,
       "state",
       "last_graph_recall.json"
     );
     try {
-      const raw = await readFile4(snapshotPath, "utf-8");
+      const raw = await readFile5(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -12589,9 +14340,9 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastIntentSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path13.join(storage.dir, "state", "last_intent.json");
+    const snapshotPath = path14.join(storage.dir, "state", "last_intent.json");
     try {
-      const raw = await readFile4(snapshotPath, "utf-8");
+      const raw = await readFile5(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       const graphDecision = parsed.graphDecision && typeof parsed.graphDecision === "object" ? parsed.graphDecision : void 0;
@@ -12622,13 +14373,13 @@ var RecallIntrospectionCoordinator = class {
   }
   async getLastQmdRecallSnapshot(namespace) {
     const storage = await this.deps.getStorage(namespace);
-    const snapshotPath = path13.join(
+    const snapshotPath = path14.join(
       storage.dir,
       "state",
       "last_qmd_recall.json"
     );
     try {
-      const raw = await readFile4(snapshotPath, "utf-8");
+      const raw = await readFile5(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || typeof parsed !== "object") return null;
       return {
@@ -12914,12 +14665,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastIntentSnapshot(options) {
     try {
-      const snapshotPath = path13.join(
+      const snapshotPath = path14.join(
         options.storage.dir,
         "state",
         "last_intent.json"
       );
-      await mkdir5(path13.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path14.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12931,12 +14682,12 @@ var RecallIntrospectionCoordinator = class {
   }
   async recordLastQmdRecallSnapshot(options) {
     try {
-      const snapshotPath = path13.join(
+      const snapshotPath = path14.join(
         options.storage.dir,
         "state",
         "last_qmd_recall.json"
       );
-      await mkdir5(path13.dirname(snapshotPath), { recursive: true });
+      await mkdir5(path14.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12951,8 +14702,8 @@ var RecallIntrospectionCoordinator = class {
       const stateDir = await this.deps.resolveStateDirForNamespace(
         options.namespace
       );
-      const snapshotPath = path13.join(stateDir, "last_intent.json");
-      await mkdir5(path13.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path14.join(stateDir, "last_intent.json");
+      await mkdir5(path14.dirname(snapshotPath), { recursive: true });
       await writeFile5(
         snapshotPath,
         JSON.stringify(options.snapshot, null, 2),
@@ -12965,8 +14716,8 @@ var RecallIntrospectionCoordinator = class {
 };
 
 // src/orchestration/orchestrator-init.ts
-import { readdir as readdir2, stat as stat2, unlink as unlink2 } from "fs/promises";
-import path14 from "path";
+import { readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
+import path15 from "path";
 var OrchestratorInitCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -13070,10 +14821,10 @@ var OrchestratorInitCoordinator = class {
           const files = await readdir2(wsDir).catch(() => []);
           for (const f of files) {
             if (!f.startsWith(".compaction-reset-signal-")) continue;
-            const fp = path14.join(wsDir, f);
+            const fp = path15.join(wsDir, f);
             const s = await stat2(fp).catch(() => null);
             if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
-              await unlink2(fp).catch(() => {
+              await unlink3(fp).catch(() => {
               });
               log.debug(`initialize: removed stale compaction signal ${f}`);
             }
@@ -13422,7 +15173,7 @@ var OrchestratorInitCoordinator = class {
 };
 
 // src/orchestration/persistence-index.ts
-import path15 from "path";
+import path16 from "path";
 var PersistenceIndexCoordinator = class {
   constructor(deps) {
     this.deps = deps;
@@ -13608,7 +15359,7 @@ var PersistenceIndexCoordinator = class {
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path15.relative(storage.dir, m.path);
+            const rel = path16.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -13756,8 +15507,8 @@ var PersistenceIndexCoordinator = class {
 };
 
 // src/orchestration/workspace-ops.ts
-import { lstat as lstat2, mkdir as mkdir6, readFile as readFile5, readdir as readdir3, realpath as realpath2, writeFile as writeFile6 } from "fs/promises";
-import path16 from "path";
+import { lstat as lstat2, mkdir as mkdir6, readFile as readFile6, readdir as readdir3, realpath as realpath2, writeFile as writeFile6 } from "fs/promises";
+import path17 from "path";
 
 // src/maintenance/pattern-reinforcement.ts
 function patternReinforcementKey(content) {
@@ -13797,22 +15548,22 @@ function memoryInstant(memory) {
   const parsed = Date.parse(stamp);
   return Number.isFinite(parsed) ? parsed : null;
 }
-var ACTIVE_STATUS = "active";
+var ACTIVE_STATUS2 = "active";
 async function runPatternReinforcement(storage, options) {
   const minCount = Math.max(2, Math.floor(options.minCount));
   const targetCategories = new Set(options.categories);
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   const nowIso = now().toISOString();
   if (targetCategories.size === 0) {
-    return emptyResult();
+    return emptyResult2();
   }
   const memories = await storage.readAllMemories();
   const eligible = memories.filter((m) => {
     if (!targetCategories.has(m.frontmatter.category)) return false;
-    const status = m.frontmatter.status ?? ACTIVE_STATUS;
-    return status === ACTIVE_STATUS || status === "superseded";
+    const status = m.frontmatter.status ?? ACTIVE_STATUS2;
+    return status === ACTIVE_STATUS2 || status === "superseded";
   });
-  if (eligible.length === 0) return emptyResult();
+  if (eligible.length === 0) return emptyResult2();
   const clusters = clusterByKey(
     eligible,
     (m) => patternReinforcementClusterKey(m.frontmatter.category, m.content)
@@ -13826,8 +15577,8 @@ async function runPatternReinforcement(storage, options) {
   for (const cluster of clusters.values()) {
     if (cluster.length < minCount) continue;
     const activeMembers = cluster.filter((m) => {
-      const status = m.frontmatter.status ?? ACTIVE_STATUS;
-      return status === ACTIVE_STATUS;
+      const status = m.frontmatter.status ?? ACTIVE_STATUS2;
+      return status === ACTIVE_STATUS2;
     });
     if (activeMembers.length === 0) continue;
     result.clustersFound += 1;
@@ -13898,7 +15649,7 @@ async function runPatternReinforcement(storage, options) {
   }
   return result;
 }
-function emptyResult() {
+function emptyResult2() {
   return {
     clustersFound: 0,
     canonicalsUpdated: 0,
@@ -15664,8 +17415,8 @@ var MeetingsService = class {
 // src/orchestration/workspace-ops.ts
 var MEETINGS_BUILD_DEBOUNCE_MS = 5e3;
 function matchesMemoryPath(candidatePath, requestedPath, memoryDir) {
-  const normalizedCandidate = path16.resolve(candidatePath);
-  return normalizedCandidate === path16.resolve(requestedPath) || normalizedCandidate === path16.resolve(memoryDir, requestedPath);
+  const normalizedCandidate = path17.resolve(candidatePath);
+  return normalizedCandidate === path17.resolve(requestedPath) || normalizedCandidate === path17.resolve(memoryDir, requestedPath);
 }
 function accessTrackingPathCandidates(storageDir, memoryPath) {
   const candidates = qmdResultPathCandidates(storageDir, memoryPath);
@@ -15673,12 +17424,12 @@ function accessTrackingPathCandidates(storageDir, memoryPath) {
   if (!parts) return candidates;
   candidates.push(
     ...qmdResultPathCandidates(storageDir, parts.relativePath),
-    ...qmdResultPathCandidates(path16.join(storageDir, "cold"), parts.relativePath)
+    ...qmdResultPathCandidates(path17.join(storageDir, "cold"), parts.relativePath)
   );
   return [...new Set(candidates)];
 }
 function canonicalMemoryPath(memoryPath, memoryDir) {
-  return path16.resolve(path16.isAbsolute(memoryPath) ? memoryPath : path16.resolve(memoryDir, memoryPath));
+  return path17.resolve(path17.isAbsolute(memoryPath) ? memoryPath : path17.resolve(memoryDir, memoryPath));
 }
 var WorkspaceOpsCoordinator = class {
   constructor(deps) {
@@ -15760,15 +17511,15 @@ var WorkspaceOpsCoordinator = class {
     this.deps.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path16.isAbsolute(rel) ? rel : path16.join(this.deps.config.workspaceDir, rel);
+        const abs = path17.isAbsolute(rel) ? rel : path17.join(this.deps.config.workspaceDir, rel);
         try {
-          const raw = await readFile5(abs, "utf-8");
+          const raw = await readFile6(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path16.join(
+            const archiveDir = path17.join(
               this.deps.config.workspaceDir,
               hygiene.archiveDir
             );
-            const base = path16.basename(abs);
+            const base = path17.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -15793,8 +17544,8 @@ var WorkspaceOpsCoordinator = class {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path16.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir6(path16.dirname(fp), { recursive: true });
+        const fp = path17.join(this.deps.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir6(path17.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -15803,7 +17554,7 @@ var WorkspaceOpsCoordinator = class {
 ` + warnings.map((w) => `- ${w.message}`).join("\n") + "\n";
         let existing = "";
         try {
-          existing = await readFile5(fp, "utf-8");
+          existing = await readFile6(fp, "utf-8");
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
@@ -15834,7 +17585,7 @@ var WorkspaceOpsCoordinator = class {
     for (const categoryDir of RECALL_FALLBACK_DIRS) {
       if (memoryRootReal === null) break;
       for (const date of datesToScan) {
-        const dateDir = path16.join(storage.dir, categoryDir, date);
+        const dateDir = path17.join(storage.dir, categoryDir, date);
         try {
           const dirStat = await lstat2(dateDir);
           if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
@@ -15843,10 +17594,10 @@ var WorkspaceOpsCoordinator = class {
           for (const entry of entries) {
             if (entry.isSymbolicLink()) continue;
             if (!entry.name.endsWith(".md")) continue;
-            const fullPath = path16.join(dateDir, entry.name);
+            const fullPath = path17.join(dateDir, entry.name);
             try {
               assertPathInsideRoot(memoryRootReal, await realpath2(fullPath), fullPath);
-              const raw = await readFile5(fullPath, "utf-8");
+              const raw = await readFile6(fullPath, "utf-8");
               const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
               if (!fmMatch) continue;
               const fmBlock = fmMatch[1];
@@ -15865,7 +17616,7 @@ var WorkspaceOpsCoordinator = class {
               facts.push({
                 path: fullPath,
                 frontmatter: {
-                  id: fm.id || path16.basename(entry.name, ".md"),
+                  id: fm.id || path17.basename(entry.name, ".md"),
                   category: fm.category || "fact",
                   created,
                   updated: fm.updated || created,
@@ -15888,15 +17639,15 @@ var WorkspaceOpsCoordinator = class {
       return a.frontmatter.created < b.frontmatter.created ? -1 : 1;
     });
     const hourlySummaries = [];
-    const hourlyBaseDir = path16.join(storage.dir, "summaries", "hourly");
+    const hourlyBaseDir = path17.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 = path16.join(hourlyBaseDir, sk.name, `${date}.md`);
+          const summaryFile = path17.join(hourlyBaseDir, sk.name, `${date}.md`);
           try {
-            const raw = await readFile5(summaryFile, "utf-8");
+            const raw = await readFile6(summaryFile, "utf-8");
             const filtered = filterHourlySummaryMarkdownForLocalDay(
               raw,
               date,
@@ -16358,18 +18109,18 @@ ${reflectionsContent.trim()}
 // src/orchestration/namespace-read-fanout.ts
 import { existsSync, readFileSync } from "fs";
 import { stat as stat3 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 
 // src/orchestration/orchestrator-namespace-scope.ts
-import path17 from "path";
+import path18 from "path";
 function computeSemanticDedupScope(targetStorage, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return {};
-  const memoryDir = path17.resolve(config.memoryDir);
-  const storageDir = path17.resolve(targetStorage.dir);
+  const memoryDir = path18.resolve(config.memoryDir);
+  const storageDir = path18.resolve(targetStorage.dir);
   if (storageDir === memoryDir) {
     return { pathExcludePrefixes: ["namespaces/"] };
   }
-  let rel = path17.relative(memoryDir, storageDir);
+  let rel = path18.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`
@@ -16422,7 +18173,7 @@ var NamespaceReadFanoutCoordinator = class {
   loadNamespaceStorageDirHintsFromCatalog() {
     if (this.deps.namespaceStorageDirHintsLoaded || !this.deps.namespaceCatalog.enabled) return;
     this.deps.namespaceStorageDirHintsLoaded = true;
-    const catalogPath = path18.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
+    const catalogPath = path19.join(this.deps.config.memoryDir, "state", "namespaces.jsonl");
     if (!existsSync(catalogPath)) return;
     let body;
     try {
@@ -16459,7 +18210,7 @@ var NamespaceReadFanoutCoordinator = class {
       if (!this.deps.storageDirMatchesNamespaceHint(record.namespace, record.storageDir)) {
         continue;
       }
-      const resolvedStorageDir = path18.resolve(record.storageDir);
+      const resolvedStorageDir = path19.resolve(record.storageDir);
       const current = preferredByStorageDir.get(resolvedStorageDir);
       preferredByStorageDir.set(
         resolvedStorageDir,
@@ -16643,12 +18394,12 @@ var NamespaceReadFanoutCoordinator = class {
   }
   async resolveStateDirForNamespace(namespace) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) {
-      return path18.join(this.deps.config.memoryDir, "state");
+      return path19.join(this.deps.config.memoryDir, "state");
     }
     if (namespace !== this.deps.config.defaultNamespace) {
-      return path18.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
+      return path19.join(this.deps.config.memoryDir, "namespaces", namespace, "state");
     }
-    const candidate = path18.join(
+    const candidate = path19.join(
       this.deps.config.memoryDir,
       "namespaces",
       this.deps.config.defaultNamespace
@@ -16656,11 +18407,11 @@ var NamespaceReadFanoutCoordinator = class {
     try {
       const candidateStat = await stat3(candidate);
       if (candidateStat.isDirectory()) {
-        return path18.join(candidate, "state");
+        return path19.join(candidate, "state");
       }
     } catch {
     }
-    return path18.join(this.deps.config.memoryDir, "state");
+    return path19.join(this.deps.config.memoryDir, "state");
   }
   namespaceFromPath(p) {
     if (!resolveNamespaceCapabilities(this.deps.config).namespaces) return this.deps.config.defaultNamespace;
@@ -17097,25 +18848,27 @@ var Orchestrator = class {
   passiveCorrectionDedup = /* @__PURE__ */ new Set();
   _passiveCorrectionService = null;
   passiveCorrectionTelemetry = { detected: 0, queued: 0, autoApplied: 0, suppressedReasonCounts: {} };
-  /**
-   * Background serial extraction queue coordinator (issue #1526 — moved
-   * from inline `extractionQueue`/`queueProcessing` fields). Owns queue
-   * state + scheduling + the serial drain + failure classification; the
-   * orchestrator builds each task closure in `queueBufferedExtraction` and
-   * hands it to `enqueue`.
-   */
+  _dependencyPropagationDelivery;
+  _dependencyPropagationRecovery = null;
+  destroyed = false;
+  get dependencyPropagationDelivery() {
+    if (this.destroyed) throw new Error("orchestrator has been destroyed");
+    if (!this._dependencyPropagationDelivery) {
+      this._dependencyPropagationDelivery = new DependencyPropagationDelivery({
+        queueRoot: path20.join(this.config.memoryDir, "state", "dependency-propagation"),
+        config: this.config,
+        extraction: this.extraction,
+        getStorage: (namespace) => this.getStorage(namespace),
+        readQueueFile: (filePath) => this.storage.readDependencyPropagationQueueFile(filePath),
+        writeQueueFile: (filePath, content) => this.storage.writeDependencyPropagationQueueFile(filePath, content),
+        autoStart: true,
+        replayReconciliation: createDependencyPropagationReplayReconciliation({ getStorage: (namespace) => this.getStorage(namespace), indexPersistedMemory: (storage, memoryId) => this.indexPersistedMemory(storage, memoryId), removeFromIndex: (memoryId) => this.embeddingFallback.removeFromIndex(memoryId), config: this.config })
+      });
+    }
+    return this._dependencyPropagationDelivery;
+  }
   extractionQueueCoordinator;
-  /**
-   * Extraction-run pipeline coordinator (issue #1526 seam 15). Owns
-   * `runExtraction` + dedupe fingerprint helpers + processed-fingerprint
-   * recording. The orchestrator delegates and injects its own methods.
-   */
   _extractionRunCoordinator;
-  /**
-   * Lazy getter: creates the ExtractionRunCoordinator on first access using
-   * the orchestrator's live field references. Supports Object.create(prototype)
-   * tests that set fields post-construction without invoking the constructor.
-   */
   get extractionRunCoordinator() {
     if (!this._extractionRunCoordinator) {
       this._extractionRunCoordinator = new ExtractionRunCoordinator({
@@ -17140,15 +18893,6 @@ var Orchestrator = class {
     }
     return this._extractionRunCoordinator;
   }
-  /**
-   * Consolidation-run coordinator (issue #1526 seam 17). Owns
-   * the full consolidation maintenance pass (LLM merge/invalidate/update,
-   * entity merge, commitment/TTL cleanup, lifecycle policy, compression
-   * guideline learning, tier migration, fact archival, semantic consolidation,
-   * identity consolidation, profile consolidation, summarization, topic
-   * extraction, TMT rebuild). The orchestrator delegates and injects
-   * its own methods + coordinators.
-   */
   _consolidationRunCoordinator;
   get consolidationRunCoordinator() {
     if (!this._consolidationRunCoordinator) {
@@ -17158,6 +18902,8 @@ var Orchestrator = class {
         getStorageRouter: () => this.storageRouter,
         getNamespaceCatalog: () => this.namespaceCatalog,
         getExtraction: () => this.extraction,
+        storageDirNamespace: (storageDir) => this.storageDirNamespace(storageDir),
+        getDependencyPropagationDelivery: () => this.dependencyPropagationDelivery,
         embeddingFallback: this.embeddingFallback,
         tmtBuilder: this.tmtBuilder,
         consolidationObservers: this.consolidationObservers,
@@ -17176,11 +18922,6 @@ var Orchestrator = class {
     }
     return this._consolidationRunCoordinator;
   }
-  /**
-   * Extraction-persist coordinator (issue #1526 seam 16). Owns the
-   * `persistExtraction` pipeline. Lazy: created on first access so
-   * Object.create(prototype) tests that set fields post-construction work.
-   */
   _extractionPersistCoordinator;
   get extractionPersistCoordinator() {
     if (!this._extractionPersistCoordinator) {
@@ -17188,8 +18929,8 @@ var Orchestrator = class {
         config: this.config,
         getStorageRouter: () => this.storageRouter,
         getThreading: () => this.threading,
+        getDependencyPropagationDelivery: () => this.dependencyPropagationDelivery,
         getLocalLlm: () => this.localLlm,
-        getExtraction: () => this.extraction,
         getQmd: () => this.qmd,
         getJudgeVerdictCache: () => this.judgeVerdictCache,
         getJudgeDeferCounts: () => this.judgeDeferCounts,
@@ -17309,12 +19050,21 @@ var Orchestrator = class {
    */
   async destroy() {
     this.abortDeferredInit();
+    this.extractionQueueCoordinator.stopAccepting();
     if (this.wearablesAutoSyncHandle) {
       await this.wearablesAutoSyncHandle.stop();
       this.wearablesAutoSyncHandle = null;
     }
     for (const svc of this.meetingsServiceByNamespace.values()) svc.dispose();
     await this.maintenanceScheduler.dispose();
+    await this._dependencyPropagationRecovery;
+    this._dependencyPropagationRecovery = null;
+    const extractionDrainError = await drainExtractionAndShutdownDependencyPropagation(
+      this.extractionQueueCoordinator,
+      this._dependencyPropagationDelivery
+    );
+    this.destroyed = true;
+    this._dependencyPropagationDelivery = void 0;
     await drainRecallWrites(this);
     await this.persistenceIndexCoordinator.drainContentHashReconcileRetries().catch((err) => log.warn(`content-hash reconcile drain failed during destroy: ${err}`));
     let bufferFlushError;
@@ -17338,6 +19088,12 @@ var Orchestrator = class {
         );
         throw bufferFlushError;
       }
+      if (extractionDrainError !== void 0) {
+        log.warn(
+          `orchestrator.destroy: extraction queue did not drain before teardown: ${String(extractionDrainError)}`
+        );
+        throw extractionDrainError;
+      }
     }
   }
   /** Set per-session workspace for the next recall() call (compaction reset). @internal */
@@ -17441,7 +19197,7 @@ var Orchestrator = class {
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (ns !== defaultNs && !isSafeRouteNamespace(ns)) return;
     if (!this.storageDirMatchesNamespaceHint(ns, storageDir)) return;
-    const resolvedStorageDir = path19.resolve(storageDir);
+    const resolvedStorageDir = path20.resolve(storageDir);
     let hints = this.namespaceStorageDirHints.get(resolvedStorageDir);
     if (!hints) {
       hints = /* @__PURE__ */ new Set();
@@ -17452,21 +19208,21 @@ var Orchestrator = class {
   storageDirMatchesNamespaceHint(namespace, storageDir) {
     const ns = normalizeNamespaceIdentity(namespace);
     if (!ns) return false;
-    const resolvedStorageDir = path19.resolve(storageDir);
-    const resolvedMemoryDir = path19.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path20.resolve(storageDir);
+    const resolvedMemoryDir = path20.resolve(this.config.memoryDir);
     const defaultNs = normalizeNamespaceIdentity(this.config.defaultNamespace);
     if (resolvedStorageDir === resolvedMemoryDir) return ns === defaultNs;
-    const resolvedNamespacesDir = path19.join(resolvedMemoryDir, "namespaces");
+    const resolvedNamespacesDir = path20.join(resolvedMemoryDir, "namespaces");
     if (!isPathInsideStorageRoot(resolvedNamespacesDir, resolvedStorageDir)) return false;
-    const rawRoot = path19.resolve(resolvedNamespacesDir, ns);
-    const tokenRoot = path19.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
+    const rawRoot = path20.resolve(resolvedNamespacesDir, ns);
+    const tokenRoot = path20.resolve(resolvedNamespacesDir, namespaceIdentityToken(ns));
     return resolvedStorageDir === rawRoot || resolvedStorageDir === tokenRoot;
   }
   namespaceStorageDirHintOwnershipRank(record, resolvedStorageDir, configured) {
-    if (resolvedStorageDir === path19.resolve(this.config.memoryDir)) {
+    if (resolvedStorageDir === path20.resolve(this.config.memoryDir)) {
       return record.namespace === normalizeNamespaceIdentity(this.config.defaultNamespace) ? 0 : 3;
     }
-    const leaf = path19.basename(resolvedStorageDir);
+    const leaf = path20.basename(resolvedStorageDir);
     const tokenOwnsRoot = namespaceIdentityToken(record.namespace) === leaf;
     if (tokenOwnsRoot && configured.has(record.namespace)) return 0;
     if (record.namespace === leaf) return 1;
@@ -17606,7 +19362,7 @@ var Orchestrator = class {
     StorageManager.setScopedCacheInvalidationDefault(config.memoryDir, scopedCacheInvalidationEnabled);
     this.profiler = new ProfilingCollector({
       enabled: resolvePipelineProcessingCapabilities(this.config).profiling,
-      storageDir: config.profilingStorageDir || path19.join(config.memoryDir, "profiling"),
+      storageDir: config.profilingStorageDir || path20.join(config.memoryDir, "profiling"),
       maxTraces: config.profilingMaxTraces
     });
     this.namespaceCatalog = new NamespaceCatalog(config);
@@ -17693,7 +19449,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 = path19.join(
+    this.conversationIndexDir = path20.join(
       config.memoryDir,
       "conversation-index",
       "chunks"
@@ -17720,7 +19476,9 @@ var Orchestrator = class {
       extractMemoryIdsFromResults: (results) => this.extractMemoryIdsFromResults(results),
       namespaceFromPath: (p) => this.namespaceFromPath(p),
       storageForNamespace: (namespace) => this.storageRouter.storageFor(namespace),
-      getExtraction: () => this.extraction
+      getExtraction: () => this.extraction,
+      storageDirNamespace: (storageDir) => this.storageDirNamespace(storageDir),
+      getDependencyPropagationDelivery: () => this.dependencyPropagationDelivery
     });
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.graphRecallCoordinator = new GraphRecallCoordinator({
@@ -17841,7 +19599,7 @@ var Orchestrator = class {
       saveContentHashIndexes: () => this.saveContentHashIndexes()
     });
     this.threading = new ThreadingManager(
-      path19.join(config.memoryDir, "threads"),
+      path20.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     const lifecycleCaps = resolveMemoryLifecycleCapabilities(config);
@@ -17921,7 +19679,7 @@ var Orchestrator = class {
       utilityPromoteThresholdDelta: this.utilityRuntimeValues?.promoteThresholdDelta ?? 0,
       utilityDemoteThresholdDelta: this.utilityRuntimeValues?.demoteThresholdDelta ?? 0
     };
-    return createHash6("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
+    return createHash8("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 12);
   }
   effectiveLifecycleThresholds() {
     const archiveDecayThreshold = this.config.lifecycleArchiveDecayThreshold;
@@ -18022,7 +19780,13 @@ var Orchestrator = class {
     return buildChainFollowupGenerator(this.fastLlmForRerank);
   }
   async initialize() {
-    return this.orchestratorInitCoordinator.initialize();
+    this.extractionQueueCoordinator.resumeAccepting();
+    await this.orchestratorInitCoordinator.initialize();
+    if (isDependencyPropagationEnabled(this.config)) {
+      this._dependencyPropagationRecovery = this.dependencyPropagationDelivery.recover().catch((err) => {
+        log.warn(`dependency propagation startup recovery failed: ${err}`);
+      });
+    }
   }
   async deferredInitialize(signal) {
     return this.orchestratorInitCoordinator.deferredInitialize(
@@ -19945,9 +21709,9 @@ function readStructuralSymbol(entry) {
   const rec = entry;
   const symbol = typeof rec.symbol === "string" ? rec.symbol.trim() : "";
   if (!symbol) return null;
-  const path34 = typeof rec.path === "string" && rec.path.length > 0 ? rec.path : void 0;
+  const path35 = 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 = path34 !== void 0 && kind !== void 0 ? { symbol, path: path34, kind } : path34 !== void 0 ? { symbol, path: path34 } : kind !== void 0 ? { symbol, kind } : { symbol };
+  const item = path35 !== void 0 && kind !== void 0 ? { symbol, path: path35, kind } : path35 !== void 0 ? { symbol, path: path35 } : kind !== void 0 ? { symbol, kind } : { symbol };
   return item;
 }
 function classifySpawnError(err) {
@@ -20021,7 +21785,7 @@ var DEFAULT_GRACE_PERIOD_DAYS = 7;
 
 // src/binary-lifecycle/backend.ts
 import fsp from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 var FilesystemBackend = class {
   type = "filesystem";
   basePath;
@@ -20029,19 +21793,19 @@ var FilesystemBackend = class {
     if (!basePath || basePath.trim().length === 0) {
       throw new Error("FilesystemBackend requires a non-empty basePath");
     }
-    this.basePath = path20.resolve(basePath);
+    this.basePath = path21.resolve(basePath);
   }
   resolveRemotePath(remotePath) {
-    const resolved = path20.isAbsolute(remotePath) ? path20.resolve(remotePath) : path20.resolve(this.basePath, remotePath);
-    const relative = path20.relative(this.basePath, resolved);
-    if (relative === ".." || relative.startsWith(`..${path20.sep}`) || path20.isAbsolute(relative)) {
+    const resolved = path21.isAbsolute(remotePath) ? path21.resolve(remotePath) : path21.resolve(this.basePath, remotePath);
+    const relative = path21.relative(this.basePath, resolved);
+    if (relative === ".." || relative.startsWith(`..${path21.sep}`) || path21.isAbsolute(relative)) {
       throw new Error(`FilesystemBackend remotePath escapes basePath: ${JSON.stringify(remotePath)}`);
     }
     return resolved;
   }
   isInsideBase(candidate, realBase) {
-    const relative = path20.relative(realBase, candidate);
-    return relative === "" || relative !== ".." && !relative.startsWith(`..${path20.sep}`) && !path20.isAbsolute(relative);
+    const relative = path21.relative(realBase, candidate);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${path21.sep}`) && !path21.isAbsolute(relative);
   }
   async realBasePathIfExists() {
     try {
@@ -20070,13 +21834,13 @@ var FilesystemBackend = class {
   }
   async ensureSafeParentDirectory(dest) {
     const realBase = await this.ensureBaseDirectory();
-    const destDir = path20.dirname(dest);
-    const relativeDir = path20.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path20.sep);
+    const destDir = path21.dirname(dest);
+    const relativeDir = path21.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path21.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path20.join(current, segment);
+      current = path21.join(current, segment);
       try {
         const stat5 = await fsp.lstat(current);
         if (stat5.isSymbolicLink()) {
@@ -20104,13 +21868,13 @@ var FilesystemBackend = class {
     if (realBase === null) {
       return null;
     }
-    const destDir = path20.dirname(dest);
-    const relativeDir = path20.relative(this.basePath, destDir);
-    const segments = relativeDir === "" ? [] : relativeDir.split(path20.sep);
+    const destDir = path21.dirname(dest);
+    const relativeDir = path21.relative(this.basePath, destDir);
+    const segments = relativeDir === "" ? [] : relativeDir.split(path21.sep);
     let current = this.basePath;
     for (const segment of segments) {
       if (segment === "." || segment === "") continue;
-      current = path20.join(current, segment);
+      current = path21.join(current, segment);
       let stat5;
       try {
         stat5 = await fsp.lstat(current);
@@ -20158,7 +21922,7 @@ var FilesystemBackend = class {
     return dest;
   }
   async upload(localPath, remotePath) {
-    if (path20.isAbsolute(remotePath)) {
+    if (path21.isAbsolute(remotePath)) {
       throw new Error(`FilesystemBackend upload remotePath must be relative: ${JSON.stringify(remotePath)}`);
     }
     const dest = this.resolveRemotePath(remotePath);
@@ -20231,7 +21995,7 @@ function createBackend(cfg) {
 
 // src/binary-lifecycle/scanner.ts
 import fsp2 from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 import crypto from "crypto";
 function matchesPatterns(filename, patterns) {
   const lower = filename.toLowerCase();
@@ -20256,8 +22020,8 @@ async function scanForBinaries(memoryDir, config, manifest) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path21.join(dir, entry.name);
-      const relativePath = path21.relative(memoryDir, fullPath).split(path21.sep).join("/");
+      const fullPath = path22.join(dir, entry.name);
+      const relativePath = path22.relative(memoryDir, fullPath).split(path22.sep).join("/");
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(fullPath);
@@ -20297,15 +22061,15 @@ async function hashFile(filePath) {
 
 // src/binary-lifecycle/manifest.ts
 import fsp3 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import crypto2 from "crypto";
 var MANIFEST_DIR = ".binary-lifecycle";
 var MANIFEST_FILE = "manifest.json";
 function manifestDir(memoryDir) {
-  return path22.join(memoryDir, MANIFEST_DIR);
+  return path23.join(memoryDir, MANIFEST_DIR);
 }
 function manifestPath(memoryDir) {
-  return path22.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
+  return path23.join(memoryDir, MANIFEST_DIR, MANIFEST_FILE);
 }
 async function readManifest(memoryDir) {
   const filePath = manifestPath(memoryDir);
@@ -20357,13 +22121,13 @@ function emptyManifest() {
 
 // src/binary-lifecycle/pipeline.ts
 import fsp4 from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import crypto3 from "crypto";
 var historicalIdCache = new HistoricalEntityCanonicalIdCache();
 function isRecallCorpusMarkdown(mdPath, memoryDir) {
-  const rel = path23.relative(memoryDir, mdPath);
-  if (rel.startsWith("..") || path23.isAbsolute(rel)) return false;
-  const top = rel.split(path23.sep)[0];
+  const rel = path24.relative(memoryDir, mdPath);
+  if (rel.startsWith("..") || path24.isAbsolute(rel)) return false;
+  const top = rel.split(path24.sep)[0];
   return RECALL_FALLBACK_DIRS.includes(top);
 }
 async function hashFile2(filePath) {
@@ -20387,13 +22151,13 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function resolveManifestAssetPath(memoryDir, originalPath) {
-  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path23.isAbsolute(originalPath) || path23.win32.isAbsolute(originalPath)) {
+  if (originalPath.length === 0 || originalPath.includes("\0") || originalPath.includes("\\") || path24.isAbsolute(originalPath) || path24.win32.isAbsolute(originalPath)) {
     return null;
   }
-  const memoryRoot = path23.resolve(memoryDir);
-  const fullPath = path23.resolve(memoryRoot, originalPath);
-  const relative = path23.relative(memoryRoot, fullPath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path23.sep}`) || path23.isAbsolute(relative)) {
+  const memoryRoot = path24.resolve(memoryDir);
+  const fullPath = path24.resolve(memoryRoot, originalPath);
+  const relative = path24.relative(memoryRoot, fullPath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path24.sep}`) || path24.isAbsolute(relative)) {
     return null;
   }
   return fullPath;
@@ -20404,7 +22168,7 @@ function validateBinaryLifecycleConfig(config) {
   }
 }
 function remotePathForAsset(backend, relPath) {
-  const normalized = relPath.split(path23.sep).join("/");
+  const normalized = relPath.split(path24.sep).join("/");
   if (backend.type === "filesystem") {
     return `.binary-lifecycle/mirrors/${normalized}`;
   }
@@ -20417,11 +22181,11 @@ async function stageMirror(memoryDir, newPaths, backend, assets, log2, dryRun) {
   let mirrored = 0;
   const errors = [];
   for (const relPath of newPaths) {
-    const fullPath = path23.join(memoryDir, relPath);
+    const fullPath = path24.join(memoryDir, relPath);
     try {
       const stat5 = await fsp4.stat(fullPath);
       const contentHash = await hashFile2(fullPath);
-      const ext = path23.extname(relPath);
+      const ext = path24.extname(relPath);
       const mimeType = guessMimeType(ext);
       const remotePath = remotePathForAsset(backend, relPath);
       let backendLocation = remotePath;
@@ -20559,7 +22323,7 @@ async function stageRedirect(memoryDir, assets, log2, dryRun, readMarkdownFile,
     for (const update of updates) {
       try {
         await withRawEntityPageMutation(memoryDir, update.mdPath, async () => {
-          const stateDir = path23.join(memoryDir, "state");
+          const stateDir = path24.join(memoryDir, "state");
           const kind = classifyEntityRefWritePath(memoryDir, update.mdPath);
           if (kind === "memory") {
             const idsAtWrite = historicalIdCache.get(stateDir);
@@ -20653,10 +22417,10 @@ async function countRemainingLocalReferences(memoryDir, asset, assetAbsolute, md
   return { remaining, errors };
 }
 function markdownReferencePattern(asset, assetAbsolute, mdPath) {
-  const mdDir = path23.dirname(mdPath);
+  const mdDir = path24.dirname(mdPath);
   const candidates = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const normalized = candidate.split(path23.sep).join("/");
+    const normalized = candidate.split(path24.sep).join("/");
     if (normalized.length === 0) return;
     candidates.add(normalized);
     const isParentTraversal = normalized === ".." || normalized.startsWith("../");
@@ -20664,10 +22428,10 @@ function markdownReferencePattern(asset, assetAbsolute, mdPath) {
       candidates.add(`./${normalized}`);
     }
   };
-  addCandidate(path23.relative(mdDir, assetAbsolute));
-  const originalPath = asset.originalPath.split(path23.sep).join("/");
-  const originalAsFileRelative = path23.resolve(mdDir, ...originalPath.split("/"));
-  if (path23.resolve(originalAsFileRelative) === path23.resolve(assetAbsolute)) {
+  addCandidate(path24.relative(mdDir, assetAbsolute));
+  const originalPath = asset.originalPath.split(path24.sep).join("/");
+  const originalAsFileRelative = path24.resolve(mdDir, ...originalPath.split("/"));
+  if (path24.resolve(originalAsFileRelative) === path24.resolve(assetAbsolute)) {
     addCandidate(originalPath);
   }
   addCandidate(`/${originalPath}`);
@@ -20763,7 +22527,7 @@ async function findMarkdownFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = path23.join(current, entry.name);
+      const full = path24.join(current, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === ".binary-lifecycle") continue;
         await walk(full);
@@ -20838,7 +22602,7 @@ async function runBinaryLifecyclePipeline(memoryDir, config, backend, log2, opts
 
 // src/projection/index.ts
 import fs from "fs";
-import path24 from "path";
+import path25 from "path";
 var VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
 async function generateContextTree(options) {
   const startTime = Date.now();
@@ -20853,8 +22617,8 @@ async function generateContextTree(options) {
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts = {};
-  const resolvedMemoryDir = path24.resolve(memoryDir);
-  const resolvedOutputDir = path24.resolve(outputDir);
+  const resolvedMemoryDir = path25.resolve(memoryDir);
+  const resolvedOutputDir = path25.resolve(outputDir);
   const requestedCategories = validateProjectionCategories(filterCategories);
   const realMemoryDir = assertSafeMemoryRoot(resolvedMemoryDir);
   assertNotSymlink(resolvedOutputDir, "context tree outputDir");
@@ -20892,7 +22656,7 @@ async function generateContextTree(options) {
     }
   }
   if (includeEntities) {
-    const entitiesDir = path24.join(memoryDir, "entities");
+    const entitiesDir = path25.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
       assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
@@ -20904,7 +22668,7 @@ async function generateContextTree(options) {
           continue;
         }
         const content = fs.readFileSync(filePath, "utf8");
-        const fileName = path24.basename(filePath, ".md");
+        const fileName = path25.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
         const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
         writeProjectedContent(realOutputDir, outputPath, node.content);
@@ -20916,7 +22680,7 @@ async function generateContextTree(options) {
   }
   const shouldIncludeQuestions = includeQuestions && (requestedCategories === void 0 || requestedCategories.includes("question"));
   if (shouldIncludeQuestions) {
-    const questionsDir = path24.join(memoryDir, "questions");
+    const questionsDir = path25.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
       assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
@@ -20957,8 +22721,8 @@ async function generateContextTree(options) {
   };
 }
 function isPathInside(root, candidate) {
-  const relative = path24.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path24.isAbsolute(relative);
+  const relative = path25.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path25.isAbsolute(relative);
 }
 function assertNotSymlink(targetPath, label) {
   try {
@@ -20995,12 +22759,12 @@ function assertSafeInputRoot(realMemoryDir, targetPath, label) {
 }
 function assertSafeOutputTarget(realOutputDir, outputPath) {
   let current = realOutputDir;
-  const relative = path24.relative(realOutputDir, outputPath);
-  if (relative.startsWith("..") || path24.isAbsolute(relative)) {
+  const relative = path25.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path25.isAbsolute(relative)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
-  for (const segment of relative.split(path24.sep).filter(Boolean)) {
-    current = path24.join(current, segment);
+  for (const segment of relative.split(path25.sep).filter(Boolean)) {
+    current = path25.join(current, segment);
     try {
       const stat5 = fs.lstatSync(current);
       if (stat5.isSymbolicLink()) {
@@ -21030,17 +22794,17 @@ function validateProjectionCategories(categories) {
   return validated;
 }
 function resolveContainedOutputPath(outputRoot, ...segments) {
-  const resolved = path24.resolve(outputRoot, ...segments);
-  const relative = path24.relative(outputRoot, resolved);
-  if (relative === "" || !relative.startsWith("..") && !path24.isAbsolute(relative)) {
+  const resolved = path25.resolve(outputRoot, ...segments);
+  const relative = path25.relative(outputRoot, resolved);
+  if (relative === "" || !relative.startsWith("..") && !path25.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(path24.dirname(outputPath), { recursive: true });
-  const realParent = fs.realpathSync(path24.dirname(outputPath));
+  fs.mkdirSync(path25.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path25.dirname(outputPath));
   if (!isPathInside(realOutputDir, realParent)) {
     throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
   }
@@ -21079,7 +22843,7 @@ function walkR(dir, realMemoryDir) {
   const results = [];
   function walk(directory) {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      const fullPath = path24.join(directory, entry.name);
+      const fullPath = path25.join(directory, entry.name);
       if (entry.isSymbolicLink()) {
         throw new Error(`context tree input path contains symlink: ${fullPath}`);
       }
@@ -21132,13 +22896,13 @@ function extractBody(content) {
 }
 function projectNode(filePath, category, fm, rawContent) {
   const body = extractBody(rawContent);
-  const fileName = path24.basename(filePath, ".md");
-  const dateDir = path24.basename(path24.dirname(filePath));
+  const fileName = path25.basename(filePath, ".md");
+  const dateDir = path25.basename(path25.dirname(filePath));
   let relPath;
   if (/^\d{4}-\d{2}-\d{2}$/.test(dateDir)) {
-    relPath = path24.join(category, dateDir, `${fileName}.md`);
+    relPath = path25.join(category, dateDir, `${fileName}.md`);
   } else {
-    relPath = path24.join(category, `${fileName}.md`);
+    relPath = path25.join(category, `${fileName}.md`);
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const md = `# ${fm.id}
@@ -21184,7 +22948,7 @@ function projectEntityNode(fileName, content) {
 ${content}
 `;
   return {
-    path: path24.join("entities", `${fileName}.md`),
+    path: path25.join("entities", `${fileName}.md`),
     category: "entity",
     title: fileName,
     content: md,
@@ -21237,7 +23001,7 @@ function generateIndex(categoryCounts, outputDir) {
 
 // src/onboarding/index.ts
 import fs2 from "fs";
-import path25 from "path";
+import path26 from "path";
 var LANGUAGE_RULES = [
   {
     language: "TypeScript",
@@ -21339,7 +23103,7 @@ function onboard(options) {
     maxDepth = 6,
     excludeDirs = []
   } = options;
-  const directory = path25.resolve(options.directory ?? process.cwd());
+  const directory = path26.resolve(options.directory ?? process.cwd());
   let rootStat;
   try {
     rootStat = fs2.statSync(directory);
@@ -21381,7 +23145,7 @@ function walkDir(root, exclude, maxDepth) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path25.join(dir, entry.name);
+      const fullPath = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath, depth + 1);
       } else if (entry.isFile()) {
@@ -21396,11 +23160,11 @@ function detectLanguages(files, root) {
   const results = [];
   const extCounts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const ext = path25.extname(f).toLowerCase();
+    const ext = path26.extname(f).toLowerCase();
     if (ext) extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
   }
   const rootFiles = new Set(
-    files.filter((f) => path25.dirname(f) === root).map((f) => path25.basename(f))
+    files.filter((f) => path26.dirname(f) === root).map((f) => path26.basename(f))
   );
   for (const rule of LANGUAGE_RULES) {
     const evidence = [];
@@ -21444,7 +23208,7 @@ function detectLanguages(files, root) {
 }
 function detectShape(files, root) {
   const rootFiles = new Set(
-    files.filter((f) => path25.dirname(f) === root).map((f) => path25.basename(f))
+    files.filter((f) => path26.dirname(f) === root).map((f) => path26.basename(f))
   );
   const rootDirs = /* @__PURE__ */ new Set();
   try {
@@ -21455,7 +23219,7 @@ function detectShape(files, root) {
   }
   const evidence = [];
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path25.join(root, "package.json"));
+    const pkg = readJsonSafe(path26.join(root, "package.json"));
     if (pkg?.workspaces) {
       evidence.push("package.json has workspaces");
       return { shape: "monorepo", evidence };
@@ -21469,13 +23233,13 @@ function detectShape(files, root) {
     evidence.push("workspace manifest found");
     return { shape: "workspace", evidence };
   }
-  const cargoToml = readTomlWorkspace(path25.join(root, "Cargo.toml"));
+  const cargoToml = readTomlWorkspace(path26.join(root, "Cargo.toml"));
   if (cargoToml) {
     evidence.push("Cargo.toml has workspace");
     return { shape: "workspace", evidence };
   }
   if (rootFiles.has("package.json")) {
-    const pkg = readJsonSafe(path25.join(root, "package.json"));
+    const pkg = readJsonSafe(path26.join(root, "package.json"));
     if (pkg?.exports || pkg?.main) {
       if (pkg?.bin) {
         evidence.push("package.json has bin");
@@ -21509,8 +23273,8 @@ function discoverDocs(files, root) {
     { pattern: /^\.editorconfig$/i, kind: "config" }
   ];
   for (const filePath of files) {
-    const basename = path25.basename(filePath).toLowerCase();
-    const relPath = path25.relative(root, filePath);
+    const basename = path26.basename(filePath).toLowerCase();
+    const relPath = path26.relative(root, filePath);
     let kind;
     for (const { pattern, kind: k } of docPatterns) {
       if (pattern.test(basename)) {
@@ -21522,7 +23286,7 @@ function discoverDocs(files, root) {
       kind = "docs";
     }
     if (!kind && (basename.endsWith(".md") || basename.endsWith(".mdx"))) {
-      if (path25.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
+      if (path26.dirname(relPath) === "." || isUnderDocsDir(relPath)) {
         kind = "docs";
       }
     }
@@ -21543,7 +23307,7 @@ function discoverDocs(files, root) {
   return docs;
 }
 function isUnderDocsDir(relPath) {
-  const parts = relPath.split(path25.sep);
+  const parts = relPath.split(path26.sep);
   return parts[0] === "docs" || parts[0] === "doc" || parts[0] === "documentation";
 }
 function buildPlan(languages, shape, docs, _root) {
@@ -21587,7 +23351,7 @@ function readTomlWorkspace(filePath) {
 
 // src/curation/index.ts
 import fs3 from "fs";
-import path26 from "path";
+import path27 from "path";
 import crypto4 from "crypto";
 async function curate(options) {
   const startTime = Date.now();
@@ -21678,12 +23442,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 = path26.join(dir, entry.name);
+      const fullPath = path27.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".git") {
           walk(fullPath);
         }
-      } else if (extensions.has(path26.extname(entry.name).toLowerCase())) {
+      } else if (extensions.has(path27.extname(entry.name).toLowerCase())) {
         results.push(fullPath);
       }
     }
@@ -21692,12 +23456,12 @@ function resolveTargets(targetPath) {
   return results;
 }
 function resolveProvenanceRoot(targetPath) {
-  const resolvedTarget = path26.resolve(targetPath);
+  const resolvedTarget = path27.resolve(targetPath);
   const stat5 = fs3.statSync(resolvedTarget);
-  return stat5.isFile() ? path26.dirname(resolvedTarget) : resolvedTarget;
+  return stat5.isFile() ? path27.dirname(resolvedTarget) : resolvedTarget;
 }
 function extractStatements(content, filePath, projectRoot, source, sourceFileHash, categoryOverride, confidence, entityRef, tags) {
-  const relativePath = path26.relative(projectRoot, path26.resolve(filePath)) || path26.basename(filePath);
+  const relativePath = path27.relative(projectRoot, path27.resolve(filePath)) || path27.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);
@@ -21791,7 +23555,7 @@ function loadExistingMemories(memoryDir) {
   if (!fs3.existsSync(memoryDir)) return result;
   const dirs = ALL_CATEGORY_DIRS;
   for (const dir of dirs) {
-    const fullDir = path26.join(memoryDir, dir);
+    const fullDir = path27.join(memoryDir, dir);
     if (!fs3.existsSync(fullDir)) continue;
     walkFiles(fullDir, (filePath) => {
       const content = readFileSafe(filePath);
@@ -21814,11 +23578,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 = path26.join(categoryDir, dateDir);
+  const dir = path27.join(categoryDir, dateDir);
   fs3.mkdirSync(dir, { recursive: true });
   const fileName = `${stmt.category}-${Date.now()}-${stmt.id.slice(0, 8)}.md`;
-  const filePath = path26.join(dir, fileName);
-  const historicalIds = historicalIdCache2.get(path26.join(memoryDir, "state"));
+  const filePath = path27.join(dir, fileName);
+  const historicalIds = historicalIdCache2.get(path27.join(memoryDir, "state"));
   const rawBody = `${[
     "---",
     `id: ${stmt.id}`,
@@ -21841,7 +23605,7 @@ ${stmt.content}
   fs3.writeFileSync(filePath, body);
   try {
     repairContentAfterJournalMoveSync({
-      stateDir: path26.join(memoryDir, "state"),
+      stateDir: path27.join(memoryDir, "state"),
       cache: historicalIdCache2,
       idsAtWrite: historicalIds,
       rawContent: rawBody,
@@ -21902,7 +23666,7 @@ function extractBody2(content) {
 }
 function walkFiles(dir, callback) {
   for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path26.join(dir, entry.name);
+    const fullPath = path27.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkFiles(fullPath, callback);
     } else if (entry.name.endsWith(".md")) {
@@ -21913,7 +23677,7 @@ function walkFiles(dir, callback) {
 
 // src/dedup/index.ts
 import fs4 from "fs";
-import path27 from "path";
+import path28 from "path";
 import crypto5 from "crypto";
 var DEFAULT_DEDUP_THRESHOLD = 0.85;
 var DEFAULT_MAX_LOAD = 1e4;
@@ -22055,7 +23819,7 @@ function loadMemories(memoryDir, categories, maxLoad = 1e4) {
   const memoryRootReal = fs4.realpathSync(memoryDir);
   for (const category of allCategories) {
     if (result.length >= maxLoad) break;
-    const dir = path27.join(memoryDir, category);
+    const dir = path28.join(memoryDir, category);
     if (!fs4.existsSync(dir)) continue;
     const categoryStat = fs4.lstatSync(dir);
     if (categoryStat.isSymbolicLink()) {
@@ -22116,15 +23880,15 @@ function extractBody3(content) {
   return match ? match[1].trim() : content.trim();
 }
 function assertPathInsideRoot2(rootReal, targetReal, sourcePath) {
-  const rel = path27.relative(rootReal, targetReal);
-  if (rel === "" || !rel.startsWith("..") && !path27.isAbsolute(rel)) {
+  const rel = path28.relative(rootReal, targetReal);
+  if (rel === "" || !rel.startsWith("..") && !path28.isAbsolute(rel)) {
     return;
   }
   throw new Error(`Refusing to scan memory path outside root: ${sourcePath}`);
 }
 function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
   for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path27.join(dir, entry.name);
+    const fullPath = path28.join(dir, entry.name);
     const entryStat = fs4.lstatSync(fullPath);
     if (entryStat.isSymbolicLink()) {
       throw new Error(`Refusing to scan symlinked memory path: ${fullPath}`);
@@ -22142,10 +23906,10 @@ function walkMdFiles(dir, memoryRootReal, categoryRootReal, callback) {
 
 // src/review/index.ts
 import fs5 from "fs";
-import path28 from "path";
+import path29 from "path";
 var historicalIdCache3 = new HistoricalEntityCanonicalIdCache();
 function writeReviewFileCanonicalized(memoryDir, filePath, content) {
-  const stateDir = path28.join(memoryDir, "state");
+  const stateDir = path29.join(memoryDir, "state");
   const idsAtWrite = historicalIdCache3.get(stateDir);
   let originalBytes = null;
   try {
@@ -22187,8 +23951,8 @@ function realMemoryRoot(memoryDir) {
   }
 }
 function isPathInside2(rootReal, candidateReal) {
-  const relative = path28.relative(rootReal, candidateReal);
-  return relative === "" || !!relative && !relative.startsWith("..") && !path28.isAbsolute(relative);
+  const relative = path29.relative(rootReal, candidateReal);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path29.isAbsolute(relative);
 }
 function isSafeDirectory(rootReal, dir) {
   try {
@@ -22231,7 +23995,7 @@ function listReviewItems(options) {
     if (filterReason && item.reviewReason !== filterReason) return;
     items.push(item);
   };
-  const suggestionsDir = path28.join(memoryDir, "suggestions");
+  const suggestionsDir = path29.join(memoryDir, "suggestions");
   if (!isLimitReached() && fs5.existsSync(suggestionsDir) && isSafeDirectory(rootReal, suggestionsDir)) {
     walkMd(rootReal, suggestionsDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -22252,7 +24016,7 @@ function listReviewItems(options) {
       return isLimitReached();
     });
   }
-  const reviewDir = path28.join(memoryDir, "review");
+  const reviewDir = path29.join(memoryDir, "review");
   if (!isLimitReached() && fs5.existsSync(reviewDir) && isSafeDirectory(rootReal, reviewDir)) {
     walkMd(rootReal, reviewDir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -22277,7 +24041,7 @@ function listReviewItems(options) {
   const categories = ALL_CATEGORY_DIRS;
   for (const category of categories) {
     if (isLimitReached()) break;
-    const dir = path28.join(memoryDir, category);
+    const dir = path29.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     walkMd(rootReal, dir, (filePath, content) => {
       if (isLimitReached()) return true;
@@ -22359,9 +24123,9 @@ function approveItem(memoryDir, itemId, options) {
   const targetDir = getCategoryDir(memoryDir, category);
   const dateDir = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   ensureSafeDirectory(rootReal, targetDir);
-  const outputPath = path28.join(targetDir, dateDir, path28.basename(found.filePath));
-  ensureSafeDirectory(rootReal, path28.dirname(outputPath));
-  const reviewStateDir = path28.join(memoryDir, "state");
+  const outputPath = path29.join(targetDir, dateDir, path29.basename(found.filePath));
+  ensureSafeDirectory(rootReal, path29.dirname(outputPath));
+  const reviewStateDir = path29.join(memoryDir, "state");
   const idsAtWrite = historicalIdCache3.get(reviewStateDir);
   const promotedWritten = canonicalizeEntityRefFrontmatter(updatedContent, idsAtWrite);
   const promotedPath = writeFileWithoutClobber(outputPath, promotedWritten, itemId);
@@ -22438,13 +24202,13 @@ function findReviewFileById(memoryDir, id, options = {}) {
   const rootReal = realMemoryRoot(memoryDir);
   if (!rootReal) return null;
   for (const loc of ["suggestions", "review"]) {
-    const dir = path28.join(memoryDir, loc);
+    const dir = path29.join(memoryDir, loc);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id);
     if (found) return { filePath: found, location: "queue" };
   }
   for (const category of ALL_CATEGORY_DIRS) {
-    const dir = path28.join(memoryDir, category);
+    const dir = path29.join(memoryDir, category);
     if (!fs5.existsSync(dir) || !isSafeDirectory(rootReal, dir)) continue;
     const found = findFileById(rootReal, dir, id, (fm) => isLowConfidenceReviewCandidate(fm, options));
     if (found) return { filePath: found, location: "category" };
@@ -22520,10 +24284,10 @@ function readFileSafe3(filePath) {
   }
 }
 function writeFileWithoutClobber(basePath, content, discriminator) {
-  const parsed = path28.parse(basePath);
+  const parsed = path29.parse(basePath);
   const safeDiscriminator = sanitizeFilePart(discriminator);
   for (let attempt = 0; attempt < 1e3; attempt++) {
-    const candidate = attempt === 0 ? basePath : path28.join(
+    const candidate = attempt === 0 ? basePath : path29.join(
       parsed.dir,
       `${parsed.name}-${safeDiscriminator}${attempt === 1 ? "" : `-${attempt}`}${parsed.ext || ".md"}`
     );
@@ -22579,7 +24343,7 @@ function extractBody4(content) {
 function walkMd(rootReal, dir, callback) {
   if (!isSafeDirectory(rootReal, dir)) return false;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path28.join(dir, entry.name);
+    const fullPath = path29.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       if (walkMd(rootReal, fullPath, callback)) return true;
@@ -22594,7 +24358,7 @@ function walkMdPaths(rootReal, dir) {
   const results = [];
   if (!isSafeDirectory(rootReal, dir)) return results;
   for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path28.join(dir, entry.name);
+    const fullPath = path29.join(dir, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) {
       results.push(...walkMdPaths(rootReal, fullPath));
@@ -22607,7 +24371,7 @@ function walkMdPaths(rootReal, dir) {
 
 // src/sync/index.ts
 import fs6 from "fs";
-import path29 from "path";
+import path30 from "path";
 import crypto6 from "crypto";
 var DEFAULT_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".mdx", ".rst"]);
 var DEFAULT_EXCLUDE2 = /* @__PURE__ */ new Set([
@@ -22629,7 +24393,7 @@ function syncChanges(options) {
   } = options;
   const extSet = new Set(extensions);
   const excludeSet = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDE2, ...excludeDirs]);
-  const stateFilePath = options.stateFile ?? path29.join(memoryDir, ".sync-state.json");
+  const stateFilePath = options.stateFile ?? path30.join(memoryDir, ".sync-state.json");
   const prevState = loadState(stateFilePath);
   const currentFiles = scanFiles(sourceDir, extSet, excludeSet);
   const changes = computeDiff(currentFiles, prevState.fileHashes, sourceDir);
@@ -22645,7 +24409,7 @@ function syncChanges(options) {
     for (const [relPath, hash] of Object.entries(currentFiles)) {
       newState.fileHashes[relPath] = hash;
     }
-    fs6.mkdirSync(path29.dirname(stateFilePath), { recursive: true });
+    fs6.mkdirSync(path30.dirname(stateFilePath), { recursive: true });
     fs6.writeFileSync(stateFilePath, JSON.stringify(newState, null, 2));
   }
   return {
@@ -22711,13 +24475,13 @@ function scanFiles(root, extensions, exclude) {
     }
     for (const entry of entries) {
       if (exclude.has(entry.name)) continue;
-      const fullPath = path29.join(dir, entry.name);
+      const fullPath = path30.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile()) {
-        const ext = path29.extname(entry.name).toLowerCase();
+        const ext = path30.extname(entry.name).toLowerCase();
         if (!extensions.has(ext)) continue;
-        const relPath = path29.relative(root, fullPath);
+        const relPath = path30.relative(root, fullPath);
         try {
           const content = fs6.readFileSync(fullPath, "utf8");
           result[relPath] = hashContent3(content);
@@ -22732,7 +24496,7 @@ function scanFiles(root, extensions, exclude) {
 function computeDiff(current, previous, sourceDir) {
   const changes = [];
   for (const [relPath, hash] of Object.entries(current)) {
-    const fullPath = path29.join(sourceDir, relPath);
+    const fullPath = path30.join(sourceDir, relPath);
     if (!(relPath in previous)) {
       let size = 0;
       try {
@@ -22765,7 +24529,7 @@ function computeDiff(current, previous, sourceDir) {
   for (const relPath of Object.keys(previous)) {
     if (!(relPath in current)) {
       changes.push({
-        filePath: path29.join(sourceDir, relPath),
+        filePath: path30.join(sourceDir, relPath),
         relativePath: relPath,
         type: "deleted",
         currentHash: "",
@@ -22795,21 +24559,21 @@ function hashContent3(content) {
 import { spawnSync } from "child_process";
 import crypto7 from "crypto";
 import fs7 from "fs";
-import path30 from "path";
+import path31 from "path";
 var historicalIdCache4 = new HistoricalEntityCanonicalIdCache();
 var MANIFEST_VERSION = 1;
 var MANIFEST_LOCK_STALE_MS = 3e4;
 var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
 var MANIFEST_LOCK_SLEEP_MS = 20;
 function normalizeSpaceMemoryDir(memoryDir) {
-  return path30.resolve(memoryDir);
+  return path31.resolve(memoryDir);
 }
 function getSpacesDir(baseDir) {
   const homeDir = baseDir ?? resolveHomeDir();
-  return path30.join(homeDir, ".config", "engram", "spaces");
+  return path31.join(homeDir, ".config", "engram", "spaces");
 }
 function getManifestPath(baseDir) {
-  return path30.join(getSpacesDir(baseDir), "manifest.json");
+  return path31.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
   if (fs7.existsSync(getManifestPath(baseDir))) {
@@ -22856,9 +24620,9 @@ function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
 }
 function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  const manifestDir2 = path30.dirname(manifestPath2);
+  const manifestDir2 = path31.dirname(manifestPath2);
   fs7.mkdirSync(manifestDir2, { recursive: true });
-  const tempPath = path30.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  const tempPath = path31.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
   try {
     fs7.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { flag: "wx" });
@@ -22873,7 +24637,7 @@ function saveManifestUnlocked(manifest, baseDir) {
 }
 function withManifestLock(baseDir, operation) {
   const lockDir = `${getManifestPath(baseDir)}.lock`;
-  fs7.mkdirSync(path30.dirname(lockDir), { recursive: true });
+  fs7.mkdirSync(path31.dirname(lockDir), { recursive: true });
   const lockOwner = acquireManifestLock(lockDir);
   try {
     return operation();
@@ -22899,7 +24663,7 @@ function acquireManifestLock(lockDir) {
     try {
       fs7.mkdirSync(lockDir, { recursive: false });
       try {
-        fs7.writeFileSync(path30.join(lockDir, "owner"), `${owner}
+        fs7.writeFileSync(path31.join(lockDir, "owner"), `${owner}
 `, { flag: "wx" });
       } catch (error) {
         fs7.rmSync(lockDir, { recursive: true, force: true });
@@ -22929,7 +24693,7 @@ function acquireManifestLock(lockDir) {
 }
 function releaseManifestLock(lockDir, owner) {
   try {
-    const ownerPath = path30.join(lockDir, "owner");
+    const ownerPath = path31.join(lockDir, "owner");
     if (fs7.readFileSync(ownerPath, "utf8").trim() === owner) {
       fs7.rmSync(lockDir, { recursive: true, force: true });
     }
@@ -22945,7 +24709,7 @@ function removeStaleManifestLock(lockDir) {
   try {
     fs7.mkdirSync(reclaimDir, { recursive: false });
     try {
-      fs7.writeFileSync(path30.join(reclaimDir, "owner"), `${reclaimOwner}
+      fs7.writeFileSync(path31.join(reclaimDir, "owner"), `${reclaimOwner}
 `, { flag: "wx" });
     } catch (error) {
       fs7.rmSync(reclaimDir, { recursive: true, force: true });
@@ -23020,7 +24784,7 @@ function readManifestLockSnapshot(lockDir) {
     throw error;
   }
   try {
-    const owner = fs7.readFileSync(path30.join(lockDir, "owner"), "utf8").trim();
+    const owner = fs7.readFileSync(path31.join(lockDir, "owner"), "utf8").trim();
     return { mtimeMs: stat5.mtimeMs, owner };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -23092,8 +24856,8 @@ function sleepSync(ms) {
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
-  const standalonePath = path30.join(homeDir, ".engram", "memory");
-  const openclawPath = path30.join(homeDir, ".openclaw", "workspace", "memory", "local");
+  const standalonePath = path31.join(homeDir, ".engram", "memory");
+  const openclawPath = path31.join(homeDir, ".openclaw", "workspace", "memory", "local");
   const memoryDir = memoryDirOverride ?? readEnvVar("REMNIC_MEMORY_DIR") ?? readEnvVar("ENGRAM_MEMORY_DIR") ?? (fs7.existsSync(standalonePath) ? standalonePath : fs7.existsSync(openclawPath) ? openclawPath : standalonePath);
   const normalizedMemoryDir = normalizeSpaceMemoryDir(memoryDir);
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -23122,7 +24886,7 @@ function createSpace(options) {
   const id = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const memoryDir = normalizeSpaceMemoryDir(
-    options.memoryDir ?? path30.join(getSpacesDir(options.baseDir), id, "memory")
+    options.memoryDir ?? path31.join(getSpacesDir(options.baseDir), id, "memory")
   );
   const space = updateManifest(options.baseDir, (manifest) => {
     if (manifest.spaces.some((s) => s.id === id)) {
@@ -23343,14 +25107,14 @@ async function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function getAuditLog(baseDir) {
-  const auditPath = path30.join(getSpacesDir(baseDir), "audit.jsonl");
+  const auditPath = path31.join(getSpacesDir(baseDir), "audit.jsonl");
   if (!fs7.existsSync(auditPath)) return [];
   const lines = fs7.readFileSync(auditPath, "utf8").trim().split("\n");
   return lines.filter((l) => l.trim()).map((l) => JSON.parse(l));
 }
 function appendAudit(entry, baseDir) {
-  const auditPath = path30.join(getSpacesDir(baseDir), "audit.jsonl");
-  fs7.mkdirSync(path30.dirname(auditPath), { recursive: true });
+  const auditPath = path31.join(getSpacesDir(baseDir), "audit.jsonl");
+  fs7.mkdirSync(path31.dirname(auditPath), { recursive: true });
   const full = {
     id: crypto7.randomUUID(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -23371,11 +25135,11 @@ async function copyMemories(sourceDir, targetDir, options) {
     sourceFiles.filter((p) => {
       const rp = safeRealpath(p);
       if (!rp || !isPathInsideRoot(rp, sourceRoot)) return false;
-      const rel = path30.relative(sourceRoot, rp);
-      const mapped = path30.resolve(targetRoot, rel);
+      const rel = path31.relative(sourceRoot, rp);
+      const mapped = path31.resolve(targetRoot, rel);
       if (!isPathInsideRoot(mapped, targetRoot)) return false;
       return classifyEntityRefWritePath(targetRoot, mapped) === "entity";
-    }).map((p) => path30.basename(p, ".md"))
+    }).map((p) => path31.basename(p, ".md"))
   );
   const firstEntityId = sourceEntityIds.values().next().value;
   if (firstEntityId === void 0) {
@@ -23383,7 +25147,7 @@ async function copyMemories(sourceDir, targetDir, options) {
   }
   return withRawEntityPageMutation(
     targetRoot,
-    path30.join(targetRoot, "entities", `${firstEntityId}.md`),
+    path31.join(targetRoot, "entities", `${firstEntityId}.md`),
     async () => copyPreparedMemories(
       sourceFiles,
       sourceRoot,
@@ -23410,14 +25174,14 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
       continue;
     }
     const content = fs7.readFileSync(sourcePath, "utf8");
-    const relativePath = path30.relative(sourceRoot, sourceRealPath);
-    const targetPath = path30.resolve(targetRoot, relativePath);
+    const relativePath = path31.relative(sourceRoot, sourceRealPath);
+    const targetPath = path31.resolve(targetRoot, relativePath);
     if (!isPathInsideRoot(targetPath, targetRoot)) {
       skipped++;
       continue;
     }
     const targetKind = classifyEntityRefWritePath(targetRoot, targetPath);
-    const idsAtCompare = historicalIdCache4.get(path30.join(targetRoot, "state"));
+    const idsAtCompare = historicalIdCache4.get(path31.join(targetRoot, "state"));
     const sourceRef = targetKind === "memory" ? readEntityRefFromFrontmatter(content) : null;
     const refHasSourceClaimant = sourceRef !== null && sourceEntityIds.has(sourceRef);
     const canonicalContent = targetKind === "memory" && !refHasSourceClaimant ? canonicalizeEntityRefFrontmatter(content, idsAtCompare) : content;
@@ -23444,7 +25208,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     if (fs7.existsSync(targetPath) && !options?.force) {
       const targetContent = fs7.readFileSync(targetPath, "utf8");
       const targetHash = hashContent4(targetContent);
-      if (hashContent4(canonicalContent) === targetHash && historicalIdCache4.get(path30.join(targetRoot, "state")) === idsAtCompare) {
+      if (hashContent4(canonicalContent) === targetHash && historicalIdCache4.get(path31.join(targetRoot, "state")) === idsAtCompare) {
         skipped++;
         continue;
       }
@@ -23460,13 +25224,13 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
         continue;
       }
     }
-    fs7.mkdirSync(path30.dirname(targetPath), { recursive: true });
-    const targetParentRealPath = safeRealpath(path30.dirname(targetPath));
+    fs7.mkdirSync(path31.dirname(targetPath), { recursive: true });
+    const targetParentRealPath = safeRealpath(path31.dirname(targetPath));
     if (!targetParentRealPath || !isPathInsideRoot(targetParentRealPath, targetRoot)) {
       skipped++;
       continue;
     }
-    const stateDir = path30.join(targetRoot, "state");
+    const stateDir = path31.join(targetRoot, "state");
     if (targetKind === "memory" && !refHasSourceClaimant) {
       const idsAtWrite = historicalIdCache4.get(stateDir);
       const written = canonicalizeEntityRefFrontmatter(content, idsAtWrite);
@@ -23510,7 +25274,7 @@ function copyPreparedMemories(sourceFiles, sourceRoot, targetRoot, sourceEntityI
     bumpMemoryCorpusVersionForDir(targetRoot);
   }
   if (reconcileNeeded) {
-    requestEntityCanonicalIdReconcileSync(path30.join(targetRoot, "state"));
+    requestEntityCanonicalIdReconcileSync(path31.join(targetRoot, "state"));
   }
   return { merged, conflicts, skipped };
 }
@@ -23521,7 +25285,7 @@ function walkMd2(dir) {
   const results = [];
   function walk(d) {
     for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
-      const fullPath = path30.join(d, entry.name);
+      const fullPath = path31.join(d, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -23550,8 +25314,8 @@ function safeRealpath(filePath) {
   }
 }
 function isPathInsideRoot(candidatePath, rootPath) {
-  const relative = path30.relative(rootPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path30.isAbsolute(relative);
+  const relative = path31.relative(rootPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path31.isAbsolute(relative);
 }
 function parseSimpleFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -23672,7 +25436,7 @@ var REMNIC_RECALL_DECISION_RULES = `## When to Use Recall vs Direct Read
 // src/memory-extension/codex-publisher.ts
 import fs8 from "fs";
 import os from "os";
-import path31 from "path";
+import path32 from "path";
 var REMNIC_EXTENSION_DIR_NAME = "remnic";
 function resolveEnvHome(env) {
   if (env === void 0) return resolveHomeDir();
@@ -23681,12 +25445,12 @@ function resolveEnvHome(env) {
 function expandTildeWithHome(input, homeDir) {
   if (input === "~") return homeDir;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return path31.join(homeDir, input.slice(2));
+    return path32.join(homeDir, input.slice(2));
   }
   return input;
 }
 function normalizeHostRoot(input, homeDir) {
-  return path31.resolve(expandTildeWithHome(input.trim(), homeDir));
+  return path32.resolve(expandTildeWithHome(input.trim(), homeDir));
 }
 var CodexMemoryExtensionPublisher = class {
   hostId = "codex";
@@ -23700,12 +25464,12 @@ var CodexMemoryExtensionPublisher = class {
   async resolveExtensionRoot(env) {
     const homeDir = resolveEnvHome(env);
     const codexHomeInput = env === void 0 ? readEnvVar("CODEX_HOME")?.trim() : env.CODEX_HOME?.trim();
-    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path31.resolve(homeDir, ".codex");
-    return path31.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
+    const codexHome = codexHomeInput ? normalizeHostRoot(codexHomeInput, homeDir) : path32.resolve(homeDir, ".codex");
+    return path32.join(codexHome, "memories_extensions", REMNIC_EXTENSION_DIR_NAME);
   }
   async isHostAvailable() {
     try {
-      const home = readEnvVar("CODEX_HOME")?.trim() || path31.join(resolveHomeDir(), ".codex");
+      const home = readEnvVar("CODEX_HOME")?.trim() || path32.join(resolveHomeDir(), ".codex");
       return fs8.existsSync(home);
     } catch {
       return false;
@@ -23756,7 +25520,7 @@ When running inside the Codex phase-2 consolidation sandbox:
   }
   async publish(ctx) {
     const extensionRoot = await this.resolveExtensionRoot();
-    const instructionsPath = path31.join(extensionRoot, "instructions.md");
+    const instructionsPath = path32.join(extensionRoot, "instructions.md");
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing Codex memory extension to ${extensionRoot}`);
@@ -24130,9 +25894,9 @@ async function generateActivityMemories(date, digestBody, config, deps) {
 }
 
 // src/session-summaries/index.ts
-import { createHash as createHash7 } from "crypto";
-import { lstat as lstat3, mkdir as mkdir7, readFile as readFile6, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import path32 from "path";
+import { createHash as createHash9 } from "crypto";
+import { lstat as lstat3, mkdir as mkdir7, readFile as readFile7, readdir as readdir4, rename, rm, stat as stat4, writeFile as writeFile7 } from "fs/promises";
+import path33 from "path";
 
 // src/session-summaries/adapters.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "tool", "system", "other"]);
@@ -24632,12 +26396,12 @@ var DEFAULT_MAX_FILES = 5e3;
 var DEFAULT_MAX_SESSIONS = 500;
 var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".json", ".jsonl"]);
 function shortHash(value, length = 16) {
-  return createHash7("sha256").update(value).digest("hex").slice(0, length);
+  return createHash9("sha256").update(value).digest("hex").slice(0, length);
 }
 async function listTranscriptFiles(root, maxFiles) {
   const out = [];
   let truncated = false;
-  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path32.sep}` : entryName;
+  const entrySortKey = (entryName, isDirectory) => isDirectory ? `${entryName}${path33.sep}` : entryName;
   async function visit(dir) {
     if (truncated) return;
     const entries = (await readdir4(dir, { withFileTypes: true })).sort(
@@ -24647,13 +26411,13 @@ async function listTranscriptFiles(root, maxFiles) {
       if (truncated) return;
       if (entry.name.startsWith(".")) continue;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = path32.join(dir, entry.name);
+      const fullPath = path33.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      const ext = path32.extname(entry.name).toLowerCase();
+      const ext = path33.extname(entry.name).toLowerCase();
       if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
       out.push(fullPath);
       if (out.length > maxFiles) {
@@ -24680,7 +26444,7 @@ function normalizeInputDir(inputDir) {
   if (typeof inputDir !== "string" || inputDir.trim().length === 0) {
     throw new Error("inputDir must be a non-empty string");
   }
-  return path32.resolve(expandTildePath(inputDir.trim()));
+  return path33.resolve(expandTildePath(inputDir.trim()));
 }
 function initRoleCounts() {
   return {
@@ -24826,7 +26590,7 @@ async function collectLocalSessionSummaries(options) {
     });
   }
   for (const filePath of files) {
-    const content = await readFile6(filePath, "utf-8");
+    const content = await readFile7(filePath, "utf-8");
     const fileHash = shortHash(content, 24);
     if (seenFileHashes.has(fileHash)) {
       warnings.push({
@@ -24837,11 +26601,11 @@ async function collectLocalSessionSummaries(options) {
       continue;
     }
     seenFileHashes.add(fileHash);
-    const fileExtension = path32.extname(filePath).toLowerCase();
+    const fileExtension = path33.extname(filePath).toLowerCase();
     const parsed = await adapter.parseFile(
       {
         content,
-        fileName: path32.basename(filePath),
+        fileName: path33.basename(filePath),
         fileExtension,
         fileRef: fileHash
       },
@@ -24897,7 +26661,7 @@ async function collectLocalSessionSummaries(options) {
 }
 async function readRedactionConfig(pathLike) {
   if (!pathLike) return void 0;
-  const raw = await readFile6(path32.resolve(expandTildePath(pathLike)), "utf-8");
+  const raw = await readFile7(path33.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");
@@ -24910,15 +26674,15 @@ function toJsonl(drafts) {
 }
 function defaultDraftOutputPath(memoryDir, generatedAt) {
   const stamp = generatedAt.replace(/[:.]/g, "-");
-  return path32.join(
-    path32.resolve(expandTildePath(memoryDir)),
+  return path33.join(
+    path33.resolve(expandTildePath(memoryDir)),
     "state",
     "session-summary-drafts",
     `session-summaries-${stamp}.jsonl`
   );
 }
 async function writeDrafts(filePath, drafts) {
-  await mkdir7(path32.dirname(filePath), { recursive: true });
+  await mkdir7(path33.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     await writeFile7(tempPath, toJsonl(drafts), "utf-8");
@@ -24936,7 +26700,7 @@ async function runLocalSessionSummaryCliCommand(options) {
   });
   const wroteFiles = [];
   if (options.output) {
-    const outputPath = path32.resolve(expandTildePath(options.output));
+    const outputPath = path33.resolve(expandTildePath(options.output));
     await writeDrafts(outputPath, report.drafts);
     wroteFiles.push(outputPath);
   }
@@ -24970,20 +26734,20 @@ async function runLocalSessionSummaryCliCommand(options) {
 }
 
 // src/transfer/capsule-fork.ts
-import { lstat as lstat4, mkdir as mkdir8, readFile as readFile7, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
-import path33 from "path";
+import { lstat as lstat4, mkdir as mkdir8, readFile as readFile8, realpath as realpath3, writeFile as writeFile8 } from "fs/promises";
+import path34 from "path";
 async function forkCapsule(opts) {
   validateForkId(opts.forkId);
-  const rootAbs = path33.resolve(opts.targetRoot);
+  const rootAbs = path34.resolve(opts.targetRoot);
   await assertIsDirectoryNotSymlink(rootAbs, "forkCapsule", "targetRoot");
-  const forkDirAbs = path33.join(rootAbs, "forks", opts.forkId);
+  const forkDirAbs = path34.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 = path33.resolve(opts.sourceArchive);
+  const archiveAbs = path34.resolve(opts.sourceArchive);
   const importResult = await importCapsule({
     archivePath: archiveAbs,
     root: rootAbs,
@@ -25005,10 +26769,10 @@ async function forkCapsule(opts) {
     importedRecords: importResult.imported.length,
     skippedRecords: importResult.skipped.length
   };
-  const lineagePath = path33.join(forkDirAbs, "lineage.json");
+  const lineagePath = path34.join(forkDirAbs, "lineage.json");
   const rootReal = await realpath3(rootAbs);
   await assertRealpathInsideRoot(rootReal, lineagePath, `forks/${opts.forkId}/lineage.json`, "forkCapsule");
-  await mkdir8(path33.dirname(lineagePath), { recursive: true });
+  await mkdir8(path34.dirname(lineagePath), { recursive: true });
   await writeFile8(lineagePath, JSON.stringify(lineage, null, 2) + "\n", "utf-8");
   return {
     archivePath: archiveAbs,
@@ -25022,17 +26786,17 @@ async function readForkLineage(targetRoot, forkId) {
   if (typeof forkId !== "string" || forkId.length === 0 || forkId.length > 64 || !CAPSULE_ID_PATTERN.test(forkId)) {
     return null;
   }
-  const rootAbs = path33.resolve(targetRoot);
+  const rootAbs = path34.resolve(targetRoot);
   const rootReal = await realpath3(rootAbs).catch(() => rootAbs);
-  const lineagePath = path33.join(rootReal, "forks", forkId, "lineage.json");
-  const rel = path33.relative(rootReal, lineagePath);
-  if (rel.startsWith("..") || path33.isAbsolute(rel)) {
+  const lineagePath = path34.join(rootReal, "forks", forkId, "lineage.json");
+  const rel = path34.relative(rootReal, lineagePath);
+  if (rel.startsWith("..") || path34.isAbsolute(rel)) {
     return null;
   }
   if (!await isLineagePathContained(rootReal, lineagePath)) {
     return null;
   }
-  const raw = await readFile7(lineagePath, "utf-8").catch(() => null);
+  const raw = await readFile8(lineagePath, "utf-8").catch(() => null);
   if (raw === null) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -25067,19 +26831,19 @@ async function pathEntryExists(absPath) {
 async function isLineagePathContained(rootReal, lineagePath) {
   let existing = lineagePath;
   const suffix = [];
-  while (existing !== path33.dirname(existing)) {
+  while (existing !== path34.dirname(existing)) {
     const st = await lstat4(existing).catch(() => null);
     if (st !== null) break;
-    suffix.unshift(path33.basename(existing));
-    existing = path33.dirname(existing);
+    suffix.unshift(path34.basename(existing));
+    existing = path34.dirname(existing);
   }
   const existingReal = await realpath3(existing).catch(() => existing);
-  const targetReal = suffix.length > 0 ? path33.join(existingReal, ...suffix) : existingReal;
-  const rel = path33.relative(rootReal, targetReal);
+  const targetReal = suffix.length > 0 ? path34.join(existingReal, ...suffix) : existingReal;
+  const rel = path34.relative(rootReal, targetReal);
   if (rel === "") return true;
   if (rel === "..") return false;
-  if (rel.startsWith(`..${path33.sep}`)) return false;
-  if (path33.isAbsolute(rel)) return false;
+  if (rel.startsWith(`..${path34.sep}`)) return false;
+  if (path34.isAbsolute(rel)) return false;
   return true;
 }
 
@@ -25198,4 +26962,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-ZHY5TMJG.js.map
+//# sourceMappingURL=chunk-RMHMUUBW.js.map