pi-condense 2.9.0 → 2.9.1

package/CHANGELOG.md

@@ -7,6 +7,10 @@ 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.9.1] - 2026-08-18
+
+- **Orphan sweep: any foreign message is now a barrier ([#11](https://github.com/jjuraszek/pi-condense/issues/11)).** `sweepOrphanToolResults` only reset its open-call set on `assistant` messages, while pi-ai flushes synthetic tool results at both `assistant` and `user` boundaries (`convertToLlm` maps `custom`/`branchSummary`/`compactionSummary`/`bashExecution` to `user`). A foreign message spliced between a toolCall and its toolResult (observed: a pi-cohort control notice) let the real result through alongside pi-ai's synthetic - a duplicate `tool_use_id` the provider rejects permanently (Anthropic 400, branch bricked). Now any message that is neither `assistant` nor `toolResult` clears the open set, so the interleaved result is swept and pi-ai's repairable synthetic stands alone; already-broken branches un-brick on the next render. Deliberate conservative over-sweep (unknown roles, `excludeFromContext` bashExecution) - no role allowlist. Test helper `expectNoOrphanToolResults` carries the identical rule. Spec: `doc/specs/2026-08-18-gh-11-orphan-sweep-barrier.md` (partially supersedes the 2026-08-12 spec's section C).
+
 ## [2.9.0] - 2026-08-14
 
 - **Uncovered chains now compress deterministically instead of stranding forever ([#10](https://github.com/jjuraszek/pi-condense/issues/10)).** Chain compression (Phase 3) required per-batch summary coverage; a closed eligible chain whose span produced no summaries (trivial batches, `skipped-oversized`, fully-deduped spans, capture misses) hit a permanent `no-summary` skip - once the prune frontier passed it, nothing could ever reclaim it. The motivating incident left a 639-call, ~935k-char chain (~62% of a 620k window) live in context indefinitely.

package/PRUNING.md

@@ -1096,11 +1096,11 @@ Error purge replaces those arg bodies with compact stubs after the error has coo
 
 ## Orphan Sweep
 
-`pruneMessages` ends with an unconditional structural pass, `sweepOrphanToolResults` (`src/orphan-sweep.ts`): a `toolResult` message whose id was not opened by the immediately preceding assistant turn is removed. It runs after every other phase, over whatever the previous three produced, as a final post-condition rather than a targeted fix for one code path.
+`pruneMessages` ends with an unconditional structural pass, `sweepOrphanToolResults` (`src/orphan-sweep.ts`): a `toolResult` message whose id is not open is removed, where "open" means: opened by the most recent `assistant` message and not interrupted by any barrier since. It runs after every other phase, over whatever the previous three produced, as a final post-condition rather than a targeted fix for one code path.
 
 **Why it exists.** pi-ai's auto-repair (`insertSyntheticToolResults`) only fills in a missing `toolResult` for an orphaned `toolCall` - it has no equivalent repair for the opposite shape, an orphaned `toolResult` with no matching `toolCall`. Providers reject that shape outright (Anthropic: `unexpected tool_use_id found in tool_result blocks`; Kimi K3: a tool message needs a resolvable preceding tool_call). An orphaned `toolResult` can appear from any combination of id reuse, an unresolved chain range, or a bug in an upstream phase; the sweep is the last line of defense regardless of cause, and it is intentionally not keyed to any provider's specific error string - the fix is structural ("does this id have an open call"), not reactive to how one provider happens to phrase rejection.
 
-**Per-turn, not cumulative, open-call tracking.** The sweep does one forward pass over the message array. Each `assistant` message **replaces** the current "open" id set with its own `toolCall` ids; each `toolResult` message either consumes (removes) a matching id from that set or, if its id is not open, is swept. A cumulative seen-set across the whole array would be wrong here: it would let an id used validly by an early turn license a *later* genuine orphan under the same reused id - exactly the collision scenario this exists to catch. Per-turn tracking means only the immediately preceding assistant turn can vouch for a `toolResult`'s id.
+**Per-turn, not cumulative, open-call tracking.** The sweep does one forward pass over the message array. Each `assistant` message **replaces** the current "open" id set with its own `toolCall` ids; each `toolResult` message either consumes (removes) a matching id from that set or, if its id is not open, is swept. Any message that is neither `assistant` nor `toolResult` is a **barrier** that clears the open set. This tracks the post-`convertToLlm` flush points of pi-ai's `insertSyntheticToolResults` - `convertToLlm` maps `custom`, `branchSummary`, `compactionSummary`, and `bashExecution` to `role: "user"`, and pi-ai flushes synthetic tool results at both `assistant` and `user` boundaries - **plus** a deliberate conservative over-sweep: `bashExecution` with `excludeFromContext: true` and unknown roles are dropped by `convertToLlm` and strictly need not be barriers, but a role allowlist would have to track an open interface for zero observed benefit. Not an exact mirror, and not an allowlist. Trade-off: a foreign message spliced mid-cycle now costs one tool output - the interleaved real result is swept and pi-ai injects its repairable `{isError: true, "No result provided"}` synthetic - converting an unrepairable provider shape (duplicate `tool_use_id`, permanent Anthropic 400) into a visible-but-recoverable tool failure. See `doc/specs/2026-08-18-gh-11-orphan-sweep-barrier.md`. A cumulative seen-set across the whole array would be wrong here: it would let an id used validly by an early turn license a *later* genuine orphan under the same reused id - exactly the collision scenario this exists to catch. Per-turn tracking means only the most recent assistant turn, uninterrupted by a barrier, can vouch for a `toolResult`'s id.
 
 **Provider-agnostic and reference-preserving.** The sweep has no knowledge of which provider is in play; it operates purely on message shape. When nothing is swept it returns the **same array reference** it was given, so a clean render is a true no-op and the no-op / prompt-cache-prefix invariant of `doc/specs/2026-08-04-pruner-noop-serialization.md` holds - the sweep never forces a cache bust on a session where nothing is actually orphaned.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.9.0",
+  "version": "2.9.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/chain-range-prune.test.ts

@@ -796,6 +796,13 @@ describe("applyChainCompressions - positional", () => {
         msgs[3] = { ...msgs[3], content: [{ type: "thinking", thinking: "hmm" }, { type: "text", text: "done 1" }] } as any;
         return applyChainCompressions(msgs, entries as any, summaryFor, true);
       }],
+      ["a context-prune-summary after a completed cycle", () => {
+        const msgs = incident();
+        msgs.splice(8, 0, { role: "custom", customType: CUSTOM_TYPE_SUMMARY, content: "batch summary", timestamp: 2250 } as any);
+        const out = applyChainCompressions(msgs, entries as any, summaryFor, false);
+        expect(out.some((m: any) => m.customType === CUSTOM_TYPE_SUMMARY)).toBe(true);
+        return out;
+      }],
       ["skips an entry whose start falls strictly inside another entry's range", () => {
         const wide = { blockId: "b8", startUserTimestamp: 1000, droppedToolCallIds: [], finalAssistantTimestamp: 2200, toolRefs: [], compressedAt: 9002 };
         const nestedInner = { blockId: "b9", startUserTimestamp: 2000, droppedToolCallIds: [], finalAssistantTimestamp: 2200, toolRefs: [], compressedAt: 9003 };

package/src/orphan-sweep.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { sweepOrphanToolResults } from "./orphan-sweep.js";
+import { expectNoOrphanToolResults } from "./test-support.js";
 
 const asst = (ts: number, ids: string[]) => ({
   role: "assistant",
@@ -60,8 +61,47 @@ describe("sweepOrphanToolResults", () => {
     expect(sweepOrphanToolResults(msgs).messages).toBe(msgs);
   });
 
-  test("non-assistant messages between a call and its result do not close the open set", () => {
-    const msgs = [asst(1, ["a"]), { role: "custom", customType: "x", timestamp: 2 }, res(3, "a")];
-    expect(sweepOrphanToolResults(msgs).messages).toBe(msgs);
+  // AC1: any non-assistant/non-toolResult role is a barrier - including an
+  // unknown role, so a role-allowlist implementation cannot pass.
+  const barrierRoles: Array<[string, any]> = [
+    ["custom", { role: "custom", customType: "x", timestamp: 2 }],
+    ["user", user(2)],
+    ["branchSummary", { role: "branchSummary", timestamp: 2 }],
+    ["compactionSummary", { role: "compactionSummary", timestamp: 2 }],
+    ["bashExecution", { role: "bashExecution", timestamp: 2 }],
+    ["unknown future role", { role: "future-role", timestamp: 2 }],
+  ];
+  for (const [name, barrier] of barrierRoles) {
+    test(`a ${name} message between a call and its result is a barrier: the result is swept`, () => {
+      const msgs = [asst(1, ["a"]), barrier, res(3, "a")];
+      const out = sweepOrphanToolResults(msgs);
+      expect(out.sweptIds).toEqual(["a"]);
+      expect(out.messages).toHaveLength(2);
+      expect(out.messages.some((m: any) => m.role === "toolResult")).toBe(false);
+    });
+  }
+
+  // AC2: barrier clears only what is still open; results consumed before it stay.
+  test("multi-call turn: barrier sweeps only the not-yet-consumed result", () => {
+    const msgs = [asst(1, ["a", "b"]), res(2, "a"), { role: "custom", customType: "x", timestamp: 3 }, res(4, "b")];
+    const out = sweepOrphanToolResults(msgs);
+    expect(out.sweptIds).toEqual(["b"]);
+    expect(out.messages).toHaveLength(3);
+  });
+
+  // AC3: a barrier after a completed cycle is untouched - same array reference.
+  test("trailing barrier after a completed cycle is a no-op (same array reference)", () => {
+    const msgs = [asst(1, ["a"]), res(2, "a"), { role: "custom", customType: "x", timestamp: 3 }];
+    const out = sweepOrphanToolResults(msgs);
+    expect(out.messages).toBe(msgs);
+    expect(out.sweptIds).toEqual([]);
+  });
+
+  // AC5: the test helper enforces the same barrier rule (it copies the sweep's
+  // orphan definition; delegation would make sweep tests tautological).
+  test("expectNoOrphanToolResults throws on a mid-cycle barrier orphan and passes on a clean trailing barrier", () => {
+    const bad = [asst(1, ["a"]), { role: "custom", customType: "x", timestamp: 2 }, res(3, "a")];
+    expect(() => expectNoOrphanToolResults(bad)).toThrow();
+    expectNoOrphanToolResults([asst(1, ["a"]), res(2, "a"), { role: "custom", customType: "x", timestamp: 3 }]);
   });
 });

package/src/orphan-sweep.ts

@@ -2,7 +2,9 @@
  * pi-ai repairs orphan tool calls only; providers reject orphan tool results.
  *
  * Open-call tracking is PER TURN: an assistant message replaces the open set
- * with its own toolCall ids. A cumulative seen-set would let an id used
+ * with its own toolCall ids, and any message that is neither assistant nor
+ * toolResult is a barrier that clears it (matching where pi-ai flushes
+ * synthetic tool results). A cumulative seen-set would let an id used
  * validly in an early turn license a later genuine orphan - exactly the
  * id-collision case this exists for.
  *
@@ -32,7 +34,15 @@ export function sweepOrphanToolResults(messages: any[]): { messages: any[]; swep
         orphanIndices.add(i);
         sweptIds.push(msg.toolCallId);
       }
+      continue;
     }
+    // Barrier: any other role converts to a user-boundary at the provider
+    // (convertToLlm maps custom/branchSummary/compactionSummary/bashExecution
+    // to role "user"; pi-ai flushes synthetic tool results there), so a
+    // still-open call can no longer be legally answered after it. Unknown
+    // roles and excludeFromContext bashExecutions are a deliberate
+    // conservative over-sweep - no allowlist.
+    open = new Set();
   }
 
   if (orphanIndices.size === 0) return { messages, sweptIds: [] };

package/src/pruner.ts

@@ -47,10 +47,11 @@ export function sizeMessages(messages: any[]): number {
  * Only runs when `chainCompression.enabled` and chain entries exist.
  *
  * Phase 4 — orphan sweep: structural post-condition run unconditionally over
- * the final array. Removes any toolResult whose matching toolCall id was not
- * opened by the immediately preceding assistant turn (per-turn open set, not
- * cumulative — see src/orphan-sweep.ts). Reference-preserving when nothing is
- * swept, so a clean render still returns the identical input array.
+ * the final array. Removes any toolResult whose matching toolCall id is not
+ * open: opened by the most recent assistant turn and uninterrupted by a
+ * barrier (any non-assistant/non-toolResult message) — see
+ * src/orphan-sweep.ts. Reference-preserving when nothing is swept, so a
+ * clean render still returns the identical input array.
  *
  * Return shape:
  *   - `pruned: true`  — at least one change happened; the returned

package/src/test-support.ts

@@ -12,6 +12,8 @@ export function expectNoOrphanToolResults(messages: any[]): void {
     } else if (m.role === "toolResult") {
       expect(open.has(m.toolCallId)).toBe(true);
       open.delete(m.toolCallId);
+    } else {
+      open = new Set();
     }
   }
 }