@aeondave/pi-persona 1.17.1 → 1.17.4

package/src/tools/monitor.ts

@@ -3,34 +3,69 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Type } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
 import type { MonitorManager } from "../core/monitor.ts";
-import { failureDetails } from "../extension/shared.ts";
+import { neutralizeMonitorUnicode } from "../core/monitor-output.ts";
+import { formatDuration } from "../core/time.ts";
+import { armWakeAdvice, failureDetails } from "../extension/shared.ts";
 import { compactInlineText } from "../ui/presentation.ts";
+import { renderLiteralToolResult } from "../ui/literal-tool-result.ts";
+import { fenceUntrusted, stripTerminalControls } from "../core/fence.ts";
+import type { MonitorArchive, MonitorLogRecord } from "../monitor/archive.ts";
+
+/** A bounded, fenced read of a session-owned log; never adds a wake by itself. */
+export function renderMonitorLog(record: MonitorLogRecord, full = false): string {
+	const limit = full ? 16_384 : 4_000;
+	const tail = (text: string) => {
+		// Match the live monitor projection's inert bidi/separator policy without rewriting captures.
+		const safe = neutralizeMonitorUnicode(stripTerminalControls(text));
+		return safe.length > limit ? `…[display truncated; use result with full=true for the retained capture]\n${safe.slice(-limit)}` : safe || "(no output)";
+	};
+	return [
+		`${compactInlineText(record.entry.id)} (${compactInlineText(record.entry.label)}) — ${record.outcome}`,
+		...(record.truncated ? ["Log capture is bounded; older output was truncated."] : []),
+		...(record.storageWarning ? [compactInlineText(record.storageWarning, { maxChars: 400 })] : []),
+		fenceUntrusted(`${tail(record.text)}\nstdout:\n${tail(record.stdout)}\nstderr:\n${tail(record.stderr)}`),
+	].join("\n");
+}
 
 export interface MonitorToolDeps {
 	get lastCtx(): ExtensionContext | undefined;
 	set lastCtx(value: ExtensionContext | undefined);
 	canRun(): boolean;
 	monitors: Pick<MonitorManager, "arm" | "list" | "cancel">;
+	archive?: Pick<MonitorArchive, "result" | "list">;
 }
 
 export function registerMonitorTool(pi: ExtensionAPI, d: MonitorToolDeps): void {
 	pi.registerTool({
 		name: "monitor",
 		label: "Monitor",
-		description: "Watch a job, file, log or system event using a background program. arm starts command (an executable) with args in the current workspace; no implicit shell. The argument list allows up to 64 literal arguments, each up to 8192 characters and 24,000 characters in total. mode=output wakes on nonempty stdout lines; write an adapter that prints only relevant changes. mode=exit wakes once when the launched job finishes. Returns immediately; continue independent work, then end your turn to receive events automatically. Requires monitor AND bash permission. Default: one event, ten-minute deadline; max eight monitors, twenty events each, twenty-four hours. list shows active watches; cancel stops the owned process tree and queued wakes. Keep this Pi session open; watches stop on session shutdown/reload. Do not wrap delegate or Exocom in a monitor: their notifications are already automatic.",
+		description: "Watch a job, file, log or system event using a background program. arm starts command (an executable) with args in the current workspace; no implicit shell. The argument list allows up to 64 literal arguments, each up to 8192 characters and 24,000 characters in total. mode=output wakes on nonempty stdout lines; write an adapter that prints only relevant changes. mode=exit wakes once when the launched job finishes. Returns immediately; continue independent work, then end your turn: events wake you automatically. Requires monitor AND bash permission. Default: one event, ten-minute deadline; max eight monitors, twenty events each, twenty-four hours. list shows active watches; result without id lists retained session logs, result with id reads a bounded log and outcome (also after reload/resume), full=true reads the complete retained capture; do not poll result to wait. Logs span the whole session tree, including sibling conversation branches; branch navigation does not hide captures. They are bounded session artifacts, not complete unlimited transcripts. cancel stops the owned process tree and queued wakes. Keep this Pi session open; watches stop on session shutdown/reload, and a headless `pi -p` run exits after its turn. A wake source, not a wait: for a fixed time use `timer`; sub-agents and Exocom wake you on their own.",
 		parameters: Type.Object({
-			action: Type.Union([Type.Literal("arm"), Type.Literal("list"), Type.Literal("cancel")]),
+			action: Type.Union([Type.Literal("arm"), Type.Literal("list"), Type.Literal("cancel"), Type.Literal("result")]),
 			command: Type.Optional(Type.String({ minLength: 1, maxLength: 4096, description: "arm: executable, e.g. node, python or powershell.exe. Use args for script paths and arguments." })),
 			args: Type.Optional(Type.Array(Type.String({ maxLength: 8192 }), { maxItems: 64, description: "arm: literal argv (up to 64 arguments, each up to 8192 characters; combined argument strings maximum 24000 characters). For shell syntax, explicitly launch the appropriate shell and pass a script file." })),
 			label: Type.Optional(Type.String({ minLength: 1, maxLength: 120, description: "arm: short purpose, e.g. build finished or new application error." })),
 			mode: Type.Optional(Type.Union([Type.Literal("output"), Type.Literal("exit")], { description: "arm: output for event-producing watchers; exit for job completion. Required." })),
 			timeoutSeconds: Type.Optional(Type.Number({ minimum: 1, maximum: 86400, description: "arm: lifetime deadline, default 600 seconds. Expiry stops the process and reports a timeout." })),
 			maxEvents: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "arm/output: stop after this many distinct event lines, default 1." })),
-			id: Type.Optional(Type.String({ minLength: 1, description: "cancel: monitor id returned by arm." })),
+			id: Type.Optional(Type.String({ minLength: 1, description: "cancel/result: monitor id returned by arm; omit for result to list retained logs." })),
+			full: Type.Optional(Type.Boolean({ description: "result: show the complete bounded capture instead of a short tail. Never recovers output already truncated by retention." })),
 		}),
 		async execute(_id, params, signal, _onUpdate, ctx) {
 			d.lastCtx = ctx;
 			const fail = (text: string) => ({ content: [{ type: "text" as const, text }], details: failureDetails({ ok: false }), isError: true });
+			if (params.action === "result") {
+				if (!d.archive) return fail("Monitor logs are unavailable in this session.");
+				if (params.id === undefined) {
+					const records = d.archive.list();
+					return { content: [{ type: "text" as const, text: records.length
+						? records.map((r) => `${compactInlineText(r.entry.id)} (${compactInlineText(r.entry.label)}) — ${r.outcome}${r.storageWarning ? "; storage limited" : ""}`).join("\n")
+						: "No retained monitor logs in this session." }], details: { ok: true, count: records.length } };
+				}
+				const record = d.archive.result(params.id);
+				if (!record) return fail(`Monitor log unavailable for ${compactInlineText(params.id)}; it may predate logging or have exceeded session retention. Use result without id to list available logs.`);
+				return { content: [{ type: "text" as const, text: renderMonitorLog(record, params.full === true) }], details: { ok: true, id: record.entry.id, outcome: record.outcome, truncated: record.truncated } };
+			}
 			if (params.action === "list") {
 				const entries = d.monitors.list();
 				return { content: [{ type: "text" as const, text: entries.length ? entries.map((e) => `${e.id} (${compactInlineText(e.label, { maxChars: 120 })}) — ${e.mode}; deadline ${new Date(e.expiresAtEpochMs).toISOString()}`).join("\n") : "No active monitors." }], details: { ok: true, count: entries.length } };
@@ -40,7 +75,7 @@ export function registerMonitorTool(pi: ExtensionAPI, d: MonitorToolDeps): void
 				const cancelled = d.monitors.cancel(params.id);
 				return { content: [{ type: "text" as const, text: cancelled ? `Cancelled ${params.id}; its queued events were removed.` : `No active monitor or queued event for ${params.id}.` }], details: { ok: true, cancelled } };
 			}
-			if (params.action !== "arm") return fail("monitor action must be arm, list or cancel.");
+			if (params.action !== "arm") return fail("monitor action must be arm, list, result or cancel.");
 			if (!d.canRun()) return fail("monitor arm requires both monitor and bash permission for the active persona.");
 			if (signal?.aborted) return fail("monitor arm cancelled before launch.");
 			if (typeof params.command !== "string" || !params.command.trim() || typeof params.label !== "string" || !params.label.trim()) return fail("monitor arm needs { command, label, mode }.");
@@ -55,12 +90,29 @@ export function registerMonitorTool(pi: ExtensionAPI, d: MonitorToolDeps): void
 				...(params.maxEvents !== undefined ? { maxEvents: params.maxEvents } : {}),
 			});
 			if (!result.ok) return fail(result.error);
-			return { content: [{ type: "text" as const, text: `Armed ${result.entry.id} (${compactInlineText(result.entry.label, { maxChars: 120 })}); ${params.mode === "exit" ? "wakes when this job exits" : "wakes on relevant stdout lines"}. Deadline ${new Date(result.entry.expiresAtEpochMs).toISOString()}. Keep this session open. Continue independent work, or end your turn and wait for the automatic notice.` }], details: { ok: true, id: result.entry.id, expiresAtEpochMs: result.entry.expiresAtEpochMs } };
+			return { content: [{ type: "text" as const, text: `Armed ${result.entry.id} (${compactInlineText(result.entry.label, { maxChars: 120 })}); ${params.mode === "exit" ? "wakes when this job exits" : "wakes on relevant stdout lines"}. Deadline ${new Date(result.entry.expiresAtEpochMs).toISOString()}. ${armWakeAdvice(ctx, "watch", "condition", "Keep this session open. Continue independent work, or end your turn; it wakes you by itself, so never sleep, poll, or arm a `timer` to wait for it.")}` }], details: { ok: true, id: result.entry.id, expiresAtEpochMs: result.entry.expiresAtEpochMs, label: compactInlineText(result.entry.label, { maxChars: 120 }), mode: params.mode } };
 		},
 		renderCall(args, theme) {
 			const action = compactInlineText(args.action ?? "", { maxChars: 12 });
 			const label = compactInlineText(args.label ?? args.id ?? "", { maxChars: 96 });
 			return new Text(`${theme.fg("toolTitle", theme.bold(`monitor ${action}`))}${label ? ` ${theme.fg("dim", label)}` : ""}`, 0, 0);
 		},
+		renderResult(result, { expanded }, theme, context) {
+			const details = (result.details ?? {}) as { ok?: boolean; label?: string; mode?: string; expiresAtEpochMs?: number };
+			const failed = context?.isError ?? result.isError ?? false;
+			const isArm = !failed && typeof details.label === "string" && (details.mode === "output" || details.mode === "exit");
+			if (!isArm) {
+				// Failures and every list/cancel/result receipt share the one literal renderer:
+				// error heading, bounded sanitized preview, expansion hint.
+				return renderLiteralToolResult(result, { expanded }, theme, context);
+			}
+			if (expanded) return renderLiteralToolResult(result, { expanded }, theme, context);
+			const left = typeof details.expiresAtEpochMs === "number" && Number.isFinite(details.expiresAtEpochMs)
+				? details.expiresAtEpochMs - Date.now()
+				: undefined;
+			const deadline = left === undefined ? "" : left > 0 ? ` · deadline in ${formatDuration(left)}` : " · deadline reached";
+			const summary = compactInlineText(`${details.label} · ${details.mode}${deadline}`, { maxChars: 140 });
+			return new Text(`${theme.fg("toolTitle", theme.bold("armed "))}${theme.fg("accent", summary)}`, 0, 0);
+		},
 	});
 }

package/src/tools/read-result.ts

@@ -0,0 +1,52 @@
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { fenceUntrusted } from "../core/fence.ts";
+import { RESULT_READ_DEFAULT, RESULT_READ_MAX } from "../results/types.ts";
+import { isReadRequest, isReadReplyFor, readFailure, type ReadReply, type ScopedReader } from "../bus/result-reader.ts";
+import { compactInlineText } from "../ui/presentation.ts";
+import { renderLiteralToolResult } from "../ui/literal-tool-result.ts";
+
+const Params = Type.Object({
+	ref: Type.String({ minLength: 43, maxLength: 43, description: "Granted opaque result:<UUID> reference, not a file path or run id." }),
+	offset: Type.Optional(Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER, description: "UTF-16 offset; use nextOffset from the previous page." })),
+	limit: Type.Optional(Type.Integer({ minimum: 2, maximum: RESULT_READ_MAX, default: RESULT_READ_DEFAULT, description: "Maximum UTF-16 characters to read." })),
+}, { additionalProperties: false });
+type PageDetails = Omit<Extract<ReadReply, { ok: true }>, "body">;
+
+/** Available only when the parent explicitly grants a scoped reader. No archive browsing,
+ * implicit fallback, polling, messages or model wakes. Fencing happens exactly once here.
+ * Wrapped in `defineTool` so callers that store the definition in a wider-typed variable
+ * (engine registration sites) keep renderer parameter inference. */
+export function makeReadResultTool(reader: Pick<ScopedReader, "read">) {
+	return defineTool<typeof Params, PageDetails>({
+		name: "read_result",
+		label: "Read result",
+		description: "Read one bounded page of a terminal result explicitly granted by your supervisor. Use only a supplied result:<UUID> reference. Follow nextOffset for another page; endOfStoredBody ends the retained report, which may be truncated. No search, paths, live runs or polling.",
+		parameters: Params,
+		async execute(_id, request, signal) {
+			if (signal?.aborted) throw new Error(readFailure("cancelled").message);
+			if (!isReadRequest(request)) throw new Error(readFailure("invalid").message);
+			let result: ReadReply;
+			try { result = await reader.read(request, signal); }
+			catch { throw new Error(readFailure(signal?.aborted ? "cancelled" : "unavailable").message); }
+			if (signal?.aborted) throw new Error(readFailure("cancelled").message);
+			try {
+				if (!isReadReplyFor(result, request)) throw new Error();
+			} catch { throw new Error(readFailure("protocol").message); }
+			if (!result.ok) throw new Error(result.message);
+			const { body, ...details } = result;
+			return { content: [{ type: "text", text: `${JSON.stringify(details)}\n${fenceUntrusted(body)}` }], details };
+		},
+		renderCall(args, theme) {
+			const ref = compactInlineText(args.ref ?? "", { maxChars: 48 });
+			return new Text(`${theme.fg("toolTitle", theme.bold("read_result"))}${ref ? ` ${theme.fg("dim", ref)}` : ""}`, 0, 0);
+		},
+		renderResult(result, { expanded }, theme, context) {
+			// The granted page IS literal content: the shared renderer bounds it collapsed with an
+			// expansion hint and shows the complete sanitized receipt (details line + fenced body)
+			// expanded; native context.isError drives the failure heading.
+			return renderLiteralToolResult(result, { expanded }, theme, context);
+		},
+	});
+}

package/src/tools/timer.ts

@@ -1,9 +1,12 @@
 /** Session timer tool — arm a wall-clock wake. */
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { failureDetails } from "../extension/shared.ts";
+import { armWakeAdvice, failureDetails } from "../extension/shared.ts";
 import { formatRemaining, type TimerScheduler } from "../core/timer.ts";
-import { parseInstant } from "../core/time.ts";
+import { formatDuration, parseInstant } from "../core/time.ts";
+import { compactInlineText } from "../ui/presentation.ts";
+import { renderLiteralToolResult } from "../ui/literal-tool-result.ts";
 import { readClockSnapshot } from "../extension/clock.ts";
 
 export interface TimerToolDeps {
@@ -13,11 +16,8 @@ export interface TimerToolDeps {
 }
 
 export function registerTimerTool(pi: ExtensionAPI, d: TimerToolDeps): void {
-	// ── timer tool (arm a wall-clock alarm that WAKES the session when it fires) ───
-	// Solves the "wait N minutes for a scheduled event or service window" problem WITHOUT a poll loop:
-	// arm an alarm, end your turn, and when it expires the extension injects a follow-up that
-	// resumes you (idle-gated so it starts a fresh turn instead of stranding). Up to 32 alarms may be
-	// armed; cancel/list them. In-memory per session (a reload/new session clears armed alarms).
+	// ── timer tool: a wall-clock alarm that WAKES the idle session when it fires (see core/timer.ts) ───
+	// Up to 32 alarms; in-memory per session (a reload/new session clears them).
 	const TimerToolParams = Type.Object({
 		action: Type.Union([Type.Literal("arm"), Type.Literal("cancel"), Type.Literal("list"), Type.Literal("now")], {
 			description: "arm = schedule a wakeup · cancel = drop one by id · list = show armed alarms · now = read the fresh clock",
@@ -27,18 +27,19 @@ export function registerTimerTool(pi: ExtensionAPI, d: TimerToolDeps): void {
 		),
 		delaySeconds: Type.Optional(Type.Number({ description: "arm: fire this many seconds from now; it is rounded to milliseconds and must produce a delay from 1 second through 86400 seconds. Give this OR atIso, not both." })),
 		atIso: Type.Optional(Type.String({ description: "arm: fire at this absolute ISO-8601 instant (date-time must include Z or a numeric timezone offset, e.g. '2026-07-11T19:00:00Z'). Give this OR delaySeconds, not both." })),
-		label: Type.Optional(Type.String({ description: "arm: a short human label for the alarm (e.g. 'status review')." })),
+		label: Type.Optional(Type.String({ description: "arm: a short human label for the alarm (e.g. 'status review'). Labels longer than 120 characters are clipped." })),
 		id: Type.Optional(Type.String({ description: "cancel: the timer id to cancel (e.g. 'timer-1')." })),
 	});
 	pi.registerTool({
 		name: "timer",
 		label: "Timer",
 		description: [
-			"Arm a wall-clock ALARM that wakes you when it fires — the token-cheap way to wait for a",
-			"fixed moment (a scheduled event, a service window, a scheduled re-check) instead of a",
-			"poll loop. `arm` with { message, delaySeconds } or { message, atIso }; end your turn; when",
-			"it expires a follow-up carrying your message is injected and you resume. `cancel` by id,",
-			"`list` the armed ones. Up to 32 alarms may be armed at once. The session must remain open;",
+			"Wake yourself at a wall-clock moment the world decides (an external deadline, a service window,",
+			"a reminder at a fixed time). `arm` with { message, delaySeconds } or { message, atIso }; continue",
+			"independent work, then end your turn when nothing else remains; when it fires, a follow-up",
+			"carrying your message arrives once you are idle. `cancel` by id, `list` the armed ones.",
+			"Never use it to wait for a sub-agent or monitor (they wake you on their own) or to poll: if something can report the event, use `monitor`.",
+			"Up to 32 alarms may be armed at once. The session must remain open;",
 			"alarms are in-memory and cleared on shutdown or reload. `now` returns a fresh UTC time plus",
 			"the local timezone and numeric offset.",
 		].join(" "),
@@ -98,8 +99,26 @@ export function registerTimerTool(pi: ExtensionAPI, d: TimerToolDeps): void {
 				return { content: [{ type: "text", text: r.error ?? "timer arm failed." }], details: failureDetails({ action: "arm", ok: false }), isError: true };
 			}
 			const e = r.entry;
-			const text = `Armed ${e.id} (${e.label}) — fires in ${formatRemaining(r.remainingMs ?? e.fireAtEpochMs - e.armedAtEpochMs)} [${new Date(e.fireAtEpochMs).toISOString()}]. On fire I'll be woken with: "${e.message}". You can end this turn now; keep the session open for the alarm.`;
-			return { content: [{ type: "text", text }], details: { action: "arm", id: e.id, fireAtEpochMs: e.fireAtEpochMs, ok: true }, isError: false };
+			const text = `Armed ${e.id} (${e.label}) — fires in ${formatRemaining(r.remainingMs ?? e.fireAtEpochMs - e.armedAtEpochMs)} [${new Date(e.fireAtEpochMs).toISOString()}]. ${armWakeAdvice(ctx, "alarm", "time-gated step", "You can end this turn now; keep the session open for the alarm.")}`;
+			return { content: [{ type: "text", text }], details: { action: "arm", id: e.id, fireAtEpochMs: e.fireAtEpochMs, label: compactInlineText(e.label, { maxChars: 120 }), ok: true }, isError: false };
+		},
+		renderCall(args, theme) {
+			const action = compactInlineText(args.action ?? "", { maxChars: 12 });
+			const label = compactInlineText(args.label ?? args.id ?? "", { maxChars: 96 });
+			return new Text(`${theme.fg("toolTitle", theme.bold(`timer ${action}`))}${label ? ` ${theme.fg("dim", label)}` : ""}`, 0, 0);
+		},
+		renderResult(result, { expanded }, theme, context) {
+			const details = (result.details ?? {}) as { action?: string; ok?: boolean; id?: string; label?: string; fireAtEpochMs?: number };
+			const failed = context?.isError ?? result.isError ?? false;
+			const fireAt = typeof details.fireAtEpochMs === "number" ? details.fireAtEpochMs : undefined;
+			const isArm = !failed && details.action === "arm" && details.ok === true && fireAt !== undefined;
+			// Failures and every now/list/cancel receipt share the one literal renderer:
+			// error heading, bounded sanitized preview, expansion hint.
+			if (!isArm || expanded) return renderLiteralToolResult(result, { expanded }, theme, context);
+			const left = fireAt - Date.now();
+			const due = left > 0 ? `fires in ${formatDuration(left)}` : "due now";
+			const summary = compactInlineText(`${details.label ?? details.id ?? "alarm"} · ${due}`, { maxChars: 140 });
+			return new Text(`${theme.fg("toolTitle", theme.bold("armed "))}${theme.fg("accent", summary)}`, 0, 0);
 		},
 	});
 }

package/src/ui/agent-overlay.ts

@@ -2,8 +2,8 @@
  * A focusable overlay over the unified agent tree, opened with ctx.ui.custom
  * (overlay: true). ↑↓ navigate the *agents* (leaf rows; a parent like "delegate"
  * is a non-selectable header), ⏎ drills into one — its live output in an
- * auto-scrolling viewport sized to the terminal — `x` stops it, `s` steers it
- * (from the list too), esc backs out / closes. Subscribes to the tree, so it
+ * auto-scrolling viewport sized to the terminal — `x` stops it, `X` (twice) stops every
+ * running agent, `s` steers it (from the list too), esc backs out / closes. Subscribes to the tree, so it
  * re-renders live as agents stream.
  *
  * The pure parts (flatten/order, glyphs, scroll window) live in agent-tree.ts /
@@ -23,7 +23,7 @@ import {
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 
-import { type AgentNode, type AgentTree, type FlatRow, deriveWaitingNodeIds, flattenTree, GLYPH, runningAnnotation } from "./agent-tree.ts";
+import { type AgentNode, type AgentTree, type FlatRow, deriveWaitingNodeIds, effortTag, flattenTree, isWakeSource, nodeGlyph, runningAnnotation, thinkingDetailLine } from "./agent-tree.ts";
 import { LiveClock } from "./live-clock.ts";
 import { visibleWindow } from "./model-picker.ts";
 import { compactInlineText, OPEN_SEQUENCE_TAIL, sanitizeTerminalText } from "./presentation.ts";
@@ -77,13 +77,17 @@ export function composeAgentRow(input: AgentRowInput): string {
 
 	const prefixCols = 2 + visibleWidth(indent); // "▸ " or "  ", then the indent
 	const avail = Math.max(0, bodyMax - prefixCols - 2); // 2 = glyph + space
-	const labelMax = Math.max(8, Math.floor(avail * 0.62));
-	const label = safeInline(node.label, labelMax) || "agent";
+	// The compact effort sigla rides the label (` · xh` / ` · xh→h`); its width comes out of the
+	// label budget so the appended field never becomes the part a tight row eats first. The final
+	// clamp below still guarantees the row fits either way.
+	const effort = effortTag(node.thinking, node.thinkingEffective);
+	const labelMax = Math.max(8, Math.floor(avail * 0.62) - visibleWidth(effort));
+	const label = (safeInline(node.label, labelMax) || "agent") + effort;
 	const detailMax = node.detail ? Math.max(0, avail - labelMax - 2) : 0;
 	const detail = detailMax > 0 ? safeInline(node.detail ?? "", detailMax) : "";
 	const detailText = detail ? t.fg("dim", `  ${detail}`) : "";
 
-	const labelLine = `${indent}${GLYPH[node.status]} ${label}`;
+	const labelLine = `${indent}${nodeGlyph(node)} ${label}`;
 	const prefixed = selected ? t.fg("accent", `▸ ${labelLine}`) : `  ${labelLine}`;
 	let body = `${prefixed}${detailText}`;
 	if (visibleWidth(body) > bodyMax) body = truncateToWidth(body, bodyMax, "");
@@ -119,6 +123,7 @@ export class AgentOverlay extends Container {
 	private unsubscribe: () => void;
 	private selectedId: string | undefined; // the selected agent's *id*, never its row index
 	private aimLost = false; // the aimed-at agent settled: swallow the next directed keystroke
+	private stopAllArmed: string | undefined; // the stoppable set the "press X again" prompt armed on
 	private listScroll = 0; // list rows scrolled off the top (keeps the selection visible)
 	private detailId: string | undefined;
 	private detailScroll = 0; // output lines scrolled up from the bottom (0 = latest)
@@ -209,9 +214,11 @@ export class AgentOverlay extends Container {
 		return deriveWaitingNodeIds(nodes, (id) => this.actions.isWaitingForSupervisor?.(id) === true);
 	}
 
+	/** The selectable rows: every leaf, plus a container that carries a stop of its own (a council/flow run
+	 *  root), so `x` reaches the whole run instead of one leg. Other containers stay headers. */
 	private leafRows(snap: AgentNode[] = this.tree.snapshot()): FlatRow[] {
 		const parents = new Set(snap.map((n) => n.parentId).filter((p): p is string => p !== undefined));
-		return flattenTree(snap).filter((r) => !parents.has(r.node.id));
+		return flattenTree(snap).filter((r) => !parents.has(r.node.id) || this.actions.canStop?.(r.node.id) === true);
 	}
 
 	/**
@@ -220,11 +227,14 @@ export class AgentOverlay extends Container {
 	 * (stop) and `s` (steer) onto a *different* agent whenever an earlier sibling went
 	 * away. When the aimed-at agent is the one that vanishes, fall back to the head of
 	 * the list, where the ▸ marker visibly shows the user their target changed — and
-	 * record that the aim was lost, for the directed keys (see `aimedLeaf`).
+	 * record that the aim was lost, for the directed keys (see `aimedLeaf`). The (re-)anchor
+	 * prefers an agent row: a monitor or timer that merely happens to be listed first must not
+	 * inherit the marker, or the next `x` could cancel a two-hour watch. A wake row takes it only
+	 * when no agent is left.
 	 */
 	private selectedLeaf(leaves: FlatRow[]): FlatRow | undefined {
 		const anchored = this.selectedId !== undefined ? leaves.find((r) => r.node.id === this.selectedId) : undefined;
-		const leaf = anchored ?? leaves[0];
+		const leaf = anchored ?? leaves.find((r) => !isWakeSource(r.node)) ?? leaves[0];
 		if (this.selectedId !== undefined && anchored === undefined && leaf !== undefined) this.aimLost = true;
 		this.selectedId = leaf?.node.id;
 		return leaf;
@@ -296,7 +306,7 @@ export class AgentOverlay extends Container {
 		this.addChild(new Spacer(1));
 		const stoppable = selected !== undefined && this.canStopNode(selected);
 		const steerable = selected !== undefined && selected.status === "running" && (this.actions.canSteer?.(selected.id) ?? false);
-		this.addChild(new Text(t.fg("dim", `↑↓ navigate   ⏎ open${this.hintLine("list", stoppable, steerable)}   esc close`), 1, 0));
+		this.addChild(new Text(t.fg("dim", `↑↓ navigate   ⏎ open${this.hintLine("list", stoppable, steerable, this.stoppableIds(nodes).length)}   esc close`), 1, 0));
 		this.renderNotice();
 	}
 
@@ -370,10 +380,17 @@ export class AgentOverlay extends Container {
 			return;
 		}
 		const live = node.status === "running";
+		// A wake source is armed, not a live agent: it has no steer handle, so the agent-only "● live"
+		// badge and the steer-unavailable hint below would both be wrong for it.
+		const wake = isWakeSource(node);
 		this.addChild(
-			new Text(`${GLYPH[node.status]} ${t.fg("accent", t.bold(safeInline(node.label) || "agent"))}${live ? t.fg("success", "  ● live") : ""}`, 1, 0),
+			new Text(`${nodeGlyph(node)} ${t.fg("accent", t.bold(safeInline(node.label) || "agent"))}${live ? t.fg("success", wake ? "  ● armed" : "  ● live") : ""}`, 1, 0),
 		);
 		if (node.detail) this.addChild(new Text(t.fg("dim", safeInline(node.detail)), 1, 0));
+		// The drill-in has room for FULL effort names (the rows stay compact): an observed level
+		// appears only once a terminal result actually reported one.
+		const effortLine = thinkingDetailLine(node.thinking, node.thinkingEffective);
+		if (effortLine) this.addChild(new Text(t.fg("dim", effortLine), 1, 0));
 		this.addChild(new Spacer(1));
 
 		const raw = node.output?.trim()
@@ -404,7 +421,7 @@ export class AgentOverlay extends Container {
 		} else {
 			this.addChild(new Text(t.fg("dim", `esc back   ·   ↑↓ scroll${this.hintLine("detail", stoppable, steerable)}`), 1, 0));
 			this.renderNotice();
-			if (live && !steerable) {
+			if (live && !steerable && !wake) {
 				this.addChild(new Text(t.fg("dim", "(steer unavailable: no live handle yet, or this engine/broker does not expose one)"), 1, 0));
 			}
 		}
@@ -413,6 +430,8 @@ export class AgentOverlay extends Container {
 	handleInput(keyData: string): void {
 		const hadNotice = this.notice !== undefined;
 		this.notice = undefined; // any key clears a previous refusal notice
+		const armed = this.stopAllArmed;
+		this.stopAllArmed = undefined; // only an immediately repeated X confirms
 		const kb = getKeybindings();
 		if (this.detailId) {
 			// Steer mode: type a message into the running agent. Capture all printable keys
@@ -483,6 +502,8 @@ export class AgentOverlay extends Container {
 		} else if (keyData === "x") {
 			const leaf = this.aimedLeaf(leaves);
 			if (leaf) this.tryStop(leaf.node.id);
+		} else if (keyData === "X") {
+			this.stopAll(armed);
 		} else if (kb.matches(keyData, "tui.select.cancel")) {
 			this.close();
 		} else if (hadNotice) this.refresh(); // unhandled key: still repaint so a cleared notice disappears
@@ -495,11 +516,20 @@ export class AgentOverlay extends Container {
 		return node.status === "running" && (this.actions.canStop?.(node.id) ?? true);
 	}
 
-	/** The trailing "x stop"/"s steer" hint fragment for an action line — the list's three-space
-	 *  style or the detail view's " · " style, the two views' only difference here. */
-	private hintLine(kind: "list" | "detail", stoppable: boolean, steerable: boolean): string {
+	/** The agents `X` would stop: every leaf that `x` could stop, wake sources excluded. `X` means
+	 *  "stop every agent"; a monitor's job (it may be a two-hour batch) or a timer's alarm is cancelled
+	 *  only by an explicit `x` on its own row. One list feeds the hint count, the confirmation prompt
+	 *  and the bulk stop, so the three always agree. */
+	private stoppableIds(snap: AgentNode[] = this.tree.snapshot()): string[] {
+		return this.leafRows(snap).filter((r) => !isWakeSource(r.node) && this.canStopNode(r.node)).map((r) => r.node.id);
+	}
+
+	/** The trailing "x stop"/"X stop all"/"s steer" hint fragment for an action line — the list's
+	 *  three-space style or the detail view's " · " style, the two views' only difference here.
+	 *  `stopAll` (list only) is the stoppable count; one agent is what plain `x` is for. */
+	private hintLine(kind: "list" | "detail", stoppable: boolean, steerable: boolean, stopAll = 0): string {
 		const sep = kind === "list" ? "   " : "   ·   ";
-		return `${stoppable ? `${sep}x stop` : ""}${steerable ? `${sep}s steer` : ""}`;
+		return `${stoppable ? `${sep}x stop` : ""}${stopAll >= 2 ? `${sep}X stop all (${stopAll})` : ""}${steerable ? `${sep}s steer` : ""}`;
 	}
 
 	/** The one-line refusal notice, shown identically under the list and the detail view. */
@@ -518,6 +548,25 @@ export class AgentOverlay extends Container {
 		this.refresh();
 	}
 
+	/** `X`: stop every stoppable agent after one confirming press. The prompt states how many agents
+	 *  it covers and arms on the exact set it saw, so a set that changed since (or any key in
+	 *  between) asks again — a bulk, irreversible stop is never fired on a stale confirmation. */
+	private stopAll(armed: string | undefined): void {
+		const ids = this.stoppableIds();
+		const key = ids.join("|");
+		if (ids.length >= 2) {
+			if (armed === key) {
+				let stopped = 0;
+				for (const id of ids) if (this.actions.onStop?.(id)) stopped++;
+				this.notice = `stop requested for ${stopped} agent${stopped === 1 ? "" : "s"}; queued or later stages may still start`;
+			} else {
+				this.stopAllArmed = key;
+				this.notice = `press X again to stop ${ids.length} running agents`;
+			}
+		}
+		this.refresh();
+	}
+
 	private close(): void {
 		this.dispose();
 		this.done();