@arhen/pi-core-subagent 1.1.14 → 1.1.16

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.14",
+  "version": "1.1.16",
   "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,6 +226,21 @@ function taskStatsWithUsage(task: TaskSnapshot): string {
 function taskLine(task: TaskSnapshot): string {
 	return `${statusIcon(task.status)} ${task.agent} · ${taskStatsWithUsage(task)} · ${taskTimer(task)}`;
 }
+/** 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)}`;
+}
 function argsSuffix(args: unknown): string {
 	try {
 		const s = JSON.stringify(args);
@@ -280,19 +296,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 +585,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 +600,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;
@@ -832,10 +841,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 +991,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 });
@@ -1027,6 +1038,22 @@ class SubagentManager {
 		return { run: cloneRun(run), background: true };
 	}
 
+	/** Abort ONE task; siblings keep running. Returns false when unknown or already finished. */
+	cancelTask(runId: string, taskId: string, ctx?: ExtensionContext): boolean {
+		const run = this.runs.get(runId);
+		const task = run?.tasks.find((t) => t.id === taskId);
+		if (!run || !task || TERMINAL.includes(task.status)) return false;
+		// Mark first: runChild's catch reads task.status to classify the outcome as aborted.
+		task.status = "aborted";
+		task.error = task.error || "Canceled from peek";
+		task.endedAt = Date.now();
+		this.liveChildren.get(`${runId}:${taskId}`)?.abort();
+		this.mailboxes.close(`${runId}:${taskId}`);
+		if (ctx) this.flushWidget(run, ctx);
+		this.emit("subagent:task-aborted", { runId, taskId });
+		return true;
+	}
+
 	cancelRun(runId: string): { aborted: number } {
 		const run = this.runs.get(runId);
 		if (!run) return { aborted: 0 };
@@ -1133,7 +1160,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" })),
@@ -1178,13 +1205,24 @@ export default function (pi: ExtensionAPI) {
 			manager
 				.listRuns()
 				.flatMap((run) => run.tasks)
-				.map((task) => ({ agent: task.agent, status: task.status, sessionFile: task.sessionFile, line: taskLine(task) }));
+				.map((task) => ({
+					runId: task.runId,
+					taskId: task.id,
+					agent: task.agent,
+					status: task.status,
+					running: !TERMINAL.includes(task.status),
+					sessionFile: task.sessionFile,
+					line: taskLine(task),
+				}));
 		if (getTasks().length === 0) {
 			ctx.ui.notify("No subagents in this session.", "info");
 			return;
 		}
 		await ctx.ui.custom<void>(
-			(tui, theme, _keybindings, done) => createPeekPane(getTasks, theme, () => tui.requestRender(), () => done(undefined)),
+			(tui, theme, _keybindings, done) =>
+				createPeekPane(getTasks, theme, () => tui.requestRender(), () => done(undefined), (t) => {
+					if (manager.cancelTask(t.runId, t.taskId, ctx)) ctx.ui.notify(`Aborted subagent ${t.agent}.`, "warning");
+				}),
 			{ overlay: true, overlayOptions: { anchor: "center", width: "80%", maxHeight: "70%" } },
 		);
 	};
@@ -1267,7 +1305,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);

package/src/peek.ts

@@ -15,8 +15,11 @@ const TAIL_BYTES = 64 * 1024;
 const POLL_MS = 700;
 
 export interface PeekTask {
+	runId: string;
+	taskId: string;
 	agent: string;
 	status: string;
+	running: boolean;
 	sessionFile?: string;
 	line: string; // pre-rendered stats line from the caller
 }
@@ -82,9 +85,16 @@ export interface PeekPane {
  * Build the peek component. `getTasks` is polled live, so the pane keeps
  * updating while agents run.
  */
-export function createPeekPane(getTasks: () => PeekTask[], theme: Theme, requestRender: () => void, close: () => void): PeekPane {
+export function createPeekPane(
+	getTasks: () => PeekTask[],
+	theme: Theme,
+	requestRender: () => void,
+	close: () => void,
+	abort: (task: PeekTask) => void,
+): PeekPane {
 	let selected = 0;
 	let tailing = false;
+	let confirming = false;
 	const timer = setInterval(requestRender, POLL_MS);
 
 	const clamp = (n: number, len: number) => (len === 0 ? 0 : Math.max(0, Math.min(len - 1, n)));
@@ -95,7 +105,7 @@ export function createPeekPane(getTasks: () => PeekTask[], theme: Theme, request
 			selected = clamp(selected, tasks.length);
 			if (tasks.length === 0) return [theme.fg("dim", "No subagents in this session.")];
 			const task = tasks[selected]!;
-			const hint = tailing ? "esc back" : "↑↓ move · enter tail · esc close";
+			const hint = confirming ? theme.fg("error", `abort ${task.agent}? y / n`) : tailing ? "esc back · x abort" : "↑↓ move · enter tail · x abort · esc close";
 			const head = `${theme.fg("accent", theme.bold(tailing ? task.agent : "Subagents"))} ${theme.fg("dim", `(${selected + 1}/${tasks.length}) · ${hint}`)}`;
 			if (!tailing) {
 				return [head, ...tasks.map((t, i) => truncateToWidth(`${i === selected ? theme.fg("accent", "❯ ") : "  "}${t.line}`, width, "…"))];
@@ -105,8 +115,21 @@ export function createPeekPane(getTasks: () => PeekTask[], theme: Theme, request
 			return [head, ...tailLines(task.sessionFile, 18).map((l) => truncateToWidth(`  ${l}`, width, "…"))];
 		},
 		handleInput(data: string): void {
-			const len = getTasks().length;
-			if (matchesKey(data, Key.escape)) {
+			const tasks = getTasks();
+			const len = tasks.length;
+			if (confirming) {
+				// Abort is irreversible, so it always costs a second keystroke.
+				confirming = false;
+				if (data === "y" || data === "Y") {
+					const task = tasks[selected];
+					if (task) abort(task);
+				}
+				requestRender();
+				return;
+			}
+			if (data === "x" || data === "X") {
+				if (tasks[selected]?.running) confirming = true;
+			} else if (matchesKey(data, Key.escape)) {
 				if (tailing) tailing = false;
 				else close();
 			} else if (matchesKey(data, Key.enter) || matchesKey(data, Key.right)) {