@remnic/core 10.0.37 → 10.0.39

package/dist/who-knows.js

@@ -9,22 +9,22 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-DK5VMJL3.js";
-import "./chunk-R6TCM47S.js";
+} from "./chunk-WT2VVYBM.js";
+import "./chunk-5KZNWERU.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-DM5QZ3YU.js";
 import "./chunk-VY6BD5KB.js";
-import "./chunk-JH4FCVWJ.js";
-import "./chunk-LHBOFROT.js";
-import "./chunk-P5CUEB2Q.js";
+import "./chunk-G6OFEGUR.js";
+import "./chunk-V2XMG7GM.js";
+import "./chunk-4QLKVZH6.js";
+import "./chunk-XKDQTDXN.js";
+import "./chunk-CYEPCZN5.js";
 import "./chunk-XRFLR3XF.js";
 import "./chunk-7VO6E5UD.js";
 import "./chunk-EXYT52NR.js";
 import "./chunk-5CWH2LKL.js";
-import "./chunk-XKDQTDXN.js";
 import "./chunk-WNEVEMJ3.js";
 import "./chunk-Y5NLBXPV.js";
-import "./chunk-CYEPCZN5.js";
 import "./chunk-TFA6HPOA.js";
 import "./chunk-F4TWWUMP.js";
 import "./chunk-72A4L5JJ.js";
@@ -34,17 +34,17 @@ import "./chunk-PPUNC7UX.js";
 import "./chunk-X3724WL4.js";
 import "./chunk-MRPOZBJC.js";
 import "./chunk-S2HLHAZ4.js";
-import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
+import "./chunk-DM2T26WE.js";
 import "./chunk-FF6N7BXC.js";
-import "./chunk-5EILJ6W2.js";
+import "./chunk-WXPBDEMW.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-YQ6SLFNZ.js";
+import "./chunk-MPJDQC4G.js";
 import "./chunk-ZIKENA2C.js";
+import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
 import "./chunk-3OUGSOJP.js";
 import "./chunk-SCU65EZI.js";
-import "./chunk-3ONXXHQO.js";
 import "./chunk-P4GUQSK3.js";
 import "./chunk-3WU7XOFN.js";
 import "./chunk-G7D6GZ5J.js";
@@ -55,16 +55,16 @@ import "./chunk-LWRIGKFM.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-7CT3AI52.js";
-import "./chunk-AYXRK264.js";
-import "./chunk-IUM3VSHI.js";
+import "./chunk-RROFIAYI.js";
 import "./chunk-G26YNEOC.js";
-import "./chunk-VILPVT4S.js";
 import "./chunk-AF2XMJKD.js";
 import "./chunk-OR42ZI54.js";
+import "./chunk-IUM3VSHI.js";
+import "./chunk-VILPVT4S.js";
 import "./chunk-23G5P7TA.js";
 import "./chunk-C64XATK7.js";
 import "./chunk-42JKGUFJ.js";
-import "./chunk-GMMZ45C4.js";
+import "./chunk-AVVCPA7U.js";
 import "./chunk-I55KAVET.js";
 import "./chunk-L2EXJQJP.js";
 import "./chunk-45GF7Y3V.js";
@@ -77,23 +77,23 @@ import "./chunk-YCVB7X56.js";
 import "./chunk-PQVCH2AE.js";
 import "./chunk-PJKTFXE2.js";
 import "./chunk-W5BIQOAJ.js";
-import "./chunk-A6PKEU7T.js";
+import "./chunk-PARM6OYL.js";
 import "./chunk-YBA52OKG.js";
-import "./chunk-TDCR6PQL.js";
+import "./chunk-TWRPWJJT.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-E5PVMB3I.js";
+import "./chunk-SDXBR5QO.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
 import "./chunk-L272A5QW.js";
-import "./chunk-UJDTXWMT.js";
+import "./chunk-QIMGULGN.js";
 import "./chunk-ZA53AZND.js";
 import "./chunk-7RJUVTVF.js";
 import "./chunk-AL3UYZ5N.js";
 import "./chunk-RL6NEVXT.js";
 import "./chunk-YET735EZ.js";
 import "./chunk-PWPIERBM.js";
-import "./chunk-UBN5AOLT.js";
+import "./chunk-W5EO4USJ.js";
 import "./chunk-5FVVY2EB.js";
 import "./chunk-BTNNL7ZW.js";
 import "./chunk-JDSVLVCG.js";
@@ -111,7 +111,7 @@ import "./chunk-3MUKQQ7A.js";
 import "./chunk-R2MBW2S4.js";
 import "./chunk-QUIRIG2P.js";
 import "./chunk-LDPPTPO5.js";
-import "./chunk-TYGLV6ZG.js";
+import "./chunk-EYGOM6AI.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-C7HJ3NEI.js";
 import "./chunk-VS2IYZRU.js";

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.37",
+  "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.37"
+    "@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.test.ts

@@ -1060,6 +1060,22 @@ test("parseConfig localLlmTimeoutMs clamps invalid values to a positive timeout"
   assert.equal(parseConfig({ localLlmTimeoutMs: Number.NaN }).localLlmTimeoutMs, 180_000);
 });
 
+test("parseConfig extractionJudgeTimeoutMs defaults to 20000 — compact verdict measures 2.1-2.5 s on a small fast judge model", () => {
+  assert.equal(parseConfig({}).extractionJudgeTimeoutMs, 20_000);
+});
+
+test("parseConfig extractionJudgeTimeoutMs accepts numbers and CLI-style numeric strings", () => {
+  assert.equal(parseConfig({ extractionJudgeTimeoutMs: 45_000 }).extractionJudgeTimeoutMs, 45_000);
+  assert.equal(parseConfig({ extractionJudgeTimeoutMs: "90000" }).extractionJudgeTimeoutMs, 90_000);
+});
+
+test("parseConfig extractionJudgeTimeoutMs falls back to the default on unusable values and caps the top", () => {
+  for (const value of [0, -1, Number.NaN, "abc"]) {
+    assert.equal(parseConfig({ extractionJudgeTimeoutMs: value }).extractionJudgeTimeoutMs, 20_000);
+  }
+  assert.equal(parseConfig({ extractionJudgeTimeoutMs: 10_000_000 }).extractionJudgeTimeoutMs, 3_600_000);
+});
+
 test("parseConfig validates localLlmMaxContext as a usable context window", () => {
   assert.equal(parseConfig({ localLlmMaxContext: 4096 }).localLlmMaxContext, 4096);
   assert.equal(parseConfig({ localLlmMaxContext: "8192" }).localLlmMaxContext, 8192);

package/src/config.ts

@@ -2731,6 +2731,20 @@ export function parseConfig(
       typeof cfg.extractionJudgeBatchSize === "number" && Number.isFinite(cfg.extractionJudgeBatchSize)
         ? Math.max(1, Math.round(cfg.extractionJudgeBatchSize))
         : 20,
+    // Judge LLM timeout (issue #376 follow-up, Studio 2026-10-29; tightened in
+    // PR 3264): the judge requests a compact verdict with a batch-scaled
+    // completion budget (24 tokens per candidate, up to 2048). Measured
+    // 2.1-2.5 s per call on a small fast judge
+    // model; the big shared core model measured 13-22 s per compact call,
+    // 41 s verbose. The 20s default assumes the fast model, stays fail-open
+    // on timeout, and needs a raise if extractionJudgeModel points at the
+    // slow core model. Non-positive / unusable values fall back to the
+    // default rather than a 1ms timeout that would silently disable judging.
+    extractionJudgeTimeoutMs: ((): number => {
+      const coerced = coerceNumber(cfg.extractionJudgeTimeoutMs);
+      if (coerced === undefined || coerced < 1) return 20_000;
+      return Math.min(3_600_000, Math.floor(coerced));
+    })(),
     extractionJudgeShadow: cfg.extractionJudgeShadow === true,
     // Defer cap (issue #562 PR 2): max re-deferrals for the same candidate
     // text before the verdict is forcibly converted to reject.
@@ -2854,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: