@remnic/core 10.0.13 → 10.0.15

package/dist/{chunk-JUWJYXI4.js → chunk-5ATSXCAG.js}

@@ -7,10 +7,10 @@ import {
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-XERVJYH2.js";
+} from "./chunk-C6JMGAMO.js";
 import {
   StorageManager
-} from "./chunk-Y3VDGK2O.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -21,7 +21,7 @@ import {
   readProjectedGovernanceRows,
   readProjectedNativeKnowledgeRows,
   writeProjectionMetaHighWater
-} from "./chunk-FQD2KPQH.js";
+} from "./chunk-P55FACBG.js";
 import {
   MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
   buildLifecycleEventsForMemory,
@@ -1156,4 +1156,4 @@ export {
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-JUWJYXI4.js.map
+//# sourceMappingURL=chunk-5ATSXCAG.js.map

package/dist/{chunk-EHRE7ZG3.js → chunk-5B5WYAHQ.js}

@@ -1,6 +1,6 @@
 import {
   sleep
-} from "./chunk-7LEQREP2.js";
+} from "./chunk-PGRZ3FYC.js";
 
 // src/utils/serialize-mutations.ts
 import { randomUUID } from "crypto";
@@ -297,4 +297,4 @@ export {
   serializeMutations,
   withHeldFileLock
 };
-//# sourceMappingURL=chunk-EHRE7ZG3.js.map
+//# sourceMappingURL=chunk-5B5WYAHQ.js.map

package/dist/{chunk-WCGJK4NQ.js → chunk-5FNZ3G6X.js}

@@ -1,12 +1,3 @@
-import {
-  LcmDag
-} from "./chunk-7N4KAIGN.js";
-import {
-  LcmWorkQueue
-} from "./chunk-MMCO4SRG.js";
-import {
-  assembleCompressedHistoryWithTrace
-} from "./chunk-UXPUUL3G.js";
 import {
   ensureLcmStateDir,
   openLcmDatabase
@@ -17,6 +8,15 @@ import {
 import {
   LcmArchive
 } from "./chunk-WVP2I6C5.js";
+import {
+  LcmDag
+} from "./chunk-7N4KAIGN.js";
+import {
+  LcmWorkQueue
+} from "./chunk-MMCO4SRG.js";
+import {
+  assembleCompressedHistoryWithTrace
+} from "./chunk-UXPUUL3G.js";
 import {
   nativeBindingRecoveryHint
 } from "./chunk-LD72P4YS.js";
@@ -602,4 +602,4 @@ export {
   extractLcmConfig,
   LcmEngine
 };
-//# sourceMappingURL=chunk-WCGJK4NQ.js.map
+//# sourceMappingURL=chunk-5FNZ3G6X.js.map

package/dist/{chunk-Y6DZ33PA.js → chunk-5GX5457J.js}

@@ -1,16 +1,16 @@
 import {
   writeGraphJsonlAtomic
-} from "./chunk-QUNDYIYZ.js";
+} from "./chunk-YYEOR4XN.js";
 import {
   graphFilePath,
   graphsDir,
   readEdgesStrict
-} from "./chunk-BTJ6CAIA.js";
+} from "./chunk-4IYIGN53.js";
 import {
   assertGraphLockHeld,
   withGraphWriteLock,
   yieldForLockHeartbeat
-} from "./chunk-ZQ3WU6JO.js";
+} from "./chunk-RXFCU3CY.js";
 import {
   DEFAULT_DECAY_FLOOR,
   DEFAULT_DECAY_PER_WINDOW,
@@ -215,4 +215,4 @@ export {
   discoverGraphNamespaceRoots,
   runGraphEdgeDecayMaintenanceAcrossNamespaces
 };
-//# sourceMappingURL=chunk-Y6DZ33PA.js.map
+//# sourceMappingURL=chunk-5GX5457J.js.map

package/dist/{chunk-EMFBC7L3.js → chunk-5KGYTX5O.js}

@@ -1,6 +1,6 @@
 import {
   parseFrontmatter
-} from "./chunk-Y3VDGK2O.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   activityDigestPath,
   isValidActivityDate
@@ -199,4 +199,4 @@ export {
   buildStandup,
   standupHelp
 };
-//# sourceMappingURL=chunk-EMFBC7L3.js.map
+//# sourceMappingURL=chunk-5KGYTX5O.js.map

package/dist/{chunk-OFCHT2TN.js → chunk-5LRV557D.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-BT7NVCML.js";
 import {
   isMemorySubject
-} from "./chunk-VFTK5WKI.js";
+} from "./chunk-STBX5X6B.js";
 import {
   assemblePersistedBody
 } from "./chunk-JDSVLVCG.js";
@@ -443,4 +443,4 @@ export {
   buildAccessWriteRequestFingerprint,
   buildObserveRequestFingerprint
 };
-//# sourceMappingURL=chunk-OFCHT2TN.js.map
+//# sourceMappingURL=chunk-5LRV557D.js.map

package/dist/{chunk-DXHVD4DS.js → chunk-5SMR542T.js}

@@ -2,11 +2,11 @@ import {
   OFFLINE_SYNC_SNAPSHOT_FORMAT,
   filterOfflineSyncDeletionRevisions,
   iterateOfflineSyncSnapshotFileRecords
-} from "./chunk-MZBWIJJN.js";
+} from "./chunk-23ZQPP2G.js";
 import {
   computeOmittedEmbeddingGenerationPaths,
   embeddingGenerationMembership
-} from "./chunk-3NFN4Y4P.js";
+} from "./chunk-MGCKZWAE.js";
 import {
   matchesOfflineSyncDefaultExclude
 } from "./chunk-63LFM77Z.js";
@@ -61,4 +61,4 @@ async function buildEmbeddingAwareSnapshotStream(options) {
 export {
   buildEmbeddingAwareSnapshotStream
 };
-//# sourceMappingURL=chunk-DXHVD4DS.js.map
+//# sourceMappingURL=chunk-5SMR542T.js.map

package/dist/{chunk-S7LWX2PQ.js → chunk-655FVTCD.js}

@@ -1,6 +1,6 @@
 import {
   scanMemoryDir
-} from "./chunk-4O6WRBGE.js";
+} from "./chunk-KJXP6RUG.js";
 import {
   isSearchAborted,
   throwIfSearchAborted
@@ -508,4 +508,4 @@ function isMissingVectorProviderColumnError(err) {
 export {
   LanceDbBackend
 };
-//# sourceMappingURL=chunk-S7LWX2PQ.js.map
+//# sourceMappingURL=chunk-655FVTCD.js.map

package/dist/{chunk-DGRMWDQY.js → chunk-66BCOVW2.js}

@@ -1,6 +1,12 @@
 import {
   resolveEnsureCollectionArgs
 } from "./chunk-G26YNEOC.js";
+import {
+  QmdDaemonSession
+} from "./chunk-SWWHIJUJ.js";
+import {
+  createInflightJoiner
+} from "./chunk-TPSLVZHS.js";
 import {
   QMD_PROBE_RETRY_BACKOFF_MS,
   QMD_PROBE_TIMEOUT_MS,
@@ -19,12 +25,6 @@ import {
   embedQmdFiles,
   fetchQmdStatus
 } from "./chunk-IUM3VSHI.js";
-import {
-  QmdDaemonSession
-} from "./chunk-WVHRNAXL.js";
-import {
-  createInflightJoiner
-} from "./chunk-TPSLVZHS.js";
 import {
   clearQmdResultCaches,
   getCachedQmdSearch,
@@ -2028,4 +2028,4 @@ export {
   sharedDaemonSessionCountForTest,
   QmdClient
 };
-//# sourceMappingURL=chunk-DGRMWDQY.js.map
+//# sourceMappingURL=chunk-66BCOVW2.js.map

package/dist/chunk-6EDW54SQ.js

@@ -0,0 +1,298 @@
+import {
+  CAPTURE_WRITE_LOCK_BUSY_MESSAGE,
+  captureWriteLockDelayMs,
+  resolveCaptureWriteLockBackoffLimits
+} from "./chunk-YET735EZ.js";
+import {
+  withHeldFileLock
+} from "./chunk-5B5WYAHQ.js";
+import {
+  sleepAbortable
+} from "./chunk-PGRZ3FYC.js";
+import {
+  raceAbort,
+  throwIfAborted
+} from "./chunk-BTTPKDIL.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/storage/tombstone-blocked-capture-mutation.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash } from "crypto";
+import { mkdir } from "fs/promises";
+import path from "path";
+var TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS = 6e4;
+var CAPTURE_WRITE_LOCK_PROBE_MS = 1;
+var CAPTURE_WRITE_LOCK_RETRY = /* @__PURE__ */ Symbol("capture-write-lock-retry");
+var CAPTURE_WRITE_LOCK_PERMANENT = /* @__PURE__ */ Symbol("capture-write-lock-permanent-failure");
+function normalizeExplicitCaptureContent(value) {
+  return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function buildExplicitCaptureDedupKey(content, category, sourceConnector) {
+  const encode = (label, value) => `${label} ${value.length} ${value}`;
+  return [
+    encode("category", category),
+    encode("connector", sourceConnector?.trim() ?? ""),
+    encode("content", normalizeExplicitCaptureContent(content))
+  ].join(" ");
+}
+function buildCapturePathLockIdentity(pathname) {
+  return `path ${pathname.length} ${pathname}`;
+}
+function captureIdentityHash(memory) {
+  return createHash("sha256").update(
+    buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)
+  ).digest("hex");
+}
+var TombstoneBlockedCaptureWriteLock = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  context = new AsyncLocalStorage();
+  captureWriteLockPathForHash(identityHash) {
+    const filename = identityHash.length === 0 ? "explicit-capture-write.lock" : `explicit-capture-write-${identityHash}.lock`;
+    return path.join(this.options.stateDir, "tombstone-blocked-capture", filename);
+  }
+  now() {
+    return this.options.now?.() ?? Date.now();
+  }
+  debug(message) {
+    if (this.options.logDebug) {
+      this.options.logDebug(message);
+      return;
+    }
+    log.debug(message);
+  }
+  warn(message) {
+    if (this.options.logWarn) {
+      this.options.logWarn(message);
+      return;
+    }
+    log.warn(message);
+  }
+  /** Prefer the constructor seam; converge installs the signal on lock options at acquire time. */
+  captureAbortSignal() {
+    return this.options.signal ?? this.options.lockOptions?.()?.captureWriteLockSignal;
+  }
+  /**
+   * One probe of a single lock file. Returns the retry symbol when the lock
+   * is busy and the permanent symbol on a filesystem error. Does not sleep:
+   * the caller backs off only after the whole chain has unwound.
+   */
+  async withSingleCaptureWriteLockOnce(lockPath, task) {
+    await mkdir(path.dirname(lockPath), { recursive: true });
+    const runWithHeldFileLock = this.options.withHeldFileLock ?? withHeldFileLock;
+    return await runWithHeldFileLock(
+      lockPath,
+      {
+        staleMs: TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS,
+        maxWaitMs: CAPTURE_WRITE_LOCK_PROBE_MS,
+        pollMs: CAPTURE_WRITE_LOCK_PROBE_MS
+      },
+      async (acquired, controller) => {
+        if (acquired) return await task();
+        return controller.failure === "error" ? CAPTURE_WRITE_LOCK_PERMANENT : CAPTURE_WRITE_LOCK_RETRY;
+      }
+    );
+  }
+  async withPhysicalCaptureWriteLocks(task, identityHashes) {
+    const signal = this.captureAbortSignal();
+    const lockPaths = [...new Set(identityHashes.map((hash) => this.captureWriteLockPathForHash(hash)))];
+    const limits = resolveCaptureWriteLockBackoffLimits(this.options.lockOptions?.());
+    const deadline = this.now() + limits.deadlineMs;
+    const giveUp = () => {
+      throwIfAborted(signal);
+      this.warn(
+        `tombstone-blocked capture write lock remained busy after ${limits.deadlineMs}ms; failing this write so the rest of the cycle can continue`
+      );
+      throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);
+    };
+    const acquire = async (index) => {
+      throwIfAborted(signal);
+      const runTask = async () => {
+        if (this.now() >= deadline) giveUp();
+        return await task();
+      };
+      if (index === lockPaths.length) return await runTask();
+      const lockPath = lockPaths[index];
+      if (lockPath === void 0) return await runTask();
+      if (this.now() >= deadline) giveUp();
+      return await this.withSingleCaptureWriteLockOnce(lockPath, () => acquire(index + 1));
+    };
+    for (let attempt = 0; ; attempt += 1) {
+      throwIfAborted(signal);
+      const outcome = await acquire(0);
+      if (outcome === CAPTURE_WRITE_LOCK_PERMANENT) {
+        throw new Error("tombstone-blocked capture write lock acquisition failed");
+      }
+      if (outcome !== CAPTURE_WRITE_LOCK_RETRY) return outcome;
+      throwIfAborted(signal);
+      const now = this.now();
+      if (now >= deadline) giveUp();
+      const delay = Math.min(
+        captureWriteLockDelayMs(attempt, limits, this.options.random ?? Math.random),
+        deadline - now
+      );
+      if (delay <= 0) giveUp();
+      this.debug(`tombstone-blocked capture write lock busy; backing off ${delay}ms before retry ${attempt + 1}`);
+      await raceAbort((this.options.sleep ?? sleepAbortable)(delay, signal), signal);
+    }
+  }
+  async withCaptureWriteLock(task, identity) {
+    const identities = Array.isArray(identity) && identity.length > 0 ? identity : [typeof identity === "string" ? identity : ""];
+    return await this.withCaptureWriteLocks(task, identities, []);
+  }
+  async withCaptureWriteLockHashes(task, identityHashes) {
+    return await this.withCaptureWriteLocks(task, [], identityHashes);
+  }
+  async withCaptureWriteLockAndHashes(task, identity, identityHashes) {
+    const identities = Array.isArray(identity) && identity.length > 0 ? identity : [typeof identity === "string" ? identity : ""];
+    return await this.withCaptureWriteLocks(task, identities, identityHashes);
+  }
+  async withCaptureWriteLocks(task, identities, identityHashes) {
+    throwIfAborted(this.captureAbortSignal());
+    const current = this.context.getStore();
+    const hashToken = (key) => `\0${key.length === 0 ? "" : createHash("sha256").update(key).digest("hex")}`;
+    const identityHash = (key) => key.length === 0 ? "" : createHash("sha256").update(key).digest("hex");
+    const identityKeys = [...new Set(identities)];
+    const hashes = [...new Set(identityHashes)];
+    const requested = [
+      ...identityKeys.filter((key) => !current || !current.has(key) && !current.has(hashToken(key))).map((key) => ({ hash: identityHash(key), pathLock: key.startsWith("path ") })),
+      ...hashes.filter((hash) => !current || !current.has(`\0${hash}`)).map((hash) => ({ hash, pathLock: false }))
+    ].filter((entry, index, entries) => entries.findIndex((candidate) => candidate.hash === entry.hash) === index).sort(
+      (left, right) => Number(left.pathLock) - Number(right.pathLock) || this.captureWriteLockPathForHash(left.hash).localeCompare(this.captureWriteLockPathForHash(right.hash))
+    );
+    const physicalMissing = requested.map((entry) => entry.hash);
+    if (current && requested.length > 0) {
+      const held = [...current].filter((token) => token.startsWith("\0")).map((token) => {
+        const hash = token.slice(1);
+        const pathLock = [...current].some(
+          (key) => !key.startsWith("\0") && key.startsWith("path ") && hashToken(key) === token
+        );
+        return { hash, pathLock };
+      });
+      const requestedFirst = requested[0];
+      const heldLast = held.sort(
+        (left, right) => Number(left.pathLock) - Number(right.pathLock) || this.captureWriteLockPathForHash(left.hash).localeCompare(this.captureWriteLockPathForHash(right.hash))
+      ).at(-1);
+      if (heldLast && requestedFirst && (Number(requestedFirst.pathLock) < Number(heldLast.pathLock) || requestedFirst.pathLock === heldLast.pathLock && this.captureWriteLockPathForHash(requestedFirst.hash) < this.captureWriteLockPathForHash(heldLast.hash))) {
+        throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);
+      }
+    }
+    const next = new Set(current);
+    for (const key of identityKeys) {
+      next.add(key);
+      next.add(hashToken(key));
+    }
+    for (const hash of hashes) next.add(`\0${hash}`);
+    const run = () => {
+      throwIfAborted(this.captureAbortSignal());
+      return this.context.run(next, task);
+    };
+    if (physicalMissing.length === 0) return await run();
+    return await this.withPhysicalCaptureWriteLocks(run, physicalMissing);
+  }
+};
+async function runTombstoneBlockedMutation(host, mutation) {
+  let lockIdentity = mutation.identity;
+  for (; ; ) {
+    let retryIdentity;
+    let mintedRevision;
+    const mutate = async () => {
+      const current = await host.readCurrent();
+      const currentBlocked = host.isBlocked(current);
+      const currentQueuedReview = host.isQueuedReview(current);
+      if (current !== null && (mutation.coordinate === true || currentBlocked || currentQueuedReview)) {
+        const currentIdentity = host.memoryIdentity(current);
+        const heldIdentities = Array.isArray(lockIdentity) ? lockIdentity : [lockIdentity];
+        if (!heldIdentities.includes(currentIdentity)) {
+          retryIdentity = currentIdentity;
+          return;
+        }
+      }
+      const rebuildMarker = mutation.blocked || currentBlocked ? await host.prepareWrite() : void 0;
+      const discardRebuildMarker = async () => {
+        if (!rebuildMarker) return;
+        try {
+          await host.discardWrite(rebuildMarker);
+        } catch (cleanupError) {
+          host.markUntrusted();
+          host.logWarning(`storage.tombstoneBlocked failed to clear write marker: ${cleanupError}`);
+        }
+      };
+      let transaction;
+      try {
+        transaction = mutation.shouldMintRevision?.(current) ? await host.beginDurableMemoryRevision?.(mutation.pathname, mutation.fileContent) : void 0;
+        await host.writeStorageSecureFile(mutation.pathname, mutation.fileContent);
+      } catch (err) {
+        if (transaction) {
+          try {
+            await transaction.abort();
+          } catch (abortError) {
+            host.logWarning(
+              `storage.tombstoneBlocked failed to abort the reserved receipt (pending marker preserved): ${abortError}`
+            );
+          }
+        }
+        await discardRebuildMarker();
+        throw err;
+      }
+      if (transaction) {
+        try {
+          await transaction.writeLanded();
+        } catch (evidenceError) {
+          host.logWarning(
+            `storage.tombstoneBlocked failed to record receipt crash evidence (pending marker preserved): ${evidenceError}`
+          );
+        }
+        try {
+          await transaction.commit();
+        } catch (err) {
+          host.logWarning(
+            `storage.tombstoneBlocked receipt publication failed after the memory write (pending marker preserved for recovery): ${err}`
+          );
+          await discardRebuildMarker();
+          throw err;
+        }
+      }
+      mintedRevision = transaction?.pendingRevision;
+      if (rebuildMarker) {
+        try {
+          await host.commitWrite(rebuildMarker);
+        } catch (err) {
+          host.markUntrusted();
+          host.logWarning(`storage.tombstoneBlocked committed write marker failed: ${err}`);
+        }
+      }
+      if (rebuildMarker) await mutation.beforeIndexUpdate?.();
+      await mutation.updateIndex(rebuildMarker, currentBlocked && current !== null ? current : void 0);
+    };
+    await host.withCaptureWriteLock(mutate, lockIdentity);
+    if (retryIdentity === void 0) return mintedRevision;
+    const identities = Array.isArray(lockIdentity) ? [...lockIdentity, retryIdentity] : [lockIdentity, retryIdentity];
+    lockIdentity = [...new Set(identities)];
+  }
+}
+function tombstoneBlocked(frontmatter) {
+  return frontmatter.status === "pending_review" && Boolean(frontmatter.blockedBy);
+}
+function isQueuedReviewFrontmatter(frontmatter) {
+  return frontmatter.status === "pending_review" && (frontmatter.tags ?? []).includes("queued-review");
+}
+function isQueuedReviewMemory(memory) {
+  return memory !== null && isQueuedReviewFrontmatter(memory.frontmatter);
+}
+
+export {
+  normalizeExplicitCaptureContent,
+  buildExplicitCaptureDedupKey,
+  buildCapturePathLockIdentity,
+  captureIdentityHash,
+  TombstoneBlockedCaptureWriteLock,
+  runTombstoneBlockedMutation,
+  tombstoneBlocked,
+  isQueuedReviewMemory
+};
+//# sourceMappingURL=chunk-6EDW54SQ.js.map

package/dist/chunk-6EDW54SQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/storage/tombstone-blocked-capture-mutation.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"node:async_hooks\";\nimport { createHash } from \"node:crypto\";\nimport { mkdir } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { raceAbort, throwIfAborted } from \"../abort-error.js\";\nimport {\n  CAPTURE_WRITE_LOCK_BUSY_MESSAGE,\n  type CaptureWriteLockLimitSource,\n  captureWriteLockDelayMs,\n  resolveCaptureWriteLockBackoffLimits,\n} from \"../capture-write-lock-backoff.js\";\nimport { log } from \"../logger.js\";\nimport type { MemoryFile, MemoryFrontmatter } from \"../types.js\";\nimport { withHeldFileLock } from \"../utils/serialize-mutations.js\";\nimport { sleepAbortable } from \"../utils/sleep.js\";\nimport type { CasRevisionTransaction } from \"./cas-revision-store.js\";\n\nexport { isTombstoneBlockedCaptureWriteLockBusy } from \"../capture-write-lock-backoff.js\";\n\nconst TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS = 60_000;\n/**\n * One exclusive-create probe. The bounded wait lives in the outer backoff,\n * which runs only after every lock from this attempt has been released.\n * A multi-second poll here would hold an already-acquired sibling lock.\n */\nconst CAPTURE_WRITE_LOCK_PROBE_MS = 1;\nconst CAPTURE_WRITE_LOCK_RETRY = Symbol(\"capture-write-lock-retry\");\nconst CAPTURE_WRITE_LOCK_PERMANENT = Symbol(\"capture-write-lock-permanent-failure\");\n\nexport function normalizeExplicitCaptureContent(value: string): string {\n  return value.toLowerCase().replace(/\\s+/g, \" \").trim();\n}\n\nexport function buildExplicitCaptureDedupKey(\n  content: string,\n  category: string,\n  sourceConnector: string | undefined\n): string {\n  const encode = (label: string, value: string): string => `${label} ${value.length} ${value}`;\n  return [\n    encode(\"category\", category),\n    encode(\"connector\", sourceConnector?.trim() ?? \"\"),\n    encode(\"content\", normalizeExplicitCaptureContent(content)),\n  ].join(\" \");\n}\n\nexport function buildCapturePathLockIdentity(pathname: string): string {\n  return `path ${pathname.length} ${pathname}`;\n}\n\nexport function captureIdentityHash(memory: MemoryFile): string {\n  return createHash(\"sha256\")\n    .update(\n      buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)\n    )\n    .digest(\"hex\");\n}\n\nexport type TombstoneBlockedCaptureWriteLockOptions = {\n  readonly stateDir: string;\n  readonly withHeldFileLock?: typeof withHeldFileLock;\n  /** Read when an acquire starts, after the caller has installed converge config. */\n  readonly lockOptions?: () => CaptureWriteLockLimitSource | undefined;\n  readonly now?: () => number;\n  readonly random?: () => number;\n  readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;\n  readonly logDebug?: (message: string) => void;\n  readonly logWarn?: (message: string) => void;\n  /** Direct seam. Converge passes the same signal through `lockOptions` instead. */\n  readonly signal?: AbortSignal;\n};\n\nexport class TombstoneBlockedCaptureWriteLock {\n  private readonly context = new AsyncLocalStorage<ReadonlySet<string>>();\n\n  constructor(private readonly options: TombstoneBlockedCaptureWriteLockOptions) {}\n\n  private captureWriteLockPathForHash(identityHash: string): string {\n    const filename =\n      identityHash.length === 0 ? \"explicit-capture-write.lock\" : `explicit-capture-write-${identityHash}.lock`;\n    return path.join(this.options.stateDir, \"tombstone-blocked-capture\", filename);\n  }\n\n  private now(): number {\n    return this.options.now?.() ?? Date.now();\n  }\n\n  private debug(message: string): void {\n    if (this.options.logDebug) {\n      this.options.logDebug(message);\n      return;\n    }\n    log.debug(message);\n  }\n\n  private warn(message: string): void {\n    if (this.options.logWarn) {\n      this.options.logWarn(message);\n      return;\n    }\n    log.warn(message);\n  }\n\n  /** Prefer the constructor seam; converge installs the signal on lock options at acquire time. */\n  private captureAbortSignal(): AbortSignal | undefined {\n    return this.options.signal ?? this.options.lockOptions?.()?.captureWriteLockSignal;\n  }\n\n  /**\n   * One probe of a single lock file. Returns the retry symbol when the lock\n   * is busy and the permanent symbol on a filesystem error. Does not sleep:\n   * the caller backs off only after the whole chain has unwound.\n   */\n  private async withSingleCaptureWriteLockOnce<T>(\n    lockPath: string,\n    task: () => Promise<T | typeof CAPTURE_WRITE_LOCK_RETRY>\n  ): Promise<T | typeof CAPTURE_WRITE_LOCK_RETRY | typeof CAPTURE_WRITE_LOCK_PERMANENT> {\n    await mkdir(path.dirname(lockPath), { recursive: true });\n    const runWithHeldFileLock = this.options.withHeldFileLock ?? withHeldFileLock;\n    return await runWithHeldFileLock(\n      lockPath,\n      {\n        staleMs: TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS,\n        maxWaitMs: CAPTURE_WRITE_LOCK_PROBE_MS,\n        pollMs: CAPTURE_WRITE_LOCK_PROBE_MS,\n      },\n      async (acquired, controller) => {\n        if (acquired) return await task();\n        return controller.failure === \"error\" ? CAPTURE_WRITE_LOCK_PERMANENT : CAPTURE_WRITE_LOCK_RETRY;\n      }\n    );\n  }\n\n  private async withPhysicalCaptureWriteLocks<T>(\n    task: () => Promise<T>,\n    identityHashes: readonly string[]\n  ): Promise<T> {\n    const signal = this.captureAbortSignal();\n    const lockPaths = [...new Set(identityHashes.map((hash) => this.captureWriteLockPathForHash(hash)))];\n    const limits = resolveCaptureWriteLockBackoffLimits(this.options.lockOptions?.());\n    const deadline = this.now() + limits.deadlineMs;\n    const giveUp = (): never => {\n      throwIfAborted(signal);\n      this.warn(\n        `tombstone-blocked capture write lock remained busy after ${limits.deadlineMs}ms; failing this write so the rest of the cycle can continue`\n      );\n      throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);\n    };\n    const acquire = async (\n      index: number\n    ): Promise<T | typeof CAPTURE_WRITE_LOCK_RETRY | typeof CAPTURE_WRITE_LOCK_PERMANENT> => {\n      throwIfAborted(signal);\n      // The deadline gates each probe: a chain that started before the\n      // deadline must not keep probing locks (or run the write) after it.\n      const runTask = async (): Promise<T> => {\n        if (this.now() >= deadline) giveUp();\n        return await task();\n      };\n      if (index === lockPaths.length) return await runTask();\n      const lockPath = lockPaths[index];\n      if (lockPath === undefined) return await runTask();\n      if (this.now() >= deadline) giveUp();\n      return await this.withSingleCaptureWriteLockOnce(lockPath, () => acquire(index + 1));\n    };\n    for (let attempt = 0; ; attempt += 1) {\n      throwIfAborted(signal);\n      const outcome = await acquire(0);\n      if (outcome === CAPTURE_WRITE_LOCK_PERMANENT) {\n        throw new Error(\"tombstone-blocked capture write lock acquisition failed\");\n      }\n      if (outcome !== CAPTURE_WRITE_LOCK_RETRY) return outcome;\n      throwIfAborted(signal);\n      const now = this.now();\n      if (now >= deadline) giveUp();\n      const delay = Math.min(\n        captureWriteLockDelayMs(attempt, limits, this.options.random ?? Math.random),\n        deadline - now\n      );\n      if (delay <= 0) giveUp();\n      this.debug(`tombstone-blocked capture write lock busy; backing off ${delay}ms before retry ${attempt + 1}`);\n      // raceAbort covers seam sleeps that ignore the signal; the default\n      // sleepAbortable also clears its timer so abort holds no Timeout.\n      await raceAbort((this.options.sleep ?? sleepAbortable)(delay, signal), signal);\n    }\n  }\n\n  async withCaptureWriteLock<T>(task: () => Promise<T>, identity?: string | readonly string[]): Promise<T> {\n    const identities =\n      Array.isArray(identity) && identity.length > 0 ? identity : [typeof identity === \"string\" ? identity : \"\"];\n    return await this.withCaptureWriteLocks(task, identities, []);\n  }\n\n  async withCaptureWriteLockHashes<T>(task: () => Promise<T>, identityHashes: readonly string[]): Promise<T> {\n    return await this.withCaptureWriteLocks(task, [], identityHashes);\n  }\n\n  async withCaptureWriteLockAndHashes<T>(\n    task: () => Promise<T>,\n    identity: string | readonly string[] | undefined,\n    identityHashes: readonly string[]\n  ): Promise<T> {\n    const identities =\n      Array.isArray(identity) && identity.length > 0 ? identity : [typeof identity === \"string\" ? identity : \"\"];\n    return await this.withCaptureWriteLocks(task, identities, identityHashes);\n  }\n\n  private async withCaptureWriteLocks<T>(\n    task: () => Promise<T>,\n    identities: readonly string[],\n    identityHashes: readonly string[]\n  ): Promise<T> {\n    throwIfAborted(this.captureAbortSignal());\n    const current = this.context.getStore();\n    const hashToken = (key: string): string =>\n      `\\u0000${key.length === 0 ? \"\" : createHash(\"sha256\").update(key).digest(\"hex\")}`;\n    const identityHash = (key: string): string =>\n      key.length === 0 ? \"\" : createHash(\"sha256\").update(key).digest(\"hex\");\n    const identityKeys = [...new Set(identities)];\n    const hashes = [...new Set(identityHashes)];\n    const requested = [\n      ...identityKeys\n        .filter((key) => !current || (!current.has(key) && !current.has(hashToken(key))))\n        .map((key) => ({ hash: identityHash(key), pathLock: key.startsWith(\"path \") })),\n      ...hashes.filter((hash) => !current || !current.has(`\\u0000${hash}`)).map((hash) => ({ hash, pathLock: false })),\n    ]\n      .filter((entry, index, entries) => entries.findIndex((candidate) => candidate.hash === entry.hash) === index)\n      .sort(\n        (left, right) =>\n          Number(left.pathLock) - Number(right.pathLock) ||\n          this.captureWriteLockPathForHash(left.hash).localeCompare(this.captureWriteLockPathForHash(right.hash))\n      );\n    const physicalMissing = requested.map((entry) => entry.hash);\n    if (current && requested.length > 0) {\n      const held = [...current]\n        .filter((token) => token.startsWith(\"\\u0000\"))\n        .map((token) => {\n          const hash = token.slice(1);\n          const pathLock = [...current].some(\n            (key) => !key.startsWith(\"\\u0000\") && key.startsWith(\"path \") && hashToken(key) === token\n          );\n          return { hash, pathLock };\n        });\n      const requestedFirst = requested[0];\n      const heldLast = held\n        .sort(\n          (left, right) =>\n            Number(left.pathLock) - Number(right.pathLock) ||\n            this.captureWriteLockPathForHash(left.hash).localeCompare(this.captureWriteLockPathForHash(right.hash))\n        )\n        .at(-1);\n      if (\n        heldLast &&\n        requestedFirst &&\n        (Number(requestedFirst.pathLock) < Number(heldLast.pathLock) ||\n          (requestedFirst.pathLock === heldLast.pathLock &&\n            this.captureWriteLockPathForHash(requestedFirst.hash) < this.captureWriteLockPathForHash(heldLast.hash)))\n      ) {\n        throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);\n      }\n    }\n    const next = new Set(current);\n    for (const key of identityKeys) {\n      next.add(key);\n      next.add(hashToken(key));\n    }\n    for (const hash of hashes) next.add(`\\u0000${hash}`);\n    const run = () => {\n      throwIfAborted(this.captureAbortSignal());\n      return this.context.run(next, task);\n    };\n    if (physicalMissing.length === 0) return await run();\n    return await this.withPhysicalCaptureWriteLocks(run, physicalMissing);\n  }\n}\n\nexport type TombstoneBlockedMutationHost = {\n  readCurrent: () => Promise<MemoryFile | null>;\n  isBlocked: (memory: MemoryFile | null) => boolean;\n  isQueuedReview: (memory: MemoryFile | null) => boolean;\n  memoryIdentity: (memory: MemoryFile) => string;\n  prepareWrite: () => Promise<string>;\n  commitWrite: (marker: string) => Promise<void>;\n  discardWrite: (marker: string) => Promise<void>;\n  markUntrusted: () => void;\n  writeStorageSecureFile: (pathname: string, fileContent: string) => Promise<void>;\n  withCaptureWriteLock: (task: () => Promise<void>, identity: string | readonly string[]) => Promise<void>;\n  logWarning: (message: string) => void;\n  beginDurableMemoryRevision?: (\n    pathname: string,\n    expectedContent?: string | Buffer | null\n  ) => Promise<CasRevisionTransaction | undefined>;\n};\n\nexport type TombstoneBlockedMutation = {\n  blocked: boolean;\n  pathname: string;\n  fileContent: string;\n  identity: string | readonly string[];\n  updateIndex: (rebuildMarker?: string, current?: MemoryFile | null) => Promise<void>;\n  beforeIndexUpdate?: () => Promise<void>;\n  coordinate?: boolean;\n  shouldMintRevision?: (current: MemoryFile | null) => boolean;\n};\n\nexport async function runTombstoneBlockedMutation(\n  host: TombstoneBlockedMutationHost,\n  mutation: TombstoneBlockedMutation\n): Promise<string | undefined> {\n  let lockIdentity: string | readonly string[] = mutation.identity;\n  for (;;) {\n    let retryIdentity: string | undefined;\n    let mintedRevision: string | undefined;\n    const mutate = async (): Promise<void> => {\n      const current = await host.readCurrent();\n      const currentBlocked = host.isBlocked(current);\n      const currentQueuedReview = host.isQueuedReview(current);\n      if (current !== null && (mutation.coordinate === true || currentBlocked || currentQueuedReview)) {\n        const currentIdentity = host.memoryIdentity(current);\n        const heldIdentities = Array.isArray(lockIdentity) ? lockIdentity : [lockIdentity];\n        if (!heldIdentities.includes(currentIdentity)) {\n          retryIdentity = currentIdentity;\n          return;\n        }\n      }\n      const rebuildMarker = mutation.blocked || currentBlocked ? await host.prepareWrite() : undefined;\n      const discardRebuildMarker = async (): Promise<void> => {\n        if (!rebuildMarker) return;\n        try {\n          await host.discardWrite(rebuildMarker);\n        } catch (cleanupError) {\n          host.markUntrusted();\n          host.logWarning(`storage.tombstoneBlocked failed to clear write marker: ${cleanupError}`);\n        }\n      };\n      let transaction: CasRevisionTransaction | undefined;\n      try {\n        // #2813 (P1 C): a two-phase receipt transaction under this same\n        // path lock. The PENDING reservation is minted BEFORE the durable\n        // file publish, so a failed reservation leaves the memory file\n        // untouched — never a mutated record without a receipt. The\n        // COMMITTED receipt publishes only AFTER the write lands, so a\n        // failed write can never leave the reservation posing as\n        // ownership.\n        transaction = mutation.shouldMintRevision?.(current)\n          ? await host.beginDurableMemoryRevision?.(mutation.pathname, mutation.fileContent)\n          : undefined;\n        await host.writeStorageSecureFile(mutation.pathname, mutation.fileContent);\n      } catch (err) {\n        // The memory write failed (or never ran): abort the reservation so\n        // no pending marker survives a write that did not land. A failed\n        // abort keeps the marker — ambiguity, recovered later.\n        if (transaction) {\n          try {\n            await transaction.abort();\n          } catch (abortError) {\n            host.logWarning(\n              `storage.tombstoneBlocked failed to abort the reserved receipt (pending marker preserved): ${abortError}`\n            );\n          }\n        }\n        await discardRebuildMarker();\n        throw err;\n      }\n      if (transaction) {\n        // #2807: record the post-write fingerprint in the PENDING marker\n        // BEFORE publishing, so a crash between the durable write and the\n        // COMMITTED receipt is decisively recoverable. The evidence only\n        // guards that crash window — a recording failure must not fail the\n        // landed write, so commit still runs and publishes truthfully.\n        try {\n          await transaction.writeLanded();\n        } catch (evidenceError) {\n          host.logWarning(\n            `storage.tombstoneBlocked failed to record receipt crash evidence (pending marker preserved): ${evidenceError}`\n          );\n        }\n        try {\n          await transaction.commit();\n        } catch (err) {\n          // #2813 (P1 C): the memory file LANDED but the COMMITTED receipt\n          // never published. The PENDING marker stays: readers must see\n          // unavailable/recovery-needed — never ownership, never absence —\n          // and promotion/rollback refuse until recovery reconciles. The\n          // reservation must NOT be aborted: the write is on disk.\n          host.logWarning(\n            `storage.tombstoneBlocked receipt publication failed after the memory write (pending marker preserved for recovery): ${err}`\n          );\n          await discardRebuildMarker();\n          throw err;\n        }\n      }\n      mintedRevision = transaction?.pendingRevision;\n      if (rebuildMarker) {\n        try {\n          await host.commitWrite(rebuildMarker);\n        } catch (err) {\n          host.markUntrusted();\n          host.logWarning(`storage.tombstoneBlocked committed write marker failed: ${err}`);\n        }\n      }\n      if (rebuildMarker) await mutation.beforeIndexUpdate?.();\n      await mutation.updateIndex(rebuildMarker, currentBlocked && current !== null ? current : undefined);\n    };\n\n    await host.withCaptureWriteLock(mutate, lockIdentity);\n    if (retryIdentity === undefined) return mintedRevision;\n    const identities = Array.isArray(lockIdentity) ? [...lockIdentity, retryIdentity] : [lockIdentity, retryIdentity];\n    lockIdentity = [...new Set(identities)];\n  }\n}\n\nexport function tombstoneBlocked(frontmatter: MemoryFrontmatter): boolean {\n  return frontmatter.status === \"pending_review\" && Boolean(frontmatter.blockedBy);\n}\n\nexport function isQueuedReviewFrontmatter(frontmatter: MemoryFrontmatter): boolean {\n  return frontmatter.status === \"pending_review\" && (frontmatter.tags ?? []).includes(\"queued-review\");\n}\n\nexport function isQueuedReviewMemory(memory: MemoryFile | null): memory is MemoryFile {\n  return memory !== null && isQueuedReviewFrontmatter(memory.frontmatter);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-5MDM7UE4.js → chunk-6WGMZQGG.js}

@@ -1,6 +1,6 @@
 import {
   getOperation
-} from "./chunk-3J5JKBYD.js";
+} from "./chunk-XLBFX63V.js";
 import {
   EngramAccessInputError
 } from "./chunk-3MUKQQ7A.js";
@@ -21,4 +21,4 @@ async function respondBriefingHttp(options) {
 export {
   respondBriefingHttp
 };
-//# sourceMappingURL=chunk-5MDM7UE4.js.map
+//# sourceMappingURL=chunk-6WGMZQGG.js.map