@remnic/core 9.29.0 → 9.30.0

package/dist/chunk-FBUE6PD3.js

@@ -0,0 +1,1769 @@
+import {
+  withHeldFileLock
+} from "./chunk-FFAZ2XFU.js";
+import {
+  markProjectedMemoryPathInvalid
+} from "./chunk-3CSX3ETE.js";
+import {
+  computeContentHash,
+  normalizeContent
+} from "./chunk-W5H6ZRPT.js";
+import {
+  SecureStoreLockedError,
+  readMaybeEncryptedFile,
+  readMaybeEncryptedFileFromChunks,
+  writeMaybeEncryptedFile,
+  writeMaybeEncryptedFileFromChunks
+} from "./chunk-5TFP4CUL.js";
+import {
+  isErrnoCode
+} from "./chunk-5UZXUTVO.js";
+import {
+  RECALL_FALLBACK_DIRS
+} from "./chunk-VS2IYZRU.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/storage/content-hash-index.ts
+import { mkdir, stat } from "fs/promises";
+import path from "path";
+var CONTENT_HASH_INDEX_LOCK_STALE_MS = 3e4;
+var CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS = 5;
+var CONTENT_HASH_INDEX_RETRY_BASE_MS = 500;
+var CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS = 5e3;
+var FactHashIndexNotAuthoritativeError = class extends Error {
+  constructor(stateDir) {
+    super(
+      `fact-hash index is not authoritative: the cross-process rebuild lock for ${stateDir} could not be acquired within the bounded retry budget`
+    );
+    this.name = "FactHashIndexNotAuthoritativeError";
+  }
+};
+var ContentHashIndex = class _ContentHashIndex {
+  hashes = /* @__PURE__ */ new Set();
+  dirty = false;
+  /**
+   * Hashes explicitly removed since the last successful save (issue #1909 review
+   * round 8 thread 3). Tracked separately so `saveMergingWithDisk` can be
+   * removal-AWARE: under the file lock it reads the latest on-disk set, DROPS
+   * these, then unions our additions — so a removal batch cannot resurrect a
+   * hash (union alone would) and cannot clobber a concurrent extraction's
+   * appended hash (blind overwrite would). Consumed + cleared by every save.
+   */
+  removed = /* @__PURE__ */ new Set();
+  /**
+   * Hashes added by THIS instance since the last successful save (issue #1909
+   * review round 9 finding 3). Tracked separately from the loaded snapshot so a
+   * reconciling save publishes `(on-disk \ removed) ∪ added` — it re-applies only
+   * OUR additions, never the stale loaded entries. Without this, seeding the
+   * merge from `this.hashes` (loaded ∪ added) would resurrect a hash a peer
+   * removed on disk while this instance held a stale snapshot.
+   */
+  added = /* @__PURE__ */ new Set();
+  filePath;
+  secureStoreKeyProvider;
+  secureStoreWriteKeyProvider;
+  memoryDir;
+  lockOptions;
+  /**
+   * Deferred reconcile-save durable-retry state (issue #1909 / PR #2016). At
+   * most ONE retry is ever armed (`reconcileRetryTimer` is the reentrancy guard)
+   * so successive timed-out saves cannot stack duplicate/parallel retries.
+   * `reconcileRetryBarrier` resolves when the chain settles (published or gave
+   * up) — awaited by tests and any caller wanting the eventual result.
+   */
+  reconcileRetryTimer = null;
+  reconcileRetryAttempts = 0;
+  reconcileRetryBarrier = null;
+  reconcileRetryResolve = null;
+  /**
+   * On-disk fingerprint captured at the last point THIS instance's in-memory
+   * set matched disk — after `load()`, `save()`, or a reconcile publish. A peer
+   * process that advances the durable index changes its file generation even
+   * when byte size and mtime collide, so the freshness check remains safe
+   * without an O(file-size) read on the hot path.
+   */
+  lastSyncedFingerprint = null;
+  constructor(stateDir, secureStoreKeyProvider = () => null, secureStoreWriteKeyProvider = secureStoreKeyProvider, memoryDir = path.dirname(stateDir), lockOptions = {}) {
+    this.filePath = path.join(stateDir, "fact-hashes.txt");
+    this.secureStoreKeyProvider = secureStoreKeyProvider;
+    this.secureStoreWriteKeyProvider = secureStoreWriteKeyProvider;
+    this.memoryDir = memoryDir;
+    this.lockOptions = lockOptions;
+  }
+  /** Load existing hashes from disk. Safe to call multiple times. */
+  async load() {
+    try {
+      const raw = await readMaybeEncryptedFile(this.filePath, this.secureStoreKeyProvider(), this.memoryDir);
+      for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+          this.hashes.add(trimmed);
+        }
+      }
+      log.debug(`content-hash index: loaded ${this.hashes.size} hashes`);
+    } catch (err) {
+      if (err instanceof SecureStoreLockedError) throw err;
+      if (!isErrnoCode(err, "ENOENT")) throw err;
+      log.debug("content-hash index: no existing index \u2014 starting fresh");
+    }
+    await this.captureSyncedFingerprint();
+  }
+  /** Cheap `stat` of the durable index file; null when it does not exist yet. */
+  async statIndexFile() {
+    try {
+      const s = await stat(this.filePath);
+      return {
+        mtimeMs: s.mtimeMs,
+        size: s.size,
+        dev: s.dev,
+        ino: s.ino,
+        ctimeMs: s.ctimeMs,
+        birthtimeMs: s.birthtimeMs
+      };
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) return null;
+      throw err;
+    }
+  }
+  /** Record the current on-disk fingerprint as this instance's synced baseline. */
+  async captureSyncedFingerprint() {
+    try {
+      this.lastSyncedFingerprint = await this.statIndexFile();
+    } catch (err) {
+      this.lastSyncedFingerprint = null;
+      log.debug(`content-hash index: could not fingerprint ${this.filePath}: ${err}`);
+    }
+  }
+  /**
+   * True when the durable index file is unchanged since this instance last
+   * synced it (load / save / reconcile). False when a peer advanced it, when
+   * the file appeared or vanished, or when freshness cannot be established
+   * (stat error) — the caller then treats the in-memory snapshot as
+   * non-authoritative and confirms a dedup miss against the durable corpus.
+   * The stat includes file identity and generation metadata so same-size,
+   * same-mtime atomic replacements are detected without reading the file body.
+   */
+  async isDiskFingerprintCurrent() {
+    let current;
+    try {
+      current = await this.statIndexFile();
+    } catch {
+      return false;
+    }
+    const last = this.lastSyncedFingerprint;
+    if (last === null || current === null) {
+      return last === null && current === null;
+    }
+    return current.mtimeMs === last.mtimeMs && current.size === last.size && current.dev === last.dev && current.ino === last.ino && current.ctimeMs === last.ctimeMs && current.birthtimeMs === last.birthtimeMs;
+  }
+  /** Check if content already exists in the index. */
+  has(content) {
+    return this.hashes.has(_ContentHashIndex.computeHash(content));
+  }
+  /** Add content hash to the index. */
+  add(content) {
+    const hash = _ContentHashIndex.computeHash(content);
+    this.removed.delete(hash);
+    this.hashes.add(hash);
+    this.added.add(hash);
+    this.dirty = true;
+  }
+  get size() {
+    return this.hashes.size;
+  }
+  /** Clear all loaded hashes so the next save rewrites the index from scratch. */
+  clear() {
+    if (this.hashes.size > 0) {
+      this.hashes.clear();
+    }
+    this.added.clear();
+    this.removed.clear();
+    this.cancelReconcileRetry();
+    this.dirty = true;
+  }
+  /** Persist index to disk if changed (plain whole-file overwrite). */
+  async save() {
+    if (!this.dirty) return;
+    await mkdir(path.dirname(this.filePath), { recursive: true });
+    const publishedAdded = new Set(this.added);
+    const publishedRemoved = new Set(this.removed);
+    const serialized = [...this.hashes].join("\n") + "\n";
+    await writeMaybeEncryptedFile(
+      this.filePath,
+      serialized,
+      this.secureStoreWriteKeyProvider(),
+      {},
+      this.memoryDir
+    );
+    for (const h of publishedAdded) this.added.delete(h);
+    for (const h of publishedRemoved) this.removed.delete(h);
+    this.dirty = this.added.size > 0 || this.removed.size > 0;
+    await this.captureSyncedFingerprint();
+    if (this.dirty) {
+      this.scheduleReconcileRetry();
+    } else {
+      this.cancelReconcileRetry();
+    }
+    log.debug(`content-hash index: saved ${this.hashes.size} hashes`);
+  }
+  /**
+   * Persist the index by RECONCILING with the latest on-disk state under a
+   * cross-process lock (issue #1909). Used by the extraction-persist batch save
+   * for BOTH append and removal batches, so appends and removals to the same
+   * index serialize against each other:
+   *   final = (on-disk \ this.removed) ∪ this.added
+   * Note it re-applies only OUR local additions (`added`), NOT the loaded
+   * snapshot (review round 9 finding 3): seeding from `this.hashes` would
+   * resurrect a hash a peer removed on disk while we held a stale snapshot. This
+   * preserves a concurrent writer's appended hashes (a blind overwrite would
+   * drop them), never resurrects a removed hash, and never loses our additions.
+   *
+   * Hardening:
+   *  - Dirty short-circuit (round 7 finding 3): when this instance neither added
+   *    nor removed anything this run, skip the O(file) read+rewrite entirely.
+   *  - Cross-process lock (round 7 finding 2): serialize the read→reconcile→write
+   *    window on a per-file advisory lock. If the lock is NOT acquired (timeout),
+   *    do NOT publish (round 9 finding 2): keep `dirty` set AND schedule a bounded
+   *    durable background retry (PR #2016) that keeps re-attempting the locked
+   *    publish until the deferred additions land — never an unlocked write that
+   *    could clobber a peer, and never a silent "batch save complete" that leaves
+   *    the addition in this process's memory only.
+   */
+  async saveMergingWithDisk() {
+    if (!this.dirty) return;
+    await mkdir(path.dirname(this.filePath), { recursive: true });
+    const publish = async () => {
+      const publishedAdded = new Set(this.added);
+      const publishedRemoved = new Set(this.removed);
+      const merged = new Set(publishedAdded);
+      try {
+        const raw = await readMaybeEncryptedFile(
+          this.filePath,
+          this.secureStoreKeyProvider(),
+          this.memoryDir
+        );
+        for (const line of raw.split("\n")) {
+          const trimmed = line.trim();
+          if (trimmed.length > 0 && !publishedRemoved.has(trimmed)) merged.add(trimmed);
+        }
+      } catch (err) {
+        if (err instanceof SecureStoreLockedError) throw err;
+        if (!isErrnoCode(err, "ENOENT")) throw err;
+      }
+      await mkdir(path.dirname(this.filePath), { recursive: true });
+      await writeMaybeEncryptedFile(
+        this.filePath,
+        [...merged].join("\n") + "\n",
+        this.secureStoreWriteKeyProvider(),
+        {},
+        this.memoryDir
+      );
+      for (const h of publishedAdded) this.added.delete(h);
+      for (const h of publishedRemoved) this.removed.delete(h);
+      for (const h of this.added) merged.add(h);
+      for (const h of this.removed) merged.delete(h);
+      this.hashes = merged;
+      this.dirty = this.added.size > 0 || this.removed.size > 0;
+      await this.captureSyncedFingerprint();
+    };
+    await withHeldFileLock(
+      `${this.filePath}.lock`,
+      {
+        staleMs: CONTENT_HASH_INDEX_LOCK_STALE_MS,
+        ...this.lockOptions.maxWaitMs !== void 0 ? { maxWaitMs: this.lockOptions.maxWaitMs } : {},
+        ...this.lockOptions.pollMs !== void 0 ? { pollMs: this.lockOptions.pollMs } : {}
+      },
+      async (acquired) => {
+        if (!acquired) {
+          log.warn(
+            `content-hash index: lock not acquired for ${this.filePath}; deferring reconcile save (dirty retained, scheduling durable retry)`
+          );
+          this.scheduleReconcileRetry();
+          return;
+        }
+        await publish();
+        if (this.dirty) {
+          this.scheduleReconcileRetry();
+        } else {
+          this.cancelReconcileRetry();
+        }
+      }
+    );
+    log.debug(`content-hash index: reconcile-saved ${this.hashes.size} hashes`);
+  }
+  /**
+   * Rebuild-and-publish the index from an authoritative source (the durable
+   * corpus) under the SAME per-file cross-process lock the reconciling
+   * append/removal saves (`saveMergingWithDisk`) use (issue #1909 / PR #2016).
+   * The `populate` callback runs WHILE the lock is held and MUST repopulate this
+   * index from the corpus (`clear()` then `addByHash(...)` for every corpus
+   * hash); the rebuilt set is then published with a plain overwrite that is now
+   * serialized against every locked writer.
+   *
+   * This closes the finding where the previous unlocked clear→scan→save() could
+   * overwrite a peer's newer lock-merged or deferred additions: a locked writer
+   * that committed BEFORE the rebuild acquired the lock has its memory `.md` on
+   * disk and is re-scanned; one that commits AFTER the rebuild releases
+   * reconciles its additions on top of the freshly-published set. No union with
+   * the raw on-disk file is performed, so the rebuild keeps its
+   * garbage-collection property (orphaned hashes for deleted memories drop).
+   *
+   * Lock-acquisition failure is explicit and non-destructive: `populate` is NOT
+   * run and nothing is written (never an unlocked overwrite). Returns true when
+   * the rebuild was published under the lock, false when the lock timed out —
+   * the caller keeps the index non-authoritative and retries on next use. Uses
+   * the same non-reentrant file lock as the reconcile path, so it can never
+   * deadlock with the deferred reconcile-retry: a concurrent locked writer (or a
+   * fired retry) simply yields `acquired=false` after the bounded wait.
+   */
+  async rebuildUnderLock(populate) {
+    await mkdir(path.dirname(this.filePath), { recursive: true });
+    let published = false;
+    await withHeldFileLock(
+      `${this.filePath}.lock`,
+      {
+        staleMs: CONTENT_HASH_INDEX_LOCK_STALE_MS,
+        ...this.lockOptions.maxWaitMs !== void 0 ? { maxWaitMs: this.lockOptions.maxWaitMs } : {},
+        ...this.lockOptions.pollMs !== void 0 ? { pollMs: this.lockOptions.pollMs } : {}
+      },
+      async (acquired) => {
+        if (!acquired) {
+          log.warn(
+            `content-hash index: lock not acquired for ${this.filePath}; deferring authoritative rebuild (index left non-authoritative, retried on next use)`
+          );
+          return;
+        }
+        await populate();
+        await this.save();
+        published = true;
+      }
+    );
+    return published;
+  }
+  /**
+   * True while a background durable reconcile-save retry is armed (PR #2016).
+   * Test/introspection hook.
+   */
+  get hasPendingReconcileRetry() {
+    return this.reconcileRetryTimer !== null;
+  }
+  /** True while this index has in-memory changes not yet published to disk. */
+  get hasPendingChanges() {
+    return this.dirty;
+  }
+  /**
+   * Resolve once any armed background reconcile-save retry chain has settled —
+   * either it published the deferred additions, or it exhausted its bounded
+   * attempts and fell back to the corpus-rebuild safety net. Resolves
+   * immediately when nothing is armed. Lets a caller (or a test) await the
+   * eventual durability outcome of a lock-timed-out save.
+   */
+  async whenReconcileRetrySettled() {
+    await (this.reconcileRetryBarrier ?? Promise.resolve());
+  }
+  /**
+   * Drive any deferred lock-timeout reconcile save to completion INLINE at a
+   * lifecycle boundary (PR #2016 finding 3). The background retry timer is
+   * `unref`'d so it never keeps a long-lived daemon alive — but a short-lived
+   * writer (a one-shot CLI) can exit before it fires, leaving a durable fact
+   * `.md` whose hash never reached `fact-hashes.txt` for peers that already
+   * built their in-memory index. `orchestrator.destroy()` calls this so the
+   * addition publishes before the process exits; long-lived hosts only reach it
+   * at their own shutdown, so their in-flight retries keep running in the
+   * background until then. Bounded by the same attempt ceiling as the background
+   * retry; a permanently contended lock falls back to the corpus-rebuild-on-
+   * restart safety net (the fact `.md` is already durable). No deadlock: each
+   * attempt is the same non-reentrant, bounded-wait file lock.
+   */
+  async flushReconcileRetry() {
+    if (!this.dirty) return;
+    const maxAttempts = this.lockOptions.retryMaxAttempts ?? CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS;
+    const baseMs = this.lockOptions.retryBaseMs ?? CONTENT_HASH_INDEX_RETRY_BASE_MS;
+    for (let attempt = 0; this.dirty && attempt < maxAttempts; attempt += 1) {
+      if (this.reconcileRetryTimer) {
+        clearTimeout(this.reconcileRetryTimer);
+        this.reconcileRetryTimer = null;
+      }
+      await this.saveMergingWithDisk();
+      if (!this.dirty) break;
+      if (attempt < maxAttempts - 1) {
+        const wait = Math.min(baseMs * 2 ** attempt, CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
+        await new Promise((resolve) => setTimeout(resolve, wait));
+      }
+    }
+    if (this.reconcileRetryTimer) {
+      clearTimeout(this.reconcileRetryTimer);
+      this.reconcileRetryTimer = null;
+    }
+    this.reconcileRetryAttempts = 0;
+    this.settleReconcileRetry();
+  }
+  /**
+   * Schedule ONE bounded, exponentially-backed-off background retry of the
+   * deferred reconcile save (PR #2016). Reentrant-safe: an already-armed timer
+   * short-circuits, so successive timed-out saves never stack duplicate retries.
+   * When attempts are exhausted the chain settles without publishing — the
+   * durable fact `.md` is on disk and a process restart rebuilds the index from
+   * the corpus, so this degrades to that safety net, never a fatal failure.
+   */
+  scheduleReconcileRetry() {
+    if (this.reconcileRetryTimer) return;
+    const maxAttempts = this.lockOptions.retryMaxAttempts ?? CONTENT_HASH_INDEX_RETRY_MAX_ATTEMPTS;
+    if (this.reconcileRetryAttempts >= maxAttempts) {
+      log.warn(
+        `content-hash index: exhausted ${maxAttempts} deferred reconcile-save retries for ${this.filePath}; ${this.added.size} addition(s) remain dirty in-memory (a process restart rebuilds the index from the durable corpus)`
+      );
+      this.reconcileRetryAttempts = 0;
+      this.settleReconcileRetry();
+      return;
+    }
+    if (!this.reconcileRetryBarrier) {
+      this.reconcileRetryBarrier = new Promise((resolve) => {
+        this.reconcileRetryResolve = resolve;
+      });
+    }
+    const attempt = this.reconcileRetryAttempts + 1;
+    const baseMs = this.lockOptions.retryBaseMs ?? CONTENT_HASH_INDEX_RETRY_BASE_MS;
+    const delay = Math.min(baseMs * 2 ** (attempt - 1), CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
+    this.reconcileRetryTimer = setTimeout(() => {
+      this.reconcileRetryTimer = null;
+      this.reconcileRetryAttempts = attempt;
+      void this.saveMergingWithDisk().catch((err) => {
+        log.warn(`content-hash index: deferred reconcile-save retry failed for ${this.filePath}: ${err}`);
+      }).finally(() => {
+        if (this.dirty && !this.reconcileRetryTimer) this.settleReconcileRetry();
+      });
+    }, delay);
+    this.reconcileRetryTimer.unref?.();
+  }
+  /** Cancel any armed reconcile-save retry and settle the barrier (a publish landed). */
+  cancelReconcileRetry() {
+    if (this.reconcileRetryTimer) {
+      clearTimeout(this.reconcileRetryTimer);
+      this.reconcileRetryTimer = null;
+    }
+    this.reconcileRetryAttempts = 0;
+    this.settleReconcileRetry();
+  }
+  /** Resolve and clear the retry barrier if one is outstanding. */
+  settleReconcileRetry() {
+    const resolve = this.reconcileRetryResolve;
+    this.reconcileRetryBarrier = null;
+    this.reconcileRetryResolve = null;
+    resolve?.();
+  }
+  /** Remove a hash from the index (used when archiving/deleting). */
+  remove(content) {
+    const hash = _ContentHashIndex.computeHash(content);
+    this.added.delete(hash);
+    this.removed.add(hash);
+    this.hashes.delete(hash);
+    this.dirty = true;
+  }
+  /**
+   * Remove a pre-computed SHA-256 hash directly from the index without
+   * re-hashing.  Use this when the caller already holds the stored hash
+   * (e.g. `memory.frontmatter.contentHash`) to avoid the double-hash bug
+   * where `remove(hash)` would compute `hash(hash)` and never match the
+   * entry.
+   */
+  removeByHash(hash) {
+    this.added.delete(hash);
+    this.removed.add(hash);
+    this.hashes.delete(hash);
+    this.dirty = true;
+  }
+  /**
+   * Add a pre-computed SHA-256 hash directly to the index without re-hashing.
+   * Use this when the caller already holds the stored hash
+   * (e.g. `memory.frontmatter.contentHash`) so that the index records the raw
+   * content hash rather than re-hashing the citation-annotated body.
+   *
+   * @internal Only called from `StorageManager.ensureFactHashIndexAuthoritative`.
+   * Not part of the public API — prefer `add(content)` for external callers.
+   */
+  addByHash(hash) {
+    this.removed.delete(hash);
+    this.hashes.add(hash);
+    this.added.add(hash);
+    this.dirty = true;
+  }
+  /** Normalize content (delegates to content-hash.ts for a single source of truth). */
+  static normalizeContent(content) {
+    return normalizeContent(content);
+  }
+  /** Compute SHA-256 hash (delegates to content-hash.ts for a single source of truth). */
+  static computeHash(content) {
+    return computeContentHash(content);
+  }
+};
+
+// src/storage/tombstone-blocked-capture-mutation.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { createHash } from "crypto";
+import { mkdir as mkdir2 } from "fs/promises";
+import path2 from "path";
+var TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS = 6e4;
+var CAPTURE_WRITE_LOCK_MAX_ATTEMPTS = 3;
+var CAPTURE_WRITE_LOCK_RETRY_BASE_MS = 25;
+var CAPTURE_WRITE_LOCK_BUSY_MESSAGE = "tombstone-blocked capture write lock remained busy";
+function isTombstoneBlockedCaptureWriteLockBusy(error) {
+  return error instanceof Error && error.message === CAPTURE_WRITE_LOCK_BUSY_MESSAGE;
+}
+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 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 path2.join(this.options.stateDir, "tombstone-blocked-capture", filename);
+  }
+  async withSingleCaptureWriteLock(lockPath, task) {
+    await mkdir2(path2.dirname(lockPath), { recursive: true });
+    const retry = /* @__PURE__ */ Symbol("retry");
+    const permanentFailure = /* @__PURE__ */ Symbol("permanent-failure");
+    const runWithHeldFileLock = this.options.withHeldFileLock ?? withHeldFileLock;
+    for (let attempt = 0; attempt < CAPTURE_WRITE_LOCK_MAX_ATTEMPTS; attempt += 1) {
+      const result = await runWithHeldFileLock(
+        lockPath,
+        {
+          staleMs: TOMBSTONE_CAPTURE_WRITE_LOCK_STALE_MS,
+          maxWaitMs: 1e3,
+          pollMs: 25
+        },
+        async (acquired, controller) => {
+          if (acquired) return await task();
+          return controller.failure === "error" ? permanentFailure : retry;
+        }
+      );
+      if (result === permanentFailure) {
+        throw new Error("tombstone-blocked capture write lock acquisition failed");
+      }
+      if (result !== retry) return result;
+      if (attempt === CAPTURE_WRITE_LOCK_MAX_ATTEMPTS - 1) break;
+      const delayState = Promise.withResolvers();
+      setTimeout(delayState.resolve, CAPTURE_WRITE_LOCK_RETRY_BASE_MS * 2 ** attempt);
+      await delayState.promise;
+    }
+    throw new Error(CAPTURE_WRITE_LOCK_BUSY_MESSAGE);
+  }
+  async withPhysicalCaptureWriteLocks(task, identityHashes) {
+    const lockPaths = [...new Set(identityHashes.map((hash) => this.captureWriteLockPathForHash(hash)))].sort();
+    const acquire = async (index) => {
+      if (index === lockPaths.length) return await task();
+      return await this.withSingleCaptureWriteLock(lockPaths[index], () => acquire(index + 1));
+    };
+    return await acquire(0);
+  }
+  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) {
+    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 missingIdentityHashes = identityKeys.filter((key) => !current || !current.has(key) && !current.has(hashToken(key))).map(identityHash);
+    const missingHashes = hashes.filter((hash) => !current || !current.has(`\0${hash}`));
+    const physicalMissing = [.../* @__PURE__ */ new Set([...missingIdentityHashes, ...missingHashes])];
+    if (current && physicalMissing.length > 0) {
+      const heldLockPaths = [...current].filter((token) => token.startsWith("\0")).map((token) => this.captureWriteLockPathForHash(token.slice(1)));
+      const requestedLockPaths = physicalMissing.map((hash) => this.captureWriteLockPathForHash(hash));
+      if (heldLockPaths.some((held) => requestedLockPaths.some((requested) => requested < held))) {
+        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 = () => 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;
+  let mustLock = mutation.blocked || mutation.coordinate === true;
+  for (; ; ) {
+    let retryIdentity;
+    const mutate = async () => {
+      const current = await host.readCurrent();
+      const currentBlocked = host.isBlocked(current);
+      const currentQueuedReview = host.isQueuedReview(current);
+      if (current !== null && (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;
+      try {
+        await host.writeStorageSecureFile(mutation.pathname, mutation.fileContent);
+      } catch (err) {
+        if (rebuildMarker) {
+          try {
+            await host.discardWrite(rebuildMarker);
+          } catch (cleanupError) {
+            host.markUntrusted();
+            host.logWarning(`storage.tombstoneBlocked failed to clear write marker: ${cleanupError}`);
+          }
+        }
+        throw err;
+      }
+      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);
+    };
+    if (mustLock) {
+      await host.withCaptureWriteLock(mutate, lockIdentity);
+    } else {
+      await mutate();
+    }
+    if (retryIdentity === void 0) return;
+    const identities = Array.isArray(lockIdentity) ? [...lockIdentity, retryIdentity] : [lockIdentity, retryIdentity];
+    lockIdentity = [...new Set(identities)];
+    mustLock = true;
+  }
+}
+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);
+}
+async function runTombstoneBlockedChunkMutation(mutation) {
+  const persist = async () => {
+    if (mutation.blocked) {
+      const duplicate = await mutation.findDuplicate();
+      if (duplicate) return duplicate.frontmatter.id;
+    }
+    await mutation.persistMemory();
+    await mutation.afterWrite();
+    return mutation.id;
+  };
+  return mutation.blocked ? await mutation.withCaptureWriteLock(persist, mutation.identity) : await persist();
+}
+
+// src/storage/tombstone-blocked-capture-sync.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
+import { unlink as unlink2 } from "fs/promises";
+import path4 from "path";
+import { isDeepStrictEqual } from "util";
+
+// src/storage/tombstone-blocked-capture-index.ts
+import { execFile } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdir as mkdir3, readFile, readdir, rename, stat as stat2, unlink, writeFile } from "fs/promises";
+import path3 from "path";
+import { promisify } from "util";
+var REBUILD_MAX_ATTEMPTS = 3;
+var execFileAsync = promisify(execFile);
+var REBUILD_RETRY_BASE_MS = 50;
+var ABANDONED_MARKER_MIN_AGE_MS = 6e4;
+var MARKER_PROCESS_START_TOLERANCE_MS = 2e3;
+var DOTNET_UNIX_EPOCH_TICKS = 621355968e9;
+var MARKER_PROCESS_STARTED_AT_MS = Date.now() - process.uptime() * 1e3;
+var TombstoneBlockedCaptureIndex = class {
+  options;
+  index = null;
+  loadPromise = null;
+  refreshPromise = null;
+  authoritative = false;
+  captureWriteLock;
+  constructor(options) {
+    this.options = options;
+    this.captureWriteLock = new TombstoneBlockedCaptureWriteLock(options);
+  }
+  createIndex() {
+    return new ContentHashIndex(
+      path3.join(this.options.stateDir, "tombstone-blocked-capture"),
+      this.options.secureStoreKeyProvider,
+      this.options.secureStoreWriteKeyProvider,
+      this.options.memoryDir,
+      this.options.lockOptions()
+    );
+  }
+  indexPath() {
+    return path3.join(this.options.stateDir, "tombstone-blocked-capture", "fact-hashes.txt");
+  }
+  rebuildMarkerPath() {
+    return path3.join(this.options.stateDir, "tombstone-blocked-capture", "rebuild-required");
+  }
+  async readRebuildMarkers() {
+    try {
+      const entries = (await readdir(this.rebuildMarkerPath())).filter((entry) => !entry.startsWith("."));
+      return (await Promise.all(
+        entries.map(async (entry) => {
+          const markerPath = path3.join(this.rebuildMarkerPath(), entry);
+          try {
+            const raw = (await readFile(markerPath, "utf8")).trim();
+            if (raw === "committed") return { path: markerPath, committed: true };
+            let value;
+            let malformed = false;
+            try {
+              const parsed = JSON.parse(raw);
+              if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                malformed = true;
+                value = {};
+              } else {
+                value = parsed;
+              }
+            } catch {
+              malformed = true;
+              value = {};
+            }
+            const state = value.state;
+            if (state !== "pending" && state !== "committed") malformed = true;
+            const markerStat = await stat2(markerPath).catch(() => null);
+            const createdAt = typeof value.createdAt === "number" && Number.isFinite(value.createdAt) ? value.createdAt : markerStat?.mtimeMs;
+            if (typeof value.pid !== "number" || !Number.isInteger(value.pid)) malformed = true;
+            const ownerId = typeof value.ownerId === "string" && value.ownerId.length > 0 ? value.ownerId : path3.basename(markerPath);
+            if (typeof value.ownerId !== "string" || value.ownerId.length === 0) malformed = true;
+            const processStartedAtMs = typeof value.processStartedAtMs === "number" && Number.isFinite(value.processStartedAtMs) && value.processStartedAtMs > 0 ? value.processStartedAtMs : void 0;
+            return {
+              path: markerPath,
+              committed: state === "committed",
+              ...typeof value.pid === "number" && Number.isInteger(value.pid) ? { pid: value.pid } : {},
+              ...ownerId.length > 0 ? { ownerId } : {},
+              ...typeof createdAt === "number" && Number.isFinite(createdAt) ? { createdAt } : {},
+              ...processStartedAtMs === void 0 ? {} : { processStartedAtMs },
+              ...malformed ? { malformed: true } : {}
+            };
+          } catch (err) {
+            if (isErrnoCode(err, "ENOENT")) return null;
+            throw err;
+          }
+        })
+      )).filter((marker) => marker !== null);
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) return [];
+      throw err;
+    }
+  }
+  async isAbandonedMarker(marker) {
+    if (marker.committed || marker.createdAt === void 0) return false;
+    if (Date.now() - marker.createdAt < ABANDONED_MARKER_MIN_AGE_MS) return false;
+    if (marker.malformed) return true;
+    return marker.pid !== void 0 && !await this.isProcessAlive(marker.pid, marker.processStartedAtMs);
+  }
+  async isProcessAlive(pid, processStartedAtMs) {
+    try {
+      process.kill(pid, 0);
+    } catch (err) {
+      return !isErrnoCode(err, "ESRCH");
+    }
+    if (processStartedAtMs === void 0) return true;
+    const runningStartedAtMs = await this.readProcessStartedAtMs(pid);
+    if (runningStartedAtMs === null) return true;
+    return runningStartedAtMs <= processStartedAtMs + MARKER_PROCESS_START_TOLERANCE_MS;
+  }
+  async readProcessStartedAtMs(pid) {
+    try {
+      if (process.platform === "win32") {
+        const { stdout: stdout2 } = await execFileAsync(
+          "powershell.exe",
+          [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            `(Get-Process -Id ${pid} -ErrorAction Stop).StartTime.ToUniversalTime().Ticks`
+          ],
+          { encoding: "utf8", timeout: 1e3 }
+        );
+        const ticks = Number(stdout2.trim());
+        return Number.isFinite(ticks) ? (ticks - DOTNET_UNIX_EPOCH_TICKS) / 1e4 : null;
+      }
+      const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "lstart="], {
+        encoding: "utf8",
+        timeout: 1e3
+      });
+      const output = stdout.trim();
+      if (!output) return null;
+      const startedAtMs = Date.parse(output);
+      return Number.isFinite(startedAtMs) ? startedAtMs : null;
+    } catch {
+      return null;
+    }
+  }
+  async getClearableRebuildMarkerPaths(markers) {
+    const paths = await Promise.all(
+      markers.map(async (marker) => marker.committed || await this.isAbandonedMarker(marker) ? marker.path : null)
+    );
+    return paths.filter((markerPath) => markerPath !== null);
+  }
+  async getRebuildMarkers() {
+    return await this.readRebuildMarkers();
+  }
+  // A pending marker protects the pre-commit gap; only committed markers are safe for another writer to clear.
+  async writeMarkerAtomically(markerPath, payload) {
+    const temporaryPath = `${markerPath}.tmp-${process.pid}-${randomUUID()}`;
+    try {
+      await writeFile(temporaryPath, payload, "utf8");
+      await rename(temporaryPath, markerPath);
+    } finally {
+      await unlink(temporaryPath).catch((err) => {
+        if (!isErrnoCode(err, "ENOENT")) throw err;
+      });
+    }
+  }
+  async markRebuildRequired(committed = false) {
+    const markerDir = this.rebuildMarkerPath();
+    await mkdir3(markerDir, { recursive: true });
+    const ownerId = randomUUID();
+    const markerPath = path3.join(markerDir, ownerId);
+    await this.writeMarkerAtomically(
+      markerPath,
+      `${JSON.stringify({
+        state: committed ? "committed" : "pending",
+        pid: process.pid,
+        ownerId,
+        createdAt: Date.now(),
+        processStartedAtMs: MARKER_PROCESS_STARTED_AT_MS
+      })}
+`
+    );
+    return markerPath;
+  }
+  async markRebuildCommitted(markerPath) {
+    await this.writeMarkerAtomically(
+      markerPath,
+      `${JSON.stringify({
+        state: "committed",
+        pid: process.pid,
+        ownerId: path3.basename(markerPath),
+        createdAt: Date.now(),
+        processStartedAtMs: MARKER_PROCESS_STARTED_AT_MS
+      })}
+`
+    );
+  }
+  async clearRebuildRequired(markerPaths) {
+    await Promise.all(
+      markerPaths.map(async (markerPath) => {
+        try {
+          await unlink(markerPath);
+        } catch (err) {
+          if (!isErrnoCode(err, "ENOENT")) throw err;
+        }
+      })
+    );
+  }
+  async hasRebuildRequired(excludedMarkers = []) {
+    const excluded = new Set(excludedMarkers);
+    return (await this.getRebuildMarkers()).some((marker) => !excluded.has(marker.path));
+  }
+  async setAuthoritative(rebuilt) {
+    this.authoritative = rebuilt && !(await this.getRebuildMarkers()).some((marker) => !marker.committed);
+  }
+  isBlocked(memory) {
+    return memory.frontmatter.status === "pending_review" && Boolean(memory.frontmatter.blockedBy);
+  }
+  async rebuild(index) {
+    return await index.rebuildUnderLock(async () => {
+      index.clear();
+      const existing = [...await this.options.readAllMemories(), ...await this.options.readAllColdMemories()];
+      for (const memory of existing) {
+        if (!this.isBlocked(memory)) continue;
+        index.add(
+          buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)
+        );
+      }
+    });
+  }
+  async hasPersistedIndexOrMarkers() {
+    try {
+      await stat2(this.indexPath());
+      return true;
+    } catch (err) {
+      if (!isErrnoCode(err, "ENOENT")) throw err;
+      return (await this.readRebuildMarkers()).length > 0;
+    }
+  }
+  async getIndex() {
+    if (this.index) return this.index;
+    if (!this.loadPromise) {
+      const index = this.createIndex();
+      this.loadPromise = (async () => {
+        await index.load();
+        const rebuildMarkers = await this.getRebuildMarkers();
+        const clearableRebuildMarkers = await this.getClearableRebuildMarkerPaths(rebuildMarkers);
+        let persisted = true;
+        try {
+          await stat2(this.indexPath());
+          if (rebuildMarkers.length > 0) persisted = false;
+        } catch (err) {
+          if (isErrnoCode(err, "ENOENT")) persisted = false;
+          else throw err;
+        }
+        if (!persisted) {
+          const lockOptions = this.options.lockOptions();
+          const maxAttempts = lockOptions.retryMaxAttempts ?? REBUILD_MAX_ATTEMPTS;
+          const baseMs = lockOptions.retryBaseMs ?? REBUILD_RETRY_BASE_MS;
+          let rebuilt = false;
+          for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+            rebuilt = await this.rebuild(index);
+            if (rebuilt || attempt === maxAttempts - 1) break;
+            const wait = Math.min(baseMs * 2 ** attempt, CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS);
+            const delayState = Promise.withResolvers();
+            setTimeout(delayState.resolve, wait);
+            await delayState.promise;
+          }
+          if (!rebuilt) {
+            throw new Error("tombstone-blocked capture index rebuild lock unavailable");
+          }
+          await this.clearRebuildRequired(clearableRebuildMarkers);
+        }
+        await this.setAuthoritative(true);
+        this.index = index;
+        return index;
+      })().catch((err) => {
+        this.loadPromise = null;
+        throw err;
+      });
+    }
+    return this.loadPromise;
+  }
+  async withCaptureWriteLock(task, identity) {
+    return await this.captureWriteLock.withCaptureWriteLock(task, identity);
+  }
+  async withCaptureWriteLockHashes(task, identityHashes) {
+    return await this.captureWriteLock.withCaptureWriteLockHashes(task, identityHashes);
+  }
+  async withCaptureWriteLockAndHashes(task, identity, identityHashes) {
+    return await this.captureWriteLock.withCaptureWriteLockAndHashes(task, identity, identityHashes);
+  }
+  async reload() {
+    if (!this.refreshPromise) {
+      this.refreshPromise = (async () => {
+        this.index = null;
+        this.loadPromise = null;
+        return await this.getIndex();
+      })().finally(() => {
+        this.refreshPromise = null;
+      });
+    }
+    return this.refreshPromise;
+  }
+  /** Return blocked-row membership and authority from one index snapshot. */
+  async check(content, category, sourceConnector) {
+    const key = buildExplicitCaptureDedupKey(content, category, sourceConnector);
+    let index = await this.getIndex();
+    if (await this.hasRebuildRequired() || !await index.isDiskFingerprintCurrent()) {
+      index = await this.reload();
+    }
+    return { has: index.has(key), authoritative: this.authoritative };
+  }
+  /** Return whether a blocked row matches this explicit-capture identity. */
+  async has(content, category, sourceConnector) {
+    return (await this.check(content, category, sourceConnector)).has;
+  }
+  /** Return whether the in-memory index is safe to answer an authoritative miss. */
+  async isAuthoritative() {
+    const index = await this.getIndex();
+    if (await this.hasRebuildRequired() || !await index.isDiskFingerprintCurrent()) {
+      await this.reload();
+    }
+    return this.authoritative;
+  }
+  /** Reserve durable rebuild intent before a blocked memory file is committed. */
+  async prepareWrite() {
+    return this.markRebuildRequired();
+  }
+  /** Mark a prepared write committed once its memory file is durable. */
+  async commitWrite(rebuildMarker) {
+    await this.markRebuildCommitted(rebuildMarker);
+  }
+  /** Drop a pending marker when the protected memory write never commits. */
+  async discardWrite(rebuildMarker) {
+    await this.clearRebuildRequired([rebuildMarker]);
+  }
+  /** Add a newly persisted blocked row to the durable targeted index. */
+  async add(memory, rebuildMarker) {
+    if (!this.isBlocked(memory)) return;
+    let index = await this.getIndex();
+    if (await this.hasRebuildRequired(rebuildMarker ? [rebuildMarker] : []) || !await index.isDiskFingerprintCurrent()) {
+      index = await this.reload();
+    }
+    index.add(
+      buildExplicitCaptureDedupKey(memory.content, memory.frontmatter.category, memory.frontmatter.sourceConnector)
+    );
+    const marker = rebuildMarker ?? await this.markRebuildRequired(true);
+    if (rebuildMarker) await this.markRebuildCommitted(rebuildMarker);
+    await index.saveMergingWithDisk();
+    await index.flushReconcileRetry();
+    if (index.hasPendingChanges) {
+      this.markUntrusted();
+      return;
+    }
+    await this.clearRebuildRequired([marker]);
+    await this.setAuthoritative(true);
+  }
+  /** Rebuild the index after a blocked row changes or is removed. */
+  async rebuildIfLoaded(ownedMarker) {
+    const index = this.index ?? (await this.hasPersistedIndexOrMarkers() ? this.getIndex() : null);
+    if (!index) return;
+    const rebuildMarkers = await this.getRebuildMarkers();
+    const rebuildMarker = await this.markRebuildRequired(true);
+    const clearableRebuildMarkers = await this.getClearableRebuildMarkerPaths(rebuildMarkers);
+    const rebuilt = await this.rebuild(await index);
+    if (rebuilt) {
+      await this.clearRebuildRequired([
+        ...clearableRebuildMarkers,
+        ...ownedMarker === void 0 || clearableRebuildMarkers.includes(ownedMarker) ? [] : [ownedMarker],
+        rebuildMarker
+      ]);
+    }
+    await this.setAuthoritative(rebuilt);
+  }
+  /** Rebuild when either side of a write is blocked and its identity changed. */
+  async sync(before, after, rebuildMarker) {
+    const beforeBlocked = this.isBlocked(before);
+    const afterBlocked = this.isBlocked(after);
+    if (!beforeBlocked && !afterBlocked) return;
+    const beforeKey = buildExplicitCaptureDedupKey(
+      before.content,
+      before.frontmatter.category,
+      before.frontmatter.sourceConnector
+    );
+    const afterKey = buildExplicitCaptureDedupKey(
+      after.content,
+      after.frontmatter.category,
+      after.frontmatter.sourceConnector
+    );
+    if (beforeBlocked && afterBlocked && beforeKey === afterKey) {
+      if (rebuildMarker) {
+        await this.markRebuildCommitted(rebuildMarker);
+        await this.clearRebuildRequired([rebuildMarker]);
+      }
+      return;
+    }
+    const existingMarkers = await this.getRebuildMarkers();
+    const marker = rebuildMarker ?? await this.markRebuildRequired(true);
+    const clearableExistingMarkers = await this.getClearableRebuildMarkerPaths(existingMarkers);
+    if (rebuildMarker) await this.markRebuildCommitted(rebuildMarker);
+    const rebuilt = await this.rebuild(await this.getIndex());
+    if (rebuilt) {
+      await this.clearRebuildRequired([
+        ...clearableExistingMarkers,
+        marker
+      ]);
+    }
+    await this.setAuthoritative(rebuilt);
+  }
+  markUntrusted() {
+    this.authoritative = false;
+  }
+  async failOpen(operation, action) {
+    try {
+      await action();
+    } catch (err) {
+      this.markUntrusted();
+      log.warn(`storage.${operation} completed but failed to update tombstone-blocked capture index: ${err}`);
+    }
+  }
+  async addWrittenMemory(pathname, frontmatter, content, rebuildMarker) {
+    await this.failOpen("writeMemory", () => this.add({ path: pathname, frontmatter, content }, rebuildMarker));
+  }
+  async rebuildAfterInvalidation(ownedMarker) {
+    await this.failOpen("invalidateMemory", () => this.rebuildIfLoaded(ownedMarker));
+  }
+  async syncUpdatedMemory(before, frontmatter, content, rebuildMarker) {
+    await this.failOpen("updateMemory", () => this.sync(before, { ...before, frontmatter, content }, rebuildMarker));
+  }
+  async syncUpdatedFrontmatter(before, frontmatter, rebuildMarker) {
+    await this.failOpen("writeMemoryFrontmatter", () => this.sync(before, { ...before, frontmatter }, rebuildMarker));
+  }
+  shouldRebuildAfterInvalidationForPath(filePath) {
+    const relative = path3.relative(path3.resolve(this.options.memoryDir), path3.resolve(filePath));
+    const category = relative.split(path3.sep)[0];
+    return category === "cold" || RECALL_FALLBACK_DIRS.includes(category);
+  }
+};
+
+// src/storage/tombstone-blocked-capture-sync.ts
+var OFFLINE_SYNC_BUFFER_LIMIT_BYTES = 1048576;
+var OFFLINE_SYNC_STAGE_READ_BYTES = 64 * 1024;
+var OFFLINE_SYNC_FRONTMATTER_DELIMITER = Buffer.from("\n---\n", "utf8");
+function createExplicitContentNormalizer(onChunk) {
+  let started = false;
+  let pendingSpace = false;
+  let output = "";
+  const flush = () => {
+    if (output.length > 0) {
+      onChunk(output);
+      output = "";
+    }
+  };
+  return {
+    push(text) {
+      for (const character of text.toLowerCase()) {
+        if (/\s/u.test(character)) {
+          if (started) pendingSpace = true;
+          continue;
+        }
+        if (pendingSpace) {
+          output += " ";
+          pendingSpace = false;
+        }
+        output += character;
+        started = true;
+        if (output.length >= OFFLINE_SYNC_STAGE_READ_BYTES) flush();
+      }
+    },
+    finish: flush
+  };
+}
+async function forEachStagedTextChunk(stagePath, offset, onText, key, memoryDir) {
+  const decoder = new TextDecoder("utf-8");
+  let remaining = offset;
+  for await (const chunk of readMaybeEncryptedFileFromChunks(stagePath, key, memoryDir)) {
+    const textChunk = remaining >= chunk.length ? null : chunk.subarray(remaining);
+    remaining = Math.max(0, remaining - chunk.length);
+    if (textChunk === null || textChunk.length === 0) continue;
+    const text = decoder.decode(textChunk, { stream: true });
+    if (text.length > 0) onText(text);
+  }
+  const finalText = decoder.decode();
+  if (finalText.length > 0) onText(finalText);
+}
+async function findStagedBodyOffset(stagePath, key, memoryDir) {
+  let scannedBytes = 0;
+  let tail = Buffer.alloc(0);
+  for await (const chunk of readMaybeEncryptedFileFromChunks(stagePath, key, memoryDir)) {
+    const window = tail.length > 0 ? Buffer.concat([tail, chunk]) : chunk;
+    const windowStart = scannedBytes - tail.length;
+    for (let searchFrom = 0; ; ) {
+      const delimiterStart = window.indexOf(OFFLINE_SYNC_FRONTMATTER_DELIMITER, searchFrom);
+      if (delimiterStart < 0) break;
+      if (windowStart + delimiterStart >= 4) {
+        return windowStart + delimiterStart + OFFLINE_SYNC_FRONTMATTER_DELIMITER.length;
+      }
+      searchFrom = delimiterStart + 1;
+    }
+    scannedBytes += chunk.length;
+    const tailLength = Math.min(OFFLINE_SYNC_FRONTMATTER_DELIMITER.length - 1, window.length);
+    tail = Buffer.from(window.subarray(window.length - tailLength));
+  }
+  return null;
+}
+async function readStagedPrefix(stagePath, byteLimit, key, memoryDir) {
+  const chunks = [];
+  let bytesRead = 0;
+  for await (const chunk of readMaybeEncryptedFileFromChunks(stagePath, key, memoryDir)) {
+    const length = Math.min(chunk.length, byteLimit - bytesRead);
+    if (length > 0) chunks.push(chunk.subarray(0, length));
+    bytesRead += length;
+    if (bytesRead >= byteLimit) break;
+  }
+  return Buffer.concat(chunks, bytesRead);
+}
+function parseTombstoneBlockedOfflineSyncMemory(filePath, content, memoryDir, parseFrontmatter, normalizeFrontmatterForPath, toMemoryPathRel) {
+  const parsed = parseFrontmatter(content.toString("utf8"));
+  if (!parsed) return null;
+  return {
+    path: filePath,
+    frontmatter: normalizeFrontmatterForPath(parsed.frontmatter, toMemoryPathRel(memoryDir, filePath), parsed.content),
+    content: parsed.content
+  };
+}
+var TombstoneBlockedCaptureIndexHost = class {
+  tombstoneBlockedCaptureIndex = null;
+  async writeStorageSecureFileChunks(filePath, chunks) {
+    const options = this.tombstoneBlockedCaptureIndexOptions();
+    await writeMaybeEncryptedFileFromChunks(
+      filePath,
+      chunks,
+      options.secureStoreWriteKeyProvider(),
+      {},
+      options.memoryDir
+    );
+    this.notifyCatalogWriteForPath(filePath);
+  }
+  getTombstoneBlockedCaptureIndex() {
+    if (this.tombstoneBlockedCaptureIndex === null) {
+      this.tombstoneBlockedCaptureIndex = new TombstoneBlockedCaptureIndex(this.tombstoneBlockedCaptureIndexOptions());
+    }
+    return this.tombstoneBlockedCaptureIndex;
+  }
+  async withTombstoneBlockedCaptureWriteLock(task, identity) {
+    return await this.getTombstoneBlockedCaptureIndex().withCaptureWriteLock(task, identity);
+  }
+  async withTombstoneBlockedCaptureWriteLockAndHashes(task, identity, identityHashes) {
+    return await this.getTombstoneBlockedCaptureIndex().withCaptureWriteLockAndHashes(task, identity, identityHashes);
+  }
+  async writeTombstoneBlockedMutation(blocked, pathname, fileContent, identity, updateIndex, beforeIndexUpdate, coordinate = false) {
+    const host = {
+      readCurrent: () => this.readMemoryByPath(pathname),
+      isBlocked: (memory) => this.isTombstoneBlockedMemory(memory),
+      isQueuedReview: (memory) => isQueuedReviewMemory(memory),
+      memoryIdentity: (memory) => this.offlineSyncMemoryIdentity(memory),
+      prepareWrite: () => this.getTombstoneBlockedCaptureIndex().prepareWrite(),
+      commitWrite: (marker) => this.getTombstoneBlockedCaptureIndex().commitWrite(marker),
+      discardWrite: (marker) => this.getTombstoneBlockedCaptureIndex().discardWrite(marker),
+      markUntrusted: () => this.getTombstoneBlockedCaptureIndex().markUntrusted(),
+      writeStorageSecureFile: (target, content) => this.writeStorageSecureFile(target, content),
+      withCaptureWriteLock: (task, lockIdentity) => this.withTombstoneBlockedCaptureWriteLock(task, lockIdentity),
+      logWarning: (message) => log.warn(message)
+    };
+    await runTombstoneBlockedMutation(host, {
+      blocked,
+      pathname,
+      fileContent,
+      identity,
+      updateIndex,
+      beforeIndexUpdate,
+      coordinate
+    });
+  }
+  async writeTombstoneBlockedMemory(pathname, fileContent, frontmatter, content, beforeIndexUpdate) {
+    await this.writeTombstoneBlockedMutation(
+      tombstoneBlocked(frontmatter),
+      pathname,
+      fileContent,
+      buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector),
+      (rebuildMarker) => this.getTombstoneBlockedCaptureIndex().addWrittenMemory(pathname, frontmatter, content, rebuildMarker),
+      beforeIndexUpdate
+    );
+  }
+  async writeTombstoneBlockedChunk(pathname, fileContent, frontmatter, content, findDuplicate, afterWrite) {
+    return await runTombstoneBlockedChunkMutation({
+      blocked: tombstoneBlocked(frontmatter),
+      id: frontmatter.id,
+      identity: buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector),
+      findDuplicate,
+      persistMemory: () => this.writeTombstoneBlockedMemory(pathname, fileContent, frontmatter, content),
+      afterWrite,
+      withCaptureWriteLock: (task, identity) => this.withTombstoneBlockedCaptureWriteLock(task, identity)
+    });
+  }
+  async writeTombstoneBlockedUpdate(before, fileContent, frontmatter, content, beforeIndexUpdate) {
+    await this.writeTombstoneBlockedMutation(
+      tombstoneBlocked(before.frontmatter) || tombstoneBlocked(frontmatter),
+      before.path,
+      fileContent,
+      [
+        ...tombstoneBlocked(before.frontmatter) ? [
+          buildExplicitCaptureDedupKey(
+            before.content,
+            before.frontmatter.category,
+            before.frontmatter.sourceConnector
+          )
+        ] : [],
+        ...tombstoneBlocked(frontmatter) ? [buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector)] : [],
+        ...isQueuedReviewMemory(before) ? [
+          buildExplicitCaptureDedupKey(
+            before.content,
+            before.frontmatter.category,
+            before.frontmatter.sourceConnector
+          )
+        ] : [],
+        ...isQueuedReviewFrontmatter(frontmatter) ? [buildExplicitCaptureDedupKey(content, frontmatter.category, frontmatter.sourceConnector)] : []
+      ],
+      (rebuildMarker, current) => this.getTombstoneBlockedCaptureIndex().syncUpdatedMemory(
+        current ?? before,
+        frontmatter,
+        content,
+        rebuildMarker
+      ),
+      beforeIndexUpdate,
+      isQueuedReviewMemory(before) || isQueuedReviewFrontmatter(frontmatter)
+    );
+  }
+  async writeTombstoneBlockedFrontmatter(before, fileContent, frontmatter, beforeIndexUpdate) {
+    await this.writeTombstoneBlockedMutation(
+      tombstoneBlocked(before.frontmatter) || tombstoneBlocked(frontmatter),
+      before.path,
+      fileContent,
+      [
+        ...tombstoneBlocked(before.frontmatter) ? [
+          buildExplicitCaptureDedupKey(
+            before.content,
+            before.frontmatter.category,
+            before.frontmatter.sourceConnector
+          )
+        ] : [],
+        ...tombstoneBlocked(frontmatter) ? [buildExplicitCaptureDedupKey(before.content, frontmatter.category, frontmatter.sourceConnector)] : [],
+        ...isQueuedReviewMemory(before) ? [
+          buildExplicitCaptureDedupKey(
+            before.content,
+            before.frontmatter.category,
+            before.frontmatter.sourceConnector
+          )
+        ] : [],
+        ...isQueuedReviewFrontmatter(frontmatter) ? [buildExplicitCaptureDedupKey(before.content, frontmatter.category, frontmatter.sourceConnector)] : []
+      ],
+      (rebuildMarker, current) => this.getTombstoneBlockedCaptureIndex().syncUpdatedFrontmatter(
+        current ?? before,
+        frontmatter,
+        rebuildMarker
+      ),
+      beforeIndexUpdate,
+      isQueuedReviewMemory(before) || isQueuedReviewFrontmatter(frontmatter)
+    );
+  }
+  isTombstoneBlockedMemory(memory) {
+    return memory !== null && memory.frontmatter.status === "pending_review" && Boolean(memory.frontmatter.blockedBy);
+  }
+  offlineSyncMemoryIdentity(memory) {
+    return buildExplicitCaptureDedupKey(
+      memory.content,
+      memory.frontmatter.category,
+      memory.frontmatter.sourceConnector
+    );
+  }
+  async isDuplicateTombstoneBlockedOfflineSync(target, incoming, streamedIdentity) {
+    const before = await this.readMemoryByPath(target);
+    const duplicate = streamedIdentity ? true : await this.getTombstoneBlockedCaptureIndex().has(
+      incoming.content,
+      incoming.frontmatter.category,
+      incoming.frontmatter.sourceConnector
+    );
+    if (!duplicate) return false;
+    const incomingIdentity = streamedIdentity?.identityHash ?? this.offlineSyncMemoryIdentity(incoming);
+    const options = this.tombstoneBlockedCaptureIndexOptions();
+    const existing = [...await options.readAllMemories(), ...await options.readAllColdMemories()];
+    const exactMatch = existing.some(
+      (memory) => this.isTombstoneBlockedMemory(memory) && (streamedIdentity ? captureIdentityHash(memory) : this.offlineSyncMemoryIdentity(memory)) === incomingIdentity
+    );
+    if (!exactMatch) return false;
+    if (before === null) return true;
+    if (!this.isTombstoneBlockedMemory(before)) return false;
+    const beforeIdentity = streamedIdentity ? captureIdentityHash(before) : this.offlineSyncMemoryIdentity(before);
+    if (beforeIdentity !== incomingIdentity) return false;
+    return streamedIdentity ? isDeepStrictEqual(before.frontmatter, incoming.frontmatter) : before.content === incoming.content && isDeepStrictEqual(before.frontmatter, incoming.frontmatter);
+  }
+  async invalidateAfterOfflineSyncMutation(filePath, ownedMarker) {
+    this.invalidateAllMemoriesCache();
+    this.invalidateKnowledgeIndexCache();
+    this.markFactHashIndexNotAuthoritative();
+    if (filePath.includes(`${path4.sep}cold${path4.sep}`)) {
+      this.invalidateColdMemoriesCache();
+    }
+    await this.rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath, ownedMarker);
+    if (filePath.includes(`${path4.sep}artifacts${path4.sep}`)) {
+      this.bumpArtifactWriteVersion();
+    }
+    this.bumpMemoryStatusVersion();
+  }
+  async runTombstoneBlockedArchive(memory, task) {
+    if (!this.isTombstoneBlockedMemory(memory) && !isQueuedReviewMemory(memory)) {
+      return await task(memory, () => {
+      });
+    }
+    let archivedPath = null;
+    const archived = await this.runTombstoneBlockedInvalidation(
+      memory,
+      async (current, rebuildMarker, markDurable) => {
+        let archiveDurable = false;
+        const markArchiveDurable = () => {
+          archiveDurable = true;
+          markDurable();
+        };
+        archivedPath = await task(current, markArchiveDurable);
+        if (rebuildMarker !== void 0 && (archivedPath !== null || archiveDurable)) {
+          await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
+        } else if (rebuildMarker !== void 0) {
+          const index = this.getTombstoneBlockedCaptureIndex();
+          try {
+            await index.discardWrite(rebuildMarker);
+          } catch {
+            index.markUntrusted();
+          }
+        }
+        return archivedPath !== null;
+      }
+    );
+    return archived ? archivedPath : null;
+  }
+  async runTombstoneBlockedInvalidation(memory, task, propagateErrors = false, coordinate = false) {
+    let lockIdentity = coordinate || this.isTombstoneBlockedMemory(memory) || isQueuedReviewMemory(memory) ? this.offlineSyncMemoryIdentity(memory) : void 0;
+    for (; ; ) {
+      const attempt = async () => {
+        const options = this.tombstoneBlockedCaptureIndexOptions();
+        const current = await this.readMemoryByPath(memory.path) ?? (await options.readAllMemories()).find((candidate) => candidate.frontmatter.id === memory.frontmatter.id) ?? (await options.readAllColdMemories()).find((candidate) => candidate.frontmatter.id === memory.frontmatter.id);
+        if (!current) return { result: false };
+        const blocked = this.isTombstoneBlockedMemory(current);
+        const queuedReview = isQueuedReviewMemory(current);
+        if (blocked || queuedReview) {
+          const currentIdentity = this.offlineSyncMemoryIdentity(current);
+          if (lockIdentity !== currentIdentity) return { retryIdentity: currentIdentity };
+        }
+        const blockedIndex = blocked ? this.getTombstoneBlockedCaptureIndex() : null;
+        let rebuildMarker;
+        let durable = false;
+        try {
+          if (blockedIndex) rebuildMarker = await blockedIndex.prepareWrite();
+          const result2 = await task(current, rebuildMarker, () => {
+            durable = true;
+          });
+          if (!result2 && rebuildMarker && !durable && blockedIndex) {
+            try {
+              await blockedIndex.discardWrite(rebuildMarker);
+            } catch {
+              blockedIndex.markUntrusted();
+            }
+          }
+          return { result: result2 };
+        } catch (error) {
+          if (rebuildMarker && !durable && blockedIndex) {
+            try {
+              await blockedIndex.discardWrite(rebuildMarker);
+            } catch {
+              blockedIndex.markUntrusted();
+            }
+          }
+          if (propagateErrors) throw error;
+          return { result: false };
+        }
+      };
+      const result = lockIdentity === void 0 ? await attempt() : await this.withTombstoneBlockedCaptureWriteLock(attempt, lockIdentity);
+      if (result.retryIdentity !== void 0) {
+        lockIdentity = result.retryIdentity;
+        continue;
+      }
+      return result.result;
+    }
+  }
+  async deleteMemoryForMaintenance(memory, shouldDelete = () => true) {
+    let deleted = null;
+    const removed = await this.runTombstoneBlockedInvalidation(
+      memory,
+      async (current, rebuildMarker, markDurable) => {
+        if (!shouldDelete(current)) return false;
+        await unlink2(current.path);
+        markDurable();
+        deleted = current;
+        const memoryDir = this.tombstoneBlockedCaptureIndexOptions().memoryDir;
+        markProjectedMemoryPathInvalid(memoryDir, current.frontmatter.id);
+        this.invalidateAllMemoriesCache();
+        if (current.path.includes(`${path4.sep}cold${path4.sep}`)) {
+          this.invalidateColdMemoriesCache();
+        }
+        await this.rebuildTombstoneBlockedCaptureAfterInvalidation(rebuildMarker);
+        this.bumpMemoryCorpusVersion();
+        this.bumpMemoryStatusVersion();
+        return true;
+      },
+      true,
+      true
+    );
+    return removed ? deleted : null;
+  }
+  async runTombstoneBlockedOfflineSyncMutation(target, after, write, coordinate = false, streamedIdentity) {
+    for (; ; ) {
+      const before = await this.readMemoryByPath(target);
+      const targetIdentity = this.isTombstoneBlockedMemory(before) ? this.offlineSyncMemoryIdentity(before) : void 0;
+      const blocked = coordinate || targetIdentity !== void 0 || this.isTombstoneBlockedMemory(after);
+      const identities = [
+        ...targetIdentity === void 0 ? [] : [targetIdentity],
+        ...!streamedIdentity && this.isTombstoneBlockedMemory(after) ? [this.offlineSyncMemoryIdentity(after)] : [],
+        ...coordinate ? [target] : [],
+        ...coordinate && after === null && streamedIdentity === void 0 ? [""] : []
+      ];
+      let retryIdentity;
+      const mutate = async () => {
+        const current = await this.readMemoryByPath(target);
+        if (this.isTombstoneBlockedMemory(current)) {
+          const currentIdentity = this.offlineSyncMemoryIdentity(current);
+          if (currentIdentity !== targetIdentity) {
+            retryIdentity = currentIdentity;
+            return;
+          }
+        }
+        if (this.isTombstoneBlockedMemory(after) && await this.isDuplicateTombstoneBlockedOfflineSync(target, after, streamedIdentity)) {
+          return;
+        }
+        const marker = blocked ? await this.getTombstoneBlockedCaptureIndex().prepareWrite() : void 0;
+        let durable = false;
+        try {
+          await write();
+          durable = true;
+          if (marker) {
+            try {
+              await this.getTombstoneBlockedCaptureIndex().commitWrite(marker);
+            } catch (err) {
+              this.getTombstoneBlockedCaptureIndex().markUntrusted();
+              log.warn(`storage.offlineSyncFile committed write marker failed: ${err}`);
+            }
+          }
+          await this.invalidateAfterOfflineSyncMutation(target, marker);
+        } catch (err) {
+          if (marker && !durable) {
+            try {
+              await this.getTombstoneBlockedCaptureIndex().discardWrite(marker);
+            } catch (cleanupError) {
+              this.getTombstoneBlockedCaptureIndex().markUntrusted();
+              log.warn(`storage.offlineSyncFile failed to clear write marker: ${cleanupError}`);
+            }
+          }
+          throw err;
+        }
+      };
+      if (!blocked) {
+        await mutate();
+      } else {
+        if (streamedIdentity) {
+          await this.withTombstoneBlockedCaptureWriteLockAndHashes(
+            mutate,
+            identities,
+            [streamedIdentity.identityHash]
+          );
+        } else {
+          await this.withTombstoneBlockedCaptureWriteLock(mutate, identities);
+        }
+      }
+      if (retryIdentity !== void 0) continue;
+      return;
+    }
+  }
+  async writeTombstoneBlockedOfflineSyncFile(target, content) {
+    await this.runTombstoneBlockedOfflineSyncMutation(
+      target,
+      this.tombstoneBlockedCaptureIndexOptions().parseMemory?.(target, content) ?? null,
+      () => this.writeStorageSecureFile(target, content)
+    );
+  }
+  async prepareTombstoneBlockedOfflineSyncChunks(target, chunks) {
+    const parseMemory = this.tombstoneBlockedCaptureIndexOptions().parseMemory;
+    if (!parseMemory) return { after: null, chunks };
+    const iterator = chunks[Symbol.asyncIterator]();
+    const buffered = [];
+    let bufferedBytes = 0;
+    let firstOverflow;
+    for (; ; ) {
+      const next = await iterator.next();
+      if (next.done) break;
+      if (bufferedBytes + next.value.length > OFFLINE_SYNC_BUFFER_LIMIT_BYTES) {
+        firstOverflow = next.value;
+        break;
+      }
+      bufferedBytes += next.value.length;
+      buffered.push(next.value);
+    }
+    const overflow = firstOverflow;
+    if (overflow === void 0) {
+      let after = null;
+      try {
+        after = parseMemory(target, Buffer.concat(buffered));
+      } catch {
+        after = null;
+      }
+      const replay = (async function* () {
+        for (const chunk of buffered) yield chunk;
+      })();
+      return { after, chunks: replay };
+    }
+    const options = this.tombstoneBlockedCaptureIndexOptions();
+    const stagePath = path4.join(
+      options.stateDir,
+      "tombstone-blocked-capture",
+      "offline-sync-staging",
+      `${randomUUID2()}.stage`
+    );
+    const stagedChunks = (async function* () {
+      for (const chunk of buffered) yield chunk;
+      yield overflow;
+      for (; ; ) {
+        const next = await iterator.next();
+        if (next.done) break;
+        yield next.value;
+      }
+    })();
+    try {
+      await writeMaybeEncryptedFileFromChunks(
+        stagePath,
+        stagedChunks,
+        options.secureStoreWriteKeyProvider(),
+        { atomic: false },
+        options.memoryDir
+      );
+      return await this.describeStagedOfflineSyncChunks(target, stagePath, parseMemory);
+    } catch (err) {
+      await unlink2(stagePath).catch(() => {
+      });
+      throw err;
+    }
+  }
+  async describeStagedOfflineSyncChunks(target, stagePath, parseMemory) {
+    const options = this.tombstoneBlockedCaptureIndexOptions();
+    const key = options.secureStoreKeyProvider();
+    const bodyOffset = await findStagedBodyOffset(stagePath, key, options.memoryDir);
+    if (bodyOffset === null) {
+      return { after: null, chunks: this.readStagedOfflineSyncChunks(stagePath), stagePath };
+    }
+    const prefix = await readStagedPrefix(stagePath, bodyOffset, key, options.memoryDir);
+    let after = null;
+    try {
+      after = parseMemory(target, prefix.subarray(0, bodyOffset));
+    } catch {
+      after = null;
+    }
+    if (after === null) {
+      return { after: null, chunks: this.readStagedOfflineSyncChunks(stagePath), stagePath };
+    }
+    const streamedIdentity = await this.computeStagedOfflineSyncIdentity(stagePath, bodyOffset, after);
+    return {
+      after,
+      chunks: this.readStagedOfflineSyncChunks(stagePath),
+      stagePath,
+      streamedIdentity
+    };
+  }
+  async computeStagedOfflineSyncIdentity(stagePath, bodyOffset, after) {
+    let normalizedLength = 0;
+    const countNormalizer = createExplicitContentNormalizer((chunk) => {
+      normalizedLength += chunk.length;
+    });
+    const options = this.tombstoneBlockedCaptureIndexOptions();
+    const key = options.secureStoreKeyProvider();
+    await forEachStagedTextChunk(
+      stagePath,
+      bodyOffset,
+      (text) => countNormalizer.push(text),
+      key,
+      options.memoryDir
+    );
+    countNormalizer.finish();
+    const category = after.frontmatter.category;
+    const connector = after.frontmatter.sourceConnector?.trim() ?? "";
+    const encode = (label, value) => `${label} ${value.length} ${value}`;
+    const identityPrefix = [encode("category", category), encode("connector", connector), `content ${normalizedLength} `].join(" ");
+    const identityHash = createHash2("sha256");
+    identityHash.update(identityPrefix);
+    const identityNormalizer = createExplicitContentNormalizer((chunk) => identityHash.update(chunk));
+    await forEachStagedTextChunk(
+      stagePath,
+      bodyOffset,
+      (text) => identityNormalizer.push(text),
+      key,
+      options.memoryDir
+    );
+    identityNormalizer.finish();
+    return {
+      identityHash: identityHash.digest("hex")
+    };
+  }
+  async *readStagedOfflineSyncChunks(stagePath) {
+    const options = this.tombstoneBlockedCaptureIndexOptions();
+    for await (const chunk of readMaybeEncryptedFileFromChunks(
+      stagePath,
+      options.secureStoreKeyProvider(),
+      options.memoryDir
+    )) {
+      yield chunk;
+    }
+  }
+  async writeTombstoneBlockedOfflineSyncFileChunks(target, chunks) {
+    const coordinate = this.getTombstoneBlockedCaptureIndex().shouldRebuildAfterInvalidationForPath(target);
+    const prepared = coordinate ? await this.prepareTombstoneBlockedOfflineSyncChunks(target, chunks) : { after: null, chunks };
+    const streamedIdentity = prepared.streamedIdentity;
+    const mutate = async () => {
+      try {
+        await this.runTombstoneBlockedOfflineSyncMutation(
+          target,
+          prepared.after,
+          () => this.writeStorageSecureFileChunks(target, prepared.chunks),
+          coordinate,
+          streamedIdentity
+        );
+      } finally {
+        if (prepared.stagePath !== void 0) await unlink2(prepared.stagePath).catch(() => {
+        });
+      }
+    };
+    await mutate();
+  }
+  async writeOfflineSyncFile(filePath, content) {
+    const target = this.assertManagedStoragePath(filePath, "storage.writeOfflineSyncFile");
+    await this.writeTombstoneBlockedOfflineSyncFile(target, content);
+  }
+  async writeOfflineSyncFileChunks(filePath, chunks) {
+    const target = this.assertManagedStoragePath(filePath, "storage.writeOfflineSyncFileChunks");
+    await this.writeTombstoneBlockedOfflineSyncFileChunks(target, chunks);
+  }
+  async deleteOfflineSyncFile(filePath) {
+    const target = this.assertManagedStoragePath(filePath, "storage.deleteOfflineSyncFile");
+    await this.deleteTombstoneBlockedOfflineSyncFile(target);
+  }
+  async deleteTombstoneBlockedOfflineSyncFile(target) {
+    await this.runTombstoneBlockedOfflineSyncMutation(target, null, async () => {
+      await unlink2(target).catch((error) => {
+        if (isErrnoCode(error, "ENOENT")) return;
+        throw error;
+      });
+    });
+  }
+  async checkTombstoneBlockedExplicitCapture(...args) {
+    return this.getTombstoneBlockedCaptureIndex().check(...args);
+  }
+  async hasTombstoneBlockedExplicitCapture(...args) {
+    return this.getTombstoneBlockedCaptureIndex().has(...args);
+  }
+  async isTombstoneBlockedExplicitCaptureIndexAuthoritative() {
+    return this.getTombstoneBlockedCaptureIndex().isAuthoritative();
+  }
+  async rebuildTombstoneBlockedCaptureAfterInvalidationForPath(filePath, ownedMarker) {
+    const index = this.getTombstoneBlockedCaptureIndex();
+    if (index.shouldRebuildAfterInvalidationForPath(filePath)) {
+      await this.rebuildTombstoneBlockedCaptureAfterInvalidation(ownedMarker);
+    }
+  }
+  async rebuildTombstoneBlockedCaptureAfterInvalidation(ownedMarker) {
+    await this.getTombstoneBlockedCaptureIndex().rebuildAfterInvalidation(ownedMarker);
+  }
+};
+
+export {
+  CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
+  FactHashIndexNotAuthoritativeError,
+  ContentHashIndex,
+  isTombstoneBlockedCaptureWriteLockBusy,
+  normalizeExplicitCaptureContent,
+  buildExplicitCaptureDedupKey,
+  parseTombstoneBlockedOfflineSyncMemory,
+  TombstoneBlockedCaptureIndexHost
+};
+//# sourceMappingURL=chunk-FBUE6PD3.js.map