@remnic/core 9.69.22 → 9.69.24

package/dist/{chunk-GCASGYIO.js → chunk-C7HJ3NEI.js}

@@ -1,6 +1,6 @@
 import {
   isErrnoCode
-} from "./chunk-5UZXUTVO.js";
+} from "./chunk-KNA3BXXL.js";
 
 // src/utils/path-containment.ts
 import path from "path";
@@ -68,4 +68,4 @@ export {
   listContainedSpillFiles,
   ensureContainedSpillDir
 };
-//# sourceMappingURL=chunk-GCASGYIO.js.map
+//# sourceMappingURL=chunk-C7HJ3NEI.js.map

package/dist/{chunk-C24UZSFW.js → chunk-CEH2AFXG.js}

@@ -1,6 +1,11 @@
 import {
   resolveEnsureCollectionArgs
 } from "./chunk-JXN77SGO.js";
+import {
+  EMPTY_QMD_STATUS,
+  embedQmdFiles,
+  fetchQmdStatus
+} from "./chunk-IUM3VSHI.js";
 import {
   QMD_PROBE_RETRY_BACKOFF_MS,
   QMD_PROBE_TIMEOUT_MS,
@@ -13,11 +18,6 @@ import {
   qmdVersionToString,
   resolveQmdCapabilities
 } from "./chunk-ZLQ37WJX.js";
-import {
-  EMPTY_QMD_STATUS,
-  embedQmdFiles,
-  fetchQmdStatus
-} from "./chunk-IUM3VSHI.js";
 import {
   clearQmdResultCaches,
   getCachedQmdSearch,
@@ -2245,4 +2245,4 @@ export {
   sharedDaemonSessionCountForTest,
   QmdClient
 };
-//# sourceMappingURL=chunk-C24UZSFW.js.map
+//# sourceMappingURL=chunk-CEH2AFXG.js.map

package/dist/{chunk-WVGXCBOC.js → chunk-D5F7TKMH.js}

@@ -19,7 +19,7 @@ import {
 import {
   decryptMemoryDirToPlaintext,
   migrateMemoryDirToEncrypted
-} from "./chunk-ET2CNMLD.js";
+} from "./chunk-JN72EPOE.js";
 import {
   generateSalt
 } from "./chunk-A6XUJE5D.js";
@@ -499,4 +499,4 @@ export {
   renderStatusReport,
   createPassphraseReader
 };
-//# sourceMappingURL=chunk-WVGXCBOC.js.map
+//# sourceMappingURL=chunk-D5F7TKMH.js.map

package/dist/chunk-DGS34QSY.js

@@ -0,0 +1,141 @@
+import {
+  graphFilePath,
+  readEdgesStrict
+} from "./chunk-5FAGCOZD.js";
+import {
+  assertGraphLockHeld,
+  withGraphWriteLock,
+  yieldForLockHeartbeat
+} from "./chunk-EUT2WCWS.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/graph-jsonl.ts
+import { mkdir, rename, writeFile } from "fs/promises";
+import * as path from "path";
+var EDGE_SERIALIZE_YIELD_BATCH = 5e3;
+async function writeGraphJsonlAtomic(filePath, edges, lock) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  let body = "";
+  for (let i = 0; i < edges.length; i += EDGE_SERIALIZE_YIELD_BATCH) {
+    if (i > 0) await yieldForLockHeartbeat();
+    const end = Math.min(i + EDGE_SERIALIZE_YIELD_BATCH, edges.length);
+    for (let j = i; j < end; j += 1) {
+      body += `${JSON.stringify(edges[j])}
+`;
+    }
+  }
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  await writeFile(tempPath, body, "utf-8");
+  await assertGraphLockHeld(filePath, lock);
+  await rename(tempPath, filePath);
+}
+function isNodeGeneratedEdge(edge, type, memoryPath) {
+  return type === "entity" ? edge.from === memoryPath : edge.to === memoryPath;
+}
+async function removeNodeEdgesForRewrite(memoryDir, memoryPath, types) {
+  const results = [];
+  for (const type of types) {
+    const filePath = graphFilePath(memoryDir, type);
+    let removed;
+    try {
+      removed = await withGraphWriteLock(filePath, async (lock) => {
+        const edges = await readEdgesStrict(memoryDir, type);
+        const removedEdges = edges.filter((edge) => isNodeGeneratedEdge(edge, type, memoryPath));
+        if (removedEdges.length === 0) return [];
+        await assertGraphLockHeld(filePath, lock);
+        await writeGraphJsonlAtomic(
+          filePath,
+          edges.filter((edge) => !isNodeGeneratedEdge(edge, type, memoryPath)),
+          lock
+        );
+        return removedEdges;
+      });
+    } catch (err) {
+      for (const done of results) {
+        await restoreRemovedNodeEdges(memoryDir, done).catch(() => void 0);
+      }
+      throw err;
+    }
+    if (removed.length > 0) results.push({ type, filePath, removed });
+  }
+  return results;
+}
+async function restoreRemovedNodeEdges(memoryDir, removed) {
+  if (removed.removed.length === 0) return 0;
+  return withGraphWriteLock(removed.filePath, async (lock) => {
+    const current = await readEdgesStrict(memoryDir, removed.type);
+    const present = new Set(current.map((edge) => JSON.stringify(edge)));
+    const toRestore = removed.removed.filter((edge) => !present.has(JSON.stringify(edge)));
+    if (toRestore.length === 0) return 0;
+    await assertGraphLockHeld(removed.filePath, lock);
+    await writeGraphJsonlAtomic(removed.filePath, [...current, ...toRestore], lock);
+    return toRestore.length;
+  });
+}
+async function rollbackNodeEdgeRewrite(memoryDir, memoryPath, types, removed, nodeId, appended) {
+  let residue = /* @__PURE__ */ new Set();
+  const cleanup = appended ? removeAppendedNodeEdges(memoryDir, memoryPath, types, appended) : removeNodeEdgesForRewrite(memoryDir, memoryPath, types).then(() => /* @__PURE__ */ new Set());
+  await cleanup.then((left) => {
+    residue = left;
+  }).catch(
+    (cleanErr) => log.error(
+      `semantic-merge: partial graph edge cleanup failed for ${nodeId} \u2014 edges from the failed rebuild remain; rebuild with graph health repair: ${cleanErr instanceof Error ? cleanErr.message : String(cleanErr)}`
+    )
+  );
+  for (const entry of removed) {
+    if (residue.has(entry.type)) {
+      log.warn(
+        `semantic-merge: skipped ${entry.type} snapshot restore for ${nodeId} \u2014 a newer writer's rebuilt edges are live in that graph`
+      );
+      continue;
+    }
+    await restoreRemovedNodeEdges(memoryDir, entry).catch(
+      (restoreErr) => log.error(
+        `semantic-merge: graph edge restore failed for ${nodeId} ${entry.type} graph \u2014 the prior edges may be lost; rebuild with graph health repair: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`
+      )
+    );
+  }
+}
+async function removeAppendedNodeEdges(memoryDir, memoryPath, types, appended) {
+  const mineByType = /* @__PURE__ */ new Map();
+  for (const edge of appended) {
+    const list = mineByType.get(edge.type) ?? [];
+    list.push(JSON.stringify(edge));
+    mineByType.set(edge.type, list);
+  }
+  const residue = /* @__PURE__ */ new Set();
+  for (const type of types) {
+    const filePath = graphFilePath(memoryDir, type);
+    const mine = mineByType.get(type) ?? [];
+    await withGraphWriteLock(filePath, async (lock) => {
+      const edges = await readEdgesStrict(memoryDir, type);
+      if (mine.length > 0) {
+        const identities = new Set(mine);
+        const kept = edges.filter((edge) => !identities.has(JSON.stringify(edge)));
+        if (kept.length !== edges.length) {
+          try {
+            await assertGraphLockHeld(filePath, lock);
+          } catch {
+            residue.add(type);
+            return;
+          }
+          await writeGraphJsonlAtomic(filePath, kept, lock);
+        }
+      }
+      if (edges.some((edge) => isNodeGeneratedEdge(edge, type, memoryPath) && !mine.includes(JSON.stringify(edge)))) {
+        residue.add(type);
+      }
+    });
+  }
+  return residue;
+}
+
+export {
+  writeGraphJsonlAtomic,
+  removeNodeEdgesForRewrite,
+  restoreRemovedNodeEdges,
+  rollbackNodeEdgeRewrite
+};
+//# sourceMappingURL=chunk-DGS34QSY.js.map

package/dist/chunk-DGS34QSY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/graph-jsonl.ts"],"sourcesContent":["/**\n * Graph JSONL rewrite primitives (sibling of graph.ts, kept out so graph.ts\n * stays under the 1200-LOC new-work cap of issue #1995).\n *\n * `appendEdge` in graph.ts is append-only by design. These helpers are the\n * REPLACE path: callers that re-write an existing node's edges (the\n * judge-merged target of issue #2330) must first drop the node's prior\n * generated edges or every re-write duplicates them.\n */\n\nimport { mkdir, rename, writeFile } from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { log } from \"./logger.js\";\nimport { graphFilePath, readEdgesStrict, withGraphWriteLock, type GraphEdge, type GraphType } from \"./graph.js\";\nimport {\n  assertGraphLockHeld,\n  yieldForLockHeartbeat,\n  type GraphWriteLockSection,\n} from \"./graph-write-lock.js\";\n\n/**\n * Write a graph JSONL file atomically using temp+rename (gotcha #54: never\n * delete-then-rename; rename is atomic on the same filesystem). Shared by\n * the edge-decay rewrite and node-edge replacement so every JSONL rewrite\n * path serializes on the same lock and the same atomic-write discipline.\n */\n/** Serialize batch size at which body building yields to the event loop\n * (round N+19 A): one `map+join` over a large corpus blocks the loop past\n * the lock's heartbeat window. */\nconst EDGE_SERIALIZE_YIELD_BATCH = 5_000;\n\nexport async function writeGraphJsonlAtomic(\n  filePath: string,\n  edges: GraphEdge[],\n  lock: GraphWriteLockSection,\n): Promise<void> {\n  await mkdir(path.dirname(filePath), { recursive: true });\n  // Chunked with event-loop yields: the caller holds the graph write lock,\n  // and its mtime heartbeat is a timer that cannot fire while a single\n  // synchronous stringify pass over a multi-hundred-thousand-row corpus\n  // blocks the loop (round N+19 A).\n  let body = \"\";\n  for (let i = 0; i < edges.length; i += EDGE_SERIALIZE_YIELD_BATCH) {\n    if (i > 0) await yieldForLockHeartbeat();\n    const end = Math.min(i + EDGE_SERIALIZE_YIELD_BATCH, edges.length);\n    for (let j = i; j < end; j += 1) {\n      body += `${JSON.stringify(edges[j])}\\n`;\n    }\n  }\n  const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;\n  await writeFile(tempPath, body, \"utf-8\");\n  // Round N+20 (A): the callers' pre-build guards cannot cover the build\n  // itself — a section paused past the stale window between the caller's\n  // check and this rename resumes to publish over the peer that broke the\n  // lock and wrote its own newer graph. Revalidate ownership immediately\n  // before the destructive rename; a lost lock aborts and leaves the peer's\n  // file untouched (the staged temp is orphaned, same as a rename failure).\n  await assertGraphLockHeld(filePath, lock);\n  await rename(tempPath, filePath);\n}\n\n/**\n * Which edges a node's OWN write generates, per graph type (round N+7 G):\n *  - entity: the node is the `from` side (node → entity siblings);\n *  - time/causal: the node is the `to` side (predecessor → node) — the\n *    write links BACK to its predecessor, so the inbound edge is the one\n *    this node's write created. The node's outbound time/causal edges\n *    (node → later nodes) belong to those LATER nodes' writes and are never\n *    touched here.\n */\nfunction isNodeGeneratedEdge(edge: GraphEdge, type: GraphType, memoryPath: string): boolean {\n  return type === \"entity\" ? edge.from === memoryPath : edge.to === memoryPath;\n}\n\n/** The edges one removal dropped from one graph file, kept for restoration. */\nexport interface RemovedNodeEdges {\n  type: GraphType;\n  filePath: string;\n  removed: GraphEdge[];\n}\n\n/**\n * Remove an existing node's prior generated edges across the given graph\n * types so a RE-write of the same node (a judge-merged memory, issue #2330)\n * REPLACES them instead of re-appending them into the append-only JSONL —\n * duplicates `spreadingActivation` sums into candidate scores and that grow\n * without bound. One shared routine covers every enabled type; there is no\n * per-type copy. Read and rewrite run under the same per-file write lock as\n * `appendEdge` so a concurrent append cannot be dropped (issue #729). The\n * removed edges are RETURNED so the caller can restore them when the\n * replacement build fails (round N+7 E).\n */\nexport async function removeNodeEdgesForRewrite(\n  memoryDir: string,\n  memoryPath: string,\n  types: readonly GraphType[],\n): Promise<RemovedNodeEdges[]> {\n  const results: RemovedNodeEdges[] = [];\n  for (const type of types) {\n    const filePath = graphFilePath(memoryDir, type);\n    let removed: GraphEdge[];\n    try {\n      removed = await withGraphWriteLock(filePath, async (lock) => {\n        const edges = await readEdgesStrict(memoryDir, type);\n        const removedEdges = edges.filter((edge) => isNodeGeneratedEdge(edge, type, memoryPath));\n        if (removedEdges.length === 0) return [];\n        // Round N+19 A: a peer may have stale-broken this lock while a large\n        // parse blocked the loop — revalidate ownership before publishing the\n        // replacement; a lost lock aborts (the catch below restores any\n        // earlier committed types, then rethrows).\n        await assertGraphLockHeld(filePath, lock);\n        await writeGraphJsonlAtomic(\n          filePath,\n          edges.filter((edge) => !isNodeGeneratedEdge(edge, type, memoryPath)),\n          lock,\n        );\n        return removedEdges;\n      });\n    } catch (err) {\n      // A partial pass (type 1 committed, type 2 failed) must not leave the\n      // committed removal stranded: undo what already landed, then surface.\n      for (const done of results) {\n        await restoreRemovedNodeEdges(memoryDir, done).catch(() => undefined);\n      }\n      throw err;\n    }\n    if (removed.length > 0) results.push({ type, filePath, removed });\n  }\n  return results;\n}\n\n/**\n * Restore edges a {@link removeNodeEdgesForRewrite} pass dropped, after the\n * replacement build FAILED (round N+7 E): failure must leave either the old\n * or the new complete set, never none. Appends the removed edges back under\n * the same per-file lock, deduped on the exact JSON row so a retry that\n * partially succeeded cannot double them.\n */\nexport async function restoreRemovedNodeEdges(\n  memoryDir: string,\n  removed: RemovedNodeEdges,\n): Promise<number> {\n  if (removed.removed.length === 0) return 0;\n  return withGraphWriteLock(removed.filePath, async (lock) => {\n    const current = await readEdgesStrict(memoryDir, removed.type);\n    const present = new Set(current.map((edge) => JSON.stringify(edge)));\n    const toRestore = removed.removed.filter((edge) => !present.has(JSON.stringify(edge)));\n    if (toRestore.length === 0) return 0;\n    // Round N+19 A: revalidate ownership before restoring over the file —\n    // a peer that broke the lock owns the file now, and restoring our older\n    // snapshot over its write would clobber it. The throw leaves the current\n    // (peer-owned) file intact; callers log the skipped restore.\n    await assertGraphLockHeld(removed.filePath, lock);\n    await writeGraphJsonlAtomic(removed.filePath, [...current, ...toRestore], lock);\n    return toRestore.length;\n  });\n}\n\n/**\n * Round N+10 (C) + N+14 companion to {@link removeNodeEdgesForRewrite}: the\n * replacement build FAILED or was superseded, possibly after appending SOME\n * of the node's new edges. Two duties, both scoped to what THIS writer did:\n *\n * 1. Remove the rows the failed build actually appended. When `appended` is\n *    provided the removal is surgical — by exact JSON row identity, per\n *    file, under the same per-file lock — so rows a NEWER writer appended\n *    after this writer's removal (never in this writer's snapshot) survive.\n *    Rows a newer writer already swept are simply absent and the removal is\n *    a no-op. Since round N+16 (A) a THROWING build carries its partial row\n *    set on `GraphEdgeAppendError`, so the surgical path holds on the throw\n *    too; only a build that neither returns rows nor wraps its failure\n *    falls back to the node-wide sweep of\n *    {@link removeNodeEdgesForRewrite}: identical outcome when no newer\n *    writer interleaved.\n * 2. Restore the snapshot the original removal dropped — but only for graph\n *    types whose file holds NO unexplained node rows after step 1. A type\n *    that still has node rows this writer cannot account for is owned by the\n *    newer writer's completed rebuild; restoring the older snapshot over it\n *    left the memory holding B's body while graph recall reflected the\n *    pre-A state (the N+14 finding). Types swept clean restore verbatim\n *    (N+7 E: failure leaves the old or the new complete set, never none).\n */\nexport async function rollbackNodeEdgeRewrite(\n  memoryDir: string,\n  memoryPath: string,\n  types: readonly GraphType[],\n  removed: RemovedNodeEdges[],\n  nodeId: string,\n  appended?: readonly GraphEdge[],\n): Promise<void> {\n  let residue = new Set<GraphType>();\n  const cleanup = appended\n    ? removeAppendedNodeEdges(memoryDir, memoryPath, types, appended)\n    : removeNodeEdgesForRewrite(memoryDir, memoryPath, types).then((): Set<GraphType> => new Set());\n  await cleanup\n    .then((left) => {\n      residue = left;\n    })\n    .catch((cleanErr) =>\n      log.error(\n        `semantic-merge: partial graph edge cleanup failed for ${nodeId} — edges from the failed rebuild remain; rebuild with graph health repair: ${cleanErr instanceof Error ? cleanErr.message : String(cleanErr)}`,\n      ),\n    );\n  for (const entry of removed) {\n    if (residue.has(entry.type)) {\n      log.warn(\n        `semantic-merge: skipped ${entry.type} snapshot restore for ${nodeId} — a newer writer's rebuilt edges are live in that graph`,\n      );\n      continue;\n    }\n    await restoreRemovedNodeEdges(memoryDir, entry).catch((restoreErr) =>\n      log.error(\n        `semantic-merge: graph edge restore failed for ${nodeId} ${entry.type} graph — the prior edges may be lost; rebuild with graph health repair: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`,\n      ),\n    );\n  }\n}\n\n/**\n * Round N+14: remove exactly the rows a failed/superseded build appended,\n * then report which of the rewrite types still hold node-generated rows this\n * writer did NOT append (a newer writer's live rebuild) so the caller can\n * skip restoring its older snapshot over them.\n */\nasync function removeAppendedNodeEdges(\n  memoryDir: string,\n  memoryPath: string,\n  types: readonly GraphType[],\n  appended: readonly GraphEdge[],\n): Promise<Set<GraphType>> {\n  const mineByType = new Map<GraphType, string[]>();\n  for (const edge of appended) {\n    const list = mineByType.get(edge.type) ?? [];\n    list.push(JSON.stringify(edge));\n    mineByType.set(edge.type, list);\n  }\n  const residue = new Set<GraphType>();\n  for (const type of types) {\n    const filePath = graphFilePath(memoryDir, type);\n    const mine = mineByType.get(type) ?? [];\n    await withGraphWriteLock(filePath, async (lock) => {\n      const edges = await readEdgesStrict(memoryDir, type);\n      if (mine.length > 0) {\n        const identities = new Set(mine);\n        const kept = edges.filter((edge) => !identities.has(JSON.stringify(edge)));\n        if (kept.length !== edges.length) {\n          // Round N+19 A: lost lock — a peer owns the file. Cleaning it would\n          // clobber the peer's write, so leave it, mark the type as residue,\n          // and let the caller skip restoring its older snapshot over it\n          // (our appended rows may survive as duplicates; graph health\n          // repair reconciles). Never old-plus-partial-new over a peer.\n          try {\n            await assertGraphLockHeld(filePath, lock);\n          } catch {\n            residue.add(type);\n            return;\n          }\n          await writeGraphJsonlAtomic(filePath, kept, lock);\n        }\n      }\n      if (edges.some((edge) => isNodeGeneratedEdge(edge, type, memoryPath) && !mine.includes(JSON.stringify(edge)))) {\n        residue.add(type);\n      }\n    });\n  }\n  return residue;\n}\n"],"mappings":";;;;;;;;;;;;;;AAUA,SAAS,OAAO,QAAQ,iBAAiB;AACzC,YAAY,UAAU;AAkBtB,IAAM,6BAA6B;AAEnC,eAAsB,sBACpB,UACA,OACA,MACe;AACf,QAAM,MAAW,aAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAKvD,MAAI,OAAO;AACX,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,4BAA4B;AACjE,QAAI,IAAI,EAAG,OAAM,sBAAsB;AACvC,UAAM,MAAM,KAAK,IAAI,IAAI,4BAA4B,MAAM,MAAM;AACjE,aAAS,IAAI,GAAG,IAAI,KAAK,KAAK,GAAG;AAC/B,cAAQ,GAAG,KAAK,UAAU,MAAM,CAAC,CAAC,CAAC;AAAA;AAAA,IACrC;AAAA,EACF;AACA,QAAM,WAAW,GAAG,QAAQ,IAAI,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,CAAC,CAAC;AAChG,QAAM,UAAU,UAAU,MAAM,OAAO;AAOvC,QAAM,oBAAoB,UAAU,IAAI;AACxC,QAAM,OAAO,UAAU,QAAQ;AACjC;AAWA,SAAS,oBAAoB,MAAiB,MAAiB,YAA6B;AAC1F,SAAO,SAAS,WAAW,KAAK,SAAS,aAAa,KAAK,OAAO;AACpE;AAoBA,eAAsB,0BACpB,WACA,YACA,OAC6B;AAC7B,QAAM,UAA8B,CAAC;AACrC,aAAW,QAAQ,OAAO;AACxB,UAAM,WAAW,cAAc,WAAW,IAAI;AAC9C,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM,mBAAmB,UAAU,OAAO,SAAS;AAC3D,cAAM,QAAQ,MAAM,gBAAgB,WAAW,IAAI;AACnD,cAAM,eAAe,MAAM,OAAO,CAAC,SAAS,oBAAoB,MAAM,MAAM,UAAU,CAAC;AACvF,YAAI,aAAa,WAAW,EAAG,QAAO,CAAC;AAKvC,cAAM,oBAAoB,UAAU,IAAI;AACxC,cAAM;AAAA,UACJ;AAAA,UACA,MAAM,OAAO,CAAC,SAAS,CAAC,oBAAoB,MAAM,MAAM,UAAU,CAAC;AAAA,UACnE;AAAA,QACF;AACA,eAAO;AAAA,MACT,CAAC;AAAA,IACH,SAAS,KAAK;AAGZ,iBAAW,QAAQ,SAAS;AAC1B,cAAM,wBAAwB,WAAW,IAAI,EAAE,MAAM,MAAM,MAAS;AAAA,MACtE;AACA,YAAM;AAAA,IACR;AACA,QAAI,QAAQ,SAAS,EAAG,SAAQ,KAAK,EAAE,MAAM,UAAU,QAAQ,CAAC;AAAA,EAClE;AACA,SAAO;AACT;AASA,eAAsB,wBACpB,WACA,SACiB;AACjB,MAAI,QAAQ,QAAQ,WAAW,EAAG,QAAO;AACzC,SAAO,mBAAmB,QAAQ,UAAU,OAAO,SAAS;AAC1D,UAAM,UAAU,MAAM,gBAAgB,WAAW,QAAQ,IAAI;AAC7D,UAAM,UAAU,IAAI,IAAI,QAAQ,IAAI,CAAC,SAAS,KAAK,UAAU,IAAI,CAAC,CAAC;AACnE,UAAM,YAAY,QAAQ,QAAQ,OAAO,CAAC,SAAS,CAAC,QAAQ,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC;AACrF,QAAI,UAAU,WAAW,EAAG,QAAO;AAKnC,UAAM,oBAAoB,QAAQ,UAAU,IAAI;AAChD,UAAM,sBAAsB,QAAQ,UAAU,CAAC,GAAG,SAAS,GAAG,SAAS,GAAG,IAAI;AAC9E,WAAO,UAAU;AAAA,EACnB,CAAC;AACH;AA0BA,eAAsB,wBACpB,WACA,YACA,OACA,SACA,QACA,UACe;AACf,MAAI,UAAU,oBAAI,IAAe;AACjC,QAAM,UAAU,WACZ,wBAAwB,WAAW,YAAY,OAAO,QAAQ,IAC9D,0BAA0B,WAAW,YAAY,KAAK,EAAE,KAAK,MAAsB,oBAAI,IAAI,CAAC;AAChG,QAAM,QACH,KAAK,CAAC,SAAS;AACd,cAAU;AAAA,EACZ,CAAC,EACA;AAAA,IAAM,CAAC,aACN,IAAI;AAAA,MACF,yDAAyD,MAAM,mFAA8E,oBAAoB,QAAQ,SAAS,UAAU,OAAO,QAAQ,CAAC;AAAA,IAC9M;AAAA,EACF;AACF,aAAW,SAAS,SAAS;AAC3B,QAAI,QAAQ,IAAI,MAAM,IAAI,GAAG;AAC3B,UAAI;AAAA,QACF,2BAA2B,MAAM,IAAI,yBAAyB,MAAM;AAAA,MACtE;AACA;AAAA,IACF;AACA,UAAM,wBAAwB,WAAW,KAAK,EAAE;AAAA,MAAM,CAAC,eACrD,IAAI;AAAA,QACF,iDAAiD,MAAM,IAAI,MAAM,IAAI,gFAA2E,sBAAsB,QAAQ,WAAW,UAAU,OAAO,UAAU,CAAC;AAAA,MACvN;AAAA,IACF;AAAA,EACF;AACF;AAQA,eAAe,wBACb,WACA,YACA,OACA,UACyB;AACzB,QAAM,aAAa,oBAAI,IAAyB;AAChD,aAAW,QAAQ,UAAU;AAC3B,UAAM,OAAO,WAAW,IAAI,KAAK,IAAI,KAAK,CAAC;AAC3C,SAAK,KAAK,KAAK,UAAU,IAAI,CAAC;AAC9B,eAAW,IAAI,KAAK,MAAM,IAAI;AAAA,EAChC;AACA,QAAM,UAAU,oBAAI,IAAe;AACnC,aAAW,QAAQ,OAAO;AACxB,UAAM,WAAW,cAAc,WAAW,IAAI;AAC9C,UAAM,OAAO,WAAW,IAAI,IAAI,KAAK,CAAC;AACtC,UAAM,mBAAmB,UAAU,OAAO,SAAS;AACjD,YAAM,QAAQ,MAAM,gBAAgB,WAAW,IAAI;AACnD,UAAI,KAAK,SAAS,GAAG;AACnB,cAAM,aAAa,IAAI,IAAI,IAAI;AAC/B,cAAM,OAAO,MAAM,OAAO,CAAC,SAAS,CAAC,WAAW,IAAI,KAAK,UAAU,IAAI,CAAC,CAAC;AACzE,YAAI,KAAK,WAAW,MAAM,QAAQ;AAMhC,cAAI;AACF,kBAAM,oBAAoB,UAAU,IAAI;AAAA,UAC1C,QAAQ;AACN,oBAAQ,IAAI,IAAI;AAChB;AAAA,UACF;AACA,gBAAM,sBAAsB,UAAU,MAAM,IAAI;AAAA,QAClD;AAAA,MACF;AACA,UAAI,MAAM,KAAK,CAAC,SAAS,oBAAoB,MAAM,MAAM,UAAU,KAAK,CAAC,KAAK,SAAS,KAAK,UAAU,IAAI,CAAC,CAAC,GAAG;AAC7G,gBAAQ,IAAI,IAAI;AAAA,MAClB;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO;AACT;","names":[]}

package/dist/{chunk-X7Y7WX73.js → chunk-DQEMWVMT.js}

@@ -246,4 +246,4 @@ export {
   decryptCapsuleFile,
   decryptCapsuleFileInMemory
 };
-//# sourceMappingURL=chunk-X7Y7WX73.js.map
+//# sourceMappingURL=chunk-DQEMWVMT.js.map

package/dist/{chunk-2OXIPF3A.js → chunk-DZD3WGCD.js}

@@ -4,7 +4,7 @@ import {
 import {
   drainPendingLifecycleForSyncOrThrow,
   drainPendingLifecycleLedgerForSync
-} from "./chunk-JRRQ747T.js";
+} from "./chunk-TBXAY2SS.js";
 import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
@@ -14,7 +14,7 @@ import {
 import {
   assertPathInsideRoot,
   pathIsInside
-} from "./chunk-GCASGYIO.js";
+} from "./chunk-C7HJ3NEI.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-PCXDUHQH.js";
@@ -23,7 +23,7 @@ import {
 } from "./chunk-VUFL7X3H.js";
 import {
   isErrnoCode
-} from "./chunk-5UZXUTVO.js";
+} from "./chunk-KNA3BXXL.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -181,4 +181,4 @@ export {
   offlineSyncStorageForSnapshot,
   drainPendingLifecycleForOfflineSync
 };
-//# sourceMappingURL=chunk-2OXIPF3A.js.map
+//# sourceMappingURL=chunk-DZD3WGCD.js.map

package/dist/{chunk-UMEOXLIZ.js → chunk-E2P7TZTF.js}

@@ -1,13 +1,13 @@
 import {
   StorageManager
-} from "./chunk-OGTKQ5MJ.js";
+} from "./chunk-XSGUMQQQ.js";
+import {
+  MutationSerializer
+} from "./chunk-FFAZ2XFU.js";
 import {
   keyring_exports,
   secureStoreDir
 } from "./chunk-BJMBJZ2Y.js";
-import {
-  MutationSerializer
-} from "./chunk-FFAZ2XFU.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-PCXDUHQH.js";
@@ -412,4 +412,4 @@ export {
   resolveNamespaceStorageRoot,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-UMEOXLIZ.js.map
+//# sourceMappingURL=chunk-E2P7TZTF.js.map

package/dist/{chunk-6FC3IZ26.js → chunk-EBA5DA77.js}

@@ -10,7 +10,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-P77QX3ID.js";
+} from "./chunk-B6O2YLUR.js";
 
 // src/utility-telemetry.ts
 import path from "path";
@@ -151,4 +151,4 @@ export {
   readUtilityTelemetryEvents,
   getUtilityTelemetryStatus
 };
-//# sourceMappingURL=chunk-6FC3IZ26.js.map
+//# sourceMappingURL=chunk-EBA5DA77.js.map

package/dist/{chunk-N7JK2RKG.js → chunk-EOQ6FSQP.js}

@@ -1,6 +1,6 @@
 import {
   resolveCorpusNamespaceRoots
-} from "./chunk-EJ5RKUXW.js";
+} from "./chunk-AQ7SYDVO.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-MZWSOLMT.js";
@@ -200,4 +200,4 @@ async function readAggregateExtractionWatermark(options) {
 export {
   readAggregateExtractionWatermark
 };
-//# sourceMappingURL=chunk-N7JK2RKG.js.map
+//# sourceMappingURL=chunk-EOQ6FSQP.js.map

package/dist/chunk-EUT2WCWS.js

@@ -0,0 +1,54 @@
+import {
+  withHeldFileLock
+} from "./chunk-FFAZ2XFU.js";
+
+// src/graph-write-lock.ts
+var graphWriteLocks = /* @__PURE__ */ new Map();
+var GRAPH_LOCK_STALE_MS = 3e4;
+var GRAPH_LOCK_MAX_WAIT_MS = 1e4;
+var GraphLockLostError = class extends Error {
+  constructor(filePath) {
+    super(
+      `graph: the write lock for ${filePath} was lost mid-section \u2014 a peer stale-broke and replaced it; aborting this write instead of clobbering the peer's`
+    );
+    this.name = "GraphLockLostError";
+  }
+};
+async function assertGraphLockHeld(filePath, lock) {
+  if (!await lock.refresh()) throw new GraphLockLostError(filePath);
+}
+function yieldForLockHeartbeat() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function withGraphWriteLock(filePath, fn) {
+  const run = () => withHeldFileLock(
+    `${filePath}.lock`,
+    { staleMs: GRAPH_LOCK_STALE_MS, maxWaitMs: GRAPH_LOCK_MAX_WAIT_MS },
+    (acquired, lock) => {
+      if (!acquired) {
+        throw new Error(
+          `graph: could not acquire the graph write lock for ${filePath} within ${GRAPH_LOCK_MAX_WAIT_MS}ms \u2014 another process holds it`
+        );
+      }
+      return fn(lock);
+    }
+  );
+  const prev = graphWriteLocks.get(filePath) ?? Promise.resolve();
+  const next = prev.then(run, run);
+  graphWriteLocks.set(
+    filePath,
+    next.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return next;
+}
+
+export {
+  GraphLockLostError,
+  assertGraphLockHeld,
+  yieldForLockHeartbeat,
+  withGraphWriteLock
+};
+//# sourceMappingURL=chunk-EUT2WCWS.js.map

package/dist/chunk-EUT2WCWS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/graph-write-lock.ts"],"sourcesContent":["/**\n * Cross-process-safe write lock for graph JSONL files (issue #2330 round\n * N+18 A). Sibling of graph.ts — extracted there so graph.ts stays within\n * its file-size ratchet; graph.ts re-exports {@link withGraphWriteLock}\n * because `@remnic/core/graph` is a public subpath export.\n *\n * Three layers, one per section:\n *\n * 1. An in-process promise chain keyed by JSONL file path (gotcha #40):\n *    the append path (`appendEdge`) and the rewrite path used by the decay\n *    maintenance job serialize on the same lock. Without this, an\n *    extraction can append a new edge between the decay job's\n *    read-snapshot and rewrite, silently dropping the appended edge during\n *    active traffic (issue #729 / Codex P1).\n *\n * 2. A cross-process advisory lock: the promise chain only serializes THIS\n *    process. A peer Remnic process sharing the memory directory could\n *    append an edge after this process reads its JSONL snapshot but before\n *    the rename-backed rewrite publishes, permanently discarding the\n *    peer's edge — so every section also holds the established\n *    `withHeldFileLock` advisory lock (the same primitive round N+16 gave\n *    the page-versioning manifest) as a sibling `<file>.lock`. A lock that\n *    cannot be taken within the bounded wait FAILS the write (strict,\n *    matching the manifest): proceeding unsynchronized would reintroduce\n *    the lost-write race the lock exists to prevent. Graph write callers\n *    are fail-open, so the surfaced error degrades to a logged skip.\n *\n * 3. Ownership revalidation before destructive writes (round N+19 A): the\n *    lock's mtime heartbeat is a TIMER — it cannot fire while a\n *    synchronous parse/serialize of a large graph blocks the event loop.\n *    A peer can then judge the lock stale past the 30s window, break it,\n *    and publish its own write. Every section therefore receives the\n *    lock's {@link GraphWriteLockSection} controller and MUST pass it to\n *    {@link assertGraphLockHeld} immediately before publishing a\n *    replacement (or appending): a lost lock aborts THIS write with\n *    {@link GraphLockLostError} instead of clobbering the peer's. Long\n *    CPU passes inside a section should await {@link\n *    yieldForLockHeartbeat} every few thousand rows so the heartbeat\n *    timer gets a turn and the section is less likely to be broken in\n *    the first place.\n */\n\nimport { withHeldFileLock, type HeldFileLockController } from \"./utils/serialize-mutations.js\";\n\nconst graphWriteLocks = new Map<string, Promise<void>>();\n\n/** Stale-lock window for the cross-process graph lock (crashed holder). */\nconst GRAPH_LOCK_STALE_MS = 30_000;\n/** Bounded acquisition wait for the cross-process graph lock. */\nconst GRAPH_LOCK_MAX_WAIT_MS = 10_000;\n\n/** Control surface handed to a graph write-lock section (round N+19 A). */\nexport type GraphWriteLockSection = HeldFileLockController;\n\n/**\n * A graph write section lost its advisory lock mid-critical-section — a peer\n * stale-broke and replaced it while this process's event loop was blocked.\n * The thrower has NOT published its write; callers treat it like any other\n * write failure (graph callers are fail-open).\n */\nexport class GraphLockLostError extends Error {\n  constructor(filePath: string) {\n    super(\n      `graph: the write lock for ${filePath} was lost mid-section — a peer stale-broke and replaced it; aborting this write instead of clobbering the peer's`,\n    );\n    this.name = \"GraphLockLostError\";\n  }\n}\n\n/**\n * Revalidate lock ownership immediately before a destructive graph write.\n * Throws {@link GraphLockLostError} when the lock was broken/replaced, so the\n * caller aborts and leaves the peer's write intact.\n */\nexport async function assertGraphLockHeld(\n  filePath: string,\n  lock: GraphWriteLockSection,\n): Promise<void> {\n  if (!(await lock.refresh())) throw new GraphLockLostError(filePath);\n}\n\n/**\n * Yield one event-loop turn so the lock's heartbeat timer can fire during a\n * long, CPU-bound parse/serialize/decay pass inside a held graph lock\n * section (round N+19 A). `setImmediate` runs in the check phase, after any\n * due timers, so each yield lets an overdue heartbeat stamp the lock's mtime\n * before a peer judges it stale.\n */\nexport function yieldForLockHeartbeat(): Promise<void> {\n  return new Promise<void>((resolve) => setImmediate(resolve));\n}\n\n/**\n * Run `fn` while holding the write lock for the given graph JSONL file,\n * handing it the section's {@link GraphWriteLockSection} controller.\n *\n * The lock is keyed by absolute file path so concurrent writes to\n * different graph types proceed independently. The chain recovers from\n * rejection (gotcha #40) so a single I/O failure does not poison all\n * future writers, but the original error is still surfaced to the\n * caller of `withGraphWriteLock`. The in-process chain runs INSIDE the\n * cross-process advisory lock, so peers serialize against every section\n * this process runs, one section at a time.\n */\nexport function withGraphWriteLock<T>(\n  filePath: string,\n  fn: (lock: GraphWriteLockSection) => Promise<T>,\n): Promise<T> {\n  const run = () =>\n    withHeldFileLock(\n      `${filePath}.lock`,\n      { staleMs: GRAPH_LOCK_STALE_MS, maxWaitMs: GRAPH_LOCK_MAX_WAIT_MS },\n      (acquired, lock) => {\n        if (!acquired) {\n          throw new Error(\n            `graph: could not acquire the graph write lock for ${filePath} within ${GRAPH_LOCK_MAX_WAIT_MS}ms — another process holds it`,\n          );\n        }\n        return fn(lock);\n      },\n    );\n  const prev = graphWriteLocks.get(filePath) ?? Promise.resolve();\n  const next = prev.then(run, run);\n  graphWriteLocks.set(\n    filePath,\n    next.then(\n      () => undefined,\n      () => undefined\n    )\n  );\n  return next;\n}\n"],"mappings":";;;;;AA4CA,IAAM,kBAAkB,oBAAI,IAA2B;AAGvD,IAAM,sBAAsB;AAE5B,IAAM,yBAAyB;AAWxB,IAAM,qBAAN,cAAiC,MAAM;AAAA,EAC5C,YAAY,UAAkB;AAC5B;AAAA,MACE,6BAA6B,QAAQ;AAAA,IACvC;AACA,SAAK,OAAO;AAAA,EACd;AACF;AAOA,eAAsB,oBACpB,UACA,MACe;AACf,MAAI,CAAE,MAAM,KAAK,QAAQ,EAAI,OAAM,IAAI,mBAAmB,QAAQ;AACpE;AASO,SAAS,wBAAuC;AACrD,SAAO,IAAI,QAAc,CAAC,YAAY,aAAa,OAAO,CAAC;AAC7D;AAcO,SAAS,mBACd,UACA,IACY;AACZ,QAAM,MAAM,MACV;AAAA,IACE,GAAG,QAAQ;AAAA,IACX,EAAE,SAAS,qBAAqB,WAAW,uBAAuB;AAAA,IAClE,CAAC,UAAU,SAAS;AAClB,UAAI,CAAC,UAAU;AACb,cAAM,IAAI;AAAA,UACR,qDAAqD,QAAQ,WAAW,sBAAsB;AAAA,QAChG;AAAA,MACF;AACA,aAAO,GAAG,IAAI;AAAA,IAChB;AAAA,EACF;AACF,QAAM,OAAO,gBAAgB,IAAI,QAAQ,KAAK,QAAQ,QAAQ;AAC9D,QAAM,OAAO,KAAK,KAAK,KAAK,GAAG;AAC/B,kBAAgB;AAAA,IACd;AAAA,IACA,KAAK;AAAA,MACH,MAAM;AAAA,MACN,MAAM;AAAA,IACR;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/{chunk-YNDLCWXS.js → chunk-EZ25VE3G.js}

@@ -1,9 +1,9 @@
-import {
-  diffGraphSnapshots
-} from "./chunk-AUDJPF4N.js";
 import {
   graphSnapshotFromMemoryDir
 } from "./chunk-44442YCH.js";
+import {
+  diffGraphSnapshots
+} from "./chunk-AUDJPF4N.js";
 
 // src/dashboard-runtime.ts
 import { createHash, timingSafeEqual } from "crypto";
@@ -370,4 +370,4 @@ var GraphDashboardServer = class {
 export {
   GraphDashboardServer
 };
-//# sourceMappingURL=chunk-YNDLCWXS.js.map
+//# sourceMappingURL=chunk-EZ25VE3G.js.map

package/dist/{chunk-XDMI5VKE.js → chunk-FVOP3NT7.js}

@@ -1,7 +1,7 @@
 import {
   SupportPassportError,
   getOperation
-} from "./chunk-NQFCLAYT.js";
+} from "./chunk-ICKJ52PE.js";
 import {
   abortError,
   isAbortError
@@ -499,4 +499,4 @@ export {
   buildSupportPassportPublicRequestHandler,
   composeSupportPassportExternalRequestHandlers
 };
-//# sourceMappingURL=chunk-XDMI5VKE.js.map
+//# sourceMappingURL=chunk-FVOP3NT7.js.map

package/dist/{chunk-NRLELHAY.js → chunk-G7NYVKD6.js}

@@ -15,7 +15,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-P77QX3ID.js";
+} from "./chunk-B6O2YLUR.js";
 
 // src/work-product-ledger.ts
 import path from "path";
@@ -182,4 +182,4 @@ export {
   searchWorkProductLedgerEntries,
   getWorkProductLedgerStatus
 };
-//# sourceMappingURL=chunk-NRLELHAY.js.map
+//# sourceMappingURL=chunk-G7NYVKD6.js.map

package/dist/{chunk-B3W7GWQB.js → chunk-GHTSNGBZ.js}

@@ -1,6 +1,6 @@
 import {
   deepRecallRequestSchema
-} from "./chunk-LCMUZDBZ.js";
+} from "./chunk-N3ZOP7KC.js";
 import {
   EngramAccessInputError
 } from "./chunk-2Z24E5W2.js";
@@ -39,4 +39,4 @@ async function respondDeepRecall(req, res, respondJson, readJsonBody, service, s
 export {
   respondDeepRecall
 };
-//# sourceMappingURL=chunk-B3W7GWQB.js.map
+//# sourceMappingURL=chunk-GHTSNGBZ.js.map

package/dist/chunk-GKCXTSFF.js

@@ -0,0 +1,17 @@
+// src/graph-append-error.ts
+var GraphEdgeAppendError = class extends Error {
+  appendedEdges;
+  constructor(cause, appendedEdges) {
+    super(
+      `graph edge append failed after ${appendedEdges.length} row(s): ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+    this.name = "GraphEdgeAppendError";
+    this.appendedEdges = appendedEdges;
+  }
+};
+
+export {
+  GraphEdgeAppendError
+};
+//# sourceMappingURL=chunk-GKCXTSFF.js.map

package/dist/chunk-GKCXTSFF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/graph-append-error.ts"],"sourcesContent":["/**\n * Sibling of {@link \"./graph.js\"} holding the append-failure error type so\n * graph.ts stays within its file-size ratchet cap (issue #1995). Type-only\n * dependency on GraphEdge — no runtime cycle with graph.ts.\n */\nimport type { GraphEdge } from \"./graph.js\";\n\n/**\n * Issue #2330 round N+16 (A): thrown by `GraphIndex.onMemoryWritten` when an\n * append fails, carrying the rows this call had ALREADY appended — tracked\n * incrementally as each row is written, before any return value exists. A\n * rollback that only sees the raw failure used to fall back to a node-wide\n * sweep, which also deleted rows a NEWER writer had rebuilt inside the\n * failing writer's window; with the partial set on the error, the rollback\n * stays surgical even on the throwing path. The original failure is\n * preserved as `cause` (create-path callers only log it).\n */\nexport class GraphEdgeAppendError extends Error {\n  readonly appendedEdges: readonly GraphEdge[];\n  constructor(cause: unknown, appendedEdges: readonly GraphEdge[]) {\n    super(\n      `graph edge append failed after ${appendedEdges.length} row(s): ${cause instanceof Error ? cause.message : String(cause)}`,\n      { cause },\n    );\n    this.name = \"GraphEdgeAppendError\";\n    this.appendedEdges = appendedEdges;\n  }\n}\n"],"mappings":";AAiBO,IAAM,uBAAN,cAAmC,MAAM;AAAA,EACrC;AAAA,EACT,YAAY,OAAgB,eAAqC;AAC/D;AAAA,MACE,kCAAkC,cAAc,MAAM,YAAY,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAAA,MACxH,EAAE,MAAM;AAAA,IACV;AACA,SAAK,OAAO;AACZ,SAAK,gBAAgB;AAAA,EACvB;AACF;","names":[]}

package/dist/{chunk-LUDBXTBJ.js → chunk-H272ZPQ3.js}

@@ -2,7 +2,7 @@ import {
   pathMayCarryEntityRefs,
   requestEntityCanonicalIdReconcile,
   withRawEntityPageMutation
-} from "./chunk-NNZFPYYX.js";
+} from "./chunk-R7QY5ZVB.js";
 import {
   bumpArchiveMutationForPath
 } from "./chunk-W5BIQOAJ.js";
@@ -12,7 +12,7 @@ import {
 import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex
-} from "./chunk-TVW4C7PV.js";
+} from "./chunk-NB3LRY4T.js";
 import {
   withHeldFileLock
 } from "./chunk-FFAZ2XFU.js";
@@ -22,13 +22,13 @@ import {
 import {
   readMaybeEncryptedFileFromChunks,
   writeMaybeEncryptedFileFromChunks
-} from "./chunk-ET2CNMLD.js";
+} from "./chunk-JN72EPOE.js";
 import {
   RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
 import {
   isErrnoCode
-} from "./chunk-5UZXUTVO.js";
+} from "./chunk-KNA3BXXL.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -1815,4 +1815,4 @@ export {
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-LUDBXTBJ.js.map
+//# sourceMappingURL=chunk-H272ZPQ3.js.map

package/dist/{chunk-SN4JXNLL.js → chunk-H3TKENU4.js}

@@ -1,7 +1,7 @@
 import {
   PROMOTION_CANDIDATES_DEFAULT_MIN_ACCESS,
   isSubjectGuardMode
-} from "./chunk-ME35HVDJ.js";
+} from "./chunk-VYCOJKSX.js";
 import {
   coerceBool,
   coerceNumber
@@ -52,4 +52,4 @@ function parseSubjectRuntimeConfig(cfg) {
 export {
   parseSubjectRuntimeConfig
 };
-//# sourceMappingURL=chunk-SN4JXNLL.js.map
+//# sourceMappingURL=chunk-H3TKENU4.js.map

package/dist/{chunk-4HYNMLT6.js → chunk-H4SEGIZY.js}

@@ -1,6 +1,6 @@
 import {
   runLocationSync
-} from "./chunk-ZJWDWPX6.js";
+} from "./chunk-X5K5TAQZ.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -58,4 +58,4 @@ export {
   LOCATION_SYNC_DEFAULT_INTERVAL_MS,
   startLocationAutoSync
 };
-//# sourceMappingURL=chunk-4HYNMLT6.js.map
+//# sourceMappingURL=chunk-H4SEGIZY.js.map

package/dist/{chunk-ACZN5ZXD.js → chunk-H54VWRPS.js}

@@ -3,7 +3,7 @@ import {
   readNamespaceMaintenanceLastRanStatuses,
   readNamespaceMaintenanceStatuses,
   runNamespaceMaintenancePlan
-} from "./chunk-3LADWWMA.js";
+} from "./chunk-SJDQ5RSN.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -14,7 +14,7 @@ import {
 } from "./chunk-CMTINOFS.js";
 import {
   summarizeCorpusAndReplica
-} from "./chunk-BR3OOQZQ.js";
+} from "./chunk-MWN6QEI2.js";
 import {
   readJudgeVerdictStats
 } from "./chunk-OZKOPQCM.js";
@@ -24,7 +24,7 @@ import {
   runEvalBaselineDeltaReport,
   runEvalBenchmarkCiGate,
   validateEvalBenchmarkPack
-} from "./chunk-MCA2X4WH.js";
+} from "./chunk-4IHBN6WU.js";
 import {
   resolveCuratedIncludeFilesStatePath,
   resolveNativeKnowledgeStatePath,
@@ -32,29 +32,29 @@ import {
 } from "./chunk-2DQ2XREU.js";
 import {
   runConsolidationProvenanceCheck
-} from "./chunk-DUAJKRR2.js";
+} from "./chunk-2SGLMP2E.js";
 import {
   reportBufferSurpriseDistribution
 } from "./chunk-YBPYIAA5.js";
 import {
   parseConfig
-} from "./chunk-FCATYKQA.js";
+} from "./chunk-2IOHTUP3.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-N7JK2RKG.js";
+} from "./chunk-EOQ6FSQP.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-NZGO2GKL.js";
+} from "./chunk-MY5EDR46.js";
 import {
   listNamespaces
-} from "./chunk-3LJPSRAN.js";
+} from "./chunk-RBCQVOVJ.js";
 import {
   analyzeGraphHealth
-} from "./chunk-OLT3YTDH.js";
+} from "./chunk-5FAGCOZD.js";
 import {
   StorageManager
-} from "./chunk-OGTKQ5MJ.js";
+} from "./chunk-XSGUMQQQ.js";
 import {
   lintWorkspaceFiles
 } from "./chunk-DM2T26WE.js";
@@ -1069,7 +1069,7 @@ async function summarizeBufferSurpriseDistribution(storage, config) {
   }
 }
 async function summarizeGraphEdgeDecayStatus(config) {
-  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-DGTBFALQ.js");
+  const { readGraphEdgeDecayStatus } = await import("./graph-edge-decay-MKIRZ762.js");
   const { graphEdgeDecayEnabled } = config;
   const enabled = graphEdgeDecayEnabled === true;
   if (!enabled) {
@@ -1109,7 +1109,7 @@ async function summarizeGraphEdgeDecayStatus(config) {
 }
 async function summarizeTierDistribution(storage) {
   try {
-    const { summarizeTiers } = await import("./tier-stats-2TOW3QNL.js");
+    const { summarizeTiers } = await import("./tier-stats-KA6OZX2C.js");
     const summary = await summarizeTiers(storage);
     const storageDir = storage.dir ?? "";
     const journalPath = storageDir.length > 0 ? path.join(storageDir, "state", "tier-migration-journal.jsonl") : null;
@@ -1683,4 +1683,4 @@ export {
   runBenchmarkRecall,
   runOperatorRepair
 };
-//# sourceMappingURL=chunk-ACZN5ZXD.js.map
+//# sourceMappingURL=chunk-H54VWRPS.js.map