@remnic/core 9.51.1 → 9.52.1

package/src/orchestration/dependency-propagation.test.ts

@@ -1,10 +1,15 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { findDependents, propagateInvalidation } from "./dependency-propagation.js";
+import {
+  findDependents,
+  isDependencyPropagationEnabled,
+  propagateInvalidation,
+} from "./dependency-propagation.js";
 import type { ExtractionEngine } from "../extraction.js";
 import type { MemoryFile, MemoryLinkType, PluginConfig } from "../types.js";
 import type { StorageManager } from "../storage.js";
+import { invalidationCommitFingerprint } from "../storage/deletion-revision-store.js";
 
 type Verdict = {
   memoryId: string;
@@ -25,8 +30,17 @@ type Fixture = {
   extraction: ExtractionEngine;
   calls: {
     revalidate: RevalidationCall[];
-    supersede: Array<{ id: string; replacementId: string; reason: string }>;
-    frontmatter: Array<{ id: string; patch: Record<string, unknown> }>;
+    supersede: Array<{
+      id: string;
+      replacementId: string;
+      reason: string;
+      metadata?: Record<string, unknown>;
+      options: {
+        requireActive?: boolean;
+        acceptExactReplay?: boolean;
+        expectedSnapshot?: Pick<MemoryFile, "content" | "frontmatter"> & Partial<Pick<MemoryFile, "path">>;
+      };
+    }>;
   };
 };
 
@@ -77,36 +91,63 @@ function config(overrides: Record<string, unknown> = {}): PluginConfig {
   } as unknown as PluginConfig;
 }
 
+test("dependency propagation enable gate accepts only normalized true values and a positive limit", () => {
+  assert.equal(isDependencyPropagationEnabled(config()), true);
+  assert.equal(isDependencyPropagationEnabled(config({ dependencyPropagation: { enabled: "yes" } })), true);
+  assert.equal(isDependencyPropagationEnabled(config({ dependencyPropagation: { enabled: "disabled" } })), false);
+  assert.equal(isDependencyPropagationEnabled(config({ dependencyPropagation: { maxDependents: 0 } })), false);
+});
+
 function fixture(
   initial: MemoryFile[],
   verdicts: Verdict[] | Error | ((signal?: AbortSignal) => Promise<{ verdicts: Verdict[] }>),
 ): Fixture {
   const memories = new Map(initial.map((item) => [item.frontmatter.id, item]));
-  const calls: Fixture["calls"] = { revalidate: [], supersede: [], frontmatter: [] };
-
+  const calls: Fixture["calls"] = { revalidate: [], supersede: [] };
   const storage = {
+
     async readAllMemories(): Promise<MemoryFile[]> {
-      return [...memories.values()];
+      return structuredClone([...memories.values()]);
     },
     async getMemoryById(id: string): Promise<MemoryFile | null> {
       return memories.get(id) ?? null;
     },
-    async supersedeMemory(id: string, replacementId: string, reason: string): Promise<boolean> {
-      calls.supersede.push({ id, replacementId, reason });
+    async supersedeMemory(
+      id: string,
+      replacementId: string,
+      reason: string,
+      metadata?: Record<string, unknown>,
+      options: {
+        requireActive?: boolean;
+        acceptExactReplay?: boolean;
+        expectedSnapshot?: Pick<MemoryFile, "content" | "frontmatter"> & Partial<Pick<MemoryFile, "path">>;
+      } = {},
+    ): Promise<boolean> {
+      calls.supersede.push({ id, replacementId, reason, metadata, options });
       const current = memories.get(id);
       if (!current) return false;
-      current.frontmatter.status = "superseded";
-      current.frontmatter.supersededBy = replacementId;
-      return true;
-    },
-    async writeMemoryFrontmatter(
-      current: MemoryFile,
-      patch: Record<string, unknown>,
-    ): Promise<boolean> {
-      calls.frontmatter.push({ id: current.frontmatter.id, patch });
-      const stored = memories.get(current.frontmatter.id);
-      if (!stored) return false;
-      Object.assign(stored.frontmatter, patch);
+      if (
+        options.expectedSnapshot &&
+        invalidationCommitFingerprint(current) !== invalidationCommitFingerprint(options.expectedSnapshot)
+      ) {
+        return false;
+      }
+      const exactReplay =
+        current.frontmatter.status === "superseded" &&
+        current.frontmatter.supersededBy === replacementId &&
+        current.frontmatter.supersessionCause === metadata?.supersessionCause &&
+        current.frontmatter.invalidatedBy === metadata?.invalidatedBy;
+      if (exactReplay) return options.acceptExactReplay === true;
+      if (
+        options.requireActive === true &&
+        (current.frontmatter.status ?? "active") !== "active"
+      ) {
+        return false;
+      }
+      Object.assign(current.frontmatter, metadata, {
+        status: "superseded",
+        supersededBy: replacementId,
+      });
       return true;
     },
   } as unknown as StorageManager;
@@ -293,6 +334,7 @@ test("invalidated verdict supersedes the dependent and persists dependency front
   const old = memory("old", { links: [{ targetId: "dep", linkType: "supports" }] });
   const dependent = memory("dep");
   const fixtureValue = fixture([old, dependent], [{ memoryId: "dep", verdict: "invalidated", reason: "claim lost support" }]);
+  const expectedSnapshot = structuredClone(dependent);
 
   const result = await propagateInvalidation(
     deps(fixtureValue),
@@ -317,18 +359,32 @@ test("invalidated verdict supersedes the dependent and persists dependency front
       id: "dep",
       replacementId: "replacement",
       reason: "dependency_propagation:contradiction",
-    },
-  ]);
-  assert.deepEqual(fixtureValue.calls.frontmatter, [
-    {
-      id: "dep",
-      patch: { supersessionCause: "dependency", invalidatedBy: "old" },
+      metadata: { supersessionCause: "dependency", invalidatedBy: "old" },
+      options: { requireActive: true, acceptExactReplay: true, expectedSnapshot },
     },
   ]);
   assert.equal(fixtureValue.memories.get("dep")?.frontmatter.status, "superseded");
   assert.equal(fixtureValue.memories.get("dep")?.frontmatter.supersessionCause, "dependency");
   assert.equal(fixtureValue.memories.get("dep")?.frontmatter.invalidatedBy, "old");
 });
+test("supersede fixture rejects a stale expected snapshot after concurrent mutation", async () => {
+  const old = memory("old", { links: [{ targetId: "dep", linkType: "supports" }] });
+  const dependent = memory("dep");
+  const fixtureValue = fixture([old, dependent], []);
+  const expectedSnapshot = structuredClone(dependent);
+  dependent.content = "concurrent update";
+
+  const superseded = await fixtureValue.storage.supersedeMemory(
+    "dep",
+    "replacement",
+    "dependency_propagation:contradiction",
+    { supersessionCause: "dependency", invalidatedBy: "old" },
+    { requireActive: true, expectedSnapshot },
+  );
+
+  assert.equal(superseded, false);
+  assert.equal(fixtureValue.memories.get("dep")?.frontmatter.status, "active");
+});
 
 test("still_valid and uncertain verdicts do not write", async () => {
   const old = memory("old", {
@@ -356,7 +412,6 @@ test("still_valid and uncertain verdicts do not write", async () => {
   assert.equal(result.stillValid, 1);
   assert.equal(result.uncertain, 1);
   assert.equal(fixtureValue.calls.supersede.length, 0);
-  assert.equal(fixtureValue.calls.frontmatter.length, 0);
 });
 
 test("unknown, missing, and garbage verdicts default to uncertain and drop unknown ids", async () => {
@@ -412,7 +467,6 @@ test("LLM errors skip the event and perform zero writes", async () => {
   assert.equal(typeof result.durationMs, "number");
   assert.equal(result.skipped, "llm_error");
   assert.equal(fixtureValue.calls.supersede.length, 0);
-  assert.equal(fixtureValue.calls.frontmatter.length, 0);
 });
 
 test("LLM timeout aborts the batch and performs zero writes", async () => {
@@ -439,7 +493,6 @@ test("LLM timeout aborts the batch and performs zero writes", async () => {
   assert.equal(typeof result.durationMs, "number");
   assert.equal(result.skipped, "timeout");
   assert.equal(fixtureValue.calls.supersede.length, 0);
-  assert.equal(fixtureValue.calls.frontmatter.length, 0);
 });
 
 test("a completion that ignores AbortSignal returns at the shared deadline", async (t) => {
@@ -470,7 +523,6 @@ test("a completion that ignores AbortSignal returns at the shared deadline", asy
     assert.equal(result.route, "fast-completion");
     assert.equal(result.durationMs, 20);
     assert.equal(fixtureValue.calls.supersede.length, 0);
-    assert.equal(fixtureValue.calls.frontmatter.length, 0);
   } finally {
     t.mock.timers.reset();
   }
@@ -515,7 +567,6 @@ test("dryRun computes invalidation verdicts without writing", async () => {
   assert.equal(result.invalidated, 1);
   assert.equal(fixtureValue.calls.revalidate.length, 1);
   assert.equal(fixtureValue.calls.supersede.length, 0);
-  assert.equal(fixtureValue.calls.frontmatter.length, 0);
   assert.equal(fixtureValue.memories.get("dep")?.frontmatter.status, "active");
 });
 

package/src/orchestration/dependency-propagation.ts

@@ -6,7 +6,6 @@
  */
 import type { ExtractionEngine } from "../extraction.js";
 import { log } from "../logger.js";
-import type { StorageManager } from "../index.js";
 import type {
   DependencyPropagationConfig,
   MemoryFile,
@@ -15,9 +14,14 @@ import type {
   PluginConfig,
 } from "../types.js";
 
+export function isDependencyPropagationEnabled(config: Pick<PluginConfig, "dependencyPropagation">): boolean {
+  const parsed = propagationConfig(config);
+  return isEnabled(parsed.enabled) && parsed.maxDependents > 0;
+}
+
 export interface PropagationEvent {
   /** Snapshot captured before the primary supersession or deletion. */
-  oldMemory: { content: string; frontmatter: MemoryFrontmatter };
+  oldMemory: { content: string; frontmatter: MemoryFrontmatter; path?: string };
   replacementId: string | null;
   replacementContent: string | null;
   cause:
@@ -26,6 +30,11 @@ export interface PropagationEvent {
     | "consolidation_invalidate"
     | "consolidation_merge";
   namespaceScope: string;
+  temporalMutation?: {
+    supersededAt: string;
+    invalidAt?: string;
+    matchedKeys: string[];
+  };
 }
 
 export interface PropagationResult {
@@ -38,7 +47,27 @@ export interface PropagationResult {
   durationMs: number;
 }
 
-function propagationConfig(config: PluginConfig): DependencyPropagationConfig {
+export type DependencyPropagationWriteFence = <T>(
+  write: () => Promise<T>,
+) => Promise<T | undefined>;
+
+export interface DependencyPropagationStorage {
+  readAllMemories(): Promise<MemoryFile[]>;
+  getMemoryById(id: string): Promise<MemoryFile | null>;
+  supersedeMemory(
+    id: string,
+    replacementId: string,
+    reason: string,
+    metadata?: Pick<MemoryFrontmatter, "supersessionCause" | "invalidatedBy">,
+    options?: {
+      requireActive?: boolean;
+      acceptExactReplay?: boolean;
+      expectedSnapshot?: Pick<MemoryFile, "content" | "frontmatter"> & Partial<Pick<MemoryFile, "path">>;
+    },
+  ): Promise<boolean>;
+}
+
+function propagationConfig(config: Pick<PluginConfig, "dependencyPropagation">): DependencyPropagationConfig {
   return config.dependencyPropagation;
 }
 
@@ -142,7 +171,12 @@ function isTimeoutError(error: unknown, signal: AbortSignal): boolean {
  * constructs another storage or scans a different namespace.
  */
 export async function propagateInvalidation(
-  deps: { storage: StorageManager; extraction: ExtractionEngine; config: PluginConfig },
+  deps: {
+    storage: DependencyPropagationStorage;
+    extraction: ExtractionEngine;
+    config: PluginConfig;
+    writeFence?: DependencyPropagationWriteFence;
+  },
   event: PropagationEvent,
 ): Promise<PropagationResult> {
   const startedAt = Date.now();
@@ -255,19 +289,23 @@ export async function propagateInvalidation(
       }
       try {
         const replacementId = event.replacementId ?? event.oldMemory.frontmatter.id;
-        const superseded = await deps.storage.supersedeMemory(
-          dependent.frontmatter.id,
-          replacementId,
-          `dependency_propagation:${event.cause}`,
-        );
-        if (!superseded) continue;
-        const current = await deps.storage.getMemoryById(dependent.frontmatter.id);
-        if (current) {
-          await deps.storage.writeMemoryFrontmatter(current, {
-            supersessionCause: "dependency",
-            invalidatedBy: event.oldMemory.frontmatter.id,
-          });
-        }
+        const write = () =>
+          deps.storage.supersedeMemory(
+            dependent.frontmatter.id,
+            replacementId,
+            `dependency_propagation:${event.cause}`,
+            {
+              supersessionCause: "dependency",
+              invalidatedBy: event.oldMemory.frontmatter.id,
+            },
+            {
+              requireActive: true,
+              acceptExactReplay: true,
+              expectedSnapshot: dependent,
+            },
+          );
+        const superseded = deps.writeFence ? await deps.writeFence(write) : await write();
+        if (superseded !== true) continue;
         invalidated += 1;
       } catch (error) {
         log.warn(`dependency propagation write failed for ${dependent.frontmatter.id}: ${error}`);

package/src/orchestration/extraction-persist-deps.ts

@@ -12,12 +12,12 @@ import type { RouteRule, RoutingEngineOptions } from "../routing/engine.js";
 import type { SearchBackend } from "../search/port.js";
 import type { ThreadingManager } from "../threading.js";
 import type { MemoryFile, MemoryLink, PluginConfig } from "../types.js";
-
+import type { DependencyPropagationDeliveryPort } from "./dependency-propagation-delivery.js";
 export interface ExtractionPersistDeps {
   config: PluginConfig;
   getStorageRouter: () => NamespaceStorageRouter;
   getThreading: () => ThreadingManager;
-  getExtraction: () => ExtractionEngine;
+  getDependencyPropagationDelivery: () => DependencyPropagationDeliveryPort;
   getLocalLlm: () => LocalLlmClient;
   getQmd: () => SearchBackend;
   getJudgeVerdictCache: () => Map<string, JudgeVerdict>;

package/src/orchestration/extraction-persist.ts

@@ -84,6 +84,7 @@ import { decideSemanticDedup, type SemanticDedupDecision, type SemanticDedupHit
 import { selectRouteRule, type RouteRule, type RoutingEngineOptions } from "../routing/engine.js";
 import { ThreadingManager } from "../threading.js";
 import { NamespaceStorageRouter } from "../namespaces/storage.js";
+import type { ResolvedScopeProfilePlan } from "../namespaces/scope-profiles.js";
 import type { SearchBackend } from "../search/port.js";
 import { inferIntentFromText } from "../intent.js";
 import type {
@@ -103,7 +104,8 @@ import {
   shouldPromoteToShared,
 } from "./extraction-persist-promotion.js";
 import type { ExtractionPersistDeps } from "./extraction-persist-deps.js";
-import type { ResolvedScopeProfilePlan } from "../namespaces/scope-profiles.js";
+import type { DependencyPropagationDeliveryPort } from "./dependency-propagation-delivery.js";
+import { isDependencyPropagationEnabled } from "./dependency-propagation.js";
 import {
   buildMemoryPathById,
   appendMemoryToGraphContext,
@@ -114,8 +116,6 @@ import { persistConstructedHarmonicRecords } from "./harmonic-construction-persi
 import { ExtractionAnchorSnapshot } from "./extraction-anchor-snapshot.js";
 
 
-
-
 export class ExtractionPersistCoordinator {
   constructor(
     private readonly deps: ExtractionPersistDeps,
@@ -123,6 +123,10 @@ export class ExtractionPersistCoordinator {
   private get config(): PluginConfig {
     return this.deps.config;
   }
+  private get dependencyPropagationDelivery(): DependencyPropagationDeliveryPort | undefined {
+    if (!isDependencyPropagationEnabled(this.config)) return undefined;
+    return this.deps.getDependencyPropagationDelivery();
+  }
 
   async persistExtraction(
     result: ExtractionResult,
@@ -500,8 +504,7 @@ export class ExtractionPersistCoordinator {
                 structuredAttributes: { ...targetSurvivingAttrs },
                 createdAt: supersessionOrderingAt(options.validAt),
                 enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
-                extraction: this.deps.getExtraction(),
-                config: this.config,
+                dependencyPropagationDelivery: this.dependencyPropagationDelivery,
                 namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
               });
             } catch (profileSupersessionErr) {
@@ -800,10 +803,9 @@ export class ExtractionPersistCoordinator {
                   entityRef: sharedPromotionEnvelope.entityRef,
                   structuredAttributes: { ...sharedSurvivingAttrs },
                   createdAt: supersessionOrderingAt(options.validAt),
-                  enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
                   useCallerTimestamp: true,
-                  extraction: this.deps.getExtraction(),
-                  config: this.config,
+                  enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
+                  dependencyPropagationDelivery: this.dependencyPropagationDelivery,
                   namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir),
                 });
                 // Catalog touch (issue #1499 — codex P2 NElSf): this dedup branch
@@ -927,8 +929,7 @@ export class ExtractionPersistCoordinator {
               structuredAttributes: { ...sharedSurvivingAttrs },
               createdAt: supersessionOrderingAt(options.validAt),
               enabled: !(options.eventTimeSource === "extracted" && !options.validAt),
-              extraction: this.deps.getExtraction(),
-              config: this.config,
+              dependencyPropagationDelivery: this.dependencyPropagationDelivery,
               namespaceScope: this.deps.storageDirNamespace(sharedStorage.dir),
             });
           } catch (sharedSupersessionErr) {
@@ -2358,14 +2359,13 @@ export class ExtractionPersistCoordinator {
                 structuredAttributes: parentWriteEnvelope.rawStructuredAttributes
                   ? { ...parentWriteEnvelope.rawStructuredAttributes }
                   : undefined,
-                createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
                 // #1578 r3: an extracted end-only bound (validFrom absent) is
                 // historical, not a new authoritative state — never let it
                 // supersede a later active fact (codex P1 on :15534).
+                createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
                 enabled: lifecycleCaps.temporalSupersession &&
                   !(biTemporal && !biTemporal.validFrom),
-                extraction: this.deps.getExtraction(),
-                config: this.config,
+                dependencyPropagationDelivery: this.dependencyPropagationDelivery,
                 namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
               });
               for (const supersededId of temporalSupersession.supersededIds) {
@@ -2646,8 +2646,7 @@ export class ExtractionPersistCoordinator {
             createdAt: supersessionOrderingAt(biTemporal?.validFrom ?? sourceContext?.validAt),
             enabled: lifecycleCaps.temporalSupersession &&
               !(biTemporal && !biTemporal.validFrom),
-            extraction: this.deps.getExtraction(),
-            config: this.config,
+            dependencyPropagationDelivery: this.dependencyPropagationDelivery,
             namespaceScope: this.deps.storageDirNamespace(targetStorage.dir),
           });
           for (const supersededId of temporalSupersession.supersededIds) {

package/src/orchestration/extraction-queue-coordinator.ts

@@ -39,6 +39,7 @@ export class ExtractionQueueCoordinator {
   private readonly queue: Array<() => Promise<void>> = [];
   /** Whether the serial drain loop is currently running. */
   private processing = false;
+  private accepting = true;
 
   /** Current queue depth (idle-wait + test seam). */
   get length(): number {
@@ -55,7 +56,8 @@ export class ExtractionQueueCoordinator {
    * the production entry point — the orchestrator's `queueBufferedExtraction`
    * builds each task closure and hands it here.
    */
-  enqueue(task: () => Promise<void>): void {
+  enqueue(task: () => Promise<void>): boolean {
+    if (!this.accepting) return false;
     this.queue.push(task);
     if (!this.processing) {
       this.processing = true;
@@ -64,6 +66,26 @@ export class ExtractionQueueCoordinator {
         this.processing = false;
       });
     }
+    return true;
+  }
+
+  /** Stop new producers from entering the queue. */
+  stopAccepting(): void {
+    this.accepting = false;
+  }
+
+  /** Resume producer acceptance after an orchestrator re-initializes. */
+  resumeAccepting(): void {
+    this.accepting = true;
+  }
+
+  /** Stop new producers and wait for all accepted work to finish. */
+  async pauseAndDrain(timeoutMs: number = 60_000): Promise<boolean> {
+    this.stopAccepting();
+    if (await this.waitForIdle(timeoutMs)) return true;
+    log.warn("extraction queue drain exceeded timeout; waiting for accepted work to settle");
+    await this.waitForIdle(Number.POSITIVE_INFINITY);
+    return true;
   }
 
   /**

package/src/orchestration/extraction-shutdown.ts

@@ -0,0 +1,29 @@
+import { log } from "../logger.js";
+
+export interface ExtractionDrainPort {
+  pauseAndDrain(): Promise<boolean>;
+}
+
+export interface DependencyPropagationShutdownPort {
+  shutdown(): Promise<void>;
+}
+
+export async function drainExtractionAndShutdownDependencyPropagation(
+  extractionQueue: ExtractionDrainPort,
+  dependencyPropagationDelivery: DependencyPropagationShutdownPort | undefined,
+): Promise<unknown | undefined> {
+  let extractionDrainError: unknown;
+  try {
+    if (!await extractionQueue.pauseAndDrain()) {
+      extractionDrainError = new Error("orchestrator.destroy: extraction queue did not drain before teardown");
+    }
+  } catch (error) {
+    extractionDrainError = error;
+  }
+  try {
+    await dependencyPropagationDelivery?.shutdown();
+  } catch (error) {
+    log.warn(`orchestrator.destroy: dependency propagation shutdown failed: ${error}`);
+  }
+  return extractionDrainError;
+}

package/src/orchestration/maintenance.ts

@@ -126,7 +126,8 @@ export class MaintenanceScheduler {
   // ── Consolidation scheduling state ──
   private nonZeroExtractionsSinceConsolidation = 0;
   private lastConsolidationRunAtMs = 0;
-  private consolidationInFlight = false;
+  private consolidationRunPromise: Promise<unknown> | null = null;
+  private disposed = false;
 
   // ── QMD maintenance scheduling state ──
   private qmdMaintenanceTimer: NodeJS.Timeout | null = null;
@@ -442,15 +443,17 @@ export class MaintenanceScheduler {
     ) {
       return;
     }
-    if (this.consolidationInFlight) return;
+    if (this.disposed || this.consolidationRunPromise) return;
 
-    this.consolidationInFlight = true;
     this.lastConsolidationRunAtMs = now;
     this.nonZeroExtractionsSinceConsolidation = 0;
-    runConsolidation()
-      .catch((err) => log.error("background consolidation failed", err))
+    this.consolidationRunPromise = Promise.resolve()
+      .then(runConsolidation)
+      .catch((err) => {
+        log.error("background consolidation failed", err);
+      })
       .finally(() => {
-        this.consolidationInFlight = false;
+        this.consolidationRunPromise = null;
       });
   }
 
@@ -458,7 +461,7 @@ export class MaintenanceScheduler {
    *  the orchestrator's waitForConsolidationIdle can poll idle state without
    *  owning the cadence state (issue #1526 PR1). */
   isConsolidationInFlight(): boolean {
-    return this.consolidationInFlight;
+    return this.consolidationRunPromise !== null;
   }
 
   /** Whether a debounced QMD maintenance pass is armed and waiting for the
@@ -1174,6 +1177,8 @@ export class MaintenanceScheduler {
    * teardown. Async: awaits the scheduler's abort+drain before resolving.
    */
   async dispose(): Promise<void> {
+    this.disposed = true;
+    const consolidationDrain = this.consolidationRunPromise;
     // The registrar latches teardown first (so a draining tick's onRun cannot
     // re-arm QMD maintenance) and aborts+drains the sync. Capture its drain and
     // await it last so the rest of teardown runs while the aborted tick unwinds.
@@ -1190,5 +1195,6 @@ export class MaintenanceScheduler {
       this.qmdMaintenanceTimer = null;
     }
     this.qmdMaintenancePending = false;
+    if (consolidationDrain) await consolidationDrain;
   }
 }

package/src/orchestration/turn-ingestion.ts

@@ -727,7 +727,7 @@ export class TurnIngestionCoordinator {
       scheduleQueueWaitTimeout();
     }
 
-    this.deps.extractionQueueCoordinator.enqueue(async () => {
+    const accepted = this.deps.extractionQueueCoordinator.enqueue(async () => {
       if (settled) return;
       if (
         typeof extractionDeadlineMs === "number" &&
@@ -761,6 +761,10 @@ export class TurnIngestionCoordinator {
         }
       }
     });
+    if (!accepted) {
+      settleTask(new Error("extraction queue is stopped"));
+      return;
+    }
 
     log.debug(`queued extraction from ${reason}`);
   }