pi-condense 2.12.0 → 2.13.1

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/summarizer-wiring.test.ts

@@ -4,7 +4,7 @@ let streamImpl: (model: any, input?: any, opts?: any) => any = () => {
 };
 const { summarizeBatch, summarizeRange } = await import("./summarizer.js");
 const { FallbackController } = await import("./summarizer-fallback.js");
-const { DEFAULT_CONFIG } = await import("./types.js");
+const { DEFAULT_CONFIG, SUMMARIZER_IDLE_TIMEOUT_PRESETS } = await import("./types.js");
 
 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" };
@@ -161,6 +161,7 @@ describe("virtual models through the registry", () => {
       expect(result?.summaryText).toBe("- routed summary");
       expect(controller.inFallback).toBe(true);
       expect(seen[1]).toBe(VIRTUAL);
+      expect(notes[0]).toEqual({ msg: "pi-condense: summarizer model Primary failing (down), using session model Auto until it recovers", level: "warning" });
       expect(notes.filter(n => n.level === "warning")).toHaveLength(1);
       expect(notes.filter(n => n.level === "error")).toHaveLength(0);
     });
@@ -300,6 +301,7 @@ describe("runSummarization wiring — both-down + deferred warning", () => {
     const r2 = await summarizeBatch(makeBatch(), distinctConfig, ctx, { controller });
     expect(r2?.summaryText).toBe("- rescued");
     expect(notes.filter((n) => n.level === "warning")).toHaveLength(1);
+    expect(notes[0].msg).toBe("pi-condense: summarizer model Primary failing, using session model Session until it recovers");
   });
 });
 
@@ -319,6 +321,7 @@ describe("runSummarization wiring — abort", () => {
 
 describe("runSummarization wiring — timeouts", () => {
   for (const [kind, idleMs, maxMs, message] of [
+    // Millisecond-scale overrides exercise timer behavior, not the default.
     ["idle", 20, 0, /stalled/],
     ["ceiling", 0, 20, /ceiling/],
   ] as const) {
@@ -379,7 +382,7 @@ describe("runSummarization wiring — timeouts", () => {
     const r = await summarizeBatch(makeBatch(), cfg, ctx, { controller });
     expect(r?.summaryText).toBe("- rescued");
     expect(controller.inFallback).toBe(true);
-    expect(notes.filter((n) => n.level === "warning")).toHaveLength(1); // generic "enter" fallback warning
+    expect(notes.filter((n) => n.level === "warning")).toHaveLength(1);
     expect(notes.filter((n) => n.level === "error")).toHaveLength(0);
   });
 
@@ -430,3 +433,235 @@ describe("runSummarization wiring — idle reset keeps a flowing stream alive",
     expect(notes.filter((n) => n.level === "warning")).toHaveLength(0);
   });
 });
+
+async function withTimerClock(
+  run: (clock: { advance(ms: number): Promise<void>; now(): number }) => Promise<void>,
+) {
+  const realSetTimeout = globalThis.setTimeout;
+  const realClearTimeout = globalThis.clearTimeout;
+  const timers = new Map<number, { at: number; fire(): void }>();
+  let now = 0;
+  let nextId = 0;
+  const drain = () => new Promise<void>((resolve) => realSetTimeout(resolve, 0));
+  globalThis.setTimeout = ((callback: (...args: any[]) => void, delay = 0, ...args: any[]) => {
+    const id = ++nextId;
+    timers.set(id, { at: now + Number(delay), fire: () => callback(...args) });
+    return id;
+  }) as unknown as typeof globalThis.setTimeout;
+  globalThis.clearTimeout = ((id: any) => { timers.delete(Number(id)); }) as unknown as typeof globalThis.clearTimeout;
+  try {
+    await run({
+      now: () => now,
+      async advance(ms) {
+        await drain();
+        const end = now + ms;
+        while (true) {
+          const next = [...timers.entries()]
+            .filter(([, timer]) => timer.at <= end)
+            .sort((a, b) => a[1].at - b[1].at || a[0] - b[0])[0];
+          if (!next) break;
+          now = next[1].at;
+          timers.delete(next[0]);
+          next[1].fire();
+          await drain();
+        }
+        now = end;
+        await drain();
+      },
+    });
+  } finally {
+    globalThis.setTimeout = realSetTimeout;
+    globalThis.clearTimeout = realClearTimeout;
+    timers.clear();
+  }
+}
+
+const genericEnter = "pi-condense: summarizer model Primary failing, using session model Session until it recovers";
+
+describe("immediate fallback reasons", () => {
+  it("marks only the 45s preset as default", () => {
+    expect(DEFAULT_CONFIG.summarizerIdleTimeoutMs).toBe(45000);
+    expect(SUMMARIZER_IDLE_TIMEOUT_PRESETS.filter(p => p.label.includes("(default)")))
+      .toEqual([{ value: "45000", label: "45s (default)" }]);
+  });
+
+  for (const raw of [
+    { summarizerModel: "provider-a/primary-model" },
+    { summarizerModel: "provider-a/primary-model", summarizerIdleTimeoutMs: 20000 },
+  ]) {
+    it(`delayed first event with ${raw.summarizerIdleTimeoutMs ?? "resolved default"}`, async () => {
+      await withTimerClock(async clock => {
+        const config = { ...DEFAULT_CONFIG, ...raw };
+        const notes: Note[] = [];
+        const attempts: any[] = [];
+        let primarySignal: AbortSignal;
+        streamImpl = (model, _input, opts) => {
+          attempts.push(model);
+          if (model === PRIMARY) {
+            primarySignal = opts.signal;
+            return drippingStream(opts, "- primary summary", 1, 25000);
+          }
+          return okStream("- rescued");
+        };
+        const controller = new FallbackController(clock.now);
+        let settled = false;
+        const pending = summarizeBatch(makeBatch(), config, makeCtx(notes), { controller });
+        void pending.then(() => { settled = true; });
+        await clock.advance(19999);
+        expect(settled).toBe(false);
+        await clock.advance(1);
+        if (raw.summarizerIdleTimeoutMs === 20000) {
+          expect(primarySignal!.aborted).toBe(true);
+          expect((await pending)?.summaryText).toBe("- rescued");
+          expect(attempts).toEqual([PRIMARY, SESSION]);
+          expect(notes).toEqual([{ msg: genericEnter.replace("failing,", "failing (stalled (no output for 20s)),"), level: "warning" }]);
+        } else {
+          expect(config.summarizerIdleTimeoutMs).toBe(45000);
+          expect(settled).toBe(false);
+          expect(primarySignal!.aborted).toBe(false);
+          await clock.advance(5000);
+          expect((await pending)?.summaryText).toBe("- primary summary");
+          expect(attempts).toEqual([PRIMARY]);
+          expect(controller.inFallback).toBe(false);
+          expect(notes).toEqual([]);
+        }
+      });
+    });
+  }
+
+  for (const kind of ["idle", "ceiling"] as const) {
+    it(`${kind} rescue carries the prefix-free reason`, async () => {
+      await withTimerClock(async clock => {
+        const notes: Note[] = [];
+        streamImpl = (model, _input, opts) => {
+          if (model === SESSION) return okStream("- rescued");
+          if (kind === "ceiling") return hangingStream(opts);
+          const drip = drippingStream(opts, "- partial", 1, 1000);
+          const hang = hangingStream(opts);
+          return {
+            async *[Symbol.asyncIterator]() { yield* drip; yield* hang; },
+            result: () => hang.result(),
+          };
+        };
+        let settled = false;
+        const pending = summarizeBatch(makeBatch(), {
+          ...distinctConfig, summarizerIdleTimeoutMs: kind === "idle" ? 45000 : 0,
+          summarizerMaxTimeoutMs: 180000,
+        }, makeCtx(notes), { controller: new FallbackController(clock.now) });
+        void pending.then(() => { settled = true; });
+        await clock.advance(kind === "idle" ? 45000 : 179999);
+        expect(settled).toBe(false);
+        await clock.advance(kind === "idle" ? 1000 : 1);
+        expect((await pending)?.summaryText).toBe("- rescued");
+        const reason = kind === "idle" ? "stalled (no output for 45s)" : "exceeded 180s ceiling";
+        expect(notes).toEqual([{ msg: genericEnter.replace("failing,", `failing (${reason}),`), level: "warning" }]);
+        if (kind === "idle") expect(notes[0].msg).toMatch(/summarizer model .* failing \(stalled \(no output for \d+s\)\), using session model/);
+      });
+    });
+  }
+
+  for (const path of ["response", "throw"] as const) {
+    for (const [name, message] of [
+      ["non-empty", "boom"],
+      ["multiline", "  long provider message\n" + "detail ".repeat(60) + "\n  "],
+      ["empty", ""],
+    ]) {
+      it(`${path} preserves ${name} message verbatim`, async () => {
+        streamImpl = model => {
+          if (model === SESSION) return okStream("- rescued");
+          if (path === "throw") throw new Error(message);
+          return errStream(message);
+        };
+        const notes: Note[] = [];
+        const result = await summarizeBatch(makeBatch(), distinctConfig, makeCtx(notes), { controller: new FallbackController() });
+        expect(result?.summaryText).toBe("- rescued");
+        expect(notes).toEqual([{ msg: message ? genericEnter.replace("failing,", `failing (${message}),`) : genericEnter, level: "warning" }]);
+      });
+    }
+  }
+});
+
+describe("terminal timeout labels", () => {
+  for (const kind of ["idle", "ceiling"] as const) {
+    for (const mode of ["legacy", "fallback-only", "both-down", "unusable-retry"] as const) {
+      it(`${kind}: ${mode} labels the selected outcome`, async () => {
+        await withTimerClock(async clock => {
+          const notes: Note[] = [];
+          streamImpl = (model, _input, opts) => mode === "unusable-retry" && model === SESSION
+            ? okStream(" ") : hangingStream(opts);
+          const controller = new FallbackController(clock.now);
+          if (mode === "fallback-only") controller.onBothDown();
+          const pending = summarizeBatch(makeBatch(), {
+            ...distinctConfig,
+            summarizerModel: mode === "legacy" ? "default" : distinctConfig.summarizerModel,
+            summarizerIdleTimeoutMs: kind === "idle" ? 20 : 0,
+            summarizerMaxTimeoutMs: kind === "ceiling" ? 20 : 0,
+          }, makeCtx(notes), mode === "legacy" ? {} : { controller });
+          await clock.advance(40);
+          expect(await pending).toBeNull();
+          const label = mode === "unusable-retry" ? "Primary" : "Session";
+          const reason = kind === "idle" ? "stalled (no output for 0s)" : "exceeded 0s ceiling";
+          expect(notes).toEqual([{ msg: `pi-condense: summarizer ${label} ${reason}; summarizer call abandoned`, level: "warning" }]);
+        });
+      });
+    }
+  }
+
+  it("session-only auth failure after transient primary keeps its error text", async () => {
+    streamImpl = () => errStream("down");
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes);
+    ctx.modelRegistry.getApiKeyAndHeaders = async (model: any) => model === PRIMARY
+      ? { ok: true, apiKey: "k", headers: {} } : { ok: false, error: "session key missing" };
+    expect(await summarizeBatch(makeBatch(), distinctConfig, ctx, { controller: new FallbackController() })).toBeNull();
+    expect(notes).toEqual([{ msg: "pruner: summarization failed: session key missing", level: "error" }]);
+  });
+});
+
+describe("deferred entry and probe notices", () => {
+  for (const initial of ["both-down", "rescued"] as const) {
+    it(`${initial}: failed probe rescue then recovery`, async () => {
+      let now = 0;
+      const controller = new FallbackController(() => now);
+      const notes: Note[] = [];
+      const ctx = makeCtx(notes);
+      streamImpl = model => model === PRIMARY || initial === "both-down" ? errStream("down") : okStream("- ok");
+      await summarizeBatch(makeBatch(), distinctConfig, ctx, { controller });
+      notes.length = 0;
+      now += 600001;
+      streamImpl = model => model === PRIMARY ? errStream("probe failed") : okStream("- rescued");
+      expect((await summarizeBatch(makeBatch(), distinctConfig, ctx, { controller }))?.summaryText).toBe("- rescued");
+      expect(notes).toEqual(initial === "both-down" ? [{ msg: genericEnter, level: "warning" }] : []);
+      notes.length = 0;
+      now += 600001;
+      streamImpl = () => okStream("- recovered");
+      await summarizeBatch(makeBatch(), distinctConfig, ctx, { controller });
+      expect(notes).toEqual([{ msg: "pi-condense: summarizer model Primary recovered", level: "info" }]);
+    });
+  }
+
+  it("blank primary never retries or enters fallback", async () => {
+    const attempts: any[] = [];
+    streamImpl = model => { attempts.push(model); return okStream(" "); };
+    const controller = new FallbackController();
+    const notes: Note[] = [];
+    expect(await summarizeBatch(makeBatch(), distinctConfig, makeCtx(notes), { controller })).toBeNull();
+    expect(attempts).toEqual([PRIMARY]);
+    expect(controller.inFallback).toBe(false);
+    expect(notes).toEqual([]);
+  });
+
+  it("abort during pending stream rejects without notices", async () => {
+    await withTimerClock(async clock => {
+      streamImpl = (_model, _input, opts) => hangingStream(opts);
+      const notes: Note[] = [];
+      const ac = new AbortController();
+      const pending = summarizeBatch(makeBatch(), distinctConfig, makeCtx(notes), { controller: new FallbackController(clock.now), signal: ac.signal });
+      const rejected = pending.then(() => null, error => error);
+      await clock.advance(1);
+      ac.abort();
+      expect(await rejected).toBeInstanceOf(Error);
+      expect(notes).toEqual([]);
+    });
+  });
+});

package/src/summarizer.ts

@@ -153,8 +153,8 @@ async function runOnce(
   };
   const timeoutMessage = () =>
     timeoutKind === "ceiling"
-      ? `summarizer ${modelLabel(model)} exceeded ${Math.round(maxMs / 1000)}s ceiling`
-      : `summarizer ${modelLabel(model)} stalled (no output for ${Math.round(idleMs / 1000)}s)`;
+      ? `exceeded ${Math.round(maxMs / 1000)}s ceiling`
+      : `stalled (no output for ${Math.round(idleMs / 1000)}s)`;
 
   try {
     // Preserve auth classification for physical models without pre-checking
@@ -286,10 +286,10 @@ async function runSummarization(
   const controller = options.controller;
   const sessionModel = ctx.model;
 
-  const notifyFailure = (o: { message: string; timedOut?: boolean }) =>
+  const notifyFailure = (model: any, o: { message: string; timedOut?: boolean }) =>
     ctx.ui.notify(
       o.timedOut
-        ? `pi-condense: ${o.message}; summarizer call abandoned`
+        ? `pi-condense: summarizer ${modelLabel(model)} ${o.message}; summarizer call abandoned`
         : `pruner: summarization failed: ${o.message}`,
       o.timedOut ? "warning" : "error",
     );
@@ -302,17 +302,18 @@ async function runSummarization(
         return r.result;
       case "auth":
       case "transient":
-        notifyFailure(r);
+        notifyFailure(primary, r);
         return null;
       case "unusable":
         return null;
     }
   }
 
-  const emit = (t: FallbackTransition) => {
+  const emit = (t: FallbackTransition, reason?: string) => {
     if (t === "enter") {
+      const failureReason = typeof reason === "string" && reason.length > 0 ? ` (${reason})` : "";
       ctx.ui.notify(
-        `pi-condense: summarizer model ${modelLabel(primary)} failing, using session model ${modelLabel(sessionModel)} until it recovers`,
+        `pi-condense: summarizer model ${modelLabel(primary)} failing${failureReason}, using session model ${modelLabel(sessionModel)} until it recovers`,
         "warning"
       );
     } else if (t === "recover") {
@@ -330,24 +331,29 @@ async function runSummarization(
       else emit(controller.onFallbackSuccess());
       return r.result;
     case "auth":
-      notifyFailure(r); // auth never trips the controller
+      notifyFailure(model, r); // auth never trips the controller
       return null;
     case "unusable":
       return null; // probe unusable => stay (no state change)
     case "transient": {
       if (decision.target === "fallback") {
         controller.onFallbackOnlyFail();
-        notifyFailure(r);
+        notifyFailure(model, r);
         return null;
       }
       // target was primary (initial detection or probe): retry once on the session model.
       const r2 = await runOnce(sessionModel, userMessage, config, ctx, options);
       if (r2.kind === "ok") {
-        emit(controller.onPrimaryFailFallbackOk(decision.wasProbe));
+        const wasInFallback = controller.inFallback;
+        emit(controller.onPrimaryFailFallbackOk(decision.wasProbe), wasInFallback ? undefined : r.message);
         return r2.result; // suppress the legacy error notify — fallback rescued the call
       }
       controller.onBothDown();
-      notifyFailure(r2.kind === "transient" || r2.kind === "auth" ? r2 : r);
+      if (r2.kind === "transient" || r2.kind === "auth") {
+        notifyFailure(sessionModel, r2);
+      } else {
+        notifyFailure(model, r);
+      }
       return null;
     }
   }