pi-condense 2.2.1 → 2.4.0

package/src/summarizer-wiring.test.ts

@@ -2,11 +2,11 @@ import { describe, it, expect, mock } from "bun:test";
 
 // Stub pi-ai's `stream` so runSummarization can be exercised without a network
 // call. `streamImpl` is swapped per test to simulate primary/fallback outcomes.
-let streamImpl: (model: any) => any = () => {
+let streamImpl: (model: any, input?: any, opts?: any) => any = () => {
   throw new Error("streamImpl not set");
 };
 mock.module("@earendil-works/pi-ai", () => ({
-  stream: (model: any) => streamImpl(model),
+  stream: (...args: any[]) => streamImpl(...args),
 }));
 
 const { summarizeBatch } = await import("./summarizer.js");
@@ -45,6 +45,61 @@ function errStream(message: string) {
   };
 }
 
+// Hangs until `opts.signal` (the combined caller+timeout signal runOnce
+// passes to stream()) aborts. With no signal it never settles.
+function hangingStream(opts: any) {
+  const signal: AbortSignal | undefined = opts?.signal;
+  const untilAbort = () =>
+    new Promise<never>((_, reject) => {
+      if (!signal) return; // no signal => never settles
+      if (signal.aborted) return reject(new Error("aborted"));
+      signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
+    });
+  return {
+    async *[Symbol.asyncIterator]() {
+      await untilAbort();
+    },
+    async result() {
+      return untilAbort();
+    },
+  };
+}
+
+// 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
+// abort. This is what gives the idle-reset test teeth: if runOnce's in-loop
+// bumpIdle() is ever removed, the idle timer fires at the configured window
+// and the combined signal aborts, so this stream rejects instead of
+// completing — the test then fails instead of passing vacuously.
+function drippingStream(opts: any, text: string, events: number, gapMs: number) {
+  const signal: AbortSignal | undefined = opts?.signal;
+  const sleepOrAbort = (ms: number) =>
+    new Promise<void>((resolve, reject) => {
+      if (signal?.aborted) return reject(new Error("aborted"));
+      const timer = setTimeout(resolve, ms);
+      signal?.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timer);
+          reject(new Error("aborted"));
+        },
+        { once: true }
+      );
+    });
+  return {
+    async *[Symbol.asyncIterator]() {
+      for (let i = 0; i < events; i++) {
+        await sleepOrAbort(gapMs);
+        yield { type: "thinking_delta" };
+      }
+    },
+    async result() {
+      return { stopReason: "stop", content: [{ type: "text", text }], usage: USAGE };
+    },
+  };
+}
+
 interface Note {
   msg: string;
   level: string;
@@ -163,3 +218,90 @@ describe("runSummarization wiring — abort", () => {
     ).rejects.toThrow();
   });
 });
+
+describe("runSummarization wiring — timeouts", () => {
+  it("idle timeout (default model): transient warning, returns null", async () => {
+    streamImpl = (_m, _i, opts) => hangingStream(opts);
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes);
+    const cfg = { ...DEFAULT_CONFIG, summarizerModel: "default", summarizerIdleTimeoutMs: 20, summarizerMaxTimeoutMs: 0 };
+    const r = await summarizeBatch(makeBatch(), cfg, ctx, {});
+    expect(r).toBeNull();
+    const warnings = notes.filter((n) => n.level === "warning");
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0].msg).toMatch(/stalled/);
+    expect(notes.filter((n) => n.level === "error")).toHaveLength(0);
+  });
+
+  it("ceiling timeout (idle disabled): transient warning mentioning ceiling", async () => {
+    streamImpl = (_m, _i, opts) => hangingStream(opts);
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes);
+    const cfg = { ...DEFAULT_CONFIG, summarizerModel: "default", summarizerIdleTimeoutMs: 0, summarizerMaxTimeoutMs: 20 };
+    const r = await summarizeBatch(makeBatch(), cfg, ctx, {});
+    expect(r).toBeNull();
+    const warnings = notes.filter((n) => n.level === "warning");
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0].msg).toMatch(/ceiling/);
+  });
+
+  it("option B: primary idle-times-out, session model rescues", async () => {
+    streamImpl = (model, _i, opts) => (model.id === PRIMARY.id ? hangingStream(opts) : okStream("- rescued"));
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes);
+    const controller = new FallbackController();
+    const cfg = { ...distinctConfig, summarizerIdleTimeoutMs: 20 };
+    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 === "error")).toHaveLength(0);
+  });
+
+  it("both time out: null, both-down notice at warning severity", async () => {
+    streamImpl = (_m, _i, opts) => hangingStream(opts);
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes);
+    const controller = new FallbackController();
+    const cfg = { ...distinctConfig, summarizerIdleTimeoutMs: 20 };
+    const r = await summarizeBatch(makeBatch(), cfg, ctx, { controller });
+    expect(r).toBeNull();
+    expect(notes.filter((n) => n.level === "warning")).toHaveLength(1);
+    expect(notes.filter((n) => n.level === "error")).toHaveLength(0);
+  });
+
+  it("pre-aborted signal is not a timeout (throws, no warning)", async () => {
+    streamImpl = (_m, _i, opts) => hangingStream(opts);
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes);
+    const ac = new AbortController();
+    ac.abort();
+    const cfg = { ...distinctConfig, summarizerIdleTimeoutMs: 20 };
+    await expect(summarizeBatch(makeBatch(), cfg, ctx, { signal: ac.signal })).rejects.toThrow();
+    expect(notes.filter((n) => n.level === "warning")).toHaveLength(0);
+  });
+
+  it("both timeouts disabled: okStream succeeds unchanged", async () => {
+    streamImpl = () => okStream("- ok");
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes);
+    const cfg = { ...DEFAULT_CONFIG, summarizerModel: "default", summarizerIdleTimeoutMs: 0, summarizerMaxTimeoutMs: 0 };
+    const r = await summarizeBatch(makeBatch(), cfg, ctx, {});
+    expect(r?.summaryText).toBe("- ok");
+    expect(notes).toHaveLength(0);
+  });
+});
+
+describe("runSummarization wiring — idle reset keeps a flowing stream alive", () => {
+  it("does not time out while events keep arriving within the idle window", async () => {
+    // 6 events, 10ms apart = 60ms total > 25ms idle window; only survives if
+    // the idle timer resets on every event (bumpIdle() inside the loop).
+    streamImpl = (_m, _i, opts) => drippingStream(opts, "- flowing summary", 6, 10);
+    const notes: Note[] = [];
+    const ctx = makeCtx(notes);
+    const cfg = { ...DEFAULT_CONFIG, summarizerModel: "default", summarizerIdleTimeoutMs: 25, summarizerMaxTimeoutMs: 0 };
+    const r = await summarizeBatch(makeBatch(), cfg, ctx, {});
+    expect(r?.summaryText).toBe("- flowing summary");
+    expect(notes.filter((n) => n.level === "warning")).toHaveLength(0);
+  });
+});

package/src/summarizer.ts

@@ -90,7 +90,7 @@ type RunOutcome =
   | { kind: "ok"; result: SummarizeResult }
   | { kind: "auth"; message: string }
   | { kind: "unusable" }
-  | { kind: "transient"; message: string };
+  | { kind: "transient"; message: string; timedOut?: boolean };
 
 /** Human label for a model in notify text: prefer name, fall back to provider/id. */
 function modelLabel(model: any): string {
@@ -98,6 +98,14 @@ function modelLabel(model: any): string {
   return model.name || `${model.provider}/${model.id}`;
 }
 
+/** Combines any present abort signals into one; undefined if none are given. */
+function combineSignals(...signals: (AbortSignal | undefined)[]): AbortSignal | undefined {
+  const present = signals.filter((s): s is AbortSignal => !!s);
+  if (present.length === 0) return undefined;
+  if (present.length === 1) return present[0];
+  return AbortSignal.any(present); // Node 20+; host runtime is node 24.5.0
+}
+
 /**
  * One summarization attempt against a specific model. Returns a classified
  * outcome instead of throwing (except aborts, which propagate so flushPending
@@ -113,6 +121,29 @@ async function runOnce(
   ctx: ExtensionContext,
   options: SummarizeBatchOptions
 ): Promise<RunOutcome> {
+  const idleMs = config.summarizerIdleTimeoutMs;
+  const maxMs = config.summarizerMaxTimeoutMs;
+  const timeoutController = new AbortController();
+  let timedOut = false;
+  let timeoutKind: "idle" | "ceiling" | null = null;
+  let idleTimerId: ReturnType<typeof setTimeout> | null = null;
+  let ceilingTimerId: ReturnType<typeof setTimeout> | null = null;
+
+  const bumpIdle = () => {
+    if (idleTimerId !== null) clearTimeout(idleTimerId);
+    if (idleMs > 0) {
+      idleTimerId = setTimeout(() => {
+        timedOut = true;
+        timeoutKind = "idle";
+        timeoutController.abort();
+      }, idleMs);
+    }
+  };
+  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)`;
+
   try {
     const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
     if (!auth.ok) {
@@ -120,8 +151,8 @@ async function runOnce(
       return { kind: "auth", message: authMessage };
     }
 
-    // Pass the abort signal so the underlying fetch is cancelled immediately
-    // when the user presses Esc while the tool is running.
+    // Pass the combined signal so the underlying fetch is cancelled immediately
+    // either when the user presses Esc, or when an idle/ceiling timeout fires.
     const responseStream = stream(
       model,
       {
@@ -133,9 +164,25 @@ async function runOnce(
           },
         ],
       },
-      { apiKey: auth.apiKey, headers: auth.headers, signal: options.signal, ...summarizerThinkingOptions(config) }
+      {
+        apiKey: auth.apiKey,
+        headers: auth.headers,
+        signal: combineSignals(options.signal, timeoutController.signal),
+        ...summarizerThinkingOptions(config),
+      }
     );
 
+    // Ceiling arms once at call start; idle arms/resets on every stream event
+    // (including before the first one, so it also bounds time-to-first-token).
+    if (maxMs > 0) {
+      ceilingTimerId = setTimeout(() => {
+        timedOut = true;
+        timeoutKind ??= "ceiling";
+        timeoutController.abort();
+      }, maxMs);
+    }
+    bumpIdle();
+
     let lastReportedChars = -1;
     options.onTextProgress?.(0);
     const reportTextProgress = (message: AssistantMessage) => {
@@ -147,6 +194,10 @@ async function runOnce(
     };
 
     for await (const event of responseStream) {
+      // Reset idle on ANY event (text_* and thinking_*), not just text — a
+      // reasoning-heavy model stays alive via thinking_delta and is never
+      // false-aborted for being quiet on text while it reasons.
+      bumpIdle();
       // Belt-and-suspenders: break early when signal fires mid-stream.
       if (options.signal?.aborted) break;
       if (event.type === "text_start" || event.type === "text_delta" || event.type === "text_end") {
@@ -167,6 +218,7 @@ async function runOnce(
       throw new Error("summarize: stream stopped with reason aborted");
     }
     if (response.stopReason === "error") {
+      if (timedOut) return { kind: "transient", message: timeoutMessage(), timedOut: true };
       return { kind: "transient", message: response.errorMessage ?? "Summarizer stopped with reason: error" };
     }
 
@@ -182,7 +234,11 @@ async function runOnce(
     // Propagate abort errors upward so flushPending can check signal.aborted
     // and return { ok: false, reason: "aborted" } without showing a UI error.
     if (options.signal?.aborted) throw err;
+    if (timedOut) return { kind: "transient", message: timeoutMessage(), timedOut: true };
     return { kind: "transient", message: err.message };
+  } finally {
+    if (idleTimerId !== null) clearTimeout(idleTimerId);
+    if (ceilingTimerId !== null) clearTimeout(ceilingTimerId);
   }
 }
 
@@ -211,8 +267,13 @@ async function runSummarization(
   const controller = options.controller;
   const sessionModel = ctx.model;
 
-  const notifyError = (msg: string) =>
-    ctx.ui.notify(`pruner: summarization failed: ${msg}`, "error");
+  const notifyFailure = (o: { message: string; timedOut?: boolean }) =>
+    ctx.ui.notify(
+      o.timedOut
+        ? `pi-condense: ${o.message}; summarizer call abandoned`
+        : `pruner: summarization failed: ${o.message}`,
+      o.timedOut ? "warning" : "error",
+    );
 
   // No controller or no distinct fallback: single attempt, legacy behavior.
   if (!controller || !FallbackController.hasDistinctFallback(primary, sessionModel)) {
@@ -222,7 +283,7 @@ async function runSummarization(
         return r.result;
       case "auth":
       case "transient":
-        notifyError(r.message);
+        notifyFailure(r);
         return null;
       case "unusable":
         return null;
@@ -250,14 +311,14 @@ async function runSummarization(
       else emit(controller.onFallbackSuccess());
       return r.result;
     case "auth":
-      notifyError(r.message); // auth never trips the controller
+      notifyFailure(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();
-        notifyError(r.message);
+        notifyFailure(r);
         return null;
       }
       // target was primary (initial detection or probe): retry once on the session model.
@@ -267,7 +328,7 @@ async function runSummarization(
         return r2.result; // suppress the legacy error notify — fallback rescued the call
       }
       controller.onBothDown();
-      notifyError(r2.kind === "transient" || r2.kind === "auth" ? r2.message : r.message);
+      notifyFailure(r2.kind === "transient" || r2.kind === "auth" ? r2 : r);
       return null;
     }
   }

package/src/types.ts

@@ -78,6 +78,10 @@ export const CUSTOM_TYPE_DEDUP_ALIAS = "context-prune-dedup-alias";
  */
 export const CUSTOM_TYPE_CHAIN = "context-prune-chain";
 
+/** The registered name of the recovery tool (src/query-tool.ts). Shared so the
+ * grace checks in pruner.ts / chain-compressor.ts cannot drift from registration. */
+export const QUERY_TOOL_NAME = "context_tree_query";
+
 /** pi.events channel for cross-extension cost contributions (an aggregator like pi-subagents folds these into one total). */
 export const EXTERNAL_COST_CHANNEL = "cost:external";
 
@@ -185,6 +189,43 @@ export const MIN_BATCH_CHARS_PRESETS: { value: string; label: string }[] = [
   { value: "5000", label: "5000" },
 ];
 
+/**
+ * Cycling presets for the `recoveryGraceTurns` setting in the SettingsList.
+ * Stored as strings; converted to number when applied. "0" disables the grace
+ * (recovery output stubs immediately, pre-feature behavior).
+ */
+export const RECOVERY_GRACE_PRESETS: { value: string; label: string }[] = [
+  { value: "0", label: "0 (disabled)" },
+  { value: "1", label: "1" },
+  { value: "3", label: "3 (default)" },
+  { value: "5", label: "5" },
+  { value: "8", label: "8" },
+];
+
+/**
+ * Cycling presets for `summarizerIdleTimeoutMs` (stored as strings; the
+ * settings UI cycles string values). "0" is the disabling sentinel.
+ */
+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: "90000", label: "90s" },
+];
+
+/**
+ * Cycling presets for `summarizerMaxTimeoutMs` (stored as strings). "0" is
+ * the disabling sentinel - no total-duration ceiling.
+ */
+export const SUMMARIZER_MAX_TIMEOUT_PRESETS: { value: string; label: string }[] = [
+  { value: "0", label: "0 (disabled)" },
+  { value: "120000", label: "120s" },
+  { value: "180000", label: "180s (default)" },
+  { value: "300000", label: "300s" },
+  { value: "600000", label: "600s" },
+];
+
 /**
  * Cycling presets for the `autoBudgetThreshold` setting (stored as strings;
  * the settings UI cycles string values). "0" is the disabled sentinel → null.
@@ -256,6 +297,29 @@ export interface ContextPruneConfig {
    * Default: 1000.
    */
   minBatchChars: number;
+  /**
+   * User-turn-groups a `context_tree_query` (recovery) output stays verbatim in
+   * context after recovery, before it reverts to the normal stub. Bounds the
+   * retrieve->re-stub->re-query loop without permanent retention. 0 disables
+   * (recovery output stubs immediately). Enforced at render time in pruner.ts
+   * (Phase 1) and chain-compressor.ts (eligibility), not at capture.
+   */
+  recoveryGraceTurns: number;
+  /**
+   * Idle (inactivity) timeout for a single summarizer stream call, in ms.
+   * 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.
+   */
+  summarizerIdleTimeoutMs: number;
+  /**
+   * Total-duration ceiling for a single summarizer stream call, in ms. Armed
+   * once at call start, never reset - a hard upper bound catching a stream
+   * that keeps dribbling events but never completes. Same transient/warning
+   * handling as the idle timeout. 0 disables the ceiling. Default 180000.
+   */
+  summarizerMaxTimeoutMs: number;
   /**
    * Tool names whose outputs must NEVER be pruned or summarized. Tool calls
    * with matching `toolName` are filtered out of the pruning capture path so
@@ -454,6 +518,9 @@ export const DEFAULT_CONFIG: ContextPruneConfig = {
   batchingMode: "turn",
   quietOversizedSkips: false,
   minBatchChars: 1000,
+  recoveryGraceTurns: 3,
+  summarizerIdleTimeoutMs: 20000,
+  summarizerMaxTimeoutMs: 180000,
   protectedTools: [],
   protectedPaths: ["**/skills/**/*.md"],
   chainCompression: {