@remnic/core 10.0.73 → 10.0.75

package/src/access-observe-helpers.ts

@@ -148,12 +148,15 @@ export class PendingObserveExtractionTracker {
       controllers: new Set(previous ? [...previous.controllers, controller] : [controller]),
     };
     this.entries.set(key, entry);
+    // Any settle (success OR rejection — preemption is just one rejection
+    // kind) ends the pending entry; leaving a settled failure tracked wedged
+    // the key and kept every controller ever registered for it alive.
     void promise
       .then(() => {
         if (this.entries.get(key) === entry) this.entries.delete(key);
       })
-      .catch((error) => {
-        if (error instanceof Error && isPreemptedExtraction(error) && this.entries.get(key) === entry) this.entries.delete(key);
+      .catch(() => {
+        if (this.entries.get(key) === entry) this.entries.delete(key);
       });
   }
 

package/src/access-service-observe-lcm-parity.test.ts

@@ -639,11 +639,18 @@ test("#2128: a failed observe extraction is consumed after force-flush reports i
   const failure = new Error("provider failed");
 
   await service.observe(observeRequest({ sessionKey, skipExtraction: false }));
-  rejectExtraction(failure);
-  await assert.rejects(
+  // The flush parks on the pending extraction and reports its failure
+  // (identity-preserved) when it rejects; with the last-write-wins bug the
+  // failure was never tracked at all.
+  const reported = assert.rejects(
     service.extractionForceFlush({ sessionKey }),
     (error: unknown) => error === failure,
   );
+  const parked = Promise.withResolvers<void>();
+  setImmediate(parked.resolve);
+  await parked.promise;
+  rejectExtraction(failure);
+  await reported;
 
   await service.observe(observeRequest({ sessionKey, skipExtraction: false }));
   await assert.doesNotReject(() => service.extractionForceFlush({ sessionKey }));

package/src/access-service-observe-scope.test.ts

@@ -256,8 +256,15 @@ test("a preempted observe extraction does not block the next force-flush", async
   const key = tracker.key("session-a", "alice", "default");
   tracker.track(key, Promise.reject(preemptedExtractionError()), new AbortController());
   await tracker.wait("session-a", "alice", "default");
+  // A settled failure is no longer pending: the entry is removed on ANY
+  // settle, so the next flush is neither blocked nor failed by work that
+  // already finished. (A flush overlapping the failing extraction still
+  // surfaces its error — covered in access-observe-helpers.test.ts.)
   tracker.track(key, Promise.reject(new Error("extraction failed")), new AbortController());
-  await assert.rejects(() => tracker.wait("session-a", "alice", "default"), /extraction failed/);
+  const { promise, resolve } = Promise.withResolvers<void>();
+  setImmediate(resolve);
+  await promise;
+  await tracker.wait("session-a", "alice", "default");
 });
 
 test("cancelling a tracked extraction with a preemption reason does not block the next flush", async () => {

package/src/backlog-scheduler.test.ts

@@ -804,3 +804,107 @@ test("claims past the concurrency bound are re-listed on the next tick, in page
     await scheduler.stop();
   }
 });
+
+// ── Provider-breaker churn guard ────────────────────────────────────────────
+//
+// While the shared provider breaker is OPEN inside its cooldown, a full
+// submission reads the claim, rebuilds the buffer/coordinator and re-renders
+// chunks before the breaker fails the attempt fast — pure heap pressure per
+// poll. The scheduler must skip submission entirely; when the window lapses,
+// submissions resume and the breaker's own half-open probe keeps recovery
+// automatic.
+
+function breakerInstrumentedDeps(
+  state: StubState,
+  queue: ExtractionQueueCoordinator,
+): BacklogSchedulerDeps & { claimReads(): number } {
+  const deps = makeDeps(state, queue);
+  const originalClaim = deps.claims.claimFromSessionFile;
+  let claimReads = 0;
+  deps.claims.claimFromSessionFile = async (key, lease) => {
+    claimReads += 1;
+    return originalClaim(key, lease);
+  };
+  return { ...deps, claimReads: () => claimReads };
+}
+
+test("an open provider breaker suppresses submission: no drain, no claim read", async () => {
+  const queue = new ExtractionQueueCoordinator(2);
+  const state: StubState = {
+    counts: new Map([["live-open", { turns: 4, retainedTurns: 0 }]]),
+    claimed: new Set(["pending-claim"]),
+    claimTurns: new Map([["pending-claim", 7]]),
+    claimedThisRun: new Set(),
+    outcomes: [],
+    drained: [],
+  };
+  const deps = breakerInstrumentedDeps(state, queue);
+  const originalListPage = deps.claims.listPage;
+  let listPageCalls = 0;
+  deps.claims.listPage = async (...args) => {
+    listPageCalls += 1;
+    return originalListPage(...args);
+  };
+  const scheduler = new BacklogScheduler({
+    ...deps,
+    breakerSnapshot: () => ({
+      state: "open",
+      openUntilMs: Date.now() + 300_000,
+      consecutiveFailures: 5,
+      lastReason: "provider 400s",
+    }),
+  }, { pollMs: 3_600_000 });
+  scheduler.start();
+  try {
+    for (let tick = 1; tick <= 2; tick += 1) {
+      await scheduler.tickForTest();
+      await scheduler.settleForTest();
+    }
+    assert.equal(state.drained.length, 0, "no attempt is built while the breaker is open");
+    assert.equal(deps.claimReads(), 0, "no claim is read while the breaker is open");
+    assert.equal(listPageCalls, 0, "claim discovery I/O is skipped while the breaker is open");
+    assert.equal(scheduler.snapshot().counters.claimed, 0);
+  } finally {
+    await scheduler.stop();
+  }
+});
+
+test("a lapsed breaker window resumes submission and drains the backlog", async () => {
+  const queue = new ExtractionQueueCoordinator(2);
+  const state: StubState = {
+    counts: new Map([["live-open", { turns: 4, retainedTurns: 0 }]]),
+    claimed: new Set(["pending-claim"]),
+    claimTurns: new Map([["pending-claim", 7]]),
+    claimedThisRun: new Set(),
+    outcomes: [
+      emptyOutcome("pending-claim", { turnsAtStart: 7 }),
+      emptyOutcome("live-open", { turnsAtStart: 4 }),
+    ],
+    drained: [],
+  };
+  const deps = breakerInstrumentedDeps(state, queue);
+  // Window already lapsed: the next submission IS the half-open probe path.
+  const scheduler = new BacklogScheduler({
+    ...deps,
+    breakerSnapshot: () => ({
+      state: "open",
+      openUntilMs: Date.now() - 1,
+      consecutiveFailures: 5,
+      lastReason: "provider 400s",
+    }),
+  }, { pollMs: 3_600_000 });
+  scheduler.start();
+  try {
+    await scheduler.tickForTest();
+    await scheduler.settleForTest();
+    await scheduler.tickForTest();
+    await scheduler.settleForTest();
+    assert.deepEqual(
+      state.drained.map((entry) => entry.key).sort(),
+      ["live-open", "pending-claim"],
+      "a lapsed window lets submissions (the probe path) through"
+    );
+  } finally {
+    await scheduler.stop();
+  }
+});

package/src/buffer-record-snapshots.test.ts

@@ -0,0 +1,195 @@
+import assert from "node:assert/strict";
+/**
+ * recordTurnUnlocked snapshot retention — issue: the per-turn mutation built
+ * `priorTurns` + `activeTurnsSnapshot` + `retainedTurnsSnapshot` (two full
+ * `copyBufferTurn` maps) on EVERY admitted turn, even when the decision path
+ * consumes none of them: a plain `keep_buffering` turn with no surprise probe
+ * eligible branch discards all three. The mutation now builds the snapshots
+ * only when the decision path needs them (`keep_buffering` under an
+ * eligible surprise branch, or any extraction decision), so steady-state
+ * buffering performs no per-turn snapshot copies.
+ *
+ * Harness: an instance-level spy wraps the (private) recordTurnUnlocked and
+ * captures each AddTurnMutationResult, so tests assert on exactly what the
+ * mutation returned — no production instrumentation.
+ */
+import test from "node:test";
+
+import { type BufferSurpriseProbe, SmartBuffer } from "./buffer.js";
+import { parseConfig } from "./config.js";
+import type { BufferState, BufferTurn } from "./types.js";
+
+class FakeStorage {
+  public saved: BufferState | null = null;
+  public saveCount = 0;
+
+  constructor(private readonly initial: BufferState) {}
+
+  async loadBuffer(): Promise<BufferState> {
+    return structuredClone(this.initial);
+  }
+
+  async saveBuffer(state: BufferState): Promise<void> {
+    this.saveCount += 1;
+    this.saved = structuredClone(state);
+  }
+}
+
+function makeTurn(sessionKey: string, content: string): BufferTurn {
+  return {
+    role: "user",
+    content,
+    timestamp: "2026-04-20T12:00:00.000Z",
+    sessionKey,
+  };
+}
+
+function emptyBuffer(): BufferState {
+  return { turns: [], lastExtractionAt: null, extractionCount: 0 };
+}
+
+type MutationCapture = {
+  priorTurns: BufferTurn[];
+  activeTurnsSnapshot: BufferTurn[];
+  retainedTurnsSnapshot: BufferTurn[];
+  decision: string;
+};
+
+type RecordSpy = (bufferKey: string, turn: BufferTurn) => Promise<MutationCapture>;
+
+function spyMutations(buffer: SmartBuffer): MutationCapture[] {
+  const captures: MutationCapture[] = [];
+  // SAFETY: recordTurnUnlocked is a TS-private prototype method with a stable
+  // runtime shape; the spy re-exposes the identical signature on the instance.
+  const original = Object.getPrototypeOf(buffer).recordTurnUnlocked as RecordSpy;
+  Object.defineProperty(buffer, "recordTurnUnlocked", {
+    value: async (bufferKey: string, turn: BufferTurn): Promise<MutationCapture> => {
+      const result = await original.call(buffer, bufferKey, turn);
+      captures.push(result);
+      return result;
+    },
+    configurable: true,
+    writable: true,
+  });
+  return captures;
+}
+
+function fixedScoreProbe(score: number | null): BufferSurpriseProbe & { calls: number } {
+  const probe = {
+    calls: 0,
+    async scoreTurn(_key: string, _turn: BufferTurn, _prior: readonly BufferTurn[]): Promise<number | null> {
+      probe.calls += 1;
+      return score;
+    },
+  };
+  return probe;
+}
+
+test("plain keep_buffering turn performs no snapshot copies", async () => {
+  const storage = new FakeStorage(emptyBuffer());
+  const config = parseConfig({
+    bufferMaxTurns: 5,
+    triggerMode: "smart",
+    bufferSaveDebounceMs: 0,
+  });
+  const buffer = new SmartBuffer(config, storage);
+  const captures = spyMutations(buffer);
+
+  const decision = await buffer.addTurn("sess-1", makeTurn("sess-1", "ordinary content"));
+
+  assert.equal(decision, "keep_buffering");
+  assert.equal(captures.length, 1);
+  assert.equal(captures[0].priorTurns.length, 0, "no priorTurns copy for a decision that never reads it");
+  assert.equal(captures[0].activeTurnsSnapshot.length, 0, "no active-turn snapshot copies while buffering");
+  assert.equal(captures[0].retainedTurnsSnapshot.length, 0, "no retained-turn snapshot copies while buffering");
+});
+
+test("extraction decisions still carry full snapshots", async () => {
+  const storage = new FakeStorage(emptyBuffer());
+  const config = parseConfig({
+    bufferMaxTurns: 2,
+    triggerMode: "every_n",
+    bufferSaveDebounceMs: 0,
+  });
+  const buffer = new SmartBuffer(config, storage);
+  const captures = spyMutations(buffer);
+
+  await buffer.addTurn("sess-1", makeTurn("sess-1", "one"));
+  const outcome = await buffer.addTurnWithOutcome("sess-1", makeTurn("sess-1", "two"));
+
+  assert.equal(outcome.decision, "extract_batch");
+  assert.notEqual(outcome.extractionTurns, undefined);
+  assert.equal(outcome.extractionTurns?.length, 2);
+  const last = captures[captures.length - 1];
+  assert.equal(last.decision, "extract_batch");
+  assert.equal(last.priorTurns.length, 1, "prior turn kept for extraction decisions");
+  assert.equal(last.activeTurnsSnapshot.length, 2, "active snapshot kept for extraction decisions");
+  assert.deepEqual(
+    last.activeTurnsSnapshot.map((t) => t.content),
+    ["one", "two"]
+  );
+});
+
+test("surprise-eligible keep_buffering still builds the snapshots the probe path reads", async () => {
+  const storage = new FakeStorage(emptyBuffer());
+  const probe = fixedScoreProbe(null);
+  const config = parseConfig({
+    bufferSurpriseTriggerEnabled: true,
+    bufferMaxTurns: 5,
+    triggerMode: "smart",
+    bufferSaveDebounceMs: 0,
+  });
+  const buffer = new SmartBuffer(config, storage, probe);
+  const captures = spyMutations(buffer);
+
+  const decision = await buffer.addTurn("sess-1", makeTurn("sess-1", "ordinary content"));
+
+  assert.equal(decision, "keep_buffering");
+  assert.equal(probe.calls, 1, "the surprise probe must still be consulted");
+  const capture = captures[0];
+  assert.equal(capture.priorTurns.length, 0, "first turn has no priors");
+  assert.equal(capture.activeTurnsSnapshot.length, 1, "snapshot kept while the surprise branch may promote");
+  assert.equal(capture.retainedTurnsSnapshot.length, 0, "nothing retained yet");
+});
+
+test("surprise promotion still extracts from a consistent snapshot", async () => {
+  const storage = new FakeStorage(emptyBuffer());
+  const probe = fixedScoreProbe(0.99);
+  const config = parseConfig({
+    bufferSurpriseTriggerEnabled: true,
+    bufferMaxTurns: 5,
+    triggerMode: "smart",
+    bufferSurpriseThreshold: 0.5,
+    bufferSaveDebounceMs: 0,
+  });
+  const buffer = new SmartBuffer(config, storage, probe);
+
+  const outcome = await buffer.addTurnWithOutcome("sess-1", makeTurn("sess-1", "novel"));
+
+  assert.equal(outcome.decision, "extract_now");
+  assert.deepEqual(
+    outcome.extractionTurns?.map((t) => t.content),
+    ["novel"]
+  );
+});
+
+test("keep_buffering under every_n never builds snapshots even with a probe present", async () => {
+  const storage = new FakeStorage(emptyBuffer());
+  const probe = fixedScoreProbe(0.99);
+  const config = parseConfig({
+    bufferSurpriseTriggerEnabled: true,
+    bufferMaxTurns: 5,
+    triggerMode: "every_n",
+    bufferSaveDebounceMs: 0,
+  });
+  const buffer = new SmartBuffer(config, storage, probe);
+  const captures = spyMutations(buffer);
+
+  const decision = await buffer.addTurn("sess-1", makeTurn("sess-1", "ordinary content"));
+
+  assert.equal(decision, "keep_buffering");
+  assert.equal(probe.calls, 0, "surprise branch is smart-mode only");
+  assert.equal(captures[0].activeTurnsSnapshot.length, 0);
+  assert.equal(captures[0].retainedTurnsSnapshot.length, 0);
+  assert.equal(captures[0].priorTurns.length, 0);
+});

package/src/buffer-turn-helpers.test.ts

@@ -0,0 +1,205 @@
+import assert from "node:assert/strict";
+/**
+ * mergeTurns identity comparison — issue: the claim-merge hot path
+ * (buffer-drain-claims.ts `mergeIntoClaim`) deduped incoming turns with
+ * `merged.some(isEqual)`: O(existing × incoming) per observe while a claim
+ * only grows during a stalled drain. The identity comparison now goes
+ * through a Set of identity keys built from the exact `bufferTurnsEqual`
+ * fields, so the merge is O(n + m) with byte-identical merge semantics:
+ * dedupe identical turns (including duplicates within `incoming`), append
+ * genuinely-new turns in arrival order, existing entries always win.
+ *
+ * The identity key must be injective over `bufferTurnsEqual` equality
+ * classes — including the undefined-vs-null distinctions on optional fields
+ * (`providerThreadId`) and the plan-identity triple (#3251).
+ */
+import test from "node:test";
+
+import { bufferTurnIdentityKey, bufferTurnsEqual, mergeBufferTurnsByIdentity } from "./buffer-turn-helpers.js";
+import type { ScopeProfileLayerResolution } from "./namespaces/scope-profiles.js";
+import type { BufferTurn } from "./types.js";
+
+function turn(overrides: Partial<BufferTurn> & { content: string }): BufferTurn {
+  return { role: "user", timestamp: "2026-11-01T00:00:00.000Z", ...overrides };
+}
+
+test("bufferTurnIdentityKey matches bufferTurnsEqual exactly (same key ⇔ equal)", () => {
+  const base = turn({ content: "hello", sessionKey: "s1" });
+  const same = turn({ content: "hello", sessionKey: "s1" });
+  const different = [
+    turn({ content: "hello", sessionKey: "s2" }),
+    turn({ content: "world", sessionKey: "s1" }),
+    turn({ content: "hello", sessionKey: "s1", role: "assistant" as const }),
+    turn({ content: "hello", sessionKey: "s1", timestamp: "2026-11-02T00:00:00.000Z" }),
+    turn({ content: "hello", sessionKey: "s1", providerThreadId: null }),
+    turn({ content: "hello", sessionKey: "s1", providerThreadId: "t1" }),
+    turn({ content: "hello", sessionKey: "s1", turnFingerprint: "fp" }),
+    turn({ content: "hello", sessionKey: "s1", persistProcessedFingerprint: true }),
+    turn({ content: "hello", sessionKey: "s1", persistProcessedFingerprint: false }),
+    turn({ content: "hello", sessionKey: "s1", sourceConnector: "cli" }),
+    turn({ content: "hello", sessionKey: "s1", originRole: "user" as const }),
+    turn({ content: "hello", sessionKey: "s1", ambientCapture: true }),
+    turn({ content: "hello", sessionKey: "s1", ambientCapture: false }),
+    turn({ content: "hello", sessionKey: "s1", sourceValidAt: "2026-01-01T00:00:00.000Z" }),
+    turn({ content: "hello", sessionKey: "s1", acceptedCapture: true }),
+    turn({ content: "hello", sessionKey: "s1", acceptedCapture: false }),
+    turn({ content: "hello", sessionKey: "s1", writeNamespaceOverride: "ns" }),
+    turn({ content: "hello", sessionKey: "s1", principalOverride: "p1" }),
+    turn({
+      content: "hello",
+      sessionKey: "s1",
+      codingContext: { projectId: "proj", branch: "main", rootPath: "/r", defaultBranch: "main" },
+    }),
+    turn({
+      content: "hello",
+      sessionKey: "s1",
+      codingContext: { projectId: "proj", branch: "dev", rootPath: "/r", defaultBranch: "main" },
+    }),
+  ];
+
+  assert.equal(bufferTurnIdentityKey(base), bufferTurnIdentityKey(same));
+  assert.equal(bufferTurnsEqual(base, same), true);
+  for (const other of different) {
+    assert.notEqual(
+      bufferTurnIdentityKey(base),
+      bufferTurnIdentityKey(other),
+      `key must differ for ${JSON.stringify(other)}`
+    );
+    assert.equal(bufferTurnsEqual(base, other), false);
+  }
+});
+
+test("bufferTurnIdentityKey: undefined and null providerThreadId are distinct classes", () => {
+  const absent = turn({ content: "x" });
+  const explicitNull = turn({ content: "x", providerThreadId: null });
+  const present = turn({ content: "x", providerThreadId: "t" });
+  const keys = new Set([
+    bufferTurnIdentityKey(absent),
+    bufferTurnIdentityKey(explicitNull),
+    bufferTurnIdentityKey(present),
+  ]);
+  assert.equal(keys.size, 3);
+  assert.equal(bufferTurnsEqual(absent, explicitNull), false);
+  assert.equal(bufferTurnsEqual(absent, present), false);
+});
+
+test("bufferTurnIdentityKey: null and undefined scope plan share the empty identity (#3251)", () => {
+  const noPlan = turn({ content: "x" });
+  const nullPlan = turn({ content: "x", scopeProfileWritePlan: null });
+  assert.equal(bufferTurnIdentityKey(noPlan), bufferTurnIdentityKey(nullPlan));
+  assert.equal(bufferTurnsEqual(noPlan, nullPlan), true);
+});
+
+test("mergeBufferTurnsByIdentity appends genuinely-new turns in arrival order", () => {
+  const existing = [turn({ content: "a" }), turn({ content: "b" })];
+  const incoming = [turn({ content: "c" }), turn({ content: "d" })];
+  const merged = mergeBufferTurnsByIdentity(existing, incoming);
+  assert.deepEqual(
+    merged.map((t) => t.content),
+    ["a", "b", "c", "d"]
+  );
+});
+
+test("mergeBufferTurnsByIdentity dedupes turns identical to an existing entry", () => {
+  const existing = [turn({ content: "a" }), turn({ content: "b" })];
+  const incoming = [turn({ content: "b" }), turn({ content: "c" })];
+  const merged = mergeBufferTurnsByIdentity(existing, incoming);
+  assert.deepEqual(
+    merged.map((t) => t.content),
+    ["a", "b", "c"]
+  );
+  // The kept entry is the EXISTING object, not the incoming copy.
+  assert.equal(merged[1], existing[1]);
+});
+
+test("mergeBufferTurnsByIdentity dedupes duplicates within incoming (first wins)", () => {
+  const existing: BufferTurn[] = [];
+  const first = turn({ content: "dup" });
+  const second = turn({ content: "dup" });
+  const merged = mergeBufferTurnsByIdentity(existing, [first, second]);
+  assert.equal(merged.length, 1);
+  assert.equal(merged[0], first);
+});
+
+test("mergeBufferTurnsByIdentity keeps existing entries verbatim, duplicates included", () => {
+  const dupA = turn({ content: "a" });
+  const dupB = turn({ content: "a" });
+  const existing = [dupA, dupB];
+  const merged = mergeBufferTurnsByIdentity(existing, [turn({ content: "a" }), turn({ content: "b" })]);
+  assert.equal(merged.length, 3, "existing duplicates are preserved; incoming duplicate dropped");
+  assert.equal(merged[0], dupA);
+  assert.equal(merged[1], dupB);
+  assert.equal(merged[2].content, "b");
+});
+
+test("mergeBufferTurnsByIdentity keeps existing order and does not mutate inputs", () => {
+  const existing = [turn({ content: "b" }), turn({ content: "a" })];
+  const incoming = [turn({ content: "a" }), turn({ content: "c" })];
+  const merged = mergeBufferTurnsByIdentity(existing, incoming);
+  assert.deepEqual(
+    merged.map((t) => t.content),
+    ["b", "a", "c"]
+  );
+  assert.equal(existing.length, 2);
+  assert.deepEqual(
+    existing.map((t) => t.content),
+    ["b", "a"]
+  );
+});
+
+// Identity fields only: scopeProfilePlanIdentity reads profileId, writeLayer
+// and writeNamespace; the remaining members are inert for identity tests.
+function pinnedPlan(namespace: string): NonNullable<BufferTurn["scopeProfileWritePlan"]> {
+  const layer: ScopeProfileLayerResolution = {
+    id: "userProject",
+    kind: "user-project",
+    namespace,
+    readable: true,
+    writable: true,
+    promotable: false,
+    reason: "identity-test layer",
+  };
+  return {
+    profileId: "p",
+    profile: {
+      readOrder: ["userProject"],
+      writeDefault: "userProject",
+      promotionTargets: [],
+      autoPromote: { enabled: false, targets: [], categories: [], minConfidenceTier: "speculative" },
+    },
+    baseNamespace: namespace,
+    writeLayer: "userProject",
+    writeNamespace: namespace,
+    readNamespaces: [namespace],
+    layers: [layer],
+    promotionTargets: [],
+    warnings: [],
+  };
+}
+
+test("mergeBufferTurnsByIdentity stays consistent with bufferTurnsEqual on scope-pinned turns", () => {
+  const pinned = turn({
+    content: "cap",
+    acceptedCapture: true,
+    writeNamespaceOverride: "ns-a",
+    scopeProfileWritePlan: pinnedPlan("ns-a"),
+  });
+  const samePinned = turn({
+    content: "cap",
+    acceptedCapture: true,
+    writeNamespaceOverride: "ns-a",
+    scopeProfileWritePlan: pinnedPlan("ns-a"),
+  });
+  const otherPinned = turn({
+    content: "cap",
+    acceptedCapture: true,
+    writeNamespaceOverride: "ns-b",
+    scopeProfileWritePlan: pinnedPlan("ns-b"),
+  });
+  assert.equal(bufferTurnsEqual(pinned, samePinned), true);
+  assert.equal(bufferTurnsEqual(pinned, otherPinned), false);
+  const merged = mergeBufferTurnsByIdentity([pinned], [samePinned, otherPinned]);
+  assert.equal(merged.length, 2);
+  assert.equal(merged[0], pinned);
+  assert.equal(merged[1], otherPinned);
+});

package/src/buffer-turn-helpers.ts

@@ -169,6 +169,68 @@ export function bufferTurnsEqual(left: BufferTurn | undefined, right: BufferTurn
   );
 }
 
+/**
+ * Canonical identity key for a turn, injective over `bufferTurnsEqual`
+ * equality classes. Every compared field is a primitive (or the #3251 plan
+ * identity string), so set-membership replaces pairwise comparison and turn
+ * merges run O(n + m) instead of O(n × m). JSON.stringify of a string is
+ * injective (it escapes control characters), and the raw `\u0001` sentinels
+ * distinguish undefined from null — a distinction `===` makes and plain
+ * stringification would lose.
+ */
+export function bufferTurnIdentityKey(turn: BufferTurn): string {
+  const opt = (value: string | null | undefined): string =>
+    value === undefined ? "\u0001undefined" : value === null ? "\u0001null" : JSON.stringify(value);
+  const optFlag = (value: boolean | undefined): string =>
+    value === undefined ? "\u0001undefined" : String(value);
+  const ctx = turn.codingContext;
+  return JSON.stringify([
+    turn.role,
+    turn.content,
+    turn.timestamp,
+    opt(turn.sessionKey),
+    opt(turn.sessionOwnerPrincipal),
+    opt(turn.logicalSessionKey),
+    turn.providerThreadId === undefined ? "\u0001undefined" : turn.providerThreadId === null ? "\u0001null" : JSON.stringify(turn.providerThreadId),
+    opt(turn.turnFingerprint),
+    optFlag(turn.persistProcessedFingerprint),
+    opt(turn.sourceConnector),
+    opt(turn.originRole),
+    optFlag(turn.ambientCapture),
+    opt(turn.sourceValidAt),
+    optFlag(turn.acceptedCapture),
+    opt(ctx?.projectId),
+    opt(ctx?.rootPath),
+    opt(ctx?.branch),
+    opt(ctx?.defaultBranch),
+    opt(turn.writeNamespaceOverride),
+    opt(turn.principalOverride),
+    opt(turn.scopeProfileWritePlan ? scopeProfilePlanIdentity(turn.scopeProfileWritePlan) : undefined),
+  ]);
+}
+
+/**
+ * Identity-dedupe `incoming` turns into `existing` (same contract as the
+ * claim-merge `mergeTurns`): identical turns are dropped — the EXISTING
+ * entry is kept — genuinely-new turns append in arrival order, and
+ * duplicates within `incoming` collapse to their first occurrence. O(n + m)
+ * via `bufferTurnIdentityKey` membership instead of pairwise equality.
+ */
+export function mergeBufferTurnsByIdentity(
+  existing: readonly BufferTurn[],
+  incoming: readonly BufferTurn[],
+): BufferTurn[] {
+  const merged = [...existing];
+  const seen = new Set(merged.map(bufferTurnIdentityKey));
+  for (const turn of incoming) {
+    const key = bufferTurnIdentityKey(turn);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(turn);
+  }
+  return merged;
+}
+
 /** Replace only the processed snapshot; callers without one retain legacy whole-slot semantics. */
 export function selectRetainedDeferredTurns(
   existing: readonly BufferTurn[],

package/src/buffer.ts

@@ -646,16 +646,16 @@ export class SmartBuffer {
   private async recordTurnUnlocked(bufferKey: string, turn: BufferTurn): Promise<AddTurnMutationResult> {
     await this.loadUnlocked();
     const entry = this.entryFor(bufferKey);
-    const priorTurns = entry.turns.slice();
-    entry.turns.push(turn);
-    const activeTurnsSnapshot = entry.turns.map(copyBufferTurn);
-    const retainedTurnsSnapshot = (entry.retainedTurns ?? []).map(copyBufferTurn);
-    if (bufferKey === "default") {
-      this.state.turns = entry.turns;
-    }
-
     const signal = scanSignals(turn.content, this.config.highSignalPatterns);
+    entry.turns.push(turn);
     const decision = this.evaluate(entry, signal.level);
+    // Snapshots serve only extraction decisions and surprise-eligible keep_buffering turns (probe, smart mode, sub-high signal); steady-state buffering copies nothing.
+    const surpriseEligible = this.surpriseProbe !== null && this.config.triggerMode === "smart" && signal.level !== "high";
+    const snapshotsNeeded = decision !== "keep_buffering" || surpriseEligible;
+    const priorTurns = snapshotsNeeded ? entry.turns.slice(0, -1) : [];
+    const activeTurnsSnapshot = snapshotsNeeded ? entry.turns.map(copyBufferTurn) : [];
+    const retainedTurnsSnapshot = snapshotsNeeded ? (entry.retainedTurns ?? []).map(copyBufferTurn) : [];
+    if (bufferKey === "default") this.state.turns = entry.turns;
     const turnCountInWindow = entry.turns.length;
 
     this.persistence.markDirty(bufferKey);

package/src/fallback-llm-codex-subscription.ts

@@ -201,7 +201,16 @@ export function isUnsupportedJsonSchemaError(error: unknown): boolean {
   return (
     /(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output)\b[^;,\n]{0,60}\b(?:unsupported|not supported|not implemented|not available)\b/i.test(message) ||
     /\b(?:unsupported|unknown|unrecognized)(?:[\s:"'=]|parameter|argument|request|supplied|field|type|value){1,40}\b(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output|schema|format)\b/i.test(message) ||
-    /\b(?:does not|doesn't|cannot|can't) support(?:[\s:"'=]|the|native|type){1,20}\b(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output|schema|format)\b/i.test(message)
+    /\b(?:does not|doesn't|cannot|can't) support(?:[\s:"'=]|the|native|type){1,20}\b(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output|schema|format)\b/i.test(message) ||
+    // A strict provider parser rejecting the SCHEMA CONTENT itself (2026-11-05
+    // MiniMax-M3.1-Flash: "invalid params, Mismatch type string with value
+    // array ... \"episodeTitle\": {\"type\": [\"string\",\"null\"]}"). The
+    // provider never names response_format here; it dies parsing our payload.
+    // Evidence is the observed signature only — a quoted (JSON-escaped)
+    // type-array fragment. A generic "mismatch type" naming an unrelated
+    // parameter, or a bare echo of the format name, is not enough to degrade.
+    (/invalid\s+(?:params|parameters)/i.test(message) &&
+      /\\{0,4}"\s{0,8}type\s{0,8}\\{0,4}"\s{0,8}:\s{0,8}\[/.test(message))
   );
 }