@remnic/core 10.0.98 → 10.0.100

package/dist/orchestration/turn-ingestion.d.ts

@@ -219,13 +219,7 @@ export declare class TurnIngestionCoordinator {
         abortSignal?: AbortSignal;
         /** Automatic buffered work only. Replay and import must not set this. */
         preemptable?: boolean;
-        /**
-         * Invoked when the queued closure has FULLY exited (after settlement).
-         * Settlement can fire before the closure exits — e.g. an abort listener
-         * settles while persistence is still in flight — so callers that
-         * release resources on settlement (claim leases) can use this to wait
-         * for the actual task exit first.
-         */
+        /** Fires once when the task is done: closure exited, or settled before it started. */
         onTaskExit?: () => void;
         /** Fail-closed force-flush only. Not implied by failOnExtractionFailure. */
         preemptRunning?: boolean;

package/dist/orchestration/turn-ingestion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"turn-ingestion.d.ts","sourceRoot":"","sources":["../../src/orchestration/turn-ingestion.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"turn-ingestion.d.ts","sourceRoot":"","sources":["../../src/orchestration/turn-ingestion.ts"],"names":[],"mappings":"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"}

package/dist/orchestrator.js

@@ -6,7 +6,7 @@ import {
   mergeGraphExpandedResults,
   qmdStartupCollectionChecksWithTimeout,
   resolveEffectiveIdentityInjectionMode
-} from "./chunk-5DGK7E4W.js";
+} from "./chunk-MMOXCCHF.js";
 import "./chunk-6P7U3HWG.js";
 import "./chunk-PQM3B54K.js";
 import "./chunk-B3DR2JBZ.js";
@@ -183,7 +183,7 @@ import "./chunk-MDPT6QFK.js";
 import "./chunk-UOBPK2OS.js";
 import "./chunk-2YA5N2BY.js";
 import "./chunk-3HSRWJTC.js";
-import "./chunk-4PXDXCNE.js";
+import "./chunk-PL36IQPL.js";
 import "./chunk-HUDPXTXW.js";
 import "./chunk-AZEZSQ5R.js";
 import "./chunk-YAZNBMNF.js";

package/dist/recall-navigation.js

@@ -1,6 +1,6 @@
 import {
   runRecallNavigation
-} from "./chunk-5DGK7E4W.js";
+} from "./chunk-MMOXCCHF.js";
 import "./chunk-6P7U3HWG.js";
 import "./chunk-PQM3B54K.js";
 import "./chunk-B3DR2JBZ.js";
@@ -173,7 +173,7 @@ import "./chunk-MDPT6QFK.js";
 import "./chunk-UOBPK2OS.js";
 import "./chunk-2YA5N2BY.js";
 import "./chunk-3HSRWJTC.js";
-import "./chunk-4PXDXCNE.js";
+import "./chunk-PL36IQPL.js";
 import "./chunk-HUDPXTXW.js";
 import "./chunk-AZEZSQ5R.js";
 import "./chunk-YAZNBMNF.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "10.0.98",
+  "version": "10.0.100",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3386,7 +3386,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^10.0.98"
+    "@remnic/coding-graph": "^10.0.100"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/backlog-scheduler.test.ts

@@ -12,6 +12,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import { hostname } from "node:os";
+import { log } from "./logger.js";
 import {
   BacklogScheduler,
   type BacklogSchedulerDeps,
@@ -390,6 +391,53 @@ test("the in-flight bound is the queue's own maxConcurrency", async () => {
   }
 });
 
+test("stop returns within its settle bound and names a drain that ignores abort", async () => {
+  const queue = new ExtractionQueueCoordinator(1);
+  const state: StubState = {
+    counts: new Map([["stuck-key", { turns: 3, retainedTurns: 0 }]]),
+    claimed: new Set(),
+    claimTurns: new Map(),
+    claimedThisRun: new Set(),
+    outcomes: [],
+    drained: [],
+  };
+  const entered = Promise.withResolvers<void>();
+  const forever = new Promise<DrainSessionOutcome>(() => {});
+  const scheduler = new BacklogScheduler(
+    {
+      ...makeDeps(state, queue),
+      // Ignores options.signal entirely: the shape that held a daemon stop
+      // until the 700 s systemd kill.
+      drainKey: async () => {
+        entered.resolve();
+        return forever;
+      },
+    },
+    { pollMs: 3_600_000, stopSettleTimeoutMs: 50 }
+  );
+  const warnings: string[] = [];
+  const originalWarn = log.warn;
+  log.warn = (msg: string) => {
+    warnings.push(msg);
+  };
+  try {
+    scheduler.start();
+    await scheduler.tickForTest();
+    await entered.promise;
+    const outcome = await Promise.race([
+      scheduler.stop().then(() => "returned"),
+      new Promise<string>((resolve) => setTimeout(() => resolve("hung"), 2_000)),
+    ]);
+    assert.equal(outcome, "returned", "stop must not wait forever on a drain that ignores abort");
+    assert.ok(
+      warnings.some((w) => w.includes("stuck-key")),
+      `the stuck key is named in a warning: ${JSON.stringify(warnings)}`
+    );
+  } finally {
+    log.warn = originalWarn;
+  }
+});
+
 test("stop aborts in-flight drains; a fresh start resumes the still-claimed backlog", async () => {
   const queue = new ExtractionQueueCoordinator(1);
   const state: StubState = {

package/src/harmonic-graph-cache.test.ts

@@ -1,13 +1,14 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import test from "node:test";
+import test, { type TestContext } from "node:test";
 import { recordAbstractionNode, upsertAbstractionNodes, type AbstractionNode } from "./abstraction-nodes.js";
 import { pruneOrphanCueAnchors, recordCueAnchor, upsertCueAnchors, type CueAnchor } from "./cue-anchors.js";
 import {
   clearHarmonicGraphCache,
   harmonicGraphCacheStats,
+  type ProjectedHarmonicGraph,
   readProjectedHarmonicGraph,
   searchHarmonicRetrieval,
 } from "./harmonic-retrieval.js";
@@ -228,6 +229,61 @@ test("pruneOrphanCueAnchors alone invalidates the cached graph", async () => {
   });
 });
 
+// Recall waits for the graph build, so a cache miss costs every recall that lands on it. Production: a
+// 2106 node, 9174 anchor graph rebuilt in 5 s standalone, 7 s inside the daemon, and 17 to 32 s when two
+// recalls overlapped and each ran its own build.
+test("concurrent reads on a cold cache share one build", async () => {
+  await withDir(async (memoryDir, storage) => {
+    const memory = await storage.writeMemory("fact", "theta shared fact", { source: "test" });
+    await recordAbstractionNode({ memoryDir, node: node("n1", "theta shared fact", [memory.id]) });
+    const before = { ...harmonicGraphCacheStats };
+    const [a, b, c] = await Promise.all([read(memoryDir), read(memoryDir), read(memoryDir)]);
+    assert.equal(harmonicGraphCacheStats.misses, before.misses + 1, "one build, not one per caller");
+    assert.equal(a, b);
+    assert.equal(b, c);
+  });
+});
+
+test("a caller that aborts leaves the shared build for the others", async () => {
+  await withDir(async (memoryDir, storage) => {
+    const memory = await storage.writeMemory("fact", "iota abort fact", { source: "test" });
+    await recordAbstractionNode({ memoryDir, node: node("n1", "iota abort fact", [memory.id]) });
+    const controller = new AbortController();
+    const aborted = readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: true, useCache: true, abortSignal: controller.signal });
+    const other = read(memoryDir);
+    controller.abort();
+    await assert.rejects(aborted);
+    assert.equal((await other).nodes.length, 1);
+  });
+});
+
+// Unreadable node store: a file where the nodes directory belongs is not ENOENT, so the strict listing throws
+// (a corrupt node file would not: readAbstractionNodes skips those on purpose).
+async function breakNodeStore(memoryDir: string) {
+  const nodesDir = path.join(memoryDir, "state", "abstraction-nodes", "nodes");
+  const parked = `${nodesDir}.parked`;
+  await rename(nodesDir, parked);
+  await writeFile(nodesDir, "not a directory");
+  return async () => {
+    await rm(nodesDir, { force: true });
+    await rename(parked, nodesDir);
+  };
+}
+
+test("callers that joined a failing build all reject, and the next read retries and succeeds", async () => {
+  await withDir(async (memoryDir, storage) => {
+    const memory = await storage.writeMemory("fact", "mu retry fact", { source: "test" });
+    await recordAbstractionNode({ memoryDir, node: node("n1", "mu retry fact", [memory.id]) });
+    const restore = await breakNodeStore(memoryDir);
+    const missesBefore = harmonicGraphCacheStats.misses;
+    const outcomes = await Promise.allSettled([read(memoryDir), read(memoryDir), read(memoryDir)]);
+    assert.deepEqual(outcomes.map((outcome) => outcome.status), ["rejected", "rejected", "rejected"]);
+    assert.equal(harmonicGraphCacheStats.misses, missesBefore + 1, "the three callers shared one failing build");
+    await restore();
+    assert.equal((await read(memoryDir)).nodes.length, 1);
+  });
+});
+
 test("an entry older than the TTL is rebuilt", async (t) => {
   await withDir(async (memoryDir, storage) => {
     const memory = await storage.writeMemory("fact", "zeta ttl fact", { source: "test" });
@@ -242,3 +298,132 @@ test("an entry older than the TTL is rebuilt", async (t) => {
     assert.equal((await read(memoryDir)).nodes.length, 0, "rebuilt past the TTL");
   });
 });
+
+interface BuildHold {
+  release: () => void;
+  reached: Promise<void>;
+  calls: number;
+  signal?: AbortSignal;
+}
+
+/**
+ * Hold the first build inside its source-memory read so a second read can land while it runs. The held call
+ * records the build's own abort signal; builds started after it are not held.
+ */
+function holdFirstBuild(t: TestContext): BuildHold {
+  const original = StorageManager.prototype.readAllMemories;
+  let release = () => {};
+  const opened = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  let reachedHold = () => {};
+  const reached = new Promise<void>((resolve) => {
+    reachedHold = resolve;
+  });
+  const hold: BuildHold = { release, reached, calls: 0 };
+  t.mock.method(StorageManager.prototype, "readAllMemories", async function (this: StorageManager, ...args: Parameters<typeof original>) {
+    hold.calls++;
+    if (hold.calls === 1) {
+      hold.signal = args[0]?.abortSignal;
+      reachedHold();
+      await opened;
+    }
+    return original.apply(this, args);
+  });
+  return hold;
+}
+
+/** Fail the test instead of hanging when a promise that must settle does not. */
+function within<T>(promise: Promise<T>, ms: number, what: string): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<never>((_resolve, reject) => setTimeout(() => reject(new Error(`${what} did not settle in ${ms} ms`)), ms).unref()),
+  ]);
+}
+
+test("the shared build aborts once every joined caller has aborted, and the next read starts a fresh one", async (t) => {
+  await withDir(async (memoryDir, storage) => {
+    const memory = await storage.writeMemory("fact", "nu abort fact", { source: "test" });
+    await recordAbstractionNode({ memoryDir, node: node("n1", "nu abort fact", [memory.id]) });
+    const hold = holdFirstBuild(t);
+    const first = new AbortController();
+    const second = new AbortController();
+    const options = { memoryDir, anchorsEnabled: true, useCache: true };
+    const a = readProjectedHarmonicGraph({ ...options, abortSignal: first.signal });
+    const b = readProjectedHarmonicGraph({ ...options, abortSignal: second.signal });
+    await within(hold.reached, 2000, "build start");
+    assert.equal(hold.calls, 1, "one build for both callers");
+    first.abort();
+    await assert.rejects(within(a, 1000, "first caller"), { name: "AbortError" });
+    assert.equal(hold.signal?.aborted, false, "one caller is still waiting, so the build keeps running");
+    second.abort();
+    await assert.rejects(within(b, 1000, "second caller"), { name: "AbortError" });
+    assert.equal(hold.signal?.aborted, true, "no caller is left, so the build is cancelled");
+    const missesBefore = harmonicGraphCacheStats.misses;
+    const next = read(memoryDir);
+    assert.equal(harmonicGraphCacheStats.misses, missesBefore + 1, "the next read does not join the cancelled build");
+    assert.equal((await within(next, 5000, "next read")).nodes.length, 1);
+    hold.release();
+  });
+});
+
+test("a read after a stamp change does not join the build that started on the old stamp", async (t) => {
+  await withDir(async (memoryDir, storage) => {
+    const first = await storage.writeMemory("fact", "xi stamp fact one", { source: "test" });
+    await recordAbstractionNode({ memoryDir, node: node("n1", "xi stamp fact one", [first.id]) });
+    const hold = holdFirstBuild(t);
+    const missesBefore = harmonicGraphCacheStats.misses;
+    const stale = read(memoryDir);
+    await within(hold.reached, 2000, "old build start");
+    const second = await storage.writeMemory("fact", "xi stamp fact two", { source: "test" });
+    await recordAbstractionNode({ memoryDir, node: node("n2", "xi stamp fact two", [second.id]) });
+    try {
+      const fresh = read(memoryDir);
+      assert.equal(harmonicGraphCacheStats.misses, missesBefore + 2, "the second read started its own build");
+      assert.equal((await within(fresh, 5000, "fresh read")).nodes.length, 2, "and it sees the write");
+    } finally {
+      hold.release();
+    }
+    await stale;
+  });
+});
+
+test("a joined caller that aborts rejects at once, while the build it joined is still running", async (t) => {
+  await withDir(async (memoryDir, storage) => {
+    const memory = await storage.writeMemory("fact", "omicron join fact", { source: "test" });
+    await recordAbstractionNode({ memoryDir, node: node("n1", "omicron join fact", [memory.id]) });
+    const hold = holdFirstBuild(t);
+    const owner = read(memoryDir);
+    const controller = new AbortController();
+    const joiner = readProjectedHarmonicGraph({ memoryDir, anchorsEnabled: true, useCache: true, abortSignal: controller.signal });
+    controller.abort();
+    try {
+      await assert.rejects(within(joiner, 1000, "aborted joiner"), { name: "AbortError" });
+    } finally {
+      hold.release();
+    }
+    assert.equal((await owner).nodes.length, 1, "the owner is not affected");
+  });
+});
+
+test("clearing the cache drops a running build: the next read starts its own and the old build stores nothing", async (t) => {
+  await withDir(async (memoryDir, storage) => {
+    const memory = await storage.writeMemory("fact", "pi clear fact", { source: "test" });
+    await recordAbstractionNode({ memoryDir, node: node("n1", "pi clear fact", [memory.id]) });
+    const hold = holdFirstBuild(t);
+    const missesBefore = harmonicGraphCacheStats.misses;
+    const old = read(memoryDir);
+    await within(hold.reached, 2000, "old build start");
+    clearHarmonicGraphCache();
+    let kept: ProjectedHarmonicGraph;
+    try {
+      const fresh = read(memoryDir);
+      assert.equal(harmonicGraphCacheStats.misses, missesBefore + 2, "the read after the clear did not join the old build");
+      kept = await within(fresh, 5000, "fresh read");
+    } finally {
+      hold.release();
+    }
+    await old;
+    assert.equal(await read(memoryDir), kept, "the finished old build did not overwrite the newer cache entry");
+  });
+});

package/src/harmonic-retrieval.ts

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { realpath } from "node:fs/promises";
 import { listJsonFilesStrict, readJsonFile } from "./json-store.js";
-import { throwIfAborted } from "./abort-error.js";
+import { raceAbort, throwIfAborted } from "./abort-error.js";
 import { readHarmonicGraphStamp } from "./harmonic-graph-version.js";
 import { inferMemoryStatus, toMemoryPathRel } from "./memory-lifecycle-ledger-utils.js";
  import {
@@ -471,8 +471,20 @@ interface GraphCacheEntry {
 }
 
 const graphCache = new Map<string, GraphCacheEntry>();
-/** Counters for tests and diagnostics. */
-export const harmonicGraphCacheStats = { hits: 0, misses: 0 };
+
+interface GraphBuild {
+  stamp: string;
+  promise: Promise<ProjectedHarmonicGraph>;
+  /** Cancels the build's source scan; fired when no caller is waiting for it. */
+  controller: AbortController;
+  /** Callers currently waiting for this build. */
+  waiting: number;
+}
+
+/** One build per cache key at a time: every recall that lands on a miss waits for the same build. */
+const graphBuilds = new Map<string, GraphBuild>();
+/** Counters for tests and diagnostics. `shared` counts reads that joined a build already running. */
+export const harmonicGraphCacheStats = { hits: 0, misses: 0, shared: 0 };
 
 /** Freeze records and their nested arrays/objects so a caller cannot corrupt the shared cache. */
 function deepFreeze<T extends object>(value: T): T {
@@ -485,6 +497,60 @@ function deepFreeze<T extends object>(value: T): T {
 
 export function clearHarmonicGraphCache(): void {
   graphCache.clear();
+  graphBuilds.clear();
+}
+
+type GraphReadOptions = Parameters<typeof buildProjectedHarmonicGraph>[0];
+
+/**
+ * Start the one build for `key`. The build owns an abort controller instead of using one caller's signal,
+ * so a caller that leaves does not cancel it for the others; `joinGraphBuild` cancels it when the last caller leaves.
+ */
+function startGraphBuild(key: string, stamp: string, options: GraphReadOptions): GraphBuild {
+  harmonicGraphCacheStats.misses++;
+  const startedAtMs = Date.now();
+  const controller = new AbortController();
+  const promise: Promise<ProjectedHarmonicGraph> = buildProjectedHarmonicGraph({
+    memoryDir: options.memoryDir,
+    abstractionNodeStoreDir: options.abstractionNodeStoreDir,
+    anchorsEnabled: options.anchorsEnabled,
+    temporalExpiredInInjection: options.temporalExpiredInInjection,
+    abortSignal: controller.signal,
+  })
+    .then((built) => {
+      const graph = { nodes: deepFreeze(built.nodes), anchors: deepFreeze(built.anchors) };
+      // A cleared cache or a newer build for this key has replaced this one: do not store a stale graph.
+      if (graphBuilds.get(key)?.promise !== promise) return graph;
+      graphCache.delete(key);
+      graphCache.set(key, { stamp, startedAtMs, graph });
+      while (graphCache.size > GRAPH_CACHE_MAX_ENTRIES) {
+        const oldest = graphCache.keys().next().value;
+        if (oldest === undefined) break;
+        graphCache.delete(oldest);
+      }
+      return graph;
+    })
+    .finally(() => {
+      if (graphBuilds.get(key)?.promise === promise) graphBuilds.delete(key);
+    });
+  const build: GraphBuild = { stamp, promise, controller, waiting: 0 };
+  graphBuilds.set(key, build);
+  return build;
+}
+
+/**
+ * Wait for `build` on behalf of one caller. The caller's own signal ends only its own wait. When the last
+ * waiting caller has left, the build is cancelled and dropped, so abandoned recalls do not leave full scans running
+ * (cancelling a build that already finished does nothing).
+ */
+function joinGraphBuild(key: string, build: GraphBuild, signal: AbortSignal | undefined): Promise<ProjectedHarmonicGraph> {
+  build.waiting++;
+  return raceAbort(build.promise, signal, "harmonic retrieval aborted").finally(() => {
+    build.waiting--;
+    if (build.waiting > 0) return;
+    if (graphBuilds.get(key) === build) graphBuilds.delete(key);
+    build.controller.abort();
+  });
 }
 
 /**
@@ -495,9 +561,9 @@ export function clearHarmonicGraphCache(): void {
  * cold-write version sentinels (bumped by every memory write, in any process) and
  * the graph version sentinel (bumped by node and anchor writes). A stamp read is
  * four stats, not a scan of the memories. The TTL bounds the one input a sentinel
- * cannot see, which is wall-clock validity expiry. An explicit `nowMs` bypasses the
- * cache so tests stay deterministic. The cached arrays are frozen: callers must not
- * mutate them.
+ * cannot see, which is wall-clock validity expiry. Concurrent misses share one
+ * build. An explicit `nowMs` bypasses the cache so tests stay deterministic. The
+ * cached arrays are frozen: callers must not mutate them.
  */
 export async function readProjectedHarmonicGraph(options: {
   memoryDir: string;
@@ -529,20 +595,12 @@ export async function readProjectedHarmonicGraph(options: {
     graphCache.set(key, hit);
     return hit.graph;
   }
-  harmonicGraphCacheStats.misses++;
-  const built = await buildProjectedHarmonicGraph(options);
-  const graph = {
-    nodes: deepFreeze(built.nodes),
-    anchors: deepFreeze(built.anchors),
-  };
-  graphCache.delete(key);
-  graphCache.set(key, { stamp, startedAtMs, graph });
-  while (graphCache.size > GRAPH_CACHE_MAX_ENTRIES) {
-    const oldest = graphCache.keys().next().value;
-    if (oldest === undefined) break;
-    graphCache.delete(oldest);
+  const running = graphBuilds.get(key);
+  if (running?.stamp === stamp) {
+    harmonicGraphCacheStats.shared++;
+    return joinGraphBuild(key, running, options.abortSignal);
   }
-  return graph;
+  return joinGraphBuild(key, startGraphBuild(key, stamp, options), options.abortSignal);
 }
 
 export async function searchHarmonicRetrieval(options: {

package/src/orchestration/backlog-scheduler.ts

@@ -70,6 +70,8 @@ export interface BacklogSchedulerOptions {
   pollMs?: number;
   retryBaseMs?: number;
   retryMaxMs?: number;
+  /** Bound on `stop()`'s wait for aborted drains to settle. */
+  stopSettleTimeoutMs?: number;
   now?: () => number;
 }
 
@@ -114,6 +116,9 @@ interface KeyState {
 const DEFAULT_POLL_MS = 15_000;
 const DEFAULT_RETRY_BASE_MS = 30_000;
 const DEFAULT_RETRY_MAX_MS = 15 * 60_000;
+// Aborted drains normally settle within seconds (a chunk boundary); this only
+// bounds the pathological case, well inside the daemon's stop budget.
+const DEFAULT_STOP_SETTLE_TIMEOUT_MS = 30_000;
 
 export class BacklogScheduler {
   private readonly deps: BacklogSchedulerDeps;
@@ -141,6 +146,7 @@ export class BacklogScheduler {
       pollMs: options.pollMs ?? DEFAULT_POLL_MS,
       retryBaseMs: options.retryBaseMs ?? DEFAULT_RETRY_BASE_MS,
       retryMaxMs: options.retryMaxMs ?? DEFAULT_RETRY_MAX_MS,
+      stopSettleTimeoutMs: options.stopSettleTimeoutMs ?? DEFAULT_STOP_SETTLE_TIMEOUT_MS,
       now: options.now,
     };
   }
@@ -155,7 +161,10 @@ export class BacklogScheduler {
   }
 
   /** Idempotent. Stops the timer, aborts in-flight drains (their claims stay
-   *  retryable) and waits for them to settle. */
+   *  retryable) and waits up to `stopSettleTimeoutMs` for them to settle. A
+   *  drain that ignores abort is named in a warning and left behind: the
+   *  caller's later shutdown phases (orchestrator flush and dispose) must
+   *  still run before the service manager's kill. */
   async stop(): Promise<void> {
     if (this.stopped) return;
     this.stopped = true;
@@ -168,7 +177,19 @@ export class BacklogScheduler {
       entry.controller.abort(new Error("backlog scheduler stopping"));
       aborts.push(entry.settled);
     }
-    await Promise.allSettled(aborts);
+    const bound = Promise.withResolvers<"timeout">();
+    const boundTimer = setTimeout(() => bound.resolve("timeout"), this.options.stopSettleTimeoutMs);
+    try {
+      const result = await Promise.race([Promise.allSettled(aborts), bound.promise]);
+      if (result === "timeout") {
+        log.warn(
+          `backlog scheduler stop: ${this.inFlight.size} drain(s) ignored abort for ${this.options.stopSettleTimeoutMs}ms; ` +
+            `continuing shutdown (stuck keys: ${[...this.inFlight.keys()].join(", ")})`,
+        );
+      }
+    } finally {
+      clearTimeout(boundTimer);
+    }
   }
 
   /** Bounded snapshot for ops/watchers: counters + per-key states + live sets. */

package/src/orchestration/extraction-queue-bounded-retention.test.ts

@@ -299,6 +299,26 @@ test("abort while queued: settled task starts, skips extraction, queue drains",
   assert.equal(settled.length, 1, "queued task settles exactly once from the abort");
 });
 
+test("abort while queued: onTaskExit fires at once, not after the queue head finishes", async () => {
+  const h = makeHarness();
+  const controller = new AbortController();
+  // Occupies the single worker; the drain stays blocked until release().
+  await h.coordinator.processTurn("user", "running", "k");
+  let exited = 0;
+  await h.coordinator.queueBufferedExtraction([makeTurn("queued then aborted")], "trigger_mode", {
+    bufferKey: "k",
+    preemptable: true,
+    abortSignal: controller.signal,
+    onTaskExit: () => { exited += 1; },
+  });
+  controller.abort();
+  // A claim-lease owner waiting on this exit must not be held by an unrelated
+  // running extraction: nothing of this task ever ran.
+  assert.equal(exited, 1, "queued task that never started reports exit on abort");
+  await h.release();
+  assert.equal(exited, 1, "the later no-op closure run does not report a second exit");
+});
+
 test("sharing bound: distinct reference slots equal the union, not the snapshot sum", async () => {
   const h = makeHarness();
   const turns = 30;

package/src/orchestration/task-exit.ts

@@ -0,0 +1,27 @@
+/**
+ * Exit-once bookkeeping for a queued extraction task (`onTaskExit`).
+ *
+ * A task settled (abort, queue deadline) before its closure ever ran has
+ * nothing to exit, so `settled()` reports exit at once; a claim-lease owner
+ * waiting on the exit is then not held behind an unrelated running extraction.
+ * A closure that did start reports exit when it finishes. Either way the
+ * callback fires exactly once.
+ */
+export function createTaskExit(onExit?: () => void) {
+  let started = false;
+  let reported = false;
+  const report = (): void => {
+    if (reported) return;
+    reported = true;
+    onExit?.();
+  };
+  return {
+    start: () => {
+      started = true;
+    },
+    settled: () => {
+      if (!started) report();
+    },
+    report,
+  };
+}