@aeondave/pi-persona 1.17.0 → 1.17.3

package/src/tools/models.ts

@@ -7,7 +7,7 @@ import { compactInlineText } from "../ui/presentation.ts";
 export interface ModelsToolDeps {
 	get lastCtx(): ExtensionContext | undefined;
 	set lastCtx(value: ExtensionContext | undefined);
-	searchModels(ctx: ExtensionContext, query?: string): { lines: string[]; total: number; capped: boolean };
+	searchModels(ctx: ExtensionContext, query?: string): { lines: string[]; total: number; capped: boolean; shortlist: boolean };
 }
 
 export function registerModelsTool(pi: ExtensionAPI, d: ModelsToolDeps): void {
@@ -16,23 +16,33 @@ export function registerModelsTool(pi: ExtensionAPI, d: ModelsToolDeps): void {
 		name: "models",
 		label: "Models",
 		description: [
-			"List or search the available model ids (provider/id). The same name exists under several",
-			"providers — use an EXACT id from here as a delegate task's `model`. ★ marks your session",
-			"provider; prefer it (it's the authenticated one).",
+			"Discover model candidates (provider/id). With no query: the current model first, then a compact",
+			"shortlist of nearby family/version candidates from the same provider, ordered cost:low → medium → high → unknown.",
+			"Family and version names are proximity hints, not verified release dates or account support. A query searches",
+			"the full eligible catalog, including older models and snapshots. Use exact refs; ★ marks your",
+			"session provider, not account support. Authentication does not guarantee access to every listed model.",
+			"cost:low/medium/high ranks advertised API prices relative to recent candidates of the same provider;",
+			"cost:unknown means insufficient price data. These are cost bands, not quality, speed or reasoning-effort ratings; choose task fit yourself.",
+			"Context, reasoning support and API prices are host catalog metadata; API prices do not describe subscription billing.",
+			"Prefer these nearby candidates before older or unrelated models merely because they are cheap. Omitting `model` preserves",
+			"saved per-persona role/agent assignments, then the agent frontmatter model and engine defaults; it does not necessarily select the supervisor model.",
+			"To intentionally choose the supervisor's current model over a configured choice, pass its exact provider/id as `model` only when explicitly authorized.",
+			"Never silently switch providers or billing routes.",
 		].join(" "),
 		parameters: Type.Object({
-			query: Type.Optional(Type.String({ description: "Filter by substring (provider or id), e.g. 'sonnet'" })),
+			query: Type.Optional(Type.String({ description: "Search the full catalog by substring (provider or id), e.g. 'sonnet'; omit for the current-first shortlist" })),
 		}),
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			d.lastCtx = ctx;
-			const { lines, total, capped } = d.searchModels(ctx, params.query);
+			const { lines, total, capped, shortlist } = d.searchModels(ctx, params.query);
+			const showing = shortlist || capped ? ` (showing ${lines.length} ${shortlist ? "nearby family/version candidates" : "matches"})` : "";
 			const text = lines.length
-				? `${total} model(s)${capped ? " (showing 40 — refine with a query)" : ""}; ★ = session provider:\n${lines.join("\n")}`
+				? `${total} catalog model(s)${showing}; ★ = session provider, (you) = current model. Account support may vary.${shortlist || capped ? " Query searches the full catalog." : ""}\n${lines.join("\n")}`
 				: `no models match "${params.query ?? ""}"`;
-			return { content: [{ type: "text", text }], details: { total }, isError: false };
+			return { content: [{ type: "text", text }], details: { total, shown: lines.length, shortlist }, isError: false };
 		},
 		renderCall(args, theme) {
-			const query = compactInlineText(args.query ?? "(all)", { maxChars: 96 }) || "(all)";
+			const query = compactInlineText(args.query ?? "(shortlist)", { maxChars: 96 }) || "(shortlist)";
 			return new Text(`${theme.fg("toolTitle", theme.bold("models "))}${theme.fg("dim", query)}`, 0, 0);
 		},
 	});

package/src/tools/monitor.ts

@@ -3,34 +3,67 @@ 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 { armWakeAdvice, failureDetails } from "../extension/shared.ts";
 import { compactInlineText } from "../ui/presentation.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 +73,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,7 +88,7 @@ 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 } };
 		},
 		renderCall(args, theme) {
 			const action = compactInlineText(args.action ?? "", { maxChars: 12 });

package/src/tools/timer.ts

@@ -1,7 +1,7 @@
 /** Session timer tool — arm a wall-clock wake. */
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 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 { readClockSnapshot } from "../extension/clock.ts";
@@ -13,11 +13,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 +24,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,7 +96,7 @@ 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.`;
+			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, ok: true }, isError: false };
 		},
 	});

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, flattenTree, isWakeSource, nodeGlyph, runningAnnotation } 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";
@@ -83,7 +83,7 @@ export function composeAgentRow(input: AgentRowInput): string {
 	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 +119,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 +210,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 +223,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 +302,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,8 +376,11 @@ 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));
 		this.addChild(new Spacer(1));
@@ -404,7 +413,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 +422,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 +494,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 +508,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 +540,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();

package/src/ui/agent-tree.ts

@@ -1,6 +1,8 @@
 import { compactTokens } from "../core/format.ts";
 import { formatDuration } from "../core/time.ts";
+import type { ChildUsage } from "../engine/stream.ts";
 import { compactInlineText } from "./presentation.ts";
+import { formatUsage } from "./usage.ts";
 
 /**
  * The unified agent tree — a single live model of *every* agent in flight,
@@ -11,7 +13,7 @@ import { compactInlineText } from "./presentation.ts";
  */
 
 export type AgentNodeStatus = "running" | "done" | "failed" | "stopped";
-export type AgentNodeKind = "subagent" | "delegate" | "council" | "flow" | "phase";
+export type AgentNodeKind = "subagent" | "delegate" | "council" | "flow" | "phase" | "monitor" | "timer";
 
 export interface AgentNode {
 	id: string;
@@ -31,6 +33,8 @@ export interface AgentNode {
 	 *  Excluded from change notifications — the live clock paints them. */
 	startedAt?: number;
 	lastAdvanceAt?: number;
+	/** Epoch ms when a wake source is due: a monitor's deadline or a timer's fire time. Its countdown replaces the elapsed/stall clock. Set once by the source; a change notifies (it is not a clock key). */
+	dueAt?: number;
 }
 
 export type AgentTreeChange =
@@ -60,6 +64,21 @@ export function flattenTree(nodes: AgentNode[]): FlatRow[] {
 /** Status → glyph, shared by every agent surface (tree, overlay). */
 export const GLYPH: Record<AgentNodeStatus, string> = { running: "⏳", done: "✓", failed: "✗", stopped: "■" };
 
+/** A wake source is a row that is not an agent (never counted, steered, or stopped in bulk). */
+export function isWakeSource(node: Pick<AgentNode, "kind">): boolean {
+	return node.kind === "monitor" || node.kind === "timer";
+}
+
+/** The kind-aware glyph shared by every surface (tree, overlay): a running timer is ⏰, a running
+ *  monitor ◉; everything else, settled wake rows included, uses the ordinary status glyph. */
+export function nodeGlyph(node: Pick<AgentNode, "status" | "kind">): string {
+	if (node.status === "running") {
+		if (node.kind === "timer") return "⏰";
+		if (node.kind === "monitor") return "◉";
+	}
+	return GLYPH[node.status];
+}
+
 export interface RenderOptions {
 	/** Current time; omitted ⇒ no elapsed/stall annotation (pure renders stay byte-identical). */
 	now?: number;
@@ -79,11 +98,20 @@ export function isQueuedMarker(detail: string | undefined): boolean {
 /** "1m 15s" while a running node keeps advancing; "⚠ stalled 1m 30s" once it has been quiet
  *  for `stallMs`. Undefined for settled nodes, nodes without clock data, or a node still carrying
  *  the "queued" marker — it was seeded ahead of the concurrency gate and has not started running
- *  yet, so its clock (stamped at seed time) has nothing true to report. Pure. */
-export function runningAnnotation(node: Pick<AgentNode, "status" | "startedAt" | "lastAdvanceAt" | "detail">, now: number, stallMs: number, waitingForSupervisor = false): string | undefined {
+ *  yet, so its clock (stamped at seed time) has nothing true to report. A wake-source row (one with
+ *  a `dueAt`) counts down instead — "fires in 49m 12s" for a timer, "12m 3s · deadline in 1h 47m"
+ *  for a monitor — and NEVER shows the stall badge: a quiet monitor is waiting for its event,
+ *  not stalled. Pure. */
+export function runningAnnotation(node: Pick<AgentNode, "status" | "startedAt" | "lastAdvanceAt" | "detail" | "kind" | "dueAt">, now: number, stallMs: number, waitingForSupervisor = false): string | undefined {
 	if (node.status !== "running" || node.startedAt === undefined) return undefined;
 	if (isQueuedMarker(node.detail)) return undefined;
 	if (waitingForSupervisor) return "waiting for supervisor";
+	if (node.dueAt !== undefined) {
+		const left = node.dueAt - now;
+		if (node.kind === "timer") return left > 0 ? `fires in ${formatDuration(left)}` : "firing…";
+		const elapsed = formatDuration(now - node.startedAt);
+		return left > 0 ? `${elapsed} · deadline in ${formatDuration(left)}` : `${elapsed} · deadline reached`;
+	}
 	const quietSince = node.lastAdvanceAt ?? node.startedAt;
 	if (stallMs > 0 && now - quietSince >= stallMs) return `⚠ stalled ${formatDuration(now - quietSince)}`;
 	return formatDuration(now - node.startedAt);
@@ -118,12 +146,13 @@ export function deriveWaitingNodeIds(nodes: readonly AgentNode[], isWaiting: (id
 }
 
 /** The tree patch for one progress snapshot: every snapshot is an advance; activity wins over
- *  a bare token count as the visible detail. One helper for every progress site. */
-export function progressPatch(snap: { output?: string; activity?: string; tokens?: number }, now: number): AgentNodePatch {
+ *  usage, formatted like a completed row. Legacy aggregate-only progress stays a neutral count. */
+export function progressPatch(snap: { output?: string; activity?: string; tokens?: number; usage?: ChildUsage }, now: number): AgentNodePatch {
 	const patch: AgentNodePatch = { lastAdvanceAt: now };
 	if (snap.output) patch.output = snap.output;
 	if (snap.activity) patch.detail = snap.activity;
-	else if (snap.tokens) patch.detail = `${compactTokens(snap.tokens)} tok`;
+	else if (snap.usage) patch.detail = formatUsage(snap.usage);
+	else if (snap.tokens) patch.detail = compactTokens(snap.tokens);
 	return patch;
 }
 
@@ -155,7 +184,7 @@ export function renderAgentTree(nodes: AgentNode[], opts: RenderOptions = {}): s
 			const clock = opts.now !== undefined ? runningAnnotation(node, opts.now, opts.stallMs ?? 0, opts.waitingForSupervisor?.has(node.id) ?? false) : undefined;
 			const tail = [detailText, clock].filter((s): s is string => Boolean(s)).join(" · ");
 			const detail = tail ? `  ${tail}` : "";
-			lines.push(`${prefix}${branch}${GLYPH[node.status]} ${label}${detail}`);
+			lines.push(`${prefix}${branch}${nodeGlyph(node)} ${label}${detail}`);
 			const childPrefix = isRoot ? "" : `${prefix}${isLast ? "   " : "│  "}`;
 			walk(node.id, childPrefix);
 		});
@@ -165,14 +194,41 @@ export function renderAgentTree(nodes: AgentNode[], opts: RenderOptions = {}): s
 	return lines;
 }
 
+/** One digest line for the running wake sources (monitors, timers) that fell below the summary
+ *  fold: counts by kind ("◉ 1 monitor · ⏰ 2 timers"), plus the countdown to the soonest finite
+ *  `dueAt` when a clock is given. A monitor armed after a fan-out would otherwise hide behind the
+ *  "… +N more" line — exactly the "armed but nothing visible" case wake rows exist to fix. Pure. */
+function wakeDigestLine(hidden: readonly AgentNode[], now: number | undefined): string {
+	const monitors = hidden.filter((node) => node.kind === "monitor").length;
+	const timers = hidden.filter((node) => node.kind === "timer").length;
+	const parts: string[] = [];
+	if (monitors > 0) parts.push(`${nodeGlyph({ status: "running", kind: "monitor" })} ${monitors} monitor${monitors === 1 ? "" : "s"}`);
+	if (timers > 0) parts.push(`${nodeGlyph({ status: "running", kind: "timer" })} ${timers} timer${timers === 1 ? "" : "s"}`);
+	if (now !== undefined) {
+		const due = hidden.map((node) => node.dueAt).filter((at): at is number => at !== undefined && Number.isFinite(at));
+		if (due.length > 0) {
+			const left = Math.min(...due) - now;
+			parts.push(left > 0 ? `next due in ${formatDuration(left)}` : "next due now");
+		}
+	}
+	return parts.join(" · ");
+}
+
 /**
  * Bounded above-editor digest. Large fan-outs belong in the scrollable F9
  * overlay; they must not push the editor and conversation off the screen.
+ *
+ * Below the fold, two kinds of row stay visible as one line each, because an operator must not
+ * have to open F9 to learn them: failures (`✗ N failed: …`) and RUNNING wake sources (`◉ 1 monitor
+ * · ⏰ 2 timers · next due in 4m 12s`). The layout when overflowing is
+ * `[...rows, failureLine?, wakeDigest?, overflowLine]`, every line inside `maxRows`; when the budget
+ * cannot hold them all the lowest-priority line goes first (failure > wake digest > overflow).
  */
 export function renderAgentTreeSummary(nodes: AgentNode[], maxRows = 8, opts: RenderOptions = {}): string[] {
 	const rows = renderAgentTree(nodes, opts);
 	const limit = Math.max(1, Math.floor(maxRows));
 	if (rows.length <= limit) return rows;
+	let failureLine: string | undefined;
 	const failed = nodes.filter((node) => node.status === "failed");
 	if (failed.length > 0) {
 		const names = failed.slice(0, 2).map((node) => {
@@ -181,20 +237,26 @@ export function renderAgentTreeSummary(nodes: AgentNode[], maxRows = 8, opts: Re
 			return detail ? `${label} (${detail})` : label;
 		});
 		const extra = failed.length - names.length;
-		const failureLine = `✗ ${failed.length} failed: ${names.join(", ")}${extra > 0 ? `, +${extra} more` : ""}`;
-		if (limit === 1) return [failureLine];
-		const visibleCount = Math.max(0, limit - 2);
-		return [
-			...rows.slice(0, visibleCount),
-			failureLine,
-			`… +${rows.length - visibleCount} more · F9 or /agents for the full live tree`,
-		];
+		failureLine = `✗ ${failed.length} failed: ${names.join(", ")}${extra > 0 ? `, +${extra} more` : ""}`;
+	}
+	// `flattenTree(nodes)[i]` is the node behind `rows[i]`: `renderAgentTree` and `flattenTree` walk the
+	// same parent→children order, so a row's flat index doubles as its position in the rendered list.
+	const flat = flattenTree(nodes);
+	const hiddenWake = (from: number): AgentNode[] =>
+		flat.slice(from).map((row) => row.node).filter((node) => isWakeSource(node) && node.status === "running");
+	let visibleCount = Math.max(0, limit - (failureLine !== undefined ? 2 : 1));
+	let hidden = hiddenWake(visibleCount);
+	if (hidden.length > 0) {
+		// The digest takes a slot of its own; one fewer visible row can only hide more wake rows.
+		visibleCount = Math.max(0, visibleCount - 1);
+		hidden = hiddenWake(visibleCount);
 	}
-	const visibleCount = Math.max(0, limit - 1);
-	return [
-		...rows.slice(0, visibleCount),
+	const tail = [
+		...(failureLine !== undefined ? [failureLine] : []),
+		...(hidden.length > 0 ? [wakeDigestLine(hidden, opts.now)] : []),
 		`… +${rows.length - visibleCount} more · F9 or /agents for the full live tree`,
 	];
+	return [...rows.slice(0, visibleCount), ...tail.slice(0, Math.max(0, limit - visibleCount))];
 }
 
 export interface AddNodeInput {
@@ -209,6 +271,7 @@ export interface AddNodeInput {
 	output?: string;
 	startedAt?: number;
 	lastAdvanceAt?: number;
+	dueAt?: number;
 }
 
 export interface AgentNodePatch {
@@ -220,6 +283,7 @@ export interface AgentNodePatch {
 	output?: string;
 	startedAt?: number;
 	lastAdvanceAt?: number;
+	dueAt?: number;
 }
 
 /** Apply the fields `add`'s upsert branch and `update` both accept, in place — the one place
@@ -233,6 +297,7 @@ function applyPatch(node: AgentNode, patch: AgentNodePatch): void {
 	if (patch.output !== undefined) node.output = patch.output;
 	if (patch.startedAt !== undefined) node.startedAt = patch.startedAt;
 	if (patch.lastAdvanceAt !== undefined) node.lastAdvanceAt = patch.lastAdvanceAt;
+	if (patch.dueAt !== undefined) node.dueAt = patch.dueAt;
 }
 
 /** A small mutable registry with change notification. The extension owns one. */
@@ -269,6 +334,7 @@ export class AgentTree {
 			...(input.agent !== undefined ? { agent: input.agent } : {}),
 			...(input.model !== undefined ? { model: input.model } : {}),
 			...(input.output !== undefined ? { output: input.output } : {}),
+			...(input.dueAt !== undefined ? { dueAt: input.dueAt } : {}),
 		};
 		this.nodes.push(node);
 		this.emit({ type: "added", node: { ...node } });

package/src/ui/compact-widget.ts

@@ -0,0 +1,25 @@
+import { type Component, sliceByColumn, visibleWidth } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "./presentation.ts";
+
+/**
+ * Public setWidget factory for already-budgeted, raw-text rows. Unlike the host's
+ * string[]/Text path this never wraps: one source row occupies at most one terminal
+ * row. Right-edge clipping preserves tree indentation and leading semantic markers;
+ * F9/exocom_list remain the full-detail surfaces.
+ *
+ * Snapshot and sanitize once per publication, without trimming/collapsing indentation.
+ * No theme colors are captured; each render uses its supplied width (including resize).
+ */
+export function compactWidget(rows: readonly string[]): () => Component {
+	const lines = rows.map((row) => sanitizeTerminalText(row.replace(/\t/g, " ")).replace(/[\n\u2028\u2029]/g, " "));
+	return () => ({
+		render(width: number): string[] {
+			const columns = Math.max(0, Math.floor(width));
+			if (columns === 0) return [];
+			return lines.map((line) => visibleWidth(line) <= columns
+				? line
+				: `${sliceByColumn(line, 0, columns - 1, true)}…`);
+		},
+		invalidate(): void { /* No width/theme-dependent cache. */ },
+	});
+}