pi-legion 2.0.0 → 2.0.2

package/src/tui/viz/rate.ts

@@ -6,17 +6,29 @@
  *
  *   numerator   = Δ cumulative output tokens over the trailing window
  *   denominator = Δ cumulative generationMs over the same window
- *                 (falls back to wall-clock window only when generationMs
- *                  is unavailable / zero for that node)
+ *                 (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)
  *
  * 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.
  */
 
 import type { VizNode } from "./model.ts";
 
 export const RATE_WINDOW_MS = 60_000;
+/**
+ * Min in-window ΔgenerationMs before trusting gen as the tok/s denominator.
+ * Matches tree-row t/s gate (`generationMs >= 1000` in status.ts). Below this,
+ * fall back to wall-clock window length so a 1ms gen flush cannot spike to M.
+ */
+export const MIN_RATE_GENERATION_MS = 1_000;
 const DEFAULT_RETENTION_MS = 6 * 60 * 60 * 1000;
 const MAX_SAMPLES_PER_NODE = 4096;
 
@@ -125,24 +137,39 @@ export class RateSampler {
 
 	/**
 	 * Output tok/s over the trailing window: ΔtokensOut / (ΔgenerationMs/1000).
-	 * When the node has no generationMs samples in the window, falls back to
-	 * wall-clock window length so a ledger-only path still yields a number.
+	 * When in-window ΔgenerationMs is 0 or below MIN_RATE_GENERATION_MS, falls
+	 * back to wall-clock window length so a ledger-only path still yields a
+	 * number and a sub-second gen flush cannot report M-level TPS.
 	 */
 	nodeRate(nodeId: string, now: number, windowMs = RATE_WINDOW_MS): number {
 		if (windowMs <= 0) return 0;
 		const dOut = Math.max(0, this.valueAt(nodeId, now) - this.valueAt(nodeId, now - windowMs));
 		if (dOut <= 0) return 0;
 		const dGen = Math.max(0, this.genAt(nodeId, now) - this.genAt(nodeId, now - windowMs));
-		const seconds = dGen > 0 ? dGen / 1000 : windowMs / 1000;
+		const seconds = dGen >= MIN_RATE_GENERATION_MS ? dGen / 1000 : windowMs / 1000;
 		return dOut / seconds;
 	}
 
-	totalRate(now: number, windowMs = RATE_WINDOW_MS): number {
+	/**
+	 * Sum of node rates. When `onlyNodeIds` is set (including empty), only those
+	 * series contribute — used for header "now". 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 {
+		const filter = onlyNodeIds === undefined ? undefined : new Set(onlyNodeIds);
 		let sum = 0;
-		for (const id of this.series.keys()) sum += this.nodeRate(id, now, windowMs);
+		for (const id of this.series.keys()) {
+			if (filter && !filter.has(id)) continue;
+			sum += this.nodeRate(id, now, windowMs);
+		}
 		return sum;
 	}
 
+	/** Header / snap "now" 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));
+	}
+
 	nodeIds(): string[] {
 		return [...this.series.keys()];
 	}
@@ -150,8 +177,8 @@ export class RateSampler {
 	/**
 	 * Bucketed tok/s for [from, to], stacked by role. Each bucket is the
 	 * trailing-window average ending at the bucket edge (window = max(bucket
-	 * span, RATE_WINDOW_MS)), so the last bucket equals the header "now" and
-	 * bursty per-turn token flushes do not render as spikes.
+	 * span, RATE_WINDOW_MS)), including settled series so history stays painted.
+	 * Header "now" may be lower (live-only); bursty flushes stay smoothed.
 	 */
 	buckets(from: number, to: number, count: number, windowMs = RATE_WINDOW_MS): RateSeries {
 		const n = Math.max(1, Math.floor(count));
@@ -191,6 +218,11 @@ export class RateSampler {
 	}
 }
 
+/** Node ids that contribute to header "now" 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);
+}
+
 function interpolate(ts: number[], value: number[], t: number): number {
 	if (ts.length === 0) return 0;
 	if (t <= ts[0]!) return value[0]!;

package/src/tui/viz/view.ts

@@ -1,7 +1,7 @@
 /** /legion full view: galaxy + tok/s chart + git-log history with linked selection. */
 
 import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { Canvas, ellipsize } from "./canvas.ts";
+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";
@@ -22,6 +22,9 @@ export function initialViewState(): LegionViewState {
 
 const PANES: Pane[] = ["galaxy", "chart", "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;
+
 export function renderLegionView(data: ViewData, state: LegionViewState, cols: number, rows: number): { canvas: Canvas; layout: LayoutKind } {
 	const W = Math.max(1, Math.floor(cols));
 	const H = Math.max(6, Math.floor(rows));
@@ -44,21 +47,25 @@ export function renderLegionView(data: ViewData, state: LegionViewState, cols: n
 		`${agents.length} agents`,
 		...(failed ? [`${failed} failed`] : []),
 	];
-	const badge = selected ? ` ${selected.name} (${selected.role} · ${statusLabel(selected)}) ` : "";
+	const badgeRaw = selected ? ` ${selected.name} (${selected.role} · ${statusLabel(selected)}) ` : "";
+	// Cap the selection badge so a long agent name never overwrites "⚔ /legion" / the run name.
+	const badgeCap = Math.max(0, Math.min(cellWidth(badgeRaw), Math.floor(W * 0.45), W - 14));
+	const badge = badgeRaw ? ellipsize(badgeRaw, badgeCap) : "";
+	const badgeW = cellWidth(badge);
+	const showBadge = badgeW >= MIN_SELECTION_BADGE_W;
 	if (portrait) {
 		cv.text(0, 0, "⚔ /legion ", "accent", { bold: true });
-		cv.text(10, 0, ellipsize(root?.name ?? "", Math.max(0, W - 10)), "text", { bold: true });
+		const rootRoom = Math.max(0, W - 10 - (showBadge ? badgeW + 1 : 0));
+		cv.text(10, 0, ellipsize(root?.name ?? "", rootRoom), "text", { bold: true });
 		cv.text(0, 1, ellipsize(parts.join(" · "), W), "dim");
-		if (badge) {
-			const b = ellipsize(badge, Math.max(0, W - 12 - Array.from(root?.name ?? "").length));
-			if (b.length > 4) cv.text(W - Array.from(b).length, 0, b, roleColor(selected!.role), { inverse: true });
-		}
+		if (showBadge) cv.text(W - badgeW, 0, badge, roleColor(selected!.role), { inverse: true });
 	} else {
 		let x = cv.text(0, 0, "⚔ /legion ", "accent", { bold: true });
-		x = cv.text(x, 0, `${root?.name ?? "legion"}  `, "text", { bold: true });
-		const badgeW = Array.from(badge).length;
-		cv.text(x, 0, ellipsize(parts.join(" · "), Math.max(0, W - x - badgeW - 1)), "dim");
-		if (badge) cv.text(Math.max(0, W - badgeW), 0, ellipsize(badge, W), roleColor(selected!.role), { inverse: true });
+		const reservedBadge = showBadge ? badgeW : 0;
+		const rootRoom = Math.max(0, W - x - reservedBadge - 1);
+		x = cv.text(x, 0, ellipsize(`${root?.name ?? "legion"}  `, rootRoom), "text", { bold: true });
+		cv.text(x, 0, ellipsize(parts.join(" · "), Math.max(0, W - x - reservedBadge - 1)), "dim");
+		if (showBadge) cv.text(W - badgeW, 0, badge, roleColor(selected!.role), { inverse: true });
 	}
 
 	const galaxyInner = frame(cv, layout.galaxy, portrait ? "galaxy" : "galaxy · structure", state.focus === "galaxy");