pi-condense 2.9.2 → 2.10.0

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/reload-rearm.integration.test.ts

@@ -49,6 +49,18 @@ function okStream() {
   };
 }
 
+// Classified "transient" by runOnce (src/summarizer.ts) — with
+// summarizerModel: "default" (no distinct fallback model) this yields a
+// null SummarizeResult after exactly one stream() call, no retries.
+function errStream(message: string) {
+  return {
+    async *[Symbol.asyncIterator]() {},
+    async result() {
+      return { stopReason: "error", errorMessage: message, content: [], usage: USAGE };
+    },
+  };
+}
+
 let streamImpl: (model: any, input?: any, opts?: any) => any = () => {
   summarizerCalls++;
   return okStream();
@@ -117,6 +129,26 @@ function closedChainBranch(count: number): any[] {
   return msgs;
 }
 
+// Builds one independent pending batch: user -> assistant toolCall -> toolResult,
+// with no closing text-only assistant (chain stays open, matching defaultBranch's
+// shape). Used by the frontier-gap tests below to grow/shrink the branch's
+// un-pruned tail across turns by direct array mutation (bootExtension returns
+// the live `branch` array reference, so pushing onto it after boot is visible
+// to every later getBranch() call).
+function pendingBatchEntries(toolCallId: string, text: string, timestamp: number): any[] {
+  return [
+    { type: "message", message: { role: "user", content: [{ type: "text", text: `do ${toolCallId}` }], timestamp } },
+    {
+      type: "message",
+      message: { role: "assistant", content: [{ type: "toolCall", id: toolCallId, name: "read", arguments: {} }], timestamp: timestamp + 500 },
+    },
+    {
+      type: "message",
+      message: { role: "toolResult", toolCallId, toolName: "read", content: [{ type: "text", text }], timestamp: timestamp + 1000 },
+    },
+  ];
+}
+
 // Boots a fresh index.ts extension instance against an isolated agent dir +
 // session, mirroring the fixtures shared across the three scenarios below.
 //
@@ -137,35 +169,45 @@ function closedChainBranch(count: number): any[] {
 function bootExtension(
   options: {
     chainCompressionEnabled?: boolean;
+    rollingWindow?: number;
     separatePiAppended?: boolean;
     piAppendEntry?: (push: (type: string, data?: unknown) => void) => (type: string, data?: unknown) => void;
     sessionAppendCustomEntry?: (push: (type: string, data?: unknown) => void) => (type: string, data?: unknown) => string;
     branch?: any[];
     protectedTools?: string[];
+    autoBudgetThreshold?: number | null;
+    budgetTurnDelta?: number | null;
+    frontierGapThresholdTokens?: number | null;
   } = {},
 ) {
   const agentDir = mkdtempSync(join(tmpdir(), "pi-condense-rearm-"));
   process.env.PI_CODING_AGENT_DIR = agentDir;
+  const contextPruneSettings: any = {
+    enabled: true,
+    pruneOn: "agent-message",
+    batchingMode: "agent-message",
+    autoBudgetThreshold: options.autoBudgetThreshold === undefined ? 0.5 : options.autoBudgetThreshold,
+    summarizerModel: "default",
+    minBatchChars: 1,
+    showPruneStatusLine: true,
+    protectedTools: options.protectedTools ?? [],
+    chainCompression: {
+      enabled: options.chainCompressionEnabled ?? false,
+      rollingWindow: options.rollingWindow ?? 3,
+      stripFinalAssistantThinking: true,
+      fuseRangeSummary: true,
+    },
+  };
+  // Omitted unless the test explicitly passes them, so the "default-null
+  // inert" scenario can assert behavior with no key present at all (not an
+  // explicit null), matching config.ts's own default.
+  if (options.budgetTurnDelta !== undefined) contextPruneSettings.budgetTurnDelta = options.budgetTurnDelta;
+  if (options.frontierGapThresholdTokens !== undefined) {
+    contextPruneSettings.frontierGapThresholdTokens = options.frontierGapThresholdTokens;
+  }
   writeFileSync(
     join(agentDir, "settings.json"),
-    JSON.stringify({
-      contextPrune: {
-        enabled: true,
-        pruneOn: "agent-message",
-        batchingMode: "agent-message",
-        autoBudgetThreshold: 0.5,
-        summarizerModel: "default",
-        minBatchChars: 1,
-        showPruneStatusLine: true,
-        protectedTools: options.protectedTools ?? [],
-        chainCompression: {
-          enabled: options.chainCompressionEnabled ?? false,
-          rollingWindow: 3,
-          stripFinalAssistantThinking: true,
-          fuseRangeSummary: true,
-        },
-      },
-    }),
+    JSON.stringify({ contextPrune: contextPruneSettings }),
   );
 
   const sessionDir = mkdtempSync(join(tmpdir(), "pi-condense-rearm-session-"));
@@ -577,4 +619,300 @@ describe("reload rearm (issue #6)", () => {
     expect(text).toContain(`chain share:  ${expectedPct}%`);
     expect(expectedPct).toBeLessThan(inflatedPct);
   });
+
+  it("feeds persisted custom_message steers into chain detection via the shared projection (#13)", async () => {
+    // A production-feed regression: chain detection/compaction/metrics must
+    // all see custom_message entries projected as role "custom" (src/batch-
+    // capture.ts projectBranchMessages), not just plain "message" entries.
+    // A non-pruner customType (isChainAnchorCustom) opens a chain while idle
+    // and anchors resolveRange the same way a user message does; a pruner-
+    // namespaced customType (context-prune-*) must NOT anchor one.
+    const t0 = new Date().toISOString();
+    let t = new Date(t0).getTime();
+
+    const customAnchoredChain: any[] = [
+      {
+        type: "custom_message",
+        customType: "pi-gauntlet-transition-recovery",
+        content: [{ type: "text", text: "continue" }],
+        timestamp: t0,
+      },
+      {
+        type: "message",
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc-custom", name: "read", arguments: {} }] },
+      },
+      {
+        type: "message",
+        message: {
+          role: "toolResult",
+          toolCallId: "tc-custom",
+          toolName: "read",
+          content: [{ type: "text", text: "x".repeat(400) }],
+          timestamp: (t += 1000),
+        },
+      },
+      {
+        type: "message",
+        message: { role: "assistant", content: [{ type: "text", text: "done custom" }], timestamp: (t += 1000) },
+      },
+    ];
+
+    // A second closed, user-anchored chain so the custom-anchored chain above
+    // is not the newest/frontier chain (rollingWindow: 0 makes every closed
+    // chain not already compressed eligible regardless, but this mirrors a
+    // realistic multi-turn session and rules out any "only chain" special case).
+    const trailingChain: any[] = [
+      { type: "message", message: { role: "user", content: [{ type: "text", text: "do more" }], timestamp: (t += 1000) } },
+      {
+        type: "message",
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc-trail", name: "read", arguments: {} }] },
+      },
+      {
+        type: "message",
+        message: {
+          role: "toolResult",
+          toolCallId: "tc-trail",
+          toolName: "read",
+          content: [{ type: "text", text: "y".repeat(400) }],
+          timestamp: (t += 1000),
+        },
+      },
+      {
+        type: "message",
+        message: { role: "assistant", content: [{ type: "text", text: "done trailing" }], timestamp: (t += 1000) },
+      },
+    ];
+
+    const branch = [...customAnchoredChain, ...trailingChain];
+
+    const { handlers, ctx, appended } = await boot({ chainCompressionEnabled: true, rollingWindow: 0, branch });
+
+    await handlers.get("session_start")!({}, ctx);
+    await handlers.get("turn_end")!(
+      { toolResults: [], message: { role: "assistant", content: [{ type: "text", text: "hi" }] }, turnIndex: 2 },
+      ctx,
+    );
+    await handlers.get("message_end")!(
+      { message: { role: "assistant", content: [{ type: "text", text: "done" }] } },
+      ctx,
+    );
+
+    const chainEntries = appended.filter((e) => e.type === "context-prune-chain");
+    const anchoredAtCustom = chainEntries.find(
+      (e) => (e.data as any).startUserTimestamp === new Date(t0).getTime(),
+    );
+    expect(anchoredAtCustom).toBeDefined();
+  });
+
+  it("does not let a pruner-namespaced custom_message (context-prune-*) anchor a chain (#13)", async () => {
+    const t0 = new Date().toISOString();
+    let t = new Date(t0).getTime();
+
+    const pruneSummaryEntry: any[] = [
+      {
+        type: "custom_message",
+        customType: "context-prune-summary",
+        content: [{ type: "text", text: "prior summary" }],
+        timestamp: t0,
+      },
+      {
+        type: "message",
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc-p", name: "read", arguments: {} }] },
+      },
+      {
+        type: "message",
+        message: {
+          role: "toolResult",
+          toolCallId: "tc-p",
+          toolName: "read",
+          content: [{ type: "text", text: "x".repeat(400) }],
+          timestamp: (t += 1000),
+        },
+      },
+      {
+        type: "message",
+        message: { role: "assistant", content: [{ type: "text", text: "done p" }], timestamp: (t += 1000) },
+      },
+    ];
+
+    const { handlers, ctx, appended } = await boot({ chainCompressionEnabled: true, rollingWindow: 0, branch: pruneSummaryEntry });
+
+    await handlers.get("session_start")!({}, ctx);
+    await handlers.get("turn_end")!(
+      { toolResults: [], message: { role: "assistant", content: [{ type: "text", text: "hi" }] }, turnIndex: 2 },
+      ctx,
+    );
+    await handlers.get("message_end")!(
+      { message: { role: "assistant", content: [{ type: "text", text: "done" }] } },
+      ctx,
+    );
+
+    const chainEntries = appended.filter((e) => e.type === "context-prune-chain");
+    const anchoredAtSummary = chainEntries.find(
+      (e) => (e.data as any).startUserTimestamp === new Date(t0).getTime(),
+    );
+    expect(anchoredAtSummary).toBeUndefined();
+  });
+
+  it("frontier-gap trigger fires at turn_end when the un-pruned tail exceeds the threshold (#13)", async () => {
+    const { handlers, ctx, notifications, appended } = await boot({
+      autoBudgetThreshold: null,
+      frontierGapThresholdTokens: 10,
+    });
+
+    ctx.getContextUsage = () => ({ tokens: 10, contextWindow: 1000000 });
+
+    await handlers.get("session_start")!({}, ctx);
+
+    // defaultBranch() already carries an unsummarized ~400-char toolResult
+    // (~100 tokens), well past the threshold of 10.
+    await handlers.get("turn_end")!(
+      {
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "read", arguments: {} }] },
+        toolResults: [
+          { role: "toolResult", toolCallId: "tc1", toolName: "read", content: [{ type: "text", text: "x".repeat(400) }], timestamp: Date.now() },
+        ],
+        turnIndex: 2,
+      },
+      ctx,
+    );
+
+    const flushMetricsEntries = appended.filter((e) => e.type === "context-prune-flush-metrics");
+    expect(flushMetricsEntries.length).toBe(1);
+    const fm = flushMetricsEntries[0].data as any;
+    expect(fm.trigger).toBe("frontier-gap");
+    expect(fm.metrics.frontierGapTokens).toBeGreaterThanOrEqual(10);
+
+    expect(notifications.some((n) => n.includes("un-pruned tail exceeded frontier gap threshold"))).toBe(true);
+  });
+
+  it("budget trigger takes precedence over frontier-gap when both conditions are met at turn_end (#13)", async () => {
+    const { handlers, ctx, appended } = await boot({
+      autoBudgetThreshold: 0.5,
+      frontierGapThresholdTokens: 10,
+    });
+
+    await handlers.get("session_start")!({}, ctx);
+
+    // Usage fraction 0.9 crosses the 0.5 budget threshold; defaultBranch()'s
+    // un-pruned tail also crosses the 10-token gap threshold. Budget must win.
+    ctx.getContextUsage = () => ({ tokens: 900000, contextWindow: 1000000 });
+
+    await handlers.get("turn_end")!(
+      {
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "read", arguments: {} }] },
+        toolResults: [
+          { role: "toolResult", toolCallId: "tc1", toolName: "read", content: [{ type: "text", text: "x".repeat(400) }], timestamp: Date.now() },
+        ],
+        turnIndex: 2,
+      },
+      ctx,
+    );
+
+    const flushMetricsEntries = appended.filter((e) => e.type === "context-prune-flush-metrics");
+    expect(flushMetricsEntries.length).toBe(1);
+    expect((flushMetricsEntries[0].data as any).trigger).toBe("budget");
+  });
+
+  it("frontier-gap trigger stays inert when frontierGapThresholdTokens is unset (default null), even with a huge un-pruned tail (#13)", async () => {
+    const { handlers, ctx, appended } = await boot({
+      autoBudgetThreshold: null,
+    });
+
+    await handlers.get("session_start")!({}, ctx);
+    ctx.getContextUsage = () => ({ tokens: 10, contextWindow: 1000000 });
+
+    await handlers.get("turn_end")!(
+      {
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "read", arguments: {} }] },
+        toolResults: [
+          { role: "toolResult", toolCallId: "tc1", toolName: "read", content: [{ type: "text", text: "x".repeat(400) }], timestamp: Date.now() },
+        ],
+        turnIndex: 2,
+      },
+      ctx,
+    );
+
+    expect(appended.some((e) => e.type === "context-prune-flush-metrics")).toBe(false);
+  });
+
+  it("frontier-gap cadence: a partial-failure flush persists the surviving prefix and advances the frontier; the next gap-triggered flush advances it further (#13)", async () => {
+    const { handlers, ctx, appended } = await boot({
+      autoBudgetThreshold: null,
+      frontierGapThresholdTokens: 10,
+      branch: [],
+    });
+
+    await handlers.get("session_start")!({}, ctx);
+    ctx.getContextUsage = () => ({ tokens: 10, contextWindow: 1000000 });
+
+    // Turn 1: branch still empty -> frontierGapTokens is 0 -> no flush, even
+    // though this turn's own toolResults are pushed into pendingBatches.
+    await handlers.get("turn_end")!(
+      {
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc-warmup", name: "read", arguments: {} }] },
+        toolResults: [
+          { role: "toolResult", toolCallId: "tc-warmup", toolName: "read", content: [{ type: "text", text: "w".repeat(400) }], timestamp: Date.now() },
+        ],
+        turnIndex: 1,
+      },
+      ctx,
+    );
+    expect(appended.some((e) => e.type === "context-prune-flush-metrics")).toBe(false);
+
+    // Grow the branch with two independent unindexed batches (tc-a, tc-b) —
+    // capturePendingBatches rescans the branch, not the in-memory queue, so
+    // this is what actually makes the upcoming flush see two batches.
+    let t = Date.now();
+    ctx.sessionManager.getBranch().push(...pendingBatchEntries("tc-a", "a".repeat(400), (t += 1000)));
+    ctx.sessionManager.getBranch().push(...pendingBatchEntries("tc-b", "b".repeat(400), (t += 1000)));
+
+    let callCount = 0;
+    streamImpl = () => {
+      callCount++;
+      summarizerCalls++;
+      if (callCount === 2) return errStream("simulated summarizer failure on second batch");
+      return okStream();
+    };
+
+    // Turn 2: gap now over threshold (tc-a + tc-b unsummarized) -> flush fires,
+    // processes tc-a successfully, tc-b's summarization call fails.
+    await handlers.get("turn_end")!(
+      {
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc-a", name: "read", arguments: {} }] },
+        toolResults: [
+          { role: "toolResult", toolCallId: "tc-a", toolName: "read", content: [{ type: "text", text: "a".repeat(400) }], timestamp: Date.now() },
+        ],
+        turnIndex: 2,
+      },
+      ctx,
+    );
+
+    let frontierEntries = appended.filter((e) => e.type === "context-prune-frontier");
+    expect(frontierEntries.length).toBe(1);
+    const firstFrontier = frontierEntries[0].data as any;
+    expect(firstFrontier.lastAttemptedToolCallId).toBe("tc-a");
+
+    // Grow the branch again (tc-b is still unsummarized/pending after the
+    // restore; add tc-c as this turn's new work) — gap stays over threshold.
+    ctx.sessionManager.getBranch().push(...pendingBatchEntries("tc-c", "c".repeat(400), (t += 1000)));
+
+    // Turn 3: gap still over threshold -> flush fires again, this time both
+    // tc-b (restored) and tc-c succeed (streamImpl only fails on call #2).
+    await handlers.get("turn_end")!(
+      {
+        message: { role: "assistant", content: [{ type: "toolCall", id: "tc-c", name: "read", arguments: {} }] },
+        toolResults: [
+          { role: "toolResult", toolCallId: "tc-c", toolName: "read", content: [{ type: "text", text: "c".repeat(400) }], timestamp: Date.now() },
+        ],
+        turnIndex: 3,
+      },
+      ctx,
+    );
+
+    frontierEntries = appended.filter((e) => e.type === "context-prune-frontier");
+    expect(frontierEntries.length).toBe(2);
+    const secondFrontier = frontierEntries[1].data as any;
+    expect(secondFrontier.lastAttemptedTimestamp).toBeGreaterThan(firstFrontier.lastAttemptedTimestamp);
+  });
 });