@arhen/pi-core-subagent 1.1.13 → 1.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arhen/pi-core-subagent",
-  "version": "1.1.13",
+  "version": "1.1.15",
   "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

@@ -21,6 +21,7 @@ import { Type } from "typebox";
 import { join } from "node:path";
 import { CHILD_TALK_TOOLS, createChildTools, createWatchdog, type ChildHandlers } from "./child.ts";
 import { createMailbox, type Mailbox } from "./mailbox.ts";
+import { createPeekPane, type PeekTask } from "./peek.ts";
 
 const DEFAULT_CONCURRENCY = 3;
 const MAX_CONCURRENCY = 8;
@@ -1026,6 +1027,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 };
@@ -1170,6 +1187,37 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	/** Read-only peek: browse agents, enter to tail one. Never mutates run state. */
+	const openPeek = async (ctx: ExtensionContext) => {
+		if (!ctx.hasUI) return;
+		const getTasks = (): PeekTask[] =>
+			manager
+				.listRuns()
+				.flatMap((run) => run.tasks)
+				.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), (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%" } },
+		);
+	};
+	pi.registerCommand("peek", { description: "Peek at running subagents (↑↓ move, enter tails)", handler: (_args, ctx) => openPeek(ctx) });
+	pi.registerShortcut("ctrl+shift+s", { description: "Peek at running subagents", handler: openPeek });
+
 	pi.on("agent_start", (_event, ctx) => {
 		if (!manager.turnActivity && !manager.hasActiveRun()) manager.clearWidget(ctx);
 		manager.turnActivity = false;

package/src/peek.ts

@@ -0,0 +1,153 @@
+/**
+ * Peek pane — quick, read-only look at what subagents are doing.
+ *
+ * ↑/↓ (or ←/→) move between agents, enter opens a live tail of that child's
+ * session file, esc goes back / closes. Never touches run state: no abort,
+ * no cancel, no writes.
+ */
+
+import { closeSync, openSync, readSync, statSync } from "node:fs";
+import { Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+
+/** Tail window: last 64KB of the child session file is plenty for a peek. */
+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
+}
+
+function readTail(path: string): string {
+	const fd = openSync(path, "r");
+	try {
+		const size = statSync(path).size;
+		const start = Math.max(0, size - TAIL_BYTES);
+		const buf = Buffer.alloc(size - start);
+		readSync(fd, buf, 0, buf.length, start);
+		return buf.toString("utf8");
+	} finally {
+		closeSync(fd);
+	}
+}
+
+/** One session-file line → one display line. Unparseable/irrelevant → null. */
+function eventLine(raw: string): string | null {
+	let entry: any;
+	try {
+		entry = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	const msg = entry?.message;
+	if (!msg) return null;
+	const parts: string[] = [];
+	for (const block of msg.content ?? []) {
+		if (block.type === "text" && block.text?.trim()) parts.push(block.text.trim());
+		else if (block.type === "toolCall") parts.push(`→ ${block.name} ${JSON.stringify(block.arguments ?? {})}`);
+		else if (block.type === "thinking" && block.thinking?.trim()) parts.push(`(thinking) ${block.thinking.trim()}`);
+	}
+	if (parts.length === 0) return null;
+	const who = msg.role === "assistant" ? "" : msg.role === "toolResult" ? "  ← " : `${msg.role}: `;
+	return `${who}${parts.join(" ").replace(/\s+/g, " ")}`;
+}
+
+function tailLines(path: string, max: number): string[] {
+	let text: string;
+	try {
+		text = readTail(path);
+	} catch {
+		return ["(session file not readable yet)"];
+	}
+	const lines: string[] = [];
+	// First line of a mid-file read is usually a fragment — drop it.
+	for (const raw of text.split("\n").slice(1)) {
+		const line = eventLine(raw);
+		if (line) lines.push(line);
+	}
+	return lines.slice(-max);
+}
+
+export interface PeekPane {
+	render(width: number): string[];
+	handleInput(data: string): void;
+	invalidate(): void;
+	dispose(): void;
+}
+
+/**
+ * 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,
+	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)));
+
+	return {
+		render(width: number): string[] {
+			const tasks = getTasks();
+			selected = clamp(selected, tasks.length);
+			if (tasks.length === 0) return [theme.fg("dim", "No subagents in this session.")];
+			const task = tasks[selected]!;
+			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, "…"))];
+			}
+			if (!task.sessionFile) return [head, theme.fg("dim", "(no session file — agent has not started yet)")];
+			// ponytail: re-reads the tail each render (700ms poll). A watcher only pays off for files far bigger than a child session.
+			return [head, ...tailLines(task.sessionFile, 18).map((l) => truncateToWidth(`  ${l}`, width, "…"))];
+		},
+		handleInput(data: string): void {
+			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)) {
+				tailing = true;
+			} else if (matchesKey(data, Key.left)) {
+				tailing = false;
+			} else if (matchesKey(data, Key.up)) {
+				selected = clamp(selected - 1, len);
+			} else if (matchesKey(data, Key.down)) {
+				selected = clamp(selected + 1, len);
+			}
+			requestRender();
+		},
+		invalidate(): void {
+			/* no cached strings */
+		},
+		dispose(): void {
+			clearInterval(timer);
+		},
+	};
+}