pi-condense 2.11.5 → 2.13.0

package/src/summarizer.test.ts

@@ -1,25 +1,21 @@
-import { describe, it, expect, mock } from "bun:test";
-import * as actualCompat from "@earendil-works/pi-ai/compat";
+import { describe, it, expect } from "bun:test";
 
 let seenInput: any;
-mock.module("@earendil-works/pi-ai/compat", () => ({
-  ...actualCompat,
-  stream: (_model: any, input: any) => {
-    seenInput = input;
-    return {
-      async *[Symbol.asyncIterator]() {},
-      async result() {
-        return {
-          stopReason: "stop",
-          content: [{ type: "text", text: "- summary" }],
-          usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-        };
-      },
-    };
-  },
-}));
+function captureStream(_model: any, input: any) {
+  seenInput = input;
+  return {
+    async *[Symbol.asyncIterator]() {},
+    async result() {
+      return {
+        stopReason: "stop",
+        content: [{ type: "text", text: "- summary" }],
+        usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+      };
+    },
+  };
+}
 
-const { isUsableSummary, summarizeBatch } = await import("./summarizer.js");
+const { isUsableSummary, summarizeBatch, summarizerThinkingOptions } = await import("./summarizer.js");
 const { DEFAULT_CONFIG } = await import("./types.js");
 
 describe("isUsableSummary", () => {
@@ -37,6 +33,18 @@ describe("isUsableSummary", () => {
   });
 });
 
+describe("summarizerThinkingOptions", () => {
+  it("omits reasoning for default and off", () => {
+    expect(summarizerThinkingOptions({ ...DEFAULT_CONFIG, summarizerThinking: "default" })).toEqual({});
+    expect(summarizerThinkingOptions({ ...DEFAULT_CONFIG, summarizerThinking: "off" })).toEqual({});
+  });
+  it("forwards every other level as reasoning", () => {
+    for (const level of ["minimal", "low", "medium", "high", "xhigh"] as const) {
+      expect(summarizerThinkingOptions({ ...DEFAULT_CONFIG, summarizerThinking: level })).toEqual({ reasoning: level });
+    }
+  });
+});
+
 describe("summarizer prompt", () => {
   it("tells the model that an image marker is an image it cannot see", async () => {
     const model = { id: "m", provider: "p", name: "M" };
@@ -45,7 +53,7 @@ describe("summarizer prompt", () => {
       modelRegistry: {
         find: () => model,
         getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
-        getProviderAuth: async () => undefined,
+        streamSimple: captureStream,
       },
       ui: { notify() {} },
     } as any;
@@ -66,7 +74,7 @@ describe("summarizer prompt", () => {
       modelRegistry: {
         find: () => model,
         getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
-        getProviderAuth: async () => undefined,
+        streamSimple: captureStream,
       },
       ui: { notify() {} },
     } as any;

package/src/summarizer.ts

@@ -1,5 +1,4 @@
-import { stream } from "@earendil-works/pi-ai/compat";
-import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { AssistantMessage, ThinkingLevel } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type {
   CapturedBatch,
@@ -32,17 +31,14 @@ const RANGE_SYSTEM_PROMPT = `You are fusing several per-step summaries of one CL
 - Keep any reference tokens like \`t12\` or \`b3\` intact.
 - Be concise: a short narrative or a few grouped bullets, not one bullet per step.`;
 
-export function summarizerThinkingOptions(config: ContextPruneConfig): Record<string, unknown> {
-  const level: SummarizerThinking = config.summarizerThinking;
-  if (level === "default") {
-    return {};
-  }
+// Pi does not export isVirtualModel.
+const VIRTUAL_MODEL_API = "pi-virtual";
 
-  // stream()/complete() accept provider-level options. For reasoning-capable providers,
-  // pi-ai adapters translate reasoningEffort into the provider-specific field.
-  // "off" intentionally sends no effort; adapters that support explicit disable
-  // handle that the same way as an absent effort, while preserving compatibility.
-  return { reasoningEffort: level === "off" ? undefined : level };
+/** "off" is not a ThinkingLevel; omitting the option is how pi-ai and Pi's own compaction express it. */
+export function summarizerThinkingOptions(config: ContextPruneConfig): { reasoning?: ThinkingLevel } {
+  const level: SummarizerThinking = config.summarizerThinking;
+  if (level === "default" || level === "off") return {};
+  return { reasoning: level };
 }
 
 /**
@@ -110,11 +106,23 @@ function combineSignals(...signals: (AbortSignal | undefined)[]): AbortSignal |
   return AbortSignal.any(present); // Node 20+; host runtime is node 24.5.0
 }
 
+// Virtual routing can ignore the signal, so cancellation must end our wait
+// without depending on the underlying stream settling.
+function untilAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(new Error("summarize: aborted"));
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(new Error("summarize: aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+
 /**
  * One summarization attempt against a specific model. Returns a classified
  * outcome instead of throwing (except aborts, which propagate so flushPending
- * can restore state). Auth failure is detected pre-stream and never reaches
- * the fallback path. `unusable` = empty or length-truncated. Everything else
+ * can restore state). Physical-model auth failure is detected pre-stream and never
+ * reaches the fallback path; virtual models skip the pre-check. `unusable` = empty or length-truncated. Everything else
  * that reaches the catch is `transient` (the outage bucket) — pi-ai surfaces
  * no structured status code on the throw, so classification is coarse by design.
  */
@@ -149,25 +157,21 @@ async function runOnce(
       : `summarizer ${modelLabel(model)} stalled (no output for ${Math.round(idleMs / 1000)}s)`;
 
   try {
-    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-    if (!auth.ok) {
-      const authMessage = "error" in auth ? auth.error : "authentication failed";
-      return { kind: "auth", message: authMessage };
+    // Preserve auth classification for physical models without pre-checking
+    // a virtual model's provider instead of its routed physical target.
+    if (model.api !== VIRTUAL_MODEL_API) {
+      const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+      if (!auth.ok) {
+        const authMessage = "error" in auth ? auth.error : "authentication failed";
+        return { kind: "auth", message: authMessage };
+      }
     }
 
-    // Mirror the main loop (model-runtime stream): auth resolution can carry a
-    // seat-specific baseUrl (e.g. GitHub Copilot business/enterprise endpoints).
-    // The shipped model data pins the individual host, which 421s other seats,
-    // so the resolved auth baseUrl must win over the static model baseUrl.
-    const providerAuth = await ctx.modelRegistry.getProviderAuth(model.provider);
-    const effectiveModel = providerAuth?.auth.baseUrl
-      ? { ...model, baseUrl: providerAuth.auth.baseUrl }
-      : model;
-
     // 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(
-      effectiveModel,
+    const signal = combineSignals(options.signal, timeoutController.signal);
+    const responseStream = ctx.modelRegistry.streamSimple(
+      model,
       {
         messages: [
           {
@@ -178,9 +182,7 @@ async function runOnce(
         ],
       },
       {
-        apiKey: auth.apiKey,
-        headers: auth.headers,
-        signal: combineSignals(options.signal, timeoutController.signal),
+        signal,
         ...summarizerThinkingOptions(config),
       }
     );
@@ -206,8 +208,12 @@ async function runOnce(
       }
     };
 
-    for await (const event of responseStream) {
-      // Reset idle on ANY event (text_* and thinking_*), not just text — a
+    const events = responseStream[Symbol.asyncIterator]();
+    while (true) {
+      const next = await untilAbort(events.next(), signal);
+      if (next.done) break;
+      const event = next.value;
+      // 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();
@@ -222,7 +228,7 @@ async function runOnce(
     // flushPending can detect it and restore batches.
     if (options.signal?.aborted) throw new Error("summarize: aborted during stream");
 
-    const response = await responseStream.result();
+    const response = await untilAbort(responseStream.result(), signal);
     reportTextProgress(response);
     // stopReason "aborted" means the provider cut the stream short (e.g. signal
     // fired just before the final chunk). Treat identically to the signal check

package/src/supersede.test.ts

@@ -7,9 +7,9 @@ import {
   findSuperseded,
   lowerFloor,
   supersededStub,
-  type SupersedeState,
 } from "./supersede.js";
 import { isProtected } from "./protected.js";
+import { expectNoOrphanToolResults } from "./test-support.js";
 import { occKey } from "./occurrence-key.js";
 
 const cfg = { protectedTools: ["phase_tracker"], protectedPaths: ["**/skills/**/*.md"] };
@@ -42,9 +42,15 @@ describe("findSuperseded", () => {
     expect(findSuperseded(msgs, prot).map((c) => c.toolCallId)).toEqual(["a", "b"]);
   });
 
-  test("different offset/limit slices of one path -> older is a candidate", () => {
+  test("different offset/limit slices of one path -> neither is a candidate", () => {
     const msgs = [...call("a", 10, { path: SKILL, offset: 1, limit: 400 }), ...call("b", 20, { path: SKILL, offset: 400, limit: 50 })];
-    expect(findSuperseded(msgs, prot).map((c) => c.toolCallId)).toEqual(["a"]);
+    expectNoOrphanToolResults(msgs);
+    expect(findSuperseded(msgs, prot)).toEqual([]);
+    const state = createSupersedeState();
+    state.floor = 0;
+    const out = applySupersede(msgs, state, prot);
+    expect(out).toBe(msgs);
+    expectNoOrphanToolResults(out);
   });
 
   test("two paths interleaved -> per-path winners and candidates", () => {
@@ -153,6 +159,70 @@ describe("findSuperseded", () => {
   });
 });
 
+type RangeRead = { offset?: unknown; limit?: unknown; cap?: string; text?: string; path?: string };
+const oversizedLine = `[Line 1 is 61.2KB, exceeds 50.0KB limit. Use bash: sed -n '1p' ${SKILL} | head -c 51200]`;
+const cap1800 = "[Showing lines 1-1800 of 3000 (50.0KB limit). Use offset=1801 to continue.]";
+const cap2000 = "[Showing lines 1-2000 of 3000. Use offset=2001 to continue.]";
+
+describe("delivered range coverage", () => {
+  const cases: [string, RangeRead[], string[]][] = [
+    ["full/full", [{}, {}], ["r0"]],
+    ["tail then oversized-first-line warning", [{ offset: 2001 }, { text: oversizedLine }], []],
+    ["oversized-first-line warning then full", [{ text: oversizedLine }, {}], ["r0"]],
+    ["disjoint chunks", [{ limit: 2000 }, { offset: 2001 }], []],
+    ["chunk then capped full", [{ limit: 2000 }, { cap: cap2000 }], ["r0"]],
+    ["tail then capped full", [{ offset: 2001, limit: 1000 }, { cap: cap2000 }], []],
+    ["full then chunk", [{}, { limit: 50 }], []],
+    ["chunk1/chunk2/chunk1", [{ limit: 2000 }, { offset: 2001 }, { limit: 2000 }], ["r0"]],
+    ["equal capped full reads", [{ cap: cap2000 }, { cap: cap2000 }], ["r0"]],
+    ["byte-capped limit then capped full", [{ limit: 2500, cap: cap1800 }, { cap: cap2000 }], ["r0"]],
+    ["capped full then byte-capped limit", [{ cap: cap2000 }, { limit: 2500, cap: cap1800 }], []],
+    ["zero offset", [{ offset: 0, limit: 100 }, {}], ["r0"]],
+    ["null offset full then chunk", [{ offset: null }, { limit: 50 }], []],
+    ["null offset limited", [{ limit: 50 }, { offset: null, limit: 50 }], ["r0"]],
+    ["negative offset", [{ offset: -10, limit: 50 }, { limit: 50 }], ["r0"]],
+    ["null limit is open", [{ limit: null }, { limit: 50 }], []],
+    ["string values are open", [{ offset: "2001", limit: "50" }, { limit: 50 }], []],
+    ["later string values cover full", [{}, { offset: "2001", limit: "50" }], ["r0"]],
+    ["later null limit covers full", [{}, { limit: null }], ["r0"]],
+    ["zero limit covers nothing", [{ limit: 50 }, { limit: 0 }], []],
+    ["negative limit covers nothing", [{ limit: 50 }, { limit: -1 }], []],
+    ["empty cannot cover empty", [{ limit: 0 }, { limit: -1 }], []],
+    ["nonempty covers empty", [{ offset: 2001, limit: 0 }, { limit: 50 }], ["r0"]],
+    ["partial overlap", [{ offset: 10, limit: 50 }, { offset: 20, limit: 50 }], []],
+    ["equal end with earlier start", [{ offset: 10, limit: 41 }, { limit: 50 }], ["r0"]],
+    ["different paths", [{ limit: 50 }, { path: OTHER }], []],
+    ["intermediate covering read", [{ limit: 50 }, { limit: 100 }, { offset: 2001 }], ["r0"]],
+    ["offset byte cap", [{ offset: 1001, limit: 2500, cap: "[Showing lines 1001-2800 of 4000 (50.0KB limit). Use offset=2801 to continue.]" }, { offset: 1001, limit: 1800 }], ["r0"]],
+    ["ordinary continuation keeps limit", [{ limit: 50, cap: "[2950 more lines in file. Use offset=51 to continue.]" }, { limit: 50 }], ["r0"]],
+    ["nonterminal notice is body text", [{ cap: cap2000 + "\nmore body" }, { limit: 2000 }], []],
+  ];
+
+  test.each(cases)("%s", (_name, reads, expected) => {
+    const msgs = reads.flatMap(({ cap, text, ...args }, i) => {
+      const pair = call(`r${i}`, i * 10, { path: SKILL, ...args });
+      if (text) pair[1].content[0].text = text;
+      if (cap) pair[1].content[0].text += `\n\n${cap}`;
+      return pair;
+    });
+    expectNoOrphanToolResults(msgs);
+    expect(findSuperseded(msgs, prot).map((c) => c.toolCallId)).toEqual(expected);
+    const state = createSupersedeState();
+    expect(applySupersede(msgs, state, prot)).toBe(msgs);
+    state.floor = 0;
+    const out = applySupersede(msgs, state, prot);
+    expectNoOrphanToolResults(out);
+    if (expected.length === 0) expect(out).toBe(msgs);
+    for (let i = 0; i < reads.length; i++) {
+      if (expected.includes(`r${i}`)) expect(out[i * 2 + 1].content[0].text).toBe(supersededStub(SKILL));
+      else expect(out[i * 2 + 1]).toBe(msgs[i * 2 + 1]);
+    }
+    const sticky = applySupersede(msgs, state, prot);
+    expect(sticky).toEqual(out);
+    expectNoOrphanToolResults(sticky);
+  });
+});
+
 describe("floor helpers", () => {
   test("lowerFloor sets when undefined, lowers monotonically, ignores undefined input", () => {
     const s = createSupersedeState();

package/src/supersede.ts

@@ -1,11 +1,7 @@
 import { normalizePath } from "./protected.js";
 import { occKey, resultTimestampOf } from "./occurrence-key.js";
 
-/**
- * Protected reads are never indexed, so nothing else in the pipeline ever
- * collapses a re-read of the same skill file. This module keeps only the
- * newest protected read per `args.path` verbatim (spec 2026-09-07).
- */
+/** Protected reads stay verbatim until a later same-path read covers their delivered lines. */
 export interface SupersededCandidate {
   toolCallId: string;
   path: string;
@@ -49,11 +45,34 @@ export function supersededStub(path: string): string {
 
 export type IsProtectedFn = (toolName: string, args: unknown) => boolean;
 
+interface DeliveredRange {
+  start: number;
+  end: number;
+}
+
+function deliveredRange(args: Record<string, unknown>, result: any): DeliveredRange {
+  const start = typeof args.offset === "number" ? Math.max(1, args.offset) : 1;
+  const limit = args.limit;
+  let end = typeof limit === "number" ? (limit <= 0 ? start - 1 : start + limit - 1) : Infinity;
+  for (const block of result.content ?? []) {
+    if (block?.type !== "text" || typeof block.text !== "string") continue;
+    if (/^\[Line \d+ is [^,]+, exceeds [^ ]+ limit\. Use bash: .*\]$/.test(block.text)) return { start, end: start - 1 };
+    const cap = block.text.match(/(?:^|\n)\[Showing lines \d+-(\d+) of \d+(?: \([^)]*limit\))?\. Use offset=\d+ to continue\.\]$/);
+    if (cap) end = Math.min(end, Number(cap[1]));
+  }
+  return { start, end };
+}
+
+function covers(later: DeliveredRange, earlier: DeliveredRange): boolean {
+  if (later.end < later.start) return false;
+  return earlier.end < earlier.start || (later.start <= earlier.start && later.end >= earlier.end);
+}
+
 export function findSuperseded(messages: any[], isProtected: IsProtectedFn): SupersededCandidate[] {
   // Provider ids repeat across turns and an aborted call has no result, so pairing
   // uses the same per-turn open-set model as orphan-sweep, not a global per-id cursor.
   let open = new Map<string, any>();
-  const byPath = new Map<string, SupersededCandidate[]>();
+  const byPath = new Map<string, { candidate: SupersededCandidate; range: DeliveredRange }[]>();
 
   for (let i = 0; i < messages.length; i++) {
     const m = messages[i];
@@ -77,16 +96,25 @@ export function findSuperseded(messages: any[], isProtected: IsProtectedFn): Sup
         timestamp: resultTimestampOf(m.timestamp),
         resultIndex: i,
       };
+      const occurrence = { candidate: cand, range: deliveredRange(args, m) };
       const list = byPath.get(path);
-      if (list) list.push(cand);
-      else byPath.set(path, [cand]);
+      if (list) list.push(occurrence);
+      else byPath.set(path, [occurrence]);
       continue;
     }
     open = new Map();
   }
 
   const out: SupersededCandidate[] = [];
-  for (const list of byPath.values()) for (let i = 0; i < list.length - 1; i++) out.push(list[i]);
+  for (const list of byPath.values()) {
+    for (let i = 0; i < list.length - 1; i++) {
+      for (let j = i + 1; j < list.length; j++) {
+        if (!covers(list[j].range, list[i].range)) continue;
+        out.push(list[i].candidate);
+        break;
+      }
+    }
+  }
   out.sort((a, b) => a.resultIndex - b.resultIndex);
   return out;
 }