pi-open-tui 0.2.4 → 0.2.6

package/README.md

@@ -12,8 +12,9 @@ A polished TUI for [Pi](https://pi.dev) coding agent. Combines the best of pi-ha
 - **60+ runtime detection** — Node, Rust, Go, Python, Ruby, Java, Swift, Kotlin, C/C++, Deno, Bun, and many more
 - **Git status** — branch, ahead/behind, modified/untracked/staged/stashed, detached HEAD commit hash + tag
 - **Working timer** — live elapsed time while the agent is working, done duration when finished
+- **Turn telemetry** — generation speed, TTFT, stalls, tokens, and list-price rate after each complete agent run
 - **Zero prototype patches** — uses public Pi APIs (setHeader/setFooter/setEditorComponent), safe across Pi updates
-- **Interactive settings UI** — `/open-tui` opens a tabbed settings dialog (Features / Icons / Segments)
+- **Interactive settings UI** — `/open-tui` opens a tabbed settings dialog (Features / Icons / Segments / Telemetry)
 
 ## Install
 
@@ -46,6 +47,15 @@ Run `/open-tui` to open the interactive settings UI. Configuration is stored at
     "context": true,
     "tokens": true,
     "cost": true
+  },
+  "telemetry": {
+    "enabled": true,
+    "tps": true,
+    "ttft": true,
+    "duration": true,
+    "tokens": true,
+    "stalls": true,
+    "cost": true
   }
 }
 ```
@@ -53,6 +63,18 @@ Run `/open-tui` to open the interactive settings UI. Configuration is stored at
 - `icons.mode`: `auto` (detect Nerd Font), `nerd` (force Nerd Font glyphs), or `ascii` (plain fallbacks)
 - `footerSegments.gitCommit`: shows short hash + tag on detached HEAD (off by default)
 
+## Turn telemetry
+
+After each complete agent run, open-tui shows one transient notification. Tool-call turns are aggregated into that single result:
+
+```text
+> TPS 42.5 tok/s | ~ TTFT 1.2s | + 29.7s | ↓ in 567 | ↑ out 1.2k | ! stall 1x / 4.3s | $ $3.60/M
+```
+
+The notification uses the footer's icon mode and semantic theme colors. Configure its master switch and individual TPS, TTFT, duration, token, stall, and cost segments from the **Telemetry** tab in `/open-tui`.
+
+TPS excludes time-to-first-token, detected stalls, and tool execution between messages. In a multi-turn agent run, it is weighted from the turns with measurable streaming spans; an unmeasurable tool turn no longer hides a measurable final response. A rate that cannot be identified reliably is shown as `TPS —`. The `stall` segment shows occurrence count followed by accumulated duration. The optional `$ / M` value uses the model's list-price `usage.cost.total`; it is not the session's cumulative cost shown in the footer.
+
 ## Local development
 
 ```bash
@@ -70,5 +92,6 @@ This project builds on the work of several Pi community packages:
 - **[pi-haiku](https://github.com/nnocte/pi-haiku)** — the 2-line footer structure (location+model · timer+context) and working-timer pattern
 - **[pi-claude-code-tui](https://github.com/Phoobobo/pi-claude-code-tui)** — the 16-frame animated Pi logo and rounded editor border technique
 - **[pi-zentui](https://github.com/lmilojevicc/pi-zentui)** — the Starship-style footer segments (git status icons, runtime detection, context gauge), generation-based session lifecycle, and interactive settings UI pattern
+- **[pi-tps](https://github.com/monotykamary/pi-tps)** — the turn timing, stall detection, and conservative TPS measurement approach
 
 The animated logo frames are derived from `pi-claude-code-tui`, which in turn derive from Pi's official install script (`pi.dev/install.sh`). The runtime detection list and git porcelain parsing borrow structure from `pi-zentui`.

package/extensions/open-tui/config.ts

@@ -16,12 +16,23 @@ export interface FooterSegments {
 	cost: boolean;
 }
 
+export interface TelemetryConfig {
+	enabled: boolean;
+	tps: boolean;
+	ttft: boolean;
+	duration: boolean;
+	tokens: boolean;
+	stalls: boolean;
+	cost: boolean;
+}
+
 export interface OpenTuiConfig {
 	enabled: boolean;
 	icons: {
 		mode: IconMode;
 	};
 	footerSegments: FooterSegments;
+	telemetry: TelemetryConfig;
 }
 
 export const DEFAULT_CONFIG: OpenTuiConfig = {
@@ -39,6 +50,15 @@ export const DEFAULT_CONFIG: OpenTuiConfig = {
 		tokens: true,
 		cost: true,
 	},
+	telemetry: {
+		enabled: true,
+		tps: true,
+		ttft: true,
+		duration: true,
+		tokens: true,
+		stalls: true,
+		cost: true,
+	},
 };
 
 export function getConfigPath(): string {

package/extensions/open-tui/icons.ts

@@ -12,6 +12,9 @@ export interface IconGlyphs {
 	output: string;
 	cacheHit: string;
 	cost: string;
+	speed: string;
+	latency: string;
+	stall: string;
 	extensions: string;
 	ahead: string;
 	behind: string;
@@ -37,6 +40,9 @@ const NERD_GLYPHS: IconGlyphs = {
 	output: "",
 	cacheHit: "",
 	cost: "",
+	speed: "󰓅",
+	latency: "",
+	stall: "",
 	extensions: "",
 	ahead: "↑",
 	behind: "↓",
@@ -61,10 +67,13 @@ const ASCII_GLYPHS: IconGlyphs = {
 	context: "%",
 	model: "M",
 	thinking: "~",
-	input: "↑",
-	output: "↓",
+	input: "↓",
+	output: "↑",
 	cacheHit: "c",
 	cost: "$",
+	speed: ">",
+	latency: "~",
+	stall: "!",
 	extensions: "&",
 	ahead: "^",
 	behind: "v",

package/extensions/open-tui/index.ts

@@ -7,6 +7,7 @@ import { readGitStatus } from "./git.ts";
 import { readRuntimeInfo } from "./runtime.ts";
 import { SessionLifecycle } from "./session-lifecycle.ts";
 import { registerSettingsCommand } from "./settings-command.ts";
+import { formatTurnTelemetry, TurnTelemetryTracker } from "./telemetry.ts";
 import {
 	createInitialState,
 	getModelMeta,
@@ -43,6 +44,7 @@ function isTuiContext(ctx: ExtensionContext): boolean {
 export default function (pi: ExtensionAPI) {
 	const sessionLifecycle = new SessionLifecycle();
 	const state: FooterState = createInitialState();
+	const turnTelemetry = new TurnTelemetryTracker();
 
 	let config: OpenTuiConfig = structuredClone(DEFAULT_CONFIG);
 	let active = false;
@@ -175,7 +177,8 @@ export default function (pi: ExtensionAPI) {
 		lastCtx = undefined;
 	});
 
-	pi.on("agent_start", (_event, _ctx) => {
+	pi.on("agent_start", (event, _ctx) => {
+		turnTelemetry.handle(event);
 		if (!sessionLifecycle.isCurrent()) return;
 		state.workingSince = Date.now();
 		state.lastDoneIn = undefined;
@@ -192,6 +195,34 @@ export default function (pi: ExtensionAPI) {
 		requestFooterRender?.();
 	});
 
+	pi.on("turn_start", (event) => {
+		turnTelemetry.handle(event);
+	});
+
+	pi.on("message_start", (event) => {
+		turnTelemetry.handle(event);
+	});
+
+	pi.on("message_update", (event) => {
+		turnTelemetry.handle(event);
+	});
+
+	pi.on("tool_execution_start", (event) => {
+		turnTelemetry.handle(event);
+	});
+
+	pi.on("turn_end", (event) => {
+		turnTelemetry.handle(event);
+	});
+
+	pi.on("agent_settled", (event, ctx) => {
+		const telemetry = turnTelemetry.handle(event);
+		if (telemetry && config.enabled && config.telemetry.enabled && isTuiContext(ctx)) {
+			const message = formatTurnTelemetry(telemetry, ctx.ui.theme, config.telemetry, config.icons.mode);
+			if (message) ctx.ui.notify(message, "info");
+		}
+	});
+
 	pi.on("model_select", (_event, ctx) => {
 		refreshInteractiveState(ctx);
 	});
@@ -200,7 +231,8 @@ export default function (pi: ExtensionAPI) {
 		refreshInteractiveState(ctx);
 	});
 
-	pi.on("message_end", (_event, ctx) => {
+	pi.on("message_end", (event, ctx) => {
+		turnTelemetry.handle(event);
 		if (!sessionLifecycle.isCurrent()) return;
 		invalidateUsageCache();
 		refreshInteractiveState(ctx);

package/extensions/open-tui/settings-command.ts

@@ -17,12 +17,13 @@ interface SettingItem {
 	values: string[];
 }
 
-type Tab = "features" | "icons" | "segments";
+type Tab = "features" | "icons" | "segments" | "telemetry";
 
 const TABS: { id: Tab; label: string }[] = [
 	{ id: "features", label: "Features" },
 	{ id: "icons", label: "Icons" },
 	{ id: "segments", label: "Segments" },
+	{ id: "telemetry", label: "Telemetry" },
 ];
 
 function toggleSetting(config: OpenTuiConfig, key: keyof OpenTuiConfig["footerSegments"]): OpenTuiConfig {
@@ -46,6 +47,13 @@ function toggleEnabled(config: OpenTuiConfig): OpenTuiConfig {
 	return { ...config, enabled: !config.enabled };
 }
 
+function toggleTelemetry(config: OpenTuiConfig, key: keyof OpenTuiConfig["telemetry"]): OpenTuiConfig {
+	return {
+		...config,
+		telemetry: { ...config.telemetry, [key]: !config.telemetry[key] },
+	};
+}
+
 function buildFeaturesItems(config: OpenTuiConfig): SettingItem[] {
 	return [
 		{
@@ -82,11 +90,25 @@ function buildSegmentsItems(config: OpenTuiConfig): SettingItem[] {
 	];
 }
 
+function buildTelemetryItems(config: OpenTuiConfig): SettingItem[] {
+	const telemetry = config.telemetry;
+	return [
+		{ id: "enabled", label: "Enabled", currentValue: telemetry.enabled ? "on" : "off", values: ["on", "off"] },
+		{ id: "tps", label: "TPS", currentValue: telemetry.tps ? "on" : "off", values: ["on", "off"] },
+		{ id: "ttft", label: "TTFT", currentValue: telemetry.ttft ? "on" : "off", values: ["on", "off"] },
+		{ id: "duration", label: "total duration", currentValue: telemetry.duration ? "on" : "off", values: ["on", "off"] },
+		{ id: "tokens", label: "token counts", currentValue: telemetry.tokens ? "on" : "off", values: ["on", "off"] },
+		{ id: "stalls", label: "stall details", currentValue: telemetry.stalls ? "on" : "off", values: ["on", "off"] },
+		{ id: "cost", label: "cost rate", currentValue: telemetry.cost ? "on" : "off", values: ["on", "off"] },
+	];
+}
+
 function buildItems(tab: Tab, config: OpenTuiConfig): SettingItem[] {
 	switch (tab) {
 		case "features": return buildFeaturesItems(config);
 		case "icons": return buildIconsItems(config);
 		case "segments": return buildSegmentsItems(config);
+		case "telemetry": return buildTelemetryItems(config);
 	}
 }
 
@@ -104,6 +126,9 @@ function handleSettingChange(
 	if (tab === "segments") {
 		return toggleSetting(config, itemId as keyof OpenTuiConfig["footerSegments"]);
 	}
+	if (tab === "telemetry") {
+		return toggleTelemetry(config, itemId as keyof OpenTuiConfig["telemetry"]);
+	}
 	return config;
 }
 

package/extensions/open-tui/telemetry.ts

@@ -0,0 +1,375 @@
+import type {
+	AgentSettledEvent,
+	AgentStartEvent,
+	MessageEndEvent,
+	MessageStartEvent,
+	MessageUpdateEvent,
+	ToolExecutionStartEvent,
+	TurnEndEvent,
+	TurnStartEvent,
+	Theme,
+} from "@earendil-works/pi-coding-agent";
+import type { IconMode, TelemetryConfig } from "./config.ts";
+import { resolveGlyphs } from "./icons.ts";
+import { fmtTokens, formatDuration } from "./utils.ts";
+
+const STALL_THRESHOLD_MS = 500;
+const MIN_STREAM_MS = 1;
+const MIN_STREAM_UPDATES = 5;
+const MIN_INTER_CHUNK_MS = 1;
+const MIN_GENERATION_MS = 200;
+const STALL_DOMINANCE_RATIO = 0.85;
+const MAX_PLAUSIBLE_TPS = 10_000;
+
+type TelemetryEvent =
+	| AgentStartEvent
+	| AgentSettledEvent
+	| TurnStartEvent
+	| MessageStartEvent
+	| MessageUpdateEvent
+	| MessageEndEvent
+	| ToolExecutionStartEvent
+	| TurnEndEvent;
+type AgentMessage = MessageStartEvent["message"];
+type AssistantMessage = Extract<AgentMessage, { role: "assistant" }>;
+
+interface MessageTiming {
+	startMs: number;
+	lastUpdateMs: number;
+	firstUpdateSeen: boolean;
+	streamUpdateCount: number;
+	firstStreamUpdateMs: number | null;
+	lastStreamUpdateMs: number | null;
+	inStall: boolean;
+}
+
+interface TurnTiming {
+	startMs: number;
+	firstTokenMs: number | null;
+	currentMessage: MessageTiming | null;
+	messages: AssistantMessage[];
+	generationMs: number;
+	streamMs: number;
+	streamIntervals: number;
+	streamUpdateCount: number;
+	stallMs: number;
+	stallCount: number;
+	isToolCall: boolean;
+	modelKey: string | null;
+}
+
+export interface TurnTelemetry {
+	tps: number | null;
+	ttftMs: number;
+	totalMs: number;
+	inputTokens: number;
+	outputTokens: number;
+	stallMs: number;
+	stallCount: number;
+	rateUsdPerMTokens: number | null;
+	generationMs: number;
+	totalTokens: number;
+	costUsd: number;
+	measurementMs: number | null;
+}
+
+function isAssistantMessage(message: AgentMessage): message is AssistantMessage {
+	return message.role === "assistant";
+}
+
+function round(value: number, decimals: number): number {
+	const factor = 10 ** decimals;
+	return Math.round(value * factor) / factor;
+}
+
+export class TurnTelemetryTracker {
+	private readonly now: () => number;
+	private readonly tpsCaps = new Map<string, number>();
+	private turn: TurnTiming | undefined;
+	private agentStartMs: number | null = null;
+	private agentTurns: TurnTelemetry[] = [];
+
+	constructor(now: () => number = () => performance.now()) {
+		this.now = now;
+	}
+
+	handle(event: TelemetryEvent): TurnTelemetry | undefined {
+		switch (event.type) {
+			case "agent_start":
+				if (this.agentStartMs === null) {
+					this.agentStartMs = this.now();
+					this.agentTurns = [];
+				}
+				return;
+			case "agent_settled":
+				return this.endAgent();
+			case "turn_start":
+				this.startTurn();
+				return;
+			case "message_start":
+				this.startMessage(event.message);
+				return;
+			case "message_update":
+				this.updateMessage(event);
+				return;
+			case "message_end":
+				this.endMessage(event.message);
+				return;
+			case "tool_execution_start":
+				if (this.turn) this.turn.isToolCall = true;
+				return;
+			case "turn_end":
+				return this.endTurnAndCollect();
+		}
+	}
+
+	private startTurn(): void {
+		this.turn = {
+			startMs: this.now(),
+			firstTokenMs: null,
+			currentMessage: null,
+			messages: [],
+			generationMs: 0,
+			streamMs: 0,
+			streamIntervals: 0,
+			streamUpdateCount: 0,
+			stallMs: 0,
+			stallCount: 0,
+			isToolCall: false,
+			modelKey: null,
+		};
+	}
+
+	private startMessage(message: AgentMessage): void {
+		if (!this.turn || !isAssistantMessage(message)) return;
+		const now = this.now();
+		this.turn.currentMessage = {
+			startMs: now,
+			lastUpdateMs: now,
+			firstUpdateSeen: false,
+			streamUpdateCount: 0,
+			firstStreamUpdateMs: null,
+			lastStreamUpdateMs: null,
+			inStall: false,
+		};
+		this.turn.modelKey ??= `${message.provider}:${message.model}`;
+	}
+
+	private updateMessage(event: MessageUpdateEvent): void {
+		const turn = this.turn;
+		const current = turn?.currentMessage;
+		const streamEvent = event.assistantMessageEvent;
+		if (
+			streamEvent.type !== "text_delta" &&
+			streamEvent.type !== "thinking_delta" &&
+			streamEvent.type !== "toolcall_delta"
+		) return;
+		if (streamEvent.delta.length === 0) return;
+		const message = event.message;
+		if (!turn || !current || !isAssistantMessage(message)) return;
+
+		const now = this.now();
+		if (!current.firstUpdateSeen) {
+			current.firstUpdateSeen = true;
+			turn.firstTokenMs ??= now;
+			current.lastUpdateMs = now;
+			return;
+		}
+
+		current.streamUpdateCount++;
+		current.firstStreamUpdateMs ??= now;
+		current.lastStreamUpdateMs = now;
+
+		const gap = now - current.lastUpdateMs;
+		if (gap >= STALL_THRESHOLD_MS) {
+			if (!current.inStall) turn.stallCount++;
+			current.inStall = true;
+			turn.stallMs += gap;
+		} else {
+			current.inStall = false;
+		}
+		current.lastUpdateMs = now;
+	}
+
+	private endMessage(message: AgentMessage): void {
+		const turn = this.turn;
+		if (!turn || !isAssistantMessage(message)) return;
+
+		const current = turn.currentMessage;
+		if (current) {
+			turn.generationMs += this.now() - current.startMs;
+			turn.streamUpdateCount += current.streamUpdateCount;
+			turn.streamIntervals += Math.max(0, current.streamUpdateCount - 1);
+			// Sum per-message spans so tool execution between messages never enters TPS.
+			if (current.firstStreamUpdateMs !== null && current.lastStreamUpdateMs !== null) {
+				turn.streamMs += current.lastStreamUpdateMs - current.firstStreamUpdateMs;
+			}
+			turn.currentMessage = null;
+		}
+		turn.messages.push(message);
+		turn.modelKey ??= `${message.provider}:${message.model}`;
+	}
+
+	private endTurnAndCollect(): TurnTelemetry | undefined {
+		const telemetry = this.endTurn();
+		if (telemetry && this.agentStartMs !== null) this.agentTurns.push(telemetry);
+		return telemetry;
+	}
+
+	private endTurn(): TurnTelemetry | undefined {
+		const turn = this.turn;
+		this.turn = undefined;
+		if (!turn || turn.firstTokenMs === null || turn.messages.length === 0) return;
+
+		const endMs = this.now();
+		let inputTokens = 0;
+		let outputTokens = 0;
+		let totalTokens = 0;
+		let costUsd = 0;
+		for (const message of turn.messages) {
+			inputTokens += message.usage.input;
+			outputTokens += message.usage.output;
+			totalTokens += message.usage.totalTokens;
+			costUsd += message.usage.cost.total;
+		}
+		if (![inputTokens, outputTokens, totalTokens, costUsd].every(Number.isFinite)) {
+			throw new Error("Invalid assistant usage in turn telemetry");
+		}
+		if (outputTokens <= 0 || !turn.modelKey) return;
+
+		const streamMs = turn.streamUpdateCount > 0 ? turn.streamMs : null;
+		const averageGapMs = turn.streamIntervals > 0 ? turn.streamMs / turn.streamIntervals : 0;
+		let tps: number | null = null;
+		let measurementMs: number | null = null;
+		let primary = false;
+		if (
+			streamMs !== null &&
+			streamMs >= MIN_STREAM_MS &&
+			turn.streamUpdateCount >= MIN_STREAM_UPDATES &&
+			averageGapMs >= MIN_INTER_CHUNK_MS &&
+			turn.stallMs < streamMs &&
+			streamMs - turn.stallMs >= MIN_GENERATION_MS &&
+			turn.stallMs < streamMs - turn.stallMs
+		) {
+			measurementMs = streamMs - turn.stallMs;
+			tps = round(outputTokens / (measurementMs / 1000), 1);
+			primary = true;
+		} else if (turn.streamUpdateCount >= 2 && turn.generationMs >= MIN_GENERATION_MS) {
+			let activeMs = turn.generationMs - turn.stallMs;
+			if (activeMs < MIN_GENERATION_MS || turn.stallMs > turn.generationMs * STALL_DOMINANCE_RATIO) {
+				activeMs = turn.generationMs - turn.stallMs / 2;
+			}
+			measurementMs = Math.max(activeMs, MIN_GENERATION_MS);
+			tps = round(outputTokens / (measurementMs / 1000), 1);
+		}
+
+		if (tps !== null && tps > MAX_PLAUSIBLE_TPS) {
+			tps = null;
+			measurementMs = null;
+			primary = false;
+		}
+		if (primary && tps !== null) {
+			this.tpsCaps.set(turn.modelKey, Math.max(tps, this.tpsCaps.get(turn.modelKey) ?? 0));
+		}
+		if (turn.isToolCall && tps !== null) {
+			tps = this.tpsCaps.has(turn.modelKey)
+				? Math.min(tps, this.tpsCaps.get(turn.modelKey)!)
+				: null;
+			if (tps === null) measurementMs = null;
+		}
+
+		const validCost = Number.isFinite(costUsd) && costUsd > 0;
+		const validTokens = Number.isFinite(totalTokens) && totalTokens > 0;
+		return {
+			tps,
+			ttftMs: turn.firstTokenMs - turn.startMs,
+			totalMs: endMs - turn.startMs,
+			inputTokens,
+			outputTokens,
+			stallMs: turn.stallMs,
+			stallCount: turn.stallCount,
+			rateUsdPerMTokens: validCost && validTokens
+				? round(costUsd / (totalTokens / 1_000_000), 2)
+				: null,
+			generationMs: turn.generationMs,
+			totalTokens,
+			costUsd: validCost ? costUsd : 0,
+			measurementMs,
+		};
+	}
+
+	private endAgent(): TurnTelemetry | undefined {
+		const startMs = this.agentStartMs;
+		const turns = this.agentTurns;
+		this.agentStartMs = null;
+		this.agentTurns = [];
+		if (startMs === null || turns.length === 0) return;
+
+		const outputTokens = turns.reduce((sum, turn) => sum + turn.outputTokens, 0);
+		const inputTokens = turns.reduce((sum, turn) => sum + turn.inputTokens, 0);
+		const totalTokens = turns.reduce((sum, turn) => sum + turn.totalTokens, 0);
+		const costUsd = turns.reduce((sum, turn) => sum + turn.costUsd, 0);
+		const stallMs = turns.reduce((sum, turn) => sum + turn.stallMs, 0);
+		const stallCount = turns.reduce((sum, turn) => sum + turn.stallCount, 0);
+		const measuredTurns = turns.filter((turn) => turn.measurementMs !== null);
+		const measuredOutputTokens = measuredTurns.reduce((sum, turn) => sum + turn.outputTokens, 0);
+		const measurementMs = measuredTurns.length > 0
+			? measuredTurns.reduce((sum, turn) => sum + turn.measurementMs!, 0)
+			: null;
+		const tps =
+			measurementMs !== null && measurementMs >= MIN_GENERATION_MS
+				? round(measuredOutputTokens / (measurementMs / 1000), 1)
+				: null;
+		const boundedTps = tps !== null && tps <= MAX_PLAUSIBLE_TPS ? tps : null;
+		const validRate = costUsd > 0 && totalTokens > 0;
+		return {
+			tps: boundedTps,
+			ttftMs: turns[0]!.ttftMs,
+			totalMs: this.now() - startMs,
+			inputTokens,
+			outputTokens,
+			stallMs,
+			stallCount,
+			rateUsdPerMTokens: validRate ? round(costUsd / (totalTokens / 1_000_000), 2) : null,
+			generationMs: turns.reduce((sum, turn) => sum + turn.generationMs, 0),
+			totalTokens,
+			costUsd,
+			measurementMs,
+		};
+	}
+}
+
+function formatTurnDuration(ms: number): string {
+	return ms < 60_000 ? `${(ms / 1000).toFixed(1)}s` : formatDuration(ms);
+}
+
+export function formatTurnTelemetry(
+	telemetry: TurnTelemetry,
+	theme: Theme,
+	config: TelemetryConfig,
+	iconMode: IconMode,
+): string {
+	const glyphs = resolveGlyphs(iconMode);
+	const parts: string[] = [];
+	if (config.tps) {
+		const value = telemetry.tps === null ? "—" : `${telemetry.tps.toFixed(1)} tok/s`;
+		parts.push(theme.fg(telemetry.tps === null ? "muted" : "accent", `${glyphs.speed} TPS ${value}`));
+	}
+	if (config.ttft) {
+		parts.push(theme.fg("text", `${glyphs.latency} TTFT ${formatTurnDuration(telemetry.ttftMs)}`));
+	}
+	if (config.duration) {
+		parts.push(theme.fg("success", `${glyphs.done} ${formatTurnDuration(telemetry.totalMs)}`));
+	}
+	if (config.tokens) {
+		parts.push(theme.fg("accent", `${glyphs.input} in ${fmtTokens(telemetry.inputTokens)}`));
+		parts.push(theme.fg("success", `${glyphs.output} out ${fmtTokens(telemetry.outputTokens)}`));
+	}
+	if (config.stalls && telemetry.stallMs > 0) {
+		parts.push(theme.fg("warning", `${glyphs.stall} stall ${telemetry.stallCount}x / ${formatTurnDuration(telemetry.stallMs)}`));
+	}
+	if (config.cost && telemetry.rateUsdPerMTokens !== null) {
+		parts.push(theme.fg("warning", `${glyphs.cost} $${telemetry.rateUsdPerMTokens.toFixed(2)}/M`));
+	}
+	return parts.join(` ${theme.fg("dim", "|")} `);
+}

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "pi-open-tui",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "A polished TUI for Pi coding agent: animated logo header, Starship-style footer, rounded editor with model metadata, and prompt-box user messages. Combines the best of pi-haiku, pi-claude-code-tui, and pi-zentui.",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OldSuns/pi-open-tui.git"
+  },
   "keywords": [
     "pi-package",
     "pi",
@@ -20,7 +24,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test --experimental-transform-types tests/settings-command.test.ts tests/footer.test.ts tests/editor.test.ts",
+    "test": "node --test --experimental-transform-types tests/settings-command.test.ts tests/footer.test.ts tests/editor.test.ts tests/telemetry.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "pi": {