@remnic/core 10.0.38 → 10.0.39

package/dist/write-envelope.js

@@ -12,10 +12,10 @@ import {
   isMemoryCategory,
   isSealedMemoryEnvelope,
   sealedWriteToLegacyArgs
-} from "./chunk-TDCR6PQL.js";
+} from "./chunk-TWRPWJJT.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-E5PVMB3I.js";
-import "./chunk-UBN5AOLT.js";
+import "./chunk-SDXBR5QO.js";
+import "./chunk-W5EO4USJ.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-JDSVLVCG.js";
 import "./chunk-5GKPFL3S.js";
@@ -24,7 +24,7 @@ import "./chunk-EBRG7ZIK.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-X4OZMANG.js";
 import "./chunk-R2MBW2S4.js";
-import "./chunk-TYGLV6ZG.js";
+import "./chunk-EYGOM6AI.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-C7HJ3NEI.js";
 import "./chunk-VS2IYZRU.js";

package/package.json

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

package/src/buffer-drop-extraction-chunk.test.ts

@@ -0,0 +1,196 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { SmartBuffer } from "./buffer.js";
+import { parseConfig } from "./config.js";
+import { StorageManager } from "./storage.js";
+import type { BufferTurn } from "./types.js";
+import { ExtractionDrain } from "./orchestration/extraction-drain.js";
+import type { ExtractionRunResult } from "./orchestration/extraction-run.js";
+
+function makeTurn(sessionKey: string, content: string): BufferTurn {
+  return {
+    role: "user",
+    content,
+    timestamp: "2026-10-29T12:00:00.000Z",
+    sessionKey,
+  };
+}
+
+/** A real buffer on real storage; `restart()` is what a process restart would load from disk. */
+async function withBuffer(run: (buffer: SmartBuffer, restart: () => Promise<SmartBuffer>) => Promise<void>): Promise<void> {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-drop-chunk-"));
+  try {
+    const buffer = new SmartBuffer(parseConfig({}), new StorageManager(root));
+    await run(buffer, async () => {
+      const reloaded = new SmartBuffer(parseConfig({}), new StorageManager(root));
+      await reloaded.load();
+      return reloaded;
+    });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+
+test("dropExtractionChunk removes the matched prefix and the drop survives a restart", async () => {
+  await withBuffer(async (buffer, restart) => {
+    const turns = [makeTurn("s1", "turn one"), makeTurn("s1", "turn two"), makeTurn("s1", "turn three")];
+    for (const turn of turns) await buffer.addTurn("s1", turn);
+    await buffer.flushPendingSave();
+
+    const dropped = await buffer.dropExtractionChunk("s1", turns.slice(0, 2));
+
+    assert.equal(dropped, 2);
+    assert.deepEqual(buffer.getTurns("s1").map((turn) => turn.content), ["turn three"]);
+    assert.deepEqual((await restart()).getTurns("s1").map((turn) => turn.content), ["turn three"], "what a restart loads");
+    // A drop is not an extraction: the extraction bookkeeping stays untouched.
+    assert.equal(buffer.getExtractionCount("s1"), 0);
+  });
+});
+
+test("dropExtractionChunk returns zero without dropping when turns no longer match", async () => {
+  await withBuffer(async (buffer, restart) => {
+    await buffer.addTurn("s1", makeTurn("s1", "kept turn"));
+    await buffer.flushPendingSave();
+
+    const dropped = await buffer.dropExtractionChunk("s1", [makeTurn("s1", "already extracted elsewhere")]);
+
+    assert.equal(dropped, 0);
+    assert.equal(buffer.getTurns("s1").length, 1);
+    assert.equal((await restart()).getTurns("s1").length, 1, "the kept turn is still there after a restart");
+  });
+});
+
+test("dropExtractionChunk drops the whole matched window and a restart finds the buffer empty", async () => {
+  await withBuffer(async (buffer, restart) => {
+    const turns = [makeTurn("s1", "only turn")];
+    await buffer.addTurn("s1", turns[0]!);
+    await buffer.flushPendingSave();
+
+    const dropped = await buffer.dropExtractionChunk("s1", turns);
+
+    assert.equal(dropped, 1);
+    assert.equal(buffer.getTurns("s1").length, 0);
+    assert.equal((await restart()).getTurns("s1").length, 0);
+  });
+});
+
+const FAILED: ExtractionRunResult = { status: "skipped", reason: "empty_extraction_result", retainedBuffer: true, failureClass: "parse_empty", persistedCount: 0, durableOutputCount: 0 };
+const DONE: ExtractionRunResult = { status: "completed", persistedCount: 1, durableOutputCount: 1 };
+
+/** w7K's probe on #3266: a pinned capture sits before a native group drained with clearMatchingTurns. */
+async function drainBehindPinnedCapture(buffer: SmartBuffer, results: ExtractionRunResult[], dropAfter: number): Promise<ExtractionRunResult> {
+  const pinned: BufferTurn = { ...makeTurn("s1", "pinned capture"), acceptedCapture: true };
+  const native = [makeTurn("s1", "a".repeat(60)), makeTurn("s1", "b".repeat(60))];
+  for (const turn of [pinned, ...native]) await buffer.addTurn("s1", turn);
+  await buffer.flushPendingSave();
+  const drain = new ExtractionDrain({
+    config: { extractionMinUserTurns: 1, extractionMinChars: 0, extractionMaxTurnChars: 100_000, extractionChunkDropAfterFailures: dropAfter },
+    extractionWindowBudgetChars: () => 100,
+    runExtraction: async (turns, options) => {
+      const result = results.shift() ?? DONE;
+      // A successful run clears its chunk the way the coordinator does for a native group: by identity.
+      if (result.status === "completed") await buffer.clearAfterExtraction("s1", turns, options?.clearMatchingTurns === true ? { allowNonPrefix: true } : undefined);
+      return result;
+    },
+    getStorage: async () => ({ saveDroppedExtractionChunk: async () => "/recovery/copy.json" }),
+    buffer,
+    extractionQueueCoordinator: { beginPreemptable: () => {} },
+  });
+  return await drain.run(native, {
+    bufferKey: "s1",
+    clearBufferAfterExtraction: true,
+    clearMatchingTurns: true,
+    skipUserTurnThreshold: false,
+    failOnExtractionFailure: false,
+    forceExtractionAttempt: false,
+  });
+}
+
+test("a dropped chunk behind a pinned capture is removed by identity, like a successful clear (w7K)", async () => {
+  await withBuffer(async (buffer, restart) => {
+    const result = await drainBehindPinnedCapture(buffer, [FAILED, DONE], 1);
+
+    assert.equal(result.status, "completed");
+    assert.deepEqual(buffer.getTurns("s1").map((turn) => turn.content), ["pinned capture"], "the failed turn is gone, the pinned capture stays");
+    assert.deepEqual((await restart()).getTurns("s1").map((turn) => turn.content), ["pinned capture"], "and a restart agrees");
+  });
+});
+
+test("a failed chunk made only of deferred-retained turns can be dropped, and a restart agrees (Codex P2)", async () => {
+  await withBuffer(async (buffer, restart) => {
+    const retained = [makeTurn("s1", "retained one"), makeTurn("s1", "retained two")];
+    const live = makeTurn("s1", "live turn");
+    await buffer.retainDeferredTurns("s1", retained);
+    await buffer.addTurn("s1", live);
+    await buffer.flushPendingSave();
+
+    // The window a trigger snapshot sees is the retained turns followed by the live ones; the first chunk is retained-only.
+    const dropped = await buffer.dropExtractionChunk("s1", retained);
+
+    assert.equal(dropped, 2);
+    assert.deepEqual(buffer.getRetainedDeferredTurns("s1"), []);
+    assert.deepEqual(buffer.getTurns("s1").map((turn) => turn.content), ["live turn"]);
+    const reloaded = await restart();
+    assert.deepEqual(reloaded.getRetainedDeferredTurns("s1"), [], "retained turns stay dropped after a restart");
+    assert.deepEqual(reloaded.getTurns("s1").map((turn) => turn.content), ["live turn"]);
+  });
+});
+
+test("a chunk that spans retained and live turns drops both", async () => {
+  await withBuffer(async (buffer, restart) => {
+    const retained = [makeTurn("s1", "retained one")];
+    const live = [makeTurn("s1", "live one"), makeTurn("s1", "live two")];
+    await buffer.retainDeferredTurns("s1", retained);
+    for (const turn of live) await buffer.addTurn("s1", turn);
+    await buffer.flushPendingSave();
+
+    const dropped = await buffer.dropExtractionChunk("s1", [...retained, live[0]!]);
+
+    assert.equal(dropped, 2);
+    assert.deepEqual((await restart()).getTurns("s1").map((turn) => turn.content), ["live two"]);
+  });
+});
+
+test("deferred retention across chunks of one window stays within one retention window (Codex P2)", async () => {
+  await withBuffer(async (buffer, restart) => {
+    const window = Array.from({ length: 30 }, (_, i) => makeTurn("s1", `turn ${i}`));
+    for (const turn of window) await buffer.addTurn("s1", turn);
+    // Three chunks of ten, each deferring all of its turns; every run names the whole window as the processed snapshot.
+    for (let chunk = 0; chunk < 3; chunk++) {
+      await buffer.retainDeferredTurns("s1", window.slice(chunk * 10, chunk * 10 + 10), 10, window);
+    }
+    assert.equal(buffer.getRetainedDeferredTurns("s1").length, 10, "the latest chunk's retention replaces the earlier ones");
+    assert.equal((await restart()).getRetainedDeferredTurns("s1").length, 10);
+  });
+});
+
+test("a chunk holding only some retained turns drops those and keeps the rest of the retention slot (Phosphene)", async () => {
+  await withBuffer(async (buffer, restart) => {
+    const retained = [makeTurn("s1", "retained one"), makeTurn("s1", "retained two"), makeTurn("s1", "retained three")];
+    await buffer.retainDeferredTurns("s1", retained);
+    await buffer.addTurn("s1", makeTurn("s1", "live turn"));
+    await buffer.flushPendingSave();
+
+    const dropped = await buffer.dropExtractionChunk("s1", retained.slice(0, 2));
+
+    assert.equal(dropped, 2);
+    assert.deepEqual(buffer.getRetainedDeferredTurns("s1").map((turn) => turn.content), ["retained three"]);
+    const reloaded = await restart();
+    assert.deepEqual(reloaded.getRetainedDeferredTurns("s1").map((turn) => turn.content), ["retained three"]);
+    assert.deepEqual(reloaded.getTurns("s1").map((turn) => turn.content), ["retained three", "live turn"]);
+  });
+});
+
+test("retention for an early chunk leaves the retained turns of a later, unprocessed chunk alone (Codex P2)", async () => {
+  await withBuffer(async (buffer, restart) => {
+    const retained = [makeTurn("s1", "early retained"), makeTurn("s1", "late retained")];
+    await buffer.retainDeferredTurns("s1", retained);
+    // Chunk 0 holds the first retained turn; nothing was deferred in it, so it clears the slot for the turns it processed.
+    await buffer.retainDeferredTurns("s1", [], 0, retained.slice(0, 1));
+    assert.deepEqual(buffer.getRetainedDeferredTurns("s1").map((turn) => turn.content), ["late retained"]);
+    assert.deepEqual((await restart()).getRetainedDeferredTurns("s1").map((turn) => turn.content), ["late retained"]);
+  });
+});

package/src/buffer-types.ts

@@ -0,0 +1,65 @@
+/** Types split out of buffer.ts (structural ratchet, issue #1995). */
+
+import type { BufferTurn } from "./types.js";
+
+/**
+ * Optional surprise probe injected into `SmartBuffer`.
+ *
+ * Computes a D-MEM-style novelty score in `[0, 1]` for an incoming turn.
+ * The buffer treats the probe as purely additive: if it is not provided, if
+ * the feature flag is off, or if the probe throws/times out, the buffer
+ * falls back to the existing signal/turn-count/time triggers unchanged.
+ *
+ * Callers are responsible for sampling recent memories and passing them
+ * through the embedding pipeline — the buffer does not want to know about
+ * storage, embeddings, or QMD.
+ *
+ * @param bufferKey Identifier for the active buffer (session/thread).
+ * @param turn      The incoming turn whose novelty is being scored.
+ * @param recentTurns Turns already buffered for this key (most recent first
+ *                    is NOT guaranteed — treat as unordered corpus).
+ * @returns A surprise score in `[0, 1]`, or `null` if no score could be
+ *          produced (e.g. empty corpus, probe declined to embed).
+ */
+export interface BufferSurpriseProbe {
+  scoreTurn(
+    bufferKey: string,
+    turn: BufferTurn,
+    recentTurns: readonly BufferTurn[],
+  ): Promise<number | null>;
+}
+
+/**
+ * Minimal data carried on the serialized telemetry write chain
+ * (issue #563 PR 3).
+ *
+ * We intentionally do NOT capture the full `BufferTurn` here: under
+ * slow filesystem latency the chain can back up, and retaining
+ * `turn.content` for every pending append causes memory pressure on
+ * large conversations. Only the fields the ledger row actually needs
+ * cross the chain boundary.
+ */
+export interface SurpriseTelemetryQueueEntry {
+  bufferKey: string;
+  turnRole: "user" | "assistant";
+  sessionKey: string | null;
+  surpriseScore: number;
+  triggered: boolean;
+  turnCountInWindow: number;
+  /**
+   * ISO timestamp captured at the moment the turn was scored, NOT when
+   * the ledger append eventually runs. Backpressure on the serialized
+   * write chain could otherwise shift event timestamps away from the
+   * real decision moment and distort the distribution report (p90
+   * inflated, current-threshold row misidentified).
+   */
+  timestamp: string;
+  /**
+   * Threshold value in force when `triggered` was computed. Must be
+   * snapshot here rather than read from `config` at emit time — a
+   * concurrent config change between queue and write would otherwise
+   * record `triggered=true` against a newer threshold the operator
+   * never set, distorting precision/recall interpretation.
+   */
+  threshold: number;
+}

package/src/buffer.ts

@@ -31,6 +31,9 @@ import {
 
 export type TriggerDecision = "extract_now" | "extract_batch" | "keep_buffering";
 
+export type { BufferSurpriseProbe } from "./buffer-types.js";
+import type { BufferSurpriseProbe, SurpriseTelemetryQueueEntry } from "./buffer-types.js";
+
 export interface AddTurnOutcome {
   decision: TriggerDecision;
   extractionTurns?: BufferTurn[];
@@ -46,33 +49,6 @@ export interface RetainedTurnCleanupOptions {
   codingContext?: import("./types.js").CodingContext;
 }
 
-/**
- * Optional surprise probe injected into `SmartBuffer`.
- *
- * Computes a D-MEM-style novelty score in `[0, 1]` for an incoming turn.
- * The buffer treats the probe as purely additive: if it is not provided, if
- * the feature flag is off, or if the probe throws/times out, the buffer
- * falls back to the existing signal/turn-count/time triggers unchanged.
- *
- * Callers are responsible for sampling recent memories and passing them
- * through the embedding pipeline — the buffer does not want to know about
- * storage, embeddings, or QMD.
- *
- * @param bufferKey Identifier for the active buffer (session/thread).
- * @param turn      The incoming turn whose novelty is being scored.
- * @param recentTurns Turns already buffered for this key (most recent first
- *                    is NOT guaranteed — treat as unordered corpus).
- * @returns A surprise score in `[0, 1]`, or `null` if no score could be
- *          produced (e.g. empty corpus, probe declined to embed).
- */
-export interface BufferSurpriseProbe {
-  scoreTurn(
-    bufferKey: string,
-    turn: BufferTurn,
-    recentTurns: readonly BufferTurn[],
-  ): Promise<number | null>;
-}
-
 const MAX_BUFFER_ENTRY_COUNT = 200;
 const isAcceptedTurn = (t: { acceptedCapture?: boolean; writeNamespaceOverride?: string }): boolean =>
   t.acceptedCapture === true || t.writeNamespaceOverride !== undefined;
@@ -96,41 +72,6 @@ const BUFFER_SAVE_MAX_DEFER_MULTIPLIER = 5;
  */
 const MAX_SET_TIMEOUT_MS = 2_147_483_647;
 
-/**
- * Minimal data carried on the serialized telemetry write chain
- * (issue #563 PR 3).
- *
- * We intentionally do NOT capture the full `BufferTurn` here: under
- * slow filesystem latency the chain can back up, and retaining
- * `turn.content` for every pending append causes memory pressure on
- * large conversations. Only the fields the ledger row actually needs
- * cross the chain boundary.
- */
-interface SurpriseTelemetryQueueEntry {
-  bufferKey: string;
-  turnRole: "user" | "assistant";
-  sessionKey: string | null;
-  surpriseScore: number;
-  triggered: boolean;
-  turnCountInWindow: number;
-  /**
-   * ISO timestamp captured at the moment the turn was scored, NOT when
-   * the ledger append eventually runs. Backpressure on the serialized
-   * write chain could otherwise shift event timestamps away from the
-   * real decision moment and distort the distribution report (p90
-   * inflated, current-threshold row misidentified).
-   */
-  timestamp: string;
-  /**
-   * Threshold value in force when `triggered` was computed. Must be
-   * snapshot here rather than read from `config` at emit time — a
-   * concurrent config change between queue and write would otherwise
-   * record `triggered=true` against a newer threshold the operator
-   * never set, distorting precision/recall interpretation.
-   */
-  threshold: number;
-}
-
 interface AddTurnMutationResult {
   decision: TriggerDecision;
   signalLevel: SignalLevel;
@@ -1148,6 +1089,63 @@ export class SmartBuffer {
     });
   }
 
+  /**
+   * Remove an extraction-window chunk from the buffer WITHOUT recording an
+   * extraction (trigger-drain drop path). Used when a chunk fails extraction
+   * repeatedly and must be dropped so the session can drain; the caller is
+   * responsible for the side-file copy and logging. Returns the number of
+   * live turns dropped; 0 when the turns no longer match. `allowNonPrefix`
+   * matches by identity, like `clearAfterExtraction`, for callers (native
+   * groups) whose chunk can sit behind a pinned capture.
+   */
+  async dropExtractionChunk(
+    bufferKey = "default",
+    turns: readonly BufferTurn[],
+    options?: { allowNonPrefix?: boolean },
+  ): Promise<number> {
+    return await this.enqueueMutation(async () => {
+      await this.loadUnlocked();
+      const entry = this.entryFor(bufferKey);
+      // A window's head can be deferred-retained turns (retainDeferredTurns): take those out of the chunk first.
+      const retained = [...(entry.retainedTurns ?? [])];
+      const liveTurns: BufferTurn[] = [];
+      for (const turn of turns) {
+        const at = retained.findIndex((kept) => bufferTurnsEqual(kept, turn));
+        if (at >= 0) retained.splice(at, 1);
+        else liveTurns.push(turn);
+      }
+      const retainedDropped = (entry.retainedTurns?.length ?? 0) - retained.length;
+      let remaining = entry.turns;
+      if (options?.allowNonPrefix === true) {
+        remaining = [...entry.turns];
+        for (const turn of liveTurns) {
+          const at = remaining.findIndex((live) => bufferTurnsEqual(live, turn));
+          if (at >= 0) remaining.splice(at, 1);
+        }
+      } else {
+        remaining = entry.turns.slice(matchingQueuedExtractionPrefixLength(entry.turns, liveTurns));
+      }
+      const matchedCount = entry.turns.length - remaining.length + retainedDropped;
+      if (matchedCount === 0) return 0;
+      if (this.saveTimer) {
+        clearTimeout(this.saveTimer);
+        this.saveTimer = null;
+      }
+      entry.turns = remaining;
+      if (retainedDropped > 0) {
+        if (retained.length > 0) entry.retainedTurns = retained;
+        else delete entry.retainedTurns;
+      }
+      if (bufferKey === "default") {
+        this.state.turns = entry.turns;
+      }
+      this.persistence.markDirty(bufferKey);
+      this.pruneEntries([bufferKey]);
+      await this.saveNowRetainingPendingOnFailure("dropExtractionChunk");
+      return matchedCount;
+    });
+  }
+
   getExtractionCount(bufferKey = "default"): number {
     return this.peekEntry(bufferKey)?.extractionCount ?? 0;
   }

package/src/config.ts

@@ -2868,6 +2868,14 @@ export function parseConfig(
     extractionBreakerAuthCooldownMs:
       typeof cfg.extractionBreakerAuthCooldownMs === "number" && cfg.extractionBreakerAuthCooldownMs >= 0
         ? cfg.extractionBreakerAuthCooldownMs : 1_800_000,
+    // Trigger-drain drop threshold: consecutive failed extraction attempts
+    // before the failing buffer chunk is dropped (side-file copied first).
+    extractionChunkDropAfterFailures: parseIntegerAtLeast(
+      cfg.extractionChunkDropAfterFailures,
+      5,
+      1,
+      "extractionChunkDropAfterFailures",
+    ),
     // Local LLM fast tier (v9.1)
     localLlmFastEnabled: cfg.localLlmFastEnabled === true,
     localLlmFastModel:

package/src/extraction-window-drain.test.ts

@@ -0,0 +1,123 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  chunkExtractionWindow,
+  classifyDrainResult,
+  extractionWindowBudgetChars,
+  mergeDrainResults,
+} from "./extraction-window-drain.js";
+import type { ExtractionRunResult } from "./orchestration/extraction-run.js";
+import type { BufferTurn } from "./types.js";
+
+function makeTurn(content: string, sessionKey = "s1"): BufferTurn {
+  return { role: "user", content, timestamp: "2026-10-29T00:00:00.000Z", sessionKey };
+}
+
+function skippedResult(reason: string): ExtractionRunResult {
+  return { status: "skipped", reason, persistedCount: 0, durableOutputCount: 0 };
+}
+
+test("chunkExtractionWindow returns a single chunk when the window fits the budget", () => {
+  const turns = [makeTurn("a".repeat(10)), makeTurn("b".repeat(10))];
+  const chunks = chunkExtractionWindow(turns, 100);
+  assert.equal(chunks.length, 1);
+  assert.deepEqual(chunks[0], turns);
+});
+
+test("chunkExtractionWindow splits an oversized window into budget-fitting chunks in order", () => {
+  const turns = [
+    makeTurn("a".repeat(60)),
+    makeTurn("b".repeat(60)),
+    makeTurn("c".repeat(60)),
+    makeTurn("d".repeat(60)),
+  ];
+  const chunks = chunkExtractionWindow(turns, 100);
+  assert.equal(chunks.length, 4);
+  for (const chunk of chunks) {
+    assert.ok(chunk.every((turn) => turn.content.length <= 100));
+  }
+  assert.deepEqual(
+    chunks.flat().map((turn) => turn.content[0]),
+    ["a", "b", "c", "d"],
+  );
+  assert.deepEqual(chunks.flat(), turns);
+});
+
+test("chunkExtractionWindow gives a single oversized turn its own chunk", () => {
+  const turns = [makeTurn("x".repeat(250)), makeTurn("y".repeat(10))];
+  const chunks = chunkExtractionWindow(turns, 100);
+  assert.equal(chunks.length, 2);
+  assert.equal(chunks[0]?.length, 1);
+  assert.equal(chunks[1]?.length, 1);
+});
+
+test("chunkExtractionWindow treats a non-positive budget as no chunking", () => {
+  const turns = [makeTurn("a".repeat(500)), makeTurn("b".repeat(500))];
+  assert.equal(chunkExtractionWindow(turns, 0).length, 1);
+  assert.equal(chunkExtractionWindow(turns, Number.POSITIVE_INFINITY).length, 1);
+});
+
+test("chunkExtractionWindow returns no chunks for an empty window", () => {
+  assert.deepEqual(chunkExtractionWindow([], 100), []);
+});
+
+test("classifyDrainResult treats completed runs and benign skips as drained", () => {
+  assert.equal(classifyDrainResult({ status: "completed", persistedCount: 1, durableOutputCount: 2 }), "drained");
+  assert.equal(classifyDrainResult(skippedResult("below_threshold")), "drained");
+  assert.equal(classifyDrainResult(skippedResult("cron_session")), "drained");
+  assert.equal(classifyDrainResult(skippedResult("empty_normalized_turns")), "drained");
+  assert.equal(classifyDrainResult(skippedResult("processed_fingerprint")), "drained");
+});
+
+test("classifyDrainResult reports breaker/backoff skips as deferred", () => {
+  assert.equal(classifyDrainResult(skippedResult("provider_circuit_open")), "deferred");
+  assert.equal(classifyDrainResult(skippedResult("extraction_backoff")), "deferred");
+});
+
+test("classifyDrainResult reports empty extraction results as failed", () => {
+  assert.equal(
+    classifyDrainResult({ ...skippedResult("empty_extraction_result"), retainedBuffer: true }),
+    "failed",
+    "an empty result that kept the window for retry is a chunk failure",
+  );
+  assert.equal(
+    classifyDrainResult(skippedResult("empty_extraction_result")),
+    "drained",
+    "an empty result that cleared its turns extracted fine and found nothing durable",
+  );
+});
+
+test("mergeDrainResults sums counts, completes when any chunk completes, keeps the last skip reason", () => {
+  const first = skippedResult("empty_extraction_result");
+  const second: ExtractionRunResult = { status: "completed", persistedCount: 3, durableOutputCount: 4 };
+  // A completed chunk means the drain made durable progress.
+  const merged = mergeDrainResults(mergeDrainResults(null, first), second);
+  assert.equal(merged.status, "completed");
+  assert.equal(merged.persistedCount, 3);
+  assert.equal(merged.durableOutputCount, 4);
+  // All chunks skipped: the aggregate stays skipped with the last reason.
+  const mergedFailed = mergeDrainResults(
+    mergeDrainResults(null, skippedResult("provider_circuit_open")),
+    first,
+  );
+  assert.equal(mergedFailed.status, "skipped");
+  assert.equal(mergedFailed.reason, "empty_extraction_result");
+  assert.equal(mergedFailed.persistedCount, 0);
+});
+
+test("extractionWindowBudgetChars applies the learned local window only when the local model extracts", () => {
+  const registry = { calculateContextSizes: () => ({ maxInputChars: 12_000 }) };
+  const base = { registry, model: "local-model", maxContext: undefined };
+
+  assert.equal(extractionWindowBudgetChars({ ...base, localExtractionActive: true }), 12_000);
+  assert.equal(
+    extractionWindowBudgetChars({ ...base, localExtractionActive: false }),
+    Number.POSITIVE_INFINITY,
+    "gateway or disabled local LLM: the local window does not describe the extractor",
+  );
+  assert.equal(
+    extractionWindowBudgetChars({ ...base, registry: undefined, localExtractionActive: true }),
+    Number.POSITIVE_INFINITY,
+    "no registry (legacy host or test double): no budget",
+  );
+});