pi-legion 2.0.4 → 3.0.0

package/src/tui/live-overlay.ts

@@ -8,6 +8,8 @@ import {
 	visibleWidth,
 	type Component,
 	type OverlayHandle,
+	type OverlayOptions,
+	type SizeValue,
 	type TUI,
 	type TuiMouseEvent,
 } from "@earendil-works/pi-tui";
@@ -150,12 +152,60 @@ const DEFAULT_BACKFILL_TURNS = 3;
 const DEFAULT_TERMINAL_ROWS = 24;
 const TOOL_COLLAPSED_PREVIEW_LINES = 10;
 const BACKFILL_POLL_INTERVAL_MS = 250;
-/** Outer dim mask rows when the terminal is tall enough for a clear floating modal. */
-const MODAL_MARGIN_Y_COMFORTABLE = 1;
-/** Outer dim mask columns (left/right) outside the modal border. */
-const MODAL_MARGIN_X_COMFORTABLE = 2;
+/**
+ * #157: Cap the floating context modal by terminal ratio so large transcripts do
+ * not stretch the shell near-fullscreen. Content scrolls inside the body.
+ * Tuned on 80×24 + 160×50 dumps (≈75% × ≈65% feels clearly smaller than full
+ * screen without feeling cramped). Floor sizes kick in on mid terminals; on
+ * very small terminals we still fill the screen so body remains usable.
+ *
+ * #193: the surrounding area is NOT painted by the viewer. pi-tui's overlay
+ * compositor discards every base cell inside the overlay rectangle (there is no
+ * transparency option in `OverlayOptions`), so any mask this component paints is
+ * opaque by construction. The host underlay (chat / /legion) stays visible only
+ * because the overlay is anchored to the frame rect alone — see
+ * `resolveModalOverlayOptions()`.
+ */
+const MODAL_MAX_WIDTH_RATIO = 0.75;
+const MODAL_MAX_HEIGHT_RATIO = 0.65;
+/** Prefer at least this frame height once the terminal itself is tall enough. */
+const MODAL_MIN_FRAME_ROWS = 8;
 const MODAL_CLOSE_HINT = "Esc";
 
+/**
+ * Host overlay geometry for the floating frame: cover the frame rect only.
+ *
+ * pi-tui composites an overlay by replacing every base cell inside its
+ * rectangle, and `OverlayOptions` has no transparency mechanism. A full-screen
+ * overlay therefore hides the host chat / /legion underlay completely, and
+ * because the viewer's mask cells are spaces with no background of their own,
+ * the wiped area renders as the terminal's default background — the "black
+ * modal" bug (#193). Anchoring the overlay to the frame rect instead leaves
+ * every cell outside the frame to the host, which paints it.
+ *
+ * The frame is centered horizontally and vertically by the host (`anchor:
+ * "center"`); this module only declares what fraction of the terminal the
+ * frame should occupy.
+ */
+export function resolveModalOverlayOptions(): {
+	width: SizeValue;
+	anchor: "center";
+} & OverlayOptions {
+	// Percentages, not absolute cells: pi resolves `overlayOptions()` once when the
+	// overlay is shown, so absolute numbers freeze at the open-time terminal size and
+	// the frame gets truncated on resize (bottom border and footer disappear).
+	// pi-tui re-derives percentages from the current terminal every frame.
+	//
+	// No `maxHeight`: the component renders exactly the frame rows for whatever
+	// width it is given, so its own height is already the right rect height. A
+	// percentage cap would disagree with it on small terminals (the layout has a
+	// minimum frame height), cutting the bottom border off.
+	return {
+		width: `${MODAL_MAX_WIDTH_RATIO * 100}%`,
+		anchor: "center",
+	};
+}
+
 /**
  * Build an on-demand context-viewer controller. Calling `open` subscribes to
  * the requested node; closing, Esc, disposal, or replacing it unsubscribes once.
@@ -472,7 +522,7 @@ function createSession(
 					consumedFinalizedText ||
 					message.role !== "assistant" ||
 					!Array.isArray(message.content) ||
-					!messageText(message.content).includes(finalizedText)
+					!finalizedText.includes(messageText(message.content))
 				) {
 					return message;
 				}
@@ -548,7 +598,6 @@ function createSession(
 
 	const updateStreamingText = (delta: string): void => {
 		if (!delta) return;
-		if (finalizedAssistantText) finalizedAssistantText = "";
 		streamingText = clampStreamingText(`${streamingText}${delta}`);
 		appendActivityText(delta);
 		chat.updateStreamingText(streamingText, sourceNode()?.model ?? initialNode?.model ?? undefined);
@@ -676,9 +725,18 @@ function createSession(
 
 	let stopPending = false;
 
+	/** Slim title: name + 主/子 only. Run meta lives in the footer band (#157). */
 	const titlePlain = (): string => {
 		const node = sourceNode();
 		if (!node) return `● ${nodeId} · node unavailable`;
+		const kind = contextKindLabel(node, nodeId);
+		return `● ${safeText(node.name)} · ${kind}`;
+	};
+
+	/** Agent/run meta shown below the message body (footer band), not in the title. */
+	const metaPlain = (): string => {
+		const node = sourceNode();
+		if (!node) return "node unavailable";
 		const status = node.status;
 		const completed = status === "settled" || status === "failed" || status === "retired";
 		const elapsedEnd = completed ? node.updatedAt : now();
@@ -688,10 +746,8 @@ function createSession(
 			? `${Math.max(0, Math.round((now() - turnStartedAt) / 1_000))}s`
 			: undefined;
 		const turnLabel = `turn ${turnNumber}${turnElapsed !== undefined ? ` (${turnElapsed})` : ""}`;
-		const kind = contextKindLabel(node, nodeId);
 		return [
-			`● ${safeText(node.name)} (${safeText(node.role)})`,
-			kind,
+			safeText(node.role),
 			...(node.model ? [safeText(node.model)] : []),
 			turnLabel,
 			elapsed,
@@ -726,6 +782,11 @@ function createSession(
 		return coloredTitle + " ".repeat(pad) + style(options.theme, "dim", closeHint);
 	};
 
+	const metaBarInner = (innerWidth: number): string => {
+		const safeWidth = Math.max(1, Math.floor(innerWidth));
+		return style(options.theme, "dim", fitLine(metaPlain(), safeWidth));
+	};
+
 	const close = (): void => {
 		if (!open) return;
 		open = false;
@@ -789,12 +850,17 @@ function createSession(
 			const end = start + layout.bodyRows;
 			const visible = lastBodyLines.slice(start, end);
 			while (visible.length < layout.bodyRows) visible.push("");
+			const footerHint = layout.showMeta
+				? "↑↓ scroll · Esc close"
+				// Tiny terminals collapse the dedicated meta row into the bottom chrome.
+				: `${metaPlain()} · ↑↓ · Esc`;
 			return paintModalFrame({
 				layout,
 				theme: options.theme,
 				titleInner: titleBarInner(layout.innerWidth),
 				bodyLines: visible,
-				footerHint: "↑↓ scroll · Esc close · click mask to dismiss",
+				metaInner: layout.showMeta ? metaBarInner(layout.innerWidth) : undefined,
+				footerHint,
 			});
 		},
 		handleInput(data) {
@@ -844,16 +910,16 @@ function createSession(
 			const layout = layoutFor(terminalWidth);
 			contentWidth = layout.innerWidth;
 			if (event.type === "wheel" && event.wheelDelta) {
-				// Wheel anywhere over the overlay scrolls the modal body (mask included).
+				// Wheel over the frame scrolls the modal body.
 				scrollBy(event.wheelDelta);
 				return { handled: true };
 			}
 			lastBodyLines = renderBody(contentWidth);
 			clampScroll(lastBodyLines);
 			const hit = hitTestModal(layout, event.x, event.y);
-			if (hit.zone === "mask" || hit.zone === "close") {
+			if (hit.zone === "close") {
 				if (event.type === "click" && event.button === "left") {
-					// Esc / mask / close: dismiss only — never retire or stop (esc-no-retire-v3).
+					// Esc / close hint: dismiss only — never retire or stop (esc-no-retire-v3).
 					close();
 					return { handled: true };
 				}
@@ -948,70 +1014,95 @@ export interface ModalLayout {
 	marginX: number;
 	titleRow: number;
 	bodyStartRow: number;
+	/** Fixed meta row below the scrollable body; null when collapsed into the footer. */
+	metaRow: number | null;
 	footerRow: number;
 	bodyRows: number;
 	innerWidth: number;
+	/** Inclusive frame height in rows (title + body + optional meta + footer). */
+	frameRows: number;
 	/** Column where modal border (│/┏) starts. */
 	frameCol: number;
-	/** Absolute screen x range of the Esc close hint in the title bar. */
+	/** Whether a dedicated meta row is painted below the body. */
+	showMeta: boolean;
+	/**
+	 * x range of the Esc close hint in the title bar, RELATIVE to the frame rect
+	 * (pi-tui hands the component `screenX - layout.col`, not the screen column).
+	 */
 	closeColStart: number;
 	closeColEnd: number;
 }
 
+/**
+ * Layout of the floating frame. All row/col values are relative to the frame
+ * rect the component is mounted at (#193): the host sizes that rect
+ * (`resolveModalOverlayOptions()`) and centers it, and the component paints
+ * nothing outside it, so the host chat / /legion underlay stays visible.
+ *
+ * `rows` is the terminal height (used for the height ratio); `cols` is the
+ * frame rect width handed to `render()`.
+ */
 export function resolveModalLayout(rows: number, cols: number): ModalLayout {
 	const safeRows = Math.max(1, Math.floor(rows));
 	const safeCols = Math.max(1, Math.floor(cols));
-	// Prefer a 1-row dim mask; collapse it on short terminals so body still has room.
-	const marginY = safeRows >= 6 ? MODAL_MARGIN_Y_COMFORTABLE : 0;
-	const marginX = safeCols >= 24 ? MODAL_MARGIN_X_COMFORTABLE : safeCols >= 12 ? 1 : 0;
-	const chromeY = 2 * marginY + 2; // masks + title + footer
-	const bodyRows = Math.max(1, safeRows - chromeY);
-	const frameCol = marginX;
-	const innerWidth = Math.max(1, safeCols - 2 * marginX - 2);
-	const titleRow = marginY;
-	const bodyStartRow = marginY + 1;
-	const footerRow = marginY + 1 + bodyRows;
+	const ratioRows = Math.max(1, Math.floor(safeRows * MODAL_MAX_HEIGHT_RATIO));
+	// Small terminals: fill the screen so the body stays usable. Otherwise cap by
+	// ratio (and a modest floor) so the shell stays clearly smaller than the host.
+	const frameRows = safeRows < MODAL_MIN_FRAME_ROWS
+		? safeRows
+		: Math.min(safeRows, Math.max(MODAL_MIN_FRAME_ROWS, ratioRows));
+	// Need title + ≥1 body + meta + footer (=4) for a dedicated meta band.
+	const showMeta = frameRows >= 4;
+	const chromeInside = 2 + (showMeta ? 1 : 0); // title + optional meta + footer
+	const bodyRows = Math.max(1, frameRows - chromeInside);
+	const innerWidth = Math.max(1, safeCols - 2);
+	const titleRow = 0;
+	const bodyStartRow = 1;
+	const metaRow = showMeta ? bodyStartRow + bodyRows : null;
+	const footerRow = showMeta ? metaRow! + 1 : bodyStartRow + bodyRows;
 	const closeWidth = visibleWidth(` ${MODAL_CLOSE_HINT} `);
-	const closeColEnd = frameCol + 1 + innerWidth;
-	const closeColStart = Math.max(frameCol + 1, closeColEnd - closeWidth);
+	const closeColEnd = 1 + innerWidth;
+	const closeColStart = Math.max(1, closeColEnd - closeWidth);
 	return {
 		rows: safeRows,
 		cols: safeCols,
-		marginY,
-		marginX,
+		marginY: 0,
+		marginX: 0,
 		titleRow,
 		bodyStartRow,
+		metaRow,
 		footerRow,
 		bodyRows,
 		innerWidth,
-		frameCol,
+		frameRows,
+		frameCol: 0,
+		showMeta,
 		closeColStart,
 		closeColEnd,
 	};
 }
 
-type ModalHitZone = "mask" | "close" | "title" | "body" | "footer";
+type ModalHitZone = "close" | "title" | "body" | "meta" | "footer";
 
 function hitTestModal(
 	layout: ModalLayout,
 	x: number,
 	y: number,
 ): { zone: ModalHitZone; bodyX?: number; bodyY?: number } {
-	if (y < layout.marginY || y >= layout.rows - layout.marginY) return { zone: "mask" };
-	if (x < layout.frameCol || x >= layout.frameCol + layout.innerWidth + 2) return { zone: "mask" };
+	// x/y are relative to the frame rect (#193): pi-tui dispatches
+	// `screenX - layout.col`, and never dispatches outside the rect at all, so
+	// there is no mask zone to hit-test.
 	if (y === layout.titleRow) {
 		if (x >= layout.closeColStart && x < layout.closeColEnd) return { zone: "close" };
 		return { zone: "title" };
 	}
+	if (layout.metaRow !== null && y === layout.metaRow) return { zone: "meta" };
 	if (y === layout.footerRow) return { zone: "footer" };
-	if (y >= layout.bodyStartRow && y < layout.bodyStartRow + layout.bodyRows) {
-		return {
-			zone: "body",
-			bodyX: Math.max(0, x - (layout.frameCol + 1)),
-			bodyY: y - layout.bodyStartRow,
-		};
-	}
-	return { zone: "mask" };
+	return {
+		zone: "body",
+		bodyX: Math.max(0, x - 1),
+		bodyY: y - layout.bodyStartRow,
+	};
 }
 
 function padToInner(line: string, innerWidth: number): string {
@@ -1025,31 +1116,32 @@ function paintModalFrame(input: {
 	theme: LiveOverlayTheme | undefined;
 	titleInner: string;
 	bodyLines: readonly string[];
+	/** Fixed meta band below the body; omitted when layout.showMeta is false. */
+	metaInner?: string;
 	footerHint: string;
 }): string[] {
-	const { layout, theme, titleInner, bodyLines, footerHint } = input;
+	const { layout, theme, titleInner, bodyLines, metaInner, footerHint } = input;
 	const dim = (s: string) => style(theme, "dim", s);
 	const accent = (s: string) => style(theme, "accent", s);
 	const lines: string[] = [];
-	const maskLine = dim(" ".repeat(layout.cols));
-	const leftMask = dim(" ".repeat(layout.marginX));
-	const rightMaskWidth = Math.max(0, layout.cols - layout.marginX - layout.innerWidth - 2);
-	const rightMask = dim(" ".repeat(rightMaskWidth));
-	const top = leftMask + accent("┏") + padToInner(titleInner, layout.innerWidth) + accent("┓") + rightMask;
-	const bottom = leftMask +
-		accent("┗") +
+	// #193: the component paints the frame rect only — no side/top/bottom mask.
+	// Every cell outside it belongs to the host, which already painted the chat or
+	// the /legion view; painting spaces here would wipe it (the composite has no
+	// transparency) and render as the terminal's default background.
+	const top = accent("┏") + padToInner(titleInner, layout.innerWidth) + accent("┓");
+	const bottom = accent("┗") +
 		padToInner(dim(` ${footerHint} `), layout.innerWidth) +
-		accent("┛") +
-		rightMask;
+		accent("┛");
 
-	for (let i = 0; i < layout.marginY; i++) lines.push(maskLine);
 	lines.push(top);
 	for (let i = 0; i < layout.bodyRows; i++) {
 		const body = padToInner(bodyLines[i] ?? "", layout.innerWidth);
-		lines.push(leftMask + accent("┃") + body + accent("┃") + rightMask);
+		lines.push(accent("┃") + body + accent("┃"));
+	}
+	if (layout.showMeta) {
+		const meta = padToInner(metaInner ?? "", layout.innerWidth);
+		lines.push(accent("┃") + meta + accent("┃"));
 	}
 	lines.push(bottom);
-	for (let i = 0; i < layout.marginY; i++) lines.push(maskLine);
-	while (lines.length < layout.rows) lines.push(maskLine);
-	return lines.slice(0, layout.rows);
+	return lines;
 }

package/src/tui/status.ts

@@ -22,6 +22,7 @@ import { railwayLines, type RailScroll } from "./viz/railway.ts";
 import { IDLE_STOP_HINT, IDLE_STOP_HINT_SHORT } from "../extension/legion-stop.ts";
 
 export const STATUS_WIDGET_KEY = "pi-legion-status";
+/** @deprecated Footer segment removed (#192); kept for API soft-land. Prefer the aboveEditor widget. */
 export const STATUS_FOOTER_KEY = "pi-legion";
 export const STATUS_WIDGET_PLACEMENT = "aboveEditor" as const;
 
@@ -47,6 +48,11 @@ export interface StatusEntry {
 	currentTurnStartedAt?: number;
 	/** Unix ms the current turn settled. Absent while the turn is still in flight. */
 	currentTurnEndedAt?: number;
+	/**
+	 * Unix ms of the agent's last visible activity (edit / reply / status or
+	 * output refresh). Not the run wall-clock start.
+	 */
+	lastActivityAt?: number;
 	/** Cumulative tokens (input+cache+output); from session jsonl (fresh) or ledger usage (≤30s stale). */
 	tokensTotal?: number;
 	/** Cumulative output tokens only; numerator for tok/s / t/s. */
@@ -100,6 +106,21 @@ export function formatElapsed(ms: number): string {
 	return formatElapsedParts(ms, false);
 }
 
+/**
+ * Relative age for railway "last activity" (`3s ago` / `2m ago` / `1h ago`).
+ * Missing timestamp → `—` (placeholder; see #159).
+ */
+export function formatActivityAgo(lastActivityAt: number | undefined, now: number): string {
+	if (lastActivityAt === undefined || !Number.isFinite(lastActivityAt)) return "—";
+	const secs = Math.max(0, Math.floor((now - lastActivityAt) / 1000));
+	if (secs < 60) return `${secs}s ago`;
+	const mins = Math.floor(secs / 60);
+	if (mins < 60) return `${mins}m ago`;
+	const hours = Math.floor(mins / 60);
+	if (hours < 48) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+
 /** Compact token count: 950 -> "950", 1200 -> "1.2K", 2500000 -> "2.5M". */
 function formatTokensCompact(value: number): string {
 	if (!Number.isFinite(value) || value <= 0) return "0";
@@ -111,28 +132,25 @@ function formatTokensCompact(value: number): string {
 }
 
 /**
- * Elapsed of the current turn, shown next to the lifetime elapsed.
+ * Elapsed since the most recent task (turn) started, shown next to the
+ * lifetime elapsed.
  *
- * An in-flight turn ticks with `now`. Once `currentTurnEndedAt` is set the
- * value stays frozen until the next turn replaces the start. A terminal entry
- * with no explicit end freezes at `finishedAt` so the clock does not run on
- * after the agent exits. Undefined when the start is unknown, or when the
- * entry is neither active nor terminal and the turn was not frozen.
+ * Ticks with `now` for as long as the agent itself is live — including the
+ * quiet gap after a turn settles and before the next message arrives, which
+ * is part of "time since the last task started". It freezes only when the
+ * agent ends: a terminal entry clamps at `finishedAt` so the clock does not
+ * run on after the agent exits. Undefined when the turn start is unknown, or
+ * when the entry is neither active nor terminal (an idle seat has no
+ * meaningful running clock).
  */
 function currentTurnElapsedMs(
-	entry: Pick<StatusEntry, "state" | "herdrStatus" | "finishedAt" | "currentTurnStartedAt" | "currentTurnEndedAt">,
+	entry: Pick<StatusEntry, "state" | "herdrStatus" | "finishedAt" | "currentTurnStartedAt">,
 	now: number,
 ): number | undefined {
 	if (entry.currentTurnStartedAt === undefined) return undefined;
 	const start = entry.currentTurnStartedAt;
-	if (entry.currentTurnEndedAt !== undefined) {
-		return Math.max(0, entry.currentTurnEndedAt - start);
-	}
 	const status = entry.herdrStatus ?? entry.state;
-	if (TERMINAL_STATES.has(status)) {
-		if (entry.finishedAt === undefined) return undefined;
-		return Math.max(0, entry.finishedAt - start);
-	}
+	if (TERMINAL_STATES.has(status)) return Math.max(0, (entry.finishedAt ?? now) - start);
 	if (!ACTIVE_STATES.has(status)) return undefined;
 	return Math.max(0, now - start);
 }
@@ -147,20 +165,38 @@ function lifetimeElapsedMs(
 }
 
 /**
- * Headline clock: `12m12s / 1h03m` (current turn / lifetime). Lifetime only
- * when this turn has no timing yet.
+ * How close `currentTurnStartedAt` may sit to `startedAt` and still count as
+ * the same event (round 1). Only a fallback for entries that report no turn
+ * count: the turn start comes from the session's first user message while
+ * `startedAt` is the process spawn, so they differ by the spawn handshake
+ * (~1s) even on round 1.
+ */
+export const SAME_TURN_START_MS = 5_000;
+
+/**
+ * Headline clock: `12m12s / 1h03m` (since last task start / lifetime).
+ *
+ * Lifetime only when the leading clock adds nothing: either this turn has no
+ * timing yet, or it is still round 1 — that turn started with the agent, so
+ * the two clocks are one fact and `16s / 17s` is just the spawn gap.
  */
 export function formatAgentElapsed(
-	entry: Pick<StatusEntry, "state" | "herdrStatus" | "startedAt" | "finishedAt" | "currentTurnStartedAt" | "currentTurnEndedAt">,
+	entry: Pick<StatusEntry, "state" | "herdrStatus" | "startedAt" | "finishedAt" | "currentTurnStartedAt" | "turns">,
 	now: number,
 ): string {
 	const total = formatElapsed(lifetimeElapsedMs(entry, now));
 	const turnElapsed = currentTurnElapsedMs(entry, now);
 	if (turnElapsed === undefined) return total;
+	if (entry.turns !== undefined) {
+		if (entry.turns <= 1) return total;
+	} else if (entry.currentTurnStartedAt !== undefined
+		&& Math.abs(entry.currentTurnStartedAt - entry.startedAt) <= SAME_TURN_START_MS) {
+		return total;
+	}
 	return `${formatElapsedParts(turnElapsed, true)} / ${total}`;
 }
 
-function activeEntries(entries: StatusEntry[]): StatusEntry[] {
+export function activeEntries(entries: StatusEntry[]): StatusEntry[] {
 	return entries.filter((entry) =>
 		entry.parentId !== null && entry.depth !== 0 && ACTIVE_STATES.has(entry.herdrStatus ?? entry.state),
 	);
@@ -169,7 +205,7 @@ function activeEntries(entries: StatusEntry[]): StatusEntry[] {
 /**
  * Panel-visibility gate for the status board: with any Legion-identity
  * entries present, the board mirrors the live-tree filter (completed
- * branches age out; footer/busy counts stay consistent with the widget).
+ * branches age out; busy counts stay consistent with the widget).
  * Legacy flat rosters keep the historical always-shown behavior.
  */
 function hasTreeIdentity(entries: StatusEntry[]): boolean {
@@ -182,11 +218,15 @@ export function visiblePanelEntries(entries: StatusEntry[]): StatusEntry[] {
 	);
 	if (!hasTreeIdentity) return entries;
 	const live = filterLiveTree(entries);
-	// Footer/busy labels key off activeEntries(); keep the ledger root row out
+	// Busy labels key off activeEntries(); keep the ledger root row out
 	// of the visible set entirely (it is not an agent).
 	return live.filter((entry) => entry.nodeId !== "root");
 }
 
+/**
+ * @deprecated Footer `N agents running` removed (#192); the aboveEditor widget
+ * already shows the same count. Kept for API soft-land — do not call from new code.
+ */
 export function formatFooterStatus(entries: StatusEntry[]): string | undefined {
 	const active = activeEntries(entries);
 	if (active.length === 0) return undefined;
@@ -203,7 +243,7 @@ export function formatBusyLabel(entries: StatusEntry[]): string | undefined {
 		names.length > 0
 			? ` (${names.slice(0, 3).join(", ")}${names.length > 3 ? ", …" : ""})`
 			: "";
-	return `⏳ ${active.length} subagent${active.length === 1 ? "" : "s"}${who}`;
+	return `${active.length} subagent${active.length === 1 ? "" : "s"}${who}`;
 }
 
 function roleSuffix(entry: StatusEntry): string {
@@ -247,7 +287,7 @@ function headlineBits(entry: StatusEntry, now: number): string[] {
 	return bits;
 }
 
-function detailBits(entry: StatusEntry, now: number): string[] {
+function detailBits(entry: StatusEntry): string[] {
 	const status = entryStatus(entry);
 	const bits = [entry.phase ? `${entry.phase}/${status}` : status];
 	if (entry.turns && entry.turns > 0) bits.push(`turn ${entry.turns}`);
@@ -257,9 +297,9 @@ function detailBits(entry: StatusEntry, now: number): string[] {
 	if (entry.worktreeBranch) {
 		bits.push(`wt ${formatWorktreeBranch(entry.worktreeBranch)}`);
 	}
-	// Output tok/s over generation time (same definition as railway /legion).
+	// Lifetime avg output tok/s over generationMs (not the header 60s window / live-only nowRate).
 	if (entry.tokensOut && entry.tokensOut > 0 && entry.generationMs && entry.generationMs >= 1_000) {
-		bits.push(`${formatTokensCompact(Math.round(entry.tokensOut / (entry.generationMs / 1_000)))} t/s`);
+		bits.push(`${formatTokensCompact(Math.round(entry.tokensOut / (entry.generationMs / 1_000)))} avg t/s`);
 	}
 	return bits;
 }
@@ -271,7 +311,7 @@ function formatEntryLines(
 ): string[] {
 	return [
 		`${prefix.head}● ${headlineBits(entry, now).join(" · ")}`,
-		`${prefix.detail}  ⎿  ${detailBits(entry, now).join(" · ")}`,
+		`${prefix.detail}  ⎿  ${detailBits(entry).join(" · ")}`,
 	];
 }
 
@@ -476,7 +516,7 @@ function renderTreeWidgetLines(
 		lines.push(widgetRow(`${branch}● ${headline.join(" · ")}`, entry.nodeId));
 		const detailPrefix = `${ancestors}${isLast ? "   " : "│  "}`;
 		lines.push(widgetRow(
-			`${detailPrefix}  ⎿  ${detailBits(effectiveEntry, now).map(cleanDisplayText).join(" · ")}`,
+			`${detailPrefix}  ⎿  ${detailBits(effectiveEntry).map(cleanDisplayText).join(" · ")}`,
 			entry.nodeId,
 		));
 		const childPrefix = `${ancestors}${isLast ? "   " : "│  "}`;
@@ -532,7 +572,7 @@ type Theme = {
 	fg(color: string, text: string): string;
 };
 
-type WidgetTui = { requestRender(): void };
+export type WidgetTui = { requestRender(): void };
 
 export type WidgetFactory = (
 	tui: WidgetTui,
@@ -598,18 +638,18 @@ export interface StatusVizSnapshot {
 	nodes: VizNode[];
 	sampler: RateSampler;
 	now: number;
-	/** Header "now" tok/s (live agents only; 0 when none running). */
+	/** Header tok/s (60s window, live nodes only; 0 when none running). */
 	rate: number;
 }
 
 export interface StatusBoard {
 	bind(ctx: StatusUi): void;
-	/** Live data for the /legion view (same sampler and rate definition as the strip). */
+	/** Live data for the /legion view (same sampler; rate is header nowRate). */
 	vizSnapshot?(now?: number): StatusVizSnapshot;
 	paint(entries: StatusEntry[], now: number): void;
 	clear(): void;
 	/** The TUI the widget is mounted in, when registered (for focus/overlay checks). */
-	getTui?(): unknown;
+	getTui?(): WidgetTui | undefined;
 }
 
 /**
@@ -704,17 +744,14 @@ export function createStatusBoard(options: {
 		if (registered && ui) {
 			safe(() => ui!.setWidget(STATUS_WIDGET_KEY, undefined));
 		}
-		if (ui) safe(() => ui!.setStatus(STATUS_FOOTER_KEY, undefined));
 		registered = false;
 		tui = undefined;
 	};
 
 	const paint = (): void => {
 		if (!ctx || !liveHasUi(ctx)) return;
-		// Footer and widget share the live-tree visibility filter so the counts
-		// stay consistent ("N agents running" refers to visible live agents).
+		// Widget uses the live-tree visibility filter (completed branches age out).
 		const visible = visiblePanelEntries(entries);
-		safe(() => ctx!.ui.setStatus(STATUS_FOOTER_KEY, formatFooterStatus(visible)));
 		if (visible.length === 0) {
 			dropWidget();
 			return;
@@ -832,7 +869,6 @@ export function applyStatus(
 			themed.length ? themed : undefined,
 			{ placement: STATUS_WIDGET_PLACEMENT },
 		);
-		ctx.ui.setStatus(STATUS_FOOTER_KEY, formatFooterStatus(entries));
 	} catch (error) {
 		if (!isStaleUiError(error)) throw error;
 	}

package/src/tui/viz/model.ts

@@ -33,6 +33,10 @@ export interface VizNode {
 	currentTurnStartedAt?: number;
 	/** Unix ms the current turn settled. Absent while it is still in flight. */
 	currentTurnEndedAt?: number;
+	/** Completed turn count (1-based latest); used to gate round clocks on the strip. */
+	turns?: number;
+	/** Unix ms of last visible activity for this seat (not run wall-clock start). */
+	lastActivityAt?: number;
 }
 
 /** Same set the footer/busy label treat as active, so live counts agree everywhere. */
@@ -71,6 +75,8 @@ export function nodesFromEntries(entries: readonly StatusEntry[]): VizNode[] {
 			generationMs: Math.max(0, entry.generationMs ?? 0),
 			...(entry.currentTurnStartedAt !== undefined ? { currentTurnStartedAt: entry.currentTurnStartedAt } : {}),
 			...(entry.currentTurnEndedAt !== undefined ? { currentTurnEndedAt: entry.currentTurnEndedAt } : {}),
+			...(entry.turns !== undefined && entry.turns > 0 ? { turns: entry.turns } : {}),
+			...(entry.lastActivityAt !== undefined ? { lastActivityAt: entry.lastActivityAt } : {}),
 		});
 	}
 	// Parents that are missing from the snapshot re-attach to the nearest known ancestor.