@remnic/core 10.0.48 → 10.0.49

package/src/embedding-index-storage.ts

@@ -18,6 +18,13 @@ import { randomUUID } from "node:crypto";
 import { constants as bufferConstants } from "node:buffer";
 import { lstat, mkdir, mkdtemp, realpath, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { log } from "./logger.js";
+import {
+  GENERATION_MARKER_IN_FLIGHT,
+  beginGenerationMarker as writeGenerationMarkerInFlight,
+  completeGenerationMarker as writeGenerationMarkerComplete,
+  generationMarkerPath,
+  writeGenerationMarkerRaw,
+} from "./embedding-generation-marker.js";
 import { readEnvVar } from "./runtime/env.js";
 import type { EmbeddingGenerationFence } from "./embedding-generation-lock.js";
 
@@ -166,21 +173,6 @@ function replacementBackupPath(shardDir: string): string {
   return path.join(path.dirname(shardDir), "embeddings.pre-replace.tmp");
 }
 
-/**
- * Warm-cache generation marker (`<stateDir>/embeddings.generation`).
- * Two-phase publication barrier: in-flight before a publication's first
- * destructive write, fresh unique value after its last write. A stamp is
- * therefore stable only for a completed generation — readers can never
- * cache a stamp that stays stable while generation bytes change, and an
- * in-flight stamp never repeats, so probes cached during a failed
- * completion keep revalidating (PR #3176 codex P2). Plain fs like the
- * status file.
- */
-const GENERATION_MARKER_BASENAME = "embeddings.generation";
-
-/** Reserved in-flight marker value; never equals a completion marker. */
-const GENERATION_MARKER_IN_FLIGHT = "in-flight";
-
 /**
  * Stable FNV-1a shard assignment: an entry always hashes to the same shard,
  * so an update or removal never needs a manifest to find its file.
@@ -535,34 +527,26 @@ export class EmbeddingIndexFileStore {
 
   /** Barrier first half: strict, so bytes can never change under a stable stamp. */
   private async beginGenerationMarker(): Promise<void> {
-    await this.writeGenerationMarker(GENERATION_MARKER_IN_FLIGHT);
+    await writeGenerationMarkerInFlight(generationMarkerPath(path.dirname(this.shardDir)));
   }
 
   /**
-   * Barrier second half: written after the last content write. Best-effort:
-   * a failure leaves the in-flight marker, whose stamp identityStamp()
-   * never repeats, so cached probes revalidate on every search until a
-   * publication completes.
+   * Barrier second half: written after the last content write. Best-effort;
+   * the in-flight fallback semantics live in the shared marker module.
    */
   private async completeGenerationMarker(): Promise<void> {
-    await this.writeGenerationMarker(randomUUID()).catch((err) => {
-      log.warn(`embedding index: could not write generation completion marker: ${err instanceof Error ? err.message : String(err)}`);
-    });
+    await writeGenerationMarkerComplete(generationMarkerPath(path.dirname(this.shardDir)));
   }
 
   private async writeGenerationMarker(value: string): Promise<void> {
-    await this.writeAtomicFile(
-      path.join(path.dirname(this.shardDir), GENERATION_MARKER_BASENAME),
-      value,
-      { bypassSecureIo: true },
-    );
+    await writeGenerationMarkerRaw(generationMarkerPath(path.dirname(this.shardDir)), value);
   }
 
   /** Marker value, or null when absent/unreadable (pre-marker stores keep the stat stamp). */
   private async readGenerationMarker(): Promise<string | null> {
     try {
       const raw = await readFile(
-        path.join(path.dirname(this.shardDir), GENERATION_MARKER_BASENAME),
+        generationMarkerPath(path.dirname(this.shardDir)),
         "utf-8",
       );
       const value = raw.trim();

package/src/index.ts

@@ -880,7 +880,7 @@ export {
   type OfflineSyncSnapshot,
   type OfflineSyncState,
 } from "./offline-sync.js";
-export { embeddingGenerationMembership, divergedEmbeddingGenerationDeferrals } from "./offline-sync-embedding-generation.js";
+export { advanceEmbeddingGenerationMarker, embeddingGenerationMembership, divergedEmbeddingGenerationDeferrals } from "./offline-sync-embedding-generation.js";
 export { EmbeddingIndexCapacityError, EmbeddingIndexFileStore, EmbeddingIndexStorageError, parseEmbeddingIndexDocument, serializeEmbeddingShard, shardEntriesForIndex, shardIndexOf, validateShardMembership } from "./embedding-index-storage.js";
 
 // ---------------------------------------------------------------------------

package/src/offline-sync-embedding-delete-digest.test.ts

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { withEmbeddingGenerationLock } from "./embedding-generation-lock.js";
+import { advanceEmbeddingGenerationMarker, embeddingGenerationMembership } from "./offline-sync-embedding-generation.js";
+
+// Issue #3182 review: a peer can publish a newer shard while converge waits
+// for the generation lock; the stale pre-lock digest must not delete it.
+test("a stale-digest deletion is rejected under the generation lock", async (t) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-3182-delete-digest-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const stateDir = path.join(root, "state");
+  const relative = "state/embeddings/shard-0000.json";
+  const target = path.join(root, relative);
+  const marker = path.join(stateDir, "embeddings.generation");
+  await mkdir(path.dirname(target), { recursive: true });
+  await writeFile(target, "older shard");
+  await writeFile(marker, "peer completed generation");
+  const staleSha256 = createHash("sha256").update("older shard").digest("hex");
+
+  let signalHeld: () => void;
+  const held = new Promise<void>((resolve) => { signalHeld = resolve; });
+  let releaseWriter: (() => void) | undefined;
+  const release = new Promise<void>((resolve) => { releaseWriter = resolve; });
+  assert.ok(releaseWriter);
+  const writer = withEmbeddingGenerationLock(stateDir, async () => {
+    signalHeld();
+    await release;
+    await writeFile(target, "newer peer shard");
+  });
+  await held;
+
+  let validated = false;
+  const deletion = advanceEmbeddingGenerationMarker(
+    root,
+    embeddingGenerationMembership(relative),
+    async () => {
+      assert.fail("deletion must never run when the digest is stale");
+    },
+    async () => {
+      validated = true;
+      if ((await readFile(target, "utf8")) !== "older shard") {
+        throw new Error("converge file changed before deletion");
+      }
+    },
+  );
+  const rejected = assert.rejects(deletion, /changed before deletion/);
+  releaseWriter();
+  await writer;
+  await rejected;
+
+  assert.equal(validated, true, "the digest precondition must run inside the lock");
+  assert.equal(await readFile(target, "utf8"), "newer peer shard");
+  assert.equal(await readFile(marker, "utf8"), "peer completed generation");
+});

package/src/offline-sync-embedding-generation-marker.test.ts

@@ -0,0 +1,245 @@
+// Issue #3182: the chunk-level pull path must advance the node-local
+// generation marker around direct shard writes; partial chunks and no-ops
+// must not disturb a valid completed stamp. Stat pinning emulates a
+// coarse-tick filesystem so only a marker advance can move the stamp.
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { lstat, mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import {
+  EmbeddingIndexFileStore,
+  type EmbeddingIndexEntry,
+  type EmbeddingIndexFile,
+  shardIndexOf,
+} from "./embedding-index-storage.js";
+import { applyOfflineSyncFileContentChunk } from "./offline-sync.js";
+
+// Pin the shard dir to one whole-millisecond tick, emulating a coarse-tick
+// filesystem where the pre- and post-write directory stats alias (same
+// technique as embedding-fallback-cross-process.test.ts).
+const TICK_SEC = 1_700_000_000.5;
+const MODEL = "text-embedding-3-small";
+
+function shardRelFor(id: string): string {
+  return `state/embeddings/shard-${String(shardIndexOf(id, 64)).padStart(4, "0")}.json`;
+}
+
+function indexFile(entries: Record<string, EmbeddingIndexEntry>): EmbeddingIndexFile {
+  return { version: 1, provider: "openai", model: MODEL, entries };
+}
+
+function shardDirOf(memoryDir: string): string {
+  return path.join(memoryDir, "state", "embeddings");
+}
+
+async function seedPublishedGeneration(memoryDir: string): Promise<EmbeddingIndexFileStore> {
+  const stateDir = path.join(memoryDir, "state");
+  const store = new EmbeddingIndexFileStore(
+    path.join(stateDir, "embeddings.json"),
+    path.join(stateDir, "embeddings"),
+    path.join(stateDir, "embedding-fallback-status.json"),
+  );
+  // Same fixture shape as embedding-index-storage.test.ts: a published
+  // sharded generation with one entry, completed through the store's
+  // two-phase marker.
+  await mkdir(path.join(stateDir, "embeddings"), { recursive: true });
+  await writeFile(
+    path.join(stateDir, "embeddings", shardRelFor("mem-old").split("/").pop()!),
+    JSON.stringify(indexFile({ "mem-old": { vector: [1, 0], path: "facts/old.md" } })),
+  );
+  await store.persist(indexFile({ "mem-old": { vector: [1, 0], path: "facts/old.md" } }), {
+    touchedIds: ["mem-old"],
+    memoryId: "mem-old",
+  });
+  return store;
+}
+
+async function readMarker(memoryDir: string): Promise<string> {
+  return (await readFile(path.join(memoryDir, "state", "embeddings.generation"), "utf-8")).trim();
+}
+
+async function pinShardDirStat(memoryDir: string): Promise<number> {
+  const shardDir = shardDirOf(memoryDir);
+  await utimes(shardDir, TICK_SEC, TICK_SEC);
+  return (await lstat(shardDir)).ino;
+}
+
+async function assertInoUnchanged(memoryDir: string, inoBefore: number): Promise<void> {
+  assert.equal(
+    (await lstat(shardDirOf(memoryDir))).ino,
+    inoBefore,
+    "precondition: the pull rewrote the shard in place (no directory swap)",
+  );
+}
+
+test("a completed offline-sync chunk write to a published shard moves the generation stamp", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-3182-chunk-"));
+  try {
+    const store = await seedPublishedGeneration(memoryDir);
+    const shardRel = shardRelFor("mem-old");
+    const updated = Buffer.from(
+      JSON.stringify(indexFile({ "mem-old": { vector: [0, 1], path: "facts/old.md" } })),
+      "utf-8",
+    );
+
+    const inoBefore = await pinShardDirStat(memoryDir);
+    const markerBefore = await readMarker(memoryDir);
+    const stampBefore = await store.identityStamp();
+    assert.equal(await store.identityStamp(), stampBefore, "precondition: the completed stamp is stable");
+
+    // The chunk-level pull path used by converge pulls and CLI hydrate:
+    // no IO hooks, plain fs final write (writeSafeFileFromUpload).
+    const result = await applyOfflineSyncFileContentChunk({
+      root: memoryDir,
+      sourceId: "remote",
+      path: shardRel,
+      sha256: createHash("sha256").update(updated).digest("hex"),
+      bytes: updated.length,
+      mtimeMs: 1000,
+      offset: 0,
+      content: updated,
+    });
+    assert.equal(result.applied, true, "precondition: the shard write applied");
+
+    // Force the exact stat the stamp reads so only a marker advance can move it.
+    await utimes(shardDirOf(memoryDir), TICK_SEC, TICK_SEC);
+    await assertInoUnchanged(memoryDir, inoBefore);
+
+    assert.notEqual(
+      await readMarker(memoryDir),
+      markerBefore,
+      "a peer pull that published new generation bytes must advance the generation marker",
+    );
+    const stampAfter = await store.identityStamp();
+    assert.notEqual(
+      stampAfter,
+      stampBefore,
+      "a peer pull that changed generation bytes must move the warm-cache stamp even when the directory stat aliases",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true }).catch(() => undefined);
+  }
+});
+
+test("a partial chunk (staging only) must not invalidate a valid completed stamp", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-3182-partial-"));
+  try {
+    const store = await seedPublishedGeneration(memoryDir);
+    const shardRel = shardRelFor("mem-old");
+    const onDiskBefore = await readFile(path.join(memoryDir, ...shardRel.split("/")));
+
+    const updated = Buffer.from(
+      JSON.stringify(indexFile({ "mem-old": { vector: [0, 1], path: "facts/old.md" } })),
+      "utf-8",
+    );
+    const inoBefore = await pinShardDirStat(memoryDir);
+    const markerBefore = await readMarker(memoryDir);
+    const stampBefore = await store.identityStamp();
+
+    const result = await applyOfflineSyncFileContentChunk({
+      root: memoryDir,
+      sourceId: "remote",
+      path: shardRel,
+      sha256: createHash("sha256").update(updated).digest("hex"),
+      bytes: updated.length,
+      mtimeMs: 1000,
+      offset: 0,
+      content: updated.subarray(0, Math.floor(updated.length / 2)),
+    });
+    assert.equal(result.done, false, "precondition: the chunk is partial");
+    assert.deepEqual(
+      await readFile(path.join(memoryDir, ...shardRel.split("/"))),
+      onDiskBefore,
+      "precondition: a partial chunk spools to staging, never to the generation",
+    );
+
+    await utimes(shardDirOf(memoryDir), TICK_SEC, TICK_SEC);
+    await assertInoUnchanged(memoryDir, inoBefore);
+
+    assert.equal(await readMarker(memoryDir), markerBefore, "a staging-only write must not touch the generation marker");
+    assert.equal(
+      await store.identityStamp(),
+      stampBefore,
+      "no generation bytes changed: the completed stamp must stay valid so warm caches keep working",
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true }).catch(() => undefined);
+  }
+});
+
+test("a skipped no-op chunk (content already identical) must not invalidate the stamp", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-3182-noop-"));
+  try {
+    const store = await seedPublishedGeneration(memoryDir);
+    const shardRel = shardRelFor("mem-old");
+    const onDisk = await readFile(path.join(memoryDir, ...shardRel.split("/")));
+
+    const inoBefore = await pinShardDirStat(memoryDir);
+    const markerBefore = await readMarker(memoryDir);
+    const stampBefore = await store.identityStamp();
+
+    const result = await applyOfflineSyncFileContentChunk({
+      root: memoryDir,
+      sourceId: "remote",
+      path: shardRel,
+      sha256: createHash("sha256").update(onDisk).digest("hex"),
+      bytes: onDisk.length,
+      mtimeMs: 1000,
+      offset: 0,
+      content: onDisk,
+    });
+    assert.equal(result.skipped, true, "precondition: identical content is a no-op");
+
+    await utimes(shardDirOf(memoryDir), TICK_SEC, TICK_SEC);
+    await assertInoUnchanged(memoryDir, inoBefore);
+
+    assert.equal(await readMarker(memoryDir), markerBefore, "a no-op must not touch the generation marker");
+    assert.equal(await store.identityStamp(), stampBefore, "no generation bytes changed: the stamp stays valid");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true }).catch(() => undefined);
+  }
+});
+
+test("a failed direct shard write leaves the marker in-flight: the stamp never repeats", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-3182-failed-"));
+  try {
+    const store = await seedPublishedGeneration(memoryDir);
+    const shardRel = shardRelFor("mem-old");
+    const updated = Buffer.from(
+      JSON.stringify(indexFile({ "mem-old": { vector: [0, 1], path: "facts/old.md" } })),
+      "utf-8",
+    );
+
+    const stampBefore = await store.identityStamp();
+
+    // Force the final destructive write to fail: the publish rename cannot
+    // replace the shard file with a directory in its place.
+    const shardAbs = path.join(memoryDir, ...shardRel.split("/"));
+    await rm(shardAbs);
+    await mkdir(shardAbs);
+
+    await assert.rejects(
+      applyOfflineSyncFileContentChunk({
+        root: memoryDir,
+        sourceId: "remote",
+        path: shardRel,
+        sha256: createHash("sha256").update(updated).digest("hex"),
+        bytes: updated.length,
+        mtimeMs: 1000,
+        offset: 0,
+        content: updated,
+      }),
+    );
+
+    assert.equal(await readMarker(memoryDir), "in-flight", "a failed publication must leave the in-flight barrier");
+    const probeA = await store.identityStamp();
+    const probeB = await store.identityStamp();
+    assert.notEqual(probeA, probeB, "an in-flight stamp never repeats, so cached probes keep revalidating");
+    assert.notEqual(probeA, stampBefore);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true }).catch(() => undefined);
+  }
+});

package/src/offline-sync-embedding-generation.ts

@@ -45,7 +45,12 @@ import type {
   OfflineSyncFileStagingWriteTarget,
   OfflineSyncFileState,
 } from "./offline-sync.js";
-import { type SafeArchiveRoot, resolveSafeArchiveTarget } from "./transfer/fs-utils.js";
+import { type SafeArchiveRoot, prepareSafeArchiveRoot, resolveSafeArchiveTarget } from "./transfer/fs-utils.js";
+import {
+  GENERATION_MARKER_BASENAME,
+  beginGenerationMarker,
+  completeGenerationMarker,
+} from "./embedding-generation-marker.js";
 
 const EMBEDDING_MARKER_BASENAME = "embeddings.json";
 export const EMBEDDING_SHARD_DIR_BASENAME = "embeddings";
@@ -95,7 +100,12 @@ export function embeddingMarkerDirOf(relPath: string): string | null {
  * `.../embeddings` directory, the legacy marker belongs to the sibling
  * `.../embeddings` directory of its state dir.
  */
-export function embeddingGenerationMembership(relPath: string): { kind: "shard" | "marker"; shardDir: string } | null {
+export interface EmbeddingGenerationMembership {
+  kind: "shard" | "marker";
+  shardDir: string;
+}
+
+export function embeddingGenerationMembership(relPath: string): EmbeddingGenerationMembership | null {
   const shardDir = embeddingShardDirOf(relPath);
   if (shardDir) return { kind: "shard", shardDir };
   const markerDir = embeddingMarkerDirOf(relPath);
@@ -103,6 +113,41 @@ export function embeddingGenerationMembership(relPath: string): { kind: "shard"
   return null;
 }
 
+/**
+ * Advance the node-local generation marker around one out-of-band destructive
+ * write or delete of a generation member (issue #3182); the fence reasserts
+ * lock ownership so a stale-broken lock never publishes a stable marker over
+ * a peer's write. Callers must not already hold the generation lock — the
+ * snapshot removal deletes members under it, which is why converge hooks its
+ * own call sites, not the shared IO adapter.
+ */
+export async function advanceEmbeddingGenerationMarker<T>(
+  rootAbs: string,
+  membership: EmbeddingGenerationMembership | null,
+  write: () => Promise<T>,
+  validate?: () => Promise<void>,
+): Promise<T> {
+  if (!membership) {
+    await validate?.();
+    return write();
+  }
+  const root = await prepareSafeArchiveRoot(rootAbs, "advanceEmbeddingGenerationMarker", "root");
+  const stateDirRel = membership.shardDir.slice(0, -`/${EMBEDDING_SHARD_DIR_BASENAME}`.length);
+  const stateDirAbs = await resolveSafeArchiveTarget(root, stateDirRel);
+  const lockPath = embeddingGenerationLockPath(stateDirAbs);
+  return await withEmbeddingGenerationLock(stateDirAbs, async (section) => {
+    const markerAbs = await resolveSafeArchiveTarget(root, `${stateDirRel}/${GENERATION_MARKER_BASENAME}`);
+    await validate?.();
+    await assertEmbeddingGenerationLockHeld(lockPath, section);
+    await beginGenerationMarker(markerAbs);
+    await assertEmbeddingGenerationLockHeld(lockPath, section);
+    const result = await write();
+    await assertEmbeddingGenerationLockHeld(lockPath, section);
+    await completeGenerationMarker(markerAbs);
+    return result;
+  });
+}
+
 export interface IncomingEmbeddingGenerations {
   /** Generation dirs with at least one incoming shard. */
   shardDirs: Set<string>;

package/src/offline-sync-embedding-lock-loss.test.ts

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import { syncBuiltinESMExports } from "node:module";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { EmbeddingGenerationLockLostError, embeddingGenerationLockPath } from "./embedding-generation-lock.js";
+import { advanceEmbeddingGenerationMarker, embeddingGenerationMembership } from "./offline-sync-embedding-generation.js";
+
+// Lose ownership exactly after the in-flight rename, before any content write.
+test("a direct embedding mutation rechecks ownership after its in-flight marker", async (t) => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "remnic-embedding-fence-"));
+  const stateDir = path.join(root, "state");
+  const relative = "state/embeddings/shard-0000.json";
+  const target = path.join(root, relative);
+  const marker = path.join(stateDir, "embeddings.generation");
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await fs.writeFile(target, "winning generation");
+  await fs.writeFile(marker, "completed generation");
+  const rename = fs.rename;
+  t.mock.method(fs, "rename", async (source: Parameters<typeof rename>[0], destination: Parameters<typeof rename>[1]) => {
+    await rename(source, destination);
+    if (String(destination) === marker && await fs.readFile(marker, "utf8") === "in-flight") {
+      await fs.unlink(embeddingGenerationLockPath(stateDir));
+      await fs.writeFile(marker, "peer completed generation");
+    }
+  });
+  syncBuiltinESMExports();
+  t.after(() => { t.mock.restoreAll(); syncBuiltinESMExports(); });
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+  let writes = 0;
+  await assert.rejects(
+    advanceEmbeddingGenerationMarker(root, embeddingGenerationMembership(relative), async () => {
+      writes++;
+      await fs.writeFile(target, "stale owner's generation");
+    }),
+    EmbeddingGenerationLockLostError,
+  );
+  assert.equal(writes, 0, "a lost owner must stop before touching generation bytes");
+  assert.equal(await fs.readFile(target, "utf8"), "winning generation");
+  assert.equal(await fs.readFile(marker, "utf8"), "peer completed generation");
+});

package/src/offline-sync.ts

@@ -32,6 +32,7 @@ import { isMacOsReplicationJunkBasename } from "./utils/macos-replication-junk.j
 import {
   applyIncomingEmbeddingGenerations,
   assertEmbeddingGenerationStillIncluded,
+  advanceEmbeddingGenerationMarker,
   computeOmittedEmbeddingGenerationPaths,
   divergedEmbeddingGenerationDeferrals,
   embeddingGenerationMembership,
@@ -2466,7 +2467,9 @@ export async function applyOfflineSyncFileContentChunk(options: {
       };
     }
 
-    await writeSafeFileFromUpload(root, relPath, upload, options.readFile, options.writeFileChunks, mtimeMs);
+    await advanceEmbeddingGenerationMarker(root.abs, embeddingGenerationMembership(relPath), () =>
+      writeSafeFileFromUpload(root, relPath, upload, options.readFile, options.writeFileChunks, mtimeMs),
+    );
     return {
       ...baseResult,
       applied: true,

package/src/storage.ts

@@ -17,6 +17,7 @@ import { computeLegacyContentHash, normalizeContent } from "./content-hash.js";
 import { parseDriftProvenance, serializeDriftProvenance } from "./preferences/drift-types.js";
 import { isAbortError, raceAbort } from "./abort-error.js";
 import { checkCorpusReadAbort, type CorpusReadOptions } from "./corpus-read-cancellation.js";
+import { scopedCaptureWriteLockLimits } from "./capture-write-lock-scope.js";
 import { selectArtifactMatches, type ArtifactSearchOptions } from "./artifact-search.js";
 import path from "node:path";
 import { resolveSafeStoragePath } from "./storage-paths.js";
@@ -3241,7 +3242,7 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
    * resolves to the legacy short bounds instead of the converge deadline.
    */
   private captureLockLimitSource(): ContentHashIndexLockOptions | undefined {
-    const options = this.factHashIndexLockOptions;
+    const options = { ...this.factHashIndexLockOptions, ...scopedCaptureWriteLockLimits(this) };
     const keys = ["captureWriteLockInitialDelayMs", "captureWriteLockMaxDelayMs", "captureWriteLockDeadlineMs", "captureWriteLockSignal"] as const;
     return keys.some((key) => options[key] !== undefined) ? options : undefined;
   }