pi-legion 2.0.3 → 3.0.0

package/src/tui/viz/rate.ts

@@ -1,23 +1,24 @@
 /**
  * Minimal in-memory token-rate sampling.
  *
- * Every tok/s figure in the UI (railway header, /legion header, chart "now",
- * tree detail t/s) uses ONE definition:
+ * Two UI surfaces show throughput with different definitions:
  *
- *   numerator   = Δ cumulative output tokens over the trailing window
- *   denominator = Δ cumulative generationMs over the same window
- *                 (falls back to wall-clock window when generationMs is
- *                  unavailable / zero, or when in-window ΔgenerationMs is
- *                  below MIN_RATE_GENERATION_MS — same 1s floor as tree t/s)
+ * - Header / snap tok/s (`nowRate`): 60s trailing window + live (running)
+ *   agents only. Numerator = Δ cumulative output tokens; denominator =
+ *   Δ cumulative generationMs over the same window (falls back to wall-clock
+ *   window when generationMs is unavailable / zero, or when in-window
+ *   ΔgenerationMs is below MIN_RATE_GENERATION_MS — same 1s floor as the
+ *   tree-row gate). Once nothing is live, the header rate is 0 even if the
+ *   window still holds Δtokens.
+ * - Tree-row label (`avg t/s` in status.ts): lifetime cumulative average
+ *   `tokensOut / (generationMs/1000)` — no window, no live filter.
  *
  * generationMs comes from session JSONL: sum of (assistant_ts − prior
  * user/toolResult_ts). Idle and tool gaps are excluded. Approximate —
  * usage lands when each assistant message completes, not mid-stream.
  *
- * Header / snap "now" (`nowRate` / `totalRate` with live node ids) only sums
- * agents that are still `running`. Settled/retired series keep contributing to
- * chart buckets/avg so the history window stays accurate; once nothing is live,
- * "now" is forced to 0 even if the 60s window still holds Δtokens.
+ * Settled/retired series keep contributing to chart buckets/avg so the
+ * history window stays accurate.
  */
 
 import type { VizNode } from "./model.ts";
@@ -53,6 +54,8 @@ export class RateSampler {
 	private readonly series = new Map<string, Series>();
 	private readonly retentionMs: number;
 	private first: number | undefined;
+	/** Wall time of the latest tokensOut/gen change across all series (not flat-collapse moves). */
+	private lastChange: number | undefined;
 
 	constructor(options: { retentionMs?: number } = {}) {
 		this.retentionMs = options.retentionMs ?? DEFAULT_RETENTION_MS;
@@ -62,6 +65,15 @@ export class RateSampler {
 		return this.first;
 	}
 
+	/**
+	 * Latest timestamp where any series recorded a substantive tokensOut or
+	 * generationMs change. Flat-collapse (advancing a flat trailing sample to
+	 * `now`) does not move this — chart x-axis freezes until real data arrives.
+	 */
+	get lastChangeAt(): number | undefined {
+		return this.lastChange;
+	}
+
 	record(now: number, nodes: readonly VizNode[]): void {
 		if (!Number.isFinite(now)) return;
 		if (this.first === undefined) this.first = now;
@@ -85,9 +97,11 @@ export class RateSampler {
 			// Cumulative counters never decrease; ignore regressions from stale sources.
 			const value = last === undefined ? node.tokensOut : Math.max(last, node.tokensOut);
 			const gen = lastGen === undefined ? node.generationMs : Math.max(lastGen, node.generationMs);
+			const changed = last === undefined || value !== last || gen !== lastGen;
 			if (lastTs !== undefined && now <= lastTs) {
 				s.value[s.value.length - 1] = value;
 				s.gen[s.gen.length - 1] = gen;
+				if (changed) this.noteChange(lastTs);
 				continue;
 			}
 			if (
@@ -99,16 +113,23 @@ export class RateSampler {
 				s.gen[s.gen.length - 2] === lastGen
 			) {
 				// Collapse flat runs: move the trailing sample forward.
+				// Does NOT advance lastChangeAt — chart x-axis stays frozen.
 				s.ts[s.ts.length - 1] = now;
 				continue;
 			}
 			s.ts.push(now);
 			s.value.push(value);
 			s.gen.push(gen);
+			if (changed) this.noteChange(now);
 			this.prune(s, now);
 		}
 	}
 
+	private noteChange(at: number): void {
+		if (!Number.isFinite(at)) return;
+		this.lastChange = this.lastChange === undefined ? at : Math.max(this.lastChange, at);
+	}
+
 	private prune(s: Series, now: number): void {
 		const cutoff = now - this.retentionMs;
 		let drop = 0;
@@ -152,7 +173,7 @@ export class RateSampler {
 
 	/**
 	 * Sum of node rates. When `onlyNodeIds` is set (including empty), only those
-	 * series contribute — used for header "now". Omit it for chart buckets/avg
+	 * series contribute — used for the header tok/s. Omit it for chart buckets/avg
 	 * so settled agents still paint their trailing-window history.
 	 */
 	totalRate(now: number, windowMs = RATE_WINDOW_MS, onlyNodeIds?: Iterable<string>): number {
@@ -165,7 +186,7 @@ export class RateSampler {
 		return sum;
 	}
 
-	/** Header / snap "now" tok/s: live (running) agents only; none live → 0. */
+	/** Header / snap tok/s: live (running) agents only; none live → 0. */
 	nowRate(now: number, nodes: readonly VizNode[], windowMs = RATE_WINDOW_MS): number {
 		return this.totalRate(now, windowMs, liveRateNodeIds(nodes));
 	}
@@ -215,10 +236,11 @@ export class RateSampler {
 	clear(): void {
 		this.series.clear();
 		this.first = undefined;
+		this.lastChange = undefined;
 	}
 }
 
-/** Node ids that contribute to header "now" tok/s (running agents; root excluded). */
+/** Node ids that contribute to the header tok/s (running agents; root excluded). */
 export function liveRateNodeIds(nodes: readonly VizNode[]): string[] {
 	return nodes.filter((n) => n.id !== "root" && n.status === "running").map((n) => n.id);
 }

package/src/tui/viz/view.ts

@@ -1,26 +1,39 @@
-/** /legion full view: galaxy + tok/s chart + git-log history with linked selection. */
+/** /legion full view: galaxy + tok/s chart + timing + git-log history with linked selection. */
 
 import { Key, matchesKey } from "@earendil-works/pi-tui";
 import { Canvas, cellWidth, ellipsize } from "./canvas.ts";
 import { computeLayout, type LayoutKind } from "./layout.ts";
 import { formatCount, formatDuration, isAgent, type VizNode } from "./model.ts";
 import { roleColor, type VizTheme } from "./palette.ts";
-import { buildLog, dfsOrder, drawChart, drawGalaxy, drawLog, frame, type Pane, type ViewData } from "./panels.ts";
+import {
+	buildLog,
+	dfsOrder,
+	drawChart,
+	drawGalaxy,
+	drawLog,
+	drawTiming,
+	frame,
+	timingRowsFromNodes,
+	type Pane,
+	type ViewData,
+} from "./panels.ts";
 
 export interface LegionViewState {
 	focus: Pane;
 	selectedId?: string;
 	logOffset: number;
 	logCursor: number;
+	timingOffset: number;
+	timingCursor: number;
 	/** `x` pressed: an in-view y/N prompt for stopping this agent (dialogs would be hidden behind the full-screen view). */
 	pendingStopId?: string;
 }
 
 export function initialViewState(): LegionViewState {
-	return { focus: "galaxy", logOffset: 0, logCursor: 0 };
+	return { focus: "galaxy", logOffset: 0, logCursor: 0, timingOffset: 0, timingCursor: 0 };
 }
 
-const PANES: Pane[] = ["galaxy", "chart", "log"];
+const PANES: Pane[] = ["galaxy", "chart", "timing", "log"];
 
 /** Min grapheme cells before painting a selection badge. Shared by portrait + landscape so a truncated stub never paints (#128). Was portrait `>4` vs landscape `>0`. */
 export const MIN_SELECTION_BADGE_W = 5;
@@ -72,8 +85,26 @@ export function renderLegionView(data: ViewData, state: LegionViewState, cols: n
 	drawGalaxy(cv, galaxyInner, data, state.selectedId);
 	const chartInner = frame(cv, layout.chart, portrait ? "tok/s · by role" : "tok/s · stacked by role", state.focus === "chart");
 	drawChart(cv, chartInner, data, selected, !portrait);
+
+	const timingRows = timingRowsFromNodes(data.nodes, data.now);
+	const timingVisible = Math.max(1, layout.timing.h - 3);
+	clampList(state, "timing", timingRows.length, timingVisible);
+	const timingInner = frame(
+		cv,
+		layout.timing,
+		portrait ? "timing" : "timing · wall/gen/other",
+		state.focus === "timing",
+		portrait ? undefined : "↑↓ · ⏎ sel · o open",
+	);
+	drawTiming(cv, timingInner, timingRows, {
+		offset: state.timingOffset,
+		cursor: state.timingCursor,
+		focused: state.focus === "timing",
+		...(state.selectedId ? { selectedId: state.selectedId } : {}),
+	});
+
 	const events = buildLog(data.nodes);
-	clampLog(state, events.length, Math.max(1, layout.log.h - 3));
+	clampList(state, "log", events.length, Math.max(1, layout.log.h - 3));
 	const logInner = frame(cv, layout.log, "log --graph", state.focus === "log", portrait ? undefined : "↑↓ scroll · ⏎ select");
 	drawLog(cv, logInner, events, {
 		offset: state.logOffset,
@@ -112,11 +143,23 @@ function statusLabel(node: VizNode): string {
 	return node.status === "settled" ? "done" : node.status;
 }
 
-function clampLog(state: LegionViewState, count: number, visible: number): void {
-	state.logCursor = Math.max(0, Math.min(state.logCursor, count - 1));
-	if (state.logCursor < state.logOffset) state.logOffset = state.logCursor;
-	if (state.logCursor >= state.logOffset + visible) state.logOffset = state.logCursor - visible + 1;
-	state.logOffset = Math.max(0, Math.min(state.logOffset, Math.max(0, count - visible)));
+function clampList(
+	state: LegionViewState,
+	which: "log" | "timing",
+	count: number,
+	visible: number,
+): void {
+	if (which === "log") {
+		state.logCursor = Math.max(0, Math.min(state.logCursor, count - 1));
+		if (state.logCursor < state.logOffset) state.logOffset = state.logCursor;
+		if (state.logCursor >= state.logOffset + visible) state.logOffset = state.logCursor - visible + 1;
+		state.logOffset = Math.max(0, Math.min(state.logOffset, Math.max(0, count - visible)));
+		return;
+	}
+	state.timingCursor = Math.max(0, Math.min(state.timingCursor, count - 1));
+	if (state.timingCursor < state.timingOffset) state.timingOffset = state.timingCursor;
+	if (state.timingCursor >= state.timingOffset + visible) state.timingOffset = state.timingCursor - visible + 1;
+	state.timingOffset = Math.max(0, Math.min(state.timingOffset, Math.max(0, count - visible)));
 }
 
 export type ViewAction = "none" | "render" | "close" | "open" | "stop";
@@ -124,6 +167,7 @@ export type ViewAction = "none" | "render" | "close" | "open" | "stop";
 /** Pure key handling so it can be unit tested without a terminal. */
 export function handleViewKey(data: string, state: LegionViewState, nodes: readonly VizNode[], page = 10): ViewAction {
 	const events = buildLog(nodes);
+	const timingRows = timingRowsFromNodes(nodes, Date.now());
 	const order = dfsOrder(nodes).filter(isAgent);
 	if (state.pendingStopId) {
 		const confirmed = matchesKey(data, "y") || data === "Y" || matchesKey(data, Key.enter);
@@ -171,6 +215,21 @@ export function handleViewKey(data: string, state: LegionViewState, nodes: reado
 		} else return "none";
 		return "render";
 	}
+	if (state.focus === "timing") {
+		if (down) state.timingCursor = Math.min(timingRows.length - 1, state.timingCursor + 1);
+		else if (up) state.timingCursor = Math.max(0, state.timingCursor - 1);
+		else if (matchesKey(data, Key.pageDown)) state.timingCursor = Math.min(timingRows.length - 1, state.timingCursor + page);
+		else if (matchesKey(data, Key.pageUp)) state.timingCursor = Math.max(0, state.timingCursor - page);
+		else if (matchesKey(data, Key.home)) state.timingCursor = 0;
+		else if (matchesKey(data, Key.end)) state.timingCursor = Math.max(0, timingRows.length - 1);
+		else if (matchesKey(data, Key.enter)) {
+			const row = timingRows[state.timingCursor];
+			if (!row) return "none";
+			state.selectedId = state.selectedId === row.node.id ? undefined : row.node.id;
+			if (state.selectedId === undefined) delete state.selectedId;
+		} else return "none";
+		return "render";
+	}
 	if (down || up || matchesKey(data, Key.right) || matchesKey(data, Key.left)) {
 		if (order.length === 0) return "none";
 		const step = down || matchesKey(data, Key.right) ? 1 : -1;