pi-subagents 0.17.5 → 0.18.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [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

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/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.5:xhigh
+model: openai-codex/gpt-5.5
 thinking: high
 systemPromptMode: replace
 inheritProjectContext: true

package/agents/scout.md

@@ -2,7 +2,7 @@
 name: scout
 description: Fast codebase recon that returns compressed context for handoff
 tools: read, grep, find, ls, bash, write
-model: openai-codex/gpt-5.5-mini
+model: openai-codex/gpt-5.4-mini
 systemPromptMode: replace
 inheritProjectContext: true
 inheritSkills: false

package/async-execution.ts

@@ -25,6 +25,7 @@ import {
 	type ResolvedControlConfig,
 	ASYNC_DIR,
 	RESULTS_DIR,
+	SUBAGENT_ASYNC_STARTED_EVENT,
 	TEMP_ROOT_DIR,
 	getAsyncConfigPath,
 	resolveChildMaxSubagentDepth,
@@ -77,6 +78,8 @@ export interface AsyncChainParams {
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
 	controlConfig?: ResolvedControlConfig;
+	controlIntercomTarget?: string;
+	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 }
 
 export interface AsyncSingleParams {
@@ -99,6 +102,8 @@ export interface AsyncSingleParams {
 	worktreeSetupHook?: string;
 	worktreeSetupHookTimeoutMs?: number;
 	controlConfig?: ResolvedControlConfig;
+	controlIntercomTarget?: string;
+	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 }
 
 export interface AsyncExecutionResult {
@@ -182,6 +187,8 @@ export function executeAsyncChain(
 		worktreeSetupHook,
 		worktreeSetupHookTimeoutMs,
 		controlConfig,
+		controlIntercomTarget,
+		childIntercomTarget,
 	} = params;
 	const chainSkills = params.chainSkills ?? [];
 	const availableModels = params.availableModels;
@@ -280,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 {
@@ -302,6 +316,8 @@ export function executeAsyncChain(
 				worktreeSetupHook,
 				worktreeSetupHookTimeoutMs,
 				controlConfig,
+				controlIntercomTarget,
+				childIntercomTargets,
 			},
 			id,
 			runnerCwd,
@@ -320,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],
@@ -370,6 +386,8 @@ export function executeAsyncSingle(
 		worktreeSetupHook,
 		worktreeSetupHookTimeoutMs,
 		controlConfig,
+		controlIntercomTarget,
+		childIntercomTarget,
 	} = params;
 	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
 	const skillNames = params.skills ?? agentConfig.skills ?? [];
@@ -437,6 +455,8 @@ export function executeAsyncSingle(
 				worktreeSetupHook,
 				worktreeSetupHookTimeoutMs,
 				controlConfig,
+				controlIntercomTarget,
+				childIntercomTargets: childIntercomTarget ? [childIntercomTarget(agent, 0)] : undefined,
 			},
 			id,
 			runnerCwd,
@@ -451,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,11 +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;
@@ -83,7 +147,7 @@ export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string
 				}
 			}
 
-			rerenderWidget(state.lastUiContext);
+			if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext);
 		}, pollIntervalMs);
 		state.poller.unref?.();
 	};
@@ -103,16 +167,15 @@ export function createAsyncJobTracker(state: SubagentState, asyncDirRoot: string
 			asyncId: info.id,
 			asyncDir,
 			status: "queued",
-			activityState: "starting",
 			mode: info.chain ? "chain" : "single",
 			agents,
 			stepsTotal: agents?.length,
 			startedAt: now,
 			updatedAt: now,
 		});
+		ensurePoller();
 		if (state.lastUiContext) {
 			rerenderWidget(state.lastUiContext);
-			ensurePoller();
 		}
 	};
 

package/async-status.ts

@@ -10,6 +10,9 @@ export interface AsyncRunStepSummary {
 	agent: string;
 	status: string;
 	activityState?: ActivityState;
+	lastActivityAt?: number;
+	currentTool?: string;
+	currentToolStartedAt?: number;
 	durationMs?: number;
 	tokens?: TokenUsage;
 	skills?: string[];
@@ -23,6 +26,9 @@ export interface AsyncRunSummary {
 	asyncDir: string;
 	state: "queued" | "running" | "complete" | "failed" | "paused";
 	activityState?: ActivityState;
+	lastActivityAt?: number;
+	currentTool?: string;
+	currentToolStartedAt?: number;
 	mode: "single" | "chain";
 	cwd?: string;
 	startedAt: number;
@@ -78,27 +84,31 @@ function outputFileMtime(outputFile: string | undefined): number | undefined {
 	}
 }
 
-function deriveAsyncActivityState(asyncDir: string, status: AsyncStatus): ActivityState | undefined {
-	if (status.state === "paused") return "paused";
-	if (status.state !== "running") return status.activityState;
+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 lastActivityAt = outputFileMtime(outputPath) ?? status.lastUpdate;
-	return deriveActivityState({
-		config: DEFAULT_CONTROL_CONFIG,
-		startedAt: status.startedAt,
+	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,
-		hasSeenActivity: Boolean(lastActivityAt),
-		paused: false,
-	});
+		activityState: status.activityState ?? deriveActivityState({
+			config: DEFAULT_CONTROL_CONFIG,
+			startedAt: status.startedAt,
+			lastActivityAt,
+		}),
+	};
 }
 
 function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string }): AsyncRunSummary {
-	const activityState = deriveAsyncActivityState(asyncDir, status);
+	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,
@@ -107,11 +117,15 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 		currentStep: status.currentStep,
 		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 } : {}),
@@ -184,9 +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 state = step.activityState ? `${step.status}/${step.activityState}` : step.status;
-	const parts = [`${step.index + 1}. ${step.agent}`, state];
+	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`);
@@ -197,8 +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);
-	const state = run.activityState ? `${run.state}/${run.activityState}` : run.state;
-	return `${run.id} | ${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 {

package/chain-execution.ts

@@ -44,6 +44,7 @@ import {
 	type AgentProgress,
 	type ArtifactConfig,
 	type ArtifactPaths,
+	type ControlEvent,
 	type Details,
 	type ResolvedControlConfig,
 	type SingleResult,
@@ -84,12 +85,17 @@ interface ParallelChainRunInput {
 	artifactsDir: string;
 	signal?: AbortSignal;
 	onUpdate?: (r: AgentToolResult<Details>) => void;
+	onControlEvent?: (event: ControlEvent) => void;
 	controlConfig: ResolvedControlConfig;
+	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 	foregroundControl?: {
 		updatedAt: number;
 		currentAgent?: string;
 		currentIndex?: number;
 		currentActivityState?: ActivityState;
+		lastActivityAt?: number;
+		currentTool?: string;
+		currentToolStartedAt?: number;
 		interrupt?: () => boolean;
 	};
 	results: SingleResult[];
@@ -200,12 +206,12 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 			if (input.foregroundControl) {
 				input.foregroundControl.currentAgent = task.agent;
 				input.foregroundControl.currentIndex = input.globalTaskIndex + taskIndex;
-				input.foregroundControl.currentActivityState = "starting";
+				input.foregroundControl.currentActivityState = undefined;
 				input.foregroundControl.updatedAt = Date.now();
 				input.foregroundControl.interrupt = () => {
 					if (interruptController.signal.aborted) return false;
 					interruptController.abort();
-					input.foregroundControl!.currentActivityState = "paused";
+					input.foregroundControl!.currentActivityState = undefined;
 					input.foregroundControl!.updatedAt = Date.now();
 					return true;
 				};
@@ -225,6 +231,8 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				outputPath,
 				maxSubagentDepth,
 				controlConfig: input.controlConfig,
+				onControlEvent: input.onControlEvent,
+				intercomSessionName: input.childIntercomTarget?.(task.agent, input.globalTaskIndex + taskIndex),
 				modelOverride: effectiveModel,
 				availableModels: input.availableModels,
 				preferredModelProvider: input.ctx.model?.provider,
@@ -238,6 +246,9 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 							input.foregroundControl.currentAgent = task.agent;
 							input.foregroundControl.currentIndex = input.globalTaskIndex + taskIndex;
 							input.foregroundControl.currentActivityState = current?.activityState;
+							input.foregroundControl.lastActivityAt = current?.lastActivityAt;
+							input.foregroundControl.currentTool = current?.currentTool;
+							input.foregroundControl.currentToolStartedAt = current?.currentToolStartedAt;
 							input.foregroundControl.updatedAt = Date.now();
 						}
 						input.onUpdate?.({
@@ -287,12 +298,17 @@ export interface ChainExecutionParams {
 	includeProgress?: boolean;
 	clarify?: boolean;
 	onUpdate?: (r: AgentToolResult<Details>) => void;
+	onControlEvent?: (event: ControlEvent) => void;
 	controlConfig: ResolvedControlConfig;
+	childIntercomTarget?: (agent: string, index: number) => string | undefined;
 	foregroundControl?: {
 		updatedAt: number;
 		currentAgent?: string;
 		currentIndex?: number;
 		currentActivityState?: ActivityState;
+		lastActivityAt?: number;
+		currentTool?: string;
+		currentToolStartedAt?: number;
 		interrupt?: () => boolean;
 	};
 	chainSkills?: string[];
@@ -332,7 +348,9 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 		includeProgress,
 		clarify,
 		onUpdate,
+		onControlEvent,
 		controlConfig,
+		childIntercomTarget,
 		foregroundControl,
 		chainSkills: chainSkillsParam,
 		chainDir: chainDirBase,
@@ -533,6 +551,8 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					chainAgents,
 					totalSteps,
 					controlConfig,
+					onControlEvent,
+					childIntercomTarget,
 					foregroundControl,
 					worktreeSetup,
 					maxSubagentDepth: params.maxSubagentDepth,
@@ -674,12 +694,12 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			if (foregroundControl) {
 				foregroundControl.currentAgent = seqStep.agent;
 				foregroundControl.currentIndex = globalTaskIndex;
-				foregroundControl.currentActivityState = "starting";
+				foregroundControl.currentActivityState = undefined;
 				foregroundControl.updatedAt = Date.now();
 				foregroundControl.interrupt = () => {
 					if (interruptController.signal.aborted) return false;
 					interruptController.abort();
-					foregroundControl.currentActivityState = "paused";
+					foregroundControl.currentActivityState = undefined;
 					foregroundControl.updatedAt = Date.now();
 					return true;
 				};
@@ -699,6 +719,8 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				outputPath,
 				maxSubagentDepth,
 				controlConfig,
+				onControlEvent,
+				intercomSessionName: childIntercomTarget?.(seqStep.agent, globalTaskIndex),
 				modelOverride: effectiveModel,
 				availableModels,
 				preferredModelProvider: ctx.model?.provider,
@@ -712,6 +734,9 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 							foregroundControl.currentAgent = seqStep.agent;
 							foregroundControl.currentIndex = globalTaskIndex;
 							foregroundControl.currentActivityState = current?.activityState;
+							foregroundControl.lastActivityAt = current?.lastActivityAt;
+							foregroundControl.currentTool = current?.currentTool;
+							foregroundControl.currentToolStartedAt = current?.currentToolStartedAt;
 							foregroundControl.updatedAt = Date.now();
 						}
 						onUpdate({