@remnic/plugin-openclaw 1.0.35 → 1.0.37

package/dist/chunk-IO5WWY6A.js

@@ -0,0 +1,156 @@
+// ../remnic-core/src/graph-edge-reinforcement.ts
+var CONFIDENCE_CEILING = 1;
+var DEFAULT_DECAY_WINDOW_MS = 90 * 24 * 60 * 60 * 1e3;
+var DEFAULT_DECAY_FLOOR = 0.1;
+var DEFAULT_DECAY_PER_WINDOW = 0.1;
+function readEdgeConfidence(edge) {
+  const raw = edge.confidence;
+  if (raw === void 0 || raw === null || !Number.isFinite(raw)) {
+    return CONFIDENCE_CEILING;
+  }
+  if (raw < 0) return 0;
+  if (raw > CONFIDENCE_CEILING) return CONFIDENCE_CEILING;
+  return raw;
+}
+function readLastReinforcedAt(edge) {
+  return edge.lastReinforcedAt ?? edge.ts;
+}
+function decayEdgeConfidence(edge, now, opts = {}) {
+  const windowMs = opts.windowMs ?? DEFAULT_DECAY_WINDOW_MS;
+  const perWindow = opts.perWindow ?? DEFAULT_DECAY_PER_WINDOW;
+  const floor = opts.floor ?? DEFAULT_DECAY_FLOOR;
+  if (!(windowMs > 0) || !Number.isFinite(perWindow) || perWindow < 0 || !Number.isFinite(floor)) {
+    return { ...edge, confidence: readEdgeConfidence(edge) };
+  }
+  const safeFloor = Math.min(CONFIDENCE_CEILING, Math.max(0, floor));
+  const nowMs = Date.parse(now);
+  const refMs = Date.parse(readLastReinforcedAt(edge));
+  if (!Number.isFinite(nowMs) || !Number.isFinite(refMs)) {
+    return { ...edge, confidence: readEdgeConfidence(edge) };
+  }
+  const age = nowMs - refMs;
+  const current = readEdgeConfidence(edge);
+  if (age <= windowMs) {
+    return { ...edge, confidence: current };
+  }
+  const windowsPast = Math.ceil((age - windowMs) / windowMs);
+  const decayed = current - perWindow * windowsPast;
+  const lowerBound = Math.min(safeFloor, current);
+  const next = Math.max(lowerBound, Math.min(current, decayed));
+  const newRefMs = refMs + windowsPast * windowMs;
+  const newRef = new Date(newRefMs).toISOString();
+  return { ...edge, confidence: next, lastReinforcedAt: newRef };
+}
+
+// ../remnic-core/src/graph.ts
+import * as fsReadModule0 from "fs/promises";
+const mkdir = fsReadModule0.mkdir;
+const appendFile = fsReadModule0.appendFile;
+const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
+import * as path from "path";
+
+// ../remnic-core/src/graph-events.ts
+import { EventEmitter } from "events";
+var buses = /* @__PURE__ */ new Map();
+function getGraphEventBus(memoryDir) {
+  let bus = buses.get(memoryDir);
+  if (!bus) {
+    bus = new EventEmitter();
+    bus.setMaxListeners(200);
+    buses.set(memoryDir, bus);
+  }
+  return bus;
+}
+function emitGraphEvent(memoryDir, type, payload) {
+  const event = {
+    type,
+    memoryDir,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    payload
+  };
+  const bus = getGraphEventBus(memoryDir);
+  try {
+    bus.emit("graph-event", event);
+  } catch {
+  }
+}
+
+// ../remnic-core/src/graph.ts
+function graphsDir(memoryDir) {
+  return path.join(memoryDir, "state", "graphs");
+}
+function graphFilePath(memoryDir, type) {
+  return path.join(graphsDir(memoryDir), `${type}.jsonl`);
+}
+async function ensureGraphsDir(memoryDir) {
+  await mkdir(graphsDir(memoryDir), { recursive: true });
+}
+var graphWriteLocks = /* @__PURE__ */ new Map();
+function withGraphWriteLock(filePath, fn) {
+  const prev = graphWriteLocks.get(filePath) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  graphWriteLocks.set(
+    filePath,
+    next.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return next;
+}
+async function appendEdge(memoryDir, edge) {
+  await ensureGraphsDir(memoryDir);
+  const filePath = graphFilePath(memoryDir, edge.type);
+  const line = JSON.stringify(edge) + "\n";
+  await withGraphWriteLock(filePath, async () => {
+    await appendFile(filePath, line, "utf8");
+  });
+  emitGraphEvent(memoryDir, "edge-added", {
+    source: edge.from,
+    target: edge.to,
+    kind: edge.type,
+    weight: edge.weight,
+    label: edge.label,
+    confidence: typeof edge.confidence === "number" ? edge.confidence : 1
+  });
+}
+function isNodeError(err) {
+  return typeof err === "object" && err !== null && "code" in err;
+}
+function parseEdgesJsonl(raw) {
+  const edges = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      edges.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return edges;
+}
+async function readEdgesStrict(memoryDir, type) {
+  const filePath = graphFilePath(memoryDir, type);
+  try {
+    const raw = await fileReader(filePath, "utf8");
+    return parseEdgesJsonl(raw);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+}
+
+export {
+  DEFAULT_DECAY_WINDOW_MS,
+  DEFAULT_DECAY_FLOOR,
+  DEFAULT_DECAY_PER_WINDOW,
+  readEdgeConfidence,
+  decayEdgeConfidence,
+  graphsDir,
+  graphFilePath,
+  withGraphWriteLock,
+  appendEdge,
+  readEdgesStrict
+};

package/dist/{contradiction-scan-A5NOTZPN.js → chunk-JC3FCKYL.js}

@@ -1,16 +1,18 @@
 import {
+  computeMemoryContentHash,
   computePairId,
   isCoolingDown,
   listPairs,
+  memoryHashesChanged,
+  migrateUnscopedPairsToNamespace,
   writePairs
-} from "./chunk-DIZW6H5J.js";
+} from "./chunk-YJYZMLD5.js";
 import {
   extractJsonCandidates
 } from "./chunk-3A5ELHTT.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
-import "./chunk-MLKGABMK.js";
 
 // ../remnic-core/src/contradiction/contradiction-judge.ts
 import { createHash } from "crypto";
@@ -157,15 +159,14 @@ function parseJudgeResponse(candidates, inputs) {
       for (const item of items) {
         if (!item || typeof item !== "object") continue;
         const verdict = typeof item.verdict === "string" && VALID_VERDICTS.includes(item.verdict) ? item.verdict : "needs-user";
-        const pairKeyVal = typeof item.pairKey === "string" ? item.pairKey : null;
+        const pairKeyVal = typeof item.pairKey === "string" && item.pairKey.length > 0 ? item.pairKey : null;
         const input = pairKeyVal ? inputs.find((p) => pairKey(p.memoryIdA, p.memoryIdB) === pairKeyVal) : null;
-        const fallbackInput = input ?? inputs[results.length] ?? inputs[0];
-        if (!fallbackInput) continue;
-        matchedKeys.add(pairKey(fallbackInput.memoryIdA, fallbackInput.memoryIdB));
+        if (!input) continue;
+        matchedKeys.add(pairKey(input.memoryIdA, input.memoryIdB));
         const confidence = typeof item.confidence === "number" ? Math.min(1, Math.max(0, item.confidence)) : 0.5;
         results.push({
-          memoryIdA: fallbackInput.memoryIdA,
-          memoryIdB: fallbackInput.memoryIdB,
+          memoryIdA: input.memoryIdA,
+          memoryIdB: input.memoryIdB,
           verdict,
           rationale: typeof item.rationale === "string" ? item.rationale : "No rationale provided",
           confidence
@@ -209,14 +210,22 @@ var SCAN_CATEGORIES = /* @__PURE__ */ new Set([
 ]);
 async function runContradictionScan(deps) {
   const startTime = Date.now();
-  const { storage, config, memoryDir, embeddingLookup, embeddingLookupFactory, localLlm, fallbackLlm, namespace } = deps;
+  const { config, memoryDir, embeddingLookup, embeddingLookupFactory, localLlm, fallbackLlm } = deps;
+  const requestedNamespace = normalizeScanNamespace(deps.namespace);
   const scanConfig = config.contradictionScan;
-  const scopedEmbeddingLookup = embeddingLookupFactory ? embeddingLookupFactory(storage) : embeddingLookup;
   if (!scanConfig.enabled) {
     log.info("[contradiction-scan] disabled by config");
     return { scanned: 0, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: 0 };
   }
-  const memories = await loadEligibleMemories(storage, namespace);
+  const { storage: scanStorage, namespace } = await resolveScanStorage(deps, requestedNamespace);
+  if (config.namespacesEnabled && namespace !== void 0 && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {
+    const migrated = migrateUnscopedPairsToNamespace(memoryDir, namespace, { cooldownDays: scanConfig.cooldownDays });
+    if (migrated > 0) {
+      log.info("[contradiction-scan] migrated %d legacy unscoped review pairs to namespace %s", migrated, namespace);
+    }
+  }
+  const scopedEmbeddingLookup = embeddingLookupFactory ? embeddingLookupFactory(scanStorage) : embeddingLookup;
+  const memories = await loadEligibleMemories(scanStorage);
   log.info("[contradiction-scan] loaded %d eligible memories", memories.length);
   if (memories.length < 2) {
     return { scanned: memories.length, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: Date.now() - startTime };
@@ -226,7 +235,7 @@ async function runContradictionScan(deps) {
   for (const p of existingPairs) {
     existingMap.set(p.pairId, p);
   }
-  const candidates = await generatePairs(memories, existingMap, scanConfig, scopedEmbeddingLookup);
+  const candidates = await generatePairs(memories, existingMap, scanConfig, namespace, scopedEmbeddingLookup);
   const cooledDown = candidates.skipped;
   log.info("[contradiction-scan] generated %d candidates (%d cooled down)", candidates.pairs.length, cooledDown);
   if (candidates.pairs.length === 0) {
@@ -239,8 +248,7 @@ async function runContradictionScan(deps) {
       elapsedMs: Date.now() - startTime
     };
   }
-  const capped = candidates.pairs.sort((a, b) => computePairId(a.idA, a.idB).localeCompare(computePairId(b.idA, b.idB))).slice(0, scanConfig.maxPairsPerRun);
-  const judgeInputs = capped.map((pair) => ({
+  const judgeInputs = candidates.pairs.map((pair) => ({
     memoryIdA: pair.idA,
     memoryIdB: pair.idB,
     textA: pair.textA,
@@ -252,6 +260,7 @@ async function runContradictionScan(deps) {
   const judgeResult = await judgeContradictionPairs(judgeInputs, config, localLlm, fallbackLlm, scanCache);
   log.info("[contradiction-scan] judge completed: %d judged, %d cached in %dms", judgeResult.judged, judgeResult.cached, judgeResult.elapsed);
   const queueEntries = [];
+  const currentMemoryHashes = memoryContentHashMap(memories);
   for (const [key, result] of judgeResult.results) {
     queueEntries.push({
       memoryIds: [result.memoryIdA, result.memoryIdB],
@@ -261,10 +270,11 @@ async function runContradictionScan(deps) {
       detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
       // Set lastReviewedAt for non-actionable verdicts so cooldown prevents re-judging
       lastReviewedAt: result.verdict === "independent" ? (/* @__PURE__ */ new Date()).toISOString() : void 0,
+      memoryContentHashes: pairMemoryContentHashes(result.memoryIdA, result.memoryIdB, currentMemoryHashes),
       namespace
     });
   }
-  const written = writePairs(memoryDir, queueEntries);
+  const written = writePairs(memoryDir, queueEntries, { cooldownDays: scanConfig.cooldownDays });
   const elapsed = Date.now() - startTime;
   log.info("[contradiction-scan] complete: %d queued in %dms", written.length, elapsed);
   return {
@@ -276,13 +286,24 @@ async function runContradictionScan(deps) {
     elapsedMs: elapsed
   };
 }
-async function generatePairs(memories, existingPairs, scanConfig, embeddingLookup) {
+async function generatePairs(memories, existingPairs, scanConfig, namespace, embeddingLookup) {
   const pairs = [];
-  const embeddingPairs = [];
   let skipped = 0;
   const seen = /* @__PURE__ */ new Set();
+  const maxPairs = Math.max(0, Math.floor(scanConfig.maxPairsPerRun));
+  if (maxPairs === 0) return { pairs, skipped };
+  const orderedMemories = [...memories].sort(compareMemoryId);
+  const currentMemoryHashes = memoryContentHashMap(orderedMemories);
+  const pushCandidate = (pair) => {
+    if (pairs.length < maxPairs) pairs.push(pair);
+  };
+  const hasCapacity = () => pairs.length < maxPairs;
+  const isSkippedByCooldown = (existing) => {
+    if (!existing || !isCoolingDown(existing, scanConfig.cooldownDays)) return false;
+    return !memoryHashesChanged("", existing, (memoryId) => currentMemoryHashes.get(memoryId) ?? null);
+  };
   const byEntity = /* @__PURE__ */ new Map();
-  for (const mem of memories) {
+  for (const mem of orderedMemories) {
     const entity = mem.frontmatter.entityRef;
     if (entity) {
       const existing = byEntity.get(entity) ?? [];
@@ -290,21 +311,55 @@ async function generatePairs(memories, existingPairs, scanConfig, embeddingLooku
       byEntity.set(entity, existing);
     }
   }
-  for (const [, group] of byEntity) {
-    if (group.length < 2) continue;
-    for (let i = 0; i < group.length; i++) {
-      for (let j = i + 1; j < group.length; j++) {
-        const a = group[i];
-        const b = group[j];
-        const pairId = computePairId(a.frontmatter.id, b.frontmatter.id);
+  entityPairs:
+    for (const entity of [...byEntity.keys()].sort()) {
+      const group = byEntity.get(entity) ?? [];
+      if (group.length < 2) continue;
+      for (let i = 0; i < group.length; i++) {
+        for (let j = i + 1; j < group.length; j++) {
+          if (!hasCapacity()) break entityPairs;
+          const a = group[i];
+          const b = group[j];
+          const pairId = computePairId(a.frontmatter.id, b.frontmatter.id, namespace);
+          if (seen.has(pairId)) continue;
+          seen.add(pairId);
+          const existing = existingPairs.get(pairId);
+          if (isSkippedByCooldown(existing)) {
+            skipped++;
+            continue;
+          }
+          pushCandidate({
+            idA: a.frontmatter.id,
+            idB: b.frontmatter.id,
+            textA: a.content,
+            textB: b.content,
+            categoryA: a.frontmatter.category,
+            categoryB: b.frontmatter.category
+          });
+        }
+      }
+    }
+  const noEntity = orderedMemories.filter((m) => !m.frontmatter.entityRef);
+  topicPairs:
+    for (let i = 0; i < noEntity.length; i++) {
+      for (let j = i + 1; j < noEntity.length; j++) {
+        if (!hasCapacity()) break topicPairs;
+        const a = noEntity[i];
+        const b = noEntity[j];
+        const overlap = jaccardOverlap(
+          a.frontmatter.tags ?? [],
+          b.frontmatter.tags ?? []
+        );
+        if (overlap < scanConfig.topicOverlapFloor) continue;
+        const pairId = computePairId(a.frontmatter.id, b.frontmatter.id, namespace);
         if (seen.has(pairId)) continue;
         seen.add(pairId);
         const existing = existingPairs.get(pairId);
-        if (existing && isCoolingDown(existing, scanConfig.cooldownDays)) {
+        if (isSkippedByCooldown(existing)) {
           skipped++;
           continue;
         }
-        pairs.push({
+        pushCandidate({
           idA: a.frontmatter.id,
           idB: b.frontmatter.id,
           textA: a.content,
@@ -314,71 +369,97 @@ async function generatePairs(memories, existingPairs, scanConfig, embeddingLooku
         });
       }
     }
-  }
-  const noEntity = memories.filter((m) => !m.frontmatter.entityRef);
-  for (let i = 0; i < noEntity.length; i++) {
-    for (let j = i + 1; j < noEntity.length; j++) {
-      const a = noEntity[i];
-      const b = noEntity[j];
-      const overlap = jaccardOverlap(
-        a.frontmatter.tags ?? [],
-        b.frontmatter.tags ?? []
-      );
-      if (overlap < scanConfig.topicOverlapFloor) continue;
-      const pairId = computePairId(a.frontmatter.id, b.frontmatter.id);
-      if (seen.has(pairId)) continue;
-      seen.add(pairId);
-      const existing = existingPairs.get(pairId);
-      if (existing && isCoolingDown(existing, scanConfig.cooldownDays)) {
-        skipped++;
-        continue;
-      }
-      pairs.push({
-        idA: a.frontmatter.id,
-        idB: b.frontmatter.id,
-        textA: a.content,
-        textB: b.content,
-        categoryA: a.frontmatter.category,
-        categoryB: b.frontmatter.category
-      });
-    }
-  }
-  if (embeddingLookup) {
-    const memoryById = new Map(memories.map((m) => [m.frontmatter.id, m]));
-    for (const mem of memories) {
-      const id = mem.frontmatter.id;
-      try {
-        const hits = await embeddingLookup(mem.content, 20);
-        for (const hit of hits) {
-          if (hit.score < scanConfig.similarityFloor) continue;
-          if (hit.id === id) continue;
-          const peer = memoryById.get(hit.id);
-          if (!peer) continue;
-          const pairId = computePairId(id, hit.id);
-          if (seen.has(pairId)) continue;
-          seen.add(pairId);
-          const existing = existingPairs.get(pairId);
-          if (existing && isCoolingDown(existing, scanConfig.cooldownDays)) {
-            skipped++;
-            continue;
+  if (embeddingLookup && hasCapacity()) {
+    const memoryById = new Map(orderedMemories.map((m) => [m.frontmatter.id, m]));
+    embeddingPairs:
+      for (const mem of orderedMemories) {
+        if (!hasCapacity()) break;
+        const id = mem.frontmatter.id;
+        try {
+          const hits = (await embeddingLookup(mem.content, 20)).sort(
+            (a, b) => b.score - a.score || a.id.localeCompare(b.id)
+          );
+          for (const hit of hits) {
+            if (!hasCapacity()) break embeddingPairs;
+            if (hit.score < scanConfig.similarityFloor) continue;
+            if (hit.id === id) continue;
+            const peer = memoryById.get(hit.id);
+            if (!peer) continue;
+            const pairId = computePairId(id, hit.id, namespace);
+            if (seen.has(pairId)) continue;
+            seen.add(pairId);
+            const existing = existingPairs.get(pairId);
+            if (isSkippedByCooldown(existing)) {
+              skipped++;
+              continue;
+            }
+            pushCandidate({
+              idA: id,
+              idB: hit.id,
+              textA: mem.content,
+              textB: peer.content,
+              categoryA: mem.frontmatter.category,
+              categoryB: peer.frontmatter.category
+            });
           }
-          embeddingPairs.push({
-            idA: id,
-            idB: hit.id,
-            textA: mem.content,
-            textB: peer.content,
-            categoryA: mem.frontmatter.category,
-            categoryB: peer.frontmatter.category
-          });
+        } catch {
         }
-      } catch {
       }
-    }
   }
-  pairs.push(...embeddingPairs);
   return { pairs, skipped };
 }
-async function loadEligibleMemories(storage, namespace) {
+function normalizeScanNamespace(namespace) {
+  const trimmed = namespace?.trim();
+  return trimmed ? trimmed : void 0;
+}
+async function resolveScanStorage(deps, namespace) {
+  if (!deps.config.namespacesEnabled) {
+    const defaultNamespace = normalizeScanNamespace(deps.config.defaultNamespace);
+    if (namespace && namespace !== defaultNamespace) {
+      throw new Error(`unsupported namespace: ${namespace}`);
+    }
+    return { storage: deps.storage, namespace: void 0 };
+  }
+  if (deps.storageForNamespace) {
+    const resolved = await deps.storageForNamespace(namespace);
+    if (isScanStorageResolution(resolved)) {
+      return {
+        storage: resolved.storage,
+        namespace: normalizeScanNamespace(resolved.namespace) ?? fallbackResolvedNamespace(deps, namespace)
+      };
+    }
+    if (!isStorageManagerLike(resolved)) {
+      throw new Error("storageForNamespace must return a StorageManager or { storage: StorageManager, namespace?: string }");
+    }
+    return {
+      storage: resolved,
+      namespace: fallbackResolvedNamespace(deps, namespace)
+    };
+  }
+  throw new Error(
+    "contradiction scans require storageForNamespace when namespaces are enabled so callers can enforce namespace access"
+  );
+}
+function isScanStorageResolution(value) {
+  if (isStorageManagerLike(value)) return false;
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return isStorageManagerLike(candidate.storage);
+}
+function isStorageManagerLike(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.readAllMemories === "function";
+}
+function fallbackResolvedNamespace(deps, namespace) {
+  if (namespace) return namespace;
+  return deps.config.namespacesEnabled ? deps.config.defaultNamespace : void 0;
+}
+function isDefaultNamespaceScan(config, requestedNamespace, resolvedNamespace) {
+  if (requestedNamespace === void 0) return true;
+  return requestedNamespace === config.defaultNamespace || resolvedNamespace === config.defaultNamespace;
+}
+async function loadEligibleMemories(storage) {
   let all;
   try {
     all = await storage.readAllMemories();
@@ -407,6 +488,28 @@ function jaccardOverlap(a, b) {
   const union = setA.size + setB.size - intersection;
   return union === 0 ? 0 : intersection / union;
 }
+function compareMemoryId(a, b) {
+  return (a.frontmatter.id ?? "").localeCompare(b.frontmatter.id ?? "");
+}
+function memoryContentHashMap(memories) {
+  const hashes = /* @__PURE__ */ new Map();
+  for (const memory of memories) {
+    const id = memory.frontmatter.id;
+    if (!id) continue;
+    hashes.set(id, computeMemoryContentHash(memory.content, memory.frontmatter.category));
+  }
+  return hashes;
+}
+function pairMemoryContentHashes(memoryIdA, memoryIdB, currentMemoryHashes) {
+  const hashA = currentMemoryHashes.get(memoryIdA);
+  const hashB = currentMemoryHashes.get(memoryIdB);
+  if (!hashA || !hashB) return void 0;
+  return {
+    [memoryIdA]: hashA,
+    [memoryIdB]: hashB
+  };
+}
+
 export {
   ACTIVE_STATUSES,
   runContradictionScan

package/dist/{chunk-SVSQAG6M.js → chunk-KC7KSQR4.js}

@@ -1,8 +1,9 @@
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens,
+  resolveCausalTrajectoryStoreDir,
   topicOverlapScore
-} from "./chunk-WPINX4MF.js";
+} from "./chunk-3IKMUNW5.js";
 import {
   assertIsoRecordedAt,
   assertString,
@@ -12,7 +13,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-5LE4HTVL.js";
+} from "./chunk-25J4PXDH.js";
 import {
   log
 } from "./chunk-UFU5GGGA.js";
@@ -67,7 +68,7 @@ function makeEdgeId(fromId, toId) {
   return `edge-${digest}`;
 }
 function resolveChainsDir(memoryDir, causalTrajectoryStoreDir) {
-  const root = causalTrajectoryStoreDir ? path.join(memoryDir, causalTrajectoryStoreDir) : path.join(memoryDir, "state", "causal-trajectories");
+  const root = resolveCausalTrajectoryStoreDir(memoryDir, causalTrajectoryStoreDir);
   return path.join(root, "chains");
 }
 function chainIndexPath(chainsDir) {
@@ -77,6 +78,22 @@ function edgeFilePath(chainsDir, edge) {
   const day = recordStoreDay(edge.createdAt);
   return path.join(chainsDir, "edges", day, `${edge.edgeId}.json`);
 }
+var chainMutationQueues = /* @__PURE__ */ new Map();
+function enqueueChainMutation(chainsDir, op) {
+  const key = path.resolve(chainsDir);
+  const previous = chainMutationQueues.get(key) ?? Promise.resolve();
+  const run = previous.catch(() => {
+  }).then(op);
+  const settled = run.catch(() => {
+  });
+  chainMutationQueues.set(key, settled);
+  void settled.finally(() => {
+    if (chainMutationQueues.get(key) === settled) {
+      chainMutationQueues.delete(key);
+    }
+  });
+  return run;
+}
 async function readChainIndex(chainsDir) {
   try {
     const raw = JSON.parse(await fileReader(chainIndexPath(chainsDir), "utf8"));
@@ -213,7 +230,7 @@ function scoreStitchCandidate(newTrajectory, candidate) {
   return { trajectory: candidate, score, edgeType, stitchMethod: dominantMethod };
 }
 async function readRecentTrajectories(memoryDir, causalTrajectoryStoreDir, currentSessionKey, lookbackDays) {
-  const root = causalTrajectoryStoreDir ? path.join(memoryDir, causalTrajectoryStoreDir) : path.join(memoryDir, "state", "causal-trajectories");
+  const root = resolveCausalTrajectoryStoreDir(memoryDir, causalTrajectoryStoreDir);
   const trajectoriesDir = path.join(root, "trajectories");
   const files = await listJsonFiles(trajectoriesDir).catch(() => []);
   if (files.length === 0) return [];
@@ -246,30 +263,32 @@ async function stitchCausalChain(options) {
   if (candidates.length === 0) return [];
   const scored = candidates.map((c) => scoreStitchCandidate(newTrajectory, c)).filter((s) => s.score >= stitchConfig.minScore).sort((a, b) => b.score - a.score).slice(0, stitchConfig.maxEdgesPerTrajectory);
   if (scored.length === 0) return [];
-  const index = await readChainIndex(chainsDir);
-  const newEdges = [];
-  for (const candidate of scored) {
-    const edgeId = makeEdgeId(candidate.trajectory.trajectoryId, newTrajectory.trajectoryId);
-    if (index.edges[edgeId]) continue;
-    const edge = {
-      schemaVersion: 1,
-      edgeId,
-      fromTrajectoryId: candidate.trajectory.trajectoryId,
-      toTrajectoryId: newTrajectory.trajectoryId,
-      edgeType: candidate.edgeType,
-      confidence: Math.min(1, candidate.score / 10),
-      stitchMethod: candidate.stitchMethod,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    addEdgeToIndex(index, edge);
-    await persistEdge(chainsDir, edge);
-    newEdges.push(edge);
-  }
-  if (newEdges.length > 0) {
-    await writeChainIndex(chainsDir, index);
-    log.debug(`[cmc] stitched ${newEdges.length} causal edge(s) for trajectory ${newTrajectory.trajectoryId}`);
-  }
-  return newEdges;
+  return enqueueChainMutation(chainsDir, async () => {
+    const index = await readChainIndex(chainsDir);
+    const newEdges = [];
+    for (const candidate of scored) {
+      const edgeId = makeEdgeId(candidate.trajectory.trajectoryId, newTrajectory.trajectoryId);
+      if (index.edges[edgeId]) continue;
+      const edge = {
+        schemaVersion: 1,
+        edgeId,
+        fromTrajectoryId: candidate.trajectory.trajectoryId,
+        toTrajectoryId: newTrajectory.trajectoryId,
+        edgeType: candidate.edgeType,
+        confidence: Math.min(1, candidate.score / 10),
+        stitchMethod: candidate.stitchMethod,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      addEdgeToIndex(index, edge);
+      await persistEdge(chainsDir, edge);
+      newEdges.push(edge);
+    }
+    if (newEdges.length > 0) {
+      await writeChainIndex(chainsDir, index);
+      log.debug(`[cmc] stitched ${newEdges.length} causal edge(s) for trajectory ${newTrajectory.trajectoryId}`);
+    }
+    return newEdges;
+  });
 }
 
 export {