pi-condense 2.6.0 → 2.8.0

package/src/budget.ts

@@ -1,10 +1,18 @@
 import type { ContextUsage } from "@earendil-works/pi-coding-agent";
 
+// Ceiling on what the budget triggers treat as the context window. Advertised
+// windows reach 1M, which makes any (0,1] fraction unreachable in a real session.
+// The two triggers apply it in different shapes on purpose: the threshold is a
+// LEVEL, so the cap bounds the level itself (min(CAP, threshold * window)); the
+// delta is a GROWTH RATE, where a 300k ceiling could never bind, so the cap
+// enters through the denominator instead (delta * min(window, CAP)).
+export const MAX_BUDGET_WINDOW = 300_000;
+
 /**
- * True iff a budget-triggered flush should fire. Computes the ratio ourselves
- * (tokens / contextWindow, a 0–1 fraction) rather than using ContextUsage.percent
- * (a 0–100 value, null when tokens is null). tokens is also null right after a
- * compaction — guarded here.
+ * True iff a budget-triggered flush should fire: at `threshold` of the model's
+ * window, or at MAX_BUDGET_WINDOW tokens, whichever comes first. Computes the
+ * level ourselves rather than using ContextUsage.percent (a 0–100 value, null
+ * when tokens is null). tokens is also null right after a compaction — guarded here.
  */
 export function shouldBudgetFlush(
   usage: ContextUsage | undefined,
@@ -12,17 +20,23 @@ export function shouldBudgetFlush(
 ): boolean {
   if (threshold == null || threshold <= 0 || threshold > 1) return false;
   if (!usage || usage.tokens == null || !(usage.contextWindow > 0)) return false;
-  return usage.tokens / usage.contextWindow >= threshold;
+  return usage.tokens >= Math.min(MAX_BUDGET_WINDOW, threshold * usage.contextWindow);
 }
 
-/** 0–1 usage fraction, or null when usage is missing / tokens null / window non-positive. */
+/**
+ * Usage fraction against the effective window (min(contextWindow, MAX_BUDGET_WINDOW)),
+ * or null when usage is missing / tokens null / window non-positive. NOT bounded by 1:
+ * 600k tokens on a 1M window returns 2.0. Deliberately unclamped — clamping would make
+ * shouldDeltaFlush saturate above the ceiling and stop re-arming.
+ */
 export function usageFraction(usage: ContextUsage | undefined): number | null {
   if (!usage || usage.tokens == null || !(usage.contextWindow > 0)) return null;
-  return usage.tokens / usage.contextWindow;
+  return usage.tokens / Math.min(usage.contextWindow, MAX_BUDGET_WINDOW);
 }
 
 /**
- * True iff this turn's usage fraction rose by at least `delta` versus the previous turn.
+ * True iff this turn's usage fraction rose by at least `delta` versus the previous turn,
+ * i.e. growth of at least `delta * min(contextWindow, MAX_BUDGET_WINDOW)` tokens.
  * Mirrors shouldBudgetFlush's guards. previousFraction === null (first turn or post-restart)
  * never fires; the absolute autoBudgetThreshold covers that gap.
  */

package/src/commands.test.ts

@@ -1,6 +1,7 @@
-import { describe, it, expect } from "bun:test";
-import { pruneStatusText, setPruneStatusWidget } from "./commands.js";
-import type { ContextPruneConfig } from "./types.js";
+import { describe, it, expect, mock } from "bun:test";
+import { pruneStatusText, setPruneStatusWidget, registerCommands } from "./commands.js";
+import type { ContextPruneConfig, ContextMetricsSnapshot, SummarizerStats } from "./types.js";
+import { DEFAULT_CONFIG } from "./types.js";
 
 const cfg = (enabled: boolean): ContextPruneConfig => ({ enabled } as ContextPruneConfig);
 const cfgVisible = (enabled: boolean): ContextPruneConfig =>
@@ -10,12 +11,119 @@ 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);
+  setPruneStatusWidget({ ui: { setStatus: (_id, text) => { captured = text; } } }, config, value, diagnostics, metrics);
   return captured;
 }
 
+// ── /pruner command handler harness (registerCommands) ──────────────────────
+// Drives the real switch-statement handler registered by registerCommands,
+// with all injected collaborators stubbed. This is the seam for exercising
+// /pruner subcommands without booting the full index.ts extension.
+function setupPrunerCommand(overrides: {
+  capturePendingBatches?: () => any[];
+  flushPending?: (ctx: any, options?: any) => Promise<any>;
+  getRearmed?: () => boolean;
+  getContextMetrics?: (ctx: any) => ContextMetricsSnapshot;
+} = {}) {
+  let handler: (args: string, ctx: any) => Promise<void>;
+  const notifications: { message: string; type?: string }[] = [];
+  const flushCalls: any[] = [];
+
+  const flushPending =
+    overrides.flushPending ??
+    (async (_ctx: any, options?: any) => {
+      flushCalls.push(options);
+      return { ok: false, reason: "empty" };
+    });
+
+  const pi: any = {
+    registerCommand(_name: string, spec: { handler: (args: string, ctx: any) => Promise<void> }) {
+      handler = spec.handler;
+    },
+    registerMessageRenderer() {},
+  };
+
+  const currentConfig = { value: { ...DEFAULT_CONFIG, enabled: true } };
+
+  registerCommands(
+    pi,
+    currentConfig,
+    flushPending,
+    overrides.capturePendingBatches ?? (() => []),
+    () => ({ callCount: 0, totalInputTokens: 0, totalOutputTokens: 0, totalCost: 0 } as SummarizerStats),
+    () => undefined,
+    {} as any,
+    async () => ({ compressedEntries: [], skipped: 0 }),
+    undefined,
+    overrides.getContextMetrics,
+    undefined,
+    overrides.getRearmed,
+  );
+
+  const ctx: any = {
+    ui: {
+      notify(message: string, type?: string) {
+        notifications.push({ message, type });
+      },
+    },
+  };
+
+  return {
+    run: (args: string) => handler(args, ctx),
+    notifications,
+    flushCalls,
+  };
+}
+
+describe("/pruner now (empty capture)", () => {
+  it("invokes flushPending even when nothing is pending, so a flush-metrics entry is recorded", async () => {
+    const harness = setupPrunerCommand({ capturePendingBatches: () => [] });
+    await harness.run("now");
+
+    expect(harness.flushCalls.length).toBe(1);
+    expect(harness.flushCalls[0]).toMatchObject({ previewedBatches: [], trigger: "manual" });
+    expect(harness.notifications[0]?.message).toBe("pruner: nothing pending — no batches to summarize");
+  });
+});
+
+describe("/pruner status context block", () => {
+  const metrics: ContextMetricsSnapshot = {
+    openCycleThinkingTokens: 12000,
+    largestChainSharePct: 62,
+    frontierGapTokens: 195000,
+  };
+
+  it("renders the --- context --- block with all three metrics", async () => {
+    const harness = setupPrunerCommand({ getContextMetrics: () => metrics, getRearmed: () => false });
+    await harness.run("status");
+
+    const text = harness.notifications[0]?.message ?? "";
+    expect(text).toContain("--- context ---");
+    expect(text).toContain("thinking:     12.0k tokens (open segment)");
+    expect(text).toContain("chain share:  62%");
+    expect(text).toContain("frontier gap: 195.0k tokens");
+  });
+
+  it("appends the rearmed: line only when getRearmed() is true", async () => {
+    const armed = setupPrunerCommand({ getContextMetrics: () => metrics, getRearmed: () => true });
+    await armed.run("status");
+    expect(armed.notifications[0]?.message).toContain("rearmed:      yes");
+
+    const notArmed = setupPrunerCommand({ getContextMetrics: () => metrics, getRearmed: () => false });
+    await notArmed.run("status");
+    expect(notArmed.notifications[0]?.message).not.toContain("rearmed:");
+  });
+
+  it("omits the context block entirely when getContextMetrics is unwired", async () => {
+    const harness = setupPrunerCommand();
+    await harness.run("status");
+    expect(harness.notifications[0]?.message).not.toContain("--- context ---");
+  });
+});
+
 describe("pruneStatusText", () => {
   it("disabled config -> 'prune: OFF'", () => {
     expect(pruneStatusText(cfg(false))).toBe("prune: OFF");
@@ -94,3 +202,29 @@ 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

@@ -6,6 +6,7 @@ import {
   type ChainCompressionEntry,
   type FlushOptions,
   type DiagnosticKind,
+  type ContextMetricsSnapshot,
   PRUNE_ON_MODES,
   BATCHING_MODES,
   STATUS_WIDGET_ID,
@@ -23,6 +24,7 @@ import {
 } from "./types.js";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { saveConfig } from "./config.js";
+import { MAX_BUDGET_WINDOW } from "./budget.js";
 import { formatTokens, formatCost, formatCharProgress, formatCompactCount } from "./stats.js";
 import { Container, Text, SettingsList, type SettingItem } from "@earendil-works/pi-tui";
 import { DynamicBorder, getSettingsListTheme } from "@earendil-works/pi-coding-agent";
@@ -62,6 +64,7 @@ export function pruneStatusText(
   config: ContextPruneConfig,
   reclaim?: LiveReclaim,
   diagnostics?: Record<DiagnosticKind, number>,
+  metrics?: ContextMetricsSnapshot,
 ): string {
   if (!config.enabled) return "prune: OFF";
   const diag = diagnostics
@@ -72,11 +75,14 @@ export function pruneStatusText(
       ].filter(Boolean)
     : [];
   const suffix = diag.length > 0 ? ` \u00b7 diag ${diag.join("/")}` : "";
-  if (!reclaim || reclaim.beforeChars <= 0) return `prune: ON${suffix}`;
+  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}`;
   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}`;
+  return `prune: ON \u00b7 ${formatCompactCount(beforeTok)}->${formatCompactCount(afterTok)} (-${reduction}%)${suffix}${metricsSuffix}`;
 }
 
 export function setPruneStatusWidget(
@@ -84,12 +90,13 @@ 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);
+  const text = typeof value === "string" ? value : pruneStatusText(config, value, diagnostics, metrics);
   // 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
@@ -228,10 +235,12 @@ function maxTimeoutDescription(config: ContextPruneConfig): string {
 }
 
 function autoBudgetThresholdDescription(config: ContextPruneConfig): string {
+  const cap = `${MAX_BUDGET_WINDOW / 1000}k`;
   if (config.autoBudgetThreshold == null) {
-    return `Token-budget auto-flush: force a prune when context usage reaches this share of the window, regardless of prune-on mode. Currently off. Pick a percentage to enable.`;
+    return `Token-budget auto-flush: force a prune when context usage reaches this share of the window (or ${cap} tokens, whichever comes first), regardless of prune-on mode. Currently off. Pick a percentage to enable.`;
   }
-  return `Token-budget auto-flush: force a prune when context usage reaches ${Math.round(config.autoBudgetThreshold * 100)}% of the window, regardless of prune-on mode. Set to Off to disable.`;
+  const pct = Math.round(config.autoBudgetThreshold * 100);
+  return `Token-budget auto-flush: force a prune when context usage reaches ${pct}% of the window or ${cap} tokens, whichever comes first, regardless of prune-on mode. The ${cap} ceiling keeps this reachable on huge-window models. Set to Off to disable.`;
 }
 
 function protectedToolsDisplay(list: string[]): string {
@@ -470,6 +479,9 @@ export function registerCommands(
   indexer: ToolCallIndexer,
   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
   pi.registerCommand("pruner", {
@@ -816,7 +828,7 @@ export function registerCommands(
             }
             currentConfig.value = newConfig;
             saveConfig(newConfig);
-            setPruneStatusWidget(ctx, newConfig, getLiveReclaim(), getDiagnosticCounts?.());
+            setPruneStatusWidget(ctx, newConfig, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
             settingsList?.invalidate();
           };
 
@@ -851,7 +863,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?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
           break;
         }
 
@@ -860,7 +872,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?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
           break;
         }
 
@@ -873,8 +885,12 @@ export function registerCommands(
             ? `\n  --- summarizer ---\n  calls:       ${s.callCount}\n  input:       ${formatTokens(s.totalInputTokens)} tokens\n  output:      ${formatTokens(s.totalOutputTokens)} tokens\n  cost:        ${formatCost(s.totalCost)}`
             : "\n  (no summarizer calls yet)";
           const fmtTimeout = (ms: number) => (ms === 0 ? "disabled" : `${Math.round(ms / 1000)}s`);
+          const m = getContextMetrics?.(ctx);
+          const contextLine = m
+            ? `\n  --- context ---\n  thinking:     ${formatTokens(m.openCycleThinkingTokens)} tokens (open segment)\n  chain share:  ${m.largestChainSharePct}%\n  frontier gap: ${formatTokens(m.frontierGapTokens)} tokens${getRearmed?.() ? "\n  rearmed:      yes" : ""}`
+            : "";
           ctx.ui.notify(
-            `pruner status:\n  enabled:  ${cfg.enabled}\n  model:    ${cfg.summarizerModel}\n  thinking: ${summarizerThinkingLabel(cfg.summarizerThinking)} (${cfg.summarizerThinking})\n  idle to:  ${fmtTimeout(cfg.summarizerIdleTimeoutMs)}\n  max to:   ${fmtTimeout(cfg.summarizerMaxTimeoutMs)}\n  trigger:  ${mode}\n  batching: ${batchingModeLabel(cfg.batchingMode)} (${cfg.batchingMode})\n  dedup:    ${cfg.dedupByContentHash ? "on" : "off"}\n  status:   ${cfg.showPruneStatusLine ? "on" : "off"}${statsLine}`,
+            `pruner status:\n  enabled:  ${cfg.enabled}\n  model:    ${cfg.summarizerModel}\n  thinking: ${summarizerThinkingLabel(cfg.summarizerThinking)} (${cfg.summarizerThinking})\n  idle to:  ${fmtTimeout(cfg.summarizerIdleTimeoutMs)}\n  max to:   ${fmtTimeout(cfg.summarizerMaxTimeoutMs)}\n  trigger:  ${mode}\n  batching: ${batchingModeLabel(cfg.batchingMode)} (${cfg.batchingMode})\n  dedup:    ${cfg.dedupByContentHash ? "on" : "off"}\n  status:   ${cfg.showPruneStatusLine ? "on" : "off"}${statsLine}${contextLine}`,
           );
           break;
         }
@@ -979,7 +995,7 @@ export function registerCommands(
             currentConfig.value = { ...currentConfig.value, pruneOn: modeArg as ContextPruneConfig["pruneOn"] };
           }
           saveConfig(currentConfig.value);
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
           break;
         }
 
@@ -1052,6 +1068,11 @@ export function registerCommands(
           const batches = capturePendingBatches(ctx);
           if (batches.length === 0) {
             ctx.ui.notify("pruner: nothing pending — no batches to summarize", "info");
+            // Still invoke flushPending so its finally-emitted flush-metrics entry
+            // records this attempt (outcome "empty") — the incident's exact
+            // undiagnosable "nothing pending" report is precisely what this log
+            // exists to make diagnosable on recurrence.
+            await flushPending(ctx, { previewedBatches: batches, trigger: "manual" });
             break;
           }
 
@@ -1076,7 +1097,7 @@ export function registerCommands(
 
           // Remove the widget and restore the normal footer status.
           clearWidget();
-          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.());
+          setPruneStatusWidget(ctx, currentConfig.value, getLiveReclaim(), getDiagnosticCounts?.(), getCachedMetrics?.());
 
           if (!result.ok) {
             const suffix = "error" in result && result.error ? ` (${result.error})` : "";