pi-condense 2.13.0 → 2.13.1

package/CHANGELOG.md

@@ -7,6 +7,13 @@ Published to npm as [`pi-condense`](https://www.npmjs.com/package/pi-condense) (
 Pushing a `vX.Y.Z` tag triggers `.github/workflows/release.yml`, which runs the tests and
 publishes via OIDC trusted publishing. See `.agents/skills/release/SKILL.md`.
 
+## [2.13.1] - 2026-10-22
+
+### Changed
+
+- The summarizer idle default is 45s instead of 20s, allowing queued providers longer before session-model takeover; the silent-primary wait is 45s on initial detection and each failed 10-minute probe. Explicit settings keep their values. (#21)
+- Immediate session-model rescue notices include the primary failure reason, including idle/ceiling timeout or provider error text; deferred fallback notices remain unchanged. (#21)
+
 ## [2.13.0] - 2026-10-20
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.13.0",
+  "version": "2.13.1",
   "description": "Pi coding-agent extension that summarizes completed tool-call batches, replaces raw outputs with short stubs, compresses closed tool-call chains, and recovers any original on demand via context_tree_query.",
   "author": "Jacek Juraszek",
   "license": "MIT",

package/src/commands.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, mock } from "bun:test";
-import { mkdtempSync } from "node:fs";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -9,7 +9,7 @@ import { join } from "node:path";
 process.env.PI_CODING_AGENT_DIR = mkdtempSync(join(tmpdir(), "pi-condense-commands-test-"));
 
 import { pruneStatusText, setPruneStatusWidget, registerCommands } from "./commands.js";
-import { settingsPath } from "./config.js";
+import { settingsPath, loadConfig } from "./config.js";
 import type { ContextPruneConfig, ContextMetricsSnapshot, SummarizerStats } from "./types.js";
 import { DEFAULT_CONFIG } from "./types.js";
 import { Container, SettingsList } from "@earendil-works/pi-tui";
@@ -148,6 +148,23 @@ describe("/pruner now (empty capture)", () => {
 });
 
 describe("/pruner status context block", () => {
+  it("reports the resolved 45s idle default when the setting is absent", async () => {
+    const scratchDir = mkdtempSync(join(tmpdir(), "pi-condense-idle-status-"));
+    const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+    try {
+      process.env.PI_CODING_AGENT_DIR = scratchDir;
+      writeFileSync(settingsPath(), JSON.stringify({ contextPrune: { enabled: true } }));
+      const harness = setupPrunerCommand();
+      harness.currentConfig.value = await loadConfig();
+      await harness.run("status");
+      expect(harness.notifications[0]?.message).toContain("idle to:  45s");
+    } finally {
+      if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR;
+      else process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+      rmSync(scratchDir, { recursive: true, force: true });
+    }
+  });
+
   const metrics: ContextMetricsSnapshot = {
     openCycleThinkingTokens: 12000,
     largestChainSharePct: 62,

package/src/config.test.ts

@@ -99,8 +99,15 @@ describe("loadConfig summarizer timeout normalization", () => {
   it("defaults both timeouts when absent", async () => {
     await writeContextPrune({});
     const config = await loadConfig();
-    expect(config.summarizerIdleTimeoutMs).toBe(DEFAULT_CONFIG.summarizerIdleTimeoutMs);
+    expect(config.summarizerIdleTimeoutMs).toBe(45000);
     expect(config.summarizerMaxTimeoutMs).toBe(DEFAULT_CONFIG.summarizerMaxTimeoutMs);
+    expect(config.summarizerMaxTimeoutMs).toBe(180000);
+  });
+
+  it("preserves an explicit legacy 20s idle timeout", async () => {
+    await writeContextPrune({ summarizerIdleTimeoutMs: 20000 });
+    const config = await loadConfig();
+    expect(config.summarizerIdleTimeoutMs).toBe(20000);
   });
 
   it("preserves explicit 0 (disabled) for both", async () => {

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;
     }
   }

package/src/types.ts

@@ -219,8 +219,8 @@ export const RECOVERY_GRACE_PRESETS: { value: string; label: string }[] = [
 export const SUMMARIZER_IDLE_TIMEOUT_PRESETS: { value: string; label: string }[] = [
   { value: "0", label: "0 (disabled)" },
   { value: "10000", label: "10s" },
-  { value: "20000", label: "20s (default)" },
-  { value: "45000", label: "45s" },
+  { value: "20000", label: "20s" },
+  { value: "45000", label: "45s (default)" },
   { value: "90000", label: "90s" },
 ];
 
@@ -321,7 +321,7 @@ export interface ContextPruneConfig {
    * Reset on every received stream event; armed before the first event so it
    * also bounds time-to-first-token. If no event arrives within this window
    * the call is aborted and classified transient (feeds the outage-fallback
-   * retry). 0 disables the idle timer. Default 20000.
+   * retry). 0 disables the idle timer. Default 45000.
    */
   summarizerIdleTimeoutMs: number;
   /**
@@ -569,7 +569,7 @@ export const DEFAULT_CONFIG: ContextPruneConfig = {
   quietOversizedSkips: false,
   minBatchChars: 2000,
   recoveryGraceTurns: 3,
-  summarizerIdleTimeoutMs: 20000,
+  summarizerIdleTimeoutMs: 45000,
   summarizerMaxTimeoutMs: 180000,
   protectedTools: [],
   protectedPaths: ["**/skills/**/*.md", "**/gauntlet-overrides.md"],