pi-subagents 0.53.0 → 0.55.0

package/src/runs/shared/subagent-prompt-runtime.ts

@@ -11,6 +11,7 @@ import { RUNTIME_EXTENSION_ACK_EVENT, RUNTIME_EXTENSION_ACK_PATH_ENV, isRuntimeA
 import { createStructuredOutputToolParameters, STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV, validateStructuredOutputValue } from "./structured-output.ts";
 import {
 	CHILD_TOOL_DIAGNOSTIC_PATH_ENV,
+	formatChildToolDiagnostic,
 	MCP_DIRECT_CHILD_TOOLS_ENV,
 	REQUIRED_CHILD_TOOLS_ENV,
 	writeChildToolDiagnostic,
@@ -21,7 +22,7 @@ import type { JsonSchemaObject, ResolvedToolBudget, SubagentState } from "../../
 import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
 import { resolveWatchPath } from "../../shared/utils.ts";
 import { registerChildWatchdog } from "../../watchdog/register-child.ts";
-import { CHILD_WATCHDOG_CONFIG_ENV } from "../../watchdog/child-status.ts";
+import { CHILD_WATCHDOG_CONFIG_ENV, decodeChildWatchdogConfig } from "../../watchdog/child-status.ts";
 import { requestWatchdogPermission, type WatchdogPermissionRequest, type WatchdogPermissionResult } from "../../watchdog/permission-arbiter.ts";
 import { SUBAGENT_WATCHDOG_WARNING_TYPE } from "../../watchdog/types.ts";
 import { resolveWaitToolConfig } from "../background/wait-config.ts";
@@ -296,14 +297,41 @@ export function registerPermissionGate(
 		const decision = permissionDecision(rules, toolName);
 		if (decision === "allow") return undefined;
 		if (decision === "deny") return { block: true, reason: `Blocked by pi-subagents permission rule: '${toolName}' is denied.` };
-		const result = await requestPermission({
-			ctx,
-			toolName,
-			args: event.input ?? {},
-			rawWatchdogConfig: process.env[CHILD_WATCHDOG_CONFIG_ENV],
-			auditPath: process.env[PERMISSION_AUDIT_PATH_ENV],
-			...(ctx.signal ? { signal: ctx.signal } : {}),
-		});
+		const rawWatchdogConfig = process.env[CHILD_WATCHDOG_CONFIG_ENV];
+		let timeoutMs = 30_000;
+		try {
+			timeoutMs = decodeChildWatchdogConfig(rawWatchdogConfig)?.agentEndTimeoutMs ?? timeoutMs;
+		} catch {
+			// The arbiter reports invalid configuration with the concrete decode error.
+		}
+		if (ctx.signal?.aborted) return { block: true, reason: "Blocked by pi-subagents permission rule: Watchdog permission decision was cancelled." };
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		let abort: (() => void) | undefined;
+		let result: WatchdogPermissionResult;
+		try {
+			result = await Promise.race([
+				requestPermission({
+					ctx,
+					toolName,
+					args: event.input ?? {},
+					rawWatchdogConfig,
+					auditPath: process.env[PERMISSION_AUDIT_PATH_ENV],
+					...(ctx.signal ? { signal: ctx.signal } : {}),
+				}),
+				new Promise<WatchdogPermissionResult>((resolve) => {
+					if (!ctx.signal) return;
+					abort = () => resolve({ approved: false, reason: "Watchdog permission decision was cancelled.", source: "watchdog" });
+					ctx.signal.addEventListener("abort", abort, { once: true });
+				}),
+				new Promise<never>((_, reject) => { timeout = setTimeout(() => reject(new Error(`Watchdog permission decision timed out after ${timeoutMs}ms.`)), timeoutMs); }),
+			]);
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			return { block: true, reason: `Blocked by pi-subagents permission rule: Watchdog permission arbiter failed closed: ${reason}` };
+		} finally {
+			if (timeout) clearTimeout(timeout);
+			if (abort) ctx.signal?.removeEventListener("abort", abort);
+		}
 		if (result.approved) return undefined;
 		return { block: true, reason: `Blocked by pi-subagents permission rule: ${result.reason}` };
 	});
@@ -598,7 +626,8 @@ export default function registerSubagentPromptRuntime(pi: ExtensionAPI): void {
 		registerNativeSupervisorClientOnce();
 	});
 	onRuntimeEvent("agent_start", () => {
-		refreshChildToolDiagnostic(pi);
+		const diagnostic = refreshChildToolDiagnostic(pi);
+		if (diagnostic) throw new Error(formatChildToolDiagnostic(diagnostic));
 	});
 	onRuntimeEvent("agent_end", async (_event: unknown, ctx: unknown) => {
 		if ((ctx as { hasUI?: boolean } | undefined)?.hasUI === true) return;

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

@@ -13,8 +13,6 @@ export interface ChildToolDiagnostic {
 	missingMcpDirectTools?: string[];
 }
 
-const PI_CORE_CHILD_TOOLS = new Set(["bash", "edit", "find", "grep", "ls", "read", "write"]);
-
 export function writeChildToolDiagnostic(
 	filePath: string,
 	required: string[],
@@ -22,7 +20,7 @@ export function writeChildToolDiagnostic(
 	agent?: string,
 	mcpDirectTools?: string[],
 ): ChildToolDiagnostic | undefined {
-	const availableNames = new Set([...available, ...PI_CORE_CHILD_TOOLS]);
+	const availableNames = new Set(available);
 	const missing = required.filter((name) => !availableNames.has(name));
 	if (missing.length === 0) {
 		fs.rmSync(filePath, { force: true });

package/src/shared/launch-contract.ts

@@ -17,7 +17,7 @@ function stableJson(value: unknown): string {
 	return JSON.stringify(value);
 }
 
-function sha256(value: unknown): string {
+export function stableJsonDigest(value: unknown): string {
 	return createHash("sha256").update(stableJson(value)).digest("hex");
 }
 
@@ -44,6 +44,7 @@ export function projectAgentDefinition(agent: AgentConfig): Record<string, unkno
 		inheritProjectContext: agent.inheritProjectContext,
 		inheritSkills: agent.inheritSkills,
 		model: agent.model,
+		modelProvider: agent.modelProvider,
 		fallbackModels: agent.fallbackModels,
 		thinking: agent.thinking,
 		tools: agent.tools,
@@ -70,7 +71,7 @@ export function projectAgentDefinition(agent: AgentConfig): Record<string, unkno
 }
 
 export function agentDefinitionDigest(agent: AgentConfig): string {
-	return sha256(projectAgentDefinition(agent));
+	return stableJsonDigest(projectAgentDefinition(agent));
 }
 
 export interface LaunchBindingInput {
@@ -99,12 +100,12 @@ export function projectLaunchBinding(input: LaunchBindingInput): Record<string,
 	return {
 		version: LAUNCH_BINDING_PROJECTION_VERSION,
 		definitionDigest: input.definitionDigest,
-		taskDigest: input.task === undefined ? undefined : sha256(input.task),
+		taskDigest: input.task === undefined ? undefined : stableJsonDigest(input.task),
 		// The ordered candidate set already contains each attempted model; keeping only
 		// this set makes retries correlate to the same preflight binding.
 		modelCandidates: input.modelCandidates,
 		thinking: input.thinking,
-		systemPromptDigest: input.systemPrompt === undefined || input.systemPrompt === null ? undefined : sha256(input.systemPrompt),
+		systemPromptDigest: input.systemPrompt === undefined || input.systemPrompt === null ? undefined : stableJsonDigest(input.systemPrompt),
 		systemPromptMode: input.systemPromptMode,
 		inheritProjectContext: input.inheritProjectContext,
 		inheritSkills: input.inheritSkills,
@@ -120,5 +121,5 @@ export function projectLaunchBinding(input: LaunchBindingInput): Record<string,
 }
 
 export function launchBindingDigest(input: LaunchBindingInput): string {
-	return sha256(projectLaunchBinding(input));
+	return stableJsonDigest(projectLaunchBinding(input));
 }

package/src/shared/thinking-ceiling.ts

@@ -0,0 +1,52 @@
+import { resolveEffectiveThinking, THINKING_LEVELS, type ThinkingLevel } from "./model-info.ts";
+export type { ThinkingLevel } from "./model-info.ts";
+
+export const SUBAGENT_THINKING_CEILING_ENV = "PI_SUBAGENT_THINKING_CEILING";
+
+const thinkingLevelRanks = new Map<ThinkingLevel, number>(THINKING_LEVELS.map((level, index) => [level, index]));
+
+export function parseThinkingLevel(value: unknown, field = "thinking level"): ThinkingLevel {
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (thinkingLevelRanks.has(trimmed as ThinkingLevel)) return trimmed as ThinkingLevel;
+	}
+	throw new Error(`Invalid ${field}; expected one of ${THINKING_LEVELS.join(", ")}.`);
+}
+
+export function compareThinkingLevels(left: ThinkingLevel, right: ThinkingLevel): number {
+	const leftRank = thinkingLevelRanks.get(left);
+	const rightRank = thinkingLevelRanks.get(right);
+	if (leftRank === undefined || rightRank === undefined) throw new Error(`Invalid thinking level comparison; expected one of ${THINKING_LEVELS.join(", ")}.`);
+	return leftRank - rightRank;
+}
+
+export function intersectThinkingCeilings(...ceilings: Array<ThinkingLevel | undefined>): ThinkingLevel | undefined {
+	const active = ceilings.filter((ceiling): ceiling is ThinkingLevel => ceiling !== undefined);
+	if (active.length === 0) return undefined;
+	return active.reduce((lowest, ceiling) => compareThinkingLevels(ceiling, lowest) < 0 ? ceiling : lowest);
+}
+
+export function decodeThinkingCeiling(value: string | undefined): ThinkingLevel | undefined {
+	if (value === undefined || value === "") return undefined;
+	return parseThinkingLevel(value, "inherited thinking ceiling");
+}
+
+export interface ThinkingCeilingCheck {
+	model?: string;
+	configThinking?: string | false;
+	ceiling?: ThinkingLevel;
+	agent?: string;
+	runId?: string;
+}
+
+export function assertThinkingWithinCeiling(input: ThinkingCeilingCheck): void {
+	if (!input.ceiling) return;
+	const requested = resolveEffectiveThinking(input.model, input.configThinking);
+	if (!requested) return;
+	const requestedLevel = parseThinkingLevel(requested, "requested thinking level");
+	if (compareThinkingLevels(requestedLevel, input.ceiling) <= 0) return;
+	const subject = [input.agent ? `agent '${input.agent}'` : undefined, input.runId ? `run '${input.runId}'` : undefined]
+		.filter((value): value is string => Boolean(value))
+		.join(" ");
+	throw new Error(`Thinking level '${requestedLevel}' exceeds configured maximum '${input.ceiling}'${subject ? ` for ${subject}` : ""}.`);
+}

package/src/shared/types.ts

@@ -8,9 +8,10 @@ import type { Message } from "@earendil-works/pi-ai";
 import type { AgentConfig } from "../agents/agents.ts";
 import type { FSWatcher } from "node:fs";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ModelScopeConfig } from "../runs/shared/model-scope.ts";
+import type { ModelScopeRule } from "../runs/shared/model-scope.ts";
 import type { ResolvedSubagentCapabilityCeiling, SubagentCapabilityAudit } from "../runs/shared/capability-ceiling.ts";
 import type { AuthorityPolicyConfig } from "../policy/authority.ts";
+import type { ThinkingLevel } from "./model-info.ts";
 import type { GlobalMissionIndexRecord, MissionRecord, MissionStoreConfig } from "../missions/types.ts";
 
 // ============================================================================
@@ -342,7 +343,7 @@ export interface ReviewProjection {
 }
 
 export interface FileMutationEffect {
-	status: "not-requested" | "not-applicable" | "observed" | "missing";
+	status: "not-requested" | "not-applicable" | "observed" | "missing" | "blocked";
 	expected: boolean;
 	attempted: boolean;
 	message?: string;
@@ -532,9 +533,11 @@ export interface SteeringRecoveryDescriptor {
 	sessionFile?: string;
 	cwd: string;
 	model?: string;
+	modelProvider?: string;
 	modelOverrideFromParent?: boolean;
 	fallbackModels?: string[];
 	thinking?: string;
+	thinkingCeiling?: ThinkingLevel;
 	tools?: string[];
 	extensions?: string[];
 	subagentOnlyExtensions?: string[];
@@ -957,6 +960,13 @@ export interface SingleResult {
 	modelAttempts?: ModelAttempt[];
 	controlEvents?: ControlEvent[];
 	error?: string;
+	/**
+	 * True when the dispatch failed because the input exceeded the model's
+	 * context window. The model fallback loop stops immediately (retrying the
+	 * same input on another model cannot succeed). Callers should treat this as
+	 * a signal to reduce input size or re-decompose the task.
+	 */
+	contextOverflow?: boolean;
 	protocolError?: ProtocolOutputLimit;
 	sessionFile?: string;
 	skills?: string[];
@@ -1022,6 +1032,7 @@ export interface WaitCompletionChild {
 	outputState?: SubagentOutputState;
 	error?: string;
 	model?: string;
+	contextOverflow?: boolean;
 	artifactPaths?: Partial<ArtifactPaths>;
 }
 
@@ -1364,6 +1375,12 @@ export interface ExternalJobStatus {
 	provider: string;
 	providerJobId?: string;
 	promptDigest: string;
+	operation?: "start" | "follow-up";
+	sourceRunId?: string;
+	sourceStepIndex?: number;
+	parentProviderJobId?: string;
+	requestId?: string;
+	requestDigest?: string;
 	options: Record<string, unknown>;
 	handleUrl?: string;
 	conversationUrl?: string;
@@ -1446,6 +1463,8 @@ export interface AsyncStatus {
 	/** Set when a durable schedule launched this run, so completions can name their origin. */
 	scheduleOrigin?: ScheduleOrigin;
 	steps?: Array<{
+		/** Stable caller-facing child identity for inspect/status/stop. */
+		childId?: string;
 		agent: string;
 		runner?: ExternalCliRunnerStatus | ExternalJobRunnerStatus;
 		externalProcess?: ExternalProcessStatus;
@@ -1465,6 +1484,8 @@ export interface AsyncStatus {
 		outputName?: string;
 		structured?: boolean;
 		status: "pending" | "running" | "complete" | "completed" | "failed" | "paused" | "stopped" | "rejected";
+		stopRequested?: boolean;
+		stopRequestedAt?: number;
 		children?: NestedRunSummary[];
 		sessionFile?: string;
 		transcriptPath?: string;
@@ -1494,8 +1515,11 @@ export interface AsyncStatus {
 		skills?: string[];
 		model?: string;
 		thinking?: string;
+		thinkingCeiling?: ThinkingLevel;
 		attemptedModels?: string[];
 		modelAttempts?: ModelAttempt[];
+		/** True when the child input exceeded the model context window. */
+		contextOverflow?: boolean;
 		totalCost?: CostSummary;
 		steering?: SteeringStatus;
 		error?: string;
@@ -1754,6 +1778,8 @@ export interface SubagentState {
 	};
 	/** Current-session top-level async capacity projection. */
 	activeAsyncCapacity?: ActiveAsyncCapacitySnapshot;
+	/** Herdr project panes opened by this Pi session, keyed by project root. */
+	herdrProjectPanes?: Map<string, HerdrProjectPaneSnapshot>;
 	asyncJobs: Map<string, AsyncJobState>;
 	/** Current-session active and recent async runs for the native fleet inspector. */
 	fleetJobs?: Map<string, AsyncJobState>;
@@ -1780,6 +1806,26 @@ export interface SubagentState {
 	waitSubscriptions?: Map<string, WaitSubscriptionRecord>;
 	/** Live in-process workflow controllers. Durable status remains on disk after settlement. */
 	workflowControllers?: Map<string, AbortController>;
+	/** Live in-process workflow child stoppers keyed by parent workflow run id. */
+	workflowChildStops?: Map<string, (childId: string, message?: string) => boolean>;
+}
+
+export interface HerdrProjectPaneSnapshot {
+	projectRoot: string;
+	bindingPath: string;
+	paneId: string;
+	openedAt: string;
+	lastFocusedAt?: string;
+	state: "open" | "stale";
+	agentStatus: string;
+	ownership: "verified" | "unknown" | "mismatch";
+	safeToClose: boolean;
+	refreshedAt: number;
+	summary?: string;
+	tabId?: string;
+	workspaceId?: string;
+	terminalTitle?: string;
+	staleReason?: string;
 }
 
 // ============================================================================
@@ -1815,9 +1861,28 @@ export const SUBAGENT_FOREGROUND_COMPLETE_EVENT = "subagent:foreground-complete"
 export const SUBAGENT_CONTROL_EVENT = "subagent:control-event";
 export const SUBAGENT_CONTROL_INTERCOM_EVENT = "subagent:control-intercom";
 export const SUBAGENT_STEERING_NOTICE_EVENT = "subagent:steering-notice";
+export const SUBAGENT_CHILD_STATUS_EVENT = "subagent:child-status";
 export const SUBAGENT_RESULT_INTERCOM_EVENT = "subagent:result-intercom";
 export const SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT = "subagent:result-intercom-delivery";
 
+export interface SubagentChildStatusEvent {
+	type: "subagent.child-status";
+	version: 1;
+	runId: string;
+	childId: string;
+	status: "stopping" | "stopped";
+	ts: number;
+	reason?: string;
+	source?: "rpc" | "async";
+	asyncDir?: string;
+	stepIndex?: number;
+	agent?: string;
+	childRunId?: string;
+	workflowKey?: string;
+	phase?: string;
+	label?: string;
+}
+
 // ============================================================================
 // Execution Options
 // ============================================================================
@@ -1885,12 +1950,13 @@ export interface RunSyncOptions {
 	llmIntentArbiter?: import("../runs/shared/llm-intent-arbiter.ts").TaskMutationArbiter;
 	/** Override the agent's default thinking level for this run */
 	thinkingOverride?: AgentConfig["thinking"];
+	thinkingCeiling?: ThinkingLevel;
 	/** Registry models available for heuristic bare-model resolution */
 	availableModels?: Array<{ provider: string; id: string; fullId: string }>;
 	/** Current parent-session provider to prefer for ambiguous bare model ids */
 	preferredModelProvider?: string;
 	/** Optional subagent model-scope enforcement for fallback candidates */
-	modelScope?: ModelScopeConfig;
+	modelScope?: ModelScopeRule | ModelScopeRule[];
 	/** Skills to make available (overrides agent default if provided) */
 	skills?: string[];
 	structuredOutput?: {
@@ -1972,7 +2038,7 @@ 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. */
+	/** Create one Orca observer tab per top-level subagent call. Experimental and opt-in. */
 	enabled?: boolean;
 }
 
@@ -2054,7 +2120,7 @@ export interface ExtensionConfig {
 	/** Artifact cleanup retention. Set cleanupDays to 0 to disable cleanup. */
 	artifactConfig?: Pick<ArtifactConfig, "cleanupDays">;
 	intercomBridge?: IntercomBridgeConfig;
-	/** Control how slow result-index scans are logged. Defaults to \"all\".
+	/** Control how slow result-index scans are logged. Defaults to \"activity\".
 	 *  - \"all\": log every slow scan, including scans that find nothing.
 	 *  - \"activity\": log only slow scans that found or scheduled work. Silences
 	 *    the periodic healthy rescan that inspects zero files while no async runs
@@ -2168,6 +2234,7 @@ export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
 export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
 export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
 export const POLL_INTERVAL_MS = 250;
+export const WIDGET_ANIMATION_INTERVAL_MS = 1000;
 export const MAX_WIDGET_JOBS = 4;
 export const DEFAULT_SUBAGENT_MAX_DEPTH = 2;
 export const SUBAGENT_ACTIONS = ["list", "get", "models", "children.list", "guide", "create", "update", "delete", "eject", "disable", "enable", "reset", "mission.create", "mission.list", "mission.show", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close", "worktree.discard", "refine", "refine.show", "refine.rollback", "inspector.open", "inspector.status", "inspector.close", "project.open", "project.status", "project.close", "status", "debug.run", "grant-spawn-budget", "interrupt", "resume", "steer", "stop", "dismiss", "doctor", "watchdog.status", "watchdog.check", "watchdog.configure", "watchdog.recommend-model", "schedule.create", "schedule.list", "schedule.show", "schedule.history", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"] as const;

package/src/tui/fleet-status.ts

@@ -2,7 +2,7 @@ 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 type { AsyncJobState, AsyncJobStep, FleetViewPlacement, HerdrProjectPaneSnapshot, NestedRunSummary, NestedStepSummary, SubagentState } from "../shared/types.ts";
 import { formatWorkflowJsonPreview } from "../workflows/scripted-workflow.ts";
 
 export const FLEET_STATUS_WIDGET_KEY = "subagent-fleet-status";
@@ -17,6 +17,7 @@ type FleetStatusTui = {
 };
 type FleetStatusEntry = {
 	key: string;
+	surface?: "project-pane";
 	parentKey?: string;
 	workflowWrapper?: boolean;
 	agent: string;
@@ -26,6 +27,7 @@ type FleetStatusEntry = {
 	tokens: number;
 	state: string;
 	external?: true;
+	projectPane?: HerdrProjectPaneSnapshot;
 	nestedChildren?: NestedRunSummary[];
 	workflowRows?: FleetWorkflowRow[];
 };
@@ -284,7 +286,32 @@ function foregroundDescription(control: { parentWorkflowRunId?: string; workflow
 }
 
 function activeLeafAgentCount(entries: FleetStatusEntry[]): number {
-	return entries.filter((entry) => !entry.workflowWrapper).length;
+	return entries.filter((entry) => !entry.workflowWrapper && !entry.surface).length;
+}
+
+function projectPaneNeedsAttention(pane: HerdrProjectPaneSnapshot): boolean {
+	return ["attention", "blocked", "paused", "failed", "error"].some((status) => pane.agentStatus.includes(status))
+		|| pane.summary?.includes("⚠") === true;
+}
+
+function projectName(projectRoot: string): string {
+	return projectRoot.split(/[\\/]/).filter(Boolean).at(-1) ?? projectRoot;
+}
+
+function projectPaneEntries(state: SubagentState): FleetStatusEntry[] {
+	return [...(state.herdrProjectPanes?.values() ?? [])]
+		.filter((pane) => pane.state === "open")
+		.sort((left, right) => left.openedAt.localeCompare(right.openedAt) || left.projectRoot.localeCompare(right.projectRoot))
+		.map((pane) => ({
+			key: `project-pane:${pane.projectRoot}`,
+			surface: "project-pane" as const,
+			agent: `${projectName(pane.projectRoot)} · ${pane.paneId}`,
+			description: pane.summary,
+			startedAt: Date.parse(pane.openedAt) || pane.refreshedAt,
+			tokens: 0,
+			state: pane.agentStatus || "unknown",
+			projectPane: pane,
+		}));
 }
 
 export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntry[] {
@@ -406,6 +433,7 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 		}
 	}
 
+	entries.push(...projectPaneEntries(state));
 	return entries.sort((left, right) => left.startedAt - right.startedAt || left.key.localeCompare(right.key));
 }
 
@@ -483,7 +511,7 @@ export class SubagentFleetStatus {
 			this.clearWidget();
 			return;
 		}
-		if (this.entries.length === 0 && !(this.state.activeAsyncCapacity?.used)) {
+		if (!this.hasInlineSurface()) {
 			this.active = false;
 			this.selectedKey = "main";
 			this.lastRenderKey = "";
@@ -578,26 +606,31 @@ export class SubagentFleetStatus {
 	}
 
 	render(width: number, theme: Theme): string[] {
-		if (this.entries.length === 0 && !(this.state.activeAsyncCapacity?.used)) return [];
+		if (!this.hasInlineSurface()) return [];
 		if (!this.active) {
-			const tokens = this.entries.reduce((total, entry) => total + entry.tokens, 0);
+			const workEntries = this.entries.filter((entry) => !entry.surface);
+			const projectEntries = this.entries.filter((entry) => entry.surface === "project-pane");
+			const tokens = workEntries.reduce((total, entry) => total + entry.tokens, 0);
 			const capacity = this.state.activeAsyncCapacity;
-			const hasNativeRows = this.entries.some((entry) => !entry.external);
+			const hasNativeRows = workEntries.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 activeEntries = activeLeafAgentCount(workEntries);
+			const noun = workEntries.some((entry) => entry.external) ? "job" : "agent";
 			const agents = activeEntries > 0 ? `${activeEntries} active ${noun}${activeEntries === 1 ? "" : "s"}` : "";
-			const label = [agents, asyncRuns].filter(Boolean).join(" · ");
+			const paneAttention = projectEntries.filter((entry) => entry.projectPane && projectPaneNeedsAttention(entry.projectPane)).length;
+			const panes = projectEntries.length > 0 ? `${projectEntries.length} pane${projectEntries.length === 1 ? "" : "s"}${paneAttention ? ` (${paneAttention} ⚠)` : ""}` : "";
+			const label = [agents, asyncRuns, panes].filter(Boolean).join(" · ");
 			const detail = [showNativeSummary ? formatFleetTokens(tokens) : undefined, "↓/← to inspect"].filter(Boolean).join(" · ");
-			return [truncateToWidth(`  ${theme.fg("muted", label)} · ${theme.fg("dim", detail)}`, width)];
+			return [truncateToWidth(`  ${theme.fg("muted", label)}${label && detail ? " · " : ""}${theme.fg("dim", detail)}`, width)];
 		}
 		const roster = this.rosterKeys();
 		const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
 		const lines = [truncateToWidth(`  ${theme.fg("dim", "↑↓/jk select · enter inspect · esc back")}`, width), ""];
 		lines.push(truncateToWidth(`  ${this.bullet(0, selectedIndex, theme)} main`, width));
 
-		const tree = fleetTreeRows(this.entries);
+		const workEntries = this.entries.filter((entry) => !entry.surface);
+		const tree = fleetTreeRows(workEntries);
 		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;
@@ -615,15 +648,30 @@ export class SubagentFleetStatus {
 			}
 		}
 		if (hiddenBelow > 0) lines.push(rightAlign("", theme.fg("dim", `↓ ${hiddenBelow} more`), width));
+		this.renderProjectPaneSection(lines, selectedIndex, width, theme);
 		return lines;
 	}
 
+	private renderProjectPaneSection(lines: string[], selectedIndex: number, width: number, theme: Theme): void {
+		const entries = this.entries.filter((entry) => entry.surface === "project-pane");
+		if (!entries.length) return;
+		lines.push("", truncateToWidth(`  ${theme.fg("dim", "project panes")}`, width));
+		for (const entry of entries) {
+			const rosterIndex = this.entries.findIndex((candidate) => candidate.key === entry.key) + 1;
+			lines.push(this.renderEntry(rosterIndex, selectedIndex, entry, width, theme));
+		}
+	}
+
+
 	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 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", entry.external ? formatFleetElapsed(elapsed) : `${formatFleetElapsed(elapsed)} · ${formatFleetTokens(entry.tokens)}`);
+		const rightText = entry.projectPane
+			? `${entry.projectPane.summary ?? "—"} · ${formatFleetElapsed(Date.now() - entry.projectPane.refreshedAt)} ago`
+				: entry.external ? formatFleetElapsed(elapsed) : `${formatFleetElapsed(elapsed)} · ${formatFleetTokens(entry.tokens)}`;
+		const right = theme.fg("dim", rightText);
 		return rightAlign(left, right, width);
 	}
 
@@ -692,6 +740,7 @@ export class SubagentFleetStatus {
 			entries: this.entries.map((entry) => this.active
 				? [
 					entry.key,
+					entry.surface,
 					entry.parentKey,
 					entry.agent,
 					entry.state,
@@ -719,10 +768,14 @@ export class SubagentFleetStatus {
 						row.overflow,
 					]),
 				]
-				: [entry.key, entry.state, entry.external, entry.tokens]),
+				: [entry.key, entry.state, entry.external, entry.surface, entry.tokens, entry.projectPane?.refreshedAt, entry.projectPane?.summary]),
 		});
 	}
 
+	private hasInlineSurface(): boolean {
+		return this.entries.length > 0 || Boolean(this.state.activeAsyncCapacity?.used);
+	}
+
 	private getActiveUiContext(): ExtensionContext | undefined {
 		const ctx = this.ctx;
 		if (!ctx) return undefined;

package/src/tui/render.ts

@@ -18,7 +18,7 @@ import {
 	type WorkflowNodeStatus,
 	type MainWindowRendererConfig,
 	MAX_WIDGET_JOBS,
-	POLL_INTERVAL_MS,
+	WIDGET_ANIMATION_INTERVAL_MS,
 	WIDGET_KEY,
 } from "../shared/types.ts";
 import { sanitizeDisplayText, truncateDisplayText } from "../shared/display-text.ts";
@@ -1580,7 +1580,7 @@ function buildWidgetComponent(jobs: AsyncJobState[], expanded: boolean): (_tui:
 		const container = new Container();
 		container.render = (renderWidth: number): string[] => {
 			const width = Math.max(0, renderWidth - 2);
-			const frame = Math.floor(Date.now() / POLL_INTERVAL_MS);
+			const frame = Math.floor(Date.now() / WIDGET_ANIMATION_INTERVAL_MS);
 			const buildLines = (): string[] => expanded
 				? buildWidgetLines(jobs, theme, width, true, frame)
 				: jobs.length === 1
@@ -1746,8 +1746,9 @@ function workflowRowStateLabel(row: WorkflowChatProgressRow, theme: Theme): stri
 }
 
 function workflowOverallState(rows: WorkflowChatProgressRow[], hasTerminalValue: boolean, isError?: boolean): "running" | "complete" | "failed" | "paused" {
-	if (isError || rows.some((row) => row.state === "failed")) return "failed";
+	if (rows.some((row) => row.state === "failed")) return "failed";
 	if (rows.some((row) => row.state === "detached")) return "paused";
+	if (isError) return "failed";
 	if ((rows.length > 0 && rows.every((row) => row.state === "complete")) || hasTerminalValue) return "complete";
 	return "running";
 }
@@ -1948,7 +1949,7 @@ export function renderSubagentResult(
 	const layout = resolveMainWindowRenderLayout(rendererConfig);
 	const compact = (component: Component): Component => capCompactMainWindowResult(component, layout, theme, !options.expanded);
 	const d = result.details;
-	if (d?.mode === "workflow" && d.chatProgress?.mode === "live-card" && !result.isError && d.workflow?.value === undefined) {
+	if (d?.mode === "workflow" && d.chatProgress?.mode === "live-card" && d.workflow?.value === undefined && (!result.isError || (d.workflow?.trace.length ?? 0) > 0)) {
 		return compact(renderWorkflowChatProgress(d, result, theme, options.expanded ? resolveMainWindowRenderLayout() : layout, frame));
 	}
 	if (!d || !d.results.length) {