pi-condense 2.12.0 → 2.13.1

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

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"],