pi-editor-footer 0.6.1 → 0.6.2

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.6.2] - 2026-08-25
+
+### Fixed
+
+- Live `↑` no longer exceeds context window or session total — `telemetry:peekAgentLive` and `endAgent` now use peak window (`max`) for `inputTokens` not sum (summing `50k+60k=110k` double-counted overlapping history `> 60k` window), `live-border` top `↑` now shows current window `peekLive` + per-agent `output`/`cost` capped to `contextUsage.tokens`, idle also via telemetry `max` capped, timeline `↑` prefers telemetry `max` capped
+
 ## [0.6.1] - 2026-08-25
 
 ### Fixed

package/dist/index.js

@@ -631,7 +631,7 @@ export default function (pi) {
     pi.on("turn_start", (e, ctx) => {
         // Input is known at turn_start via context usage — seed live input so peekLive shows it during streaming (output already streams via liveDeltaChars)
         const usageTokens = ctx // SAFETY: pi context seam — getContextUsage is ExtensionContext API
-            ?.getContextUsage?.()?.tokens;
+        ?.getContextUsage?.()?.tokens;
         if (typeof usageTokens === "number" &&
             Number.isFinite(usageTokens) &&
             usageTokens > 0) {
@@ -715,21 +715,29 @@ export default function (pi) {
                 const cacheRate = totals.latestCacheHitRate ?? 0;
                 const cacheStr = `${glyphs.cacheHit} ${cacheRate.toFixed(1)}%`;
                 // Respect timeline.* toggles for specified metrics (wallTime/tokens/cost), but datetime/cache/turn/tools are always shown per user spec
-                // Timeline tokens per-agent: prefer baseline delta (totals - baseline) which yields 18k (279k-261k) not 279k total.
-                // Fallback to tel (tracker sum) then session totals.
+                // Timeline tokens per-agent: input is peak window (max), not sum — summing full prompts
+                // double-counts overlapping history (50k+60k=110k > window 60k). Prefer telemetry max
+                // (tel.inputTokens after fix) when available, else delta capped to context/total.
+                // Output/cost remain per-agent sum for billing.
                 let telInput;
                 let telOutput;
                 let telCost;
-                if (agentBaselineTotals) {
-                    telInput = Math.max(0, totals.input - agentBaselineTotals.input);
-                    telOutput = Math.max(0, totals.output - agentBaselineTotals.output);
-                    telCost = Math.max(0, totals.cost - agentBaselineTotals.cost);
-                }
-                else if (tel) {
+                if (tel) {
                     telInput = tel.inputTokens;
                     telOutput = tel.outputTokens;
                     telCost = tel.costUsd;
                 }
+                else if (agentBaselineTotals) {
+                    telInput = Math.max(0, totals.input - agentBaselineTotals.input);
+                    telOutput = Math.max(0, totals.output - agentBaselineTotals.output);
+                    telCost = Math.max(0, totals.cost - agentBaselineTotals.cost);
+                    // Cap input to not exceed context window (peak) or session total
+                    const ctxTokens = lastSessionCtx?.getContextUsage?.()?.tokens;
+                    if (typeof ctxTokens === "number" && Number.isFinite(ctxTokens))
+                        telInput = Math.min(telInput, ctxTokens);
+                    if (totals.input > 0)
+                        telInput = Math.min(telInput, totals.input);
+                }
                 else {
                     telInput = totals.input;
                     telOutput = totals.output;

package/dist/live-border.js

@@ -197,38 +197,85 @@ export class LiveBorder {
             let tokensText = "";
             if (cfg.telemetry.enabled && cfg.telemetry.tokens) {
                 const isRunning = this.deps.runActivityTracker.isRunning();
-                // When idle (settled) and baseline available, show per-agent delta (input/output/cost) = cur totals - baseline at agent_start.
-                // This yields 18k for the example (279k session - 261k baseline = 18k agent) instead of 279k total.
-                // When running, use live agent tracker (sum of turns in this agent + live turn) which is already per-agent after guard fix.
+                // Live input: window occupancy (max), not sum. Summing full prompts double-counts
+                // overlapping history (50k+60k=110k > window 60k) and exceeds context/total.
+                // Idle shows per-agent max via telemetry (fallback to delta capped), running shows
+                // current turn window (peekLive) + per-agent output/cost, both capped to context/total.
                 if (!isRunning && this.agentBaseline) {
                     const cur = snapshot.totals;
                     const base = this.agentBaseline;
-                    const deltaInput = Math.max(0, cur.input - base.input);
-                    const deltaOutput = Math.max(0, cur.output - base.output);
-                    // Build minimal telemetry for formatting (only tokens matter for formatTelemetryTokens)
+                    // Idle per-agent display — input is peak window (max), not sum, to avoid
+                    // double-count exceed (sum of prompts double-counts overlapping history).
+                    // Prefer telemetry max when available, else delta capped to context/totals.
+                    const trackerIdle = this.deps.telemetryTracker;
+                    const telIdle = trackerIdle.peekAgentLive() ?? trackerIdle.getLastTelemetry();
+                    let displayInput;
+                    let displayOutput;
+                    let displayCost;
+                    if (telIdle) {
+                        displayInput = telIdle.inputTokens;
+                        displayOutput = telIdle.outputTokens;
+                        displayCost = telIdle.costUsd;
+                    }
+                    else {
+                        displayInput = Math.max(0, cur.input - base.input);
+                        displayOutput = Math.max(0, cur.output - base.output);
+                        displayCost = Math.max(0, cur.cost - base.cost);
+                    }
+                    // Guarantee invariant: live input never exceeds context window or session total
+                    if (snapshot.contextUsage?.tokens)
+                        displayInput = Math.min(displayInput, snapshot.contextUsage.tokens);
+                    if (cur.input > 0)
+                        displayInput = Math.min(displayInput, cur.input);
                     const deltaTel = {
                         tps: null,
                         ttftMs: 0,
                         totalMs: 0,
-                        inputTokens: deltaInput,
-                        outputTokens: deltaOutput,
+                        inputTokens: displayInput,
+                        outputTokens: displayOutput,
                         stallMs: 0,
                         stallCount: 0,
                         rateUsdPerMTokens: null,
                         generationMs: 0,
-                        totalTokens: deltaInput + deltaOutput,
-                        costUsd: Math.max(0, cur.cost - base.cost),
+                        totalTokens: displayInput + displayOutput,
+                        costUsd: displayCost,
                         measurementMs: null,
                     };
                     tokensText = formatTelemetryTokens(deltaTel, theme, cfg.telemetry, glyphs);
                 }
                 else {
-                    // Live or fallback — per-agent sum from tracker (option B), correctly reset per agent_start
-                    // SAFETY: pi seam — intentional unsafe cast, validated at runtime — telemetry tracker for top tokens line (agent run)
+                    // Live per-agent — input is current window (peekLive), not per-agent sum,
+                    // to avoid sum(50k+60k)=110k > window 60k. Output/cost still per-agent sum.
                     const tracker = this.deps.telemetryTracker;
-                    const live = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
-                    if (live) {
-                        tokensText = formatTelemetryTokens(live, theme, cfg.telemetry, glyphs);
+                    const agentLive = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
+                    const liveTurn = tracker.peekLive();
+                    let displayLive = agentLive;
+                    if (agentLive &&
+                        liveTurn &&
+                        this.deps.runActivityTracker.isRunning()) {
+                        // Input = current turn window (liveTurn), output/cost = per-agent sum
+                        displayLive = {
+                            ...agentLive,
+                            inputTokens: liveTurn.inputTokens,
+                            totalTokens: liveTurn.inputTokens + agentLive.outputTokens,
+                        };
+                    }
+                    if (displayLive) {
+                        let cappedInput = displayLive.inputTokens;
+                        if (snapshot.contextUsage?.tokens)
+                            cappedInput = Math.min(cappedInput, snapshot.contextUsage.tokens);
+                        // Note: not capping to session totals during running — totals is authoritative
+                        // (lagging) while liveTurn is predictive (current window). Capping to totals
+                        // would make live stale (50k) during second turn streaming instead of showing
+                        // current window 60k. After fix to max, live 60k == context 60k, not exceed context;
+                        // live may still be > authoritative totals interim (60k > 50k) but will be <= totals
+                        // after turn completes (60k <= 110k). This is expected predictive vs authoritative.
+                        displayLive = {
+                            ...displayLive,
+                            inputTokens: cappedInput,
+                            totalTokens: cappedInput + displayLive.outputTokens,
+                        };
+                        tokensText = formatTelemetryTokens(displayLive, theme, cfg.telemetry, glyphs);
                     }
                 }
             }

package/dist/telemetry.js

@@ -83,11 +83,12 @@ export class TurnTelemetryTracker {
         let stallCount = 0;
         let generationMs = 0;
         let ttftMs = 0;
-        // sum completed turns
+        // input per turn is the full prompt (includes history), summing double-counts overlapping
+        // history and makes live input exceed context usage (e.g. 50k+60k=110k > window 60k).
+        // Display input as peak window occupancy (max), not sum. Output/cost still sum.
         for (const t of this.agentTurns) {
-            inputTokens += t.inputTokens;
+            inputTokens = Math.max(inputTokens, t.inputTokens);
             outputTokens += t.outputTokens;
-            totalTokens += t.totalTokens;
             costUsd += t.costUsd;
             stallMs += t.stallMs;
             stallCount += t.stallCount;
@@ -96,9 +97,8 @@ export class TurnTelemetryTracker {
         if (this.agentTurns.length > 0)
             ttftMs = this.agentTurns[0].ttftMs;
         if (live) {
-            inputTokens += live.inputTokens;
+            inputTokens = Math.max(inputTokens, live.inputTokens);
             outputTokens += live.outputTokens;
-            totalTokens += live.totalTokens;
             costUsd += live.costUsd;
             stallMs += live.stallMs;
             stallCount += live.stallCount;
@@ -106,6 +106,8 @@ export class TurnTelemetryTracker {
             if (ttftMs === 0)
                 ttftMs = live.ttftMs;
         }
+        // totalTokens is window input (max) + cumulative output, not sum of per-turn totals
+        totalTokens = inputTokens + outputTokens;
         const now = this.now();
         const totalMs = Math.max(0, now - this.agentStartMs);
         const measurementMs = outputTokens > 0 && generationMs > 0 ? generationMs : null;
@@ -397,8 +399,9 @@ export class TurnTelemetryTracker {
         if (startMs === null || turns.length === 0)
             return;
         const outputTokens = turns.reduce((sum, t) => sum + t.outputTokens, 0);
-        const inputTokens = turns.reduce((sum, t) => sum + t.inputTokens, 0);
-        const totalTokens = turns.reduce((sum, t) => sum + t.totalTokens, 0);
+        const inputTokens = turns.reduce((sum, t) => Math.max(sum, t.inputTokens), 0);
+        // totalTokens is window input (max) + cumulative output, not sum of per-turn totals
+        const totalTokens = inputTokens + outputTokens;
         const costUsd = turns.reduce((sum, t) => sum + t.costUsd, 0);
         const stallMs = turns.reduce((sum, t) => sum + t.stallMs, 0);
         const stallCount = turns.reduce((sum, t) => sum + t.stallCount, 0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-editor-footer",
   "type": "module",
-  "description": "Pi TUI theme — project-aware footer, model border, and skill detail window (TrackingEditor, live theme)",
+  "description": "Pi TUI theme \u2014 project-aware footer, model border, and skill detail window (TrackingEditor, live theme)",
   "scripts": {
     "test": "node --import tsx --test test/*.test.ts",
     "typecheck": "tsc --noEmit",
@@ -18,7 +18,7 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   },
-  "version": "0.6.1",
+  "version": "0.6.2",
   "files": [
     "dist",
     "src",

package/src/index.ts

@@ -802,9 +802,8 @@ export default function (pi: ExtensionAPILike): void {
 	pi.on("turn_start", (e, ctx) => {
 		// Input is known at turn_start via context usage — seed live input so peekLive shows it during streaming (output already streams via liveDeltaChars)
 		const usageTokens = (
-			ctx as unknown as { getContextUsage?: () => { tokens?: number } }
-		) // SAFETY: pi context seam — getContextUsage is ExtensionContext API
-			?.getContextUsage?.()?.tokens;
+            ctx as unknown as { getContextUsage?: () => { tokens?: number } } // SAFETY: pi context seam — getContextUsage is ExtensionContext API
+        )?.getContextUsage?.()?.tokens;
 		if (
 			typeof usageTokens === "number" &&
 			Number.isFinite(usageTokens) &&
@@ -895,24 +894,34 @@ export default function (pi: ExtensionAPILike): void {
 				const cacheRate = totals.latestCacheHitRate ?? 0;
 				const cacheStr = `${glyphs.cacheHit} ${cacheRate.toFixed(1)}%`;
 				// Respect timeline.* toggles for specified metrics (wallTime/tokens/cost), but datetime/cache/turn/tools are always shown per user spec
-				// Timeline tokens per-agent: prefer baseline delta (totals - baseline) which yields 18k (279k-261k) not 279k total.
-				// Fallback to tel (tracker sum) then session totals.
-				let telInput: number;
-				let telOutput: number;
-				let telCost: number;
-				if (agentBaselineTotals) {
-					telInput = Math.max(0, totals.input - agentBaselineTotals.input);
-					telOutput = Math.max(0, totals.output - agentBaselineTotals.output);
-					telCost = Math.max(0, totals.cost - agentBaselineTotals.cost);
-				} else if (tel) {
-					telInput = tel.inputTokens;
-					telOutput = tel.outputTokens;
-					telCost = tel.costUsd;
-				} else {
-					telInput = totals.input;
-					telOutput = totals.output;
-					telCost = totals.cost;
-				}
+        // Timeline tokens per-agent: input is peak window (max), not sum — summing full prompts
+        // double-counts overlapping history (50k+60k=110k > window 60k). Prefer telemetry max
+        // (tel.inputTokens after fix) when available, else delta capped to context/total.
+        // Output/cost remain per-agent sum for billing.
+        let telInput: number;
+        let telOutput: number;
+        let telCost: number;
+        if (tel) {
+          telInput = tel.inputTokens;
+          telOutput = tel.outputTokens;
+          telCost = tel.costUsd;
+        } else if (agentBaselineTotals) {
+          telInput = Math.max(0, totals.input - agentBaselineTotals.input);
+          telOutput = Math.max(0, totals.output - agentBaselineTotals.output);
+          telCost = Math.max(0, totals.cost - agentBaselineTotals.cost);
+          // Cap input to not exceed context window (peak) or session total
+          const ctxTokens = (
+            lastSessionCtx as unknown as { // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+              getContextUsage?: () => { tokens?: number };
+            }
+          )?.getContextUsage?.()?.tokens;
+          if (typeof ctxTokens === "number" && Number.isFinite(ctxTokens)) telInput = Math.min(telInput, ctxTokens);
+          if (totals.input > 0) telInput = Math.min(telInput, totals.input);
+        } else {
+          telInput = totals.input;
+          telOutput = totals.output;
+          telCost = totals.cost;
+        }
 				const line1Parts: string[] = [dt];
 				if (currentConfig.timeline.wallTime) line1Parts.push(wallDur);
 				else line1Parts.push(wallDur); // wall time always per spec (11s)

package/src/live-border.ts

@@ -245,27 +245,50 @@ export class LiveBorder {
       let tokensText = "";
       if (cfg.telemetry.enabled && cfg.telemetry.tokens) {
         const isRunning = this.deps.runActivityTracker.isRunning();
-        // When idle (settled) and baseline available, show per-agent delta (input/output/cost) = cur totals - baseline at agent_start.
-        // This yields 18k for the example (279k session - 261k baseline = 18k agent) instead of 279k total.
-        // When running, use live agent tracker (sum of turns in this agent + live turn) which is already per-agent after guard fix.
+        // Live input: window occupancy (max), not sum. Summing full prompts double-counts
+        // overlapping history (50k+60k=110k > window 60k) and exceeds context/total.
+        // Idle shows per-agent max via telemetry (fallback to delta capped), running shows
+        // current turn window (peekLive) + per-agent output/cost, both capped to context/total.
         if (!isRunning && this.agentBaseline) {
           const cur = snapshot.totals;
           const base = this.agentBaseline;
-          const deltaInput = Math.max(0, cur.input - base.input);
-          const deltaOutput = Math.max(0, cur.output - base.output);
-          // Build minimal telemetry for formatting (only tokens matter for formatTelemetryTokens)
+          // Idle per-agent display — input is peak window (max), not sum, to avoid
+          // double-count exceed (sum of prompts double-counts overlapping history).
+          // Prefer telemetry max when available, else delta capped to context/totals.
+          const trackerIdle = this.deps.telemetryTracker as unknown as {
+            peekAgentLive(): import("./telemetry.js").TurnTelemetry | null;
+            getLastTelemetry(): import("./telemetry.js").TurnTelemetry | null;
+          };
+          const telIdle =
+            trackerIdle.peekAgentLive() ?? trackerIdle.getLastTelemetry();
+          let displayInput: number;
+          let displayOutput: number;
+          let displayCost: number;
+          if (telIdle) {
+            displayInput = telIdle.inputTokens;
+            displayOutput = telIdle.outputTokens;
+            displayCost = telIdle.costUsd;
+          } else {
+            displayInput = Math.max(0, cur.input - base.input);
+            displayOutput = Math.max(0, cur.output - base.output);
+            displayCost = Math.max(0, cur.cost - base.cost);
+          }
+          // Guarantee invariant: live input never exceeds context window or session total
+          if (snapshot.contextUsage?.tokens)
+            displayInput = Math.min(displayInput, snapshot.contextUsage.tokens);
+          if (cur.input > 0) displayInput = Math.min(displayInput, cur.input);
           const deltaTel: TurnTelemetry = {
             tps: null,
             ttftMs: 0,
             totalMs: 0,
-            inputTokens: deltaInput,
-            outputTokens: deltaOutput,
+            inputTokens: displayInput,
+            outputTokens: displayOutput,
             stallMs: 0,
             stallCount: 0,
             rateUsdPerMTokens: null,
             generationMs: 0,
-            totalTokens: deltaInput + deltaOutput,
-            costUsd: Math.max(0, cur.cost - base.cost),
+            totalTokens: displayInput + displayOutput,
+            costUsd: displayCost,
             measurementMs: null,
           };
           tokensText = formatTelemetryTokens(
@@ -275,16 +298,46 @@ export class LiveBorder {
             glyphs as never,
           );
         } else {
-          // Live or fallback — per-agent sum from tracker (option B), correctly reset per agent_start
-          // SAFETY: pi seam — intentional unsafe cast, validated at runtime — telemetry tracker for top tokens line (agent run)
+          // Live per-agent — input is current window (peekLive), not per-agent sum,
+          // to avoid sum(50k+60k)=110k > window 60k. Output/cost still per-agent sum.
           const tracker = this.deps.telemetryTracker as unknown as {
             peekAgentLive(): import("./telemetry.js").TurnTelemetry | null;
+            peekLive(): import("./telemetry.js").TurnTelemetry | null;
             getLastTelemetry(): import("./telemetry.js").TurnTelemetry | null;
           };
-          const live = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
-          if (live) {
+          const agentLive =
+            tracker.peekAgentLive() ?? tracker.getLastTelemetry();
+          const liveTurn = tracker.peekLive();
+          let displayLive = agentLive;
+          if (
+            agentLive &&
+            liveTurn &&
+            this.deps.runActivityTracker.isRunning()
+          ) {
+            // Input = current turn window (liveTurn), output/cost = per-agent sum
+            displayLive = {
+              ...agentLive,
+              inputTokens: liveTurn.inputTokens,
+              totalTokens: liveTurn.inputTokens + agentLive.outputTokens,
+            };
+          }
+          if (displayLive) {
+            let cappedInput = displayLive.inputTokens;
+            if (snapshot.contextUsage?.tokens)
+              cappedInput = Math.min(cappedInput, snapshot.contextUsage.tokens);
+            // Note: not capping to session totals during running — totals is authoritative
+            // (lagging) while liveTurn is predictive (current window). Capping to totals
+            // would make live stale (50k) during second turn streaming instead of showing
+            // current window 60k. After fix to max, live 60k == context 60k, not exceed context;
+            // live may still be > authoritative totals interim (60k > 50k) but will be <= totals
+            // after turn completes (60k <= 110k). This is expected predictive vs authoritative.
+            displayLive = {
+              ...displayLive,
+              inputTokens: cappedInput,
+              totalTokens: cappedInput + displayLive.outputTokens,
+            };
             tokensText = formatTelemetryTokens(
-              live,
+              displayLive,
               theme as never,
               cfg.telemetry,
               glyphs as never,

package/src/telemetry.ts

@@ -185,11 +185,12 @@ export class TurnTelemetryTracker {
     let stallCount = 0;
     let generationMs = 0;
     let ttftMs = 0;
-    // sum completed turns
+    // input per turn is the full prompt (includes history), summing double-counts overlapping
+    // history and makes live input exceed context usage (e.g. 50k+60k=110k > window 60k).
+    // Display input as peak window occupancy (max), not sum. Output/cost still sum.
     for (const t of this.agentTurns) {
-      inputTokens += t.inputTokens;
+      inputTokens = Math.max(inputTokens, t.inputTokens);
       outputTokens += t.outputTokens;
-      totalTokens += t.totalTokens;
       costUsd += t.costUsd;
       stallMs += t.stallMs;
       stallCount += t.stallCount;
@@ -197,15 +198,16 @@ export class TurnTelemetryTracker {
     }
     if (this.agentTurns.length > 0) ttftMs = this.agentTurns[0]!.ttftMs;
     if (live) {
-      inputTokens += live.inputTokens;
+      inputTokens = Math.max(inputTokens, live.inputTokens);
       outputTokens += live.outputTokens;
-      totalTokens += live.totalTokens;
       costUsd += live.costUsd;
       stallMs += live.stallMs;
       stallCount += live.stallCount;
       generationMs += live.generationMs;
       if (ttftMs === 0) ttftMs = live.ttftMs;
     }
+    // totalTokens is window input (max) + cumulative output, not sum of per-turn totals
+    totalTokens = inputTokens + outputTokens;
     const now = this.now();
     const totalMs = Math.max(0, now - this.agentStartMs);
     const measurementMs =
@@ -524,8 +526,12 @@ export class TurnTelemetryTracker {
     if (startMs === null || turns.length === 0) return;
 
     const outputTokens = turns.reduce((sum, t) => sum + t.outputTokens, 0);
-    const inputTokens = turns.reduce((sum, t) => sum + t.inputTokens, 0);
-    const totalTokens = turns.reduce((sum, t) => sum + t.totalTokens, 0);
+    const inputTokens = turns.reduce(
+      (sum, t) => Math.max(sum, t.inputTokens),
+      0,
+    );
+    // totalTokens is window input (max) + cumulative output, not sum of per-turn totals
+    const totalTokens = inputTokens + outputTokens;
     const costUsd = turns.reduce((sum, t) => sum + t.costUsd, 0);
     const stallMs = turns.reduce((sum, t) => sum + t.stallMs, 0);
     const stallCount = turns.reduce((sum, t) => sum + t.stallCount, 0);