@remnic/core 10.0.84 → 10.0.85

package/src/namespaces/search.test.ts

@@ -831,6 +831,345 @@ test("healthForNamespace stops waiting when namespace availability probe aborts"
   assert.equal(backend.disposed, 1);
 });
 
+test("healthForNamespace reuses a completed result within the TTL without re-probing", async (t) => {
+  t.mock.timers.enable({ apis: ["Date"], now: 1_700_000_000_000 });
+  try {
+    const created: FakeBackend[] = [];
+    const router = new NamespaceSearchRouter(
+      config(),
+      { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+      () => {
+        const backend = new FakeBackend(false, [], { check: "present" }, false, {
+          debugStatus: "cached-health",
+        });
+        backend.statusResult = {
+          pendingEmbeddings: 3,
+          oldestPendingAgeMs: 1_000,
+          totalFiles: 10,
+          embeddedFiles: 7,
+        };
+        created.push(backend);
+        return backend;
+      },
+    );
+
+    const first = await router.healthForNamespace("shared");
+    const second = await router.healthForNamespace("shared");
+
+    assert.equal(created.length, 1, "second call must not create another backend probe");
+    assert.equal(created[0]?.availabilitySignals.length, 1);
+    assert.deepEqual(created[0]?.checkCollections, ["openclaw-engram--ns-736861726564"]);
+    assert.deepEqual(first, second);
+    assert.equal(first.debugStatus, "cached-health");
+    assert.equal(first.pendingEmbeddings, 3);
+
+    first.available = false;
+    first.debugStatus = "mutated";
+    const third = await router.healthForNamespace("shared");
+    assert.equal(third.available, true, "returned health objects must be copies");
+    assert.equal(third.debugStatus, "cached-health");
+    assert.equal(created.length, 1);
+  } finally {
+    t.mock.timers.reset();
+  }
+});
+
+test("healthForNamespace re-probes after the health result TTL elapses", async (t) => {
+  t.mock.timers.enable({ apis: ["Date"], now: 1_700_000_000_000 });
+  try {
+    const created: FakeBackend[] = [];
+    const router = new NamespaceSearchRouter(
+      config(),
+      { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+      () => {
+        const backend = new FakeBackend(false, [], { check: "present" });
+        backend.statusResult = {
+          pendingEmbeddings: created.length,
+          oldestPendingAgeMs: 0,
+          totalFiles: 1,
+          embeddedFiles: 1,
+        };
+        created.push(backend);
+        return backend;
+      },
+    );
+
+    const first = await router.healthForNamespace("shared");
+    assert.equal(created.length, 1);
+    assert.equal(first.pendingEmbeddings, 0);
+
+    t.mock.timers.tick(10_000);
+    const second = await router.healthForNamespace("shared");
+
+    assert.equal(created.length, 2, "TTL expiry must force a fresh backend probe");
+    assert.equal(second.pendingEmbeddings, 1);
+    assert.equal(created[0]?.disposed, 1);
+    assert.equal(created[1]?.disposed, 1);
+  } finally {
+    t.mock.timers.reset();
+  }
+});
+
+test("healthForNamespace clearCache forces a re-probe before the TTL", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false, [], { check: "present" });
+      backend.statusResult = {
+        pendingEmbeddings: created.length + 1,
+        oldestPendingAgeMs: 0,
+        totalFiles: 1,
+        embeddedFiles: 1,
+      };
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  const first = await router.healthForNamespace("shared");
+  assert.equal(created.length, 1);
+  assert.equal(first.pendingEmbeddings, 1);
+
+  router.clearCache();
+  const second = await router.healthForNamespace("shared");
+
+  assert.equal(created.length, 2, "clearCache must drop the health result cache");
+  assert.equal(second.pendingEmbeddings, 2);
+});
+
+test("healthForNamespace does not cache a thrown probe", async () => {
+  let attempts = 0;
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    {
+      storageFor: async (namespace: string) => {
+        attempts += 1;
+        if (attempts === 1) {
+          throw new Error("storage unavailable");
+        }
+        return { dir: `/tmp/remnic/${namespace}` };
+      },
+    },
+    () => {
+      const backend = new FakeBackend(false, [], { check: "present" });
+      backend.statusResult = {
+        pendingEmbeddings: 9,
+        oldestPendingAgeMs: 0,
+        totalFiles: 1,
+        embeddedFiles: 1,
+      };
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  await assert.rejects(
+    () => router.healthForNamespace("shared"),
+    /storage unavailable/,
+  );
+  assert.equal(created.length, 0, "failed call must not create a backend");
+
+  const health = await router.healthForNamespace("shared");
+  assert.equal(health.pendingEmbeddings, 9);
+  assert.equal(created.length, 1);
+
+  const cached = await router.healthForNamespace("shared");
+  assert.equal(created.length, 1, "only the successful result is cached");
+  assert.deepEqual(cached, health);
+});
+
+test("healthForNamespace does not cache an unavailable answer", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false, [], { check: "present" });
+      if (created.length === 0) {
+        backend.available = false;
+      }
+      backend.statusResult = {
+        pendingEmbeddings: created.length,
+        oldestPendingAgeMs: 0,
+        totalFiles: 1,
+        embeddedFiles: 1,
+      };
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  const first = await router.healthForNamespace("shared");
+  assert.equal(first.available, false);
+  assert.equal(created.length, 1);
+
+  const second = await router.healthForNamespace("shared");
+  assert.equal(second.available, true, "recovery must be visible on the next probe");
+  assert.equal(created.length, 2, "unavailable answers must not be cached");
+});
+
+test("healthForNamespace does not cache a missing-collection answer", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(
+        false,
+        [],
+        created.length === 0 ? { check: "missing" } : { check: "present" },
+      );
+      backend.statusResult = {
+        pendingEmbeddings: created.length,
+        oldestPendingAgeMs: 0,
+        totalFiles: 1,
+        embeddedFiles: 1,
+      };
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  const first = await router.healthForNamespace("shared");
+  assert.equal(first.collectionState, "missing");
+  assert.equal(created.length, 1);
+
+  const second = await router.healthForNamespace("shared");
+  assert.equal(second.collectionState, "present", "collection recovery must re-probe");
+  assert.equal(created.length, 2, "missing-collection answers must not be cached");
+});
+
+function routerWithDegradedFirstProbe(
+  created: FakeBackend[],
+  firstCheck: CollectionState,
+  degradeFirst: (backend: FakeBackend) => void,
+): NamespaceSearchRouter {
+  return new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const isFirst = created.length === 0;
+      const backend = new FakeBackend(false, [], { check: isFirst ? firstCheck : "present" });
+      backend.statusResult = {
+        pendingEmbeddings: 10,
+        oldestPendingAgeMs: 0,
+        totalFiles: 1,
+        embeddedFiles: 1,
+      };
+      if (isFirst) degradeFirst(backend);
+      created.push(backend);
+      return backend;
+    },
+  );
+}
+
+test("healthForNamespace does not cache an unknown-collection answer", async () => {
+  const created: FakeBackend[] = [];
+  const router = routerWithDegradedFirstProbe(created, "unknown", () => {});
+
+  const first = await router.healthForNamespace("shared");
+  assert.equal(first.collectionState, "unknown");
+
+  const second = await router.healthForNamespace("shared");
+  assert.equal(second.collectionState, "present", "recovery must be visible on the next probe");
+  assert.equal(created.length, 2, "unknown-collection answers must not be cached");
+});
+
+test("healthForNamespace does not cache an answer whose backend status failed", async () => {
+  const created: FakeBackend[] = [];
+  const router = routerWithDegradedFirstProbe(created, "present", (backend) => {
+    backend.statusResult = null;
+  });
+
+  const first = await router.healthForNamespace("shared");
+  assert.equal(first.pendingEmbeddings, null);
+
+  const second = await router.healthForNamespace("shared");
+  assert.equal(second.pendingEmbeddings, 10, "backlog data must be visible on the next probe");
+  assert.equal(created.length, 2, "answers without backlog data must not be cached");
+});
+
+test("healthForNamespace does not cache a backlog over the threshold", async () => {
+  const created: FakeBackend[] = [];
+  const router = routerWithDegradedFirstProbe(created, "present", (backend) => {
+    backend.statusResult = {
+      pendingEmbeddings: config().qmdEmbeddingBacklogThreshold + 1,
+      oldestPendingAgeMs: 0,
+      totalFiles: 1,
+      embeddedFiles: 1,
+    };
+  });
+
+  await router.healthForNamespace("shared");
+
+  const second = await router.healthForNamespace("shared");
+  assert.equal(second.pendingEmbeddings, 10, "a drained backlog must be visible on the next probe");
+  assert.equal(created.length, 2, "over-threshold answers must not be cached");
+});
+
+test("healthForNamespace dispose drops the health result cache", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false, [], { check: "present" });
+      backend.statusResult = {
+        pendingEmbeddings: created.length + 1,
+        oldestPendingAgeMs: 0,
+        totalFiles: 1,
+        embeddedFiles: 1,
+      };
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  const first = await router.healthForNamespace("shared");
+  assert.equal(created.length, 1);
+  assert.equal(first.pendingEmbeddings, 1);
+
+  await router.dispose();
+  const second = await router.healthForNamespace("shared");
+
+  assert.equal(created.length, 2, "dispose must drop the health result cache");
+  assert.equal(second.pendingEmbeddings, 2);
+});
+
+test("healthForNamespace disableSearchBackends drops the health result cache", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false, [], { check: "present" });
+      backend.statusResult = {
+        pendingEmbeddings: created.length + 1,
+        oldestPendingAgeMs: 0,
+        totalFiles: 1,
+        embeddedFiles: 1,
+      };
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  const first = await router.healthForNamespace("shared");
+  assert.equal(created.length, 1);
+  assert.equal(first.pendingEmbeddings, 1);
+
+  await router.disableSearchBackends();
+  const second = await router.healthForNamespace("shared");
+
+  assert.equal(created.length, 2, "disableSearchBackends must drop the health result cache");
+  assert.equal(second.pendingEmbeddings, 2);
+});
+
+
+
 test("ensureNamespaceCollection does not cache aborted namespace backend probes", async () => {
   const created: FakeBackend[] = [];
   const router = new NamespaceSearchRouter(

package/src/namespaces/search.ts

@@ -14,6 +14,9 @@ import { ALL_CATEGORY_DIRS } from "../utils/category-dir.js";
 const NESTED_NAMESPACE_FILTER_OVERFETCH_FACTOR = 4;
 const NESTED_NAMESPACE_FILTER_OVERFETCH_MIN = 50;
 
+// Short TTL so repeated health polls skip a full QMD re-probe (~1.5s).
+const HEALTH_RESULT_CACHE_TTL_MS = 10_000;
+
 export function namespaceCollectionName(
   baseCollection: string,
   namespace: string,
@@ -72,6 +75,27 @@ export interface NamespaceSearchHealth {
   embeddingBacklogThreshold: number;
 }
 
+/** True when the pending-embedding count is above a positive backlog threshold. */
+export function embeddingBacklogExceeds(pending: number | null, threshold: number): boolean {
+  return threshold > 0 && pending !== null && pending > threshold;
+}
+
+/**
+ * The one definition of a degraded search answer. The readiness consumer
+ * reports it, and `healthForNamespace` refuses to cache it.
+ */
+export function isSearchHealthDegraded(
+  health: Pick<NamespaceSearchHealth, "available" | "collectionState" | "pendingEmbeddings">,
+  backlogThreshold: number,
+): boolean {
+  const active = health.available && health.collectionState !== "missing";
+  return (
+    !active ||
+    health.collectionState === "unknown" ||
+    embeddingBacklogExceeds(health.pendingEmbeddings, backlogThreshold)
+  );
+}
+
 type NamespaceScopedSearchConfig = PluginConfig & {
   hostEmbeddingProviderScope?: string;
 };
@@ -84,6 +108,11 @@ type BackendRecordOptions = {
 
 export class NamespaceSearchRouter {
   private readonly cache = new Map<string, Promise<NamespaceBackendRecord>>();
+  private readonly healthResultCache = new Map<
+    string,
+    { expiresAt: number; value: NamespaceSearchHealth }
+  >();
+
   private readonly pendingDisposals = new Set<Promise<void>>();
 
   constructor(
@@ -279,6 +308,11 @@ export class NamespaceSearchRouter {
     execution?: SearchExecutionOptions,
   ): Promise<NamespaceSearchHealth> {
     const key = namespace.trim() || this.config.defaultNamespace;
+    const cached = this.healthResultCache.get(key);
+    if (cached && cached.expiresAt > Date.now()) {
+      return { ...cached.value };
+    }
+
     const record = await this.createBackendRecordFor(
       key,
       execution,
@@ -310,7 +344,7 @@ export class NamespaceSearchRouter {
           ? "missing"
           : record.collectionState;
 
-      return {
+      const health: NamespaceSearchHealth = {
         collection: record.collection,
         memoryDir: record.memoryDir,
         available: liveRecord?.available ?? record.available,
@@ -326,6 +360,22 @@ export class NamespaceSearchRouter {
         oldestPendingAgeMs: backendStatus?.oldestPendingAgeMs ?? null,
         embeddingBacklogThreshold: this.config.qmdEmbeddingBacklogThreshold,
       };
+
+      // Cache only a healthy answer that carries backlog data when the backend
+      // reports status. A degraded or incomplete answer must re-probe so a
+      // readiness poll sees recovery on the next call, not one TTL late.
+      const statusMissing = backendStatus === null && "status" in diagnosticBackend;
+      if (
+        execution?.signal?.aborted !== true &&
+        !statusMissing &&
+        !isSearchHealthDegraded(health, health.embeddingBacklogThreshold)
+      ) {
+        this.healthResultCache.set(key, {
+          expiresAt: Date.now() + HEALTH_RESULT_CACHE_TTL_MS,
+          value: { ...health },
+        });
+      }
+      return { ...health };
     } finally {
       const dispose = (record.backend as { dispose?: () => void | Promise<void> }).dispose;
       await dispose?.call(record.backend);
@@ -358,6 +408,7 @@ export class NamespaceSearchRouter {
 
   /** Clear cached backend records so the next access re-probes availability. */
   clearCache(): void {
+    this.healthResultCache.clear();
     const pendingRecords = Array.from(this.cache.values());
     this.cache.clear();
     const disposal = Promise.allSettled(pendingRecords).then(async (settled) => {
@@ -379,6 +430,7 @@ export class NamespaceSearchRouter {
   /** Release any per-namespace backend handles held by cached records. */
   async dispose(): Promise<void> {
     await this.drainPendingDisposals();
+    this.healthResultCache.clear();
     const pendingRecords = Array.from(this.cache.values());
     this.cache.clear();
     const settled = await Promise.allSettled(pendingRecords);
@@ -395,6 +447,7 @@ export class NamespaceSearchRouter {
    * has been switched to NoopSearchBackend for a missing collection.
    */
   async disableSearchBackends(): Promise<void> {
+    this.healthResultCache.clear();
     const settled = await Promise.allSettled(this.cache.values());
     await Promise.allSettled(
       settled.flatMap((entry) => {

package/src/orchestration/backlog-scheduler.ts

@@ -25,6 +25,7 @@
  * every claim retryable; a restarted daemon's scheduler adopts them.
  */
 
+import { randomUUID } from "node:crypto";
 import { hostname } from "node:os";
 import { log } from "../logger.js";
 import type { Orchestrator } from "../orchestrator.js";
@@ -44,8 +45,8 @@ export interface BacklogSchedulerDeps {
   liveBufferCounts():
     | Map<string, { turns: number; retainedTurns: number }>
     | Promise<Map<string, { turns: number; retainedTurns: number }>>;
-  /** A fresh lease for claims this scheduler takes. */
-  lease(): DrainLease;
+  /** Create a fresh lease for a unique owner token. */
+  lease(ownerId: string): DrainLease;
   /** Drain one key to quiescence (BufferDrainRunner.drainSession). */
   drainKey(
     key: string,
@@ -63,6 +64,7 @@ export interface BacklogSchedulerDeps {
 }
 
 export interface BacklogSchedulerOptions {
+  /** Optional label prefix; each scheduler instance adds a unique token. */
   ownerId?: string;
   /** Scan cadence in ms (startup + new-work + retry checks). */
   pollMs?: number;
@@ -135,7 +137,7 @@ export class BacklogScheduler {
   constructor(deps: BacklogSchedulerDeps, options: BacklogSchedulerOptions = {}) {
     this.deps = deps;
     this.options = {
-      ownerId: options.ownerId ?? `daemon-drain-${process.pid}`,
+      ownerId: `${options.ownerId ?? "daemon-drain"}-${randomUUID()}`,
       pollMs: options.pollMs ?? DEFAULT_POLL_MS,
       retryBaseMs: options.retryBaseMs ?? DEFAULT_RETRY_BASE_MS,
       retryMaxMs: options.retryMaxMs ?? DEFAULT_RETRY_MAX_MS,
@@ -333,11 +335,11 @@ export class BacklogScheduler {
     const { promise: settled, resolve: settle } = Promise.withResolvers<void>();
     this.inFlight.set(key, { controller, settled });
     try {
-      if (!(await this.claimForSubmit(key, needsClaim))) return;
+      if (!(await this.claimForSubmit(key, needsClaim, this.options.ownerId))) return;
       // Stopped between the claim decision and the task: leave the claim
       // with its lease (it expires; the next start adopts) — never drain.
       if (this.stopped) return;
-      await this.drainClaimedKey(key, controller.signal);
+      await this.drainClaimedKey(key, controller.signal, this.options.ownerId);
     } catch (err) {
       // Claim/drain failures are scheduler-level: the claim content is
       // untouched — count failed and back off (never an unhandled rejection
@@ -357,10 +359,10 @@ export class BacklogScheduler {
   }
 
   /** after all — the key goes quiet without a task. "claimed": ours. */
-  private async claimForSubmit(key: string, needsClaim: boolean): Promise<boolean> {
+  private async claimForSubmit(key: string, needsClaim: boolean, ownerId: string): Promise<boolean> {
     if (!needsClaim) return true;
     try {
-      const outcome = await this.deps.claims.claimFromSessionFile(key, this.deps.lease());
+      const outcome = await this.deps.claims.claimFromSessionFile(key, this.deps.lease(ownerId));
       if (outcome === "empty") {
         this.keys.delete(key);
         return false;
@@ -375,11 +377,11 @@ export class BacklogScheduler {
   /** Drain one claimed key. drainKey reports failures as outcomes; a thrown
    *  error still means the claim content is intact — count it failed and
    *  back off. */
-  private async drainClaimedKey(key: string, signal: AbortSignal): Promise<void> {
+  private async drainClaimedKey(key: string, signal: AbortSignal, ownerId: string): Promise<void> {
     this.counters.claimed += 1;
     try {
       const outcome = await this.deps.drainKey(key, {
-        ownerId: this.options.ownerId,
+        ownerId,
         signal,
       });
       this.applyOutcome(key, outcome);
@@ -480,7 +482,6 @@ export function wireBacklogScheduler(
   orchestrator: Orchestrator,
   options: BacklogSchedulerOptions = {}
 ): BacklogScheduler {
-  const ownerId = options.ownerId ?? `daemon-drain-${process.pid}`;
   const runner = new BufferDrainRunner(orchestrator);
   return new BacklogScheduler(
     {
@@ -492,7 +493,7 @@ export function wireBacklogScheduler(
         await orchestrator.buffer.load();
         return orchestrator.buffer.entryCounts();
       },
-      lease: () => {
+      lease: (ownerId) => {
         const now = new Date().toISOString();
         return {
           ownerId,
@@ -508,6 +509,6 @@ export function wireBacklogScheduler(
       // claim-backed drain accumulate toward the same threshold).
       breakerSnapshot: () => orchestrator.getExtractionResilienceStatus().breaker,
     },
-    { ...options, ownerId }
+    options
   );
 }

package/src/orchestration/buffer-drain-runner.ts

@@ -74,27 +74,35 @@ const DEFAULT_LEASE_MS = 120_000;
  * A `BufferStorage` view of one drain claim: the claim file IS the buffer.
  * Writes are the drain's progress (what is left to extract), so every
  * successfully extracted chunk is durably removed before the next one runs.
+ *
+ * `seen` is the drainer's own view of the claim: the entry it loaded, then the
+ * entry it last wrote. Each progress write is diffed against it, so a write
+ * records only the turns extracted since the previous one.
  */
 export class ClaimBufferStorage implements BufferStorage {
+  private seen: BufferEntryState;
+
   constructor(
     private readonly claims: BufferDrainClaims,
     private readonly key: string,
     private readonly ownerId: string,
-    private readonly entry: BufferEntryState
-  ) {}
+    entry: BufferEntryState
+  ) {
+    this.seen = entry;
+  }
 
   async loadBuffer(): Promise<BufferState> {
     const entries: NonNullable<BufferState["entries"]> = Object.create(null);
     entries[this.key] = {
-      turns: this.entry.turns,
-      retainedTurns: this.entry.retainedTurns,
-      lastExtractionAt: this.entry.lastExtractionAt,
-      extractionCount: this.entry.extractionCount,
+      turns: this.seen.turns,
+      retainedTurns: this.seen.retainedTurns,
+      lastExtractionAt: this.seen.lastExtractionAt,
+      extractionCount: this.seen.extractionCount,
     };
     return {
-      turns: this.entry.turns,
-      lastExtractionAt: this.entry.lastExtractionAt,
-      extractionCount: this.entry.extractionCount,
+      turns: this.seen.turns,
+      lastExtractionAt: this.seen.lastExtractionAt,
+      extractionCount: this.seen.extractionCount,
       entries,
     };
   }
@@ -102,16 +110,21 @@ export class ClaimBufferStorage implements BufferStorage {
   async saveBuffer(state: BufferState): Promise<void> {
     // Whole-state fallback (the claim covers one session): persist the entry.
     const entry = state.entries?.[this.key];
-    await this.claims.writeEntry(
-      this.key,
-      this.ownerId,
-      entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 },
-      this.entry
-    );
+    await this.writeProgress(entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 });
   }
 
   async saveBufferSession(key: string, entry: BufferEntryState): Promise<void> {
-    await this.claims.writeEntry(key, this.ownerId, entry, key === this.key ? this.entry : undefined);
+    if (key !== this.key) {
+      await this.claims.writeEntry(key, this.ownerId, entry, undefined);
+      return;
+    }
+    await this.writeProgress(entry);
+  }
+
+  private async writeProgress(entry: BufferEntryState): Promise<void> {
+    await this.claims.writeEntry(this.key, this.ownerId, entry, this.seen);
+    // Copy the lists: the buffer keeps mutating its own arrays after a save.
+    this.seen = { ...entry, turns: [...entry.turns], retainedTurns: entry.retainedTurns ? [...entry.retainedTurns] : undefined };
   }
 
   async deleteBufferSession(): Promise<void> {
@@ -554,14 +567,25 @@ async function runClaimDrain(
   options: BufferDrainRunnerOptions,
   heartbeat: NodeJS.Timeout
 ): Promise<DrainSessionOutcome> {
+  // Reconcile only identities recorded as durably extracted under this
+  // owner's claim lease. The claim lock is released before entering the live
+  // buffer mutation queue, preserving the buffer→claim lock order used by
+  // concurrent ingress saves.
+  const reconcileDrainedTurns = async (): Promise<void> => {
+    const drained = await ctx.claims.drainedTurnsForOwner(ctx.key, ctx.ownerId);
+    if (drained !== null) await ctx.orchestrator.buffer.save({ key: ctx.key, drained });
+  };
+
   // An emptied claim acks here: the ack verdict is the truth (drained), or
   // live ingress merged between the read and the ack — deferred, source kept.
   if (ctx.turns.length === 0) {
+    await reconcileDrainedTurns();
     const outcome = await ackEmptyClaim(ctx.claims, ctx.key, ctx.ownerId, ctx.turnsAtStart);
     options.onEvent?.({ type: "session_finished", key: ctx.key, outcome });
     return outcome;
   }
   const { groupOutcomes, groupError } = await drainScopeGroups(ctx);
+  await reconcileDrainedTurns();
   // Heartbeat cleared on EVERY exit path: a rejected drain must not keep
   // renewing the lease forever (cleared in the caller's finally).
   const remaining = await ctx.claims.load(ctx.key);

package/src/orchestration/extraction-persist.ts

@@ -1694,11 +1694,7 @@ export class ExtractionPersistCoordinator {
       // confirmation, so a disabled deployment never suppresses a write via
       // dedup (PR #2016 thread SD-nH).
       if (factDedupEnabled) {
-        exactDuplicate = await confirmActiveFactDuplicate(
-          { hasContentHashDedup: (storage, key) => this.deps.hasContentHashDedup(storage, key) },
-          targetStorage,
-          raceDedupOpts(contentHashDedupKey),
-        );
+        exactDuplicate = await confirmActiveFactDuplicate(targetStorage, raceDedupOpts(contentHashDedupKey));
       }
       // PR #2016/#3231: finalize committed writes before a fail-closed
       // window throw propagates (PRRT_kwDORJXyws6zxG6H).
@@ -1711,11 +1707,7 @@ export class ExtractionPersistCoordinator {
       const raceRecheck = (storage: StorageManager, key: string) => () => {
         // Gates mirror the persist-time suppression gates (PR #2016 SD-nH; #1645 quarantine).
         if (!factDedupEnabled || injectionScreenStatus === "pending_review") return Promise.resolve(false);
-        return confirmActiveFactDuplicate(
-          { hasContentHashDedup: (s, k) => this.deps.hasContentHashDedup(s, k) },
-          storage,
-          raceDedupOpts(key),
-        );
+        return confirmActiveFactDuplicate(storage, raceDedupOpts(key));
       };
       // #1671/#1707 — backfill bi-temporal bounds onto the surviving copy
       // when a duplicate short-circuits: persist-time hit OR raced duplicate