@ferris1225/pi-subagents 0.2.0 → 0.4.0

package/README-zh.md

@@ -117,6 +117,19 @@ agentModels[name]  →  当前 session 模型  →  agent frontmatter 里的默
 { "tasks": [ { "agent": "explore", "task": "..." }, { "agent": "explore", "task": "..." } ] }
 ```
 
+## 实时状态与通知
+
+子代理运行期间，编辑器上方的挂件为每个运行显示一行状态（图标、agent、模型、
+token 用量、耗时），其下缩进一行显示它正在做什么：`thinking`、`writing`、
+`read src/index.ts`、`bash npm test`……（不会是一坨 JSON 参数）。
+
+运行结束（成功**或**失败）时，该行立即从挂件消失，主窗口收到一条通知，
+给出最终摘要（`✓ worker · openai/gpt-5 · ↑12.4k ↓3.1k · 47s`）。工具结果
+本身仍是对话里的持久记录。
+
+子代理一律请求**最强思考强度**（`--thinking max`）；pi 会按目标模型实际支持
+的级别自适应降级（`max → xhigh → high → … → off`），弱模型也能平稳运行。
+
 ## 开发
 
 ```bash

package/README.md

@@ -125,6 +125,22 @@ Tool shape:
 { "tasks": [ { "agent": "explore", "task": "..." }, { "agent": "explore", "task": "..." } ] }
 ```
 
+## Live status & notifications
+
+While sub-agents run, a widget above the editor shows one line per run — status
+icon, agent, model, token usage, elapsed time — plus a second, indented line
+with what the agent is doing right now: `thinking`, `writing`,
+`read src/index.ts`, `bash npm test`, … (never a raw JSON args blob).
+
+When a run finishes (done **or** failed), its row disappears from the widget and
+the main window gets a notification with the final summary
+(`✓ worker · openai/gpt-5 · ↑12.4k ↓3.1k · 47s`). The tool result itself
+remains the durable record in the conversation.
+
+Sub-agents always request the **strongest thinking level** (`--thinking max`);
+pi clamps it adaptively to what the resolved model supports
+(`max → xhigh → high → … → off`), so weaker models degrade gracefully.
+
 ## Development
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Focused sub-agent delegation for pi: explore / plan / worker / reviewer agents in isolated context, with proactive dispatch injection and per-agent model selection.",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -38,7 +38,7 @@ import {
 	type SubagentLiveEvent,
 	type UsageStats,
 } from "./spawn.ts";
-import { monitor, openSubagentOverlay, statusIcon } from "./monitor.ts";
+import { formatToolActivity, monitor, statusColor, statusIcon, statusLabel } from "./monitor.ts";
 
 const TaskItem = Type.Object({
 	agent: Type.String({ description: "Name of the agent to invoke" }),
@@ -124,6 +124,42 @@ export default function (pi: ExtensionAPI): void {
 		async execute(_toolCallId, params, signal, onUpdate, ctx) {
 			monitor.beginTurn();
 			const config = await loadConfig(configPath);
+
+			// Finished runs leave the widget immediately; the main window gets a
+			// notification instead (the tool result remains the durable record).
+			const finishRun = (runId: number, status: "done" | "failed"): void => {
+				monitor.setStatus(runId, status); // stamps endedAt for the elapsed time
+				const run = monitor.removeRun(runId);
+				if (!run) return; // already finished — stay idempotent
+				const icon = status === "done" ? "✓" : "✗";
+				ctx.ui.notify(`${icon} ${monitor.summarize(run)}`, status === "done" ? "info" : "error");
+			};
+
+			// Live sub-agent activity → concise one-line status ("thinking",
+			// "read src/index.ts", ...), never a raw args blob.
+			const makeLiveHandler = (runId: number) => (e: SubagentLiveEvent): void => {
+				switch (e.kind) {
+					case "status":
+						if (e.status === "done" || e.status === "failed") finishRun(runId, e.status);
+						else monitor.setStatus(runId, e.status);
+						break;
+					case "usage":
+						monitor.setUsage(runId, e.usage, e.model);
+						break;
+					case "tool_start":
+						monitor.setActivity(runId, formatToolActivity(e.toolName, e.args));
+						break;
+					case "tool_end":
+						if (e.isError) monitor.setActivity(runId, `✗ ${e.toolName} failed`);
+						break;
+					case "thinking":
+						monitor.setActivity(runId, "thinking");
+						break;
+					case "text":
+						monitor.setActivity(runId, "writing");
+						break;
+				}
+			};
 			const discovery = discoverAgents(ctx.cwd, {
 				scope: config.agentScope,
 				enabledNames: config.enabledAgents,
@@ -190,25 +226,7 @@ export default function (pi: ExtensionAPI): void {
 				const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
 					const resolvedModel = agents.find((a) => a.name === t.agent)?.model;
 					const runId = monitor.addRun(t.agent, resolvedModel);
-					const onLive = (e: SubagentLiveEvent): void => {
-						switch (e.kind) {
-							case "status":
-								monitor.setStatus(runId, e.status);
-								break;
-							case "usage":
-								monitor.setUsage(runId, e.usage, e.model);
-								break;
-							case "tool_start":
-								monitor.appendTranscript(runId, { kind: "tool", text: `▸ ${e.toolName}(${typeof e.args === "object" ? JSON.stringify(e.args).slice(0, 120) : String(e.args).slice(0, 120)})` });
-								break;
-							case "tool_end":
-								monitor.appendTranscript(runId, { kind: e.isError ? "error" : "status", text: `${e.isError ? "✗" : "✓"} ${e.toolName}` });
-								break;
-							case "text_delta":
-								monitor.appendTextDelta(runId, e.delta);
-								break;
-						}
-					};
+					const onLive = makeLiveHandler(runId);
 					const perTaskUpdate: OnUpdateCallback | undefined = onUpdate
 						? (partial) => {
 								const current = partial.details?.results[0];
@@ -218,17 +236,23 @@ export default function (pi: ExtensionAPI): void {
 								}
 							}
 						: undefined;
-					const result = await runSingleAgent({
-						defaultCwd: ctx.cwd,
-						agent: agents.find((a) => a.name === t.agent),
-						agentName: t.agent,
-						task: t.task,
-						cwd: t.cwd,
-						signal,
-						onUpdate: perTaskUpdate,
-						onLive,
-						makeDetails: makeDetails("parallel"),
-					});
+					let result: SingleResult;
+					try {
+						result = await runSingleAgent({
+							defaultCwd: ctx.cwd,
+							agent: agents.find((a) => a.name === t.agent),
+							agentName: t.agent,
+							task: t.task,
+							cwd: t.cwd,
+							signal,
+							onUpdate: perTaskUpdate,
+							onLive,
+							makeDetails: makeDetails("parallel"),
+						});
+					} catch (err) {
+						finishRun(runId, "failed");
+						throw err;
+					}
 					allResults[index] = result;
 					emitParallelUpdate();
 					return result;
@@ -255,36 +279,24 @@ export default function (pi: ExtensionAPI): void {
 			// ---- Single mode ----
 			const resolvedModel = agents.find((a) => a.name === params.agent)?.model;
 			const runId = monitor.addRun(params.agent as string, resolvedModel);
-			const onLive = (e: SubagentLiveEvent): void => {
-				switch (e.kind) {
-					case "status":
-						monitor.setStatus(runId, e.status);
-						break;
-					case "usage":
-						monitor.setUsage(runId, e.usage, e.model);
-						break;
-					case "tool_start":
-						monitor.appendTranscript(runId, { kind: "tool", text: `▸ ${e.toolName}(${typeof e.args === "object" ? JSON.stringify(e.args).slice(0, 120) : String(e.args).slice(0, 120)})` });
-						break;
-					case "tool_end":
-						monitor.appendTranscript(runId, { kind: e.isError ? "error" : "status", text: `${e.isError ? "✗" : "✓"} ${e.toolName}` });
-						break;
-					case "text_delta":
-						monitor.appendTextDelta(runId, e.delta);
-						break;
-				}
-			};
-			const result = await runSingleAgent({
-				defaultCwd: ctx.cwd,
-				agent: agents.find((a) => a.name === params.agent),
-				agentName: params.agent as string,
-				task: params.task as string,
-				cwd: params.cwd,
-				signal,
-				onUpdate,
-				onLive,
-				makeDetails: makeDetails("single"),
-			});
+			const onLive = makeLiveHandler(runId);
+			let result: SingleResult;
+			try {
+				result = await runSingleAgent({
+					defaultCwd: ctx.cwd,
+					agent: agents.find((a) => a.name === params.agent),
+					agentName: params.agent as string,
+					task: params.task as string,
+					cwd: params.cwd,
+					signal,
+					onUpdate,
+					onLive,
+					makeDetails: makeDetails("single"),
+				});
+			} catch (err) {
+				finishRun(runId, "failed");
+				throw err;
+			}
 
 			if (isFailedResult(result)) {
 				return {
@@ -359,20 +371,30 @@ export default function (pi: ExtensionAPI): void {
 			"pi-subagents",
 			(tui, theme) => {
 				const unsub = monitor.subscribe(() => tui.requestRender());
+				// Tick once a second so elapsed time stays live while runs are active.
+				const timer = setInterval(() => {
+					if (monitor.getRuns().some((r) => r.status === "queued" || r.status === "running")) {
+						tui.requestRender();
+					}
+				}, 1000);
 				return {
 					render(width: number): string[] {
 						const runs = monitor.getRuns();
 						if (runs.length === 0) return [];
-						const lines = runs.map((r) => {
+						const lines: string[] = [];
+						for (const r of runs) {
 							const icon = statusIcon(r.status, theme);
-							return truncateToWidth(` ${icon} ${monitor.summarize(r)}`, width, "");
-						});
-						lines.push(truncateToWidth(theme.fg("dim", " ctrl+shift+a / /subagents to inspect"), width, ""));
+							const label = theme.fg(statusColor(r.status), statusLabel(r.status));
+							lines.push(truncateToWidth(` ${icon} ${monitor.summarize(r)} · ${label}`, width, ""));
+							// Activity sits one indent level below the agent name.
+							if (r.activity) lines.push(truncateToWidth(theme.fg("dim", `     ${r.activity}`), width, ""));
+						}
 						return lines;
 					},
 					invalidate() {},
 					dispose() {
 						unsub();
+						clearInterval(timer);
 					},
 				};
 			},
@@ -380,27 +402,6 @@ export default function (pi: ExtensionAPI): void {
 		);
 	});
 
-	// Drill-down overlay command.
-	pi.registerCommand("subagents", {
-		description: "Inspect running/recent sub-agents (model, tokens, live transcript)",
-		handler: async (_args, ctx) => {
-			if (ctx.mode !== "tui") {
-				ctx.ui.notify("The sub-agent monitor requires Pi's interactive TUI.", "warning");
-				return;
-			}
-			await openSubagentOverlay(ctx);
-		},
-	});
-
-	// Keyboard shortcut for the overlay.
-	pi.registerShortcut("ctrl+shift+a", {
-		description: "Open sub-agent monitor",
-		handler: async (ctx) => {
-			if (ctx.mode !== "tui") return;
-			await openSubagentOverlay(ctx);
-		},
-	});
-
 	// Proactive dispatch: inject the delegation directive into the parent system prompt.
 	pi.on("before_agent_start", async (event, ctx) => {
 		const config = await loadConfig(configPath);

package/src/monitor.ts

@@ -1,20 +1,16 @@
 /**
  * Sub-agent monitor: a module-level singleton store that tracks subagent runs
- * for the current turn, plus a drill-down overlay component for live inspection.
+ * for the current turn.
  *
- * The store notifies subscribers on every mutation so the persistent widget and
- * the overlay can re-render. The overlay shows a list of runs (↑/↓ + Enter) and
- * a detail view with the live transcript (auto-tailing, scrollable).
+ * The store notifies subscribers on every mutation so the persistent widget
+ * above the editor can re-render. Each run carries timing information
+ * (started/ended) plus a concise activity string describing what the run is
+ * doing right now ("thinking", "read src/index.ts", ...). Runs are removed
+ * as soon as they finish: the tool result is the durable record in the main
+ * conversation, so a stale "done" row must not linger in the widget.
  */
 
-import {
-	matchesKey,
-	truncateToWidth,
-	type Component,
-	type Focusable,
-	type TUI,
-} from "@earendil-works/pi-tui";
-import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { UsageStats } from "./spawn.ts";
 
 // ---------------------------------------------------------------------------
@@ -23,18 +19,18 @@ import type { UsageStats } from "./spawn.ts";
 
 export type RunStatus = "queued" | "running" | "done" | "failed";
 
-export interface TranscriptLine {
-	kind: "tool" | "text" | "status" | "error";
-	text: string;
-}
-
 export interface RunView {
 	id: number;
 	agent: string;
 	model?: string;
 	status: RunStatus;
 	usage: UsageStats;
-	transcript: TranscriptLine[];
+	/** Concise current activity ("thinking", "read src/index.ts"); last writer wins. */
+	activity?: string;
+	/** Epoch ms when the run started executing (set on first "running" status). */
+	startedAt?: number;
+	/** Epoch ms when the run finished (set on "done"/"failed"). */
+	endedAt?: number;
 }
 
 // ---------------------------------------------------------------------------
@@ -56,6 +52,80 @@ export function formatUsageCompact(usage: UsageStats): string {
 	return parts.join(" ");
 }
 
+export function formatDuration(ms: number): string {
+	const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+	if (totalSeconds < 60) return `${totalSeconds}s`;
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (minutes < 60) return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+	const hours = Math.floor(minutes / 60);
+	return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
+}
+
+/** Elapsed wall time of a run: live while running, final once finished. */
+export function formatElapsed(run: RunView, now: number = Date.now()): string {
+	if (run.startedAt === undefined) return "";
+	const end = run.endedAt ?? now;
+	return formatDuration(end - run.startedAt);
+}
+
+/** Max length of the argument target inside a formatted activity line. */
+export const ACTIVITY_TARGET_MAX = 60;
+
+function shortTarget(value: unknown): string {
+	if (typeof value !== "string") return "";
+	const oneLine = value.replace(/\s+/g, " ").trim();
+	// Slice by code point so emoji / CJK-ext never leave a lone surrogate.
+	const chars = [...oneLine];
+	return chars.length > ACTIVITY_TARGET_MAX ? `${chars.slice(0, ACTIVITY_TARGET_MAX - 1).join("")}…` : oneLine;
+}
+
+/** Concise "what is it doing" text for a tool call: the tool name plus its single
+ * most telling argument (path, command, pattern, ...) — never a raw JSON blob. */
+export function formatToolActivity(toolName: string, args: unknown): string {
+	const a = (typeof args === "object" && args !== null ? args : {}) as Record<string, unknown>;
+	const pick = (...keys: string[]): string => {
+		for (const key of keys) {
+			const s = shortTarget(a[key]);
+			if (s) return s;
+		}
+		return "";
+	};
+	let target: string;
+	switch (toolName) {
+		case "bash":
+		case "shell":
+			target = pick("command");
+			break;
+		case "read":
+		case "edit":
+		case "write":
+		case "ls":
+			target = pick("path", "file", "filePath");
+			break;
+		case "grep":
+		case "find":
+		case "glob":
+			target = pick("pattern", "query", "path");
+			break;
+		case "web_search":
+		case "search":
+			target = pick("query");
+			break;
+		case "fetch":
+		case "web_fetch":
+		case "fetch_content":
+			target = pick("url");
+			break;
+		case "subagent":
+			target = pick("agent", "task");
+			break;
+		default:
+			target = pick("path", "command", "query", "pattern", "url", "file", "task");
+	}
+	return target ? `${toolName} ${target}` : toolName;
+}
+
 // ---------------------------------------------------------------------------
 // MonitorStore
 // ---------------------------------------------------------------------------
@@ -80,7 +150,6 @@ export class MonitorStore {
 			model,
 			status: "queued",
 			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-			transcript: [],
 		});
 		this.notify();
 		return id;
@@ -90,9 +159,13 @@ export class MonitorStore {
 		const run = this.find(id);
 		if (!run) return;
 		run.status = status;
+		if (status === "running" && run.startedAt === undefined) {
+			run.startedAt = Date.now();
+		} else if ((status === "done" || status === "failed") && run.endedAt === undefined) {
+			run.endedAt = Date.now();
+		}
 		this.notify();
 	}
-
 	setUsage(id: number, usage: UsageStats, model?: string): void {
 		const run = this.find(id);
 		if (!run) return;
@@ -101,29 +174,21 @@ export class MonitorStore {
 		this.notify();
 	}
 
-	appendTranscript(id: number, line: TranscriptLine): void {
+	/** Update the run's current one-line activity (what it is doing now). */
+	setActivity(id: number, text: string): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.transcript.push(line);
+		run.activity = text;
 		this.notify();
 	}
 
-	/** Append streamed assistant text, merging consecutive deltas into coherent
-	 * lines (split only on real newlines) instead of one line per token fragment. */
-	appendTextDelta(id: number, delta: string): void {
-		const run = this.find(id);
-		if (!run || delta.length === 0) return;
-		const segments = delta.split("\n");
-		for (let i = 0; i < segments.length; i++) {
-			const seg = segments[i];
-			const last = run.transcript[run.transcript.length - 1];
-			if (i === 0 && last && last.kind === "text") {
-				last.text += seg;
-			} else {
-				run.transcript.push({ kind: "text", text: seg });
-			}
-		}
+	/** Remove a run (finished runs leave the widget). Returns the removed run. */
+	removeRun(id: number): RunView | undefined {
+		const index = this.runs.findIndex((r) => r.id === id);
+		if (index === -1) return undefined;
+		const [run] = this.runs.splice(index, 1);
 		this.notify();
+		return run;
 	}
 
 	getRuns(): RunView[] {
@@ -142,7 +207,8 @@ export class MonitorStore {
 		const parts = [run.agent];
 		if (run.model) parts.push(run.model);
 		if (usage) parts.push(usage);
-		parts.push(run.status);
+		const elapsed = formatElapsed(run);
+		if (elapsed) parts.push(elapsed);
 		return parts.join(" · ");
 	}
 
@@ -180,191 +246,30 @@ export function statusIcon(status: RunStatus, theme: Theme): string {
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Overlay component
-// ---------------------------------------------------------------------------
-
-class SubagentOverlay implements Component, Focusable {
-	private _focused = false;
-	private mode: "list" | "detail" = "list";
-	private cursor = 0;
-	private scroll = 0;
-	private cachedWidth = -1;
-	private cachedLines: string[] = [];
-	private closed = false;
-
-	private readonly unsub: () => void;
-
-	constructor(
-		private readonly tui: TUI,
-		private readonly theme: Theme,
-		private readonly done: (result: void) => void,
-	) {
-		this.unsub = monitor.subscribe(() => {
-			this.invalidate();
-			this.tui.requestRender();
-		});
-	}
-
-	get focused(): boolean {
-		return this._focused;
-	}
-
-	set focused(value: boolean) {
-		this._focused = value;
-	}
-
-	invalidate(): void {
-		this.cachedWidth = -1;
-		this.cachedLines = [];
-	}
-
-	handleInput(data: string): void {
-		if (this.mode === "list") {
-			const runs = monitor.getRuns();
-			if (matchesKey(data, "up")) {
-				if (runs.length > 0) this.cursor = this.cursor === 0 ? runs.length - 1 : this.cursor - 1;
-			} else if (matchesKey(data, "down")) {
-				if (runs.length > 0) this.cursor = this.cursor === runs.length - 1 ? 0 : this.cursor + 1;
-			} else if (matchesKey(data, "return")) {
-				if (runs.length > 0) {
-					this.mode = "detail";
-					this.scrollToBottom();
-				}
-			} else if (matchesKey(data, "escape")) {
-				this.close();
-				return;
-			}
-		} else {
-			if (matchesKey(data, "up")) {
-				this.scroll = Math.max(0, this.scroll - 1);
-			} else if (matchesKey(data, "down")) {
-				this.scroll++;
-			} else if (matchesKey(data, "escape")) {
-				this.mode = "list";
-			}
-		}
-		this.invalidate();
-		this.tui.requestRender();
-	}
-
-	render(width: number): string[] {
-		if (this.cachedWidth === width && this.cachedLines.length > 0) return this.cachedLines;
-
-		const t = this.theme;
-		const fit = (line: string): string => truncateToWidth(line, width, "");
-		const border = fit(t.fg("border", "─".repeat(Math.max(1, width))));
-
-		const lines: string[] = [];
-
-		if (this.mode === "list") {
-			lines.push(border);
-			lines.push(fit(t.fg("accent", t.bold(" Sub-agents"))));
-			lines.push(border);
-
-			const runs = monitor.getRuns();
-			if (runs.length === 0) {
-				lines.push(fit(t.fg("dim", "  (no sub-agent runs this turn)")));
-			} else {
-				this.cursor = Math.max(0, Math.min(this.cursor, runs.length - 1));
-				for (let i = 0; i < runs.length; i++) {
-					const run = runs[i];
-					const isCursor = i === this.cursor;
-					const mark = isCursor ? t.fg("accent", "❯ ") : "  ";
-					const icon = statusIcon(run.status, t);
-					const usage = formatUsageCompact(run.usage);
-					const parts = [run.agent];
-					if (run.model) parts.push(run.model);
-					if (usage) parts.push(usage);
-					parts.push(run.status);
-					const label = isCursor ? t.fg("accent", t.bold(parts.join(" · "))) : parts.join(" · ");
-					lines.push(fit(`${mark}${icon} ${label}`));
-				}
-			}
-
-			lines.push(border);
-			lines.push(fit(t.fg("dim", " ↑↓ select · enter open · esc close")));
-			lines.push(border);
-		} else {
-			const runs = monitor.getRuns();
-			const run = runs[this.cursor];
-
-			lines.push(border);
-			if (run) {
-				const headerParts = [run.agent];
-				if (run.model) headerParts.push(run.model);
-				lines.push(fit(t.fg("accent", t.bold(` ${headerParts.join(" · ")}`))));
-				const usage = formatUsageCompact(run.usage);
-				const statusLine = ` ${statusIcon(run.status, t)} ${run.status}${usage ? ` · ${usage}` : ""}`;
-				lines.push(fit(statusLine));
-			} else {
-				lines.push(fit(t.fg("dim", " (no run selected)")));
-			}
-			lines.push(border);
-
-			if (run) {
-				// Available height for transcript: total minus header(4) + footer(2)
-				const transcriptLines = run.transcript;
-				const availHeight = Math.max(1, 40 - 6); // reasonable default; actual height varies
-				this.scroll = Math.max(0, Math.min(this.scroll, Math.max(0, transcriptLines.length - availHeight)));
-
-				// Auto-tail: if scroll is at the bottom, keep it there
-				const maxScroll = Math.max(0, transcriptLines.length - availHeight);
-				if (this.scroll >= maxScroll - 1) this.scroll = maxScroll;
-
-				const visible = transcriptLines.slice(this.scroll, this.scroll + availHeight);
-				for (const entry of visible) {
-					const color =
-						entry.kind === "tool"
-							? "accent"
-							: entry.kind === "error"
-								? "error"
-								: entry.kind === "status"
-									? "dim"
-									: "text";
-					lines.push(fit(t.fg(color, ` ${entry.text}`)));
-				}
-				if (transcriptLines.length === 0) {
-					lines.push(fit(t.fg("dim", " (waiting for output…)")));
-				}
-			}
-
-			lines.push(border);
-			lines.push(fit(t.fg("dim", " ↑↓ scroll · esc back")));
-			lines.push(border);
-		}
-
-		this.cachedWidth = width;
-		this.cachedLines = lines;
-		return lines;
-	}
-
-	dispose(): void {
-		if (!this.closed) {
-			this.closed = true;
-			this.unsub();
-		}
-	}
-
-	private scrollToBottom(): void {
-		const runs = monitor.getRuns();
-		const run = runs[this.cursor];
-		if (run) this.scroll = Math.max(0, run.transcript.length);
-	}
-
-	private close(): void {
-		this.closed = true;
-		this.unsub();
-		this.done();
+/** User-facing status label shown in the widget. */
+export function statusLabel(status: RunStatus): string {
+	switch (status) {
+		case "queued":
+			return "ready";
+		case "running":
+			return "running";
+		case "done":
+			return "done";
+		case "failed":
+			return "stopped";
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Public entry point
-// ---------------------------------------------------------------------------
-
-export async function openSubagentOverlay(ctx: ExtensionContext): Promise<void> {
-	await ctx.ui.custom<void>((tui, theme, _kb, done) => new SubagentOverlay(tui, theme, done), {
-		overlay: true,
-	});
+/** Theme color matching the status label. */
+export function statusColor(status: RunStatus): "accent" | "success" | "error" | "dim" {
+	switch (status) {
+		case "running":
+			return "accent";
+		case "done":
+			return "success";
+		case "failed":
+			return "error";
+		default:
+			return "dim";
+	}
 }

package/src/spawn.ts

@@ -20,6 +20,10 @@ import type { AgentConfig, AgentSource } from "./agents.ts";
 
 export const MAX_PARALLEL_TASKS = 8;
 export const MAX_CONCURRENCY = 4;
+/** Thinking level requested for every sub-agent: the strongest pi offers. pi's
+ * session layer clamps it adaptively to what the resolved model supports
+ * (max → xhigh → high → … → off), so weaker models degrade gracefully. */
+export const SUBAGENT_THINKING_LEVEL = "max";
 /** Max nesting depth for sub-agent -> sub-agent spawning (recursion guard). */
 export const MAX_SUBAGENT_DEPTH = 2;
 export const DEPTH_ENV_VAR = "PI_SUBAGENT_DEPTH";
@@ -59,7 +63,8 @@ export type SubagentLiveEvent =
 	| { kind: "usage"; usage: UsageStats; model?: string }
 	| { kind: "tool_start"; toolName: string; args: unknown }
 	| { kind: "tool_end"; toolName: string; isError: boolean }
-	| { kind: "text_delta"; delta: string };
+	| { kind: "thinking" }
+	| { kind: "text" };
 
 function emptyUsage(): UsageStats {
 	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
@@ -168,6 +173,8 @@ export async function runSingleAgent(options: RunSingleOptions): Promise<SingleR
 
 	const args: string[] = ["--mode", "json", "-p", "--no-session"];
 	if (agent.model) args.push("--model", agent.model);
+	// Strongest thinking by default; clamped adaptively per model by pi.
+	args.push("--thinking", SUBAGENT_THINKING_LEVEL);
 	if (agent.tools && agent.tools.length > 0) args.push("--tools", agent.tools.join(","));
 
 	let tmpPromptDir: string | null = null;
@@ -237,12 +244,15 @@ export async function runSingleAgent(options: RunSingleOptions): Promise<SingleR
 					}
 				}
 
-				// Live event: streamed assistant text
-				if (event.type === "message_update" && event.assistantMessageEvent?.type === "text_delta") {
-					if (onLive) {
-						try {
-							onLive({ kind: "text_delta", delta: event.assistantMessageEvent.delta ?? "" });
-						} catch { /* never throw from event handling */ }
+				// Live event: streamed assistant reasoning / output text
+				if (event.type === "message_update") {
+					const t = event.assistantMessageEvent?.type;
+					if (t === "thinking_delta" || t === "text_delta") {
+						if (onLive) {
+							try {
+								onLive({ kind: t === "thinking_delta" ? "thinking" : "text" });
+							} catch { /* never throw from event handling */ }
+						}
 					}
 				}
 
@@ -309,17 +319,32 @@ export async function runSingleAgent(options: RunSingleOptions): Promise<SingleR
 
 			proc.on("close", (code) => {
 				if (buffer.trim()) processLine(buffer);
-				// Live event: final status derived from exit code
+				// Live event: final status derived from exit code / abort state.
+				// code is null on signal termination (e.g. our own Esc abort), which
+				// must read as failure — never as a false "done".
 				if (onLive) {
 					try {
-						const failed = (code ?? 0) !== 0 || currentResult.stopReason === "error" || currentResult.stopReason === "aborted";
+						const failed =
+							code !== 0 ||
+							wasAborted ||
+							(signal?.aborted ?? false) ||
+							currentResult.stopReason === "error" ||
+							currentResult.stopReason === "aborted";
 						onLive({ kind: "status", status: failed ? "failed" : "done" });
 					} catch { /* never throw from event handling */ }
 				}
 				resolve(code ?? 0);
 			});
 
-			proc.on("error", () => resolve(1));
+			proc.on("error", () => {
+				// Spawn itself failed; close may never fire, so finish the run here.
+				if (onLive) {
+					try {
+						onLive({ kind: "status", status: "failed" });
+					} catch { /* never throw from event handling */ }
+				}
+				resolve(1);
+			});
 
 			if (signal) {
 				const killProc = (): void => {