pi-editor-footer 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -4,6 +4,18 @@ 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
+
+- Live `↑` now per-agent delta (`279k-261k=18k` for 10 turns) not session total — `live-border` top `↑`/`↓` when idle uses `totals - baseline` at `agent_start` (`LiveBorder.setAgentBaseline`), timeline `↑`/`↓`/`$` also prefers baseline delta; when running uses per-agent sum via `telemetry:peekAgentLive()` which now always resets on `agent_start` (removed stale `if (agentStartMs===null)` guard) and handles `agent_end` alias for `agent_settled`
+
 ## [0.6.0] - 2026-08-24
 
 ### Changed

package/dist/index.js

@@ -52,6 +52,7 @@ const REFRESH_MS = 1000;
 let liveTickTimer = null;
 let footerState = createInitialState();
 let agentStartMs = null;
+let agentBaselineTotals = null;
 let currentModelInfo = {
     provider: "",
     modelId: "unknown",
@@ -170,7 +171,8 @@ function injectTimelineDimLine(_ctx, rawLine) {
         // SAFETY: pi custom entry is TUI-only, not sent to LLM
         extensionPi?.appendEntry?.("timeline", { text: rawLine });
     }
-    catch { // SAFETY: best-effort, ignore recoverable error
+    catch {
+        // SAFETY: best-effort, ignore recoverable error
         // SAFETY: best-effort, ignore recoverable error
     }
     // keep legacy array in sync
@@ -320,7 +322,8 @@ export default function (pi) {
             return new Text(lines.join("\n"));
         });
     }
-    catch { // SAFETY: best-effort, ignore recoverable error
+    catch {
+        // SAFETY: best-effort, ignore recoverable error
         // SAFETY: best-effort, ignore recoverable error
     }
     let headerCleanupInner = null;
@@ -451,6 +454,8 @@ export default function (pi) {
         }
         currentModelInfo = modelInfoOf(ctx);
         lastSessionCtx = ctx;
+        agentBaselineTotals = null;
+        liveBorder.setAgentBaseline(null);
         // Deferred so we win the single editor slot (see installEditor).
         deferredInstallTimer = setTimeout(() => installEditor(ctx.ui), 0);
         // header disabled — first line workspace/hints removed per user request; cwd preserved in footer below input
@@ -544,6 +549,8 @@ export default function (pi) {
         // timeline entries are custom entries interleaved — no aboveEditor widget to clear
         wallTimeHistory = [];
         agentStartMs = null;
+        agentBaselineTotals = null;
+        liveBorder.setAgentBaseline(null);
         footerState = {
             ...footerState,
             workingSince: undefined,
@@ -591,9 +598,21 @@ export default function (pi) {
     const refreshAllLive = () => {
         liveBorder.render();
     };
-    pi.on("agent_start", (e) => {
+    pi.on("agent_start", (e, ctx) => {
         telemetryTracker.handle(e);
         runActivityTracker.startRun();
+        // Capture baseline totals for per-agent delta (live input 18k not 279k = totals - baseline)
+        try {
+            // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+            const baselineCtx = (ctx ?? lastSessionCtx);
+            if (baselineCtx?.sessionManager?.getEntries) {
+                agentBaselineTotals = getUsageTotals(baselineCtx);
+                liveBorder.setAgentBaseline(agentBaselineTotals);
+            }
+        }
+        catch {
+            // SAFETY: best-effort, ignore recoverable error
+        }
         // timeline stays permanently between each run — do not hide on start
         agentStartMs = Date.now();
         footerState = {
@@ -604,10 +623,15 @@ export default function (pi) {
         startLiveTick();
         refreshAllLive();
     });
+    pi.on("agent_end", (e) => {
+        // Alias for agent_settled — ensure tracker resets even if only agent_end is emitted
+        telemetryTracker.handle(e);
+        runActivityTracker.settle();
+    });
     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) {
@@ -691,10 +715,34 @@ 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 now mirror telemetry (per-agent) not session totals — input known at turn_start via liveInputTokens
-                const telInput = tel ? tel.inputTokens : totals.input;
-                const telOutput = tel ? tel.outputTokens : totals.output;
-                const telCost = tel ? tel.costUsd : 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;
+                let telOutput;
+                let telCost;
+                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;
+                    telCost = totals.cost;
+                }
                 const line1Parts = [dt];
                 if (currentConfig.timeline.wallTime)
                     line1Parts.push(wallDur);
@@ -724,7 +772,8 @@ export default function (pi) {
                 wallText);
             }
         }
-        catch { // SAFETY: best-effort, ignore recoverable error
+        catch {
+            // SAFETY: best-effort, ignore recoverable error
             // SAFETY: best-effort, ignore recoverable error
         }
         // final settled telemetry overwrites live peek with authoritative totals

package/dist/live-border.js

@@ -20,9 +20,14 @@ export class LiveBorder {
     timer = null;
     lastRenderMs = 0;
     pendingRender = null;
+    agentBaseline = null;
     constructor(deps) {
         this.deps = deps;
     }
+    /** Set baseline totals at agent_start for per-agent delta (input/output/cost). */
+    setAgentBaseline(baseline) {
+        this.agentBaseline = baseline ? { ...baseline } : null;
+    }
     /** Coalesced render: top (run-activity) + bottom (telemetry) + context bar → editor. */
     render() {
         const now = Date.now();
@@ -191,12 +196,87 @@ export class LiveBorder {
             // Tokens line above model info — left aligned, no border; hidden at startup per user request
             let tokensText = "";
             if (cfg.telemetry.enabled && cfg.telemetry.tokens) {
-                // Live input/output per agent run (option B) — cumulative across turns in this agent, like live output
-                // SAFETY: pi seam — intentional unsafe cast, validated at runtime — telemetry tracker for top tokens line (agent run)
-                const tracker = this.deps.telemetryTracker;
-                const live = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
-                if (live) {
-                    tokensText = formatTelemetryTokens(live, theme, cfg.telemetry, glyphs);
+                const isRunning = this.deps.runActivityTracker.isRunning();
+                // 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;
+                    // 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: displayInput,
+                        outputTokens: displayOutput,
+                        stallMs: 0,
+                        stallCount: 0,
+                        rateUsdPerMTokens: null,
+                        generationMs: 0,
+                        totalTokens: displayInput + displayOutput,
+                        costUsd: displayCost,
+                        measurementMs: null,
+                    };
+                    tokensText = formatTelemetryTokens(deltaTel, theme, cfg.telemetry, glyphs);
+                }
+                else {
+                    // 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 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);
+                    }
                 }
             }
             editor.setTopContextText(contextText);

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;
@@ -225,11 +227,10 @@ export class TurnTelemetryTracker {
     handle(event) {
         switch (event.type) {
             case "agent_start":
-                if (this.agentStartMs === null) {
-                    this.agentStartMs = this.now();
-                    this.agentTurns = [];
-                }
+                this.agentStartMs = this.now();
+                this.agentTurns = [];
                 return;
+            case "agent_end":
             case "agent_settled":
                 return this.endAgent();
             case "turn_start":
@@ -398,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,8 +18,7 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   },
-  "version": "0.6.0",
-  "main": "./dist/index.js",
+  "version": "0.6.2",
   "files": [
     "dist",
     "src",

package/src/index.ts

@@ -122,8 +122,8 @@ let lastSessionCtx: ExtensionContextLike | null = null;
 let extensionPi: unknown = null;
 let wallTimeHistory: string[] = []; // kept for compat, not used for widget
 const timeline = new TranscriptTimeline({
-  getLastSessionCtx: () => lastSessionCtx,
-  getTuiRef: () => tuiRef,
+	getLastSessionCtx: () => lastSessionCtx,
+	getTuiRef: () => tuiRef,
 });
 void timeline; // keep import used while now using pi.appendEntry interleaved path
 let currentConfig: ThemeConfig = loadConfig();
@@ -140,6 +140,7 @@ const REFRESH_MS = 1000;
 let liveTickTimer: ReturnType<typeof setInterval> | null = null;
 let footerState: FooterState = createInitialState();
 let agentStartMs: number | null = null;
+let agentBaselineTotals: ReturnType<typeof getUsageTotals> | null = null;
 let currentModelInfo: ModelInfo = {
 	provider: "",
 	modelId: "unknown",
@@ -267,28 +268,31 @@ function formatDateTimeWithTimezone(d: Date = new Date()): string {
 		// en-CA gives YYYY-MM-DD, HH:MM:SS
 		return `${get("year")}-${get("month")}-${get("day")} ${get("hour")}:${get("minute")}:${get("second")} ${tz}`.trim();
 	} catch {
-	  // SAFETY: best-effort, ignore recoverable error
+		// SAFETY: best-effort, ignore recoverable error
 		return d.toLocaleString();
 	}
 }
 
 function injectTimelineDimLine(
-  _ctx: ExtensionUIContextLike,
-  rawLine: string,
+	_ctx: ExtensionUIContextLike,
+	rawLine: string,
 ): void {
-  // Use pi.appendEntry so it is interleaved in chat container (not aboveEditor stacked widget)
-  try {
-    // SAFETY: pi custom entry is TUI-only, not sent to LLM
-    (extensionPi as unknown as { appendEntry?: (t:string,d:unknown)=>void })?.appendEntry?.("timeline", { text: rawLine });
-  } catch {// SAFETY: best-effort, ignore recoverable error
-    // SAFETY: best-effort, ignore recoverable error
-}
-  // keep legacy array in sync
-  wallTimeHistory = [...wallTimeHistory, rawLine];
+	// Use pi.appendEntry so it is interleaved in chat container (not aboveEditor stacked widget)
+	try {
+		// SAFETY: pi custom entry is TUI-only, not sent to LLM
+		(
+			extensionPi as unknown as { appendEntry?: (t: string, d: unknown) => void }
+		)?.appendEntry?.("timeline", { text: rawLine });
+	} catch {
+		// SAFETY: best-effort, ignore recoverable error
+		// SAFETY: best-effort, ignore recoverable error
+	}
+	// keep legacy array in sync
+	wallTimeHistory = [...wallTimeHistory, rawLine];
 }
 function clearTimelineHistory(_ctx?: ExtensionUIContextLike): void {
-  // No widget to clear — entries are interleaved and persist with session
-  wallTimeHistory = [];
+	// No widget to clear — entries are interleaved and persist with session
+	wallTimeHistory = [];
 }
 
 /** shift+up/down handler: scroll the detail window one line, clamped. */
@@ -435,30 +439,36 @@ export default function (pi: ExtensionAPILike): void {
 	extensionPi = pi;
 	let watchTimer: ReturnType<typeof setInterval> | null = null;
 	let deferredInstallTimer: ReturnType<typeof setTimeout> | null = null;
-  // Timeline now uses pi.appendEntry("timeline") interleaved in chat container — not aboveEditor widget
-  // Register renderer for timeline custom entries (dim, left-aligned, interleaved)
-  try {
-    // SAFETY: pi entry renderer is public API — timeline entries are TUI-only, not sent to LLM
-    (pi as unknown as { registerEntryRenderer?: (t:string, r:unknown)=>void }).registerEntryRenderer?.(
-      "timeline",
-      (entry: unknown, _opts: unknown, theme: unknown) => {
-        const data = (entry as { data?: { text?: string } }).data;
-        const text = data?.text ?? "";
-        const lines = text.split("\n").map((l: string) => {
-          try {
-            return (theme as { fg: (c:string,s:string)=>string }).fg("dim", " " + l);
-          } catch {
-            // SAFETY: best-effort, ignore recoverable error
-            return " " + l;
-          }
-        });
-        // SAFETY: intentional unsafe cast — validated at runtime
-        return new Text(lines.join("\n")) as unknown as Component;
-      },
-    );
-  } catch {// SAFETY: best-effort, ignore recoverable error
-    // SAFETY: best-effort, ignore recoverable error
-}
+	// Timeline now uses pi.appendEntry("timeline") interleaved in chat container — not aboveEditor widget
+	// Register renderer for timeline custom entries (dim, left-aligned, interleaved)
+	try {
+		// SAFETY: pi entry renderer is public API — timeline entries are TUI-only, not sent to LLM
+		(
+			pi as unknown as { registerEntryRenderer?: (t: string, r: unknown) => void }
+		).registerEntryRenderer?.(
+			"timeline",
+			(entry: unknown, _opts: unknown, theme: unknown) => {
+				const data = (entry as { data?: { text?: string } }).data;
+				const text = data?.text ?? "";
+				const lines = text.split("\n").map((l: string) => {
+					try {
+						return (theme as { fg: (c: string, s: string) => string }).fg(
+							"dim",
+							" " + l,
+						);
+					} catch {
+						// SAFETY: best-effort, ignore recoverable error
+						return " " + l;
+					}
+				});
+				// SAFETY: intentional unsafe cast — validated at runtime
+				return new Text(lines.join("\n")) as unknown as Component;
+			},
+		);
+	} catch {
+		// SAFETY: best-effort, ignore recoverable error
+		// SAFETY: best-effort, ignore recoverable error
+	}
 	let headerCleanupInner: (() => void) | null = null;
 
 	// Toggle the border glow + model label (off restores pi's stock border).
@@ -602,7 +612,8 @@ export default function (pi: ExtensionAPILike): void {
 
 		currentModelInfo = modelInfoOf(ctx);
 		lastSessionCtx = ctx;
-
+		agentBaselineTotals = null;
+		liveBorder.setAgentBaseline(null);
 		// Deferred so we win the single editor slot (see installEditor).
 		deferredInstallTimer = setTimeout(() => installEditor(ctx.ui), 0);
 
@@ -703,10 +714,12 @@ export default function (pi: ExtensionAPILike): void {
 	// before re-evaluating the module on /reload). Any timer that captured this
 	// session's ctx must be dead before then — otherwise its next tick hits the
 	// stale `ctx.ui` getter and assertActive() throws, crashing the process.
-	  pi.on("session_shutdown", () => {
-    // timeline entries are custom entries interleaved — no aboveEditor widget to clear
-    wallTimeHistory = [];
+	pi.on("session_shutdown", () => {
+		// timeline entries are custom entries interleaved — no aboveEditor widget to clear
+		wallTimeHistory = [];
 		agentStartMs = null;
+		agentBaselineTotals = null;
+		liveBorder.setAgentBaseline(null);
 		footerState = {
 			...footerState,
 			workingSince: undefined,
@@ -755,9 +768,22 @@ export default function (pi: ExtensionAPILike): void {
 		liveBorder.render();
 	};
 
-	pi.on("agent_start", (e) => {
+	pi.on("agent_start", (e, ctx) => {
 		telemetryTracker.handle(e as never);
 		runActivityTracker.startRun();
+		// Capture baseline totals for per-agent delta (live input 18k not 279k = totals - baseline)
+		try {
+			// SAFETY: pi seam — intentional unsafe cast, validated at runtime
+			const baselineCtx = (ctx ?? lastSessionCtx) as unknown as Parameters<
+				typeof getUsageTotals
+			>[0];
+			if (baselineCtx?.sessionManager?.getEntries) {
+				agentBaselineTotals = getUsageTotals(baselineCtx);
+				liveBorder.setAgentBaseline(agentBaselineTotals);
+			}
+		} catch {
+			// SAFETY: best-effort, ignore recoverable error
+		}
 		// timeline stays permanently between each run — do not hide on start
 		agentStartMs = Date.now();
 		footerState = {
@@ -768,12 +794,16 @@ export default function (pi: ExtensionAPILike): void {
 		startLiveTick();
 		refreshAllLive();
 	});
+	pi.on("agent_end", (e) => {
+		// Alias for agent_settled — ensure tracker resets even if only agent_end is emitted
+		telemetryTracker.handle(e as never);
+		runActivityTracker.settle();
+	});
 	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) &&
@@ -864,10 +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 now mirror telemetry (per-agent) not session totals — input known at turn_start via liveInputTokens
-				const telInput = tel ? tel.inputTokens : totals.input;
-				const telOutput = tel ? tel.outputTokens : totals.output;
-				const telCost = tel ? tel.costUsd : 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)
@@ -894,9 +948,10 @@ export default function (pi: ExtensionAPILike): void {
 					wallText,
 				);
 			}
-		} catch {// SAFETY: best-effort, ignore recoverable error
-		  // SAFETY: best-effort, ignore recoverable error
-}
+		} catch {
+			// SAFETY: best-effort, ignore recoverable error
+			// SAFETY: best-effort, ignore recoverable error
+		}
 		// final settled telemetry overwrites live peek with authoritative totals
 		if (tel && installedEditor && currentConfig.telemetry.enabled) {
 			try {

package/src/live-border.ts

@@ -23,6 +23,7 @@ import {
   formatTurnDuration,
   formatTurnTelemetry,
 } from "./telemetry.js";
+import type { UsageTotals } from "./state.js";
 import type { TurnTelemetry } from "./telemetry.js";
 import type { TurnTelemetryTracker } from "./telemetry.js";
 import type { ThemeConfig } from "./config.js";
@@ -43,9 +44,15 @@ export class LiveBorder {
   private timer: ReturnType<typeof setInterval> | null = null;
   private lastRenderMs = 0;
   private pendingRender: ReturnType<typeof setTimeout> | null = null;
+  private agentBaseline: UsageTotals | null = null;
 
   constructor(private readonly deps: LiveBorderDeps) {}
 
+  /** Set baseline totals at agent_start for per-agent delta (input/output/cost). */
+  setAgentBaseline(baseline: UsageTotals | null): void {
+    this.agentBaseline = baseline ? { ...baseline } : null;
+  }
+
   /** Coalesced render: top (run-activity) + bottom (telemetry) + context bar → editor. */
   render(): void {
     const now = Date.now();
@@ -237,21 +244,105 @@ export class LiveBorder {
       // Tokens line above model info — left aligned, no border; hidden at startup per user request
       let tokensText = "";
       if (cfg.telemetry.enabled && cfg.telemetry.tokens) {
-        // Live input/output per agent run (option B) — cumulative across turns in this agent, like live output
-        // SAFETY: pi seam — intentional unsafe cast, validated at runtime — telemetry tracker for top tokens line (agent run)
-        const tracker = this.deps.telemetryTracker as unknown as {
-          // SAFETY: pi seam — intentional unsafe cast, validated at runtime
-          peekAgentLive(): import("./telemetry.js").TurnTelemetry | null;
-          getLastTelemetry(): import("./telemetry.js").TurnTelemetry | null;
-        };
-        const live = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
-        if (live) {
+        const isRunning = this.deps.runActivityTracker.isRunning();
+        // 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;
+          // 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: displayInput,
+            outputTokens: displayOutput,
+            stallMs: 0,
+            stallCount: 0,
+            rateUsdPerMTokens: null,
+            generationMs: 0,
+            totalTokens: displayInput + displayOutput,
+            costUsd: displayCost,
+            measurementMs: null,
+          };
           tokensText = formatTelemetryTokens(
-            live,
+            deltaTel,
             theme as never,
             cfg.telemetry,
             glyphs as never,
           );
+        } else {
+          // 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 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 as never,
+              cfg.telemetry,
+              glyphs as never,
+            );
+          }
         }
       }
       editor.setTopContextText(contextText);

package/src/telemetry.ts

@@ -60,6 +60,7 @@ type AgentMessage = { role: string } & AssistantMessage;
 
 export type TelemetryEvent =
   | { type: "agent_start" }
+  | { type: "agent_end" }
   | { type: "agent_settled" }
   | {
       type: "turn_start";
@@ -184,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;
@@ -196,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 =
@@ -329,11 +332,10 @@ export class TurnTelemetryTracker {
   handle(event: TelemetryEvent): TurnTelemetry | undefined {
     switch (event.type) {
       case "agent_start":
-        if (this.agentStartMs === null) {
-          this.agentStartMs = this.now();
-          this.agentTurns = [];
-        }
+        this.agentStartMs = this.now();
+        this.agentTurns = [];
         return;
+      case "agent_end":
       case "agent_settled":
         return this.endAgent();
       case "turn_start":
@@ -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);