@arhen/pi-core-subagent 1.1.15 → 1.1.17

package/README.md

@@ -8,6 +8,10 @@ Minimalist pi extension: **fast in-process subagents** with single / parallel /
 
 Built for one job: delegate work to isolated subagents **without bloating the parent context**.
 
+![Subagents widget](docs/subagents-widget.png)
+
+*The `subagent` tool call plus the live above-editor widget: per-agent activity, tool counts, turns, token counters and timers.*
+
 ## Design principles
 
 - **No agent files, no discovery.** The leader defines every subagent inline per call — name, system prompt, toolset. Nothing is read from or written to disk.
@@ -15,7 +19,8 @@ Built for one job: delegate work to isolated subagents **without bloating the pa
 - **In-process** — children are `AgentSession`s in the same runtime. No process spawn, no context bleed.
 - **Zero parent-context injection.** No catalog, no context hook. 6 slim tools total.
 - **Throttled updates** — widget/stream updates coalesce to ~6/s; no per-event deep clones.
-- **No silent hangs** — watchdog aborts children that produce no events for 3 minutes; per-task timeout 10min.
+- **No silent hangs** — watchdog aborts children that produce no events for 3 minutes.
+- **No default runtime cap** — tasks run until done, stalled (watchdog), or aborted by the user. `maxRuntimeMs` is opt-in (default 0 = unlimited).
 
 ## Install
 
@@ -95,6 +100,15 @@ Background + intercom:
 | `send_agent_message` | message to a sibling subagent's mailbox (`to` = its task id, or `"leader"`) |
 | `poll_agent_messages` | drain this subagent's mailbox |
 
+## Peek — `/peek` or `ctrl+shift+s`
+
+Read-only pane over the session's subagents:
+
+- `↑`/`↓` — move between agents
+- `enter` — live tail of that child's session file (`esc` goes back)
+- `x` then `y` — abort ONE subagent (only mutation; `n`/any other key cancels)
+- `esc` — close
+
 ## Context budget
 
 - Parent tools: 6 schemas with short descriptions. **No catalog, no context hook** — nothing injected per request.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arhen/pi-core-subagent",
-  "version": "1.1.15",
+  "version": "1.1.17",
   "type": "module",
   "description": "pi extension: fast in-process subagents with single/parallel/chain, background runs, intercom and agent-to-agent mailbox. Leader defines agents inline.",
   "license": "MIT",

package/src/index.ts

@@ -26,7 +26,8 @@ import { createPeekPane, type PeekTask } from "./peek.ts";
 const DEFAULT_CONCURRENCY = 3;
 const MAX_CONCURRENCY = 8;
 const MAX_TASKS = 16;
-const DEFAULT_RUNTIME_MS = 10 * 60 * 1000;
+/** No default wall-clock cap: a subagent runs until its task is done, it stalls, or the user aborts. */
+const DEFAULT_RUNTIME_MS = 0;
 const DEFAULT_STALL_MS = 180_000; // 3 min: long model thinking streams emit message_update, not message_end
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
 const READONLY_TOOLS = ["read", "grep", "find", "ls"];
@@ -225,14 +226,40 @@ function taskStatsWithUsage(task: TaskSnapshot): string {
 function taskLine(task: TaskSnapshot): string {
 	return `${statusIcon(task.status)} ${task.agent} · ${taskStatsWithUsage(task)} · ${taskTimer(task)}`;
 }
-function argsSuffix(args: unknown): string {
-	try {
-		const s = JSON.stringify(args);
-		if (!s || s === "{}") return "";
-		return ` ${s.length > 60 ? `${s.slice(0, 60)}…` : s}`;
-	} catch {
-		return "";
+/** Numbers get the theme's number color, same as the footer's token counters. */
+function colorNums(text: string, theme: Theme): string {
+	return text.replace(/\d+(?:\.\d+)?/g, (n) => theme.fg("syntaxNumber", n));
+}
+/**
+ * Themed one-liner. Finished tasks dim entirely (stats included); live tasks
+ * keep the agent name readable with themed numbers.
+ */
+function themedTaskLine(task: TaskSnapshot, theme: Theme, activity = ""): string {
+	const tail = `${taskStatsWithUsage(task)} · ${taskTimer(task)}`;
+	if (TERMINAL.includes(task.status)) {
+		return theme.fg("dim", `${statusIcon(task.status)} ${task.agent} · ${tail}`);
 	}
+	return `${statusIcon(task.status)} ${task.agent} · ${activity}${colorNums(theme.fg("muted", tail), theme)}`;
+}
+/**
+ * Human-readable activity line: "Read src/index.ts", "Grep wrapSingleLine".
+ * ponytail: picks the first interesting string arg instead of a per-tool table —
+ * unknown/custom tools then read fine too. Add a case only if one reads badly.
+ */
+// Order matters: the most specific arg wins (grep's pattern beats its path).
+const ARG_KEYS = ["pattern", "query", "command", "path", "file_path", "filePath", "url", "name", "subject", "task"];
+export function describeCall(toolName: string, args: unknown, cwd?: string): string {
+	const verb = toolName.charAt(0).toUpperCase() + toolName.slice(1);
+	const obj = args && typeof args === "object" ? (args as Record<string, unknown>) : undefined;
+	if (!obj) return verb;
+	let value = ARG_KEYS.map((k) => obj[k]).find((v) => typeof v === "string" && v.trim() !== "") as string | undefined;
+	if (value === undefined) {
+		value = Object.values(obj).find((v) => typeof v === "string" && v.trim() !== "") as string | undefined;
+	}
+	if (value === undefined) return verb;
+	let text = value.replace(/\s+/g, " ").trim();
+	if (cwd && text.startsWith(`${cwd}/`)) text = text.slice(cwd.length + 1); // absolute paths inside the task cwd read as noise
+	return `${verb} ${text.length > 60 ? `${text.slice(0, 60)}…` : text}`;
 }
 function activitySnippet(text: string): string {
 	const flat = text.replace(/\s+/g, " ").trim();
@@ -280,19 +307,12 @@ class SubagentsWidget implements Component {
 		const budget = WIDGET_MAX_LINES - 1;
 		let shown = 0;
 		outer: for (const run of runs) {
-			const allDone = TERMINAL.includes(run.status);
 			for (const task of run.tasks) {
 				if (shown >= budget) break outer;
 				shown += 1;
-				const activity =
-					!TERMINAL.includes(task.status) && task.lastActivity
-						? `${this.theme.fg("dim", `→ ${task.lastActivity}`)} · `
-						: "";
-				// Tasks of a finished run: dim everything except the agent name.
-				const line = allDone
-					? `${this.theme.fg("dim", `${statusIcon(task.status)} `)}${task.agent} ${this.theme.fg("dim", `· ${taskStatsWithUsage(task)} · ${taskTimer(task)}`)}`
-					: `${statusIcon(task.status)} ${task.agent} · ${activity}${taskStatsWithUsage(task)} · ${taskTimer(task)}`;
-				lines.push(truncateToWidth(`${this.theme.fg("dim", "├─")} ${line}`, width, "…"));
+				const activity = task.lastActivity ? `${this.theme.fg("dim", `→ ${task.lastActivity}`)} · ` : "";
+				// Per-TASK status drives dimming: a finished agent stays dim even while siblings run.
+				lines.push(truncateToWidth(`${this.theme.fg("dim", "├─")} ${themedTaskLine(task, this.theme, activity)}`, width, "…"));
 			}
 		}
 		const hidden = total - shown;
@@ -576,7 +596,6 @@ class SubagentManager {
 				this.ensureWidget(ctx);
 				this.widgetTui?.requestRender();
 			}
-			onUpdate?.({ content: [{ type: "text", text: compactLines(run).join("\n") }] });
 		}, WIDGET_THROTTLE_MS));
 	}
 	private flushWidget(run: RunSnapshot | undefined, ctx?: ExtensionContext, onUpdate?: (partial: any) => void): void {
@@ -592,7 +611,8 @@ class SubagentManager {
 			this.ensureWidget(ctx);
 			this.widgetTui?.requestRender();
 		}
-		onUpdate?.({ content: [{ type: "text", text: compactLines(run).join("\n") }] });
+		// Transcript gets one status line only — the live per-task view is the widget's job.
+		onUpdate?.({ content: [{ type: "text", text: `${run.tasks.filter((t) => TERMINAL.includes(t.status)).length}/${run.tasks.length} done · ${run.status}` }] });
 	}
 	private ensureWidget(ctx: ExtensionContext): void {
 		if (this.widgetTui !== null || !ctx.hasUI) return;
@@ -779,7 +799,7 @@ class SubagentManager {
 					this.emit("subagent:session-event", { runId: run.id, taskId: task.id, seq: eventSeq++, event: { type: event.type } });
 				}
 				if (event.type === "tool_execution_start") {
-					this.updateTask(run, task, { toolCalls: task.toolCalls + 1, lastActivity: `${event.toolName}${argsSuffix(event.args)}` }, ctx, onUpdate);
+					this.updateTask(run, task, { toolCalls: task.toolCalls + 1, lastActivity: describeCall(event.toolName, event.args, task.cwd) }, ctx, onUpdate);
 				} else if (event.type === "tool_execution_end") {
 					this.scheduleWidget(run, ctx, onUpdate);
 				} else if (event.type === "message_end") {
@@ -832,10 +852,15 @@ class SubagentManager {
 
 			const maxRuntimeMs = input.maxRuntimeMs ?? DEFAULT_RUNTIME_MS;
 			const promptPromise = child.prompt(task.task, { source: "extension" });
-			const timeoutPromise = new Promise<never>((_, reject) => {
-				timeout = setTimeout(() => reject(new Error(`Subagent timed out after ${maxRuntimeMs}ms`)), maxRuntimeMs);
-			});
-			await Promise.race([promptPromise, childFailurePromise, childEndPromise, watchdog.promise, timeoutPromise]);
+			const races: Promise<unknown>[] = [promptPromise, childFailurePromise, childEndPromise, watchdog.promise];
+			if (maxRuntimeMs > 0) {
+				races.push(
+					new Promise<never>((_, reject) => {
+						timeout = setTimeout(() => reject(new Error(`Subagent timed out after ${maxRuntimeMs}ms`)), maxRuntimeMs);
+					}),
+				);
+			}
+			await Promise.race(races);
 			if (timeout) clearTimeout(timeout);
 
 			pendingFailure ??= lastAssistantFailure(child.messages as AssistantMessage[]);
@@ -977,13 +1002,10 @@ class SubagentManager {
 		run.status = aborted ? "aborted" : failed ? "failed" : "completed";
 		run.endedAt = Date.now();
 		this.flushWidget(run, ctx, onUpdate);
-		// Run done: keep the widget only while another run is still live.
+		// Finished runs (including aborted ones) stay on screen so the outcome is readable.
+		// The agent_start handler clears them on the next turn that spawns nothing.
 		const live = this.listRuns().find((r) => !TERMINAL.includes(r.status));
-		if (live) {
-			this.scheduleWidget(live, ctx, onUpdate);
-		} else {
-			this.clearWidget(ctx);
-		}
+		if (live) this.scheduleWidget(live, ctx, onUpdate);
 		// L7: cancelRun already emitted + settled — don't double-report.
 		if (this.settlers.has(run.id)) {
 			this.emit("subagent:run-completed", { runId: run.id, status: run.status, run: cloneRun(run), aggregateUsage: run.aggregateUsage });
@@ -1149,7 +1171,7 @@ const SubagentParams = Type.Object({
 	thinking: Type.Optional(StringEnum(THINKING_LEVELS, { description: "Thinking level override (single mode)" })),
 	cwd: Type.Optional(Type.String({ description: "Working directory (single mode). Default: current project." })),
 	concurrency: Type.Optional(Type.Number({ description: `Parallel concurrency (default ${DEFAULT_CONCURRENCY}, max ${MAX_CONCURRENCY})` })),
-	maxRuntimeMs: Type.Optional(Type.Number({ description: `Per-task timeout, ms (default ${DEFAULT_RUNTIME_MS / 60000} min)` })),
+	maxRuntimeMs: Type.Optional(Type.Number({ description: "Per-task timeout, ms. Omit for no cap (default): tasks run until done, stalled, or user-aborted." })),
 	background: Type.Optional(Type.Boolean({ description: "Fire-and-forget: return immediately with a runId; you'll be notified on completion" })),
 	notifyPerTask: Type.Optional(Type.Boolean({ description: "Wake you (queued follow-up turn) as each task completes, even mid-run. Default false." })),
 	allowIntercom: Type.Optional(Type.Boolean({ description: "Let children ask you questions, notify you, and message sibling subagents" })),
@@ -1294,7 +1316,7 @@ export default function (pi: ExtensionAPI) {
 			// ponytail: mode/count already shown on the call line above; result header only adds progress + status.
 			const header = `${statusIcon(run.status)} ${theme.fg("accent", `${run.tasks.filter((t) => t.status === "completed").length}/${run.tasks.length} done`)}${run.background ? ` ${theme.fg("muted", "(background)")}` : ""} ${theme.fg("muted", run.status)}`;
 			if (!expanded) {
-				const lines = [header, ...run.tasks.map((task) => `  ${taskLine(task)}`)];
+				const lines = [header, ...run.tasks.map((task) => `  ${themedTaskLine(task, theme)}`)];
 				const usage = formatUsage(run.aggregateUsage);
 				if (usage) lines.push(theme.fg("dim", usage));
 				return new Text(lines.join("\n"), 0, 0);