pi-subagents 0.49.0 → 0.50.0

package/src/runs/shared/tool-timeout.ts

@@ -0,0 +1,93 @@
+export const TOOL_TIMEOUT_ENV = "PI_SUBAGENT_TOOL_TIMEOUT_MS";
+
+/** Maximum delay a Node.js timer accepts without overflow. */
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+
+export const DEFAULT_FAST_TOOL_TIMEOUT_MS = 300_000;
+
+export const DEFAULT_FAST_TOOL_TIMEOUT_TOOLS = new Set([
+	"read",
+	"grep",
+	"find",
+	"ls",
+	"edit",
+	"write",
+	"structured_output",
+]);
+
+/** Tools whose normal job can be to wait for a person or another run. */
+export const TOOL_TIMEOUT_EXEMPT_TOOLS = new Set(["contact_supervisor", "intercom", "subagent_wait"]);
+
+// Backward-compatible export name for existing callers/tests.
+export const TOOL_TIMEOUT_ALLOWLIST = TOOL_TIMEOUT_EXEMPT_TOOLS;
+
+export function isToolTimeoutExempt(toolName: string | undefined): boolean {
+	return toolName !== undefined && TOOL_TIMEOUT_EXEMPT_TOOLS.has(toolName);
+}
+
+export function defaultToolTimeoutMs(toolName: string | undefined): number | undefined {
+	return toolName !== undefined && DEFAULT_FAST_TOOL_TIMEOUT_TOOLS.has(toolName)
+		? DEFAULT_FAST_TOOL_TIMEOUT_MS
+		: undefined;
+}
+
+export function effectiveToolTimeoutMs(toolName: string | undefined, configuredToolTimeoutMs: number | undefined): number | undefined {
+	if (isToolTimeoutExempt(toolName)) return undefined;
+	return configuredToolTimeoutMs ?? defaultToolTimeoutMs(toolName);
+}
+
+export function formatToolTimeoutMessage(toolName: string, timeoutMs: number): string {
+	return `Tool '${toolName}' exceeded its timeout of ${timeoutMs}ms.`;
+}
+
+export function toolTimeoutCallKey(event: { toolCallId?: unknown; toolName?: unknown }, fallbackId: number): string {
+	return typeof event.toolCallId === "string" && event.toolCallId.length > 0
+		? `id:${event.toolCallId}`
+		: `anon:${String(event.toolName ?? "tool")}:${fallbackId}`;
+}
+
+export interface ToolTimeoutResolutionInput {
+	/** Per-call value from the subagent tool params (highest precedence). */
+	callValue?: unknown;
+	/** Agent frontmatter default (second precedence). */
+	agentValue?: number;
+	/** Global extension config.toolTimeoutMs (third precedence). */
+	configValue?: unknown;
+	/** PI_SUBAGENT_TOOL_TIMEOUT_MS environment override (lowest precedence). */
+	envValue?: string | undefined;
+}
+
+/** Resolve the configured hard timeout. Default fast-tool timeouts apply later per tool name. */
+export function resolveToolTimeoutMs(input: ToolTimeoutResolutionInput): { toolTimeoutMs?: number; error?: string } {
+	const candidates: Array<{ label: string; value: unknown }> = [
+		{ label: "toolTimeoutMs", value: input.callValue },
+		{ label: "agent.toolTimeoutMs", value: input.agentValue },
+		{ label: "config.toolTimeoutMs", value: input.configValue },
+	];
+	let winner: { label: string; value: unknown } | undefined;
+	for (const candidate of candidates) {
+		if (candidate.value === undefined) continue;
+		winner = candidate;
+		break;
+	}
+	if (winner === undefined && input.envValue !== undefined && input.envValue.trim() !== "") {
+		winner = { label: TOOL_TIMEOUT_ENV, value: input.envValue };
+	}
+	if (winner === undefined) return {};
+
+	let raw: unknown = winner.value;
+	let parsed: number;
+	if (winner.label === TOOL_TIMEOUT_ENV && typeof raw === "string") {
+		parsed = Number(raw);
+		if (raw.trim() !== "" && !Number.isNaN(parsed)) raw = parsed;
+	}
+	if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0 || raw > MAX_TIMER_DELAY_MS) {
+		return { error: `${winner.label} must be a positive integer no larger than ${MAX_TIMER_DELAY_MS}.` };
+	}
+	return { toolTimeoutMs: raw };
+}
+
+/** Read the environment override without requiring callers to know the name. */
+export function toolTimeoutFromEnv(env: NodeJS.ProcessEnv = process.env): string | undefined {
+	return env[TOOL_TIMEOUT_ENV];
+}

package/src/shared/types.ts

@@ -215,7 +215,7 @@ export interface ControlEvent {
 	nestedRunId?: string;
 	nestingPath?: NestedRunAddress["path"];
 	message: string;
-	reason?: "idle" | "completion_guard" | "active_long_running" | "tool_failures" | "supervisor_request" | "time_threshold" | "turn_threshold" | "token_threshold";
+	reason?: "idle" | "completion_guard" | "active_long_running" | "tool_failures" | "supervisor_request" | "time_threshold" | "turn_threshold" | "token_threshold" | "tool_open_threshold";
 	turns?: number;
 	tokens?: number;
 	toolCount?: number;
@@ -1031,6 +1031,7 @@ export interface Details {
 	controlEvents?: ControlEvent[];
 	steering?: SteerActionResult;
 	asyncId?: string;
+	background?: boolean;
 	asyncDir?: string;
 	timeoutMs?: number;
 	deadlineAt?: number;
@@ -1088,7 +1089,7 @@ export interface Details {
 		trace: Array<{
 			operation: "run" | "status";
 			key: string;
-			state: "started" | "completed" | "failed" | "stopped" | "reused";
+			state: "started" | "completed" | "failed" | "detached" | "stopped" | "reused";
 			agent?: string;
 			runId?: string;
 			phase?: string;
@@ -1464,6 +1465,8 @@ export type AsyncJobStep = NonNullable<AsyncStatus["steps"]>[number] & {
 export interface AsyncJobState {
 	asyncId: string;
 	asyncDir: string;
+	/** Host tool-call id retained when it differs from the internal run id. */
+	toolCallId?: string;
 	/** Parent-resolved launch directory retained for trusted live artifact lookup. */
 	cwd?: string;
 	/** Parent-resolved child session root retained for trusted live transcript lookup. */
@@ -1767,6 +1770,10 @@ export interface RunSyncOptions {
 	interruptSignal?: AbortSignal;
 	timeoutMs?: number;
 	deadlineAt?: number;
+	/** Per-call per-tool timeout (ms), resolved with the agent/config/environment ladder at execution. */
+	toolTimeoutMs?: number;
+	/** Raw global config.toolTimeoutMs, used by the per-child resolver. */
+	configToolTimeoutMs?: number;
 	turnBudget?: ResolvedTurnBudget;
 	usageBudget?: UsageBudgetConfig;
 	/** Enforce maxTurns + graceTurns as a hard model-turn boundary. */
@@ -1831,6 +1838,8 @@ export interface RunSyncOptions {
 	};
 	/** Private live callback for the exact child prompt after runtime acceptance injection. */
 	onEffectivePrompt?: (prompt: string) => void;
+	/** Internal lifecycle hook for the observer shared across retries of one logical child. */
+	onOrcaProgressTabCreated?: (tab: import("../runs/shared/orca-progress-tabs.ts").OrcaProgressTab) => void;
 }
 
 export type IntercomBridgeMode = "off" | "fork-only" | "always";
@@ -1892,6 +1901,11 @@ export const FLEET_KEYBINDING_ACTIONS = [
 export type FleetKeybindingAction = typeof FLEET_KEYBINDING_ACTIONS[number];
 export type FleetKeybindingsConfig = Partial<Record<FleetKeybindingAction, string[]>>;
 
+export interface OrcaProgressTabsConfig {
+	/** Create one Orca terminal tab per running subagent. Experimental and opt-in. */
+	enabled?: boolean;
+}
+
 export interface MainWindowRendererConfig {
 	/** Unit of horizontal space in main chat subagent call/result rows. Omit to preserve current spacing. Set 0 for no extra padding. */
 	horizontalSpacing?: number;
@@ -1901,6 +1915,8 @@ export interface MainWindowRendererConfig {
 
 export interface ExtensionConfig {
 	asyncByDefault?: boolean;
+	/** Optional shortcut that detaches the active foreground single-subagent run. */
+	foregroundDetachShortcut?: string;
 	/** Show the Claude Code-style navigable fleet. Defaults to true. */
 	fleetView?: boolean;
 	/** Place the persistent FleetView above or below the editor. Defaults to belowEditor. */
@@ -1917,6 +1933,8 @@ export interface ExtensionConfig {
 	inlineToolDisplay?: InlineToolDisplay;
 	/** Density controls for the main chat subagent call/result renderer. */
 	mainWindowRenderer?: MainWindowRendererConfig;
+	/** Experimental observer: mirror each native subagent's progress into a new Orca tab. */
+	orcaProgressTabs?: OrcaProgressTabsConfig;
 	forceTopLevelAsync?: boolean;
 	waitTool?: WaitToolConfig;
 	defaultSessionDir?: string;
@@ -1940,6 +1958,15 @@ export interface ExtensionConfig {
 	 * Must be a positive integer; invalid values are ignored.
 	 */
 	timeoutMs?: number;
+	/**
+	 * Optional hard per-tool-call timeout in milliseconds. Bounds a single
+	 * subagent tool call inside the child; the run-level timeout remains
+	 * authoritative. Known-fast built-in tools have a five-minute default when
+	 * this is undefined. Precedence: call param > agent frontmatter > this config >
+	 * PI_SUBAGENT_TOOL_TIMEOUT_MS. Must be a positive integer; invalid values
+	 * are rejected with an error.
+	 */
+	toolTimeoutMs?: number;
 	control?: ControlConfig;
 	completionBatch?: CompletionBatchConfig;
 	turnBudget?: TurnBudgetConfig;

package/src/slash/slash-commands.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { keyText, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { Key, matchesKey, truncateToWidth, type Component, type KeyId, type TUI } from "@earendil-works/pi-tui";
 import { BUILTIN_AGENT_NAMES, discoverAgents } from "../agents/agents.ts";
 import { resolveExistingReadPaths } from "../shared/settings.ts";
 import {
@@ -631,7 +631,7 @@ function slashRunWorkflowScript(key: string, child: Record<string, unknown>): st
 export function registerSlashCommands(
 	pi: ExtensionAPI,
 	state: SubagentState,
-	options: { fleetKeybindings?: FleetKeybindingsConfig } = {},
+	options: { fleetKeybindings?: FleetKeybindingsConfig; foregroundDetachShortcut?: string } = {},
 ): void {
 	let fleetOpen = false;
 	const showFleet = async (ctx: ExtensionContext) => {
@@ -741,33 +741,42 @@ export function registerSlashCommands(
 		handler: async (ctx) => showFleet(ctx),
 	});
 
+	const detachForegroundRun = (args: string, ctx: ExtensionContext): void => {
+		const id = args.trim();
+		let control: ReturnType<typeof selectForegroundDetachControl>;
+		try {
+			control = selectForegroundDetachControl(state, id);
+		} catch (error) {
+			ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			return;
+		}
+		if (!control) {
+			ctx.ui.notify(id ? `No active foreground run found for '${id}'.` : "No active foreground single-subagent run to detach.", "info");
+			return;
+		}
+		if (control.mode !== "single") {
+			ctx.ui.notify("/subagents-detach currently supports single-subagent runs only.", "error");
+			return;
+		}
+		if (!control.detach?.()) {
+			ctx.ui.notify(`Foreground run ${control.runId} is not currently detachable.`, "info");
+			return;
+		}
+		sendSlashText(pi, `Detached foreground run ${control.runId} without terminating its child. Use subagent({ action: "status", id: ${JSON.stringify(control.runId)} }) or subagent_wait({ id: ${JSON.stringify(control.runId)} }) to recover the eventual result. This does not daemonize the process or guarantee survival across Pi reload/restart.`);
+	};
+
 	pi.registerCommand("subagents-detach", {
 		description: "Detach the active foreground single-subagent run without terminating it",
-		handler: async (args, ctx) => {
-			const id = args.trim();
-			let control: ReturnType<typeof selectForegroundDetachControl>;
-			try {
-				control = selectForegroundDetachControl(state, id);
-			} catch (error) {
-				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
-				return;
-			}
-			if (!control) {
-				ctx.ui.notify(id ? `No active foreground run found for '${id}'.` : "No active foreground single-subagent run to detach.", "info");
-				return;
-			}
-			if (control.mode !== "single") {
-				ctx.ui.notify("/subagents-detach currently supports single-subagent runs only.", "error");
-				return;
-			}
-			if (!control.detach?.()) {
-				ctx.ui.notify(`Foreground run ${control.runId} is not currently detachable.`, "info");
-				return;
-			}
-			sendSlashText(pi, `Detached foreground run ${control.runId} without terminating its child. Use subagent({ action: "status", id: ${JSON.stringify(control.runId)} }) or subagent_wait({ id: ${JSON.stringify(control.runId)} }) to recover the eventual result. This does not daemonize the process or guarantee survival across Pi reload/restart.`);
-		},
+		handler: async (args, ctx) => detachForegroundRun(args, ctx),
 	});
 
+	if (options.foregroundDetachShortcut) {
+		pi.registerShortcut(options.foregroundDetachShortcut as KeyId, {
+			description: "Detach the active foreground subagent and keep it running in the background",
+			handler: async (ctx) => detachForegroundRun("", ctx),
+		});
+	}
+
 	pi.registerCommand("subagents-stop", {
 		description: "Stop a current-session async subagent run",
 		handler: async (args, ctx) => {

package/src/slash/slash-live-state.ts

@@ -81,6 +81,7 @@ function buildParallelInitialResult(params: SubagentParamsLike): AgentToolResult
 		content: [{ type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") }],
 		details: {
 			mode: "parallel",
+			...(params.async ? { background: true } : {}),
 			...(params.context ? { context: params.context } : {}),
 			results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
 			progress: tasks.map((task, index) => ({
@@ -136,6 +137,7 @@ function buildChainInitialResult(params: SubagentParamsLike): AgentToolResult<De
 		}],
 		details: {
 			mode: "chain",
+			...(params.async ? { background: true } : {}),
 			...(params.context ? { context: params.context } : {}),
 			results,
 			progress: results.map((result, index) => ({
@@ -164,6 +166,7 @@ function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<D
 		content: [{ type: "text", text: task }],
 		details: {
 			mode: "single",
+			...(params.async ? { background: true } : {}),
 			...(params.context ? { context: params.context } : {}),
 			results: [createPlaceholderResult(agent, task, "running", 0)],
 			progress: [{

package/src/tui/fleet-status.ts

@@ -1,12 +1,13 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type EditorComponent, isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { snapshotExternalRuns } from "../api/external-runs.ts";
 import { formatModelThinking } from "../shared/formatters.ts";
 import type { AsyncJobStep, FleetViewPlacement, NestedRunSummary, NestedStepSummary, SubagentState } from "../shared/types.ts";
 import { formatWorkflowJsonPreview } from "../workflows/scripted-workflow.ts";
 
 export const FLEET_STATUS_WIDGET_KEY = "subagent-fleet-status";
 
-// Six rows fit the accepted collapsed hierarchy: one owner, four direct leaves, and overflow.
+// Six rows fit the accepted collapsed hierarchy: one owner, four visible descendants, and overflow.
 const MAX_AGENT_ROWS = 6;
 const REFRESH_MS = 500;
 
@@ -16,12 +17,15 @@ type FleetStatusTui = {
 };
 type FleetStatusEntry = {
 	key: string;
+	parentKey?: string;
+	workflowWrapper?: boolean;
 	agent: string;
 	modelThinking?: string;
 	description?: string;
 	startedAt: number;
 	tokens: number;
 	state: string;
+	external?: true;
 	nestedChildren?: NestedRunSummary[];
 };
 
@@ -31,11 +35,13 @@ type FleetNestedRow = {
 	modelThinking?: string;
 	activity?: string;
 	startedAt?: number;
+	depth: number;
 	overflow?: number;
 };
 
 type FleetTreeRow =
 	| { kind: "owner"; entry: FleetStatusEntry }
+	| { kind: "child"; entry: FleetStatusEntry; last: boolean }
 	| { kind: "nested"; ownerKey: string; row: FleetNestedRow; last: boolean };
 
 export interface FleetStatusOptions {
@@ -94,44 +100,112 @@ function nestedStatusGlyph(state: FleetNestedRow["state"], theme: Theme): string
 	return theme.fg("warning", "■");
 }
 
-function nestedFleetRows(children: NestedRunSummary[] | undefined): FleetNestedRow[] {
-	const rows: FleetNestedRow[] = [];
-	for (const child of children ?? []) {
+function nestedStepDisplayCount(steps: NestedStepSummary[] | undefined, start = 0): number {
+	let count = 0;
+	for (let index = start; index < (steps?.length ?? 0); index++) {
+		count += 1 + nestedDisplayCount(steps![index]!.children);
+	}
+	return count;
+}
+
+function nestedDisplayCount(children: NestedRunSummary[] | undefined, start = 0): number {
+	let count = 0;
+	for (let index = start; index < (children?.length ?? 0); index++) {
+		const child = children![index]!;
 		const steps = (child.mode === "parallel" || child.mode === "chain") ? child.steps ?? [] : [];
-		if (steps.length > 0) {
-			for (const step of steps) {
-				const modelThinking = formatModelThinking(step.model, step.thinking) || undefined;
-				const activity = nestedActivity(step);
+		count += steps.length > 0 ? nestedStepDisplayCount(steps) : 1;
+		count += nestedDisplayCount(child.children);
+	}
+	return count;
+}
+
+function nestedFleetRows(children: NestedRunSummary[] | undefined, visibleLimit: number): FleetNestedRow[] {
+	const rows: FleetNestedRow[] = [];
+	let omitted = 0;
+	const appendRuns = (runs: NestedRunSummary[] | undefined, depth: number): boolean => {
+		for (let runIndex = 0; runIndex < (runs?.length ?? 0); runIndex++) {
+			const child = runs![runIndex]!;
+			const steps = (child.mode === "parallel" || child.mode === "chain") ? child.steps ?? [] : [];
+			if (steps.length > 0) {
+				for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
+					if (rows.length >= visibleLimit) {
+						omitted += nestedStepDisplayCount(steps, stepIndex);
+						omitted += nestedDisplayCount(child.children);
+						omitted += nestedDisplayCount(runs, runIndex + 1);
+						return false;
+					}
+					const step = steps[stepIndex]!;
+					const modelThinking = formatModelThinking(step.model, step.thinking) || undefined;
+					const activity = nestedActivity(step);
+					rows.push({
+						name: step.agent,
+						state: step.status,
+						depth,
+						...(modelThinking ? { modelThinking } : {}),
+						...(activity ? { activity } : {}),
+						...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
+					});
+					if (!appendRuns(step.children, depth + 1)) {
+						omitted += nestedStepDisplayCount(steps, stepIndex + 1);
+						omitted += nestedDisplayCount(child.children);
+						omitted += nestedDisplayCount(runs, runIndex + 1);
+						return false;
+					}
+				}
+			} else {
+				if (rows.length >= visibleLimit) {
+					omitted += nestedDisplayCount(runs, runIndex);
+					return false;
+				}
+				const modelThinking = formatModelThinking(child.model, child.thinking) || undefined;
+				const activity = nestedActivity(child);
 				rows.push({
-					name: step.agent,
-					state: step.status,
+					name: nestedRunLabel(child),
+					state: child.state,
+					depth,
 					...(modelThinking ? { modelThinking } : {}),
 					...(activity ? { activity } : {}),
-					...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
+					...(child.startedAt !== undefined ? { startedAt: child.startedAt } : {}),
 				});
 			}
-			continue;
+			if (!appendRuns(child.children, depth + 1)) {
+				omitted += nestedDisplayCount(runs, runIndex + 1);
+				return false;
+			}
 		}
-		const modelThinking = formatModelThinking(child.model, child.thinking) || undefined;
-		const activity = nestedActivity(child);
-		rows.push({
-			name: nestedRunLabel(child),
-			state: child.state,
-			...(modelThinking ? { modelThinking } : {}),
-			...(activity ? { activity } : {}),
-			...(child.startedAt !== undefined ? { startedAt: child.startedAt } : {}),
-		});
-	}
-	const visible = rows.slice(0, 4);
-	if (rows.length > visible.length) visible.push({ name: `… +${rows.length - visible.length} more nested leaves`, state: "complete", overflow: rows.length - visible.length });
-	return visible;
+		return true;
+	};
+	appendRuns(children, 0);
+	if (omitted > 0) rows.push({ name: `… +${omitted} more nested leaves`, state: "complete", depth: 0, overflow: omitted });
+	return rows;
 }
 
 function fleetTreeRows(entries: FleetStatusEntry[]): FleetTreeRow[] {
 	const rows: FleetTreeRow[] = [];
+	const entryKeys = new Set(entries.map((entry) => entry.key));
+	const childrenByParent = new Map<string, FleetStatusEntry[]>();
+	for (const entry of entries) {
+		if (!entry.parentKey || !entryKeys.has(entry.parentKey)) continue;
+		const children = childrenByParent.get(entry.parentKey) ?? [];
+		children.push(entry);
+		childrenByParent.set(entry.parentKey, children);
+	}
 	for (const entry of entries) {
+		if (entry.parentKey && entryKeys.has(entry.parentKey)) continue;
 		rows.push({ kind: "owner", entry });
-		const nested = nestedFleetRows(entry.nestedChildren);
+		const attached = childrenByParent.get(entry.key) ?? [];
+		for (const [index, child] of attached.entries()) {
+			const nested = nestedFleetRows(child.nestedChildren, 3);
+			const laterRows = index < attached.length - 1 || Boolean(entry.nestedChildren?.length);
+			rows.push({ kind: "child", entry: child, last: !laterRows && nested.length === 0 });
+			for (const [nestedIndex, row] of nested.entries()) rows.push({
+				kind: "nested",
+				ownerKey: child.key,
+				row: { ...row, depth: row.depth + 1 },
+				last: nestedIndex === nested.length - 1 && !laterRows,
+			});
+		}
+		const nested = nestedFleetRows(entry.nestedChildren, attached.length > 0 ? 3 : 4);
 		for (const [index, row] of nested.entries()) rows.push({ kind: "nested", ownerKey: entry.key, row, last: index === nested.length - 1 });
 	}
 	return rows;
@@ -150,14 +224,24 @@ function foregroundDescription(control: { parentWorkflowRunId?: string; workflow
 	return description ? `${workflow} · ${description}` : workflow;
 }
 
+function activeLeafAgentCount(entries: FleetStatusEntry[]): number {
+	return entries.filter((entry) => !entry.workflowWrapper).length;
+}
+
 export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntry[] {
 	const entries: FleetStatusEntry[] = [];
+	const activeWorkflowKeys = new Set([...state.asyncJobs.values()]
+		.filter((job) => job.mode === "workflow" && isActiveState(job.status))
+		.map((job) => `async:${job.asyncId}`));
 	for (const control of state.foregroundControls.values()) {
+		const parentKey = control.parentWorkflowRunId ? `async:${control.parentWorkflowRunId}` : undefined;
+		const linkedParentKey = parentKey && activeWorkflowKeys.has(parentKey) ? parentKey : undefined;
 		if (control.activeChildren) {
 			for (const child of [...control.activeChildren.values()].sort((left, right) => left.index - right.index)) {
 				const modelThinking = formatModelThinking(child.model, child.thinking) || undefined;
 				entries.push({
 					key: `foreground-active:${control.runId}:${child.index}`,
+					...(linkedParentKey ? { parentKey: linkedParentKey } : {}),
 					agent: child.agent,
 					...(modelThinking ? { modelThinking } : {}),
 					description: foregroundDescription(control, child.description),
@@ -174,6 +258,7 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 		const modelThinking = formatModelThinking(control.model, control.thinking) || undefined;
 		entries.push({
 			key: `foreground-active:${control.runId}:${control.currentIndex ?? 0}`,
+			...(linkedParentKey ? { parentKey: linkedParentKey } : {}),
 			agent: control.currentAgent ?? control.mode,
 			...(modelThinking ? { modelThinking } : {}),
 			description: foregroundDescription(control, control.description),
@@ -191,6 +276,7 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 			const latestEmit = job.workflow?.emits?.length ? formatWorkflowJsonPreview(job.workflow.emits.at(-1), 120) : undefined;
 			entries.push({
 				key: `async:${job.asyncId}`,
+				workflowWrapper: true,
 				agent: "workflow",
 				description: latestEmit !== undefined ? `latest emit: ${latestEmit}` : job.description,
 				startedAt,
@@ -241,6 +327,25 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 		}
 	}
 
+	if (state.currentSessionId) {
+		try {
+			for (const run of snapshotExternalRuns(state.currentSessionId, { ignoreMalformed: true, onMalformedRecord: (message) => console.warn(`[pi-subagents] Removed ${message}`) })) {
+				if (!isActiveState(run.state)) continue;
+				entries.push({
+					key: `external:${run.id}`,
+					agent: `external · ${run.label}`,
+					description: run.currentAction ?? `source: ${run.source}`,
+					startedAt: run.startedAt,
+					tokens: 0,
+					state: run.state,
+					external: true,
+				});
+			}
+		} catch (cause) {
+			console.warn(`[pi-subagents] Failed to inspect external jobs: ${cause instanceof Error ? cause.message : String(cause)}`);
+		}
+	}
+
 	return entries.sort((left, right) => left.startedAt - right.startedAt || left.key.localeCompare(right.key));
 }
 
@@ -417,10 +522,15 @@ export class SubagentFleetStatus {
 		if (!this.active) {
 			const tokens = this.entries.reduce((total, entry) => total + entry.tokens, 0);
 			const capacity = this.state.activeAsyncCapacity;
-			const asyncRuns = capacity ? `Async runs ${capacity.used}/${capacity.limit || "∞"}` : "";
-			const agents = this.entries.length > 0 ? `${this.entries.length} active ${this.entries.length === 1 ? "agent" : "agents"}` : "";
+			const hasNativeRows = this.entries.some((entry) => !entry.external);
+			const showNativeSummary = hasNativeRows || Boolean(capacity?.used);
+			const asyncRuns = capacity && showNativeSummary ? `Async runs ${capacity.used}/${capacity.limit || "∞"}` : "";
+			const activeEntries = activeLeafAgentCount(this.entries);
+			const noun = this.entries.some((entry) => entry.external) ? "job" : "agent";
+			const agents = activeEntries > 0 ? `${activeEntries} active ${noun}${activeEntries === 1 ? "" : "s"}` : "";
 			const label = [agents, asyncRuns].filter(Boolean).join(" · ");
-			return [truncateToWidth(`  ${theme.fg("muted", label)} · ${theme.fg("dim", `${formatFleetTokens(tokens)} · ↓/← to inspect`)}`, width)];
+			const detail = [showNativeSummary ? formatFleetTokens(tokens) : undefined, "↓/← to inspect"].filter(Boolean).join(" · ");
+			return [truncateToWidth(`  ${theme.fg("muted", label)} · ${theme.fg("dim", detail)}`, width)];
 		}
 		const roster = this.rosterKeys();
 		const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
@@ -428,16 +538,16 @@ export class SubagentFleetStatus {
 		lines.push(truncateToWidth(`  ${this.bullet(0, selectedIndex, theme)} main`, width));
 
 		const tree = fleetTreeRows(this.entries);
-		const selectedTreeIndex = Math.max(0, tree.findIndex((row) => row.kind === "owner" && row.entry.key === this.selectedKey));
+		const selectedTreeIndex = Math.max(0, tree.findIndex((row) => (row.kind === "owner" || row.kind === "child") && row.entry.key === this.selectedKey));
 		const visibleCount = Math.min(this.maxAgentRows, tree.length);
 		const start = selectedTreeIndex < visibleCount ? 0 : selectedTreeIndex - visibleCount + 1;
 		const hiddenBelow = tree.length - (start + visibleCount);
 		if (start > 0) lines.push(rightAlign("", theme.fg("dim", `↑ ${start} more`), width));
 		for (let index = start; index < start + visibleCount; index++) {
 			const row = tree[index]!;
-			if (row.kind === "owner") {
+			if (row.kind === "owner" || row.kind === "child") {
 				const ownerIndex = this.entries.findIndex((entry) => entry.key === row.entry.key);
-				lines.push(this.renderEntry(ownerIndex + 1, selectedIndex, row.entry, width, theme));
+				lines.push(this.renderEntry(ownerIndex + 1, selectedIndex, row.entry, width, theme, row.kind === "child" ? (row.last ? "└─" : "├─") : undefined));
 			} else {
 				lines.push(this.renderNestedRow(row.row, row.last, width, theme));
 			}
@@ -446,20 +556,22 @@ export class SubagentFleetStatus {
 		return lines;
 	}
 
-	private renderEntry(rosterIndex: number, selectedIndex: number, entry: FleetStatusEntry, width: number, theme: Theme): string {
+	private renderEntry(rosterIndex: number, selectedIndex: number, entry: FleetStatusEntry, width: number, theme: Theme, branch?: string): string {
 		const agent = entry.modelThinking ? `${entry.agent} (${entry.modelThinking})` : entry.agent;
-		const left = `  ${this.bullet(rosterIndex, selectedIndex, theme)} ${theme.fg("muted", agent)} · ${entry.state}`;
+		const prefix = branch ? `    ${branch}` : " ";
+		const left = `${prefix} ${this.bullet(rosterIndex, selectedIndex, theme)} ${theme.fg("muted", agent)} · ${entry.state}`;
 		const elapsed = Date.now() - entry.startedAt;
-		const right = theme.fg("dim", `${formatFleetElapsed(elapsed)} · ${formatFleetTokens(entry.tokens)}`);
+		const right = theme.fg("dim", entry.external ? formatFleetElapsed(elapsed) : `${formatFleetElapsed(elapsed)} · ${formatFleetTokens(entry.tokens)}`);
 		return rightAlign(left, right, width);
 	}
 
 	private renderNestedRow(row: FleetNestedRow, last: boolean, width: number, theme: Theme): string {
 		const marker = last ? "└─" : "├─";
-		if (row.overflow !== undefined) return truncateToWidth(`    ${marker} ${theme.fg("dim", `+${row.overflow} nested leaves`)}`, width);
+		const indent = "    ".repeat(row.depth + 1);
+		if (row.overflow !== undefined) return truncateToWidth(`${indent}${marker} ${theme.fg("dim", `+${row.overflow} nested leaves`)}`, width);
 		const modelThinking = row.modelThinking ? ` (${row.modelThinking})` : "";
 		const activity = row.activity ? ` · ${row.activity}` : "";
-		const left = `    ${marker} ${nestedStatusGlyph(row.state, theme)} ${theme.fg("muted", `${row.name}${modelThinking}`)} · ${row.state}${activity}`;
+		const left = `${indent}${marker} ${nestedStatusGlyph(row.state, theme)} ${theme.fg("muted", `${row.name}${modelThinking}`)} · ${row.state}${activity}`;
 		const elapsed = row.startedAt !== undefined ? ` · ${formatFleetElapsed(Date.now() - row.startedAt)}` : "";
 		return truncateToWidth(`${left}${theme.fg("dim", elapsed)}`, width);
 	}
@@ -504,22 +616,25 @@ export class SubagentFleetStatus {
 			entries: this.entries.map((entry) => this.active
 				? [
 					entry.key,
+					entry.parentKey,
 					entry.agent,
 					entry.state,
 					entry.modelThinking,
 					entry.description,
+					entry.external,
 					Math.round((now - entry.startedAt) / 1000),
 					entry.tokens,
-					entry.nestedChildren?.map((child) => [
-						child.id,
-						child.state,
-						child.model,
-						child.thinking,
-						child.lastUpdate,
-						child.steps?.map((step) => [step.agent, step.status, step.model, step.thinking, step.lastActivityAt]),
+					nestedFleetRows(entry.nestedChildren, entry.parentKey ? 3 : 4).map((row) => [
+						row.name,
+						row.state,
+						row.modelThinking,
+						row.activity,
+						row.startedAt,
+						row.depth,
+						row.overflow,
 					]),
 				]
-				: [entry.key, entry.state, entry.tokens]),
+				: [entry.key, entry.state, entry.external, entry.tokens]),
 		});
 	}