@ferris1225/pi-subagents 0.3.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.3.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, statusColor, statusIcon, statusLabel } 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];
@@ -232,7 +250,7 @@ export default function (pi: ExtensionAPI): void {
 							makeDetails: makeDetails("parallel"),
 						});
 					} catch (err) {
-						monitor.setStatus(runId, "failed");
+						finishRun(runId, "failed");
 						throw err;
 					}
 					allResults[index] = result;
@@ -261,25 +279,7 @@ 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 onLive = makeLiveHandler(runId);
 			let result: SingleResult;
 			try {
 				result = await runSingleAgent({
@@ -294,7 +294,7 @@ export default function (pi: ExtensionAPI): void {
 					makeDetails: makeDetails("single"),
 				});
 			} catch (err) {
-				monitor.setStatus(runId, "failed");
+				finishRun(runId, "failed");
 				throw err;
 			}
 
@@ -386,8 +386,8 @@ export default function (pi: ExtensionAPI): void {
 							const icon = statusIcon(r.status, theme);
 							const label = theme.fg(statusColor(r.status), statusLabel(r.status));
 							lines.push(truncateToWidth(` ${icon} ${monitor.summarize(r)} · ${label}`, width, ""));
-							const activity = monitor.lastActivity(r);
-							if (activity) lines.push(truncateToWidth(theme.fg("dim", `   ${activity}`), width, ""));
+							// Activity sits one indent level below the agent name.
+							if (r.activity) lines.push(truncateToWidth(theme.fg("dim", `     ${r.activity}`), width, ""));
 						}
 						return lines;
 					},

package/src/monitor.ts

@@ -4,8 +4,10 @@
  *
  * The store notifies subscribers on every mutation so the persistent widget
  * above the editor can re-render. Each run carries timing information
- * (started/ended) and a transcript whose most recent entry is surfaced as the
- * run's current activity.
+ * (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 type { Theme } from "@earendil-works/pi-coding-agent";
@@ -17,18 +19,14 @@ 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"). */
@@ -71,6 +69,63 @@ export function formatElapsed(run: RunView, now: number = Date.now()): string {
 	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
 // ---------------------------------------------------------------------------
@@ -95,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;
@@ -120,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[] {
@@ -166,15 +212,6 @@ export class MonitorStore {
 		return parts.join(" · ");
 	}
 
-	/** Text of the most recent transcript entry (what the run is doing now). */
-	lastActivity(run: RunView): string | undefined {
-		for (let i = run.transcript.length - 1; i >= 0; i--) {
-			const text = run.transcript[i].text.trim();
-			if (text.length > 0) return text;
-		}
-		return undefined;
-	}
-
 	private find(id: number): RunView | undefined {
 		return this.runs.find((r) => r.id === id);
 	}

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 => {