pi-subagents 0.17.4 → 0.18.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [0.18.0] - 2026-04-23
+
+### Added
+- Added subagent control notifications so `needs_attention` signals push structured parent events, persist async control events to `events.jsonl`, show visible transcript notices for the user and parent agent, include proactive `nudge`/`status`/`interrupt` commands when a child appears blocked, and show each visible notice at most once per child run and attention state.
+- Added stable child intercom session names for controlled subagents so needs-attention pings can tell the orchestrator which agent needs attention and how to message it when intercom is available.
+
+### Changed
+- Replaced the unreleased `starting`/`active`/`quiet`/`stalled`/`paused` activity labels with factual activity reporting and a single `needs_attention` control signal, keeping `paused` as lifecycle state only.
+- Added `subagent({ action: "status", id })` and `subagent({ action: "status" })` as the control-surface status checks, replacing the separate `subagent_status(...)` tool.
+- Adjusted bundled agent defaults: most builtins now use `openai-codex/gpt-5.5`, while `scout` uses `openai-codex/gpt-5.4-mini`.
+- Removed the incomplete e2e suite and stale `@marcfargas/pi-test-harness` dev dependency; `test:all` now runs the maintained unit and integration suites.
+
+### Fixed
+- Paused async runs now render `Background task paused` notifications instead of failed/completed copy, including after extension reloads with stale legacy listeners still present.
+- Async status output no longer shows stale activity-age lines for paused or completed runs.
+
+## [0.17.5] - 2026-04-23
+
+### Added
+- Added subagent control activity state for foreground and async runs, including `starting`/`active`/`quiet`/`stalled`/`paused` tracking, compact stalled/recovered/paused control events, and an in-tool `action: "interrupt"` soft interrupt that pauses the current child turn without adding another top-level tool.
+
+### Changed
+- Updated bundled agents to use `openai-codex/gpt-5.5` defaults, with `scout` on `openai-codex/gpt-5.5-mini` and `oracle-executor` on `openai-codex/gpt-5.5:xhigh`.
+
+### Fixed
+- Async/background status token reporting now falls back to in-memory model-attempt usage when detached runs do not produce session `.jsonl` files, which also preserves token totals across model fallback retries.
+- Non-Windows subagent launches now use plain `pi` again instead of reusing the current CLI script path, avoiding runs that get confused by installed `dist/cli.js` entrypoints.
+
 ## [0.17.4] - 2026-04-22
 
 ### Added

package/README.md

@@ -48,8 +48,8 @@ Use `agentScope` parameter to control discovery: `"user"`, `"project"`, or `"bot
 
 **Builtin agents:** The extension ships with ready-to-use agents — `scout`, `planner`, `worker`, `reviewer`, `context-builder`, `researcher`, `delegate`, `oracle`, and `oracle-executor`. They load at lowest priority so any user or project agent with the same name overrides them.
 
-- `oracle` is a high-context advisory reviewer on `openai-codex/gpt-5.4:high`. It critiques direction, surfaces hidden risks, and proposes a concrete execution prompt, but it does not edit files directly.
-- `oracle-executor` is a high-context implementation escalator on `openai-codex/gpt-5.3-codex:high`. It is intended to run only after the main agent explicitly approves a course of action.
+- `oracle` is a high-context advisory reviewer on `openai-codex/gpt-5.5`. It critiques direction, surfaces hidden risks, and proposes a concrete execution prompt, but it does not edit files directly.
+- `oracle-executor` is a high-context implementation escalator on `openai-codex/gpt-5.5`. It is intended to run only after the main agent explicitly approves a course of action.
 
 You can also override selected builtin fields without copying the whole agent. Builtin overrides are stored in settings under `subagents.agentOverrides`:
 
@@ -285,7 +285,7 @@ Add `--bg` at the end of any slash command to run in the background:
 /parallel scout "scan frontend" -> scout "scan backend" -> scout "scan infra" --bg
 ```
 
-Without `--bg`, the run is foreground: the tool call stays active and streams progress until completion. With `--bg`, the run is launched asynchronously: control returns immediately, and completion arrives later via notification. In both cases subagents run as separate processes. Check status with the `subagent_status` tool, or open the `/subagents-status` slash command for a read-only overlay listing active runs and recent completions.
+Without `--bg`, the run is foreground: the tool call stays active and streams progress until completion. With `--bg`, the run is launched asynchronously: control returns immediately, and completion arrives later via notification. In both cases subagents run as separate processes. Check status with `subagent({ action: "status", id })`, or open the `/subagents-status` slash command for a read-only overlay listing active runs and recent completions.
 
 ### Forked Context Execution
 
@@ -649,16 +649,16 @@ These are the parameters the **LLM agent** passes when it calls the `subagent` t
 ], clarify: false, async: true }
 ```
 
-**subagent_status tool:**
+**Programmatic status:**
 ```typescript
-{ action: "list" }                    // active async runs only
-{ id: "a53ebe46" }                    // inspect one run
-{ dir: "<tmpdir>/pi-subagents-<scope>/async-subagent-runs/a53ebe46-..." }
+subagent({ action: "status" })                    // active async runs only
+subagent({ action: "status", id: "a53ebe46" })    // inspect one run
+subagent({ action: "status", dir: "<tmpdir>/pi-subagents-<scope>/async-subagent-runs/a53ebe46-..." })
 ```
 
 **/subagents-status slash command:**
 
-Opens a small read-only overlay that shows active async runs plus recent completed/failed runs. It auto-refreshes every 2 seconds while open, keeps the current run selected when possible, and uses `↑↓` to select a run plus `Esc` to close.
+Opens a small read-only overlay that shows active async runs plus recent completed, failed, and paused runs. It auto-refreshes every 2 seconds while open, keeps the current run selected when possible, and uses `↑↓` to select a run plus `Esc` to close.
 
 ## Management Actions
 
@@ -798,11 +798,12 @@ Fallbacks are inherited from the selected agent for that step. There is no per-s
 
 Fallbacks are inherited from the selected agent for that task. There is no per-task `fallbackModels` override in v1.
 
-Status tool:
+Status commands:
 
-| Tool | Description |
+| Command | Description |
 |------|-------------|
-| `subagent_status` | List active async runs or inspect one run by id or dir |
+| `subagent({ action: "status" })` | List active async runs |
+| `subagent({ action: "status", id })` | Inspect a foreground or async run by id or prefix |
 
 ## Worktree Isolation
 
@@ -1167,20 +1168,20 @@ When fallback is used in async/background mode, `status.json` and the final resu
 For programmatic access:
 
 ```typescript
-subagent_status({ action: "list" })
-subagent_status({ id: "<id>" })
-subagent_status({ dir: "<tmpdir>/pi-subagents-<scope>/async-subagent-runs/<id>" })
+subagent({ action: "status" })
+subagent({ action: "status", id: "<id>" })
+subagent({ action: "status", dir: "<tmpdir>/pi-subagents-<scope>/async-subagent-runs/<id>" })
 ```
 
-For an interactive overview, run the `/subagents-status` slash command to open the overlay listing active runs and recent completed/failed runs. The overlay auto-refreshes every 2 seconds while it is open and focuses on summary/status information, including the current output/session paths when available.
+For an interactive overview, run the `/subagents-status` slash command to open the overlay listing active runs and recent completed, failed, and paused runs. The overlay auto-refreshes every 2 seconds while it is open and focuses on summary/status information, including the current output/session paths when available.
 
 ## Events
 
 Async events:
-- `subagent:started`
-- `subagent:complete`
+- `subagent:async-started`
+- `subagent:async-complete`
 
-`notify.ts` consumes `subagent:complete` as the canonical completion channel.
+The result watcher emits `subagent:async-complete`; `index.ts` registers the notification handler that consumes it.
 
 ## Files
 
@@ -1227,7 +1228,6 @@ Async events:
 ├── run-history.ts                # Per-agent run recording (JSONL)
 ├── test/unit/                    # Fast unit tests for pure modules
 ├── test/integration/             # Loader-based execution/integration tests
-├── test/e2e/                     # End-to-end sandbox tests
 ├── test/support/                 # Shared test loader, helpers, and mock pi harness
 └── text-editor.ts                # Shared text editor (word nav, paste)
 ```

package/agents/context-builder.md

@@ -2,7 +2,7 @@
 name: context-builder
 description: Analyzes requirements and codebase, generates context and meta-prompt
 tools: read, grep, find, ls, bash, write, web_search
-model: openai-codex/gpt-5.4
+model: openai-codex/gpt-5.5
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/agents/oracle-executor.md

@@ -2,7 +2,7 @@
 name: oracle-executor
 description: High-context implementation agent that executes only after main-agent approval
 tools: read, grep, find, ls, bash, edit, write, intercom
-model: openai-codex/gpt-5.3-codex
+model: openai-codex/gpt-5.5
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true

package/agents/oracle.md

@@ -2,7 +2,7 @@
 name: oracle
 description: High-context decision-consistency oracle that protects inherited state and prevents drift
 tools: read, grep, find, ls, bash, intercom
-model: openai-codex/gpt-5.4
+model: openai-codex/gpt-5.5
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true

package/agents/planner.md

@@ -2,7 +2,7 @@
 name: planner
 description: Creates implementation plans from context and requirements
 tools: read, grep, find, ls, write
-model: openai-codex/gpt-5.4
+model: openai-codex/gpt-5.5
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true

package/agents/researcher.md

@@ -2,7 +2,7 @@
 name: researcher
 description: Autonomous web researcher — searches, evaluates, and synthesizes a focused research brief
 tools: read, write, web_search, fetch_content, get_search_content
-model: openai-codex/gpt-5.4
+model: openai-codex/gpt-5.5
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/agents/reviewer.md

@@ -2,7 +2,7 @@
 name: reviewer
 description: Code review specialist that validates implementation and fixes issues
 tools: read, grep, find, ls, bash, edit, write
-model: openai-codex/gpt-5.3-codex
+model: openai-codex/gpt-5.5
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true

package/agents/worker.md

@@ -1,7 +1,7 @@
 ---
 name: worker
 description: General-purpose subagent with full capabilities
-model: openai-codex/gpt-5.4
+model: openai-codex/gpt-5.5
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/async-execution.ts

@@ -22,8 +22,10 @@ import {
 	type ArtifactConfig,
 	type Details,
 	type MaxOutputConfig,
+	type ResolvedControlConfig,
 	ASYNC_DIR,
 	RESULTS_DIR,
+	SUBAGENT_ASYNC_STARTED_EVENT,
 	TEMP_ROOT_DIR,
 	getAsyncConfigPath,
 	resolveChildMaxSubagentDepth,
@@ -75,6 +77,9 @@ export interface AsyncChainParams {
 	maxSubagentDepth: number;
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
+	controlConfig?: ResolvedControlConfig;
+	controlIntercomTarget?: string;
+	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 }
 
 export interface AsyncSingleParams {
@@ -96,6 +101,9 @@ export interface AsyncSingleParams {
 	maxSubagentDepth: number;
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
+	controlConfig?: ResolvedControlConfig;
+	controlIntercomTarget?: string;
+	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 }
 
 export interface AsyncExecutionResult {
@@ -178,6 +186,9 @@ export function executeAsyncChain(
 		maxSubagentDepth,
 		worktreeSetupHook,
 		worktreeSetupHookTimeoutMs,
+		controlConfig,
+		controlIntercomTarget,
+		childIntercomTarget,
 	} = params;
 	const chainSkills = params.chainSkills ?? [];
 	const availableModels = params.availableModels;
@@ -276,6 +287,13 @@ export function executeAsyncChain(
 		}
 		return buildSeqStep(s as SequentialStep, nextSessionFile());
 	});
+	let childTargetIndex = 0;
+	const childIntercomTargets = childIntercomTarget ? steps.flatMap((step) => {
+		if ("parallel" in step) {
+			return step.parallel.map((task) => childIntercomTarget(task.agent, childTargetIndex++));
+		}
+		return [childIntercomTarget(step.agent, childTargetIndex++)];
+	}) : undefined;
 
 	let spawnResult: { pid?: number; error?: string } = {};
 	try {
@@ -297,6 +315,9 @@ export function executeAsyncChain(
 				piArgv1: process.argv[1],
 				worktreeSetupHook,
 				worktreeSetupHookTimeoutMs,
+				controlConfig,
+				controlIntercomTarget,
+				childIntercomTargets,
 			},
 			id,
 			runnerCwd,
@@ -315,7 +336,7 @@ export function executeAsyncChain(
 		const firstAgents = isParallelStep(firstStep)
 			? firstStep.parallel.map((t) => t.agent)
 			: [(firstStep as SequentialStep).agent];
-		ctx.pi.events.emit("subagent:started", {
+		ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
 			id,
 			pid: spawnResult.pid,
 			agent: firstAgents[0],
@@ -364,6 +385,9 @@ export function executeAsyncSingle(
 		maxSubagentDepth,
 		worktreeSetupHook,
 		worktreeSetupHookTimeoutMs,
+		controlConfig,
+		controlIntercomTarget,
+		childIntercomTarget,
 	} = params;
 	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
 	const skillNames = params.skills ?? agentConfig.skills ?? [];
@@ -430,6 +454,9 @@ export function executeAsyncSingle(
 				piArgv1: process.argv[1],
 				worktreeSetupHook,
 				worktreeSetupHookTimeoutMs,
+				controlConfig,
+				controlIntercomTarget,
+				childIntercomTargets: childIntercomTarget ? [childIntercomTarget(agent, 0)] : undefined,
 			},
 			id,
 			runnerCwd,
@@ -444,7 +471,7 @@ export function executeAsyncSingle(
 	}
 
 	if (spawnResult.pid) {
-		ctx.pi.events.emit("subagent:started", {
+		ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
 			id,
 			pid: spawnResult.pid,
 			agent,

package/async-job-tracker.ts

@@ -1,9 +1,15 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import { renderWidget } from "./render.ts";
+import { formatControlNoticeMessage } from "./subagent-control.ts";
 import {
+	type AsyncJobState,
+	type ControlEvent,
 	type SubagentState,
 	POLL_INTERVAL_MS,
+	SUBAGENT_CONTROL_EVENT,
+	SUBAGENT_CONTROL_INTERCOM_EVENT,
 } from "./types.ts";
 import { readStatus } from "./utils.ts";
 
@@ -12,7 +18,7 @@ interface AsyncJobTrackerOptions {
 	pollIntervalMs?: number;
 }
 
-export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string, options: AsyncJobTrackerOptions = {}): {
+export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: SubagentState, asyncDirRoot: string, options: AsyncJobTrackerOptions = {}): {
 	ensurePoller: () => void;
 	handleStarted: (data: unknown) => void;
 	handleComplete: (data: unknown) => void;
@@ -36,13 +42,67 @@ export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string
 		}, completionRetentionMs);
 		state.cleanupTimers.set(asyncId, timer);
 	};
+	const emitNewControlEvents = (job: AsyncJobState) => {
+		const eventsPath = path.join(job.asyncDir, "events.jsonl");
+		let fd: number;
+		try {
+			fd = fs.openSync(eventsPath, "r");
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+			console.error(`Failed to open async control events for '${job.asyncDir}':`, error);
+			return;
+		}
+		try {
+			const stat = fs.fstatSync(fd);
+			const cursor = stat.size < (job.controlEventCursor ?? 0) ? 0 : (job.controlEventCursor ?? 0);
+			if (stat.size <= cursor) return;
+			const buffer = Buffer.alloc(stat.size - cursor);
+			fs.readSync(fd, buffer, 0, buffer.length, cursor);
+			const lastNewline = buffer.lastIndexOf(0x0a);
+			if (lastNewline === -1) return;
+			job.controlEventCursor = cursor + lastNewline + 1;
+			for (const line of buffer.subarray(0, lastNewline).toString("utf-8").split("\n")) {
+				if (!line.trim()) continue;
+				let parsed: unknown;
+				try {
+					parsed = JSON.parse(line);
+				} catch {
+					// Ignore malformed completed records but keep the poller alive for later events.
+					continue;
+				}
+				if (!parsed || typeof parsed !== "object" || (parsed as { type?: unknown }).type !== "subagent.control") continue;
+				const record = parsed as { event?: ControlEvent; channels?: string[]; childIntercomTarget?: string; noticeText?: string; intercom?: { to?: string; message?: string } };
+				if (!record.event || !Array.isArray(record.channels)) continue;
+				const payload = {
+					event: record.event,
+					source: "async" as const,
+					asyncDir: job.asyncDir,
+					childIntercomTarget: record.childIntercomTarget,
+					noticeText: record.noticeText ?? formatControlNoticeMessage(record.event, record.childIntercomTarget),
+				};
+				if (record.channels.includes("event")) {
+					pi.events.emit(SUBAGENT_CONTROL_EVENT, payload);
+				}
+				if (record.channels.includes("intercom") && record.intercom?.to && record.intercom.message) {
+					pi.events.emit(SUBAGENT_CONTROL_INTERCOM_EVENT, {
+						...payload,
+						to: record.intercom.to,
+						message: record.intercom.message,
+					});
+				}
+			}
+		} catch (error) {
+			console.error(`Failed to read async control events for '${job.asyncDir}':`, error);
+		} finally {
+			fs.closeSync(fd);
+		}
+	};
 
 	const ensurePoller = () => {
 		if (state.poller) return;
 		state.poller = setInterval(() => {
-			if (!state.lastUiContext || !state.lastUiContext.hasUI) return;
 			if (state.asyncJobs.size === 0) {
-				rerenderWidget(state.lastUiContext, []);
+				if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext, []);
 				if (state.poller) {
 					clearInterval(state.poller);
 					state.poller = null;
@@ -52,10 +112,15 @@ export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string
 
 			for (const job of state.asyncJobs.values()) {
 				try {
+					emitNewControlEvents(job);
 					const status = readStatus(job.asyncDir);
 					if (status) {
 						const previousStatus = job.status;
 						job.status = status.state;
+						job.activityState = status.activityState;
+						job.lastActivityAt = status.lastActivityAt ?? job.lastActivityAt;
+						job.currentTool = status.currentTool ?? job.currentTool;
+						job.currentToolStartedAt = status.currentToolStartedAt ?? job.currentToolStartedAt;
 						job.mode = status.mode;
 						job.currentStep = status.currentStep ?? job.currentStep;
 						job.stepsTotal = status.steps?.length ?? job.stepsTotal;
@@ -68,7 +133,7 @@ export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string
 						job.outputFile = status.outputFile ?? job.outputFile;
 						job.totalTokens = status.totalTokens ?? job.totalTokens;
 						job.sessionFile = status.sessionFile ?? job.sessionFile;
-						if ((job.status === "complete" || job.status === "failed") && previousStatus !== job.status) {
+						if ((job.status === "complete" || job.status === "failed" || job.status === "paused") && previousStatus !== job.status) {
 							scheduleCleanup(job.asyncId);
 						}
 						continue;
@@ -82,7 +147,7 @@ export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string
 				}
 			}
 
-			rerenderWidget(state.lastUiContext);
+			if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext);
 		}, pollIntervalMs);
 		state.poller.unref?.();
 	};
@@ -108,9 +173,9 @@ export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string
 			startedAt: now,
 			updatedAt: now,
 		});
+		ensurePoller();
 		if (state.lastUiContext) {
 			rerenderWidget(state.lastUiContext);
-			ensurePoller();
 		}
 	};
 
@@ -136,6 +201,8 @@ export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string
 		}
 		state.cleanupTimers.clear();
 		state.asyncJobs.clear();
+		state.foregroundControls?.clear();
+		state.lastForegroundControlId = null;
 		state.resultFileCoalescer.clear();
 		if (ctx?.hasUI) {
 			state.lastUiContext = ctx;

package/async-status.ts

@@ -1,13 +1,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { formatDuration, formatTokens, shortenPath } from "./formatters.ts";
-import { type AsyncStatus, type TokenUsage } from "./types.ts";
+import { type ActivityState, type AsyncStatus, type TokenUsage } from "./types.ts";
+import { DEFAULT_CONTROL_CONFIG, deriveActivityState } from "./subagent-control.ts";
 import { readStatus } from "./utils.ts";
 
 export interface AsyncRunStepSummary {
 	index: number;
 	agent: string;
 	status: string;
+	activityState?: ActivityState;
+	lastActivityAt?: number;
+	currentTool?: string;
+	currentToolStartedAt?: number;
 	durationMs?: number;
 	tokens?: TokenUsage;
 	skills?: string[];
@@ -19,7 +24,11 @@ export interface AsyncRunStepSummary {
 export interface AsyncRunSummary {
 	id: string;
 	asyncDir: string;
-	state: "queued" | "running" | "complete" | "failed";
+	state: "queued" | "running" | "complete" | "failed" | "paused";
+	activityState?: ActivityState;
+	lastActivityAt?: number;
+	currentTool?: string;
+	currentToolStartedAt?: number;
 	mode: "single" | "chain";
 	cwd?: string;
 	startedAt: number;
@@ -66,28 +75,65 @@ function isAsyncRunDir(root: string, entry: string): boolean {
 	}
 }
 
+function outputFileMtime(outputFile: string | undefined): number | undefined {
+	if (!outputFile) return undefined;
+	try {
+		return fs.statSync(outputFile).mtimeMs;
+	} catch {
+		return undefined;
+	}
+}
+
+function deriveAsyncActivityState(asyncDir: string, status: AsyncStatus): { activityState?: ActivityState; lastActivityAt?: number } {
+	if (status.state !== "running") return { activityState: status.activityState, lastActivityAt: status.lastActivityAt };
+	const outputPath = status.outputFile ? (path.isAbsolute(status.outputFile) ? status.outputFile : path.join(asyncDir, status.outputFile)) : undefined;
+	const currentStep = typeof status.currentStep === "number" ? status.steps?.[status.currentStep] : undefined;
+	const lastActivityAt = status.lastActivityAt ?? outputFileMtime(outputPath) ?? currentStep?.lastActivityAt ?? currentStep?.startedAt ?? status.startedAt;
+	return {
+		lastActivityAt,
+		activityState: status.activityState ?? deriveActivityState({
+			config: DEFAULT_CONTROL_CONFIG,
+			startedAt: status.startedAt,
+			lastActivityAt,
+		}),
+	};
+}
+
 function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string }): AsyncRunSummary {
+	const { activityState, lastActivityAt } = deriveAsyncActivityState(asyncDir, status);
 	return {
 		id: status.runId || path.basename(asyncDir),
 		asyncDir,
 		state: status.state,
+		activityState,
+		lastActivityAt,
+		currentTool: status.currentTool,
+		currentToolStartedAt: status.currentToolStartedAt,
 		mode: status.mode,
 		cwd: status.cwd,
 		startedAt: status.startedAt,
 		lastUpdate: status.lastUpdate,
 		endedAt: status.endedAt,
 		currentStep: status.currentStep,
-		steps: (status.steps ?? []).map((step, index) => ({
-			index,
-			agent: step.agent,
-			status: step.status,
-			...(step.durationMs !== undefined ? { durationMs: step.durationMs } : {}),
-			...(step.tokens ? { tokens: step.tokens } : {}),
-			...(step.skills ? { skills: step.skills } : {}),
-			...(step.model ? { model: step.model } : {}),
-			...(step.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
-			...(step.error ? { error: step.error } : {}),
-		})),
+		steps: (status.steps ?? []).map((step, index) => {
+			const stepActivityState = step.activityState ?? (step.status === "running" ? activityState : undefined);
+			const stepLastActivityAt = step.lastActivityAt ?? (step.status === "running" ? lastActivityAt : undefined);
+			return {
+				index,
+				agent: step.agent,
+				status: step.status,
+				...(stepActivityState ? { activityState: stepActivityState } : {}),
+				...(stepLastActivityAt ? { lastActivityAt: stepLastActivityAt } : {}),
+				...(step.currentTool ? { currentTool: step.currentTool } : {}),
+				...(step.currentToolStartedAt ? { currentToolStartedAt: step.currentToolStartedAt } : {}),
+				...(step.durationMs !== undefined ? { durationMs: step.durationMs } : {}),
+				...(step.tokens ? { tokens: step.tokens } : {}),
+				...(step.skills ? { skills: step.skills } : {}),
+				...(step.model ? { model: step.model } : {}),
+				...(step.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
+				...(step.error ? { error: step.error } : {}),
+			};
+		}),
 		...(status.sessionDir ? { sessionDir: status.sessionDir } : {}),
 		...(status.outputFile ? { outputFile: status.outputFile } : {}),
 		...(status.totalTokens ? { totalTokens: status.totalTokens } : {}),
@@ -100,8 +146,9 @@ function sortRuns(runs: AsyncRunSummary[]): AsyncRunSummary[] {
 		switch (state) {
 			case "running": return 0;
 			case "queued": return 1;
-			case "failed": return 2;
-			case "complete": return 3;
+		case "failed": return 2;
+		case "paused": return 2;
+		case "complete": return 3;
 		}
 	};
 	return [...runs].sort((a, b) => {
@@ -142,7 +189,7 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 export function listAsyncRunsForOverlay(asyncDirRoot: string, recentLimit = 5): AsyncRunOverlayData {
 	const all = listAsyncRuns(asyncDirRoot);
 	const recent = all
-		.filter((run) => run.state === "complete" || run.state === "failed")
+		.filter((run) => run.state === "complete" || run.state === "failed" || run.state === "paused")
 		.sort((a, b) => (b.lastUpdate ?? b.endedAt ?? b.startedAt) - (a.lastUpdate ?? a.endedAt ?? a.startedAt))
 		.slice(0, recentLimit);
 	return {
@@ -151,8 +198,17 @@ export function listAsyncRunsForOverlay(asyncDirRoot: string, recentLimit = 5):
 	};
 }
 
+function formatActivityFacts(input: { activityState?: ActivityState; lastActivityAt?: number; currentTool?: string; currentToolStartedAt?: number }): string | undefined {
+	if (input.currentTool && input.currentToolStartedAt) return `tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`;
+	if (!input.lastActivityAt) return input.activityState === "needs_attention" ? "needs attention" : undefined;
+	const elapsed = formatDuration(Math.max(0, Date.now() - input.lastActivityAt));
+	return input.activityState === "needs_attention" ? `no activity for ${elapsed}` : `active ${elapsed} ago`;
+}
+
 function formatStepLine(step: AsyncRunStepSummary): string {
 	const parts = [`${step.index + 1}. ${step.agent}`, step.status];
+	const activity = formatActivityFacts(step);
+	if (activity) parts.push(activity);
 	if (step.model) parts.push(step.model);
 	if (step.durationMs !== undefined) parts.push(formatDuration(step.durationMs));
 	if (step.tokens) parts.push(`${formatTokens(step.tokens.total)} tok`);
@@ -163,7 +219,8 @@ function formatRunHeader(run: AsyncRunSummary): string {
 	const stepCount = run.steps.length || 1;
 	const stepLabel = run.currentStep !== undefined ? `step ${run.currentStep + 1}/${stepCount}` : `steps ${stepCount}`;
 	const cwd = run.cwd ? shortenPath(run.cwd) : shortenPath(run.asyncDir);
-	return `${run.id} | ${run.state} | ${run.mode} | ${stepLabel} | ${cwd}`;
+	const activity = formatActivityFacts(run);
+	return `${run.id} | ${run.state}${activity ? ` | ${activity}` : ""} | ${run.mode} | ${stepLabel} | ${cwd}`;
 }
 
 export function formatAsyncRunList(runs: AsyncRunSummary[], heading = "Active async runs"): string {