pi-legion 2.0.4 → 3.0.0

package/src/tui/viz/panels.ts

@@ -13,7 +13,7 @@ export interface ViewData {
 	nodes: readonly VizNode[];
 	sampler: RateSampler;
 	now: number;
-	/** Header "now" tok/s (live agents only; 0 when none running). Chart avg/buckets keep full-series windows. */
+	/** Header tok/s (live agents only; 0 when none running). Chart avg/buckets keep full-series windows. */
 	rate: number;
 }
 
@@ -303,7 +303,7 @@ export function computeStats(data: ViewData, buckets: number): ChartStats {
 			peakIndex = i;
 		}
 	});
-	// "now" is the shared header definition, never the last bucket.
+	// The header tok/s is the shared definition, never the last bucket.
 	peak = Math.max(peak, data.rate);
 	const peakAt = peakIndex >= 0 && peak > data.rate ? series.times[peakIndex]! : to;
 	const roleTotals = new Map<string, number>();
@@ -315,7 +315,7 @@ export function computeStats(data: ViewData, buckets: number): ChartStats {
 	}
 	return {
 		now: data.rate,
-		// Full-series window average (includes settled); differs from header "now" on purpose.
+		// Full-series window average (includes settled); differs from the header tok/s on purpose.
 		avg: data.sampler.totalRate(to, Math.max(1, to - from)),
 		peak,
 		peakAt,
@@ -333,7 +333,7 @@ export function drawChart(cv: Canvas, r: Rect, data: ViewData, selected: VizNode
 	const statsBelow = statsW === 0 ? Math.min(selected ? 4 : 3, Math.max(0, r.h - 6)) : 0;
 	const axisW = 6;
 	const plotX = r.x + axisW;
-	// With side stats, keep room for the "◂ now" label so it never runs into the stats column.
+	// With side stats, keep room for the "◂ N" label so it never runs into the stats column.
 	const plotW = Math.max(4, r.w - axisW - statsW - (statsW ? 9 : 0) - 1);
 	const plotTop = r.y + 1;
 	const plotH = Math.max(1, r.h - 2 - statsBelow);
@@ -394,14 +394,13 @@ export function drawChart(cv: Canvas, r: Rect, data: ViewData, selected: VizNode
 	if (stats.peak > 0) yLabel(max, plotTop);
 	if (plotH >= 5 && max >= 20) yLabel(max / 2, axisY - 1 - Math.floor(plotH / 2));
 	yLabel(0, axisY - 1);
-	// X axis with "now" at the right edge.
+	// X axis: elapsed time since the window start; the right edge is the present.
 	cv.text(plotX - 1, axisY, "└" + "─".repeat(plotW), "borderMuted", { maxX: plotX + plotW });
 	cv.text(plotX, axisY, "0m", "dim");
 	const mid = formatDuration((to - from) / 2);
 	if (plotW > 24) cv.text(plotX + Math.floor(plotW / 2) - Math.floor(mid.length / 2), axisY, mid, "dim");
-	cv.text(plotX + plotW - 3, axisY, "now", "text", { bold: true });
 	const nowLabel = `◂ ${formatCount(stats.now)}`;
-	if (statsW === 0) cv.text(r.x, r.y, `now ${formatCount(stats.now)} tok/s`, "accent", { bold: true, maxX: Math.max(r.x, plotX + plotW - 22) });
+	if (statsW === 0) cv.text(r.x, r.y, `${formatCount(stats.now)} tok/s`, "accent", { bold: true, maxX: Math.max(r.x, plotX + plotW - 22) });
 	else cv.text(plotX + plotW + 1, axisY - 1 - Math.min(plotH - 1, Math.floor(rowsFor(stats.now))), nowLabel, "text", { maxX: r.x + r.w - statsW - 1 });
 
 	const selLines = (): Array<[string, string]> => {
@@ -410,14 +409,14 @@ export function drawChart(cv: Canvas, r: Rect, data: ViewData, selected: VizNode
 		const share = stats.total > 0 ? (selected.tokens / stats.total) * 100 : 0;
 		return [
 			[`▸ ${selected.name}`, roleColor(selected.role)],
-			[`${formatCount(rate)} tok/s now · ${formatCount(selected.tokens)} tok`, "text"],
+			[`${formatCount(rate)} tok/s · ${formatCount(selected.tokens)} tok`, "text"],
 			[`${share.toFixed(1)}% of run · ━ bright line`, "dim"],
 		];
 	};
 	if (statsW) {
 		const sx = r.x + r.w - statsW;
 		const rows: Array<[string, string, string]> = [
-			["now", `${formatCount(stats.now)} tok/s`, "text"],
+			["rate", `${formatCount(stats.now)} tok/s`, "text"],
 			["avg", `${formatCount(stats.avg)} tok/s`, "text"],
 			["peak", stats.peak > 0 ? `${formatCount(stats.peak)} @ ${formatDuration(stats.peakAt - from)}` : "—", "text"],
 			["total", `${formatCount(stats.total)} tok`, "text"],

package/src/tui/viz/railway.ts

@@ -9,7 +9,7 @@
  * vertical remains traceable.
  */
 
-import { formatAgentElapsed } from "../status.ts";
+import { formatAgentElapsed, formatActivityAgo } from "../status.ts";
 import { Canvas, ellipsize } from "./canvas.ts";
 import { formatCount, isAgent, type VizNode } from "./model.ts";
 import { roleColor, type VizTheme } from "./palette.ts";
@@ -18,6 +18,19 @@ export const RAIL_MAX_LANES = 4;
 export const RAIL_MAX_LANES_NARROW = 3;
 export const RAIL_NARROW_COLS = 80;
 export const RAIL_WINDOW_MS = 6 * 60 * 1000;
+/**
+ * Floor for the time axis. The right-hand column is measured from what the
+ * lanes actually need and the axis takes whatever is left, but never less
+ * than this — otherwise a long detail would push the graph off the line.
+ */
+export const RAIL_AXIS_MIN_COLS = 10;
+/** Widest a lane name column may grow (it is content-driven, not reserved). */
+export const RAIL_NAME_MAX_COLS = 16;
+/**
+ * Narrowest the lane-name column may shrink. Short names would otherwise
+ * collapse the column to 1 and leave the label cramped against the ▶ marker.
+ */
+export const RAIL_NAME_MIN_COLS = 6;
 
 /**
  * Map a timestamp onto the shared railway axis.
@@ -39,7 +52,7 @@ export interface RailInput {
 	nodes: readonly VizNode[];
 	now: number;
 	width: number;
-	/** Header "now" tok/s (live agents only; 0 when none running). */
+	/** Header tok/s (live agents only; 0 when none running). */
 	rate: number;
 	windowMs?: number;
 	/** Lane scroll position when more agents are live than lanes fit. */
@@ -141,6 +154,128 @@ export function formatRate(rate: number): string {
 	return `${formatCount(rate)} tok/s`;
 }
 
+
+/**
+ * Wide-lane detail after the name: role, turn/lifetime clocks, and
+ * last-activity age.
+ *
+ * The leading clock is "time since the last task started": it keeps ticking
+ * through the quiet gap after a turn settles (the old behavior froze at that
+ * turn's end) and stops when the agent itself ends.
+ *
+ * Clocks show from round 1. #159 gated them behind `turns >= 2`, but a child
+ * is usually dispatched with a single user message, so in practice that gate
+ * hid the clocks almost always and left the lane with a bare `role · 1s ago`
+ * (~13 cols) — the axis then absorbed the rest of the line. A round-1 agent
+ * has a real start time and a real lifetime; show both.
+ */
+export function formatRailLaneDetail(node: VizNode, now: number): string {
+	const parts: string[] = [node.role];
+	parts.push(formatAgentElapsed({
+		state: node.status,
+		startedAt: node.startedAt,
+		...(node.endedAt !== undefined ? { finishedAt: node.endedAt } : {}),
+		...(node.currentTurnStartedAt !== undefined ? { currentTurnStartedAt: node.currentTurnStartedAt } : {}),
+	}, now));
+	parts.push(formatActivityAgo(node.lastActivityAt, now));
+	return parts.join(" · ");
+}
+
+/** Lane detail candidates, richest first (role → clocks → ago). */
+export function laneDetailCandidates(node: VizNode, now: number): string[] {
+	const ago = formatActivityAgo(node.lastActivityAt, now);
+	const clocks = formatAgentElapsed({
+		state: node.status,
+		startedAt: node.startedAt,
+		...(node.endedAt !== undefined ? { finishedAt: node.endedAt } : {}),
+		...(node.currentTurnStartedAt !== undefined ? { currentTurnStartedAt: node.currentTurnStartedAt } : {}),
+	}, now);
+	return [
+		`${node.role} · ${clocks} · ${ago}`,
+		`${clocks} · ${ago}`,
+		clocks,
+		ago,
+	];
+}
+
+/**
+ * Width of the lane-name column: as wide as the longest name, clamped to
+ * `RAIL_NAME_MAX_COLS` and never below `RAIL_NAME_MIN_COLS`.
+ *
+ * Planning and painting must agree on this, otherwise the axis is sized for
+ * one width while the row is drawn at another and the tail gets clipped.
+ */
+export function railNameWidth(shown: readonly VizNode[]): number {
+	const longest = shown.length ? Math.max(...shown.map((n) => Array.from(n.name).length)) : 0;
+	return Math.max(RAIL_NAME_MIN_COLS, Math.min(RAIL_NAME_MAX_COLS, longest));
+}
+
+/**
+ * Pick the richest lane detail that fits `room` (role → clocks → ago).
+ *
+ * Callers pass the room shared by every lane, so a field that does not fit
+ * one lane is dropped from all of them instead of stripping the role from a
+ * single long-named row.
+ */
+export function fitRailLaneDetail(node: VizNode, now: number, room: number): string {
+	if (room <= 0) return "";
+	const candidates = laneDetailCandidates(node, now);
+	for (const candidate of candidates) {
+		if (Array.from(candidate).length <= room) return candidate;
+	}
+	return ellipsize(candidates[candidates.length - 1]!, room);
+}
+
+export interface RailColumnPlan {
+	/** Width reserved for the lane name. */
+	nameW: number;
+	/** Index into each lane's candidate list (0 = richest). */
+	grade: number;
+	/** Columns the right-hand block needs, including the ▶ marker. */
+	needed: number;
+}
+
+/**
+ * Measure the right-hand column from the lanes themselves.
+ *
+ * The name/detail block is content-driven: the axis takes whatever the
+ * terminal has left, down to `RAIL_AXIS_MIN_COLS`. Short labels hand the slack
+ * back to the graph; long ones shrink it — so a row always fills the line
+ * instead of trailing blank space after the detail text.
+ */
+export function railColumnPlan(
+	shown: readonly VizNode[],
+	now: number,
+	portrait: boolean,
+	width: number,
+	reserve = 0,
+): RailColumnPlan {
+	if (shown.length === 0) return { nameW: 0, grade: 0, needed: 0 };
+	const nameW = railNameWidth(shown);
+	if (portrait) {
+		const label = Math.max(...shown.map((n) => {
+			const ago = formatActivityAgo(n.lastActivityAt, now);
+			return Array.from(ago === "—" ? n.name : `${n.name} · ${ago}`).length;
+		}));
+		return { nameW, grade: 0, needed: label + 2 + reserve };
+	}
+	const candidates = shown.map((n) => laneDetailCandidates(n, now));
+	const grades = Array.from(
+		{ length: Math.max(...candidates.map((c) => c.length)) },
+		(_, g) => Math.max(...candidates.map((c) => Array.from(c[Math.min(g, c.length - 1)]!).length)),
+	);
+	// Richest grade that still leaves the axis its floor.
+	const budget = Math.max(0, width - 1 - reserve - RAIL_AXIS_MIN_COLS - nameW - 3);
+	let grade = grades.length - 1;
+	for (let g = 0; g < grades.length; g++) {
+		if (grades[g]! <= budget) {
+			grade = g;
+			break;
+		}
+	}
+	return { nameW, grade, needed: nameW + grades[grade]! + 3 + reserve };
+}
+
 export function renderRailway(input: RailInput): RailRender | undefined {
 	const width = Math.max(0, Math.floor(input.width));
 	if (width < 20) return undefined;
@@ -151,9 +286,14 @@ export function renderRailway(input: RailInput): RailRender | undefined {
 	if (rows === 0) return undefined;
 	const portrait = width < RAIL_NARROW_COLS;
 	const windowMs = input.windowMs ?? RAIL_WINDOW_MS;
-	const nameCol = portrait ? Math.max(8, Math.min(16, Math.floor(width * 0.32))) : Math.min(38, Math.max(24, Math.floor(width * 0.3)));
+	const live = current.total;
+	const above = current.offset > 0;
+	const below = current.offset + rows < live;
+	// Column widths are measured before the canvas exists: the axis gets the
+	// slack, the lanes get what they need.
+	const plan = railColumnPlan(current.shown, now, portrait, width, above || below ? 2 : 0);
 	const LX = 1;
-	const AW = Math.max(4, width - LX - nameCol - 2);
+	const AW = Math.max(RAIL_AXIS_MIN_COLS, Math.min(width - LX - 1, width - LX - plan.needed));
 	const canvas = new Canvas(width, rows + 1);
 	const hit: Array<Array<string | undefined>> = Array.from({ length: rows + 1 }, () => new Array<string | undefined>(width).fill(undefined));
 	const byId = new Map(nodes.map((node) => [node.id, node]));
@@ -227,9 +367,6 @@ export function renderRailway(input: RailInput): RailRender | undefined {
 		hit[y0 + r]![LX + c] = cell.owner;
 	}
 
-	const live = current.total;
-	const above = current.offset > 0;
-	const below = current.offset + rows < live;
 	const rateText = formatRate(input.rate);
 	const winLabel = ` −${Math.max(1, Math.round(windowMs / 60000))}m `;
 	canvas.text(LX + 1, 0, winLabel, "dim");
@@ -285,22 +422,18 @@ export function renderRailway(input: RailInput): RailRender | undefined {
 		const overflow = i === 0 && above ? " ▲" : i === rows - 1 && below ? " ▼" : "";
 		const avail = width - (nameX + 2) - overflow.length;
 		if (portrait) {
-			canvas.text(nameX + 2, y, ellipsize(node.name, avail), col, { bold: true });
+			const ago = formatActivityAgo(node.lastActivityAt, now);
+			const label = ago === "—" ? node.name : `${node.name} · ${ago}`;
+			canvas.text(nameX + 2, y, ellipsize(label, avail), col, { bold: true });
 		} else {
-			const longest = Math.max(...current.shown.map((n) => Array.from(n.name).length));
-			const nameW = Math.min(16, longest, Math.max(6, avail - 8));
+			// Paint with the same width the plan measured (clamped to what is
+			// actually available): mismatched widths sized the axis for one layout
+			// and drew another, clipping the tail of the detail text.
+			const nameW = Math.min(plan.nameW, Math.max(1, avail));
 			canvas.text(nameX + 2, y, ellipsize(node.name, nameW), col, { bold: true });
-			const room = Math.max(0, avail - nameW - 1);
-			const elapsed = formatAgentElapsed({
-				state: node.status,
-				startedAt: node.startedAt,
-				...(node.endedAt !== undefined ? { finishedAt: node.endedAt } : {}),
-				...(node.currentTurnStartedAt !== undefined ? { currentTurnStartedAt: node.currentTurnStartedAt } : {}),
-				...(node.currentTurnEndedAt !== undefined ? { currentTurnEndedAt: node.currentTurnEndedAt } : {}),
-			}, now);
-			const full = `${node.role} · ${elapsed}`;
-			const detail = ellipsize(Array.from(full).length <= room ? full : elapsed, room);
-			canvas.text(nameX + 3 + nameW, y, detail, "dim");
+			const candidates = laneDetailCandidates(node, now);
+			const detail = candidates[Math.min(plan.grade, candidates.length - 1)]!;
+			canvas.text(nameX + 3 + nameW, y, detail, "dim", { maxX: width - overflow.length });
 		}
 		if (overflow) canvas.text(width - overflow.length, y, overflow, "text", { bold: true });
 	});

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";
@@ -172,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 {
@@ -185,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));
 	}
@@ -239,7 +240,7 @@ export class RateSampler {
 	}
 }
 
-/** 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);
 }