pi-condense 2.2.0 → 2.2.1

package/CHANGELOG.md

@@ -9,6 +9,10 @@ publishes via OIDC trusted publishing. See `.agents/skills/release/SKILL.md`.
 
 ## [Unreleased]
 
+## [2.2.1] - 2026-07-06
+
+- **Fix probe starvation in the summarizer outage fallback.** `FallbackController.onFallbackOnlyFail` reset the re-probe cooldown on every steady-state fallback failure, so a fallback (session) model that failed at least once per 10-minute cooldown perpetually pushed out the primary re-probe - a recovered `summarizerModel` was never re-tested and summarization stayed on the pricier session model indefinitely (the exact stall the feature exists to kill, in the fallback direction). The method is now a no-op on `lastProbeAt`: the primary re-probe fires on schedule regardless of fallback failures. In-memory only; no wire/config change.
+
 ## [2.2.0] - 2026-07-06
 
 - **Summarizer outage fallback to the session model.** Per-model provider outages (e.g. a cheap `summarizerModel` like Haiku degraded while the session's main model stays healthy) previously stalled pruning for the whole outage - `runSummarization` returned null and the batch retried the same dead model every flush, growing context unbounded. A new sticky in-memory `FallbackController` (`src/summarizer-fallback.ts`) now routes summarization to `ctx.model` on a **transient** failure of the configured model, retrying the failed call once on the session model. Fallback is sticky: while engaged, all calls use the session model until a single probe batch re-tests the configured model after a 10-minute cooldown, then auto-recovers. Trigger is transient-only - auth (pre-flight key failure), unusable (empty/truncated), and abort never trip it. A one-time `warning` fires on enter and an `info` on recovery via `ctx.ui.notify` (UI only, never injected into LLM context). No config key: the target is always `ctx.model`, and the controller is inert when no distinct fallback model exists (`summarizerModel: default` or the resolved model equals `ctx.model`), preserving today's single-attempt behavior byte-for-byte. State is in-memory only (reset on `session_start`, no `context-prune-*` entry).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.2.0",
+  "version": "2.2.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/summarizer-fallback.test.ts

@@ -133,6 +133,23 @@ describe("unusable probe does not falsely recover", () => {
   });
 });
 
+describe("probe schedule survives steady-state fallback failures", () => {
+  it("onFallbackOnlyFail does not push out the next primary probe", () => {
+    const t = { now: 0 };
+    const c = new FallbackController(clockAt(t));
+    c.onPrimaryFailFallbackOk(false); // enter, lastProbeAt = 0
+    // fallback keeps failing every minute, well within the cooldown
+    for (let i = 1; i < 10; i++) {
+      t.now = i * 60_000;
+      expect(c.chooseTarget()).toEqual({ target: "fallback", wasProbe: false });
+      c.onFallbackOnlyFail();
+    }
+    // at COOLDOWN_MS the primary must still be probed despite the failures
+    t.now = COOLDOWN_MS;
+    expect(c.chooseTarget()).toEqual({ target: "primary", wasProbe: true });
+  });
+});
+
 describe("reset", () => {
   it("clears all state", () => {
     const t = { now: 5 };

package/src/summarizer-fallback.ts

@@ -96,10 +96,14 @@ export class FallbackController {
     }
   }
 
-  /** A steady-state fallback call (already in fallback) failed transiently. */
-  onFallbackOnlyFail(): void {
-    this.lastProbeAt = this.now();
-  }
+  /**
+   * A steady-state fallback call (already in fallback) failed transiently.
+   * Deliberately a no-op on `lastProbeAt`: a fallback failure is not a probe,
+   * so it must not push out the next primary re-probe. Resetting the cooldown
+   * here starves the probe whenever the fallback fails at least once per
+   * COOLDOWN_MS, leaving a recovered primary undetected indefinitely.
+   */
+  onFallbackOnlyFail(): void {}
 
   /** A primary call succeeded. Recover only when it was the probe. */
   onPrimarySuccess(wasProbe: boolean): FallbackTransition {