pi-legion 2.0.1 → 2.0.2

package/CHANGELOG.md

@@ -11,8 +11,25 @@ summary so you can see **2.x vs 0.16** without leaving the tree.
 
 ## [Unreleased]
 
+## [2.0.2] — 2026-10-16
+
 ### Fixed
 
+- Child worktree launches are suppressed when the parent checkout is itself a
+  linked git worktree (`git-dir` ≠ `git-common-dir`): role defaults and unset
+  launch flags collapse to `worktree: false`, matching the centurion-child
+  precedent. Explicit `launch: true` / per-child `step` flags still win.
+- `worktreeBootstrap: "npm-install"` no longer fires `npm install` on a stray
+  `package.json` without a lockfile (observed: Java/Maven repos carrying
+  package.json for docs/tooling); without a lockfile the mode records the
+  marker and skips, so non-npm worktrees launch instead of failing after the
+  10-minute bootstrap budget.
+
+### Fixed in 2.0.1 (inherited from prior entries)
+
+- Railway / `/legion` header "now" tok/s is 0 when no agent is running; only live nodes count toward now (chart buckets still use the full trailing window) (#136).
+- Narrow/stacked `/legion` header truncates long run + selection badges without overwriting `⚔ /legion`; galaxy legend reserves room for failed/retired glyphs before roles (#125).
+- Galaxy legend `statusBudget` counts grapheme cells (not `String.length`); selection badge min width unified for portrait + landscape (#128).
 - Dispatched children now receive `--provider` pinned from the parent's model
   registry, so a bare model id (`workbuddy/…`) that also exists under a static
   auth-less provider in `models.json` can no longer hijack the child start
@@ -36,6 +53,8 @@ summary so you can see **2.x vs 0.16** without leaving the tree.
 
 ### Changed
 
+- Esc no longer retires children; only `/legion stop` or session exit retires (esc-no-retire-v3, #134).
+- Status strip shows a persistent `/legion stop` hint while children are live (railway + tree; width may truncate) (#134).
 - Prefer `PI_LEGION_EXTRA_AGENT_DIRS` over legacy `PI_HERDR_SUBAGENTS_*` (alias; new name wins if both set) (#109 / #114).
 - CONTRIBUTING/CI docs aligned with 2.x RPC; verify-12/13 paths point at `test/legacy/docker/` (#95 / #100, #107 / #112).
 - README: remove duplicate Child extensions heading (#94 / #98).

package/README.md

@@ -96,9 +96,9 @@ prints one node — see [Status](#status-legion-status).
 
 The `subagent` control actions include event-driven `wait` and graceful `stop`:
 `subagent({ action: "wait", name: "worker-0" })` returns as soon as the child
-settles (or the parent turn is interrupted with Esc). Aborting a parent turn
-with Esc gracefully retires its tracked children, including those being waited
-on or collected; the cascade is silent. Launch stays async by default. Under
+settles (or the parent turn is interrupted with Esc). Esc only ends the parent
+wait — children keep running and settle still notifies; retire them with
+`/legion stop` or by exiting the session. Launch stays async by default. Under
 `pi --print` or JSON mode the process would otherwise exit at the end of the
 parent turn and retire those children before they write an assistant message.
 That shutdown waits for each live async child to settle, bounded by the
@@ -113,23 +113,20 @@ sequence for each selected child.
 
 ### Stopping async subagents yourself
 
-Async children keep running after the main turn ends, so Esc-abort no longer
-reaches them. Three user controls run the same graceful `stop` (a stopped
-parent retires its own subtree on shutdown):
+Esc never retires children (see `docs/contracts/esc-no-retire-v3.md`). Two user
+controls run graceful `stop` (a stopped parent retires its own subtree on
+shutdown); process exit / session shutdown also retires:
 
 - **`/legion stop`** stops every live subagent; **`/legion stop <name>`** stops
   one (`all` is an alias for no name). Names complete from the live children;
   nested agents complete as `parent/name` and are reported as owned by their
   parent (stop the parent to retire them).
-- **Esc** while the main agent is idle, the editor is empty, no dialog or
-  overlay is open and subagents are live asks "Stop N running subagents?".
-  In every other state Esc keeps pi's normal behaviour.
 - **`x`** on the selected live agent in the `/legion` view or its live
   overlay asks `y` to confirm in place, then stops it.
 
-While the main agent is idle and subagents are live, the railway header shows
-a dim `esc stop all · /legion stop [name]` hint (shortened on narrow terminals,
-hidden while the main agent is working).
+While subagents are live, the railway header can show a dim
+`/legion stop [name|all]` hint (shortened on narrow terminals; idle gating /
+tree-strip coverage is a TUI follow-up).
 
 ### Status (`/legion status`)
 

package/docs/contracts/esc-abort-v1.md

@@ -2,6 +2,8 @@
 
 > **v2 修订（2026-10-13）**：ESC / 父 turn abort 的语义已改为级联优雅关闭由该 turn 拥有的 children，推翻 v1 下文的「ESC ≠ 杀 children」决定。下文保留 v1 冻结原文，仅供历史考古；当前语义以 `docs/contracts/esc-cascade-v2.md` 为准。
 
+> **v3 说明（2026-10-15）**：v3（`esc-no-retire-v3.md`）再次回到 v1 的「ESC ≠ 杀 children」原则；与 v1 不同的是保留 session_shutdown drain/归因与显式 `/legion stop`。v2 级联语义已推翻。
+
 ## 目标
 
 1. 主 pi 按 ESC（或 RPC abort）打断当前 turn 时，正在执行的 `subagent` 工具调用必须尽快感知并优雅收场，不能钉住事件循环。

package/docs/contracts/esc-cascade-v2.md

@@ -1,5 +1,8 @@
 # ESC 级联关闭契约（v2，2026-10-13 冻结）
 
+> **v3 推翻（2026-10-15）**：ESC / 父 turn abort **不再**级联 retire children。当前语义以 `docs/contracts/esc-no-retire-v3.md` 为准。下文保留 v2 冻结原文，仅供历史考古。
+
+
 ## 背景
 
 v1（esc-abort-v1.md，已随 e66c85f 合入）冻结了「ESC ≠ 杀 children」语义。用户裁决推翻：turn 是 children 的 owner，turn 被 abort 时 children 应级联关闭，否则是资源泄漏。

package/docs/contracts/esc-no-retire-v3.md

@@ -0,0 +1,57 @@
+# ESC 不再 retire children（v3，2026-10-15 冻结）
+
+## 背景
+
+v2（`esc-cascade-v2.md`）把「父 turn abort → 级联 retire children」冻结为产品语义。2026-10-15 实测事故：主会话异步派了多个 child 后用 `wait` 阻塞，用户按 Esc 打断父 turn，级联 retire 把整棵仍在生长的 legion 树抹掉（含尚未派生子 agent 的 centurion）。Esc 是高频误触键，后果不可恢复。
+
+用户裁决推翻 v2：**Esc 只打断父 turn 的等待，不杀 children；停止 subagent 只有两条路——显式 `/legion stop`，或主进程退出。**
+
+## 冻结决定
+
+### A. Esc ≠ retire
+
+1. **Idle Esc stop 删除**：不再有 `createIdleEscStop` / `onTerminalInput` 接线。裸 Esc 在 idle 时也不再 stop all。
+2. **父 turn abort 不再级联**：工具 execute 各 `signal?.aborted` 分支只返回 interrupted 文案，**不**调用 `cascadeRetireAll`。`cascadeRetireAll` / `cascadePromise` / `agent_settled{aborted}` 级联钩子全部删除。
+3. **`abandonLaunchedChild`**：spawn 后 abort 时 **不 retire**；`followLaunched(..., { watch: true })`，child 继续跑，settle 仍通知父会话。
+4. **`runtime.waitOne` WAIT_INTERRUPTED**：**必须 re-arm watch**（`consumedByTool = false` + `watch`），否则 child 完成后无人收割、无完成通知。
+
+### B. 中断文案
+
+统一为：
+
+```text
+interrupted (parent turn ended; children still running)
+```
+
+不再使用 `interrupted (parent turn aborted)`（易误导为已 abort children）。
+
+### C. 保留的 retire 路径（不变）
+
+- 显式 `stop` action / `/legion stop` / `/legion` 视图 `x`
+- `session_shutdown` → `shutdownRetireAll`（交互立刻 retire；`--print` / JSON 先 `drainBeforeShutdown` 再 retire）
+- SIGINT / 进程退出 = 主进程退出 = retire
+
+### D. TUI 提示
+
+有 live child 时，aboveEditor 状态栏常驻 `/legion stop [name|all]`（短版 `/legion stop`）：railway header 在宽度挤压下可截断摘要以保短 hint；`PI_LEGION_STRIP=tree` 在 header 下另起一行短提示。无 idle 门控。
+
+## 语义边界
+
+| 动作 | children |
+|---|---|
+| Esc 打断 wait / 父 turn | 继续跑；re-arm watch；settle 通知 |
+| `/legion stop` / `stop` action | graceful retire |
+| 主进程退出 / session_shutdown | drain（print/json）+ retire |
+| SIGINT | 进程退出 → retire |
+
+## 与 v1 / v2 的关系
+
+- **v1**（`esc-abort-v1.md`）主张「ESC ≠ 杀 children」——v3 回到这一原则，但保留 v1 没有的 drain / shutdown 归因与显式 stop。
+- **v2**（`esc-cascade-v2.md`）级联 retire —— **v3 推翻**；原文保留供考古。
+
+## 验收锚点
+
+- 无 `cascadeRetireAll` / idle Esc 接线
+- wait abort → children still alive + watching；完成通知仍达
+- launch abort mid-spawn → child watched, not retired
+- print-shutdown / session_shutdown / stop 回归绿

package/docs/design.md

@@ -933,12 +933,14 @@ subagent({
 | `resume` | **已退出后恢复**（F12） | 新 pane + `--session <file>` |
 | `retire` | 回收 | ctrl+d / pane close / tab close |
 | `status` / `collect` / `list` | 查询 | child record / session JSONL |
-| `wait` | 等待指定或全部活动 child 完成；由 RPC settle 事件唤醒；ESC 中断时级联优雅关闭 children 后返回 | session runtime + RPC supervisor |
+| `wait` | 等待指定或全部活动 child 完成；由 RPC settle 事件唤醒；ESC 中断只结束等待（children 继续跑并 re-arm watch） | session runtime + RPC supervisor |
 | `stop` | 优雅停止指定或全部 tracked、非 retired children | `retire` 全链 + runtime release |
 
 ### ESC abort 语义 + stop
 
-父 turn 的 ESC / RPC abort signal 会立即打断当前工具等待，并静默级联优雅关闭该 session 所拥有的 tracked children（包括 vexillatio utility children）。`wait` 返回 `interrupted (parent turn aborted)` 前先完成级联 retire；`collect` / inline collect 被中断时也会级联关闭 children，不生成显式 stop 的工具结果文案。级联先取消 completion watch，再并行 retire 并释放 runtime tracking；并发 abort 复用同一级联 promise。新的 turn 会建立新的级联周期。正常完成的 `wait` 仍由 RPC settle 事件立即解除，不需要等满 timeout。
+> **v3（2026-10-15）**：见 `docs/contracts/esc-no-retire-v3.md`。ESC / 父 turn abort **不再**级联 retire。
+
+父 turn 的 ESC / RPC abort signal 会立即打断当前工具等待，但 **children 继续运行**；`wait` 返回 `interrupted (parent turn ended; children still running)` 并 re-arm watch，settle 仍通知父会话。显式 `/legion stop` / `stop` action，或主进程退出（`session_shutdown`，print/json 先 drain）才会 retire。正常完成的 `wait` 仍由 RPC settle 事件立即解除，不需要等满 timeout。
 
 `stop` 是显式停止操作：`subagent({ action: "stop", name: "worker-0" })` 停一个 child，`subagent({ action: "stop", all: true })` 逐个停止当前跟踪的全部非 retired children。它复用 `retire` 生命周期（优雅关闭、超时后升级信号、后代清理）并释放 runtime 跟踪；`stop` 本身不接父 turn abort signal。`name` 与 `all` 互斥且必须指定其一。
 

package/index.ts

@@ -42,7 +42,7 @@ import {
 	loadSubagentSettings,
 	resolveSubagentSettings,
 } from "./src/agents/settings.ts";
-import { createSessionRuntime, renderLiveChildStatus, type SessionRuntime, type TrackedJob, shouldRecycleAfterCollect, type WaitResult } from "./src/extension/runtime.ts";
+import { createSessionRuntime, renderLiveChildStatus, type SessionRuntime, shouldRecycleAfterCollect, type WaitResult } from "./src/extension/runtime.ts";
 import { createDbEventSource, createLegionEventBus, type DbEventSource, type LegionEventBus } from "./src/extension/event-bus.ts";
 import { LegionPostman, registerLegionTools, type LegionMailCommand } from "./src/extension/legion-tools.ts";
 import { LEGION_DB_ENV, LEGION_NODE_ID_ENV } from "./src/runs/args.ts";
@@ -66,7 +66,6 @@ import {
 	type RpcEventSource,
 	confirmAndStopNode,
 } from "./src/extension/legion-commands.ts";
-import { createIdleEscStop, liveJobs } from "./src/extension/legion-stop.ts";
 import { DEFAULT_FLUSH_MS, DEFAULT_JOIN_MODE } from "./src/extension/join.ts";
 import { registerChildGuard } from "./src/extension/child-guard.ts";
 import { registerScoutGuard } from "./src/extension/scout-guard.ts";
@@ -102,10 +101,6 @@ import {
 	SubagentError,
 } from "./src/shared/types.ts";
 
-// The parent turn owns its child lifetime. Parallel tool aborts in one turn
-// share this graceful-retire cascade; turn_start begins a fresh cycle.
-let cascadePromise: Promise<void> | undefined;
-
 // ---------------------------------------------------------------------------
 // Parameters
 // ---------------------------------------------------------------------------
@@ -481,7 +476,6 @@ async function resumeLegionChild(input: { pi: ExtensionAPI; supervisor: LegionSu
 }
 
 export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps = {}) {
-	cascadePromise = undefined;
 	const isChild = process.env.PI_SUBAGENT_CHILD === "1";
 	const allowNested = process.env[ALLOW_NESTED_ENV] === "1";
 	if (isChild) restoreHostNodeOptions();
@@ -592,49 +586,6 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 		]);
 		stopLegionRuntime();
 	};
-	let cascadingJobs = new Set<TrackedJob>();
-	let cascadingUtilityRetires = new Set<() => Promise<void>>();
-	const cascadeRetireAll = (): Promise<void> => {
-		const jobs = (sessionRuntime?.activeJobs() ?? []).filter(
-			(job) => job.state !== "retired" && !cascadingJobs.has(job),
-		);
-		const utilityRetires = pendingUtilityRetires.filter(
-			(retire) => !cascadingUtilityRetires.has(retire),
-		);
-		if (!cascadePromise) cascadePromise = Promise.resolve();
-		if (jobs.length === 0 && utilityRetires.length === 0) return cascadePromise;
-		for (const job of jobs) {
-			cascadingJobs.add(job);
-			sessionRuntime?.cancelWatch(job.name);
-		}
-		for (const retire of utilityRetires) cascadingUtilityRetires.add(retire);
-		const retirements = [
-			...jobs.map((job) => async () => job.retire?.()),
-			...utilityRetires.map((retire) => async () => retire()),
-		];
-		cascadePromise = cascadePromise.then(async () => {
-			// allSettled waits for every graceful retire without turning a child
-			// failure into a user-visible result or skipping runtime release.
-			await Promise.allSettled(retirements.map((retire) => retire()));
-			for (const job of jobs) sessionRuntime?.release(job.name);
-		});
-		return cascadePromise;
-	};
-	// Register before the child early-return paths below: a command-chain child
-	// may use vexillatio across multiple turns without creating a session runtime.
-	pi.on("turn_start", () => {
-		cascadePromise = undefined;
-		cascadingJobs = new Set();
-		cascadingUtilityRetires = new Set();
-	});
-	// An async launch has already returned when ESC lands: no subagent-family
-	// tool call is in flight to observe the abort signal, so the run's settle
-	// event is the last chance to retire this turn's children. Never awaited —
-	// a graceful retire may take seconds and must not stall the settle path.
-	pi.on("agent_settled", (event) => {
-		if (!event.aborted) return;
-		void cascadeRetireAll();
-	});
 	if (process.env[UTILITY_CHILD_ENV] !== "1") {
 		pi.registerTool({
 			name: "vexillatio",
@@ -643,8 +594,7 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 			parameters: VexillatioParams,
 			async execute(_id, params, signal, _onUpdate, ctx: ExtensionContext): Promise<AgentToolResult<unknown>> {
 				if (signal?.aborted) {
-					await cascadeRetireAll();
-					return ok("interrupted (parent turn aborted)");
+					return ok("interrupted (parent turn ended; children still running)");
 				}
 				if (!subagentsEnabled(ctx.cwd)) {
 					return fail("subagents are disabled (subagents.enabled: false or /legion off). Re-enable with /legion on.", ErrorCodes.DISABLED);
@@ -673,8 +623,7 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 					onUtilityChild: (retire) => pendingUtilityRetires.push(retire),
 				});
 				if (signal?.aborted) {
-					await cascadeRetireAll();
-					return ok("interrupted (parent turn aborted)");
+					return ok("interrupted (parent turn ended; children still running)");
 				}
 				return result;
 			},
@@ -874,8 +823,7 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 			runtime.bind(ctx);
 			const action = params.action ?? "launch";
 			if (signal?.aborted && action !== "stop") {
-				await cascadeRetireAll();
-				return ok("interrupted (parent turn aborted)");
+				return ok("interrupted (parent turn ended; children still running)");
 			}
 			// Master switch: refuse NEW launches with a pointer to the toggle;
 			// control actions (status/collect/wait/…) must stay available so a
@@ -940,7 +888,7 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 							nodeId: job.nodeId,
 						})),
 						stopAvailable: true,
-						idleEscWired: true,
+						idleEscWired: false,
 						legionTools: ["subagent", "vexillatio"],
 						allowNestedEnv: process.env[ALLOW_NESTED_ENV] === "1",
 					},
@@ -960,8 +908,7 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 				return fail(`legion runtime initialization failed: ${error instanceof Error ? error.message : String(error)}`, ErrorCodes.INVALID_PARAMS);
 			}
 			if (signal?.aborted && action !== "stop") {
-				await cascadeRetireAll();
-				return ok("interrupted (parent turn aborted)");
+				return ok("interrupted (parent turn ended; children still running)");
 			}
 
 			// Control actions address an EXISTING child; launch-family actions
@@ -985,8 +932,7 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 					legion: activeLegion,
 				});
 				if (signal?.aborted && action !== "stop") {
-					await cascadeRetireAll();
-					return ok("interrupted (parent turn aborted)");
+					return ok("interrupted (parent turn ended; children still running)");
 				}
 				return result;
 			}
@@ -1010,41 +956,13 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 				onUpdate,
 			});
 			if (signal?.aborted) {
-				await cascadeRetireAll();
-				return ok("interrupted (parent turn aborted)");
+				return ok("interrupted (parent turn ended; children still running)");
 			}
 			return result;
 		},
 	});
 
-	let lastCtx: ExtensionContext | undefined;
-	let escUi: ExtensionUIContext | undefined;
-	let escUnsubscribe: (() => void) | undefined;
-	const idleEscStop = createIdleEscStop({
-		isIdle: () => lastCtx?.isIdle?.() ?? false,
-		editorEmpty: () => !(lastUi?.getEditorText?.() ?? "").trim(),
-		uiBusy: () => {
-			const tui = runtime.statusTui() as { hasOverlay?: () => boolean; getFocusedComponent?: () => unknown } | undefined;
-			if (!tui) return true;
-			if (tui.hasOverlay?.()) return true;
-			const focused = tui.getFocusedComponent?.() as { getText?: unknown } | null | undefined;
-			// Only the prompt editor may have focus: dialogs/selectors keep pi's Esc.
-			return !focused || typeof focused.getText !== "function" || !("onEscape" in focused);
-		},
-		liveCount: () => liveJobs(runtime.activeJobs()).length,
-		confirm: (title, message) => lastUi ? lastUi.confirm(title, message) : Promise.resolve(false),
-		stopAll: async () => {
-			const result = await stopChildren({ all: true });
-			lastUi?.notify(result.text, result.ok ? "info" : "error");
-		},
-	});
 	const bindUi = (_event: unknown, ctx: ExtensionContext): void => {
-		lastCtx = ctx;
-		if (ctx.hasUI && ctx.ui !== escUi && typeof ctx.ui?.onTerminalInput === "function") {
-			escUnsubscribe?.();
-			escUi = ctx.ui;
-			escUnsubscribe = ctx.ui.onTerminalInput(idleEscStop);
-		}
 		lastUi = ctx.hasUI ? ctx.ui : undefined;
 		if (ctx.cwd) lastCwd = ctx.cwd;
 		runtime.bind(ctx);
@@ -1075,7 +993,6 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 	});
 
 	pi.on("session_start", (event, ctx) => {
-		runtime.setParentIdle(ctx.isIdle?.() ?? true);
 		bindUi(event, ctx);
 	});
 	pi.on("session_info_changed", bindUi);
@@ -1088,11 +1005,9 @@ export default function piLegion(pi: ExtensionAPI, deps: ExtensionSupervisorDeps
 		bindUi(event, ctx);
 	});
 	pi.on("agent_start", (event, ctx) => {
-		runtime.setParentIdle(false);
 		bindUi(event, ctx);
 	});
 	pi.on("agent_end", (event, ctx) => {
-		runtime.setParentIdle(true);
 		bindUi(event, ctx);
 	});
 	pi.on("input", bindUi);
@@ -1367,13 +1282,13 @@ async function collectChild(
 	signal?: AbortSignal,
 ): Promise<AgentToolResult<unknown>> {
 	try {
-		if (signal?.aborted) return ok("interrupted (parent turn aborted)");
+		if (signal?.aborted) return ok("interrupted (parent turn ended; children still running)");
 		const pending = signal
 			? ctx.runtime.consumeCollectInterruptible(ctx.name, signal)
 			: ctx.runtime.consumeCollect(ctx.name);
 		if (pending) {
 			const collected = await pending;
-			if (!collected || signal?.aborted) return ok("interrupted (parent turn aborted)");
+			if (!collected || signal?.aborted) return ok("interrupted (parent turn ended; children still running)");
 			await persistChild(ctx.store, ctx.found.runId, ctx.orchestrator, ctx.name, { preserveRetired: true });
 			return ok(renderCollect(ctx.name, collected));
 		}
@@ -1392,7 +1307,7 @@ async function collectChild(
 			...(signal ? { signal } : {}),
 		});
 		if (signal?.aborted || collected.execution.reason === "aborted by parent") {
-			return ok("interrupted (parent turn aborted)");
+			return ok("interrupted (parent turn ended; children still running)");
 		}
 		const retireAlreadyFinishedJob = shouldRecycleAfterCollect(collected.execution.status) && !collected.blocked;
 		await persistChild(ctx.store, ctx.found.runId, ctx.orchestrator, ctx.name, { preserveRetired: !retireAlreadyFinishedJob });
@@ -1602,7 +1517,7 @@ async function launchFamily(input: {
 		for (const name of session.handles) await abandonLaunchedChild(session, name);
 		session.handles.length = 0;
 		return {
-			content: [{ type: "text", text: session.results.join("\n") || "interrupted (parent turn aborted)" }],
+			content: [{ type: "text", text: session.results.join("\n") || "interrupted (parent turn ended; children still running)" }],
 			details: { runId: run.runId, handles: [], async: params.async ?? true },
 		};
 	};
@@ -1913,7 +1828,7 @@ function resolveStep(
 async function collectInline(session: LaunchSession, signal?: AbortSignal): Promise<void> {
 	for (const name of session.handles) {
 		if (signal?.aborted) {
-			session.results.push("interrupted (parent turn aborted)");
+			session.results.push("interrupted (parent turn ended; children still running)");
 			return;
 		}
 		try {
@@ -1922,7 +1837,7 @@ async function collectInline(session: LaunchSession, signal?: AbortSignal): Prom
 				...(signal ? { signal } : {}),
 			});
 			if (signal?.aborted || collected.execution.reason === "aborted by parent") {
-				session.results.push("interrupted (parent turn aborted)");
+				session.results.push("interrupted (parent turn ended; children still running)");
 				return;
 			}
 			session.results.push(renderCollect(name, collected));
@@ -2265,7 +2180,7 @@ async function launchUtilityFamily(input: {
 			return `✗ ${handle.name}: collect failed: ${error instanceof Error ? error.message : String(error)}\nsessionFile: ${handle.sessionFile}`;
 		}
 	}));
-	if (input.signal?.aborted) return ok("interrupted (parent turn aborted)");
+	if (input.signal?.aborted) return ok("interrupted (parent turn ended; children still running)");
 	results.push(...collected);
 	return {
 		content: [{ type: "text", text: results.join("\n\n") || "No utility agents were launched." }],
@@ -2583,18 +2498,10 @@ async function abandonLaunchedChild(session: LaunchSession, name: string): Promi
 		session.runtime.release(name);
 		return;
 	}
-	child.execution = { status: "failed", reason: "launch abandoned because parent turn aborted" };
-	child.acceptance = { status: "rejected", level: "none", reason: "aborted by parent" };
-	try {
-		await session.orchestrator.retire(name);
-		await persistChild(session.store, session.runId, session.orchestrator, name);
-		session.runtime.release(name);
-		session.results.push(`✗ ${name}: abandoned because parent turn aborted (child retired)`);
-	} catch (error) {
-		await persistChild(session.store, session.runId, session.orchestrator, name);
-		followLaunched(session, name, { watch: true });
-		session.results.push(`✗ ${name}: abandon retire failed: ${String(error)}; completion remains watched`);
-	}
+	// Esc / parent-turn abort must not retire: child keeps running; follow+watch
+	// so settle still notifies the parent (esc-no-retire-v3).
+	followLaunched(session, name, { watch: true });
+	session.results.push(`▶ ${name}: parent turn ended; child still running (watched)`);
 }
 
 // ---------------------------------------------------------------------------
@@ -2647,7 +2554,7 @@ export function renderWait(results: WaitResult[]): string {
 			parts.push(`── ${result.name} ──\nstill running`);
 		} else if (result.interrupted) {
 			interrupted += 1;
-			parts.push(`── ${result.name} ──\ninterrupted (parent turn aborted)`);
+			parts.push(`── ${result.name} ──\ninterrupted (parent turn ended; children still running)`);
 		} else {
 			parts.push(`── ${result.name} ──\nnot tracked (no live job, no finished cache)`);
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-legion",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Pi Legion v2: recursive centurion trees on headless Pi RPC; shared SQLite WAL legion.db. Four-stage planning/implementing/reviewing/verifying state machine, parent/child/sibling legion_mail, three-layer /legion UI, upward MR trees, squad resume.",
   "type": "module",
   "license": "MIT",

package/src/extension/legion-commands.ts

@@ -519,7 +519,7 @@ function buildDoctorReport(
 				: undefined,
 		})),
 		stopAvailable: Boolean(deps.stop),
-		idleEscWired: true,
+		idleEscWired: false,
 		legionTools: ["subagent", "vexillatio"],
 		allowNestedEnv: process.env[ALLOW_NESTED_ENV] === "1",
 	};

package/src/extension/legion-doctor.ts

@@ -809,7 +809,7 @@ export function runLegionDoctor(options: DoctorOptions = {}): DoctorReport {
 		for (const line of LEGION_SLASH_HELP_LINES) push(`    ${line}`);
 		push(`- stop wired: ${runtime.stopAvailable === undefined ? "(unknown)" : runtime.stopAvailable ? "yes" : "no"}`);
 		push(`- idle Esc stop wired: ${runtime.idleEscWired === undefined ? "(unknown)" : runtime.idleEscWired ? "yes" : "no"}`);
-		push(`- idle strip hints: "${IDLE_STOP_HINT}" / short "${IDLE_STOP_HINT_SHORT}"`);
+		push(`- stop strip hints: "${IDLE_STOP_HINT}" / short "${IDLE_STOP_HINT_SHORT}"`);
 		push(`- legion tools registered: ${(runtime.legionTools ?? ["(unknown — typically subagent, vexillatio, legion-* mail/tools)"]).join(", ")}`);
 		push("- slash: `/legion doctor [section]`");
 		push("- tool: `subagent({ action: \"diagnose\", section? })` — optional section filter (same as `/legion doctor [section]`)");

package/src/extension/legion-stop.ts

@@ -3,10 +3,9 @@
  *   - `/legion stop` (all) / `/legion stop <name>` — thin wrapper over the
  *     subagent tool's `stop` action (graceful retire; a retired parent's own
  *     session shutdown retires its subtree, so stopping a parent cascades).
- *   - Esc while the main agent is idle, the editor is empty and children are
- *     live → confirm → stop all.
  *   - `x` on the selected agent in the /legion view → confirm → stop it.
- * Everything here is pure/injectable so it can be unit tested.
+ * Esc no longer stops children (esc-no-retire-v3); only `/legion stop` or
+ * process exit retires. Everything here is pure/injectable for unit tests.
  */
 
 export interface StopJob {
@@ -114,37 +113,6 @@ export async function runLegionStop(arg: string, deps: StopDeps): Promise<string
 	return say(result.text, result.ok ? "info" : "error");
 }
 
-export interface IdleEscDeps {
-	/** Main agent not streaming / running a turn. */
-	isIdle(): boolean;
-	editorEmpty(): boolean;
-	/** An overlay, dialog or non-editor component has focus. */
-	uiBusy(): boolean;
-	liveCount(): number;
-	confirm(title: string, message: string): Promise<boolean>;
-	stopAll(): Promise<void>;
-}
-
-/**
- * Raw terminal input hook: consumes a bare Esc only when the main agent is
- * idle, the editor is empty, nothing else owns focus and children are live.
- * Every other key (and Esc in any other state) passes through to pi.
- */
-export function createIdleEscStop(deps: IdleEscDeps): (data: string) => { consume: true } | undefined {
-	let prompting = false;
-	return (data) => {
-		if (data !== "\x1b" || prompting) return undefined;
-		const count = deps.liveCount();
-		if (count === 0 || !deps.isIdle() || !deps.editorEmpty() || deps.uiBusy()) return undefined;
-		prompting = true;
-		void deps.confirm("Stop subagents", `Stop ${count} running subagent${count === 1 ? "" : "s"}?`)
-			.then((yes) => (yes ? deps.stopAll() : undefined))
-			.catch(() => {})
-			.finally(() => { prompting = false; });
-		return { consume: true };
-	};
-}
-
-/** Dim hint shown in the railway header while the main agent is idle and children are live. */
-export const IDLE_STOP_HINT = "esc stop all · /legion stop [name]";
-export const IDLE_STOP_HINT_SHORT = "esc stop all";
+/** Dim hint shown in the status strip while children are live (aboveEditor / tree). */
+export const IDLE_STOP_HINT = "/legion stop [name|all]";
+export const IDLE_STOP_HINT_SHORT = "/legion stop";

package/src/extension/playbook.ts

@@ -10,7 +10,7 @@ export const PARENT_PLAYBOOK = [
 	'   One child:  subagent({ agent: "<role>", task: "...", name?: "scout-a" })  // optional name= registers that handle (not auto scout-N)',
 	"   Parallel:   subagent({ tasks: [{ agent, task }, { agent, task }] })",
 	"2. Prefer tasks[] for independent parallel work. Child processes are headless RPC children; no pane or tab is created.",
-	"3. Then return control. A completion message wakes this session when idle; if it is still working, the notice waits until the current turn ends. Use `wait` when you need blocking results, and `collect` to inspect a child's session JSONL. Pressing Esc to abort a parent turn gracefully retires its children; a wait interrupted by Esc returns `interrupted (parent turn aborted)` after cascade shutdown. In `pi --print` or JSON mode, session shutdown waits for live async children to settle (up to each child's turn timeout) before retiring them. Use same-turn `wait`/`collect` or `async: false` when that print turn must include the child's result.",
+	"3. Then return control. A completion message wakes this session when idle; if it is still working, the notice waits until the current turn ends. Use `wait` when you need blocking results, and `collect` to inspect a child's session JSONL. Esc / wait interrupt only ends the parent turn's wait — children keep running and settle still notifies; only an explicit `stop` or session exit retires them. A wait interrupted by Esc returns `interrupted (parent turn ended; children still running)`. In `pi --print` or JSON mode, session shutdown waits for live async children to settle (up to each child's turn timeout) before retiring them. Use same-turn `wait`/`collect` or `async: false` when that print turn must include the child's result.",
 	"4. Later control is only through `subagent({ action, name, message })`; use `stop` to gracefully retire one child or all tracked children. If a child exits oddly (Model not found, missing tools, memory refused, …), call `subagent({ action: \"diagnose\" })` or ask the user to run `/legion doctor` / `/legion doctor models` — children use `--no-extensions`, so provider packages must be passed explicitly. Do not tell a child to message or prompt the parent directly.",
 	"5. A collect timeout with a live RPC child is a progress signal, not a verdict. Check status or session JSONL before deciding to steer or resume.",
 	"6. Isolation is YOUR call. Pass `worktree: true` when another parent may write this repo or the child must ship via MR; pass `worktree: false` to share the checkout. Omit it for the role default.",
@@ -23,7 +23,7 @@ export const TOOL_DESCRIPTION = [
 	PARENT_PLAYBOOK,
 	"Roles: the system prompt lists every loaded role. Prefer the matching role over doing that work yourself.",
 	"Launch is async by default. Outcomes come from the child session JSONL. In non-interactive `pi --print` / JSON mode, shutdown waits for those children before retiring them; pass `async: false` or call `wait`/`collect` in the same turn to fold the result into the print output.",
-	"Actions: launch (default), continue, steer, resume, status, collect, wait, list, retire, stop, diagnose. `diagnose` prints the Legion doctor report (host vs child extensions/providers/models/memory). `wait` is event-driven: it returns when a child settles, times out, or the parent turn is aborted; an Esc abort also gracefully retires children owned by that turn. `stop` explicitly and gracefully retires selected children.",
+	"Actions: launch (default), continue, steer, resume, status, collect, wait, list, retire, stop, diagnose. `diagnose` prints the Legion doctor report (host vs child extensions/providers/models/memory). `wait` is event-driven: it returns when a child settles, times out, or the parent turn is interrupted; Esc does not retire children — use `stop` (or exit the session) to retire them.",
 ].join(" ");
 
 /** Split shell commands into sequential chunks while preserving old helper API. */

package/src/extension/runtime.ts

@@ -300,7 +300,7 @@ export interface WaitResult {
 	snapshot?: CollectSnapshot;
 	/** Still running when the timeout fired. */
 	stillRunning?: boolean;
-	/** The parent turn aborted while this wait was pending. */
+	/** The parent turn ended while this wait was pending; children still running. */
 	interrupted?: boolean;
 	/** Not tracked live and no finished cache (pre-validated upstream). */
 	missing?: boolean;
@@ -339,8 +339,6 @@ export interface SessionRuntime {
 	refreshUi(): void;
 	/** Live visualization data (nodes + token-rate sampler) for the /legion view. */
 	vizSnapshot(): StatusVizSnapshot;
-	/** Main agent idle flag for the railway stop hint. */
-	setParentIdle(idle: boolean): void;
 	/** TUI hosting the status widget (unknown shape; used for overlay/focus checks). */
 	statusTui(): unknown;
 	/** Forward join config to the internal coordinator (settings wiring). */
@@ -709,9 +707,10 @@ export function createSessionRuntime(deps: SessionRuntimeDeps): SessionRuntime {
 			}
 			const outcome = await Promise.race(racers);
 			if (outcome === WAIT_INTERRUPTED) {
-				// The session-level abort cascade retires this job, so do not arm
-				// a completion watcher for a child that is about to be closed.
+				// Esc / parent-turn abort does not retire children (esc-no-retire-v3).
+				// Re-arm watch so settle still notifies the parent.
 				job.consumedByTool = false;
+				if (!job.watching) runtime.watch(name);
 				return { name, interrupted: true };
 			}
 			const snapshot = outcome;
@@ -1065,9 +1064,6 @@ export function createSessionRuntime(deps: SessionRuntimeDeps): SessionRuntime {
 			return [...jobs.values()];
 		},
 
-		setParentIdle(idle) {
-			board.setIdleHint?.(idle);
-		},
 		statusTui() {
 			return board.getTui?.();
 		},

package/src/runs/orchestrator.ts

@@ -64,6 +64,7 @@ import { nativeModelFor } from "./kind.ts";
 import { applyVerification, type VerifyRunner } from "./acceptance.ts";
 import {
 	createChildWorktree,
+	isInsideChildWorktree,
 	removeChildWorktree,
 	resolveLaunchWorktree,
 } from "./worktree.ts";
@@ -535,7 +536,11 @@ export class Orchestrator {
 			? true
 			: this.legion && parentRole === "centurion"
 				? false
-				: resolveLaunchWorktree({ roleDefault: input.agent.worktree, launch: input.worktree });
+				: resolveLaunchWorktree({
+					roleDefault: input.agent.worktree,
+					launch: input.worktree,
+					parentInWorktree: isInsideChildWorktree(this.cwd),
+				});
 		let worktreePath = previous?.worktreePath;
 		let worktreeBranch = previous?.worktreeBranch;
 		let createdWorktree = false;

package/src/runs/provision.ts

@@ -58,7 +58,13 @@ function writeMarker(worktreePath: string, mode: string): void {
 	fs.renameSync(tmp, file);
 }
 
-/** Repo-relative manifests, in resolution order, for the npm-install mode. */
+/** Repo-relative manifests, in resolution order, for the npm-install mode.
+ *
+ * The bare package.json fallback was removed: a package.json without any
+ * lockfile is far more often a non-npm repo caught by mistake (Java/Maven
+ * repos carry stray package.json files for docs/tooling) than a real npm
+ * project (which always has a lockfile). Without a lockfile we skip
+ * provisioning instead of firing npm install into a Java checkout. */
 function installCommandFor(worktreePath: string): string | null {
 	if (fs.existsSync(path.join(worktreePath, "pnpm-lock.yaml"))) {
 		return "pnpm install --frozen-lockfile";
@@ -72,9 +78,6 @@ function installCommandFor(worktreePath: string): string | null {
 	if (fs.existsSync(path.join(worktreePath, "package-lock.json"))) {
 		return "npm ci";
 	}
-	if (fs.existsSync(path.join(worktreePath, "package.json"))) {
-		return "npm install";
-	}
 	return null;
 }
 

package/src/runs/worktree.ts

@@ -24,17 +24,49 @@ export function worktreePathFor(runDir: string, name: string): string {
  * Per-step tool field wins, then the top-level `subagent({ worktree })`
  * argument, then the role default. The parent (group) agent is supposed to
  * pick this; the role default is only the fallback when it omits the field.
+ *
+ * Nesting suppression: when the parent cwd is itself a child worktree
+ * (git-dir ≠ git-common-dir), the role default and launch fallback collapse
+ * to false — a worktree of a worktree only re-pays the bootstrap tax.
+ * Explicit `launch: true`/`step: true` still wins: the caller saw the
+ * suppression and insisted.
  */
 export function resolveLaunchWorktree(opts: {
 	roleDefault?: boolean;
 	launch?: boolean;
 	step?: boolean;
+	parentInWorktree?: boolean;
 }): boolean {
 	if (typeof opts.step === "boolean") return opts.step;
 	if (typeof opts.launch === "boolean") return opts.launch;
+	if (opts.parentInWorktree) return false;
 	return opts.roleDefault === true;
 }
 
+/**
+ * True when cwd is itself a linked git worktree (child of a main checkout).
+ * Detected via `git rev-parse --git-dir` vs `--git-common-dir`: they differ
+ * inside any linked worktree, including ones created by other agent runs.
+ * Non-git directories report both as ".git" and are treated as not-in-worktree;
+ * the later createChildWorktree call owns the "not a repo" error.
+ */
+export function isInsideChildWorktree(cwd: string): boolean {
+	try {
+		const gitDir = execFileSync("git", ["-C", cwd, "rev-parse", "--git-dir"], {
+			stdio: ["ignore", "pipe", "pipe"],
+			encoding: "utf8",
+		}).trim();
+		const commonDir = execFileSync(
+			"git",
+			["-C", cwd, "rev-parse", "--git-common-dir"],
+			{ stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" },
+		).trim();
+		return gitDir !== commonDir && gitDir !== "" && commonDir !== "";
+	} catch {
+		return false;
+	}
+}
+
 /** Branch the child commits on. Unique per launch so two workers never collide. */
 export function worktreeBranchFor(name: string, nonce?: string): string {
 	const tag = nonce ?? randomBytes(4).toString("hex");

package/src/tui/status.ts

@@ -598,7 +598,7 @@ export interface StatusVizSnapshot {
 	nodes: VizNode[];
 	sampler: RateSampler;
 	now: number;
-	/** Shared output tok/s (ΔtokensOut / ΔgenerationMs over trailing 60s). */
+	/** Header "now" tok/s (live agents only; 0 when none running). */
 	rate: number;
 }
 
@@ -608,8 +608,6 @@ export interface StatusBoard {
 	vizSnapshot?(now?: number): StatusVizSnapshot;
 	paint(entries: StatusEntry[], now: number): void;
 	clear(): void;
-	/** Show the idle stop hint in the railway header (main agent idle, children live). */
-	setIdleHint?(on: boolean): void;
 	/** The TUI the widget is mounted in, when registered (for focus/overlay checks). */
 	getTui?(): unknown;
 }
@@ -646,7 +644,6 @@ export function createStatusBoard(options: {
 	let tui: WidgetTui | undefined;
 	let railScroll: RailScroll = { offset: 0 };
 	let railWindow: { offset: number; total: number; maxLanes: number } | undefined;
-	let idleHint = false;
 
 	const renderLines = (now: number, theme: Theme, width?: number): {
 		lines: string[];
@@ -655,8 +652,9 @@ export function createStatusBoard(options: {
 	} => {
 		if (strip === "railway" && hasTreeIdentity(entries) && width !== undefined && width >= 20) {
 			const nodes = nodesFromEntries(entries);
-			const hint = idleHint ? { hint: IDLE_STOP_HINT, hintShort: IDLE_STOP_HINT_SHORT } : {};
-			const rendered = railwayLines({ nodes, now, width, rate: sampler.totalRate(now), scroll: railScroll, ...hint }, theme);
+			// Live-child gate: railway only renders when lanes exist; always show stop hint.
+			const hint = { hint: IDLE_STOP_HINT, hintShort: IDLE_STOP_HINT_SHORT };
+			const rendered = railwayLines({ nodes, now, width, rate: sampler.nowRate(now, nodes), scroll: railScroll, ...hint }, theme);
 			// Persist the clamped window (anchored on the top lane's agent) so later
 			// renders follow ends/starts without jumping; resets to 0 when all fit.
 			railWindow = rendered.window;
@@ -666,10 +664,14 @@ export function createStatusBoard(options: {
 		railWindow = undefined;
 		const visible = visiblePanelEntries(entries);
 		const totals = statusTotals(entries);
-		const rows = formatWidgetRows(visible, now, totals);
+		let rows = formatWidgetRows(visible, now, totals);
+		// Tree strip + Legion identity: short stop hint on its own row (survives width squeeze).
+		if (strip === "tree" && hasTreeIdentity(entries) && rows.length > 0) {
+			rows = [rows[0]!, { text: IDLE_STOP_HINT_SHORT }, ...rows.slice(1)];
+		}
 		const nodeIdsByRow = rows.map((row) => row.nodeId);
 		return {
-			lines: themeLines(formatWidgetLines(visible, now, totals), theme),
+			lines: themeLines(rows.map((row) => row.text), theme),
 			hitAt: (_x, y) => nodeIdsByRow[y],
 		};
 	};
@@ -796,16 +798,12 @@ export function createStatusBoard(options: {
 			if (hasTreeIdentity(next)) sampler.record(_now, nodesFromEntries(next));
 			paint();
 		},
-		setIdleHint(on) {
-			if (idleHint === on) return;
-			idleHint = on;
-			tui?.requestRender();
-		},
 		getTui() {
 			return tui;
 		},
 		vizSnapshot(now = Date.now()) {
-			return { nodes: nodesFromEntries(entries), sampler, now, rate: sampler.totalRate(now) };
+			const nodes = nodesFromEntries(entries);
+			return { nodes, sampler, now, rate: sampler.nowRate(now, nodes) };
 		},
 		clear() {
 			entries = [];

package/src/tui/viz/canvas.ts

@@ -87,6 +87,11 @@ function isWide(code: number): boolean {
 	);
 }
 
+/** Grapheme / cell count (UTF-16-safe). Prefer over `String.length` for layout budgets. */
+export function cellWidth(value: string): number {
+	return Array.from(value).length;
+}
+
 /** Truncate plain text to `width` single-width cells with an ellipsis. */
 export function ellipsize(value: string, width: number): string {
 	const chars = Array.from(value).map(sanitizeChar);

package/src/tui/viz/panels.ts

@@ -1,6 +1,6 @@
 /** Panel renderers for the /legion full view. All drawing is clipped to its rect. */
 
-import { Canvas, ellipsize } from "./canvas.ts";
+import { Canvas, cellWidth, ellipsize } from "./canvas.ts";
 import type { Rect } from "./layout.ts";
 import { formatCount, formatDuration, isAgent, type VizNode } from "./model.ts";
 import { nodeToken, roleColor } from "./palette.ts";
@@ -12,7 +12,7 @@ export interface ViewData {
 	nodes: readonly VizNode[];
 	sampler: RateSampler;
 	now: number;
-	/** Shared output tok/s (ΔtokensOut / ΔgenerationMs over trailing 60s). */
+	/** Header "now" tok/s (live agents only; 0 when none running). Chart avg/buckets keep full-series windows. */
 	rate: number;
 }
 
@@ -241,23 +241,29 @@ export function drawGalaxy(cv: Canvas, r: Rect, data: ViewData, selectedId: stri
 		}
 	}
 	// Legend: roles that actually appear (dynamic), then status hints.
+	// Reserve room for failed/retired glyphs first so a narrow panel still matches live scout (#102/#125).
 	const ly = r.y + r.h - 1;
 	let lx = r.x + 1;
 	const roles: string[] = [];
 	for (const node of dfsOrder(nodes)) if (isAgent(node) && !roles.includes(node.role)) roles.push(node.role);
+	const statuses = new Set(nodes.map((node) => node.status));
+	const statusItems = ([["failed", "✗ failed", "error"], ["retired", "⣿ retired", "dim"]] as const)
+		.filter(([status]) => statuses.has(status));
+	// Budget in grapheme cells (not String.length) so multi-byte / emoji labels do not squeeze roles (#128).
+	const statusBudget = statusItems.reduce((sum, [, label]) => sum + cellWidth(label) + 2, 0);
+	const roleLimit = r.x + r.w - 1 - statusBudget;
 	for (const role of roles) {
-		const w = Array.from(role).length + 4;
-		if (lx + w > r.x + r.w - 1) break;
+		const w = cellWidth(role) + 4;
+		if (lx + w > roleLimit) break;
 		cv.set(lx, ly, "⣿", roleColor(role));
 		cv.text(lx + 2, ly, role, "dim");
 		lx += w;
 	}
-	const statuses = new Set(nodes.map((node) => node.status));
-	for (const [status, label, col] of [["failed", "✗ failed", "error"], ["retired", "⣿ retired", "dim"]] as const) {
-		if (!statuses.has(status)) continue;
-		if (lx + label.length + 1 > r.x + r.w - 1) break;
+	for (const [, label, col] of statusItems) {
+		const lw = cellWidth(label);
+		if (lx + lw + 1 > r.x + r.w - 1) break;
 		cv.text(lx, ly, label, col);
-		lx += label.length + 2;
+		lx += lw + 2;
 	}
 }
 
@@ -302,7 +308,7 @@ export function computeStats(data: ViewData, buckets: number): ChartStats {
 	}
 	return {
 		now: data.rate,
-		// Same definition as header "now", averaged over the chart window.
+		// Full-series window average (includes settled); differs from header "now" on purpose.
 		avg: data.sampler.totalRate(to, Math.max(1, to - from)),
 		peak,
 		peakAt,

package/src/tui/viz/railway.ts

@@ -39,14 +39,14 @@ export interface RailInput {
 	nodes: readonly VizNode[];
 	now: number;
 	width: number;
-	/** Output tok/s over the shared 60s generation window. */
+	/** Header "now" tok/s (live agents only; 0 when none running). */
 	rate: number;
 	windowMs?: number;
 	/** Lane scroll position when more agents are live than lanes fit. */
 	scroll?: RailScroll;
-	/** Dim hint on the header rule (e.g. stop controls while the main agent is idle). */
+	/** Dim hint on the header rule (e.g. `/legion stop` while children are live). */
 	hint?: string;
-	/** Shorter variant used when the full hint does not fit. */
+	/** Shorter variant used when the full hint does not fit; truncated further under squeeze. */
 	hintShort?: string;
 }
 
@@ -234,18 +234,41 @@ export function renderRailway(input: RailInput): RailRender | undefined {
 	const winLabel = ` −${Math.max(1, Math.round(windowMs / 60000))}m `;
 	canvas.text(LX + 1, 0, winLabel, "dim");
 	const range = above || below ? ` · ${scrollIndicator(current.offset, rows, live)} ${above ? "▲" : " "}${below ? "▼" : " "}` : "";
-	const header = portrait
+	const headerFull = portrait
 		? ` ${live} live${range} · ${rateText} `
 		: ` legion ${live} live${range} · ${rateText} `;
-	const headerX = Math.max(LX + 1 + winLabel.length, width - header.length - 1);
-	canvas.text(headerX, 0, header, "accent", { bold: true, maxX: width - 1 });
+	// Hint sits between the window label and the right-hand summary. Prefer the
+	// full string, then short; when width squeezes, shrink the summary so the
+	// short `/legion stop` still fits, and only then ellipsize the hint.
+	const labelEnd = LX + 1 + winLabel.length;
+	const hx = labelEnd + 1;
+	let header = headerFull;
+	let headerX = Math.max(labelEnd, width - Array.from(header).length - 1);
+	let hintPick: string | undefined;
 	if (input.hint) {
-		// Between the window label and the summary, with a rule gap on both sides.
-		const hx = LX + 1 + winLabel.length + 1;
-		const room = headerX - 1 - hx;
-		const pick = [input.hint, input.hintShort].find((text) => text && Array.from(text).length + 2 <= room);
-		if (pick) canvas.text(hx, 0, ` ${pick} `, "dim");
+		const short = input.hintShort ?? input.hint;
+		const shortBlock = Array.from(short).length + 2; // leading+trailing spaces
+		const gap = 1; // rule cell between hint and summary
+		const needHeaderX = hx + shortBlock + gap;
+		if (headerX < needHeaderX) {
+			// Pull/truncate the summary so short hint keeps a slot.
+			headerX = Math.min(width - 1, Math.max(needHeaderX, labelEnd));
+			const avail = Math.max(0, width - 1 - headerX);
+			header = avail >= 3 ? ` ${ellipsize(headerFull.trim(), avail - 2)} ` : "";
+			if (header) headerX = Math.max(labelEnd, width - Array.from(header).length - 1);
+			// Re-assert short reservation if summary still crowds the hint.
+			if (header && headerX < needHeaderX) {
+				headerX = needHeaderX;
+				const clipped = Math.max(0, width - 1 - headerX);
+				header = clipped >= 3 ? ` ${ellipsize(headerFull.trim(), clipped - 2)} ` : "";
+			}
+		}
+		const room = Math.max(0, (header ? headerX - 1 : width - 1) - hx);
+		hintPick = [input.hint, input.hintShort].find((text) => text && Array.from(text).length + 2 <= room);
+		if (!hintPick && room >= 3) hintPick = ellipsize(short, room - 2);
 	}
+	if (header) canvas.text(headerX, 0, header, "accent", { bold: true, maxX: width - 1 });
+	if (hintPick) canvas.text(hx, 0, ` ${hintPick} `, "dim");
 	for (const [c, tick] of headerTicks) {
 		if (canvas.get(LX + c, 0)?.ch !== "─") continue; // never draw over header text
 		canvas.set(LX + c, 0, "┬", tick.color);

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");