pi-condense 2.11.5 → 2.13.0

package/src/error-purge.ts

@@ -1,17 +1,21 @@
+import { occKey, resultTimestampOf } from "./occurrence-key.js";
 import type { ErrorPurgeConfig } from "./types.js";
 
-// Keep short paths and commands readable while reclaiming large failed-call bodies.
+// Keep short paths and commands readable while reclaiming large completed-call bodies.
 const PURGE_STRING_MIN_CHARS = 200;
 
-function shrinkStrings(value: unknown): [unknown, boolean] {
+function shrinkStrings(
+  value: unknown,
+  marker: (size: number) => string = (size) => `<purged-errored-args size="${size}"/>`,
+): [unknown, boolean] {
   if (typeof value === "string") {
-    if (value.length > PURGE_STRING_MIN_CHARS) return [`<purged-errored-args size="${value.length}"/>`, true];
+    if (value.length > PURGE_STRING_MIN_CHARS) return [marker(value.length), true];
     return [value, false];
   }
   if (Array.isArray(value)) {
     let out: unknown[] | undefined;
     for (let i = 0; i < value.length; i++) {
-      const [next, changed] = shrinkStrings(value[i]);
+      const [next, changed] = shrinkStrings(value[i], marker);
       if (!changed) continue;
       out ??= value.slice();
       out[i] = next;
@@ -22,7 +26,7 @@ function shrinkStrings(value: unknown): [unknown, boolean] {
     const object = value as Record<string, unknown>;
     let out: Record<string, unknown> | undefined;
     for (const key of Object.keys(object)) {
-      const [next, changed] = shrinkStrings(object[key]);
+      const [next, changed] = shrinkStrings(object[key], marker);
       if (!changed) continue;
       // Spread creates own data properties, including JSON's possible __proto__ key.
       out ??= { ...object };
@@ -34,65 +38,64 @@ function shrinkStrings(value: unknown): [unknown, boolean] {
 }
 
 /**
- * Shrinks long strings in failed toolCall arguments after the cooldown window.
- * Keys and JSON types must survive because pi-ai validates grammar-tool input
- * properties when replaying calls.
- *
- * Why only the arguments, not the whole toolCall or its toolResult:
- *   - The toolResult content (e.g. "Error: file not found") is small and carries
- *     the failure signal the model needs to understand what went wrong.
- *   - The toolCall block itself must remain so the provider can pair it with its
- *     result and avoid injecting a synthetic "No result provided" error.
- *   - The arguments body is what grows large — failed `write` / `edit` calls
- *     embed the full file content that will never be acted on again.
- *
- * Why the cooldown:
- *   - Gives the model 1–2 turns to retry before context is mutated. Purging
- *     immediately would remove the call detail before the model has had a
- *     chance to see the error and adapt.
- *
- * Turn index is computed internally by counting AssistantMessages in the input.
- * This avoids threading a turn counter through index.ts.
+ * Shrinks summarized arguments immediately and errored arguments after cooldown.
+ * Keys and JSON types survive pi-ai grammar validation during replay.
  */
-export function purgeErroredArgs(messages: any[], config: ErrorPurgeConfig): any[] {
-  // Pass 1: collect errored toolCallIds → the turn index at which the error occurred.
-  // Turn index = number of AssistantMessages seen up to and including the one that
-  // issued the tool call (ToolResultMessages follow immediately after).
-  const erroredAtTurn = new Map<string, number>();
+export function purgeErroredArgs(
+  messages: any[],
+  config: ErrorPurgeConfig,
+  summarizedRefs: ReadonlyMap<string, string> = new Map(),
+): any[] {
+  if (!config.enabled) return messages;
+
+  const targets = new Map<number, Map<string, { turn: number; ref?: string }>>();
+  const open = new Map<string, { assistantIndex: number; turn: number }>();
   let turnCount = 0;
-  for (const msg of messages) {
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
     if (msg.role === "assistant") {
-      // Count each assistant turn; toolResults referencing the turn come next.
       turnCount++;
-    } else if (msg.role === "toolResult" && msg.isError === true) {
-      // Record the turn this errored call belongs to for cooldown comparison.
-      erroredAtTurn.set(msg.toolCallId, turnCount);
+      open.clear();
+      for (const block of msg.content) {
+        if (block.type === "toolCall") open.set(block.id, { assistantIndex: i, turn: turnCount });
+      }
+    } else if (msg.role === "toolResult") {
+      const paired = open.get(msg.toolCallId);
+      if (!paired) continue;
+      open.delete(msg.toolCallId);
+      const ref = summarizedRefs.get(occKey(msg.toolCallId, resultTimestampOf(msg.timestamp)));
+      if (ref === undefined && msg.isError !== true) continue;
+      let blocks = targets.get(paired.assistantIndex);
+      if (!blocks) targets.set(paired.assistantIndex, blocks = new Map());
+      blocks.set(msg.toolCallId, { turn: paired.turn, ref });
+    } else {
+      open.clear();
     }
   }
 
-  if (erroredAtTurn.size === 0) return messages;
-
-  const currentTurnIndex = turnCount;
+  if (targets.size === 0) return messages;
 
   // Pass 2: rewrite AssistantMessages whose toolCall args should be purged.
   let anyModified = false;
-  const result = messages.map((msg) => {
-    if (msg.role !== "assistant") return msg;
+  const result = messages.map((msg, assistantIndex) => {
+    const targetsForTurn = targets.get(assistantIndex);
+    if (!targetsForTurn) return msg;
 
     let contentModified = false;
     const newContent = (msg.content as any[]).map((block) => {
       if (block.type !== "toolCall") return block;
 
-      const errorTurn = erroredAtTurn.get(block.id);
-      if (errorTurn === undefined) return block;
-
-      const age = currentTurnIndex - errorTurn;
-      if (age < config.cooldownTurns) return block;
+      const target = targetsForTurn.get(block.id);
+      if (!target) return block;
+      if (target.ref === undefined && turnCount - target.turn < config.cooldownTurns) return block;
 
       const argBody = JSON.stringify(block.arguments);
       if (argBody.length < config.minArgChars) return block;
 
-      const [shrunk, changed] = shrinkStrings(block.arguments);
+      const [shrunk, changed] = shrinkStrings(
+        block.arguments,
+        target.ref === undefined ? undefined : (size) => `<purged-args size="${size}" ref="${target.ref}"/>`,
+      );
       if (!changed) return block;
 
       contentModified = true;

package/src/frontier.test.ts

@@ -85,6 +85,7 @@ describe("PruneFrontierTracker.reconstructFromSession", () => {
 
     const indexer = {
       isSummarized: (id: string) => id === "tc-old" || id === "tc-stub",
+      isDedupAlias: () => false,
       hasLegacyBareRecord: (id: string) => id === "tc-old" || id === "tc-stub",
       getShortRefForToolCallId: (id: string) => (id === "tc-stub" ? "t1" : id === "tc-old" ? "told" : undefined),
       getRecord: () => undefined,

package/src/indexer.test.ts

@@ -132,6 +132,28 @@ describe("occurrence keying", () => {
     expect(records.map((r) => r.resultTimestamp)).toEqual([1150, 9150]);
   });
 
+  test("isDedupAlias checks exact registered keys without resolving refs or sibling occurrences", () => {
+    const indexer = new ToolCallIndexer();
+    indexer.addBatch(batch(0, 1000, [{ id: "bash_23", ts: 1150, text: "SAME" }]), () => {});
+    indexer.addBatch(batch(1, 2000, [{ id: "bash_23", ts: 2150, text: "OTHER" }]), () => {});
+    indexer.registerSummaryRefs([{ shortId: "t1", toolCallId: "bash_23", resultTimestamp: 1150 }]);
+    indexer.registerDuplicate("bash_23@9150", "bash_23@1150", () => {});
+    indexer.registerDuplicate("bash_legacy", "bash_23@1150", () => {});
+
+    for (const [key, expected] of [
+      ["bash_23@9150", true],
+      ["bash_legacy", true],
+      ["bash_23@1150", false],
+      ["bash_23@2150", false],
+      ["bash_23", false],
+      ["bash_legacy@9150", false],
+      ["unknown", false],
+      ["t1", false],
+    ] as const) {
+      expect(indexer.isDedupAlias(key)).toBe(expected);
+    }
+  });
+
   test("summary body lookups are occurrence-keyed", () => {
     const indexer = new ToolCallIndexer();
     indexer.registerSummaryBody(["bash_23@1150"], "summary of FIRST");
@@ -302,6 +324,10 @@ describe("session rebuild", () => {
     expect(indexer.getRecord("bash_99@4150")?.resultText).toBe("FIRST");
     expect(indexer.getShortRefForToolCallId("bash_99@4150")).toBe("t1");
     expect(indexer.getPerBatchSummaryTextForToolCallIds(["bash_23@2150"])).toBe("summary text");
+    expect(indexer.isDedupAlias("bash_99@4150")).toBe(true);
+    expect(indexer.isDedupAlias("bash_99")).toBe(false);
+    expect(indexer.isDedupAlias("bash_23@1150")).toBe(false);
+    expect(indexer.isDedupAlias("t1")).toBe(false);
   });
 
   test("legacy entries without resultTimestamp keep bare-id keys", () => {
@@ -336,6 +362,8 @@ describe("session rebuild", () => {
     expect(indexer.hasLegacyBareRecord("bash_7")).toBe(true);
     expect(indexer.hasLegacyBareRecord("bash_23")).toBe(false);
     expect(indexer.isSummarized("bash_8")).toBe(true);
+    expect(indexer.isDedupAlias("bash_8")).toBe(true);
+    expect(indexer.isDedupAlias("bash_7")).toBe(false);
   });
 });
 

package/src/indexer.ts

@@ -183,6 +183,10 @@ export class ToolCallIndexer {
     return this.index.has(occurrenceKey) || this.dedupAliasToOriginal.has(occurrenceKey);
   }
 
+  isDedupAlias(key: string): boolean {
+    return this.dedupAliasToOriginal.has(key);
+  }
+
   /**
    * Returns the full runtime index map.
    */

package/src/pruner.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import { pruneMessages, sizeMessages } from "./pruner.js";
+import { purgeErroredArgs } from "./error-purge.js";
 import { charsOf } from "./context-metrics.js";
 import { ToolCallIndexer } from "./indexer.js";
 import { CUSTOM_TYPE_INDEX } from "./types.js";
@@ -33,6 +34,7 @@ function makeMockIndexer({
 } = {}) {
   return {
     isSummarized: (id: string) => summarized.has(id),
+    isDedupAlias: (_key: string) => false,
     hasLegacyBareRecord: (id: string) => summarized.has(id),
     getShortRefForToolCallId: (id: string) => shortRefs.get(id),
     getRecord: (id: string) => records.get(id),
@@ -47,6 +49,116 @@ function makeMockIndexer({
   } as any;
 }
 
+describe("summarized argument handoff", () => {
+  const prompt = "p".repeat(600);
+  const config = { enabled: true, minArgChars: 300, cooldownTurns: 2 };
+  const history = (name = "subagent"): any[] => [
+    { role: "assistant", content: [{ type: "toolCall", id: "call", name, arguments: { prompt } }] },
+    { role: "toolResult", toolCallId: "call", toolName: name, timestamp: 10, content: [{ type: "text", text: "original output" }], isError: false },
+  ];
+  const render = (messages: any[], indexer: any, options = config, protection?: any, grace = 0) => {
+    expectNoOrphanToolResults(messages);
+    const result = pruneWithZeroSweepAssertion(messages, indexer, undefined, options, protection, grace);
+    expectNoOrphanToolResults(result.messages);
+    return result.messages;
+  };
+  const indexed = (key = "call@10", record?: any) => makeMockIndexer({
+    summarized: new Set([key]), shortRefs: new Map([[key, "t6"]]),
+    records: new Map([[key, record]]),
+  });
+
+  for (const row of [
+    { label: "summary", record: undefined },
+    { label: "spill", record: { spillPath: "/tmp/output", toolName: "subagent" } },
+    { label: "legacy fallback", key: "call" },
+    { label: "timestamp-less", key: "call" },
+  ]) {
+    it(`stubs and shrinks together: ${row.label}`, () => {
+      const raw = history();
+      if (row.label === "timestamp-less") delete raw[1].timestamp;
+      const out = render(raw, indexed(row.key, row.record));
+      expect(out[1].content[0].text).toContain("`t6`");
+      expect(out[0].content[0].arguments.prompt).toBe(`<purged-args size="${prompt.length}" ref="t6"/>`);
+      expect(raw[0].content[0].arguments.prompt).toBe(prompt);
+      expect(purgeErroredArgs(out, config, new Map([[row.label === "timestamp-less" ? "call" : "call@10", "t6"]]))).toBe(out);
+    });
+  }
+
+  for (const row of [
+    { label: "disabled", options: { ...config, enabled: false } },
+    { label: "body below gate", options: { ...config, minArgChars: 1000 } },
+    { label: "no long strings", args: { a: "a".repeat(180), b: "b".repeat(180) } },
+    { label: "unindexed", unindexed: true },
+    { label: "protected", record: { toolName: "read", args: { path: "keep.md" } }, protection: { protectedTools: [], protectedPaths: ["keep.md"] } },
+  ]) {
+    it(`retains arguments: ${row.label}`, () => {
+      const raw = history();
+      if (row.args) raw[0].content[0].arguments = row.args;
+      const out = render(raw, row.unindexed ? makeMockIndexer() : indexed(undefined, row.record), row.options, row.protection);
+      expect(out[0]).toBe(raw[0]);
+      expect(out[1] === raw[1]).toBe(!!row.unindexed || !!row.protection);
+    });
+  }
+
+  it("pairs timestamp-less handoff positionally without shrinking a reused-id sibling", () => {
+    const indexer = indexed("call");
+    indexer.hasLegacyBareRecord = () => false;
+    const raw = [...history(), { role: "user", content: "next" }, ...history()];
+    delete raw[4].timestamp;
+    const out = render(raw, indexer);
+    expect(out[0]).toBe(raw[0]);
+    expect(out[1]).toBe(raw[1]);
+    expect(out[3].content[0].arguments.prompt).toBe('<purged-args size="600" ref="t6"/>');
+    expect(out[4].content[0].text).toContain("`t6`");
+  });
+
+  it("uses the same raw-id fallback ref in the stub and argument marker", () => {
+    const out = render(history(), makeMockIndexer({ summarized: new Set(["call@10"]) }));
+    expect(out[1].content[0].text).toContain("`call`");
+    expect(out[0].content[0].arguments.prompt).toBe('<purged-args size="600" ref="call"/>');
+  });
+
+  it("advances recovery grace with stub and shrink at the same boundary", () => {
+    const raw = history("context_tree_query");
+    const indexer = indexed();
+    expect(render(raw, indexer, config, undefined, 1)).toBe(raw);
+    raw.push({ role: "user", content: "next" }, { role: "assistant", content: [] }, { role: "user", content: "again" });
+    const out = render(raw, indexer, config, undefined, 1);
+    expect(out[1].content[0].text).toContain("`t6`");
+    expect(out[0].content[0].arguments.prompt).toBe(`<purged-args size="600" ref="t6"/>`);
+  });
+
+  it("switches aged error markers on indexing and keeps fresh-render prefixes stable", () => {
+    const raw = history();
+    raw[1].isError = true;
+    raw.push({ role: "assistant", content: [] }, { role: "user", content: "next" }, { role: "assistant", content: [] });
+    const before = render(structuredClone(raw), makeMockIndexer());
+    expect(before[0].content[0].arguments.prompt).toBe('<purged-errored-args size="600"/>');
+    const indexer = indexed();
+    const first = render(structuredClone(raw), indexer);
+    expect(first[0].content[0].arguments.prompt).toBe('<purged-args size="600" ref="t6"/>');
+    expect(first[1].isError).toBe(false);
+    expect(JSON.stringify(render(structuredClone(raw), indexer))).toBe(JSON.stringify(first));
+    const extended = [...structuredClone(raw), { role: "user", content: "continue" }, { role: "assistant", content: [] }];
+    expect(JSON.stringify(render(extended, indexer).slice(0, raw.length))).toBe(JSON.stringify(first));
+  });
+
+  it("keeps dedup alias prompts while shrinking the recoverable canonical prompt", () => {
+    const indexer = new ToolCallIndexer();
+    const raw = history();
+    indexer.addBatch({ turnIndex: 0, timestamp: 0, assistantText: "", toolCalls: [{ toolCallId: "call", toolName: "subagent", args: raw[0].content[0].arguments, resultText: "original output", isError: false, resultTimestamp: 10 }] }, () => {});
+    indexer.registerSummaryRefs([{ shortId: "t6", toolCallId: "call", resultTimestamp: 10 }]);
+    indexer.registerDuplicate("alias@20", "call@10", () => {});
+    raw.push({ role: "assistant", content: [{ type: "toolCall", id: "alias", name: "subagent", arguments: { prompt: "alias".repeat(120) } }] }, { ...raw[1], toolCallId: "alias", timestamp: 20 });
+    const out = render(raw, indexer);
+    expect(out[0].content[0].arguments.prompt).toBe('<purged-args size="600" ref="t6"/>');
+    expect(out[2]).toBe(raw[2]);
+    expect(out[1].content[0].text).toContain("`t6`");
+    expect(out[3].content[0].text).toContain("`t6`");
+    expect(indexer.getRecord("call@10")?.args).toEqual({ prompt });
+  });
+});
+
 const enabledCC: ChainCompressionConfig = {
   enabled: true,
   rollingWindow: 0,

package/src/pruner.ts

@@ -46,9 +46,9 @@ export function sizeMessages(messages: any[]): number {
  * See src/supersede.ts. Runs before phase 3 so a superseded read inside a
  * compressed chain relocates as the stub, not the verbatim body.
  *
- * Phase 2 — error purge: replaces failed toolCall arg bodies with stubs after a
- * cooldown, reclaiming context from large `write`/`edit` arguments that will
- * never succeed. The toolResult error message stays visible.
+ * Phase 2 - argument purge: shrinks summarized toolCall arguments in the
+ * stub render and failed toolCall arguments after cooldown. Unsummarized
+ * toolResult error messages stay visible.
  *
  * Phase 3 — chain range prune: closed chains older than the rolling window
  * are dropped (middle assistant + toolResult messages) and replaced with a
@@ -75,9 +75,8 @@ export function sizeMessages(messages: any[]): number {
  *     the only consumer (`index.ts` live-reclaim) reads them solely under
  *     `if (result.pruned)`.
  *
- * AssistantMessage tool-call blocks (which carry the IDs) are kept
- * unchanged so the model can still reference them by id when calling
- * `context_tree_query`.
+ * Tool-call ids, names, and result pairing stay unchanged; eligible argument
+ * strings shrink with a ref for recovery through `context_tree_query`.
  */
 export function pruneMessages(
   messages: any[],
@@ -91,6 +90,7 @@ export function pruneMessages(
 ): { messages: any[]; pruned: boolean; beforeChars: number; afterChars: number } {
   // Phase 1: stub-replace summarized tool results
   let pruned = false;
+  const summarizedRefs = new Map<string, string>();
   const inGrace = inGraceRecoveryToolCallIds(messages, recoveryGraceTurns);
   const next = messages.map((msg) => {
     if (msg.role !== "toolResult") return msg;
@@ -124,6 +124,7 @@ export function pruneMessages(
     }
     pruned = true;
     const ref = indexer.getShortRefForToolCallId(lookupKey) ?? msg.toolCallId;
+    if (!indexer.isDedupAlias(lookupKey)) summarizedRefs.set(key, ref);
     const text = record?.spillPath
       ? [
           `[Oversized output spilled to file — ${record.spillBytes ?? "?"} bytes.]`,
@@ -155,9 +156,9 @@ export function pruneMessages(
     }
   }
 
-  // Phase 2: error purge - shrink long strings in failed toolCall args after cooldown
+  // Phase 2: argument purge - summarized now, errored after cooldown
   if (errorPurge?.enabled) {
-    const afterPurge = purgeErroredArgs(current, errorPurge);
+    const afterPurge = purgeErroredArgs(current, errorPurge, summarizedRefs);
     if (afterPurge !== current) {
       current = afterPurge;
       pruned = true;

package/src/query-tool.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { pruneWithZeroSweepAssertion, expectNoOrphanToolResults } from "./test-support.js";
 import { registerQueryTool } from "./query-tool.js";
 import { imageDigest } from "./batch-capture.js";
 import { ToolCallIndexer } from "./indexer.js";
@@ -91,6 +92,33 @@ describe("context_tree_query image recovery", () => {
 });
 
 describe("context_tree_query occurrence handling", () => {
+  test("alias ref recovers unclipped canonical arguments after rendering, not alias arguments", async () => {
+    const idx = new ToolCallIndexer();
+    const prompt = "canonical".repeat(80);
+    const aliasPrompt = "alias".repeat(120);
+    idx.addBatch({ turnIndex: 0, timestamp: 0, assistantText: "", toolCalls: [{ toolCallId: "canonical", toolName: "subagent", args: { prompt }, resultText: "shared original output", isError: false, resultTimestamp: 10 }] }, () => {});
+    idx.registerSummaryRefs([{ shortId: "t6", toolCallId: "canonical", resultTimestamp: 10 }]);
+    idx.registerDuplicate("alias@20", "canonical@10", () => {});
+    const raw = [
+      { role: "assistant", content: [{ type: "toolCall", id: "canonical", name: "subagent", arguments: { prompt } }] },
+      { role: "toolResult", toolCallId: "canonical", toolName: "subagent", timestamp: 10, content: [{ type: "text", text: "shared original output" }] },
+      { role: "assistant", content: [{ type: "toolCall", id: "alias", name: "subagent", arguments: { prompt: aliasPrompt } }] },
+      { role: "toolResult", toolCallId: "alias", toolName: "subagent", timestamp: 20, content: [{ type: "text", text: "shared original output" }] },
+    ];
+    expectNoOrphanToolResults(raw);
+    const out = pruneWithZeroSweepAssertion(raw, idx, undefined, { enabled: true, minArgChars: 300, cooldownTurns: 2 }).messages;
+    expectNoOrphanToolResults(out);
+    expect(out[0].content[0].arguments.prompt).toBe(`<purged-args size="${prompt.length}" ref="t6"/>`);
+    expect(out[2].content[0].arguments.prompt).toBe(aliasPrompt);
+    const aliasRef = idx.getShortRefForToolCallId("alias@20");
+    expect(aliasRef).toBe("t6");
+    expect(idx.getRecordsForId(aliasRef!)[0].args).toEqual({ prompt });
+    const text = await runTool(idx, [aliasRef!]);
+    expect(text).toContain(`Args: ${JSON.stringify({ prompt }, null, 2)}`);
+    expect(text).toContain("shared original output");
+    expect(text).not.toContain(aliasPrompt);
+    expect(text).not.toContain("<purged-args");
+  });
   test("a bare id with two occurrences returns both blocks, chronologically", async () => {
     const idx = new ToolCallIndexer();
     capture(idx, "bash_23", 2150, "SECOND", 1);

package/src/reload-rearm.integration.test.ts

@@ -1,8 +1,7 @@
-import { describe, it, expect, mock } from "bun:test";
+import { describe, it, expect } from "bun:test";
 import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import * as actualCompat from "@earendil-works/pi-ai/compat";
 import { supersededStub } from "./supersede.js";
 
 // This must run before any module that transitively reads PI_CODING_AGENT_DIR
@@ -67,11 +66,6 @@ let streamImpl: (model: any, input?: any, opts?: any) => any = () => {
   return okStream();
 };
 
-mock.module("@earendil-works/pi-ai/compat", () => ({
-  ...actualCompat,
-  stream: (...args: any[]) => streamImpl(...args),
-}));
-
 type AppendedEntry = { type: string; data: unknown };
 
 // The captured-but-unflushed batch: a user message, an assistant message with
@@ -305,7 +299,7 @@ function bootExtension(
     modelRegistry: {
       find: () => undefined,
       getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "test", headers: {} }),
-      getProviderAuth: async () => undefined,
+      streamSimple: (model: any, input: any, opts: any) => streamImpl(model, input, opts),
     },
     ui: {
       setStatus() {},

package/src/summarizer-wiring.test.ts

@@ -1,22 +1,14 @@
-import { describe, it, expect, mock } from "bun:test";
-import * as actualCompat from "@earendil-works/pi-ai/compat";
-
-// Stub pi-ai's `stream` so runSummarization can be exercised without a network
-// call. `streamImpl` is swapped per test to simulate primary/fallback outcomes.
+import { describe, it, expect } from "bun:test";
 let streamImpl: (model: any, input?: any, opts?: any) => any = () => {
   throw new Error("streamImpl not set");
 };
-mock.module("@earendil-works/pi-ai/compat", () => ({
-  ...actualCompat,
-  stream: (...args: any[]) => streamImpl(...args),
-}));
-
-const { summarizeBatch } = await import("./summarizer.js");
+const { summarizeBatch, summarizeRange } = await import("./summarizer.js");
 const { FallbackController } = await import("./summarizer-fallback.js");
 const { DEFAULT_CONFIG } = await import("./types.js");
 
-const PRIMARY = { id: "primary-model", provider: "provider-a", name: "Primary" };
-const SESSION = { id: "session-model", provider: "provider-b", name: "Session" };
+const PRIMARY = { id: "primary-model", provider: "provider-a", name: "Primary", api: "openai-responses" };
+const SESSION = { id: "session-model", provider: "provider-b", name: "Session", api: "openai-responses" };
+const VIRTUAL = { id: "auto", provider: "router", name: "Auto", api: "pi-virtual" };
 
 const USAGE = {
   input: 1,
@@ -67,6 +59,19 @@ function hangingStream(opts: any) {
   };
 }
 
+// Models a router that never settles and ignores cancellation.
+function deafStream() {
+  const never = new Promise<never>(() => {});
+  return {
+    async *[Symbol.asyncIterator]() {
+      await never;
+    },
+    async result() {
+      return never;
+    },
+  };
+}
+
 // Emits `events` thinking_delta events spaced `gapMs` apart, then completes
 // successfully — UNLESS `opts.signal` aborts mid-drip, in which case the
 // current sleep rejects, exactly like a real provider stream cancelling on
@@ -107,13 +112,19 @@ interface Note {
   level: string;
 }
 
-function makeCtx(notes: Note[], sessionModel: any = SESSION, primaryModel: any = PRIMARY) {
+function makeCtx(notes: Note[], sessionModel: any = SESSION, primaryModel: any = PRIMARY, authOk = true) {
+  const authCalls: any[] = [];
   return {
     model: sessionModel,
+    authCalls,
     modelRegistry: {
       find: () => primaryModel,
-      getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
-      getProviderAuth: async () => undefined,
+      getApiKeyAndHeaders: async (model: any) => {
+        authCalls.push(model);
+        return authOk ? { ok: true, apiKey: "k", headers: {} } : { ok: false, error: "no key for provider-a" };
+      },
+      getProviderAuth: async () => ({ auth: { baseUrl: "https://seat.example" } }),
+      streamSimple: (model: any, input: any, opts: any) => streamImpl(model, input, opts),
     },
     ui: { notify: (msg: string, level: string) => notes.push({ msg, level }) },
   } as any;
@@ -132,6 +143,90 @@ function makeBatch() {
 
 const distinctConfig = { ...DEFAULT_CONFIG, summarizerModel: "provider-a/primary-model" };
 
+describe("virtual models through the registry", () => {
+  for (const operation of ["batch", "range"] as const) {
+    const summarize = (config: any, ctx: any, options: any = {}) => operation === "batch"
+      ? summarizeBatch(makeBatch(), config, ctx, options)
+      : summarizeRange("- step one", config, ctx, options);
+
+    it(`${operation}: virtual session model rescues a transient primary`, async () => {
+      const seen: any[] = [];
+      streamImpl = (model) => {
+        seen.push(model);
+        return model === PRIMARY ? errStream("down") : okStream("- routed summary");
+      };
+      const notes: Note[] = [];
+      const controller = new FallbackController();
+      const result = await summarize(distinctConfig, makeCtx(notes, VIRTUAL), { controller });
+      expect(result?.summaryText).toBe("- routed summary");
+      expect(controller.inFallback).toBe(true);
+      expect(seen[1]).toBe(VIRTUAL);
+      expect(notes.filter(n => n.level === "warning")).toHaveLength(1);
+      expect(notes.filter(n => n.level === "error")).toHaveLength(0);
+    });
+
+    for (const selection of ["default", "router/auto"]) {
+      it(`${operation}: virtual ${selection} skips auth and sends only summarizer context`, async () => {
+        const calls: any[] = [];
+        streamImpl = (model, input, opts) => {
+          calls.push({ model, input, opts });
+          return okStream("- ok");
+        };
+        const notes: Note[] = [];
+        const ctx = makeCtx(notes, VIRTUAL, VIRTUAL);
+        const result = await summarize({ ...DEFAULT_CONFIG, summarizerModel: selection }, ctx);
+        expect(result?.summaryText).toBe("- ok");
+        expect(calls).toHaveLength(1);
+        expect(calls[0].model).toBe(VIRTUAL);
+        expect(ctx.authCalls).toHaveLength(0);
+        expect(Object.keys(calls[0].input)).toEqual(["messages"]);
+        expect(calls[0].input.messages).toHaveLength(1);
+        expect(calls[0].input.messages[0].role).toBe("user");
+        expect(calls[0].opts.apiKey).toBeUndefined();
+        expect(calls[0].opts.headers).toBeUndefined();
+        expect(notes).toHaveLength(0);
+      });
+    }
+  }
+
+  it("passes the physical model unchanged and pre-checks once", async () => {
+    const seen: any[] = [];
+    streamImpl = (model) => {
+      seen.push(model);
+      return okStream("- ok");
+    };
+    const ctx = makeCtx([]);
+    await summarizeBatch(makeBatch(), DEFAULT_CONFIG, ctx);
+    expect(seen[0]).toBe(SESSION);
+    expect(seen[0].baseUrl).toBeUndefined();
+    expect(ctx.authCalls).toEqual([SESSION]);
+  });
+
+  it("missing physical credentials never stream or trip the controller", async () => {
+    let called = 0;
+    streamImpl = () => { called++; return okStream("- never"); };
+    const notes: Note[] = [];
+    const controller = new FallbackController();
+    const result = await summarizeBatch(makeBatch(), distinctConfig, makeCtx(notes, SESSION, PRIMARY, false), { controller });
+    expect(result).toBeNull();
+    expect(called).toBe(0);
+    expect(controller.inFallback).toBe(false);
+    expect(notes).toHaveLength(1);
+    expect(notes[0].level).toBe("error");
+    expect(notes[0].msg).toContain("no key for provider-a");
+  });
+
+  it("virtual stream failure returns null with the existing error notice", async () => {
+    streamImpl = () => errStream("router: no credentials for routed model");
+    const notes: Note[] = [];
+    const result = await summarizeBatch(makeBatch(), DEFAULT_CONFIG, makeCtx(notes, VIRTUAL));
+    expect(result).toBeNull();
+    expect(notes).toHaveLength(1);
+    expect(notes[0].level).toBe("error");
+    expect(notes[0].msg).toContain("router: no credentials for routed model");
+  });
+});
+
 describe("runSummarization wiring — same-model no-op (legacy path)", () => {
   it("summarizerModel=default: transient failure notifies error, returns null, controller untouched", async () => {
     streamImpl = () => errStream("provider overloaded");
@@ -223,6 +318,33 @@ describe("runSummarization wiring — abort", () => {
 });
 
 describe("runSummarization wiring — timeouts", () => {
+  for (const [kind, idleMs, maxMs, message] of [
+    ["idle", 20, 0, /stalled/],
+    ["ceiling", 0, 20, /ceiling/],
+  ] as const) {
+    it(`stream that ignores the signal still times out (${kind})`, async () => {
+      streamImpl = () => deafStream();
+      const notes: Note[] = [];
+      const ctx = makeCtx(notes, VIRTUAL);
+      const cfg = { ...DEFAULT_CONFIG, summarizerModel: "default", summarizerIdleTimeoutMs: idleMs, summarizerMaxTimeoutMs: maxMs };
+      expect(await summarizeBatch(makeBatch(), cfg, ctx, {})).toBeNull();
+      expect(notes).toHaveLength(1);
+      expect(notes[0].level).toBe("warning");
+      expect(notes[0].msg).toMatch(message);
+    });
+  }
+
+  it("caller abort during a stream that ignores the signal throws, no warning", async () => {
+    streamImpl = () => deafStream();
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes, VIRTUAL);
+    const ac = new AbortController();
+    setTimeout(() => ac.abort(), 20);
+    const cfg = { ...DEFAULT_CONFIG, summarizerModel: "default", summarizerIdleTimeoutMs: 0, summarizerMaxTimeoutMs: 0 };
+    await expect(summarizeBatch(makeBatch(), cfg, ctx, { signal: ac.signal })).rejects.toThrow();
+    expect(notes).toHaveLength(0);
+  });
+
   it("idle timeout (default model): transient warning, returns null", async () => {
     streamImpl = (_m, _i, opts) => hangingStream(opts);
     const notes: Note[] = [];