pi-condense 2.9.1 → 2.10.0

package/src/chain-detector.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { detectChains, withClosingMessage } from "./chain-detector.js";
+import { detectChains, isChainAnchorCustom, withClosingMessage } from "./chain-detector.js";
+
+const custom = (customType: string, timestamp: number) => ({ role: "custom", customType, timestamp });
 
 // ── Minimal message factories ──────────────────────────────────────────────
 
@@ -349,3 +351,77 @@ describe("withClosingMessage", () => {
     expect(ranges[1].finalAssistantTimestamp).toBe(800);
   });
 });
+
+describe("chain-anchor custom messages", () => {
+  test("custom message while idle opens a chain", () => {
+    const messages = [
+      custom("pi-gauntlet-transition-recovery", 100),
+      { role: "assistant", timestamp: 200, content: [{ type: "toolCall", id: "tc1", name: "read", input: {} }] },
+      { role: "toolResult", toolCallId: "tc1", toolName: "read", timestamp: 250, content: [] },
+      { role: "assistant", timestamp: 300, content: [{ type: "text", text: "done" }] },
+    ];
+    const ranges = detectChains(messages);
+    expect(ranges).toHaveLength(1);
+    expect(ranges[0].startUserTimestamp).toBe(100);
+    expect(ranges[0].finalAssistantTimestamp).toBe(300);
+    expect(ranges[0].middleToolCallIds).toEqual(["tc1"]);
+  });
+
+  test("custom message mid-chain is passthrough; enclosing chain closes as one range", () => {
+    const messages = [
+      { role: "user", timestamp: 100, content: [{ type: "text", text: "go" }] },
+      { role: "assistant", timestamp: 200, content: [{ type: "toolCall", id: "tc1", name: "read", input: {} }] },
+      { role: "toolResult", toolCallId: "tc1", toolName: "read", timestamp: 250, content: [] },
+      custom("pi-gauntlet-transition-recovery", 260),
+      { role: "assistant", timestamp: 300, content: [{ type: "toolCall", id: "tc2", name: "read", input: {} }] },
+      { role: "toolResult", toolCallId: "tc2", toolName: "read", timestamp: 350, content: [] },
+      { role: "assistant", timestamp: 400, content: [{ type: "text", text: "done" }] },
+    ];
+    const ranges = detectChains(messages);
+    expect(ranges).toHaveLength(1);
+    expect(ranges[0].startUserTimestamp).toBe(100);
+    expect(ranges[0].middleToolCallIds).toEqual(["tc1", "tc2"]);
+  });
+
+  test("context-prune-summary custom is passthrough in both states", () => {
+    // idle state: a summary custom must not anchor anything
+    const idleMessages = [
+      custom("context-prune-summary", 50),
+      { role: "assistant", timestamp: 200, content: [{ type: "toolCall", id: "tc1", name: "read", input: {} }] },
+      { role: "toolResult", toolCallId: "tc1", toolName: "read", timestamp: 250, content: [] },
+      { role: "assistant", timestamp: 300, content: [{ type: "text", text: "done" }] },
+    ];
+    expect(detectChains(idleMessages)).toHaveLength(0);
+    // in-chain: a summary custom between turns leaves the chain unbroken
+    const midMessages = [
+      { role: "user", timestamp: 100, content: [{ type: "text", text: "go" }] },
+      { role: "assistant", timestamp: 200, content: [{ type: "toolCall", id: "tc1", name: "read", input: {} }] },
+      { role: "toolResult", toolCallId: "tc1", toolName: "read", timestamp: 250, content: [] },
+      custom("context-prune-summary", 260),
+      { role: "assistant", timestamp: 300, content: [{ type: "toolCall", id: "tc2", name: "read", input: {} }] },
+      { role: "toolResult", toolCallId: "tc2", toolName: "read", timestamp: 350, content: [] },
+      { role: "assistant", timestamp: 400, content: [{ type: "text", text: "done" }] },
+    ];
+    const ranges = detectChains(midMessages);
+    expect(ranges).toHaveLength(1);
+    expect(ranges[0].middleToolCallIds).toEqual(["tc1", "tc2"]);
+  });
+
+  test("future context-prune-* customType is excluded", () => {
+    const messages = [
+      custom("context-prune-whatever", 100),
+      { role: "assistant", timestamp: 200, content: [{ type: "toolCall", id: "tc1", name: "read", input: {} }] },
+      { role: "toolResult", toolCallId: "tc1", toolName: "read", timestamp: 250, content: [] },
+      { role: "assistant", timestamp: 300, content: [{ type: "text", text: "done" }] },
+    ];
+    expect(detectChains(messages)).toHaveLength(0);
+  });
+
+  test("isChainAnchorCustom predicate", () => {
+    expect(isChainAnchorCustom({ role: "custom", customType: "pi-gauntlet-transition-recovery" })).toBe(true);
+    expect(isChainAnchorCustom({ role: "custom", customType: "context-prune-summary" })).toBe(false);
+    expect(isChainAnchorCustom({ role: "custom" })).toBe(true); // missing customType -> not pruner-namespaced
+    expect(isChainAnchorCustom({ role: "user" })).toBe(false);
+    expect(isChainAnchorCustom(undefined)).toBe(false);
+  });
+});

package/src/chain-detector.ts

@@ -23,12 +23,22 @@ function collectToolCalls(msg: any): { id: string; name: string; args: unknown }
     .map((b: any) => ({ id: b.id as string, name: b.name as string, args: b.input ?? b.arguments }));
 }
 
+/**
+ * A non-pruner custom message: eligible to open a chain (while the detector is
+ * idle) and to act as a resolveRange start anchor. The `context-prune-`
+ * namespace prefix excludes every pruner-emitted custom message — today
+ * context-prune-summary; by construction any future pruner customType.
+ */
+export function isChainAnchorCustom(msg: any): boolean {
+  return msg?.role === "custom" && !String(msg.customType ?? "").startsWith("context-prune-");
+}
+
 type State = "idle" | "inChain";
 
 /**
  * Walks an AgentMessage array and emits ChainRange records for each detectable chain.
  *
- * A chain is: [user message] → [assistant+toolResult turns...] → [text-only assistant].
+ * A chain is: [user message or eligible custom message] → [assistant+toolResult turns...] → [text-only assistant].
  * Synthetic chain messages (injected by chain-range-prune) are treated as passthroughs —
  * not chain starts. This is defensive; the detector normally runs pre-compression.
  *
@@ -49,6 +59,12 @@ export function detectChains(
   let middleKeys = new Set<string>();
   let protectedIds = new Set<string>();
 
+  const resetChain = () => {
+    middleIds = new Set();
+    middleKeys = new Set();
+    protectedIds = new Set();
+  };
+
   const emitInterrupted = () => {
     if (state === "inChain" && chainStart) {
       ranges.push({
@@ -66,9 +82,14 @@ export function detectChains(
       if (isSyntheticChainMessage(msg)) continue; // passthrough — not a chain start
       emitInterrupted();
       chainStart = { timestamp: msg.timestamp };
-      middleIds = new Set();
-      middleKeys = new Set();
-      protectedIds = new Set();
+      resetChain();
+      state = "inChain";
+      continue;
+    }
+
+    if (state === "idle" && isChainAnchorCustom(msg)) {
+      chainStart = { timestamp: msg.timestamp };
+      resetChain();
       state = "inChain";
       continue;
     }
@@ -103,9 +124,7 @@ export function detectChains(
         finalAssistantTimestamp: msg.timestamp,
       });
       chainStart = null;
-      middleIds = new Set();
-      middleKeys = new Set();
-      protectedIds = new Set();
+      resetChain();
       state = "idle";
     }
   }

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/commands.test.ts

@@ -11,10 +11,9 @@ function captureStatus(
   config: ContextPruneConfig,
   value?: Parameters<typeof setPruneStatusWidget>[2],
   diagnostics?: Parameters<typeof setPruneStatusWidget>[3],
-  metrics?: Parameters<typeof setPruneStatusWidget>[4],
 ): string | undefined {
   let captured: string | undefined;
-  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value, diagnostics, metrics);
+  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value, diagnostics);
   return captured;
 }
 
@@ -59,7 +58,6 @@ function setupPrunerCommand(overrides: {
     async () => ({ compressedEntries: [], skipped: 0 }),
     undefined,
     overrides.getContextMetrics,
-    undefined,
     overrides.getRearmed,
   );
 
@@ -213,28 +211,3 @@ describe("diagnostic counters on the status line", () => {
   });
 });
 
-describe("context metrics suffix on the status line", () => {
-  const metrics: ContextMetricsSnapshot = {
-    openCycleThinkingTokens: 12000,
-    largestChainSharePct: 62,
-    frontierGapTokens: 195000,
-  };
-
-  it("appends a compact think/gap/chain segment when frontierGapTokens > 0", () => {
-    const text = pruneStatusText(cfg(true), undefined, undefined, metrics);
-    expect(text).toContain("\u00b7 think 12.0k \u00b7 gap 195.0k \u00b7 chain 62%");
-  });
-
-  it("omits the suffix when frontierGapTokens is 0", () => {
-    const withZeroGap = { ...metrics, frontierGapTokens: 0 };
-    expect(pruneStatusText(cfg(true), undefined, undefined, withZeroGap)).toBe(
-      pruneStatusText(cfg(true)),
-    );
-  });
-
-  it("composes after the diag suffix when both are present", () => {
-    const mixedDiag = { "unresolved-range": 2, "range-id-mismatch": 0, "orphan-sweep": 1 } as const;
-    const text = pruneStatusText(cfg(true), undefined, mixedDiag, metrics);
-    expect(text).toBe("prune: ON \u00b7 diag u2/o1 \u00b7 think 12.0k \u00b7 gap 195.0k \u00b7 chain 62%");
-  });
-});

package/src/commands.ts

@@ -64,7 +64,6 @@ export function pruneStatusText(
   config: ContextPruneConfig,
   reclaim?: LiveReclaim,
   diagnostics?: Record<DiagnosticKind, number>,
-  metrics?: ContextMetricsSnapshot,
 ): string {
   if (!config.enabled) return "prune: OFF";
   const diag = diagnostics
@@ -76,14 +75,11 @@ export function pruneStatusText(
       ].filter(Boolean)
     : [];
   const suffix = diag.length > 0 ? ` \u00b7 diag ${diag.join("/")}` : "";
-  const metricsSuffix = metrics && metrics.frontierGapTokens > 0
-    ? ` \u00b7 think ${formatCompactCount(metrics.openCycleThinkingTokens)} \u00b7 gap ${formatCompactCount(metrics.frontierGapTokens)} \u00b7 chain ${metrics.largestChainSharePct}%`
-    : "";
-  if (!reclaim || reclaim.beforeChars <= 0) return `prune: ON${suffix}${metricsSuffix}`;
+  if (!reclaim || reclaim.beforeChars <= 0) return `prune: ON${suffix}`;
   const beforeTok = Math.round(reclaim.beforeChars / 4);
   const afterTok = Math.round(reclaim.afterChars / 4);
   const reduction = Math.max(0, Math.round((1 - afterTok / beforeTok) * 100));
-  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)${suffix}${metricsSuffix}`;
+  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)${suffix}`;
 }
 
 export function setPruneStatusWidget(
@@ -91,13 +87,12 @@ export function setPruneStatusWidget(
   config: ContextPruneConfig,
   value?: LiveReclaim | string,
   diagnostics?: Record<DiagnosticKind, number>,
-  metrics?: ContextMetricsSnapshot,
 ): void {
   if (!config.showPruneStatusLine) {
     ctx.ui.setStatus(STATUS_WIDGET_ID, undefined);
     return;
   }
-  const text = typeof value === "string" ? value : pruneStatusText(config, value, diagnostics, metrics);
+  const text = typeof value === "string" ? value : pruneStatusText(config, value, diagnostics);
   // Leading-only separator: the footer joins extension status segments with a
   // single space, so a trailing divider collides with the next segment's leading
   // one and renders doubled. One leading bar yields single dividers between
@@ -481,7 +476,6 @@ export function registerCommands(
   compactChains: (ctx: ExtensionCommandContext) => Promise<{ compressedEntries: ChainCompressionEntry[]; skipped: number }>,
   getDiagnosticCounts?: () => Record<DiagnosticKind, number>,
   getContextMetrics?: (ctx: ExtensionCommandContext) => ContextMetricsSnapshot,
-  getCachedMetrics?: () => ContextMetricsSnapshot | undefined,
   getRearmed?: () => boolean,
 ): void {
   // Register the /pruner command
@@ -829,7 +823,7 @@ export function registerCommands(
             }
             currentConfig.value = newConfig;
             saveConfig(newConfig);
-            setPruneStatusWidget(ctx, newConfig, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+            setPruneStatusWidget(ctx, newConfig, getLiveReclaim(), getDiagnosticCounts?.());
             settingsList?.invalidate();
           };
 
@@ -864,7 +858,7 @@ export function registerCommands(
           currentConfig.value = { ...currentConfig.value, enabled: true };
           saveConfig(currentConfig.value);
           ctx.ui.notify("Context pruning enabled.");
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -873,7 +867,7 @@ export function registerCommands(
           currentConfig.value = { ...currentConfig.value, enabled: false };
           saveConfig(currentConfig.value);
           ctx.ui.notify("Context pruning disabled.");
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -996,7 +990,7 @@ export function registerCommands(
             currentConfig.value = { ...currentConfig.value, pruneOn: modeArg as ContextPruneConfig["pruneOn"] };
           }
           saveConfig(currentConfig.value);
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
           break;
         }
 
@@ -1098,7 +1092,7 @@ export function registerCommands(
 
           // Remove the widget and restore the normal footer status.
           clearWidget();
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
 
           if (!result.ok) {
             const suffix = "error" in result && result.error ? ` (${result.error})` : "";

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;