pi-legion 2.0.3 → 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";
@@ -21,6 +23,9 @@ import {
 } from "./chat-items.ts";
 
 export interface LiveOverlayNode extends Pick<LegionNode, "id" | "name" | "role" | "model" | "status" | "createdAt" | "updatedAt"> {
+	/** Null parent = root/主 agent; set for 子 agents so the modal title can mark 主/子. */
+	parentId?: string | null;
+	depth?: number;
 	turn?: number;
 	turns?: number;
 	sessionFile?: string | null;
@@ -147,6 +152,59 @@ const DEFAULT_BACKFILL_TURNS = 3;
 const DEFAULT_TERMINAL_ROWS = 24;
 const TOOL_COLLAPSED_PREVIEW_LINES = 10;
 const BACKFILL_POLL_INTERVAL_MS = 250;
+/**
+ * #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
@@ -287,7 +345,13 @@ function createSession(
 		return value;
 	};
 
-	const bodyPageSize = (): number => Math.max(0, currentTerminalRows() - 1);
+	/** Full terminal width last passed to render/handleMouse (modal chrome uses this). */
+	let terminalWidth = 80;
+
+	const layoutFor = (width = terminalWidth): ModalLayout =>
+		resolveModalLayout(currentTerminalRows(), Math.max(1, Math.floor(width)));
+
+	const bodyPageSize = (): number => layoutFor().bodyRows;
 
 	const mountNewItems = (): void => {
 		for (const item of mountedItems) {
@@ -458,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;
 				}
@@ -534,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);
@@ -661,13 +724,19 @@ function createSession(
 	};
 
 	let stopPending = false;
-	const headerLine = (width: number): string => {
-		const safeWidth = Math.max(1, Math.floor(width));
+
+	/** Slim title: name + 主/子 only. Run meta lives in the footer band (#157). */
+	const titlePlain = (): string => {
 		const node = sourceNode();
-		if (!node) {
-			const missing = `● ${nodeId} · node unavailable`;
-			return style(options.theme, "dim", fitLine(missing, safeWidth));
-		}
+		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();
@@ -677,14 +746,45 @@ function createSession(
 			? `${Math.max(0, Math.round((now() - turnStartedAt) / 1_000))}s`
 			: undefined;
 		const turnLabel = `turn ${turnNumber}${turnElapsed !== undefined ? ` (${turnElapsed})` : ""}`;
-		const details = [
-			`● ${safeText(node.name)} (${safeText(node.role)})`,
+		return [
+			safeText(node.role),
 			...(node.model ? [safeText(node.model)] : []),
 			turnLabel,
 			elapsed,
 			status,
-		];
-		return style(options.theme, completed ? "dim" : "accent", fitLine(details.join(" · "), safeWidth));
+		].join(" · ");
+	};
+
+	const titleBarInner = (innerWidth: number): string => {
+		const safeWidth = Math.max(1, Math.floor(innerWidth));
+		const node = sourceNode();
+		const completed = node !== undefined &&
+			(node.status === "settled" || node.status === "failed" || node.status === "retired");
+		if (stopPending) {
+			return style(
+				options.theme,
+				"accent",
+				fitLine(
+					`Stop ${safeText(node?.name ?? nodeId)}? Its own subagents are retired with it.  y stop · any other key cancel`,
+					safeWidth,
+				),
+			);
+		}
+		const closeHint = ` ${MODAL_CLOSE_HINT} `;
+		const closeWidth = visibleWidth(closeHint);
+		const titleBudget = Math.max(1, safeWidth - closeWidth);
+		const coloredTitle = style(
+			options.theme,
+			!node || completed ? "dim" : "accent",
+			fitLine(titlePlain(), titleBudget),
+		);
+		const pad = Math.max(0, titleBudget - visibleWidth(stripTerminalSequences(coloredTitle)));
+		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 => {
@@ -741,15 +841,27 @@ function createSession(
 	const component: LiveOverlayComponent = {
 		nodeId,
 		render(width) {
-			contentWidth = Math.max(1, Math.floor(width));
+			terminalWidth = Math.max(1, Math.floor(width));
+			const layout = layoutFor(terminalWidth);
+			contentWidth = layout.innerWidth;
 			lastBodyLines = renderBody(contentWidth);
 			syncScroll(lastBodyLines);
 			const start = Math.max(0, scrollTop);
-			const end = start + bodyPageSize();
-			const header = stopPending
-				? style(options.theme, "accent", fitLine(`Stop ${safeText(sourceNode()?.name ?? nodeId)}? Its own subagents are retired with it.  y stop · any other key cancel`, contentWidth))
-				: headerLine(contentWidth);
-			return [header, ...lastBodyLines.slice(start, end)];
+			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,
+				metaInner: layout.showMeta ? metaBarInner(layout.innerWidth) : undefined,
+				footerHint,
+			});
 		},
 		handleInput(data) {
 			if (!open) return;
@@ -794,20 +906,33 @@ function createSession(
 		},
 		handleMouse(event: TuiMouseEvent) {
 			if (!open) return undefined;
+			terminalWidth = Math.max(1, Math.floor(event.width));
+			const layout = layoutFor(terminalWidth);
+			contentWidth = layout.innerWidth;
 			if (event.type === "wheel" && event.wheelDelta) {
+				// Wheel over the frame scrolls the modal body.
 				scrollBy(event.wheelDelta);
 				return { handled: true };
 			}
-			contentWidth = Math.max(1, Math.floor(event.width));
 			lastBodyLines = renderBody(contentWidth);
 			clampScroll(lastBodyLines);
-			const viewportY = event.y - 1;
-			if (viewportY < 0 || viewportY >= bodyPageSize()) return undefined;
-			const transcriptY = viewportY + scrollTop;
-			if (transcriptY >= lastBodyLines.length) return undefined;
+			const hit = hitTestModal(layout, event.x, event.y);
+			if (hit.zone === "close") {
+				if (event.type === "click" && event.button === "left") {
+					// Esc / close hint: dismiss only — never retire or stop (esc-no-retire-v3).
+					close();
+					return { handled: true };
+				}
+				return { handled: true };
+			}
+			if (hit.zone !== "body" || hit.bodyY === undefined) return { handled: true };
+			const transcriptY = hit.bodyY + scrollTop;
+			if (transcriptY >= lastBodyLines.length) return { handled: true };
 			return transcript.handleMouse({
 				...event,
+				x: hit.bodyX ?? 0,
 				y: transcriptY,
+				width: layout.innerWidth,
 				height: lastBodyLines.length,
 			});
 		},
@@ -872,3 +997,151 @@ function style(
 ): string {
 	return theme ? theme.fg(color, line) : line;
 }
+
+/** Label the viewed agent as 主 (root) or 子 (child) for the modal title bar. */
+export function contextKindLabel(node: LiveOverlayNode | undefined, nodeId: string): "主" | "子" {
+	if (node?.parentId === null || node?.depth === 0 || nodeId === "root") return "主";
+	if (node?.parentId !== undefined && node.parentId !== null) return "子";
+	if (node?.depth !== undefined && node.depth > 0) return "子";
+	// Infer from Legion id shape: root has no dots; children are parent.child…
+	return nodeId === "root" || !nodeId.includes(".") ? "主" : "子";
+}
+
+export interface ModalLayout {
+	rows: number;
+	cols: number;
+	marginY: number;
+	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;
+	/** 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));
+	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 = 1 + innerWidth;
+	const closeColStart = Math.max(1, closeColEnd - closeWidth);
+	return {
+		rows: safeRows,
+		cols: safeCols,
+		marginY: 0,
+		marginX: 0,
+		titleRow,
+		bodyStartRow,
+		metaRow,
+		footerRow,
+		bodyRows,
+		innerWidth,
+		frameRows,
+		frameCol: 0,
+		showMeta,
+		closeColStart,
+		closeColEnd,
+	};
+}
+
+type ModalHitZone = "close" | "title" | "body" | "meta" | "footer";
+
+function hitTestModal(
+	layout: ModalLayout,
+	x: number,
+	y: number,
+): { zone: ModalHitZone; bodyX?: number; bodyY?: number } {
+	// 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" };
+	return {
+		zone: "body",
+		bodyX: Math.max(0, x - 1),
+		bodyY: y - layout.bodyStartRow,
+	};
+}
+
+function padToInner(line: string, innerWidth: number): string {
+	const clipped = fitLine(line, innerWidth);
+	const pad = Math.max(0, innerWidth - visibleWidth(stripTerminalSequences(clipped)));
+	return clipped + " ".repeat(pad);
+}
+
+function paintModalFrame(input: {
+	layout: ModalLayout;
+	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, metaInner, footerHint } = input;
+	const dim = (s: string) => style(theme, "dim", s);
+	const accent = (s: string) => style(theme, "accent", s);
+	const lines: string[] = [];
+	// #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("┛");
+
+	lines.push(top);
+	for (let i = 0; i < layout.bodyRows; i++) {
+		const body = padToInner(bodyLines[i] ?? "", layout.innerWidth);
+		lines.push(accent("┃") + body + accent("┃"));
+	}
+	if (layout.showMeta) {
+		const meta = padToInner(metaInner ?? "", layout.innerWidth);
+		lines.push(accent("┃") + meta + accent("┃"));
+	}
+	lines.push(bottom);
+	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;
 	}