pi-condense 2.9.2 → 2.10.1

package/src/chain-range-prune.test.ts

@@ -559,6 +559,35 @@ describe("applyChainCompressions", () => {
     expect(synthetic.content[0].text).not.toContain("<protected-output");
   });
 
+  test("custom-anchored range: drops interior and relocates protected output, same as the user-anchored equivalent", () => {
+    const e = {
+      blockId: "b1",
+      startUserTimestamp: 1,
+      droppedToolCallIds: ["tc-read", "tc-todo"],
+      protectedToolCallIds: ["tc-todo"],
+      finalAssistantTimestamp: 9,
+      toolRefs: ["t1", "t2"],
+      compressedAt: 100,
+    };
+    const messages = [
+      { role: "custom", customType: "pi-gauntlet-transition-recovery", timestamp: 1 },
+      { role: "assistant", timestamp: 2, content: [
+        { type: "toolCall", id: "tc-read", name: "read" },
+        { type: "toolCall", id: "tc-todo", name: "todowrite" },
+      ] },
+      { role: "toolResult", toolCallId: "tc-read", toolName: "read", content: [{ type: "text", text: "FILE" }] },
+      { role: "toolResult", toolCallId: "tc-todo", toolName: "todowrite", content: [{ type: "text", text: "PLAN-STATE" }] },
+      { role: "assistant", timestamp: 9, content: [{ type: "text", text: "done" }] },
+    ];
+    const out = applyChainCompressions(messages, [e] as any, () => "SUMMARY", false);
+    expect(out.find((m: any) => m.role === "toolResult" && m.toolCallId === "tc-todo")).toBeUndefined();
+    expect(out.find((m: any) => m.role === "assistant" && m.timestamp === 2)).toBeUndefined();
+    const synthetic = out.find((m: any) => typeof m.content?.[0]?.text === "string" && m.content[0].text.startsWith("<compressed-chain"));
+    expect(synthetic.content[0].text).toContain('<protected-output tool="todowrite">');
+    expect(synthetic.content[0].text).toContain("PLAN-STATE");
+    expect(synthetic.content[0].text).not.toContain("FILE");
+  });
+
   test("blockSummaryLookup: missing lookup leaves placeholder literal", () => {
     const msgs = [
       userMsg(100),
@@ -636,6 +665,60 @@ describe("resolveRange", () => {
     const range = resolveRange({ startUserTimestamp: 100, finalAssistantTimestamp: 200 }, messages);
     expect(range).toEqual({ startIndex: 0, endIndex: 1 });
   });
+
+  function customAnchor(timestamp: number, customType = "pi-gauntlet-transition-recovery"): any {
+    return { role: "custom", customType, timestamp };
+  }
+
+  test("resolves when the start anchor is an eligible non-pruner custom message", () => {
+    const messages = [
+      customAnchor(100),
+      assistantWithTools(200, ["tc1"]),
+      toolResult(300, "tc1"),
+      assistantText(400),
+    ];
+    const range = resolveRange(entry({ startUserTimestamp: 100, finalAssistantTimestamp: 400 }), messages);
+    expect(range).toEqual({ startIndex: 0, endIndex: 3 });
+  });
+
+  test("returns null when a user message and an eligible custom message collide at the same start timestamp", () => {
+    const messages = [
+      { role: "user", content: [{ type: "text", text: "go" }], timestamp: 100 },
+      customAnchor(100),
+      assistantWithTools(200, ["tc1"]),
+      toolResult(300, "tc1"),
+      assistantText(400),
+    ];
+    const range = resolveRange(entry({ startUserTimestamp: 100, finalAssistantTimestamp: 400 }), messages);
+    expect(range).toBeNull();
+  });
+
+  test("returns null when two eligible custom messages share the start timestamp", () => {
+    const messages = [
+      customAnchor(100),
+      customAnchor(100, "other-extension"),
+      assistantWithTools(200, ["tc1"]),
+      toolResult(300, "tc1"),
+      assistantText(400),
+    ];
+    const range = resolveRange(entry({ startUserTimestamp: 100, finalAssistantTimestamp: 400 }), messages);
+    expect(range).toBeNull();
+  });
+
+  test("user-anchored resolution is unaffected by the custom-anchor widening (regression pin)", () => {
+    expect(resolveRange(entry(), base())).toEqual({ startIndex: 0, endIndex: 3 });
+  });
+
+  test("a context-prune-summary custom at the start timestamp does not count as a start match", () => {
+    const messages = [
+      summaryMsg(100, ["tc0"]),
+      assistantWithTools(200, ["tc1"]),
+      toolResult(300, "tc1"),
+      assistantText(400),
+    ];
+    const range = resolveRange(entry({ startUserTimestamp: 100, finalAssistantTimestamp: 400 }), messages);
+    expect(range).toBeNull();
+  });
 });
 
 describe("applyChainCompressions - positional", () => {

package/src/chain-range-prune.ts

@@ -3,6 +3,7 @@ import { CUSTOM_TYPE_SUMMARY } from "./types.js";
 import type { ChainCompressionEntry } from "./types.js";
 import { substituteBlockRefs } from "./nested-placeholders.js";
 import { extractToolResultText } from "./batch-capture.js";
+import { isChainAnchorCustom } from "./chain-detector.js";
 import { bareToolCallId, occKey, resultTimestampOf } from "./occurrence-key.js";
 import type { DiagnosticSink } from "./diagnostics.js";
 
@@ -68,11 +69,12 @@ export function buildSyntheticChainMessage(
 /**
  * Resolves a persisted chain entry to a positional index range.
  *
- * Role-gated and unique-match-or-nothing: exactly one user message at
+ * Role-gated and unique-match-or-nothing: exactly one start anchor (user
+ * message or eligible non-pruner custom, isChainAnchorCustom) at
  * startUserTimestamp, exactly one assistant at finalAssistantTimestamp, and
- * start < end. Otherwise null - the entry drops nothing. Fail-closed is the
- * whole point: an id-set or timestamp-window fallback is what deleted live
- * turns (doc/specs/2026-08-12-toolcall-id-collisions.md).
+ * startIndex < endIndex. Otherwise null - the entry drops nothing. Fail-closed
+ * is the whole point: an id-set or timestamp-window fallback is what deleted
+ * live turns (doc/specs/2026-08-12-toolcall-id-collisions.md).
  */
 export function resolveRange(
   entry: Pick<ChainCompressionEntry, "startUserTimestamp" | "finalAssistantTimestamp">,
@@ -85,7 +87,7 @@ export function resolveRange(
   let endMatches = 0;
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
-    if (msg.role === "user" && msg.timestamp === entry.startUserTimestamp) {
+    if ((msg.role === "user" || isChainAnchorCustom(msg)) && msg.timestamp === entry.startUserTimestamp) {
       startMatches++;
       if (startIndex < 0) startIndex = i;
     } else if (msg.role === "assistant" && msg.timestamp === entry.finalAssistantTimestamp) {

package/src/config.test.ts

@@ -125,3 +125,25 @@ describe("loadConfig backward compatibility with removed thinkingStrip key", ()
     expect(written.contextPrune.thinkingStrip).toEqual(stale);
   });
 });
+
+describe("loadConfig frontierGapThresholdTokens normalization", () => {
+  it("defaults to null when unset", async () => {
+    await writeContextPrune({});
+    const config = await loadConfig();
+    expect(config.frontierGapThresholdTokens).toBeNull();
+  });
+
+  it("floors a fractional value", async () => {
+    await writeContextPrune({ frontierGapThresholdTokens: 80000.7 });
+    const config = await loadConfig();
+    expect(config.frontierGapThresholdTokens).toBe(80000);
+  });
+
+  it("falls back to null for 0, negative, Infinity, or a string", async () => {
+    for (const value of [0, -5, Infinity, "80000"]) {
+      await writeContextPrune({ frontierGapThresholdTokens: value });
+      const config = await loadConfig();
+      expect(config.frontierGapThresholdTokens).toBeNull();
+    }
+  });
+});

package/src/config.ts

@@ -106,6 +106,12 @@ function normalize(existing: Partial<ContextPruneConfig>): ContextPruneConfig {
       merged.budgetTurnDelta <= 1
         ? merged.budgetTurnDelta
         : DEFAULT_CONFIG.budgetTurnDelta,
+    frontierGapThresholdTokens:
+      typeof merged.frontierGapThresholdTokens === "number" &&
+      Number.isFinite(merged.frontierGapThresholdTokens) &&
+      merged.frontierGapThresholdTokens > 0
+        ? Math.floor(merged.frontierGapThresholdTokens)
+        : DEFAULT_CONFIG.frontierGapThresholdTokens,
   };
 }
 

package/src/context-metrics.test.ts

@@ -170,11 +170,11 @@ describe("computeContextMetrics", () => {
     expect(openSegmentChars).toBeGreaterThan(chainChars);
   });
 
-  test("largestChainSharePct: a projected custom_message entry (role \"custom\") counts toward the denominator only, never the chain numerator", () => {
+  test("largestChainSharePct: a pruner custom message (customType starting with context-prune-) counts toward the denominator only, never the chain numerator", () => {
     // Mirrors index.ts's branch projection for persisted summary custom_message
-    // entries: role "custom" never matches the user/assistant/toolResult roles
-    // detectChains and isTextOnlyAssistant key off, so it cannot join a chain
-    // or the open segment -- it only inflates totalChars (the denominator).
+    // entries: a pruner customType (context-prune-summary) is excluded from
+    // chain anchoring by isChainAnchorCustom, so it cannot join a chain or the
+    // open segment -- it only inflates totalChars (the denominator).
     // The customEntry sits between two final text-only assistant messages, so
     // it lands outside both the chain range and the open-cycle segment --
     // isolating the denominator effect from any open-segment interaction.
@@ -184,7 +184,7 @@ describe("computeContextMetrics", () => {
       toolResult(300, "tc1", "bash", "x".repeat(2000)),
       assistantText(400),
     ];
-    const customEntry = { role: "custom", customType: "pi-condense:summary", content: "s".repeat(3000), display: true, timestamp: 450 };
+    const customEntry = { role: "custom", customType: "context-prune-summary", content: "s".repeat(3000), display: true, timestamp: 450 };
     const closer = assistantText(500, "ok");
 
     const withoutCustom = computeContextMetrics(chainMsgs, null, noSummarized, noProtected);
@@ -199,6 +199,36 @@ describe("computeContextMetrics", () => {
     expect(withCustom.largestChainSharePct).toBeLessThan(withoutCustom.largestChainSharePct);
   });
 
+  test("largestChainSharePct: a custom-anchored chain (eligible non-pruner custom message opens a chain) is counted in the numerator", () => {
+    // Mirrors the user-anchored share test's arithmetic, but the chain start
+    // is an eligible custom message (isChainAnchorCustom) instead of a user
+    // message -- Wave 1's chain-detector already opens chains on these; this
+    // pins that computeContextMetrics' chain-start lookup finds them too.
+    const customAnchor = {
+      role: "custom",
+      customType: "pi-gauntlet-transition-recovery",
+      content: "resuming",
+      timestamp: 100,
+    };
+    const msgs = [
+      customAnchor,
+      assistantWithTools(200, ["tc1"]),
+      toolResult(300, "tc1", "bash", "x".repeat(2000)), // big closed chain
+      assistantText(400),
+      userMsg(500),
+      assistantText(600), // tiny open segment (empty, since it's the last text-only assistant)
+    ];
+    const chars = msgs.map((m) => JSON.stringify(m).length);
+    const totalChars = chars.reduce((a, b) => a + b, 0);
+    const chainChars = chars[0] + chars[1] + chars[2] + chars[3]; // customAnchor..assistantText(400)
+    const openSegmentChars = 0; // last text-only assistant is msgs[5] itself; open segment is empty
+    const expectedPct = Math.round((100 * Math.max(chainChars, openSegmentChars)) / totalChars);
+
+    const result = computeContextMetrics(msgs, null, noSummarized, noProtected);
+    expect(result.largestChainSharePct).toBe(expectedPct);
+    expect(chainChars).toBeGreaterThan(openSegmentChars);
+  });
+
   test("largestChainSharePct: interrupted chain (null finalAssistantTimestamp) is counted", () => {
     const msgs = [
       userMsg(100),

package/src/context-metrics.ts

@@ -1,4 +1,4 @@
-import { detectChains } from "./chain-detector.js";
+import { detectChains, isChainAnchorCustom } from "./chain-detector.js";
 import { occKey, resultTimestampOf } from "./occurrence-key.js";
 import type { ContextMetricsSnapshot, PruneFrontier } from "./types.js";
 
@@ -75,7 +75,9 @@ export function computeContextMetrics(
   const chains = detectChains(branch, isProtected);
   let largestClosedChainChars = 0;
   for (const range of chains) {
-    const startIdx = branch.findIndex((m) => m.role === "user" && m.timestamp === range.startUserTimestamp);
+    const startIdx = branch.findIndex(
+      (m) => (m.role === "user" || isChainAnchorCustom(m)) && m.timestamp === range.startUserTimestamp,
+    );
     if (startIdx === -1) continue;
     let endIdx: number;
     if (range.finalAssistantTimestamp !== null) {
@@ -85,6 +87,7 @@ export function computeContextMetrics(
       if (endIdx === -1) continue;
     } else {
       let nextUserIdx = -1;
+      // User-only: under idle-only semantics only a user message interrupts an open chain.
       for (let i = startIdx + 1; i < branch.length; i++) {
         if (branch[i].role === "user") {
           nextUserIdx = i;

package/src/oversized-spill.integration.test.ts

@@ -1,8 +1,9 @@
 import { describe, it, expect } from "bun:test";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, basename } from "node:path";
 import { ToolCallIndexer } from "./indexer.js";
+import { occKey } from "./occurrence-key.js";
 import { spillOversizedBatch, blobPathFor } from "./spill.js";
 import { pruneMessages } from "./pruner.js";
 import type { CapturedBatch } from "./types.js";
@@ -75,4 +76,51 @@ describe("oversized spill end-to-end", () => {
       await rm(dir, { recursive: true, force: true });
     }
   });
+
+  it("long-id record survives the backfill -> restart round trip (AC4)", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "spill-e2e-"));
+    try {
+      const indexer = new ToolCallIndexer();
+      const entries: any[] = [];
+      const appendEntry = (customType: string, data?: unknown) => {
+        entries.push({ type: "custom", customType, data });
+      };
+      const longId = "toolu_" + "q".repeat(494); // 500 chars
+      const body = "BACKFILL BODY\n".repeat(200);
+      const rec: any = {
+        toolCallId: longId, toolName: "bash", args: { command: "ls" },
+        resultText: body, isError: false, turnIndex: -1, timestamp: 1000, resultTimestamp: 1000,
+      };
+
+      // 1. backfill write: must not throw (fail-closed path), basename capped
+      await indexer.backfillChainRecords([rec], {
+        spillThreshold: 10, spillPreviewBytes: 16, sessionDir: dir, sessionId: "sid", appendEntry,
+      });
+      expect(rec.spillPath).toBeTruthy();
+      expect(Buffer.byteLength(basename(rec.spillPath), "utf8")).toBeLessThanOrEqual(255);
+
+      // 2. persisted index entry exists (backfilled shape)
+      expect(entries.some((e) => e.customType === CUSTOM_TYPE_INDEX && e.data.backfilled)).toBe(true);
+
+      // 3. restart: fresh indexer reconstructs from persisted entries only
+      const rebuilt = new ToolCallIndexer();
+      rebuilt.reconstructFromSession({ sessionManager: { getBranch: () => entries } } as any);
+      const restored = rebuilt.getRecord(occKey(longId, 1000))!;
+      expect(restored.spillPath).toBe(rec.spillPath);
+
+      // 4. read-back of the restored persisted path equals the original body
+      expect(await readFile(restored.spillPath!, "utf-8")).toBe(body);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("capped names are namespace-disjoint from short-key names", () => {
+    const cappedPath = blobPathFor("/s", "sid", "a".repeat(300));
+    const stem = basename(cappedPath).slice(0, -".txt".length);
+    // sanitizeId can never emit ".", so no short key maps onto a capped name -
+    // even the short key spelled exactly like the capped stem.
+    expect(stem).toContain(".");
+    expect(blobPathFor("/s", "sid", stem)).not.toBe(cappedPath);
+  });
 });