pi-editor-footer 0.5.0 → 0.6.1

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [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
+
+- Context usage colors now `12.5%`/`25%`/`50%` quotas — `dim` 0-12.5 → `accent` 12.5-25 → `warning` 25-50 → `error` 50-100 via `color-policy:contextUsageColor` (was `25%`/`50%`/`75%`), respects theme semantic tokens
+- Live `↑`/`↓` tokens now per agent run (option B) — cumulative across turns in this agent via `telemetry:peekAgentLive()` + `live-border` top `↑`/`↓` (was per-turn via `getLastTurnTelemetry`), `getLastTelemetry` stays agent sum
+- Stall relocated from bottom telemetry to top right of tool use with `dim |` pipe — `run-activity` now `tools | !2×3.3s` top, bottom `telemetry:formatTurnTelemetry` now `TPS · TTFT` only (suppressed `stalls:false`)
+
 ## [0.5.0] - 2026-08-22
 
 ### Changed

package/dist/color-policy.js

@@ -6,13 +6,21 @@ export function stressColor(value, warn = 70, danger = 90) {
     return "accent";
 }
 export function contextUsageColor(pct) {
-    // 25% 50% 75% thresholds — transit from dimmed (low) to highlight (high)
-    // for intuitive quota status: dim (<25) → accent (25-50) → warning (50-75) → error (≥75)
-    if (pct >= 75)
-        return "error";
+    // 12.5 / 25 / 50 quotas — four urgency tiers, increasingly aggressive as context fills.
+    // 0 – 12.5%  dim      — plenty of headroom, visually quiet.
+    // 12.5 – 25% accent   — first nudge, noticeable but calm.
+    // 25 – 50%   warning  — half consumed, needs attention.
+    // 50 – 100%  error     — critical, about to run out.
+    // Uses theme semantic tokens (dim/accent/warning/error) so the progression
+    // respects the active theme and remains legible on light/dark/custom palettes.
+    // A fixed hex palette (e.g. grey→sky→amber→red) would be more vivid but
+    // would ignore the user's theme and can clash with light backgrounds —
+    // semantic tokens keep the "aggressive" ordering while staying theme-coherent.
     if (pct >= 50)
-        return "warning";
+        return "error";
     if (pct >= 25)
+        return "warning";
+    if (pct >= 12.5)
         return "accent";
     return "dim";
 }

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,6 +623,11 @@ 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
@@ -691,10 +715,26 @@ 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: prefer baseline delta (totals - baseline) which yields 18k (279k-261k) not 279k total.
+                // Fallback to tel (tracker sum) then session totals.
+                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) {
+                    telInput = tel.inputTokens;
+                    telOutput = tel.outputTokens;
+                    telCost = tel.costUsd;
+                }
+                else {
+                    telInput = totals.input;
+                    telOutput = totals.output;
+                    telCost = totals.cost;
+                }
                 const line1Parts = [dt];
                 if (currentConfig.timeline.wallTime)
                     line1Parts.push(wallDur);
@@ -724,7 +764,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

@@ -13,16 +13,21 @@
 import { createChromeSnapshot, formatTopContextFromSnapshot, } from "./chrome-state.js";
 import { resolveGlyphs, resolveIconMode } from "./icons.js";
 import { formatRunActivityTopRight } from "./run-activity.js";
-import { formatTelemetryTokens, formatTurnTelemetry } from "./telemetry.js";
+import { formatTelemetryTokens, formatTurnDuration, formatTurnTelemetry, } from "./telemetry.js";
 export const REFRESH_MS = 1000;
 export class LiveBorder {
     deps;
     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();
@@ -92,13 +97,33 @@ export class LiveBorder {
     refreshTopBorder() {
         const editor = this.deps.getEditor();
         const ctx = this.deps.getCtx();
+        const cfg = this.deps.getConfig();
         if (!editor || !ctx)
             return;
         try {
-            // SAFETY: theme is live pi TUI theme read at render time
-            const theme = ctx.ui.theme; // SAFETY: pi seam — intentional unsafe cast, validated at runtime // SAFETY: pi seam
+            // SAFETY: theme is live pi TUI theme read at render time — intentional unsafe cast, validated at runtime
+            const theme = ctx.ui.theme; // SAFETY: pi seam — intentional unsafe cast, validated at runtime
             const snap = this.deps.runActivityTracker.getSnapshot();
-            const text = formatRunActivityTopRight(snap, theme);
+            let text = formatRunActivityTopRight(snap, theme);
+            // Relocate stall to the right of tool use with pipe separator — agent-run live (option B), not bottom telemetry
+            if (cfg.telemetry.enabled && cfg.telemetry.stalls) {
+                // SAFETY: pi seam — intentional unsafe cast, validated at runtime — telemetry tracker for stall (agent run, option B)
+                const tracker = this.deps.telemetryTracker;
+                const tel = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
+                if (tel && tel.stallMs > 0) {
+                    const glyphs = resolveGlyphs(cfg.icons.mode);
+                    // SAFETY: pi seam — intentional unsafe cast, validated at runtime — theme fg
+                    const stallText = theme.fg("warning", `${glyphs.stall}${tel.stallCount}×${formatTurnDuration(tel.stallMs).trim()}`);
+                    if (text) {
+                        // SAFETY: pi seam — intentional unsafe cast, validated at runtime — theme fg for pipe
+                        const pipe = theme.fg("dim", " | ");
+                        text = `${text}${pipe}${stallText}`;
+                    }
+                    else {
+                        text = stallText;
+                    }
+                }
+            }
             editor.setTopRightText(text);
         }
         catch {
@@ -122,15 +147,17 @@ export class LiveBorder {
             return;
         }
         try {
-            // SAFETY: peekLive ?? getLastTelemetry preserves cost after toggle (AGENTS.md gotcha)
+            // SAFETY: peekLive ?? getLastTelemetry preserves cost after toggle (AGENTS.md gotcha) — intentional unsafe cast, validated at runtime
             const live = this.deps.telemetryTracker.peekLive() ??
                 this.deps.telemetryTracker.getLastTelemetry();
             if (!live)
                 return;
-            // SAFETY: pi TUI seam read-only - theme from extension context
-            const theme = ctx?.ui?.theme; // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+            // SAFETY: pi seam — intentional unsafe cast, validated at runtime — theme from extension context
+            const theme = ctx?.ui?.theme;
             const glyphs = resolveGlyphs(cfg.icons.mode);
-            const right = formatTurnTelemetry(live, theme, cfg.telemetry, glyphs);
+            // Stall relocated to top right of tool use with pipe — suppress in bottom telemetry
+            const bottomCfg = { ...cfg.telemetry, stalls: false };
+            const right = formatTurnTelemetry(live, theme, bottomCfg, glyphs);
             if (live.totalMs > 0) {
                 editor.setTelemetryText(right);
                 editor.setBottomLeftText("");
@@ -169,11 +196,40 @@ 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) {
-                // SAFETY: pi TUI seam - telemetry tokens for top tokens line
-                const live = this.deps.telemetryTracker.peekLive() ??
-                    this.deps.telemetryTracker.getLastTelemetry();
-                if (live) {
-                    tokensText = formatTelemetryTokens(live, theme, cfg.telemetry, glyphs);
+                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.
+                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)
+                    const deltaTel = {
+                        tps: null,
+                        ttftMs: 0,
+                        totalMs: 0,
+                        inputTokens: deltaInput,
+                        outputTokens: deltaOutput,
+                        stallMs: 0,
+                        stallCount: 0,
+                        rateUsdPerMTokens: null,
+                        generationMs: 0,
+                        totalTokens: deltaInput + deltaOutput,
+                        costUsd: Math.max(0, cur.cost - base.cost),
+                        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)
+                    const tracker = this.deps.telemetryTracker;
+                    const live = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
+                    if (live) {
+                        tokensText = formatTelemetryTokens(live, theme, cfg.telemetry, glyphs);
+                    }
                 }
             }
             editor.setTopContextText(contextText);

package/dist/telemetry.js

@@ -50,6 +50,7 @@ export class TurnTelemetryTracker {
     agentStartMs = null;
     agentTurns = [];
     lastTelemetry = null;
+    lastTurnTelemetry = null;
     decayBaseTps = null;
     decayStartMs = null;
     constructor(now = () => performance.now()) {
@@ -58,6 +59,78 @@ export class TurnTelemetryTracker {
     getLastTelemetry() {
         return this.lastTelemetry;
     }
+    getLastTurnTelemetry() {
+        return this.lastTurnTelemetry;
+    }
+    /** Agent-run live: cumulative across turns in current agent, including current live turn. Option B. */
+    peekAgentLive() {
+        // No agent active -> show last agent sum (option B) or current live turn if any
+        if (this.agentStartMs === null) {
+            const live = this.peekLive();
+            if (live)
+                return live;
+            return this.lastTelemetry ?? this.lastTurnTelemetry;
+        }
+        const live = this.peekLive();
+        const hasCompleted = this.agentTurns.length > 0;
+        if (!hasCompleted && !live)
+            return null;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let totalTokens = 0;
+        let costUsd = 0;
+        let stallMs = 0;
+        let stallCount = 0;
+        let generationMs = 0;
+        let ttftMs = 0;
+        // sum completed turns
+        for (const t of this.agentTurns) {
+            inputTokens += t.inputTokens;
+            outputTokens += t.outputTokens;
+            totalTokens += t.totalTokens;
+            costUsd += t.costUsd;
+            stallMs += t.stallMs;
+            stallCount += t.stallCount;
+            generationMs += t.generationMs;
+        }
+        if (this.agentTurns.length > 0)
+            ttftMs = this.agentTurns[0].ttftMs;
+        if (live) {
+            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;
+        }
+        const now = this.now();
+        const totalMs = Math.max(0, now - this.agentStartMs);
+        const measurementMs = outputTokens > 0 && generationMs > 0 ? generationMs : null;
+        const tps = measurementMs === null
+            ? null
+            : round(outputTokens / (measurementMs / 1000), 1);
+        const validCost = Number.isFinite(costUsd) && costUsd > 0;
+        const validTokens = Number.isFinite(totalTokens) && totalTokens > 0;
+        return {
+            tps,
+            ttftMs,
+            totalMs,
+            inputTokens,
+            outputTokens,
+            stallMs,
+            stallCount,
+            rateUsdPerMTokens: validCost && validTokens
+                ? round(costUsd / (totalTokens / 1_000_000), 2)
+                : null,
+            generationMs,
+            totalTokens,
+            costUsd: validCost ? costUsd : 0,
+            measurementMs,
+        };
+    }
     /** Live snapshot while a turn is running — for real-time border refresh. Returns null when idle. */
     peekLive() {
         const turn = this.turn;
@@ -152,11 +225,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":
@@ -269,8 +341,10 @@ export class TurnTelemetryTracker {
         const telemetry = this.endTurn();
         if (telemetry && this.agentStartMs !== null)
             this.agentTurns.push(telemetry);
-        if (telemetry)
+        if (telemetry) {
+            this.lastTurnTelemetry = telemetry;
             this.lastTelemetry = telemetry;
+        }
         return telemetry;
     }
     endTurn() {
@@ -351,10 +425,11 @@ export class TurnTelemetryTracker {
             measurementMs,
         };
         this.lastTelemetry = result;
+        // keep lastTurnTelemetry as last turn's per-turn telemetry (live input stays per-turn, not agent total)
         return result;
     }
 }
-function formatTurnDuration(ms) {
+export function formatTurnDuration(ms) {
     if (ms < 60_000) {
         // TTFT fixed width: 2-digit integer + one decimal -> padded 4 + "s" =5, then overall duration field padded to 7 for telemetry totalMs
         // For TTFT we want 5, for duration we want 7 — caller will pad accordingly, so here return 5 for <60s case

package/package.json

@@ -18,8 +18,7 @@
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   },
-  "version": "0.5.0",
-  "main": "./dist/index.js",
+  "version": "0.6.1",
   "files": [
     "dist",
     "src",

package/src/color-policy.ts

@@ -8,11 +8,19 @@ export function stressColor(value: number, warn = 70, danger = 90): ThemeColor {
 }
 
 export function contextUsageColor(pct: number): ThemeColor {
-  // 25% 50% 75% thresholds — transit from dimmed (low) to highlight (high)
-  // for intuitive quota status: dim (<25) → accent (25-50) → warning (50-75) → error (≥75)
-  if (pct >= 75) return "error";
-  if (pct >= 50) return "warning";
-  if (pct >= 25) return "accent";
+  // 12.5 / 25 / 50 quotas — four urgency tiers, increasingly aggressive as context fills.
+  // 0 – 12.5%  dim      — plenty of headroom, visually quiet.
+  // 12.5 – 25% accent   — first nudge, noticeable but calm.
+  // 25 – 50%   warning  — half consumed, needs attention.
+  // 50 – 100%  error     — critical, about to run out.
+  // Uses theme semantic tokens (dim/accent/warning/error) so the progression
+  // respects the active theme and remains legible on light/dark/custom palettes.
+  // A fixed hex palette (e.g. grey→sky→amber→red) would be more vivid but
+  // would ignore the user's theme and can clash with light backgrounds —
+  // semantic tokens keep the "aggressive" ordering while staying theme-coherent.
+  if (pct >= 50) return "error";
+  if (pct >= 25) return "warning";
+  if (pct >= 12.5) return "accent";
   return "dim";
 }
 

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,6 +794,11 @@ 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 = (
@@ -864,10 +895,24 @@ 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: 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;
+				}
 				const line1Parts: string[] = [dt];
 				if (currentConfig.timeline.wallTime) line1Parts.push(wallDur);
 				else line1Parts.push(wallDur); // wall time always per spec (11s)
@@ -894,9 +939,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

@@ -18,7 +18,12 @@ import {
 import { resolveGlyphs, resolveIconMode } from "./icons.js";
 import { formatRunActivityTopRight } from "./run-activity.js";
 import type { RunActivityTracker } from "./run-activity.js";
-import { formatTelemetryTokens, formatTurnTelemetry } from "./telemetry.js";
+import {
+  formatTelemetryTokens,
+  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";
@@ -39,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();
@@ -113,14 +124,43 @@ export class LiveBorder {
   private refreshTopBorder(): void {
     const editor = this.deps.getEditor();
     const ctx = this.deps.getCtx();
+    const cfg = this.deps.getConfig();
     if (!editor || !ctx) return;
     try {
-      // SAFETY: theme is live pi TUI theme read at render time
+      // SAFETY: theme is live pi TUI theme read at render time — intentional unsafe cast, validated at runtime
       const theme = (
         ctx.ui as unknown as { theme: { fg(s: string, t: string): string } }
-      ).theme; // SAFETY: pi seam — intentional unsafe cast, validated at runtime // SAFETY: pi seam
+      ).theme; // SAFETY: pi seam — intentional unsafe cast, validated at runtime
       const snap = this.deps.runActivityTracker.getSnapshot();
-      const text = formatRunActivityTopRight(snap, theme as never);
+      let text = formatRunActivityTopRight(snap, theme as never);
+      // Relocate stall to the right of tool use with pipe separator — agent-run live (option B), not bottom telemetry
+      if (cfg.telemetry.enabled && cfg.telemetry.stalls) {
+        // SAFETY: pi seam — intentional unsafe cast, validated at runtime — telemetry tracker for stall (agent run, option B)
+        const tracker = this.deps.telemetryTracker as unknown as {
+          peekAgentLive(): import("./telemetry.js").TurnTelemetry | null;
+          getLastTelemetry(): import("./telemetry.js").TurnTelemetry | null;
+        };
+        const tel = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
+        if (tel && tel.stallMs > 0) {
+          const glyphs = resolveGlyphs(cfg.icons.mode);
+          // SAFETY: pi seam — intentional unsafe cast, validated at runtime — theme fg
+          const stallText = (
+            theme as unknown as { fg: (s: string, t: string) => string }
+          ).fg(
+            "warning",
+            `${glyphs.stall}${tel.stallCount}×${formatTurnDuration(tel.stallMs).trim()}`,
+          );
+          if (text) {
+            // SAFETY: pi seam — intentional unsafe cast, validated at runtime — theme fg for pipe
+            const pipe = (
+              theme as unknown as { fg: (s: string, t: string) => string }
+            ).fg("dim", " | ");
+            text = `${text}${pipe}${stallText}`;
+          } else {
+            text = stallText;
+          }
+        }
+      }
       editor.setTopRightText(text);
     } catch {
       // SAFETY: best-effort UI, ignore recoverable error
@@ -142,18 +182,20 @@ export class LiveBorder {
       return;
     }
     try {
-      // SAFETY: peekLive ?? getLastTelemetry preserves cost after toggle (AGENTS.md gotcha)
+      // SAFETY: peekLive ?? getLastTelemetry preserves cost after toggle (AGENTS.md gotcha) — intentional unsafe cast, validated at runtime
       const live =
         this.deps.telemetryTracker.peekLive() ??
         this.deps.telemetryTracker.getLastTelemetry();
       if (!live) return;
-      // SAFETY: pi TUI seam read-only - theme from extension context
-      const theme = (ctx as unknown as { ui?: { theme?: unknown } })?.ui?.theme; // SAFETY: pi seam — intentional unsafe cast, validated at runtime
+      // SAFETY: pi seam — intentional unsafe cast, validated at runtime — theme from extension context
+      const theme = (ctx as unknown as { ui?: { theme?: unknown } })?.ui?.theme;
       const glyphs = resolveGlyphs(cfg.icons.mode);
+      // Stall relocated to top right of tool use with pipe — suppress in bottom telemetry
+      const bottomCfg = { ...cfg.telemetry, stalls: false };
       const right = formatTurnTelemetry(
         live,
         theme as never,
-        cfg.telemetry,
+        bottomCfg as never,
         glyphs as never,
       );
       if (live.totalMs > 0) {
@@ -202,17 +244,52 @@ 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) {
-        // SAFETY: pi TUI seam - telemetry tokens for top tokens line
-        const live =
-          this.deps.telemetryTracker.peekLive() ??
-          this.deps.telemetryTracker.getLastTelemetry();
-        if (live) {
+        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.
+        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)
+          const deltaTel: TurnTelemetry = {
+            tps: null,
+            ttftMs: 0,
+            totalMs: 0,
+            inputTokens: deltaInput,
+            outputTokens: deltaOutput,
+            stallMs: 0,
+            stallCount: 0,
+            rateUsdPerMTokens: null,
+            generationMs: 0,
+            totalTokens: deltaInput + deltaOutput,
+            costUsd: Math.max(0, cur.cost - base.cost),
+            measurementMs: null,
+          };
           tokensText = formatTelemetryTokens(
-            live,
+            deltaTel,
             theme as never,
             cfg.telemetry,
             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)
+          const tracker = this.deps.telemetryTracker as unknown as {
+            peekAgentLive(): import("./telemetry.js").TurnTelemetry | null;
+            getLastTelemetry(): import("./telemetry.js").TurnTelemetry | null;
+          };
+          const live = tracker.peekAgentLive() ?? tracker.getLastTelemetry();
+          if (live) {
+            tokensText = formatTelemetryTokens(
+              live,
+              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";
@@ -150,9 +151,9 @@ export class TurnTelemetryTracker {
   private agentStartMs: number | null = null;
   private agentTurns: TurnTelemetry[] = [];
   private lastTelemetry: TurnTelemetry | null = null;
+  private lastTurnTelemetry: TurnTelemetry | null = null;
   private decayBaseTps: number | null = null;
   private decayStartMs: number | null = null;
-
   constructor(now: () => number = () => performance.now()) {
     this.now = now;
   }
@@ -160,6 +161,79 @@ export class TurnTelemetryTracker {
   getLastTelemetry(): TurnTelemetry | null {
     return this.lastTelemetry;
   }
+
+  getLastTurnTelemetry(): TurnTelemetry | null {
+    return this.lastTurnTelemetry;
+  }
+
+  /** Agent-run live: cumulative across turns in current agent, including current live turn. Option B. */
+  peekAgentLive(): TurnTelemetry | null {
+    // No agent active -> show last agent sum (option B) or current live turn if any
+    if (this.agentStartMs === null) {
+      const live = this.peekLive();
+      if (live) return live;
+      return this.lastTelemetry ?? this.lastTurnTelemetry;
+    }
+    const live = this.peekLive();
+    const hasCompleted = this.agentTurns.length > 0;
+    if (!hasCompleted && !live) return null;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let totalTokens = 0;
+    let costUsd = 0;
+    let stallMs = 0;
+    let stallCount = 0;
+    let generationMs = 0;
+    let ttftMs = 0;
+    // sum completed turns
+    for (const t of this.agentTurns) {
+      inputTokens += t.inputTokens;
+      outputTokens += t.outputTokens;
+      totalTokens += t.totalTokens;
+      costUsd += t.costUsd;
+      stallMs += t.stallMs;
+      stallCount += t.stallCount;
+      generationMs += t.generationMs;
+    }
+    if (this.agentTurns.length > 0) ttftMs = this.agentTurns[0]!.ttftMs;
+    if (live) {
+      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;
+    }
+    const now = this.now();
+    const totalMs = Math.max(0, now - this.agentStartMs);
+    const measurementMs =
+      outputTokens > 0 && generationMs > 0 ? generationMs : null;
+    const tps =
+      measurementMs === null
+        ? null
+        : round(outputTokens / (measurementMs / 1000), 1);
+    const validCost = Number.isFinite(costUsd) && costUsd > 0;
+    const validTokens = Number.isFinite(totalTokens) && totalTokens > 0;
+    return {
+      tps,
+      ttftMs,
+      totalMs,
+      inputTokens,
+      outputTokens,
+      stallMs,
+      stallCount,
+      rateUsdPerMTokens:
+        validCost && validTokens
+          ? round(costUsd / (totalTokens / 1_000_000), 2)
+          : null,
+      generationMs,
+      totalTokens,
+      costUsd: validCost ? costUsd : 0,
+      measurementMs,
+    };
+  }
   /** Live snapshot while a turn is running — for real-time border refresh. Returns null when idle. */
   peekLive(): TurnTelemetry | null {
     const turn = this.turn;
@@ -256,11 +330,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":
@@ -386,7 +459,10 @@ export class TurnTelemetryTracker {
     const telemetry = this.endTurn();
     if (telemetry && this.agentStartMs !== null)
       this.agentTurns.push(telemetry);
-    if (telemetry) this.lastTelemetry = telemetry;
+    if (telemetry) {
+      this.lastTurnTelemetry = telemetry;
+      this.lastTelemetry = telemetry;
+    }
     return telemetry;
   }
 
@@ -478,11 +554,12 @@ export class TurnTelemetryTracker {
       measurementMs,
     };
     this.lastTelemetry = result;
+    // keep lastTurnTelemetry as last turn's per-turn telemetry (live input stays per-turn, not agent total)
     return result;
   }
 }
 
-function formatTurnDuration(ms: number): string {
+export function formatTurnDuration(ms: number): string {
   if (ms < 60_000) {
     // TTFT fixed width: 2-digit integer + one decimal -> padded 4 + "s" =5, then overall duration field padded to 7 for telemetry totalMs
     // For TTFT we want 5, for duration we want 7 — caller will pad accordingly, so here return 5 for <60s case