pi-subagents 0.17.4 → 0.18.0

package/index.ts

@@ -17,22 +17,24 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import { type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@mariozechner/pi-coding-agent";
-import { Box, Container, Spacer, Text } from "@mariozechner/pi-tui";
+import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@mariozechner/pi-tui";
 import { discoverAgents } from "./agents.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "./artifacts.ts";
 import { cleanupOldChainDirs } from "./settings.ts";
 import { renderWidget, renderSubagentResult } from "./render.ts";
-import { SubagentParams, StatusParams } from "./schemas.ts";
-import { findByPrefix, readStatus } from "./utils.ts";
+import { SubagentParams } from "./schemas.ts";
 import { createSubagentExecutor } from "./subagent-executor.ts";
 import { createAsyncJobTracker } from "./async-job-tracker.ts";
+import { controlNotificationKey, formatControlNoticeMessage } from "./subagent-control.ts";
 import { createResultWatcher } from "./result-watcher.ts";
 import { registerSlashCommands } from "./slash-commands.ts";
 import { registerPromptTemplateDelegationBridge } from "./prompt-template-bridge.ts";
 import { registerSlashSubagentBridge } from "./slash-bridge.ts";
 import { clearSlashSnapshots, getSlashRenderableSnapshot, resolveSlashMessageDetails, restoreSlashFinalSnapshots, type SlashMessageDetails } from "./slash-live-state.ts";
-import { formatAsyncRunList, listAsyncRuns } from "./async-status.ts";
+import { inspectSubagentStatus } from "./run-status.ts";
+import registerSubagentNotify from "./notify.ts";
 import {
+	type ControlEvent,
 	type Details,
 	type ExtensionConfig,
 	type SubagentState,
@@ -40,6 +42,9 @@ import {
 	DEFAULT_ARTIFACT_CONFIG,
 	RESULTS_DIR,
 	SLASH_RESULT_TYPE,
+	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	SUBAGENT_ASYNC_STARTED_EVENT,
+	SUBAGENT_CONTROL_EVENT,
 	WIDGET_KEY,
 } from "./types.ts";
 
@@ -139,6 +144,52 @@ function createSlashResultComponent(
 	return container;
 }
 
+const SUBAGENT_CONTROL_MESSAGE_TYPE = "subagent_control_notice";
+
+interface SubagentControlMessageDetails {
+	event: ControlEvent;
+	source?: "foreground" | "async";
+	asyncDir?: string;
+	childIntercomTarget?: string;
+	noticeText?: string;
+}
+
+function controlNoticeTarget(details: SubagentControlMessageDetails): string | undefined {
+	return details.childIntercomTarget;
+}
+
+function formatSubagentControlNotice(details: SubagentControlMessageDetails, content?: string): string {
+	return details.noticeText ?? content ?? formatControlNoticeMessage(details.event, controlNoticeTarget(details));
+}
+
+class SubagentControlNoticeComponent implements Component {
+	constructor(
+		private readonly details: SubagentControlMessageDetails,
+		private readonly theme: ExtensionContext["ui"]["theme"],
+	) {}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const eventLabel = this.details.event.type.replaceAll("_", " ");
+		if (width < 3) return [truncateToWidth(`Subagent ${eventLabel}`, width)];
+		const bodyWidth = Math.max(1, Math.min(width - 2, 68));
+		const borderChar = "─";
+		const header = ` ⚠ Subagent ${eventLabel}: ${this.details.event.agent} `;
+		const headerText = truncateToWidth(header, bodyWidth, "");
+		const headerPadding = Math.max(0, bodyWidth - visibleWidth(headerText));
+		const lines = [this.theme.fg("accent", `╭${headerText}${borderChar.repeat(headerPadding)}╮`)];
+
+		for (const line of wrapTextWithAnsi(formatSubagentControlNotice(this.details), bodyWidth)) {
+			const text = truncateToWidth(line, bodyWidth, "");
+			const padding = Math.max(0, bodyWidth - visibleWidth(text));
+			lines.push(this.theme.fg("accent", `│${text}${" ".repeat(padding)}│`));
+		}
+		lines.push(this.theme.fg("accent", `╰${borderChar.repeat(bodyWidth)}╯`));
+		return lines;
+	}
+}
+
 export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	ensureAccessibleDir(RESULTS_DIR);
 	ensureAccessibleDir(ASYNC_DIR);
@@ -153,6 +204,8 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		baseCwd: process.cwd(),
 		currentSessionId: null,
 		asyncJobs: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
 		cleanupTimers: new Map(),
 		lastUiContext: null,
 		poller: null,
@@ -174,7 +227,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	startResultWatcher();
 	primeExistingResults();
 
-	const { ensurePoller, handleStarted, handleComplete, resetJobs } = createAsyncJobTracker(state, ASYNC_DIR);
+	const { ensurePoller, handleStarted, handleComplete, resetJobs } = createAsyncJobTracker(pi, state, ASYNC_DIR);
 	const executor = createSubagentExecutor({
 		pi,
 		state,
@@ -192,6 +245,13 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		return createSlashResultComponent(details, options, theme);
 	});
 
+	pi.registerMessageRenderer<SubagentControlMessageDetails>(SUBAGENT_CONTROL_MESSAGE_TYPE, (message, _options, theme) => {
+		const details = message.details as SubagentControlMessageDetails | undefined;
+		if (!details?.event) return undefined;
+		const content = typeof message.content === "string" ? message.content : undefined;
+		return new SubagentControlNoticeComponent({ ...details, noticeText: formatSubagentControlNotice(details, content) }, theme);
+	});
+
 	const slashBridge = registerSlashSubagentBridge({
 		events: pi.events,
 		getContext: () => state.lastUiContext,
@@ -265,11 +325,15 @@ Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", tas
 
 MANAGEMENT (use action field, omit agent/task/chain/tasks):
 • { action: "list" } - discover agents/chains
-• { action: "get", agent: "name" } - full agent detail
+• { action: "get", agent: "name" } - full detail
 • { action: "create", config: { name, systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, ... } }
 • { action: "update", agent: "name", config: { ... } } - merge
 • { action: "delete", agent: "name" }
-• Use chainName for chain operations`,
+• Use chainName for chain operations
+
+CONTROL:
+• { action: "status", id: "..." } - inspect an async/background run by id or prefix
+• { action: "interrupt", id?: "..." } - soft-interrupt the current child turn and leave the run paused`,
 		parameters: SubagentParams,
 
 		execute(id, params, signal, onUpdate, ctx) {
@@ -312,130 +376,52 @@ MANAGEMENT (use action field, omit agent/task/chain/tasks):
 
 	};
 
-	const statusTool: ToolDefinition<typeof StatusParams, Details> = {
-		name: "subagent_status",
-		label: "Subagent Status",
-		description: "Inspect async subagent run status and artifacts",
-		parameters: StatusParams,
-
-		async execute(_id, params, _signal, _onUpdate, _ctx) {
-			if (params.action === "list") {
-				try {
-					const runs = listAsyncRuns(ASYNC_DIR, { states: ["queued", "running"] });
-					return {
-						content: [{ type: "text", text: formatAsyncRunList(runs) }],
-						details: { mode: "single", results: [] },
-					};
-				} catch (error) {
-					const message = error instanceof Error ? error.message : String(error);
-					return {
-						content: [{ type: "text", text: message }],
-						isError: true,
-						details: { mode: "single", results: [] },
-					};
-				}
-			}
-
-			let asyncDir: string | null = null;
-			let resolvedId = params.id;
-
-			if (params.dir) {
-				asyncDir = path.resolve(params.dir);
-			} else if (params.id) {
-				const direct = path.join(ASYNC_DIR, params.id);
-				if (fs.existsSync(direct)) {
-					asyncDir = direct;
-				} else {
-					const match = findByPrefix(ASYNC_DIR, params.id);
-					if (match) {
-						asyncDir = match;
-						resolvedId = path.basename(match);
-					}
-				}
-			}
-
-			const resultPath =
-				params.id && !asyncDir ? findByPrefix(RESULTS_DIR, params.id, ".json") : null;
-
-			if (!asyncDir && !resultPath) {
-				return {
-					content: [{ type: "text", text: "Async run not found. Provide id or dir." }],
-					isError: true,
-					details: { mode: "single" as const, results: [] },
-				};
-			}
-
-			if (asyncDir) {
-				let status;
-				try {
-					status = readStatus(asyncDir);
-				} catch (error) {
-					const message = error instanceof Error ? error.message : String(error);
-					return {
-						content: [{ type: "text", text: message }],
-						isError: true,
-						details: { mode: "single" as const, results: [] },
-					};
-				}
-				const logPath = path.join(asyncDir, `subagent-log-${resolvedId ?? "unknown"}.md`);
-				const eventsPath = path.join(asyncDir, "events.jsonl");
-				if (status) {
-					const stepsTotal = status.steps?.length ?? 1;
-					const current = status.currentStep !== undefined ? status.currentStep + 1 : undefined;
-					const stepLine =
-						current !== undefined ? `Step: ${current}/${stepsTotal}` : `Steps: ${stepsTotal}`;
-					const started = new Date(status.startedAt).toISOString();
-					const updated = status.lastUpdate ? new Date(status.lastUpdate).toISOString() : "n/a";
-
-					const lines = [
-						`Run: ${status.runId}`,
-						`State: ${status.state}`,
-						`Mode: ${status.mode}`,
-						stepLine,
-						`Started: ${started}`,
-						`Updated: ${updated}`,
-						`Dir: ${asyncDir}`,
-					];
-					if (status.sessionFile) lines.push(`Session: ${status.sessionFile}`);
-					if (fs.existsSync(logPath)) lines.push(`Log: ${logPath}`);
-					if (fs.existsSync(eventsPath)) lines.push(`Events: ${eventsPath}`);
-
-					return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [] } };
-				}
-			}
-
-			if (resultPath) {
-				try {
-					const raw = fs.readFileSync(resultPath, "utf-8");
-					const data = JSON.parse(raw) as { id?: string; success?: boolean; summary?: string };
-					const status = data.success ? "complete" : "failed";
-					const lines = [`Run: ${data.id ?? params.id}`, `State: ${status}`, `Result: ${resultPath}`];
-					if (data.summary) lines.push("", data.summary);
-					return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [] } };
-				} catch (error) {
-					const message = error instanceof Error ? error.message : String(error);
-					return {
-						content: [{ type: "text", text: `Failed to read async result file: ${message}` }],
-						isError: true,
-						details: { mode: "single" as const, results: [] },
-					};
-				}
-			}
-
-			return {
-				content: [{ type: "text", text: "Status file not found." }],
-				isError: true,
-				details: { mode: "single" as const, results: [] },
-			};
-		},
-	};
-
 	pi.registerTool(tool);
-	pi.registerTool(statusTool);
 	registerSlashCommands(pi, state);
 
-	pi.events.on("subagent:started", handleStarted);
-	pi.events.on("subagent:complete", handleComplete);
+	const eventUnsubscribeStoreKey = "__piSubagentEventUnsubscribes";
+	const controlNoticeSeenStoreKey = "__piSubagentVisibleControlNotices";
+	const globalStore = globalThis as Record<string, unknown>;
+	const previousEventUnsubscribes = globalStore[eventUnsubscribeStoreKey];
+	if (Array.isArray(previousEventUnsubscribes)) {
+		for (const unsubscribe of previousEventUnsubscribes) {
+			if (typeof unsubscribe !== "function") continue;
+			try {
+				unsubscribe();
+			} catch {
+				// Best effort cleanup for stale handlers from an older reload.
+			}
+		}
+	}
+	registerSubagentNotify(pi);
+
+	const existingVisibleControlNotices = globalStore[controlNoticeSeenStoreKey];
+	const visibleControlNotices = existingVisibleControlNotices instanceof Set ? existingVisibleControlNotices as Set<string> : new Set<string>();
+	globalStore[controlNoticeSeenStoreKey] = visibleControlNotices;
+	const controlEventHandler = (payload: unknown) => {
+		const details = payload as SubagentControlMessageDetails;
+		if (!details?.event) return;
+		const childIntercomTarget = controlNoticeTarget(details);
+		const key = controlNotificationKey(details.event, childIntercomTarget);
+		if (visibleControlNotices.has(key)) return;
+		visibleControlNotices.add(key);
+		const noticeText = details.noticeText ?? formatControlNoticeMessage(details.event, childIntercomTarget);
+		pi.sendMessage(
+			{
+				customType: SUBAGENT_CONTROL_MESSAGE_TYPE,
+				content: noticeText,
+				display: true,
+				details: { ...details, childIntercomTarget, noticeText },
+			},
+			{ triggerTurn: true },
+		);
+	};
+	const eventUnsubscribes = [
+		pi.events.on(SUBAGENT_ASYNC_STARTED_EVENT, handleStarted),
+		pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete),
+		pi.events.on(SUBAGENT_CONTROL_EVENT, controlEventHandler),
+	];
+	globalStore[eventUnsubscribeStoreKey] = eventUnsubscribes;
 
 	pi.on("tool_result", (event, ctx) => {
 		if (event.toolName !== "subagent") return;
@@ -471,6 +457,16 @@ MANAGEMENT (use action field, omit agent/task/chain/tasks):
 		resetSessionState(ctx);
 	});
 	pi.on("session_shutdown", () => {
+		for (const unsubscribe of eventUnsubscribes) {
+			try {
+				unsubscribe();
+			} catch {
+				// Best effort cleanup during shutdown.
+			}
+		}
+		if (globalStore[eventUnsubscribeStoreKey] === eventUnsubscribes) {
+			delete globalStore[eventUnsubscribeStoreKey];
+		}
 		stopResultWatcher();
 		if (state.poller) clearInterval(state.poller);
 		state.poller = null;

package/install.mjs

@@ -85,9 +85,8 @@ if (fs.existsSync(EXTENSION_DIR)) {
 }
 
 console.log(`
-The extension is now available in pi. Tools added:
-  • subagent       - Delegate tasks to agents (single, chain, parallel)
-  • subagent_status - Check async run status
+The extension is now available in pi. Tool added:
+  • subagent - Delegate tasks to agents and inspect run status
 
 Documentation: ${EXTENSION_DIR}/README.md
 `);

package/intercom-bridge.ts

@@ -41,6 +41,15 @@ export function resolveIntercomSessionTarget(sessionName: string | undefined, se
 	return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
 }
 
+function sanitizeIntercomTargetPart(value: string): string {
+	return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+
+export function resolveSubagentIntercomTarget(runId: string, agent: string, index?: number): string {
+	const stepSuffix = index !== undefined ? `-${index + 1}` : "";
+	return `subagent-${sanitizeIntercomTargetPart(agent)}-${sanitizeIntercomTargetPart(runId)}${stepSuffix}`;
+}
+
 export function resolveIntercomBridgeMode(value: unknown): IntercomBridgeMode {
 	if (value === "off" || value === "always" || value === "fork-only") return value;
 	return "always";

package/notify.ts

@@ -1,9 +1,10 @@
 /**
- * Subagent completion notifications (extension)
+ * Subagent completion notifications.
  */
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "./types.ts";
 
 interface ChainStepResult {
 	agent: string;
@@ -16,7 +17,8 @@ interface SubagentResult {
 	agent: string | null;
 	success: boolean;
 	summary: string;
-	exitCode: number;
+	exitCode?: number;
+	state?: string;
 	timestamp: number;
 	sessionFile?: string;
 	shareUrl?: string;
@@ -28,6 +30,17 @@ interface SubagentResult {
 }
 
 export default function registerSubagentNotify(pi: ExtensionAPI): void {
+	const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
+	const globalStore = globalThis as Record<string, unknown>;
+	const previousUnsubscribe = globalStore[unsubscribeStoreKey];
+	if (typeof previousUnsubscribe === "function") {
+		try {
+			previousUnsubscribe();
+		} catch {
+			// Best effort cleanup for stale handlers from an older reload.
+		}
+	}
+
 	const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
 	const ttlMs = 10 * 60 * 1000;
 
@@ -38,7 +51,13 @@ export default function registerSubagentNotify(pi: ExtensionAPI): void {
 		if (markSeenWithTtl(seen, key, now, ttlMs)) return;
 
 		const agent = result.agent ?? "unknown";
-		const status = result.success ? "completed" : "failed";
+		const summary = typeof result.summary === "string" ? result.summary : "";
+		const paused = !result.success && (
+			result.exitCode === 0
+			|| result.state === "paused"
+			|| summary.startsWith("Paused after interrupt.")
+		);
+		const status = paused ? "paused" : result.success ? "completed" : "failed";
 
 		const taskInfo =
 			result.taskIndex !== undefined && result.totalTasks !== undefined
@@ -54,11 +73,11 @@ export default function registerSubagentNotify(pi: ExtensionAPI): void {
 			extra.push(`Session file: ${result.sessionFile}`);
 		}
 
-		const summary = result.summary.trim() ? result.summary : "(no output)";
+		const displaySummary = summary.trim() ? summary : "(no output)";
 		const content = [
 			`Background task ${status}: **${agent}**${taskInfo}`,
 			"",
-			summary,
+			displaySummary,
 			extra.length ? "" : undefined,
 			extra.length ? extra.join("\n") : undefined,
 		]
@@ -75,5 +94,5 @@ export default function registerSubagentNotify(pi: ExtensionAPI): void {
 		);
 	};
 
-	pi.events.on("subagent:complete", handleComplete);
+	globalStore[unsubscribeStoreKey] = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.17.4",
+  "version": "0.18.0",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -38,13 +38,11 @@
     "test": "npm run test:unit",
     "test:unit": "node --experimental-strip-types --test test/unit/*.test.ts",
     "test:integration": "node --experimental-transform-types --import ./test/support/register-loader.mjs --test test/integration/*.test.ts",
-    "test:e2e": "node --experimental-transform-types --import ./test/support/register-loader.mjs --test test/e2e/*.test.ts",
-    "test:all": "npm run test:unit && npm run test:integration && npm run test:e2e"
+    "test:all": "npm run test:unit && npm run test:integration"
   },
   "pi": {
     "extensions": [
-      "./index.ts",
-      "./notify.ts"
+      "./index.ts"
     ],
     "skills": [
       "./skills"
@@ -60,7 +58,6 @@
     "typebox": "^1.1.24"
   },
   "devDependencies": {
-    "@marcfargas/pi-test-harness": "^0.5.0",
     "@mariozechner/pi-agent-core": "^0.65.0",
     "@mariozechner/pi-ai": "^0.65.0",
     "@mariozechner/pi-coding-agent": "^0.65.0"

package/pi-args.ts

@@ -23,6 +23,7 @@ export interface BuildPiArgsInput {
 	systemPrompt?: string | null;
 	mcpDirectTools?: string[];
 	promptFileStem?: string;
+	intercomSessionName?: string;
 }
 
 export interface BuildPiArgsResult {
@@ -112,6 +113,9 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	const env: Record<string, string | undefined> = {};
 	env.PI_SUBAGENT_INHERIT_PROJECT_CONTEXT = input.inheritProjectContext ? "1" : "0";
 	env.PI_SUBAGENT_INHERIT_SKILLS = input.inheritSkills ? "1" : "0";
+	if (input.intercomSessionName) {
+		env.PI_SUBAGENT_INTERCOM_SESSION_NAME = input.intercomSessionName;
+	}
 	if (input.mcpDirectTools?.length) {
 		env.MCP_DIRECT_TOOLS = input.mcpDirectTools.join(",");
 	} else {

package/pi-spawn.ts

@@ -83,12 +83,15 @@ export function resolveWindowsPiCliScript(deps: PiSpawnDeps = {}): string | unde
 }
 
 export function getPiSpawnCommand(args: string[], deps: PiSpawnDeps = {}): PiSpawnCommand {
-	const piCliPath = resolveWindowsPiCliScript(deps);
-	if (piCliPath) {
-		return {
-			command: deps.execPath ?? process.execPath,
-			args: [piCliPath, ...args],
-		};
+	const platform = deps.platform ?? process.platform;
+	if (platform === "win32") {
+		const piCliPath = resolveWindowsPiCliScript(deps);
+		if (piCliPath) {
+			return {
+				command: deps.execPath ?? process.execPath,
+				args: [piCliPath, ...args],
+			};
+		}
 	}
 
 	return { command: "pi", args };

package/render.ts

@@ -83,7 +83,7 @@ let lastWidgetHash = "";
 
 function computeWidgetHash(jobs: AsyncJobState[]): string {
 	return jobs.slice(0, MAX_WIDGET_JOBS).map(job =>
-		`${job.asyncId}:${job.status}:${job.currentStep}:${job.updatedAt}:${job.totalTokens?.total ?? 0}`
+		`${job.asyncId}:${job.status}:${job.activityState}:${job.currentStep}:${job.updatedAt}:${job.totalTokens?.total ?? 0}`
 	).join("|");
 }
 
@@ -114,12 +114,16 @@ function getToolCallLines(
 	return result.toolCalls?.map((toolCall) => expanded ? toolCall.expandedText : toolCall.text) ?? [];
 }
 
-function formatActivityLabel(lastActivityAt: number | undefined, now = Date.now()): string | undefined {
-	if (lastActivityAt === undefined) return undefined;
-	const ago = Math.max(0, now - lastActivityAt);
-	if (ago < 1000) return "active now";
-	if (ago < 60000) return `active ${Math.floor(ago / 1000)}s ago`;
-	return `active ${Math.floor(ago / 60000)}m ago`;
+function formatActivityAge(ms: number): string {
+	if (ms < 1000) return "now";
+	if (ms < 60000) return `${Math.floor(ms / 1000)}s`;
+	return `${Math.floor(ms / 60000)}m`;
+}
+
+function formatActivityLabel(lastActivityAt: number | undefined, needsAttention?: boolean, now = Date.now()): string | undefined {
+	if (lastActivityAt === undefined) return needsAttention ? "needs attention" : undefined;
+	const age = formatActivityAge(Math.max(0, now - lastActivityAt));
+	return needsAttention ? `no activity for ${age}` : age === "now" ? "active now" : `active ${age} ago`;
 }
 
 function formatCurrentToolLine(progress: Pick<AgentProgress, "currentTool" | "currentToolArgs" | "currentToolStartedAt">, availableWidth: number, expanded: boolean): string | undefined {
@@ -138,8 +142,8 @@ function formatCurrentToolLine(progress: Pick<AgentProgress, "currentTool" | "cu
 		: `${progress.currentTool}${durationSuffix}`;
 }
 
-function buildLiveStatusLine(progress: Pick<AgentProgress, "lastActivityAt">): string | undefined {
-	return formatActivityLabel(progress.lastActivityAt);
+function buildLiveStatusLine(progress: Pick<AgentProgress, "activityState" | "lastActivityAt">): string | undefined {
+	return formatActivityLabel(progress.lastActivityAt, progress.activityState === "needs_attention");
 }
 
 /**
@@ -175,7 +179,9 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 				? theme.fg("success", "complete")
 				: job.status === "failed"
 					? theme.fg("error", "failed")
-					: theme.fg("warning", "running");
+					: job.status === "paused"
+						? theme.fg("warning", "paused")
+						: theme.fg("warning", "running");
 
 		const stepsTotal = job.stepsTotal ?? (job.agents?.length ?? 1);
 		const stepIndex = job.currentStep !== undefined ? job.currentStep + 1 : undefined;
@@ -185,12 +191,14 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 		const agentLabel = job.agents ? job.agents.join(" -> ") : (job.mode ?? "single");
 
 		const tokenText = job.totalTokens ? ` | ${formatTokens(job.totalTokens.total)} tok` : "";
-		const activityText = job.status === "running" ? getLastActivity(job.outputFile) : "";
+		const activityText = job.currentTool && job.currentToolStartedAt
+			? `tool ${job.currentTool} ${formatDuration(Math.max(0, Date.now() - job.currentToolStartedAt))}`
+			: formatActivityLabel(job.lastActivityAt, job.activityState === "needs_attention") ?? (job.status === "running" ? getLastActivity(job.outputFile) : "");
 		const activitySuffix = activityText ? ` | ${theme.fg("dim", activityText)}` : "";
 
 		lines.push(truncLine(`- ${id} ${status} | ${agentLabel} | ${stepText}${elapsed ? ` | ${elapsed}` : ""}${tokenText}${activitySuffix}`, w));
 
-		if (job.status === "running" && job.outputFile) {
+		if ((job.status === "running" || job.status === "paused") && job.outputFile) {
 			const tail = getOutputTail(job.outputFile, 3);
 			for (const line of tail) {
 				lines.push(truncLine(theme.fg("dim", `  > ${line}`), w));

package/result-watcher.ts

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.js";
 import { createFileCoalescer } from "./file-coalescer.js";
-import type { SubagentState } from "./types.js";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, type SubagentState } from "./types.js";
 
 function isNotFoundError(error: unknown): boolean {
 	return typeof error === "object"
@@ -36,13 +36,11 @@ export function createResultWatcher(
 			const now = Date.now();
 			const completionKey = buildCompletionKey(data, `result:${file}`);
 			if (markSeenWithTtl(state.completionSeen, completionKey, now, completionTtlMs)) {
-				try {
-					fs.unlinkSync(resultPath);
-				} catch {}
+				fs.unlinkSync(resultPath);
 				return;
 			}
 
-			pi.events.emit("subagent:complete", data);
+			pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, data);
 			fs.unlinkSync(resultPath);
 		} catch (error) {
 			if (isNotFoundError(error)) return;