pi-extensible-workflows 3.1.0 → 3.3.0

package/src/host.ts

@@ -1,11 +1,12 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Type } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
-import { copyToClipboard, getAgentDir, highlightCode, truncateToVisualLines, type ExtensionAPI, type Theme } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, getAgentDir, SettingsManager, truncateToVisualLines, type ExtensionAPI, type Theme } from "@earendil-works/pi-coding-agent";
 import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor, type AgentActivity, type AgentAttempt, type AgentDefinition, type AgentProgress, type AgentProviderFailure, type AgentProviderRecovery, type SessionFactory } from "./agent-execution.js";
 import { herdrPaneId, openHerdrPane } from "./herdr.js";
 import { acquireSessionLease, listRunIds, RunStore, SessionLease, structuralPath as operationPath } from "./persistence.js";
@@ -15,8 +16,12 @@ import { asWorkflowError, aliasDrift, createLaunchSnapshot, deepFreeze, errorCod
 import { launchScriptForSnapshot, loadAgentDefinitions, preflight, resolveAgentResourcePolicy, resolveWorkflowSettings, saveModelAliases, validateAgentOptions, validateCheckpoint, validateModelAliasAvailability, validateShellOptions, validateWorkflowLaunchWithRegistry, workflowProjectSettingsPath, workflowPrompt, workflowSettingsPath } from "./validation.js";
 import { beginWorkflowExtensionLoading, loadingRegistry, resetWorkflowRegistry, type WorkflowRegistryApi } from "./registry.js";
 import { agentIdentityPath, agentWorktree, encoded, executeShellCommand, persistActiveAgentAttempt, persistAgentAttempts, readShellResult, runWorkflow, shellIdentityPath } from "./execution.js";
-import { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WORKFLOW_AGENT_STATE_CHANGED_EVENT, WORKFLOW_BUDGET_EVENT, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, WORKFLOW_PHASE_CHANGED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, WORKFLOW_WORKTREE_CREATED_EVENT, WorkflowError, type AgentAttemptSummary, type AgentOptions, type AgentRecord, type AgentResourcePolicy, type BudgetApprovalRequest, type BudgetEvent, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type WorkflowBridge, type WorkflowCatalogFunction, type WorkflowCatalogIndex, type WorkflowCatalogVariable, type WorkflowCheckpointState, type WorkflowErrorCode, type WorkflowErrorShape, type WorkflowEventBase, type WorkflowFailureAgent, type WorkflowFailureDiagnostics, type WorkflowFunctionContext, type WorkflowExecution, type WorkflowMetadata, type WorkflowModelAliasResolverContext, type WorkflowRetryProvenance, type WorkflowRunContext, type WorkflowSettings, type WorkflowSettingsResolution, type WorkflowSiblingAgent, type WorkflowWorktreeReference } from "./types.js";
+import { openWorkflowArtifact, workflowResultArtifact, workflowScriptArtifact, type WorkflowArtifact } from "./workflow-artifacts.js";
+import { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WORKFLOW_AGENT_STALL_THRESHOLD_MS, WORKFLOW_AGENT_STATE_CHANGED_EVENT, WORKFLOW_BUDGET_EVENT, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, WORKFLOW_PHASE_CHANGED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, WORKFLOW_WORKTREE_CREATED_EVENT, WorkflowError, type AgentOptions, type AgentRecord, type AgentResourcePolicy, type BudgetApprovalRequest, type BudgetEvent, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type WorkflowBridge, type WorkflowCatalogFunction, type WorkflowCatalogIndex, type WorkflowCatalogVariable, type WorkflowCheckpointState, type WorkflowErrorCode, type WorkflowErrorShape, type WorkflowEventBase, type WorkflowFailureAgent, type WorkflowFailureDiagnostics, type WorkflowFunctionContext, type WorkflowExecution, type WorkflowMetadata, type WorkflowModelAliasResolverContext, type WorkflowRetryProvenance, type WorkflowRunContext, type WorkflowSettings, type WorkflowSettingsResolution, type WorkflowSiblingAgent, type WorkflowWorktreeReference } from "./types.js";
 const SETTLED_AGENT_STATES: ReadonlySet<import("./types.js").AgentState> = new Set(["completed", "failed", "cancelled"]);
+const INTERNAL_WORKFLOW_TOOLS: readonly string[] = ["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"];
+const HARD_TERMINAL_RUN_STATES: ReadonlySet<string> = new Set(["completed", "failed", "stopped"]);
+const SHUTDOWN_TERMINAL_RUN_STATES: ReadonlySet<string> = new Set(["completed", "failed", "stopped", "budget_exhausted"]);
 export interface WorkflowProgressStyles {
   accent(text: string): string;
   success(text: string): string;
@@ -28,14 +33,14 @@ export interface WorkflowProgressStyles {
 }
 function snapshotResourcePolicy(snapshot: Readonly<LaunchSnapshot>, cwd: string, projectTrusted: boolean, globalSettingsPath: string): AgentResourcePolicy {
   const empty = { skills: [], extensions: [] };
-  return { globalSettingsPath, projectSettingsPath: join(cwd, ".pi", "pi-extensible-workflows", "settings.json"), projectTrusted, global: empty, project: empty, effective: snapshot.settings.disabledAgentResources ?? empty, unmatchedSkills: [], unmatchedExtensions: [] };
+  return { globalSettingsPath, projectSettingsPath: workflowProjectSettingsPath(cwd), projectTrusted, global: empty, project: empty, effective: snapshot.settings.disabledAgentResources ?? empty, unmatchedSkills: [], unmatchedExtensions: [] };
 }
 const PLAIN_WORKFLOW_PROGRESS_STYLES: WorkflowProgressStyles = { accent: (text) => text, success: (text) => text, error: (text) => text, warning: (text) => text, muted: (text) => text, dim: (text) => text, bold: (text) => text };
-type WorkflowLaunchSettings = { settings: Readonly<WorkflowSettings>; resolution: WorkflowSettingsResolution; resourcePolicy: AgentResourcePolicy; modelSettingsPath: string };
+type WorkflowLaunchSettings = { settings: Readonly<WorkflowSettings>; resolution: WorkflowSettingsResolution; resourcePolicy: AgentResourcePolicy };
 function workflowLaunchSettings(cwd: string, projectTrusted: boolean, globalSettingsPath: string, concurrency?: number): WorkflowLaunchSettings {
   const resolution = resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath);
   const settings = Object.freeze({ ...resolution.effective, ...(concurrency === undefined ? {} : { concurrency }) });
-  return { settings, resolution, resourcePolicy: resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath), modelSettingsPath: resolution.sources.modelAliases };
+  return { settings, resolution, resourcePolicy: resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath) };
 }
 function frozenResourcePolicy(policy: AgentResourcePolicy): () => AgentResourcePolicy { return () => structuredClone(policy); }
 function resumedSnapshotSettings(snapshot: Readonly<LaunchSnapshot>, resolution: WorkflowSettingsResolution, modelAliases: Readonly<Record<string, string>>): { settings: WorkflowSettings; settingsSources?: NonNullable<LaunchSnapshot["settingsSources"]> } {
@@ -89,9 +94,10 @@ function mainAgentError(error: unknown): WorkflowError {
   const typed = asWorkflowError(error);
   const presented = new WorkflowError(typed.code, formatWorkflowFailure(typed));
   Object.assign(presented, typed);
-  presented.message = formatWorkflowFailure(typed);
   return presented;
 }
+function workflowFailedAt(error: unknown): string | undefined { return object(error) && typeof error.failedAt === "string" && error.failedAt ? error.failedAt : undefined; }
+function persistedFailure(run: PersistedRun, error: WorkflowError): PersistedRun { const failedAt = workflowFailedAt(error); return { ...run, error: { code: error.code, message: error.message, ...(failedAt ? { failedAt } : {}) }, ...(failedAt ? { failedAt } : {}) }; }
 
 export class RunLifecycle {
   #state: RunState;
@@ -144,7 +150,7 @@ export class RunLifecycle {
   }
 
   async terminal(state: "completed" | "failed" | "stopped" | "interrupted" | "budget_exhausted", reason?: string): Promise<void> {
-    if (["completed", "failed", "stopped"].includes(this.#state)) throw new WorkflowError("RESUME_INCOMPATIBLE", `${this.#state} runs are terminal`);
+    if (HARD_TERMINAL_RUN_STATES.has(this.#state)) throw new WorkflowError("RESUME_INCOMPATIBLE", `${this.#state} runs are terminal`);
     await this.#set(state, reason ?? state);
     for (const resolve of this.#waiters.splice(0)) resolve();
   }
@@ -164,25 +170,39 @@ export function formatWorkflowPreview(args: { script?: unknown; workflow?: unkno
   return [`workflow ${name}`, typeof args.description === "string" && args.description.trim() ? args.description.trim() : ""].filter(Boolean).join("\n");
 }
 export const WORKFLOW_TOOL_LABEL = "Workflow";
-export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow";
-export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow that orchestrates subagents. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Runs in the background by default; completion arrives as a follow-up message. Foreground results include the completed run ID. Use workflow_retry with an explicit failed run ID to replay completed structural operations; parentRunId only reuses named worktrees.";
+export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline parallel-to-summary path by default";
+export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow. Prefer a named inline script that fans out independent work with parallel(...), awaits the keyed results before interpolating them into one summarizing agent(...), and returns. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Advanced controls include registered functions, outputSchema, budgets, checkpoints, worktrees, retry/resume, CLI export, and pipelines. Use workflow_retry with an explicit failed run ID; parentRunId only reuses named worktrees. Runs are in the background by default; completion arrives as a follow-up message. Set foreground: true when the caller must wait for the final value. If a foreground call detaches before its result is accepted, its terminal success or failure is promoted to one follow-up message. Foreground results include the completed run ID. Recovery inherits the source launch mode; legacy snapshots without launchMode recover in the background. Set foreground: true or false on workflow_resume/workflow_retry to override it; foreground recovery waits for terminal value and run details, while background recovery returns immediately with a follow-up. Recovery map: agent(..., { retries }) reruns one agent call in the same run for transient failures; workflow_retry({ runId, foreground? }) replays a failed run into a child; workflow_resume({ runId, budget?, foreground? }) continues a budget_exhausted run; parentRunId on a new launch only borrows named worktrees and never replays or resumes."
+function workflowRecoveryGuidance(action: "resume" | "retry", state: RunState): string {
+  if (action === "resume") {
+    if (state === "failed") return "Failed workflow runs must use workflow_retry({ runId })";
+    if (state === "completed") return "Completed workflow runs have no recovery action";
+    if (state === "stopped") return "Stopped workflow runs have no recovery action; launch a new workflow";
+    if (state === "interrupted") return "Interrupted workflow runs use /workflow resume, not workflow_resume";
+    return `Only budget-exhausted runs can be resumed with workflow_resume; source is ${state}`;
+  }
+  if (state === "budget_exhausted") return "Budget-exhausted workflow runs must use workflow_resume({ runId, budget? })";
+  if (state === "completed") return "Completed workflow runs have no recovery action";
+  if (state === "stopped") return "Stopped workflow runs cannot be retried; launch a new workflow";
+  if (state === "interrupted") return "Interrupted workflow runs use /workflow resume, not workflow_retry";
+  return `Only failed workflow runs can be retried; source is ${state}`;
+}
 export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
-  name: Type.Optional(Type.String({ description: "Required non-empty name for inline workflow runs; invalid for registered function launches" })),
+  name: Type.Optional(Type.String({ description: "Required non-empty name for the default inline workflow path; invalid for registered function launches" })),
   description: Type.Optional(Type.String({ description: "Optional human-readable workflow description" })),
-  script: Type.Optional(Type.String({ description: "Immutable workflow source without metadata" })),
-  workflow: Type.Optional(Type.String({ description: "Registered reusable function as an unqualified name" })),
+  script: Type.Optional(Type.String({ description: "Immutable inline workflow source; default to a named script that fans out with parallel(...) and awaits results before passing them to a summarizing agent(...)" })),
+  workflow: Type.Optional(Type.String({ description: "Advanced: registered reusable function as an unqualified name" })),
   args: Type.Optional(Type.Unknown({ description: "JSON-compatible workflow arguments" })),
-  foreground: Type.Optional(Type.Boolean({ description: "Wait for completion instead of running in the background" })),
-  concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 16 })),
-  budget: Type.Optional(Type.Unknown({ description: "Optional aggregate soft and hard run budgets" })),
-  parentRunId: Type.Optional(Type.String({ description: "Terminal run whose named worktrees may be reused" })),
+  foreground: Type.Optional(Type.Boolean({ description: "Wait for completion instead of the default background launch" })),
+  concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 16, description: "Advanced: optional per-run active-agent limit" })),
+  budget: Type.Optional(Type.Unknown({ description: "Advanced: optional aggregate soft and hard run budgets" })),
+  parentRunId: Type.Optional(Type.String({ description: "Advanced: terminal run whose named worktrees may be reused" })),
 });
-export const WORKFLOW_RETRY_PARAMETERS = Type.Object({ runId: Type.String({ description: "Explicit failed workflow run ID" }) });
+export const WORKFLOW_RETRY_PARAMETERS = Type.Object({ runId: Type.String({ description: "Explicit failed workflow run ID" }), foreground: Type.Optional(Type.Boolean({ description: "Override the source launch mode for this recovery" })) });
 
 type WorkflowToolUpdate = { content: [{ type: "text"; text: string }]; details: { runId: string; run: PersistedRun } };
 export type WorkflowPhaseState = "not started" | "running" | "completed" | "failed" | "cancelled" | "interrupted" | "budget_exhausted";
 export interface WorkflowPhaseAgentCounts { total: number; completed: number; running: number; failed: number; cancelled: number; pending: number }
-export interface WorkflowPhaseView { id: string; name: string; occurrence: number; state: WorkflowPhaseState; status: WorkflowPhaseState; observed: boolean; afterAgent?: number; agents: readonly AgentRecord[]; counts: WorkflowPhaseAgentCounts }
+export interface WorkflowPhaseView { id: string; name: string; occurrence: number; state: WorkflowPhaseState; observed: boolean; afterAgent?: number; agents: readonly AgentRecord[]; counts: WorkflowPhaseAgentCounts }
 export interface WorkflowPhaseModel { declaredPhases: readonly string[]; phases: readonly WorkflowPhaseView[]; currentPhaseIndex?: number; currentPhaseId?: string; counts: Readonly<Partial<Record<WorkflowPhaseState, number>>>; unassignedAgents?: readonly AgentRecord[] }
 type WorkflowPhaseSource = readonly string[] | Pick<LaunchSnapshot, "phases"> | undefined;
 function phaseNames(source: WorkflowPhaseSource): string[] {
@@ -244,7 +264,7 @@ export function buildWorkflowPhaseModel(run: Pick<PersistedRun, "state" | "phase
     const agents = observation?.agents ?? [];
     const counts = phaseAgentCounts(agents);
     const state = observation ? phaseState(run.state, counts, entry.observedIndex === observedEntries.length - 1) : "not started";
-    return { id: `${entry.name}#${String(occurrence)}`, name: entry.name, occurrence, state, status: state, observed: observation !== undefined, ...(observation ? { afterAgent: observation.afterAgent } : {}), agents, counts };
+    return { id: `${entry.name}#${String(occurrence)}`, name: entry.name, occurrence, state, observed: observation !== undefined, ...(observation ? { afterAgent: observation.afterAgent } : {}), agents, counts };
   });
   let currentPhaseIndex: number | undefined;
   for (let index = phases.length - 1; index >= 0; index -= 1) { if (phases[index]?.observed) { currentPhaseIndex = index; break; } }
@@ -258,12 +278,167 @@ export function buildWorkflowPhaseModel(run: Pick<PersistedRun, "state" | "phase
   if (unassignedAgents.length) result.unassignedAgents = unassignedAgents;
   return result;
 }
-export interface WorkflowPhaseSelection { phaseId?: string | undefined; agentId?: string | undefined }
+export interface WorkflowPhaseSelection { phaseId?: string | undefined; agentId?: string | undefined; nodeId?: string | undefined; expandedNodeIds?: readonly string[] | undefined; treeOnly?: boolean | undefined; detailsOnly?: boolean | undefined; actions?: { title: string; options: readonly string[]; index: number } | undefined }
+export type WorkflowPhaseTreeNodeKind = "phase" | "operation" | "agent";
+export interface WorkflowPhaseTreeNode { id: string; kind: WorkflowPhaseTreeNodeKind; label: string; depth: number; phaseId: string; operationPath: readonly string[]; parentId?: string; children: readonly string[]; state: WorkflowPhaseState | AgentRecord["state"]; agentId?: string; agent?: AgentRecord; phase?: WorkflowPhaseView }
+export interface WorkflowPhaseTree { roots: readonly string[]; nodes: readonly WorkflowPhaseTreeNode[]; byId: ReadonlyMap<string, WorkflowPhaseTreeNode> }
+export interface WorkflowPhaseTreeSelection { nodeId?: string | undefined }
+export type WorkflowPhaseTreeDirection = "up" | "down" | "left" | "right";
+function workflowPhaseTreePath(kind: WorkflowPhaseTreeNodeKind, phaseId: string, operationPath: readonly string[], agentId?: string): string {
+  const root = `phase/${encodeURIComponent(phaseId)}`;
+  if (kind === "phase") return root;
+  const operation = operationPath.map((part) => encodeURIComponent(part)).join("/");
+  if (kind === "operation") return `${root}/operation/${operation}`;
+  return operation ? `${root}/operation/${operation}/agent/${encodeURIComponent(agentId ?? "")}` : `${root}/agent/${encodeURIComponent(agentId ?? "")}`;
+}
+function workflowPhaseTreeAggregateState(states: readonly AgentRecord["state"][]): AgentRecord["state"] {
+  if (!states.length || states.every((state) => state === "completed")) return "completed";
+  if (states.some((state) => state === "failed")) return "failed";
+  if (states.some((state) => state === "cancelled")) return "cancelled";
+  if (states.some((state) => state === "running")) return "running";
+  return "queued";
+}
+export function buildWorkflowPhaseTree(model: WorkflowPhaseModel): WorkflowPhaseTree {
+  type Draft = Omit<WorkflowPhaseTreeNode, "children"> & { children: string[] };
+  type AgentEntry = { agent: AgentRecord; node: Draft; path: readonly string[]; defaultParentId: string };
+  const drafts = new Map<string, Draft>();
+  const roots: string[] = [];
+  const add = (node: Omit<Draft, "children">, parentId?: string): Draft => {
+    const existing = drafts.get(node.id);
+    if (existing) return existing;
+    const draft: Draft = { ...node, ...(parentId === undefined ? {} : { parentId }), children: [] };
+    drafts.set(draft.id, draft);
+    if (parentId === undefined) roots.push(draft.id); else drafts.get(parentId)?.children.push(draft.id);
+    return draft;
+  };
+  const samePath = (left: readonly string[], right: readonly string[]): boolean => left.length === right.length && left.every((part, index) => part === right[index]);
+  const addPhase = (phaseId: string, label: string, agents: readonly AgentRecord[], phase?: WorkflowPhaseView): void => {
+    const phaseNode = add({ id: workflowPhaseTreePath("phase", phaseId, []), kind: "phase", label, depth: 0, phaseId, operationPath: [], state: phase?.state ?? workflowPhaseTreeAggregateState(agents.map((agent) => agent.state)), ...(phase ? { phase } : {}) });
+    const operationNodes = new Map<string, Draft>();
+    const entries: AgentEntry[] = agents.map((agent) => ({ agent, path: [...(agent.structuralPath ?? [])], node: undefined as unknown as Draft, defaultParentId: phaseNode.id }));
+    const agentEntries = new Map(entries.map((entry) => [entry.agent.id, entry]));
+    const acceptedParents = new Map<string, string>();
+    const wouldCycle = (childId: string, parentId: string): boolean => {
+      const seen = new Set<string>([childId]);
+      let current: string | undefined = parentId;
+      while (current) {
+        if (seen.has(current)) return true;
+        seen.add(current);
+        current = acceptedParents.get(current);
+      }
+      return false;
+    };
+    for (const entry of entries) {
+      const parent = entry.agent.parentId ? agentEntries.get(entry.agent.parentId) : undefined;
+      if (parent && !wouldCycle(entry.agent.id, parent.agent.id)) acceptedParents.set(entry.agent.id, parent.agent.id);
+    }
+    const operationChain = (path: readonly string[], owner: Draft, startIndex = 0): Draft => {
+      let parent = owner;
+      for (let index = startIndex; index < path.length; index += 1) {
+        const prefix = path.slice(0, index + 1);
+        const key = `${owner.id}:${JSON.stringify(prefix)}`;
+        const existing = operationNodes.get(key);
+        if (existing) { parent = existing; continue; }
+        const suffix = path.slice(startIndex, index + 1).map((part) => encodeURIComponent(part)).join("/");
+        const id = owner.id === phaseNode.id ? workflowPhaseTreePath("operation", phaseId, prefix) : `${owner.id}/operation/${suffix}`;
+        const operation = add({ id, kind: "operation", label: prefix.at(-1) ?? "", depth: 0, phaseId, operationPath: prefix, state: "queued", ...(phase ? { phase } : {}) }, parent.id);
+        operationNodes.set(key, operation);
+        parent = operation;
+      }
+      return parent;
+    };
+    for (const entry of entries) {
+      if (!acceptedParents.has(entry.agent.id)) entry.defaultParentId = operationChain(entry.path, phaseNode).id;
+    }
+    for (const entry of entries) {
+      entry.node = add({ id: workflowPhaseTreePath("agent", phaseId, entry.path, entry.agent.id), kind: "agent", label: entry.agent.label ?? entry.agent.name, depth: 0, phaseId, operationPath: entry.path, state: entry.agent.state, agentId: entry.agent.id, agent: entry.agent }, phaseNode.id);
+    }
+    const attach = (entry: AgentEntry, parentId: string): void => {
+      const previous = entry.node.parentId ? drafts.get(entry.node.parentId) : undefined;
+      if (previous) previous.children = previous.children.filter((childId) => childId !== entry.node.id);
+      entry.node.parentId = parentId;
+      const parent = drafts.get(parentId);
+      if (parent && !parent.children.includes(entry.node.id)) parent.children.push(entry.node.id);
+    };
+    for (const entry of entries) {
+      const parentId = acceptedParents.get(entry.agent.id);
+      const parent = parentId ? agentEntries.get(parentId) : undefined;
+      if (parent) {
+        if (samePath(entry.path, parent.path)) entry.defaultParentId = parent.node.id;
+        else {
+          const commonLength = entry.path.findIndex((part, index) => parent.path[index] !== part);
+          const startIndex = commonLength < 0 ? Math.min(entry.path.length, parent.path.length) : commonLength;
+          entry.defaultParentId = operationChain(entry.path, parent.node, startIndex).id;
+        }
+      }
+      attach(entry, entry.defaultParentId);
+    }
+    const setDepth = (node: Draft, depth: number, seen = new Set<string>()): void => {
+      if (seen.has(node.id)) return;
+      seen.add(node.id);
+      node.depth = depth;
+      for (const childId of node.children) { const child = drafts.get(childId); if (child) setDepth(child, depth + 1, seen); }
+    };
+    setDepth(phaseNode, 0);
+    const statesFor = (node: Draft, seen = new Set<string>()): AgentRecord["state"][] => {
+      if (seen.has(node.id)) return [];
+      const nextSeen = new Set(seen).add(node.id);
+      return node.children.flatMap((childId) => {
+        const child = drafts.get(childId);
+        return child?.kind === "agent" ? [child.agent?.state ?? "queued", ...statesFor(child, nextSeen)] : child ? statesFor(child, nextSeen) : [];
+      });
+    };
+    for (const operation of operationNodes.values()) operation.state = workflowPhaseTreeAggregateState(statesFor(operation));
+  };
+  for (const phase of model.phases) addPhase(phase.id, `${phase.name}${phase.occurrence > 1 ? ` #${String(phase.occurrence)}` : ""}`, phase.agents, phase);
+  if (model.unassignedAgents?.length) addPhase("unassigned", "Unassigned", model.unassignedAgents);
+  const nodes = [...drafts.values()].map((node) => ({ ...node, children: [...node.children] }));
+  return { roots, nodes, byId: new Map(nodes.map((node) => [node.id, node])) };
+}
+export function workflowPhaseTreeVisibleNodes(tree: WorkflowPhaseTree, expanded: ReadonlySet<string> = new Set()): readonly WorkflowPhaseTreeNode[] {
+  const visible: WorkflowPhaseTreeNode[] = [];
+  const visit = (id: string): void => {
+    const node = tree.byId.get(id);
+    if (!node) return;
+    visible.push(node);
+    if (expanded.has(node.id)) for (const childId of node.children) visit(childId);
+  };
+  for (const root of tree.roots) visit(root);
+  return visible;
+}
+export function workflowPhaseTreeInitialExpanded(tree: WorkflowPhaseTree): ReadonlySet<string> {
+  return new Set(tree.nodes.filter((node) => node.children.length > 0).map((node) => node.id));
+}
+export function preserveWorkflowPhaseTreeSelection(tree: WorkflowPhaseTree, selection: WorkflowPhaseTreeSelection): WorkflowPhaseTreeSelection {
+  const node = (selection.nodeId ? tree.byId.get(selection.nodeId) : undefined) ?? tree.nodes[0];
+  return node ? { nodeId: node.id } : {};
+}
+export function navigateWorkflowPhaseTree(tree: WorkflowPhaseTree, selectedNodeId: string | undefined, expandedNodeIds: ReadonlySet<string>, direction: WorkflowPhaseTreeDirection): { nodeId?: string; expandedNodeIds: ReadonlySet<string> } {
+  const expanded = new Set(expandedNodeIds);
+  const current = (selectedNodeId ? tree.byId.get(selectedNodeId) : undefined) ?? tree.nodes[0];
+  if (!current) return { expandedNodeIds: expanded };
+  if (direction === "left") {
+    if (current.children.length && expanded.delete(current.id)) return { nodeId: current.id, expandedNodeIds: expanded };
+    return { nodeId: current.parentId ?? current.id, expandedNodeIds: expanded };
+  }
+  if (direction === "right") {
+    if (current.children.length && !expanded.has(current.id)) { expanded.add(current.id); return { nodeId: current.id, expandedNodeIds: expanded }; }
+    return { nodeId: current.children[0] ?? current.id, expandedNodeIds: expanded };
+  }
+  const visible = workflowPhaseTreeVisibleNodes(tree, expanded);
+  const index = Math.max(0, visible.findIndex((node) => node.id === current.id));
+  const next = visible[(index + (direction === "up" ? visible.length - 1 : 1)) % visible.length];
+  return { nodeId: next?.id ?? current.id, expandedNodeIds: expanded };
+}
 export function preserveWorkflowPhaseSelection(model: WorkflowPhaseModel, selection: WorkflowPhaseSelection): WorkflowPhaseSelection {
   const phase = model.phases.find((candidate) => candidate.id === selection.phaseId) ?? (model.currentPhaseIndex === undefined ? undefined : model.phases[model.currentPhaseIndex]) ?? model.phases[0];
-  if (!phase) return {};
-  const agentId = phase.agents.some((agent) => agent.id === selection.agentId) ? selection.agentId : phase.agents[0]?.id;
-  return { phaseId: phase.id, ...(agentId === undefined ? {} : { agentId }) };
+  if (!phase) return model.unassignedAgents?.length ? { nodeId: workflowPhaseTreePath("phase", "unassigned", []) } : {};
+  const tree = buildWorkflowPhaseTree(model);
+  const selectedAgent = selection.agentId ? phase.agents.find((candidate) => candidate.id === selection.agentId) : undefined;
+  const selectedCandidate = selection.nodeId ? tree.byId.get(selection.nodeId) : undefined;
+  const selected = selectedCandidate?.phaseId === phase.id ? selectedCandidate : selectedAgent ? tree.byId.get(workflowPhaseTreePath("agent", phase.id, selectedAgent.structuralPath ?? [], selectedAgent.id)) : undefined;
+  const nodeId = selected?.id ?? tree.byId.get(workflowPhaseTreePath("phase", phase.id, []))?.id;
+  return { phaseId: phase.id, ...(selection.agentId && phase.agents.some((agent) => agent.id === selection.agentId) ? { agentId: selection.agentId } : phase.agents[0] ? { agentId: phase.agents[0].id } : {}), ...(nodeId ? { nodeId } : {}), ...(selection.expandedNodeIds ? { expandedNodeIds: selection.expandedNodeIds } : {}) };
 }
 type AgentGroup = { label: string; entries: readonly { agent: AgentRecord; index: number; depth: number }[] };
 function agentGroupKey(agent: AgentRecord): string { return JSON.stringify([agent.structuralPath ?? [], agent.parentBreadcrumb ?? null]); }
@@ -294,25 +469,36 @@ function renderGroupedAgents(agents: readonly AgentRecord[], render: (entry: { a
     ...group.entries.map((entry) => render(entry, grouped)),
   ]);
 }
-function progressStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string {
-  if (state === "completed") return (text) => styles.success(text);
-  if (state === "failed" || state === "cancelled") return (text) => styles.error(text);
-  if (state === "running") return (text) => styles.accent(text);
-  return (text) => styles.muted(text);
-}
-export function formatWorkflowProgress(run: PersistedRun, spinner = "◇", styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES): string {
+const RUN_STATE_GLYPH: Record<string, string> = { completed: "✓", failed: "✗", stopped: "✗", budget_exhausted: "!", awaiting_input: "●" };
+const AGENT_STATE_GLYPH: Record<string, string> = { completed: "✓", failed: "✗", cancelled: "✗" };
+function runStateGlyph(state: string, running: string): string { return state === "running" ? running : RUN_STATE_GLYPH[state] ?? "◆"; }
+function agentStateGlyph(state: string, running: string): string { return state === "running" ? running : AGENT_STATE_GLYPH[state] ?? "○"; }
+type ProgressStyleKey = "success" | "error" | "warning" | "accent" | "muted";
+const PROGRESS_STATE_STYLE: Record<string, ProgressStyleKey> = { completed: "success", failed: "error", cancelled: "error", running: "accent" };
+const WORKFLOW_ICON_STYLE: Record<string, ProgressStyleKey> = { completed: "success", failed: "error", stopped: "error", budget_exhausted: "warning", running: "accent" };
+const PHASE_STATE_STYLE: Record<string, ProgressStyleKey> = { completed: "success", failed: "error", cancelled: "error", running: "accent", interrupted: "warning", budget_exhausted: "warning" };
+function styleForState(map: Record<string, ProgressStyleKey>, state: string, styles: WorkflowProgressStyles): (text: string) => string {
+  const key = map[state] ?? "muted";
+  return (text) => styles[key](text);
+}
+function progressStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(PROGRESS_STATE_STYLE, state, styles); }
+function workflowIconStyle(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(WORKFLOW_ICON_STYLE, state, styles); }
+function phaseStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(PHASE_STATE_STYLE, state, styles); }
+export function formatWorkflowProgress(run: PersistedRun, spinner = "◇", styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now()): string {
   const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
-  const workflowIcon = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "budget_exhausted" ? "!" : run.state === "running" ? spinner : "◆";
-  const workflowIconStyle = run.state === "completed" ? (text: string) => styles.success(text) : run.state === "failed" || run.state === "stopped" ? (text: string) => styles.error(text) : run.state === "budget_exhausted" ? (text: string) => styles.warning(text) : run.state === "running" ? (text: string) => styles.accent(text) : (text: string) => styles.muted(text);
+  const workflowIcon = runStateGlyph(run.state, spinner);
+  const iconStyle = workflowIconStyle(run.state, styles);
   const header = styles.bold(styles.accent(`Workflow: ${run.workflowName} (${String(done)}/${String(run.agents.length)} done)`));
-  const lines = [`${workflowIconStyle(workflowIcon)} ${header}`];
+  const lines = [`${iconStyle(workflowIcon)} ${header}`];
   const budgetWarning = run.state === "budget_exhausted" || (run.budgetEvents ?? []).some((event) => event.type === "hard_exhausted");
   lines.push(...formatCompactBudgetStatus(run).map((line) => `  ${budgetWarning ? styles.warning(line) : line}`));
+  const activeShells = run.activeShells ?? 0;
+  if (activeShells > 0) lines.push(`  ${styles.accent(spinner)} shell ${styles.accent("[running]")} ${styles.dim(`(${String(activeShells)} active)`)}`);
   const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
   const renderAgents = (agents: readonly AgentRecord[], offset: number, nested: boolean) => renderGroupedAgents(agents, ({ agent, index, depth }, grouped) => {
-    const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? spinner : "○";
+    const icon = agentStateGlyph(agent.state, spinner);
     const indent = "  ".repeat((grouped ? 2 : 1) + depth);
-    const activity = SETTLED_AGENT_STATES.has(agent.state) ? "" : formatAgentActivity(agent, spinner, styles);
+    const activity = SETTLED_AGENT_STATES.has(agent.state) ? "" : formatAgentActivity(agent, spinner, styles, now);
     const name = grouped ? agent.label ?? agent.name : styledAgentBreadcrumb(agent, byId, styles);
     const state = progressStyleForState(agent.state, styles);
     return `${indent}#${String(offset + index + 1)} ${state(icon)} ${name} ${state(`[${agent.state}]`)}${activity ? ` ${activity}` : ""}`;
@@ -364,6 +550,94 @@ function workflowCatalogBlock(text: string, expanded: boolean) {
   };
 }
 
+type WorkflowControlResult = { details?: unknown; content?: readonly { type: string; text?: string }[] };
+function controlString(value: unknown): string | undefined { return typeof value === "string" && value.trim() ? value : undefined; }
+function controlValue(value: unknown): string {
+  if (value === null) return "removed";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+  const json = JSON.stringify(value);
+  return typeof json === "string" ? json : "unknown";
+}
+function controlTitle(name: string, theme: Theme): string { return theme.fg("toolTitle", theme.bold(name)); }
+function controlState(state: string, theme: Theme): string {
+  const color = state === "completed" || state === "running" || state === "stopped" ? "success" : state === "failed" || state === "unknown" ? "error" : state === "budget_exhausted" || state === "awaiting_approval" ? "warning" : "accent";
+  return theme.fg(color, state);
+}
+function controlAction(action: string, theme: Theme): string {
+  const color = /approved|completed|stopped|started|resumed/.test(action) ? "success" : /rejected|failed/.test(action) ? "error" : "warning";
+  return theme.fg(color, action);
+}
+function budgetPatchEntries(value: unknown): string[] {
+  if (!object(value)) return value === undefined ? [] : [controlValue(value)];
+  return Object.entries(value).map(([dimension, limits]) => {
+    if (limits === null) return `${dimension}=removed`;
+    if (!object(limits)) return `${dimension}=${controlValue(limits)}`;
+    const parts = ["soft", "hard"].filter((key) => Object.prototype.hasOwnProperty.call(limits, key)).map((key) => `${key}=${controlValue(limits[key])}`);
+    return `${dimension} ${parts.join(" ")}`;
+  });
+}
+function budgetPatchSummary(value: unknown): string {
+  const entries = budgetPatchEntries(value);
+  return entries.length ? entries.join(", ") : "unchanged";
+}
+function budgetPatchDetails(value: unknown, theme: Theme): string[] {
+  const entries = budgetPatchEntries(value);
+  return entries.length ? [theme.fg("accent", theme.bold("Budget patch")), ...entries.map((entry) => `  ${theme.fg("toolOutput", entry)}`)] : [];
+}
+function workflowControlValue(result: WorkflowControlResult): unknown { return catalogResultValue(result); }
+function workflowControlCall(name: string, args: Record<string, unknown>, theme: Theme): string {
+  const runId = controlString(args.runId) ?? "(missing run ID)";
+  if (name === "workflow_respond") {
+    const proposalId = controlString(args.proposalId);
+    const target = proposalId ? `budget proposal ${proposalId}` : `checkpoint ${controlString(args.name) ?? "(missing name)"}`;
+    const decision = args.approved === true ? "approve" : "reject";
+    return [`${controlTitle(name, theme)} ${theme.fg("accent", runId)}`, `${theme.fg("muted", target)} · ${controlAction(decision, theme)}`].join("\n");
+  }
+  if (name === "workflow_resume") return args.budget === undefined ? `${controlTitle(name, theme)} ${theme.fg("accent", runId)}` : [`${controlTitle(name, theme)} ${theme.fg("accent", runId)}`, `${theme.fg("muted", "Budget")} ${theme.fg("toolOutput", budgetPatchSummary(args.budget))}`].join("\n");
+  if (name === "workflow_retry") return `${controlTitle(name, theme)} ${theme.fg("accent", runId)} ${theme.fg("muted", "failed run")}`;
+  return `${controlTitle(name, theme)} ${theme.fg("accent", runId)}`;
+}
+function workflowControlResult(name: string, args: Record<string, unknown>, result: WorkflowControlResult, expanded: boolean, theme: Theme, isError: boolean): string {
+  if (isError) {
+    const text = result.content?.filter(({ type }) => type === "text").map(({ text }) => text ?? "").join("\n").trim();
+    return theme.fg("error", text || `The ${name} tool failed.`);
+  }
+  const value = workflowControlValue(result);
+  if (!object(value)) return theme.fg("error", `The ${name} tool returned an invalid result.`);
+  const runId = controlString(args.runId) ?? controlString(value.runId) ?? "(unknown)";
+  const title = controlTitle(name, theme);
+  if (name === "workflow_stop") {
+    const state = controlString(value.state) ?? "unknown";
+    const action = value.stopped === true ? "stopped" : value.reason === "already_terminal" ? "already terminal" : value.reason === "unknown_run" ? "run not found" : "no change";
+    if (!expanded) return `${title}\nRun ${theme.fg("accent", runId)} · ${controlState(state, theme)} · ${controlAction(action, theme)}`;
+    return [title, `Run: ${theme.fg("accent", runId)}`, `State: ${controlState(state, theme)}`, `Action: ${controlAction(action, theme)}`, ...(controlString(value.reason) ? [`Reason: ${theme.fg("toolOutput", controlValue(value.reason))}`] : [])].join("\n");
+  }
+  if (name === "workflow_retry") {
+    const childRunId = controlString(value.runId) ?? "(unknown)";
+    const state = controlString(value.state) ?? "unknown";
+    const action = state === "completed" ? "completed" : "started";
+    if (!expanded) return [title, `Source ${theme.fg("accent", runId)}`, `Child ${theme.fg("accent", childRunId)} · ${controlState(state, theme)} · ${controlAction(action, theme)}`].join("\n");
+    return [title, `Source run: ${theme.fg("accent", runId)}`, `Retry run: ${theme.fg("accent", childRunId)}`, `State: ${controlState(state, theme)}`, `Action: ${controlAction(action === "completed" ? "completed" : "started; completed work will be replayed", theme)}`].join("\n");
+  }
+  if (name === "workflow_resume") {
+    const state = controlString(value.state) ?? "unknown";
+    const proposalId = controlString(value.proposalId);
+    const action = state === "awaiting_approval" ? "approval required" : state === "running" ? "resumed" : state === "completed" ? "completed" : "no change";
+    if (!expanded) return [title, `Run ${theme.fg("accent", runId)} · ${controlState(state, theme)} · ${controlAction(action, theme)}`, ...(proposalId ? [`Proposal ${theme.fg("accent", proposalId)}`] : [])].join("\n");
+    return [title, `Run: ${theme.fg("accent", runId)}`, `State: ${controlState(state, theme)}`, `Action: ${controlAction(action, theme)}`, ...(proposalId ? [`Proposal: ${theme.fg("accent", proposalId)}`] : []), ...budgetPatchDetails(args.budget, theme)].join("\n");
+  }
+  const proposalId = controlString(args.proposalId);
+  const checkpointName = controlString(args.name);
+  const target = proposalId ? `Budget proposal ${theme.fg("accent", proposalId)}` : `Checkpoint ${theme.fg("accent", checkpointName ?? "(missing)")}`;
+  const accepted = value.accepted === true;
+  const approved = value.approved === true;
+  const reason = controlString(value.reason);
+  const action = reason === "proposal_not_pending" ? "not pending" : reason === "checkpoint" && !accepted ? "not pending" : approved ? "approved" : "rejected";
+  const state = controlString(value.state);
+  if (!expanded) return [title, target, `Run ${theme.fg("accent", runId)} · ${controlAction(action, theme)}${state ? ` · ${controlState(state, theme)}` : ""}`].join("\n");
+  return [title, `Run: ${theme.fg("accent", runId)}`, `Target: ${target}`, `Action: ${controlAction(action, theme)}`, ...(state ? [`State: ${controlState(state, theme)}`] : []), ...(reason ? [`Reason: ${theme.fg("toolOutput", reason)}`] : [])].join("\n");
+}
+
 function catalogText(value: string): string { return value.replace(/\s+/g, " ").trim(); }
 
 type CatalogToolResult = { details?: unknown; content?: readonly { type: string; text?: string }[] };
@@ -439,7 +713,8 @@ function formatWorkflowCatalog(value: unknown, expanded: boolean, theme: Theme):
   return theme.fg("error", "The workflow catalog returned an invalid result.");
 }
 
-const ANSI_SGR = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`);
+const ANSI_SGR_SOURCE = `${String.fromCharCode(27)}\\[[0-9;]*m`;
+const ANSI_SGR = new RegExp(ANSI_SGR_SOURCE);
 export function truncateWorkflowProgress(text: string, width: number): string[] {
   const safeWidth = Math.max(1, width);
   return text.split("\n").flatMap((line) => {
@@ -506,7 +781,7 @@ function navigatorRunLabels(entries: readonly { store: RunStore; loaded: { run:
   for (const { loaded: { run } } of entries) nameCount.set(run.workflowName, (nameCount.get(run.workflowName) ?? 0) + 1);
   return entries.map(({ store, loaded: { run } }) => {
     const done = run.agents.filter((a) => SETTLED_AGENT_STATES.has(a.state)).length;
-    const glyph = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "budget_exhausted" ? "!" : run.state === "running" ? "⠦" : run.state === "awaiting_input" ? "●" : "◆";
+    const glyph = runStateGlyph(run.state, "⠦");
     const suffix = (nameCount.get(run.workflowName) ?? 0) > 1 ? ` ${store.runId.slice(0, 8)}` : "";
     const cost = run.agents.reduce((sum, a) => sum + (a.accounting?.cost ?? 0), 0);
     const costStr = cost > 0 ? ` $${cost.toFixed(2)}` : "";
@@ -539,23 +814,47 @@ function styledAgentBreadcrumb(agent: AgentRecord, byId: Map<string, AgentRecord
   return `${styles.muted(parts.slice(0, -1).join(" > "))} > ${styles.bold(parts[parts.length - 1] ?? "")}`;
 }
 
-function formatAgentActivity(agent: AgentRecord, spinner: string, styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES): string {
+export function formatStalledDuration(durationMs: number): string {
+  const minutes = Math.max(0, Math.floor(durationMs / 60_000));
+  if (minutes < 60) return `${String(minutes)}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return `${String(hours)}h${remainingMinutes ? ` ${String(remainingMinutes)}m` : ""}`;
+}
+function stalledDuration(agent: AgentRecord, now: number): number | undefined {
+  if (agent.state !== "running" || agent.lastEventAt === undefined || !Number.isFinite(agent.lastEventAt)) return undefined;
+  const duration = now - agent.lastEventAt;
+  return duration >= WORKFLOW_AGENT_STALL_THRESHOLD_MS ? duration : undefined;
+}
+function formatAgentActivity(agent: AgentRecord, spinner: string, styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now()): string {
   const label = agent.activity?.kind === "reasoning" ? "reasoning" : agent.activity?.kind === "text" ? "responding" : agent.activity?.kind === "tool" ? agent.activity.text : [...(agent.toolCalls ?? [])].reverse().find(({ state }) => state === "running")?.name ?? "";
-  return label ? `${styles.accent(spinner)} ${styles.dim(label)}` : "";
+  const activity = label ? `${styles.accent(spinner)} ${styles.dim(label)}` : "";
+  const stalled = stalledDuration(agent, now);
+  if (stalled === undefined) return activity;
+  const warning = `stalled? ${formatStalledDuration(stalled)}`;
+  return activity ? `${activity} ${styles.warning(`- ${warning}`)}` : styles.warning(warning);
+}
+
+function formatAccountingValue(value: number): string {
+  return new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(value).toLowerCase();
 }
 
 function formatAccounting(accounting: NonNullable<AgentRecord["accounting"]>): string {
   const total = accounting.input + accounting.output + accounting.cacheRead + accounting.cacheWrite;
-  return `${new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(total).toLowerCase()} tok`;
+  return `${formatAccountingValue(total)} tok`;
 }
 
+function formatAgentAccounting(accounting: NonNullable<AgentRecord["accounting"]>): string[] {
+  const total = accounting.input + accounting.output + accounting.cacheRead + accounting.cacheWrite;
+  return [`Tokens: ${formatAccountingValue(total)} (in=${formatAccountingValue(accounting.input)} out=${formatAccountingValue(accounting.output)} cache-read=${formatAccountingValue(accounting.cacheRead)} cache-write=${formatAccountingValue(accounting.cacheWrite)})`, `Cost: $${accounting.cost.toFixed(2)}`];
+}
 
-export function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[]): string {
+export function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[], now = Date.now()): string {
   void worktrees;
   const done = run.agents.filter((a) => SETTLED_AGENT_STATES.has(a.state)).length;
   const totalAccounting = run.agents.reduce((sum, a) => ({ input: sum.input + (a.accounting?.input ?? 0), output: sum.output + (a.accounting?.output ?? 0), cacheRead: sum.cacheRead + (a.accounting?.cacheRead ?? 0), cacheWrite: sum.cacheWrite + (a.accounting?.cacheWrite ?? 0), cost: sum.cost + (a.accounting?.cost ?? 0) }), { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 });
   const hasAccounting = run.agents.some((a) => a.accounting);
-  const glyph = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "budget_exhausted" ? "!" : run.state === "running" ? "⠦" : run.state === "awaiting_input" ? "●" : "◆";
+  const glyph = runStateGlyph(run.state, "⠦");
   const header = `${glyph} ${run.workflowName}`;
   const meta = [run.state, run.phase ? `phase: ${run.phase}` : "", `${String(done)}/${String(run.agents.length)} agents`, hasAccounting ? formatAccounting(totalAccounting) : "", totalAccounting.cost > 0 ? `$${totalAccounting.cost.toFixed(2)}` : ""].filter(Boolean).join(" · ");
   const lines = [header, meta, ...formatCompactBudgetStatus(run)];
@@ -564,7 +863,7 @@ export function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonl
   lines.push("");
   const byId = new Map(run.agents.map((a) => [a.id, a]));
   const render = ({ agent, depth }: { agent: AgentRecord; index: number; depth: number }, grouped: boolean) => {
-    const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? "⠦" : "○";
+    const icon = agentStateGlyph(agent.state, "⠦");
     const breadcrumb = grouped ? agent.label ?? agent.name : agentBreadcrumb(agent, byId);
     const tokens = agent.accounting ? formatAccounting(agent.accounting) : "";
     const indent = "  ".repeat((grouped ? 2 : 1) + depth);
@@ -573,7 +872,7 @@ export function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonl
       const last = agent.attemptDetails[agent.attemptDetails.length - 1];
       if (last?.error) result.push(`${indent}  error: ${last.error.code}: ${last.error.message}`);
     }
-    const activity = !SETTLED_AGENT_STATES.has(agent.state) ? formatAgentActivity(agent, "⠦") : "";
+    const activity = !SETTLED_AGENT_STATES.has(agent.state) ? formatAgentActivity(agent, "⠦", PLAIN_WORKFLOW_PROGRESS_STYLES, now) : "";
     if (activity) result.push(`${indent}  ${activity}`);
     return result.join("\n");
   };
@@ -582,7 +881,7 @@ export function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonl
   return lines.join("\n");
 }
 
-export function formatNavigatorRun(loaded: { run: PersistedRun; snapshot: Readonly<LaunchSnapshot> }, checkpoints: readonly AwaitingCheckpoint[], _worktrees: readonly WorktreeReference[]): string {
+export function formatNavigatorRun(loaded: { run: PersistedRun; snapshot: Readonly<LaunchSnapshot> }, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[], now = Date.now()): string {
   const { run, snapshot } = loaded;
   const lines = [
     `Workflow: ${run.workflowName}`,
@@ -611,67 +910,102 @@ export function formatNavigatorRun(loaded: { run: PersistedRun; snapshot: Readon
     const result = [`${indent}#${String(index + 1)} ${grouped ? agent.label ?? agent.name : agentBreadcrumb(agent, byId)} state=${agent.state} model=${model}${agent.requestedModel ? ` requested=${agent.requestedModel}` : ""}${role}${tools} attempts=${String(agent.attempts)} retries=${String(Math.max(0, agent.attempts - 1))}${accounting}`];
     for (const attempt of agent.attemptDetails ?? []) result.push(`${indent}  attempt ${String(attempt.attempt)}${attempt.error ? ` error=${attempt.error.code}: ${attempt.error.message}` : ""}`);
     for (const call of agent.toolCalls ?? []) result.push(`${indent}  tool ${call.name} state=${call.state}`);
+    const activity = !SETTLED_AGENT_STATES.has(agent.state) ? formatAgentActivity(agent, "⠦", PLAIN_WORKFLOW_PROGRESS_STYLES, now) : "";
+    if (activity) result.push(`${indent}  ${activity}`);
     return result.join("\n");
   }));
   lines.push("Checkpoints:");
   if (!checkpoints.length) lines.push("  (none)");
   for (const checkpoint of checkpoints) lines.push(`  ${checkpoint.name}: ${checkpoint.prompt} context=${JSON.stringify(checkpoint.context)}`);
-  lines.push(`Worktrees: ${String(_worktrees.length)}`);
+  lines.push(`Worktrees: ${String(worktrees.length)}`);
   lines.push(`Native Pi transcripts: ${String(run.nativeSessions.length)}`);
   return lines.join("\n");
 }
-export function formatWorkflowPhaseDashboard(run: PersistedRun, snapshot: Readonly<LaunchSnapshot>, width: number, selection: WorkflowPhaseSelection = {}, styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES): string[] {
+export function formatWorkflowPhaseDashboard(run: PersistedRun, snapshot: Readonly<LaunchSnapshot>, width: number, selection: WorkflowPhaseSelection = {}, styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now()): string[] {
   const safeWidth = Math.max(1, width);
   const model = buildWorkflowPhaseModel(run, snapshot);
+  const tree = buildWorkflowPhaseTree(model);
+  const expanded = selection.expandedNodeIds === undefined ? workflowPhaseTreeInitialExpanded(tree) : new Set(selection.expandedNodeIds);
   const wrap = (text: string, limit = safeWidth): string[] => truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, Math.max(1, limit), 0).visualLines.map((line) => line.trimEnd());
-  const phaseStyle = (state: WorkflowPhaseState): ((text: string) => string) => state === "completed" ? (text) => styles.success(text) : state === "failed" || state === "cancelled" ? (text) => styles.error(text) : state === "running" ? (text) => styles.accent(text) : state === "interrupted" || state === "budget_exhausted" ? (text) => styles.warning(text) : (text) => styles.muted(text);
-  const phaseName = (phase: WorkflowPhaseView): string => `${phase.name}${phase.occurrence > 1 ? ` #${String(phase.occurrence)}` : ""}`;
-  const phaseCounts = (phase: WorkflowPhaseView): string => `agents completed=${String(phase.counts.completed)} running=${String(phase.counts.running)} failed=${String(phase.counts.failed)} cancelled=${String(phase.counts.cancelled)} pending=${String(phase.counts.pending)}`;
-  const phaseLine = (phase: WorkflowPhaseView, selected: boolean): string => `${selected ? "→" : " "} ${phaseName(phase)} · ${phaseStyle(phase.state)(phase.state)} · ${phaseCounts(phase)}`;
+  // ponytail: ANSI-only width, good enough for the ASCII labels the tree renders
+  const ansiPattern = new RegExp(ANSI_SGR_SOURCE, "g");
+  const visibleLength = (text: string): number => text.replace(ansiPattern, "").length;
+  const padTo = (text: string, limit: number): string => `${text}${" ".repeat(Math.max(0, limit - visibleLength(text)))}`;
+  const phaseStyle = (state: WorkflowPhaseState | AgentRecord["state"]): ((text: string) => string) => phaseStyleForState(state, styles);
+  const phase = selection.phaseId ? model.phases.find((candidate) => candidate.id === selection.phaseId) : undefined;
+  const selectedByAgent = selection.agentId ? tree.nodes.find((node) => node.kind === "agent" && node.agentId === selection.agentId && (!selection.phaseId || node.phaseId === selection.phaseId)) : undefined;
+  const selectedNode = (selection.nodeId ? tree.byId.get(selection.nodeId) : undefined) ?? selectedByAgent ?? (phase ? tree.byId.get(workflowPhaseTreePath("phase", phase.id, [])) : undefined) ?? (model.currentPhaseId ? tree.byId.get(workflowPhaseTreePath("phase", model.currentPhaseId, [])) : undefined) ?? tree.nodes[0];
+  const selectedPhase = selectedNode?.phase ?? (selectedNode ? model.phases.find((candidate) => candidate.id === selectedNode.phaseId) : undefined);
+  const visibleNodes = workflowPhaseTreeVisibleNodes(tree, expanded);
+  const nodeAgents = (node: WorkflowPhaseTreeNode): AgentRecord[] => {
+    const agents: AgentRecord[] = [];
+    const visit = (id: string): void => {
+      const child = tree.byId.get(id);
+      if (!child) return;
+      if (child.agent) agents.push(child.agent); else for (const childId of child.children) visit(childId);
+    };
+    if (node.agent) agents.push(node.agent); else for (const childId of node.children) visit(childId);
+    return agents;
+  };
+  const nodeStatus = (node: WorkflowPhaseTreeNode): string => phaseStyle(node.state)(node.state);
+  const nodeIcon = (node: WorkflowPhaseTreeNode): string => node.children.length ? expanded.has(node.id) ? "▾" : "▸" : node.kind === "agent" ? "•" : " ";
+  const treeLine = (node: WorkflowPhaseTreeNode): string => {
+    const selected = node.id === selectedNode?.id;
+    const state = progressStyleForState(node.state, styles);
+    const activity = node.agent && !SETTLED_AGENT_STATES.has(node.agent.state) ? formatAgentActivity(node.agent, "⠦", styles, now) : "";
+    return `${selected ? "→" : " "} ${"  ".repeat(node.depth)}${nodeIcon(node)} ${node.label} · ${state(node.state)}${activity ? ` ${activity}` : ""}`;
+  };
+  const details = (node: WorkflowPhaseTreeNode | undefined): string[] => {
+    if (!node) return [styles.muted("No workflow node is selected")];
+    const agents = nodeAgents(node);
+    if (node.kind === "phase") {
+      const selected = node.phase;
+      const counts = selected?.counts ?? phaseAgentCounts(agents);
+      return [styles.bold(`Selected phase: ${node.label}`), `Status: ${nodeStatus(node)}`, `agents completed=${String(counts.completed)} running=${String(counts.running)} failed=${String(counts.failed)} cancelled=${String(counts.cancelled)} pending=${String(counts.pending)}`, `Agents: ${String(agents.length)}`];
+    }
+    if (node.kind === "operation") {
+      const states = phaseAgentCounts(agents);
+      return [styles.bold(`Selected operation: ${node.operationPath.join(" > ")}`), `Phase: ${node.phase?.name ?? node.phaseId}`, `Status: ${nodeStatus(node)}`, `agents completed=${String(states.completed)} running=${String(states.running)} failed=${String(states.failed)} cancelled=${String(states.cancelled)} pending=${String(states.pending)}`, `Agents: ${String(agents.length)}`];
+    }
+    const agent = node.agent;
+    if (!agent) return [styles.muted("Agent details are unavailable")];
+    const byId = new Map(run.agents.map((candidate) => [candidate.id, candidate]));
+    const result = [styles.bold(`Selected agent: ${agentBreadcrumb(agent, byId, true)}`), `State: ${phaseStyle(agent.state)(agent.state)}`, `Structural path: ${agent.structuralPath?.join(" > ") || "(root)"}`, `Model: ${agent.model.provider}/${agent.model.model}${agent.model.thinking ? `:${agent.model.thinking}` : ""}`, `Role: ${agent.role ?? "(none)"}`, `Tools: ${agent.tools.join(", ") || "(none)"}`, `Attempts: ${String(agent.attempts)}`, ...(agent.accounting ? formatAgentAccounting(agent.accounting) : []), ...(selection.actions ? [] : [styles.muted("enter for agent actions")])];
+    const error = agent.attemptDetails?.at(-1)?.error;
+    if (error) result.push(styles.error(`Error: ${error.code}: ${error.message}`));
+    if (agent.activity) result.push(`Activity: ${agent.activity.text}`);
+    const stalled = stalledDuration(agent, now);
+    if (stalled !== undefined) result.push(styles.warning(`stalled? ${formatStalledDuration(stalled)}`));
+    return result;
+  };
   const stateNames: readonly WorkflowPhaseState[] = ["not started", "running", "completed", "failed", "cancelled", "interrupted", "budget_exhausted"];
   const statusSummary = stateNames.filter((state) => (model.counts[state] ?? 0) > 0).map((state) => `${String(model.counts[state])} ${state}`).join(" · ") || "0 phases";
-  const selectedIndex = selection.phaseId ? model.phases.findIndex((phase) => phase.id === selection.phaseId) : -1;
-  const activeIndex = selectedIndex >= 0 ? selectedIndex : model.currentPhaseIndex ?? (model.phases.length ? 0 : -1);
-  const selectedPhase = activeIndex >= 0 ? model.phases[activeIndex] : undefined;
   const lines: string[] = [styles.bold(styles.accent(`Workflow: ${run.workflowName}`))];
   if (run.error) lines.push(styles.error(`ERROR ${run.error.code}: ${run.error.message}`));
   lines.push(`phase: ${run.phase ?? selectedPhase?.name ?? "none"}`, `Run state: ${run.state}`, `Phases: ${statusSummary}`);
   for (const event of run.events ?? []) lines.push(styles.warning(`Warning: ${event.message}`));
   lines.push(...formatCompactBudgetStatus(run));
-  const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
-  const renderAgentLines = (agents: readonly AgentRecord[], selectedAgentId: string | undefined): string[] => {
-    if (!agents.length) return [styles.muted("Agents: none")];
-    const rendered: string[] = [];
-    for (const agent of agents) {
-      const selected = agent.id === selectedAgentId;
-      const stateStyle = progressStyleForState(agent.state, styles);
-      const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? "⠦" : "○";
-      rendered.push(`${selected ? "→" : " "} ${stateStyle(icon)} ${styledAgentBreadcrumb(agent, byId, styles)} · ${stateStyle(agent.state)}`);
-      if (agent.state === "failed") {
-        const error = agent.attemptDetails?.at(-1)?.error;
-        if (error) rendered.push(styles.error(`  error: ${error.code}: ${error.message}`));
-      }
-    }
-    return rendered;
+  const renderTree = (limit: number): string[] => [styles.bold("Tree"), ...(visibleNodes.length ? visibleNodes.flatMap((node) => wrap(treeLine(node), limit)) : [styles.muted("(empty)")])];
+  const actionRows = (): string[] => {
+    const actions = selection.actions;
+    if (!actions) return [];
+    return ["", styles.bold(actions.title), ...actions.options.map((option, index) => `${index === actions.index ? "→ " : "  "}${index === actions.index ? styles.accent(option) : option}`)];
   };
-  if (!model.phases.length) {
-    lines.push(styles.muted("Phases: no declared or observed phases (legacy snapshot)"), styles.bold("Agents"), ...renderAgentLines(run.agents, selection.agentId));
-    return lines.flatMap((line) => wrap(line));
-  }
-  const selectedAgent = selectedPhase?.agents.find((agent) => agent.id === selection.agentId) ?? selectedPhase?.agents[0];
+  const detailRows = (): string[] => [...details(selectedNode), ...actionRows()];
   if (safeWidth >= 80) {
-    const sidebarWidth = Math.min(38, Math.max(24, Math.floor(safeWidth * 0.36)));
+    const sidebarWidth = Math.min(42, Math.max(24, Math.floor((safeWidth - 3) * 0.38)));
     const detailWidth = Math.max(1, safeWidth - sidebarWidth - 3);
-    const sidebar = [styles.bold("Phases"), ...model.phases.flatMap((phase, index) => wrap(phaseLine(phase, index === activeIndex), sidebarWidth))];
-    const detail = selectedPhase ? [styles.bold(`Phase: ${phaseName(selectedPhase)}`), ...wrap(`Status: ${phaseStyle(selectedPhase.state)(selectedPhase.state)}`, detailWidth), ...wrap(phaseCounts(selectedPhase), detailWidth), "Agents", ...renderAgentLines(selectedPhase.agents, selectedAgent?.id).flatMap((line) => wrap(line, detailWidth))] : [styles.muted("No phase is selected")];
+    const sidebar = renderTree(sidebarWidth).flatMap((line) => wrap(line, sidebarWidth));
+    const detail = detailRows().flatMap((line) => wrap(line, detailWidth));
     const rows = Math.max(sidebar.length, detail.length);
-    for (let index = 0; index < rows; index += 1) lines.push(`${sidebar[index] ?? ""} | ${detail[index] ?? ""}`);
+    for (let index = 0; index < rows; index += 1) lines.push(`${padTo(sidebar[index] ?? "", sidebarWidth)} | ${detail[index] ?? ""}`);
+  } else if (selection.detailsOnly) {
+    lines.push(...detailRows().flatMap((line) => wrap(line)));
   } else {
-    lines.push(styles.bold("Phases"));
-    for (const [index, phase] of model.phases.entries()) lines.push(...wrap(phaseLine(phase, index === activeIndex)));
-    if (selectedPhase) lines.push("", styles.bold(`Selected phase: ${phaseName(selectedPhase)}`), ...wrap(`Status: ${phaseStyle(selectedPhase.state)(selectedPhase.state)}`), ...wrap(phaseCounts(selectedPhase)), styles.bold("Agents"), ...renderAgentLines(selectedPhase.agents, selectedAgent?.id).flatMap((line) => wrap(line)));
+    lines.push(...renderTree(safeWidth));
+    if (!selection.treeOnly) lines.push("", ...detailRows().flatMap((line) => wrap(line)));
   }
-  if (model.unassignedAgents?.length) lines.push(...wrap(styles.muted(`Unassigned agents: ${String(model.unassignedAgents.length)}`)));
+  if (model.unassignedAgents?.length && !tree.nodes.some((node) => node.phaseId === "unassigned")) lines.push(...wrap(styles.muted(`Unassigned agents: ${String(model.unassignedAgents.length)}`)));
   return lines.flatMap((line) => wrap(line));
 }
 function formatCheckpointReview(checkpoint: AwaitingCheckpoint): string {
@@ -827,16 +1161,35 @@ export function formatWorkflowFailureDiagnostics(diagnostic: WorkflowFailureDiag
   const retry = diagnostic.retry ? [`  Retry: ${diagnostic.retry.action}`, `  Replayable completed paths: ${diagnostic.retry.completedPaths.join(", ") || "(none)"}`, `  Incomplete paths: ${diagnostic.retry.incompletePaths.join(", ") || "(unknown)"}`, `  Named worktrees: ${diagnostic.retry.namedWorktrees.join(", ") || "(none)"}`, `  Warning: ${diagnostic.retry.warning}`] : [];
   return [`✗ Workflow: ${diagnostic.workflowName}`, `  Run: ${diagnostic.runId}`, `  State: ${diagnostic.state}`, `  Error: ${diagnostic.error.code}: ${diagnostic.error.message}`, `  Failed at: ${diagnostic.failedAt ?? "(unknown)"}`, `  Failed agent: ${failedAgent}`, `  Completed sibling ${siblingAgents ? "agents" : "paths"}: ${siblings}`, ...retry, `  Artifacts: state=${diagnostic.artifacts.statePath} journal=${diagnostic.artifacts.journalPath}`].join("\n");
 }
+function deliveryPart(value: string, maxBytes: number): string { return utf8Prefix(value.replace(/\s+/g, " ").trim(), maxBytes) || "(unknown)"; }
+export function formatWorkflowFailureDelivery(diagnostic: WorkflowFailureDiagnostics): string {
+  const name = deliveryPart(diagnostic.workflowName, 128);
+  const runId = deliveryPart(diagnostic.runId, 128);
+  const error = `${diagnostic.error.code}: ${deliveryPart(diagnostic.error.message, 768)}`;
+  const failedPath = diagnostic.failedAt ? `; failed path=${deliveryPart(diagnostic.failedAt, 512)}` : "";
+  const nextAction = diagnostic.retry ? `; next action: ${deliveryPart(diagnostic.retry.action, 256)}` : "";
+  const artifacts = `; artifacts: runDirectory=${deliveryPart(diagnostic.artifacts.runDirectory, 512)} statePath=${deliveryPart(diagnostic.artifacts.statePath, 512)} journalPath=${deliveryPart(diagnostic.artifacts.journalPath, 512)}`;
+  const line = `Workflow ${name} failed (runId=${runId}): error=${error}${failedPath}${nextAction}${artifacts}`;
+  return Buffer.byteLength(line) <= DELIVERY_LIMIT_BYTES ? line : utf8Prefix(line, DELIVERY_LIMIT_BYTES);
+}
+function formatWorkflowFailureDeliveryFallback(workflowName: string, runId: string, runDirectory: string, error: unknown): string {
+  const code = errorCode(error) ?? "INTERNAL_ERROR";
+  const failedPath = workflowFailedAt(error);
+  const nextAction = code === "BUDGET_EXHAUSTED" || code === "CANCELLED" ? "" : `; next action: workflow_retry({ runId: ${JSON.stringify(runId)} })`;
+  const line = `Workflow ${deliveryPart(workflowName, 128)} failed (runId=${deliveryPart(runId, 128)}): error=${code}: ${deliveryPart(formatWorkflowFailure(error), 768)}${failedPath ? `; failed path=${deliveryPart(failedPath, 512)}` : ""}${nextAction}; artifacts: runDirectory=${deliveryPart(runDirectory, 512)} statePath=${deliveryPart(join(runDirectory, "state.json"), 512)} journalPath=${deliveryPart(join(runDirectory, "journal.json"), 512)}`;
+  return Buffer.byteLength(line) <= DELIVERY_LIMIT_BYTES ? line : utf8Prefix(line, DELIVERY_LIMIT_BYTES);
+}
 
 function serializeWorkflowFailureDiagnostics(diagnostic: WorkflowFailureDiagnostics): string { return JSON.stringify(diagnostic); }
 function isWorkflowFailureDiagnostics(value: unknown): value is WorkflowFailureDiagnostics {
   return object(value) && typeof value.runId === "string" && typeof value.workflowName === "string" && typeof value.state === "string" && "failedAt" in value && object(value.error) && object(value.artifacts);
 }
 function deliver(pi: ExtensionAPI, content: string): void {
+  if (typeof pi.sendMessage !== "function") return;
   pi.sendMessage({ customType: "workflow", content, display: true }, { deliverAs: "followUp", triggerTurn: true });
 }
 function deliverFailure(pi: ExtensionAPI, diagnostic: WorkflowFailureDiagnostics): void {
-  deliver(pi, `Workflow ${utf8Prefix(diagnostic.workflowName, 128)} failure diagnostics: ${serializeWorkflowFailureDiagnostics(diagnostic)}`);
+  deliver(pi, formatWorkflowFailureDelivery(diagnostic));
 }
 
 type WorkflowEventSink = { emit: (name: string, payload: unknown) => unknown };
@@ -1094,26 +1447,25 @@ function projectTrusted(ctx: unknown): boolean {
   const check = object(ctx) ? ctx.isProjectTrusted : undefined;
   return typeof check === "function" ? Boolean(Reflect.apply(check, ctx, [])) : true;
 }
+function asFn(value: unknown): ((...args: never[]) => unknown) | undefined { return typeof value === "function" ? value as (...args: never[]) => unknown : undefined; }
 type PiHostCapabilities = { registerEntryRenderer?: ExtensionAPI["registerEntryRenderer"]; events?: WorkflowEventSink };
-function isEntryRenderer(value: unknown): value is NonNullable<PiHostCapabilities["registerEntryRenderer"]> { return typeof value === "function"; }
 function isWorkflowEventSink(value: unknown): value is WorkflowEventSink { return object(value) && typeof value.emit === "function"; }
 function piHostCapabilities(pi: unknown): PiHostCapabilities {
   if (!object(pi)) return {};
-  const registerEntryRenderer = pi.registerEntryRenderer;
+  const registerEntryRenderer = asFn(pi.registerEntryRenderer) as NonNullable<PiHostCapabilities["registerEntryRenderer"]> | undefined;
   const events = pi.events;
-  return { ...(isEntryRenderer(registerEntryRenderer) ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
+  return { ...(registerEntryRenderer ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
 }
 type ContextHostCapabilities = { modelRegistry?: ModelRegistryCapability };
 type ModelSummary = { provider: string; id: string };
 type ModelRegistryGetter = () => readonly ModelSummary[];
 type ModelRegistryCapability = { getAll?: ModelRegistryGetter; getAvailable?: ModelRegistryGetter };
-function isModelRegistryGetter(value: unknown): value is ModelRegistryGetter { return typeof value === "function"; }
 function contextHostCapabilities(ctx: unknown): ContextHostCapabilities {
   if (!object(ctx) || !object(ctx.modelRegistry)) return {};
   const registry = ctx.modelRegistry;
-  const getAll = registry.getAll;
-  const getAvailable = registry.getAvailable;
-  return { modelRegistry: { ...(isModelRegistryGetter(getAll) ? { getAll: () => getAll.call(registry) } : {}), ...(isModelRegistryGetter(getAvailable) ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
+  const getAll = (asFn(registry.getAll) as ModelRegistryGetter | undefined);
+  const getAvailable = (asFn(registry.getAvailable) as ModelRegistryGetter | undefined);
+  return { modelRegistry: { ...(getAll ? { getAll: () => getAll.call(registry) } : {}), ...(getAvailable ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
 }
 function modelInventory(root: ModelSpec | undefined, registry: ModelRegistryCapability | undefined): { knownModels: ReadonlySet<string>; availableModels: ReadonlySet<string> } {
   const all = registry?.getAll?.() ?? registry?.getAvailable?.() ?? [];
@@ -1146,23 +1498,21 @@ type UiSelect = (title: string, options: string[]) => Promise<string | undefined
 type UiInput = (title: string, placeholder?: string) => Promise<string | undefined>;
 type UiSetStatus = (key: string, text?: string) => void;
 type UiHostCapabilities = { select?: UiSelect; input?: UiInput; setStatus?: UiSetStatus };
-function isUiSelect(value: unknown): value is UiSelect { return typeof value === "function"; }
-function isUiInput(value: unknown): value is UiInput { return typeof value === "function"; }
-function isUiSetStatus(value: unknown): value is UiSetStatus { return typeof value === "function"; }
 function uiHostCapabilities(ui: unknown): UiHostCapabilities | undefined {
   if (!object(ui)) return undefined;
-  const select = ui.select;
-  const input = ui.input;
-  const setStatus = ui.setStatus;
-  return { ...(isUiSelect(select) ? { select } : {}), ...(isUiInput(input) ? { input } : {}), ...(isUiSetStatus(setStatus) ? { setStatus } : {}) };
+  const select = (asFn(ui.select) as UiSelect | undefined);
+  const input = (asFn(ui.input) as UiInput | undefined);
+  const setStatus = (asFn(ui.setStatus) as UiSetStatus | undefined);
+  return { ...(select ? { select } : {}), ...(input ? { input } : {}), ...(setStatus ? { setStatus } : {}) };
 }
-type TuiHostCapabilities = { terminal?: { rows?: unknown } };
-function tuiHostCapabilities(tui: unknown): TuiHostCapabilities {
-  if (!object(tui) || !object(tui.terminal)) return {};
-  return { terminal: { ...(tui.terminal.rows === undefined ? {} : { rows: tui.terminal.rows }) } };
+function tuiRows(tui: unknown): number {
+  const rows = object(tui) && object(tui.terminal) ? tui.terminal.rows : undefined;
+  return typeof rows === "number" && Number.isFinite(rows) ? rows : 24;
 }
-function tuiRows(tui: unknown): number { const rows = tuiHostCapabilities(tui).terminal?.rows; return typeof rows === "number" && Number.isFinite(rows) ? rows : 24; }
+const WORKFLOW_PANEL_FOOTER_ROWS = 2;
 const WORKFLOW_OVERLAY_BORDER_ROWS = 2;
+const WORKFLOW_OVERLAY_TOP_MARGIN = 1;
+const WORKFLOW_OVERLAY_OPTIONS = { anchor: "top-left", width: "100%", maxHeight: "100%", margin: { top: WORKFLOW_OVERLAY_TOP_MARGIN } } as const;
 type WorkflowOverlayComponent = { render(width: number): string[]; invalidate(): void; handleInput?(data: string): void; dispose?(): void };
 function borderWorkflowOverlay(component: WorkflowOverlayComponent, theme: { fg(color: "border", text: string): string }): WorkflowOverlayComponent {
   return {
@@ -1174,14 +1524,21 @@ function borderWorkflowOverlay(component: WorkflowOverlayComponent, theme: { fg(
   };
 }
 type KeybindingsHostCapabilities = { getKeys?: (name: string) => readonly string[] };
-function isKeybindingGetter(value: unknown): value is NonNullable<KeybindingsHostCapabilities["getKeys"]> { return typeof value === "function"; }
-function keybindingsHostCapabilities(keybindings: unknown): KeybindingsHostCapabilities {
-  if (!object(keybindings) || !isKeybindingGetter(keybindings.getKeys)) return {};
-  return { getKeys: keybindings.getKeys };
+function keybindingKeys(keybindings: unknown, name: string): readonly string[] | undefined {
+  const getKeys = object(keybindings) ? asFn(keybindings.getKeys) as NonNullable<KeybindingsHostCapabilities["getKeys"]> | undefined : undefined;
+  return getKeys ? getKeys.call(keybindings, name) : undefined;
+}
+type WorkflowKeybindings = { matches(data: string, binding: string): boolean };
+const WORKFLOW_VIM_KEYS: Readonly<Record<string, string>> = { "tui.select.up": "k", "tui.select.down": "j", "tui.editor.cursorLeft": "h", "tui.editor.cursorRight": "l" };
+function workflowKeyMatches(keybindings: WorkflowKeybindings, data: string, binding: string): boolean { return keybindings.matches(data, binding) || WORKFLOW_VIM_KEYS[binding] === data; }
+function workflowKeyLabel(keybindings: unknown, binding: string, fallback: string, labels: Readonly<Record<string, string>>): string {
+  const keys = keybindingKeys(keybindings, binding);
+  const configured = keys?.length ? keys.map((key) => labels[key] ?? key) : [fallback];
+  const vim = WORKFLOW_VIM_KEYS[binding];
+  return [...new Set(vim ? [...configured, vim] : configured)].join("/");
 }
-function keybindingKeys(keybindings: unknown, name: string): readonly string[] | undefined { const getKeys = keybindingsHostCapabilities(keybindings).getKeys; return typeof getKeys === "function" ? getKeys.call(keybindings, name) : undefined; }
 
-export default function workflowExtension(pi: ExtensionAPI, home?: string, clipboard = copyToClipboard, createSession: SessionFactory = createNativeAgentSession, agentDir?: string) {
+export default function workflowExtension(pi: ExtensionAPI, home?: string, clipboard = copyToClipboard, createSession: SessionFactory = createNativeAgentSession, agentDir?: string, additionalSkillPaths: readonly string[] = []) {
   beginWorkflowExtensionLoading();
   const registry = loadingRegistry();
   const extensionAgentDir = agentDir ?? getAgentDir();
@@ -1202,7 +1559,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     const skillPath = [join(extensionDir, "../skills"), join(extensionDir, "../../skills")].find((path) => existsSync(path));
     return skillPath ? { skillPaths: [skillPath] } : undefined;
   });
-  type BudgetDecisionResult = { state: "running" | "budget_exhausted"; approved: boolean };
+  type BudgetDecisionResult = { state: "running" | "completed" | "budget_exhausted"; approved: boolean; value?: JsonValue; run?: PersistedRun };
   const runs = new Map<string, { executor: WorkflowAgentExecutor; store: RunStore; metadata: WorkflowMetadata; model: ModelSpec; lifecycle: RunLifecycle; budget: WorkflowBudgetRuntime; abortController: AbortController; projectTrusted: () => boolean; providerErrorRecovery?: (failure: AgentProviderFailure) => Promise<AgentProviderRecovery>; execution?: WorkflowExecution; completion?: Promise<unknown>; checkpointResolvers: Map<string, (value: boolean) => void>; update?: (result: WorkflowToolUpdate) => void }>();
   let providerRecoveryQueue = Promise.resolve();
   const enqueueProviderRecovery = <T>(task: () => Promise<T>): Promise<T> => { const next = providerRecoveryQueue.then(task, task); providerRecoveryQueue = next.then(() => undefined, () => undefined); return next; };
@@ -1226,14 +1583,9 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     });
   };
   const pendingFailureDiagnostics = new Map<string, WorkflowFailureDiagnostics>();
-  pi.on("tool_result", (event) => {
-    if (event.toolName !== "workflow" || !event.isError) return;
-    const diagnostic = pendingFailureDiagnostics.get(event.toolCallId);
-    if (!diagnostic) return;
-    pendingFailureDiagnostics.delete(event.toolCallId);
-    return { content: [{ type: "text" as const, text: serializeWorkflowFailureDiagnostics(diagnostic) }], details: diagnostic, isError: true };
-  });
+  const foregroundDeliveries = new Map<string, { store: RunStore; inline: boolean; timer?: ReturnType<typeof setTimeout> }>();
   const liveActivities = new Map<string, Map<string, AgentActivity>>();
+  const liveEventTimes = new Map<string, Map<string, number>>();
   const setLiveActivity = (runId: string, agentId: string, activity?: AgentActivity) => {
     const activities = liveActivities.get(runId);
     if (activity) {
@@ -1244,12 +1596,22 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       if (activities?.size === 0) liveActivities.delete(runId);
     }
   };
+  const setLiveEventTime = (runId: string, agentId: string, timestamp?: number) => {
+    if (timestamp === undefined) return;
+    const timestamps = liveEventTimes.get(runId);
+    if (timestamps) timestamps.set(agentId, timestamp);
+    else liveEventTimes.set(runId, new Map([[agentId, timestamp]]));
+  };
   const withLiveActivities = (run: PersistedRun): PersistedRun => {
     const activities = liveActivities.get(run.id);
-    return activities?.size ? { ...run, agents: run.agents.map((agent) => {
-      const activity = activities.get(agent.id);
-      return activity ? { ...agent, activity } : agent;
-    }) } : run;
+    const timestamps = liveEventTimes.get(run.id);
+    if (!activities?.size && !timestamps?.size) return run;
+    return { ...run, agents: run.agents.map((agent) => {
+      const activity = activities?.get(agent.id);
+      const lastEventAt = timestamps?.get(agent.id);
+      if (activity === undefined && lastEventAt === undefined) return agent;
+      return { ...agent, ...(activity === undefined ? {} : { activity }), ...(lastEventAt === undefined ? {} : { lastEventAt }) };
+    }) };
   };
   const terminalRunStates = new Map<string, "completed" | "failed" | "stopped">();
   let sessionLease: SessionLease | undefined;
@@ -1271,6 +1633,42 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     await eventPublisher.budget(store, metadata, persisted);
     return persisted;
   };
+  pi.on("tool_result", async (event) => {
+    const delivery = event.toolName === "workflow" ? foregroundDeliveries.get(event.toolCallId) : undefined;
+    if (delivery) {
+      if (delivery.timer) clearTimeout(delivery.timer);
+      delivery.inline = true;
+      await delivery.store.updateState((current) => {
+        if (current.delivery?.toolCallId !== event.toolCallId || current.delivery.state === "delivered") return current;
+        return { ...current, delivery: { ...current.delivery, state: "delivered" } };
+      });
+      foregroundDeliveries.delete(event.toolCallId);
+    }
+    if (event.toolName !== "workflow" || !event.isError) return;
+    const diagnostic = pendingFailureDiagnostics.get(event.toolCallId);
+    if (!diagnostic) return;
+    pendingFailureDiagnostics.delete(event.toolCallId);
+    return { content: [{ type: "text" as const, text: serializeWorkflowFailureDiagnostics(diagnostic) }], details: diagnostic, isError: true };
+  });
+  const deliverTerminal = async (store: RunStore, content: string): Promise<void> => {
+    let claimed: boolean | undefined;
+    await store.updateState((current) => {
+      if (current.delivery?.state === "delivered") return current;
+      if (!current.delivery) { claimed = true; return current; }
+      claimed = true;
+      return { ...current, delivery: { ...current.delivery, mode: "background", state: "delivered" } };
+    });
+    if (claimed === true) deliver(pi, content);
+  };
+  const scheduleForegroundDelivery = (toolCallId: string, send: () => Promise<void>): void => {
+    const delivery = foregroundDeliveries.get(toolCallId);
+    if (!delivery || delivery.inline || typeof (pi as unknown as { sendMessage?: unknown }).sendMessage !== "function") return;
+    //NOTE: Give Pi one event-loop turn to deliver an uninterrupted tool result before promoting.
+    delivery.timer = setTimeout(() => {
+      delete delivery.timer;
+      void send().finally(() => foregroundDeliveries.delete(toolCallId));
+    }, 0);
+  };
   const phaseBridge = (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle) => {
     let cursor = 0;
     return async (phase: string): Promise<void> => {
@@ -1311,17 +1709,30 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const path = shellIdentityPath(identity);
       const replayed = await store.replay(path);
       if (replayed) return readShellResult(replayed.value);
-      const cwd = identity.worktreeOwner ? (await persistWorktree(store, metadata, identity.worktreeOwner)).cwd : store.cwd;
-      const result = await executeShellCommand(command, options, signal, cwd);
-      await store.complete(path, result as unknown as JsonValue);
-      return result;
+      const started = await persistRunState(store, metadata, (current) => ({ ...current, activeShells: (current.activeShells ?? 0) + 1 }));
+      runs.get(store.runId)?.update?.(workflowToolUpdate(withLiveActivities(started)));
+      try {
+        const cwd = identity.worktreeOwner ? (await persistWorktree(store, metadata, identity.worktreeOwner)).cwd : store.cwd;
+        const result = await executeShellCommand(command, options, signal, cwd);
+        await store.complete(path, result as unknown as JsonValue);
+        return result;
+      } finally {
+        const stopped = await persistRunState(store, metadata, (current) => {
+          const activeShells = Math.max(0, (current.activeShells ?? 0) - 1);
+          if (activeShells > 0) return { ...current, activeShells };
+          const next = { ...current };
+          delete next.activeShells;
+          return next;
+        });
+        runs.get(store.runId)?.update?.(workflowToolUpdate(withLiveActivities(stopped)));
+      }
     } finally { await lifecycle.leave(); }
   };
   const lifecycleFor = (store: RunStore, state: RunState, budget: WorkflowBudgetRuntime, metadata: WorkflowMetadata) => new RunLifecycle(state, async (next, previous, reason) => {
     if (next !== "pausing") budget.transition(next);
     const persisted = await persistRunState(store, metadata, (current) => {
       const nextRun = { ...current, state: next, ...budget.snapshot() };
-      if (next === "running" || next === "completed") delete nextRun.error;
+      if (next === "running" || next === "completed") { delete nextRun.error; delete nextRun.failedAt; }
       return nextRun;
     });
     await eventPublisher.runState(store, metadata, previous, next, reason);
@@ -1335,25 +1746,28 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const onProgress = async (progress: AgentProgress) => {
         let runState: PersistedRun;
         if (progress.persist) {
-          runState = await persistRunState(run.store, run.metadata, (current) => current.agents.some((agent) => agent.id === id) ? { ...current, ...run.budget.snapshot(), agents: current.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, activity: progress.activity } : agent) } : current);
+          runState = await persistRunState(run.store, run.metadata, (current) => current.agents.some((agent) => agent.id === id) ? { ...current, ...run.budget.snapshot(), agents: current.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, activity: progress.activity, ...(progress.lastEventAt === undefined ? {} : { lastEventAt: progress.lastEventAt }) } : agent) } : current);
         } else {
           const loaded = await run.store.load();
           if (!loaded.run.agents.some((agent) => agent.id === id)) return;
-          runState = { ...loaded.run, ...run.budget.snapshot(), agents: loaded.run.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, activity: progress.activity } : agent) };
+          runState = { ...loaded.run, ...run.budget.snapshot(), agents: loaded.run.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, activity: progress.activity, ...(progress.lastEventAt === undefined ? {} : { lastEventAt: progress.lastEventAt }) } : agent) };
         }
         if (!runState.agents.some((agent) => agent.id === id)) return;
         setLiveActivity(runId, id, progress.activity);
+        setLiveEventTime(runId, id, progress.lastEventAt);
         run.update?.(workflowToolUpdate(withLiveActivities(runState)));
       };
       const onAttempt = async (attempt: Pick<AgentAttempt, "attempt" | "sessionId" | "sessionFile" | "setup">) => {
         await scheduler.flush();
         scheduler.attemptStarted(id);
+        const lastEventAt = Date.now();
+        setLiveEventTime(runId, id, lastEventAt);
         await scheduler.flush();
         const before = (await run.store.load()).run;
         await persistActiveAgentAttempt(run.store, id, attempt);
         const active = (await run.store.load()).run;
         await eventPublisher.agentStates(run.store, run.metadata, before.agents, active.agents);
-        const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
+        const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot(), agents: current.agents.map((agent) => agent.id === id ? { ...agent, lastEventAt } : agent) }));
         run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
       };
       const result = await run.executor.execute(prompt, { label: options.label, workflowName: run.metadata.name, onProgress, onAttempt, budget, ...(run.providerErrorRecovery ? { providerErrorRecovery: run.providerErrorRecovery } : {}), ...(parentId ? { parent: parentId, cwd: options.cwd, ...(options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}) } : options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}), ...(options.model ? { model: options.model } : {}), ...(options.thinking ? { thinking: options.thinking } : {}), ...(options.role ? { role: options.role } : {}), ...(options.role ? {} : { tools: options.tools }), effectiveTools: options.tools, ...(options.schema ? { schema: options.schema } : {}), ...(options.retries === undefined ? {} : { retries: options.retries }), ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }), ...(options.agentOptions ? { agentOptions: options.agentOptions } : {}), ...(options.agentIdentity ? { agentIdentity: options.agentIdentity } : {}) }, signal, scheduler.toolsFor(id, (role, tools, model, inheritedTools, thinking) => run.executor.resolve({ label: "child", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(tools !== undefined ? { tools } : {}) }, inheritedTools).tools), setSteer, () => { scheduler.cancelChildren(id); scheduler.retry(id); });
@@ -1392,7 +1806,9 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
         let effective: { model: ModelSpec; requestedModel?: string; tools: readonly string[] };
         try { effective = run.executor.resolve(requested); }
         catch { effective = previous ? { model: previous.model, ...(previous.requestedModel ? { requestedModel: previous.requestedModel } : {}), tools: previous.tools } : { model: node.options.model ? modelSpec(node.options.model, run.model) : { ...run.model, ...(node.options.thinking ? { thinking: node.options.thinking } : {}) }, ...(node.options.model ? { requestedModel: node.options.model } : {}), tools: node.options.tools }; }
-        return { id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), structuralPath: [...(node.options.agentIdentity?.structuralPath ?? [])], ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.worktreeOwner ? { worktreeOwner: node.options.worktreeOwner } : {}), ...(node.options.role ? { role: node.options.role } : {}), ...(effective.requestedModel ? { requestedModel: effective.requestedModel } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}) };
+        const resultPath = !node.parentId && node.options.agentIdentity ? agentIdentityPath(node.options.agentIdentity) : undefined;
+        const lastEventAt = node.state === "running" ? previous?.state === "running" && previous.lastEventAt !== undefined ? previous.lastEventAt : Date.now() : previous?.lastEventAt;
+        return { id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), structuralPath: [...(node.options.agentIdentity?.structuralPath ?? [])], ...(resultPath ? { resultPath } : {}), ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.worktreeOwner ? { worktreeOwner: node.options.worktreeOwner } : {}), ...(node.options.role ? { role: node.options.role } : {}), ...(effective.requestedModel ? { requestedModel: effective.requestedModel } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}), ...(lastEventAt === undefined ? {} : { lastEventAt }) };
       });
       return { ...current, agents };
     });
@@ -1401,7 +1817,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
   });
   const cleanupTerminalRun = async (runId: string): Promise<void> => {
     const run = runs.get(runId);
-    if (!run || !["completed", "failed", "stopped"].includes(run.lifecycle.state)) return;
+    if (!run || !HARD_TERMINAL_RUN_STATES.has(run.lifecycle.state)) return;
     await scheduler.cancelRun(runId);
     await scheduler.flush();
     if (runs.get(runId) !== run) return;
@@ -1409,6 +1825,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     terminalRunStates.set(runId, run.lifecycle.state as "completed" | "failed" | "stopped");
     run.checkpointResolvers.clear();
     liveActivities.delete(runId);
+    liveEventTimes.delete(runId);
     eventPublisher.removeRun(runId);
     runs.delete(runId);
   };
@@ -1444,13 +1861,13 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     run.budget.recordEvent({ type, budgetVersion: request.budgetVersion, dimensions: [], usage: structuredClone(request.consumed), limits: structuredClone(request.proposed), at: Date.now(), proposalId: request.proposalId, previous: structuredClone(request.previous), proposed: structuredClone(request.proposed) });
     await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
   };
-  const answerBudgetDecision = async (runId: string, proposalId: string, approved: boolean, silent = false, context?: unknown, signal?: AbortSignal): Promise<BudgetDecisionResult | undefined> => {
+  const answerBudgetDecision = async (runId: string, proposalId: string, approved: boolean, silent = false, context?: unknown, signal?: AbortSignal, waitForCompletion = true): Promise<BudgetDecisionResult | undefined> => {
     const run = runs.get(runId);
     if (!run) return undefined;
     const request = await run.store.answerWorkflowDecision(proposalId, approved);
     if (!request) return undefined;
     await appendBudgetDecisionEvent(run, request, approved ? "adjustment_approved" : "adjustment_rejected");
-    const result = await applyBudgetDecision(request, approved, context, signal);
+    const result = await applyBudgetDecision(request, approved, context, signal, waitForCompletion);
     if (!silent) deliver(pi, `Workflow ${run.metadata.name} budget adjustment ${proposalId}: ${approved ? "Approved" : "Rejected"}.`);
     return result;
   };
@@ -1514,6 +1931,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
         throw mainAgentError(error);
       }
     },
+    renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_respond", args, theme)); },
+    renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_respond", context.args, result, options.expanded, theme, context.isError), options.expanded); },
   });
   pi.registerTool({
     name: "workflow_stop",
@@ -1528,6 +1947,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
         throw mainAgentError(error);
       }
     },
+    renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_stop", args, theme)); },
+    renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_stop", context.args, result, options.expanded, theme, context.isError), options.expanded); },
   });
   let catalogRegistered = false;
   let sessionStarted = false;
@@ -1557,35 +1978,102 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     });
     catalogRegistered = true;
   };
-  const refreshPausedRunAliases = async (run: NonNullable<ReturnType<typeof runs.get>>, context?: { model: { provider: string; id: string } | undefined; modelRegistry: ModelRegistryCapability | undefined; projectTrusted?: boolean }) => {
-    const loaded = await run.store.load();
-    const active = new Set(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-    const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
+  const createAgentExecutor = (root: Omit<import("./agent-execution.js").AgentExecutionRoot, "agentDir" | "agentSetupHooks">) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, ...(additionalSkillPaths.length ? { additionalSkillPaths } : {}), agentSetupHooks: registry.agentSetupHooks() }, createSession);
+  const activeSnapshotTools = (tools: readonly string[], active: ReadonlySet<string> | "session") => active === "session"
+    ? new Set(tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog"))
+    : new Set(tools.filter((tool) => active.has(tool) || tool === "workflow_catalog"));
+  const resumeLaunchPrologue = async (input: {
+    snapshot: Readonly<LaunchSnapshot>;
+    cwd: string;
+    trustedProject: boolean;
+    rootModel: ModelSpec;
+    modelRegistry?: ModelRegistryCapability | undefined;
+    signal: AbortSignal;
+    resolvedAliases?: Readonly<Record<string, string>>;
+    blockedAliases?: ReadonlySet<string>;
+    blockedAliasTargets?: Readonly<Record<string, string>>;
+    withPreflight: boolean;
+  }) => {
+    const active = new Set(pi.getActiveTools().filter((tool) => !INTERNAL_WORKFLOW_TOOLS.includes(tool)));
+    const missing = input.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
     if (missing) throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
     const settingsPath = workflowSettingsPath(extensionAgentDir);
-    const trustedProject = context?.projectTrusted ?? run.projectTrusted();
-    const resolution = resolveWorkflowSettings(run.store.cwd, trustedProject, settingsPath);
-    const currentPolicy = resolveAgentResourcePolicy(run.store.cwd, trustedProject, settingsPath);
+    const resolution = resolveWorkflowSettings(input.cwd, input.trustedProject, settingsPath);
+    const currentPolicy = resolveAgentResourcePolicy(input.cwd, input.trustedProject, settingsPath);
     const staticAliases = resolution.effective.modelAliases ?? {};
-    const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
+    const previousAliases = input.snapshot.modelAliases ?? input.snapshot.settings.modelAliases ?? {};
+    const inventory = modelInventory(input.rootModel, input.modelRegistry);
+    const knownModels = input.modelRegistry ? inventory.knownModels : new Set([...input.snapshot.models, ...inventory.knownModels]);
+    const availableModels = input.modelRegistry ? inventory.availableModels : new Set([...input.snapshot.models, ...inventory.availableModels]);
+    const currentAliases = input.resolvedAliases ?? (await resolveLaunchAliases(registry, staticAliases, { cwd: input.cwd, projectTrusted: input.trustedProject, rootModel: input.rootModel, knownModels, availableModels, signal: input.signal }, availableModels, knownModels, settingsPath)).aliases;
+    const blockedAliases = input.blockedAliases ?? new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
+    const blockedAliasTargets = input.blockedAliasTargets ?? Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
+    let script: ReturnType<typeof launchScriptForSnapshot> | undefined;
+    if (input.withPreflight) {
+      const resumeAliases = { ...previousAliases, ...currentAliases };
+      script = launchScriptForSnapshot(input.snapshot, registry);
+      preflight(script, { models: availableModels, tools: active, agentTypes: new Set(input.snapshot.agentTypes), modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, input.snapshot.schemas, input.snapshot.metadata, true);
+    }
+    const refreshed = resumedSnapshotSettings(input.snapshot, resolution, currentAliases);
+    const snapshot = createLaunchSnapshot({ ...input.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
+    return { active, settingsPath, resolution, currentPolicy, previousAliases, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot, script };
+  };
+  const workflowAgentHandler = (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle, executor: WorkflowAgentExecutor, cwd: string, runId: string, captureRole?: (role: string, model: ModelSpec) => Promise<void>) => async (prompt: string, options: Readonly<Record<string, JsonValue>>, agentSignal: AbortSignal, identity: import("./types.js").AgentIdentity) => {
+    await lifecycle.enter();
+    try {
+      const path = agentIdentityPath(identity);
+      const replayed = await store.replay(path);
+      if (replayed) {
+        return replayed.value;
+      }
+      const worktree = agentWorktree(identity);
+      const agentCwd = worktree.worktreeOwner ? (await persistWorktree(store, metadata, worktree.worktreeOwner)).cwd : cwd;
+      const role = typeof options.role === "string" ? options.role : undefined;
+      const model = typeof options.model === "string" ? options.model : undefined;
+      const thinking = parseThinking(options.thinking);
+      const requestedLabel = typeof options.label === "string" ? options.label : undefined;
+      const resolved = executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools as string[] } : {}) });
+      if (role) await captureRole?.(role, resolved.model);
+      const label = displayAgentName(requestedLabel, role, resolved.model);
+      const tools = resolved.tools;
+      const schema = object(options.outputSchema) ? options.outputSchema : undefined;
+      const spawned = scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd: agentCwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
+      const cancel = () => { scheduler.cancel(spawned.id); };
+      if (agentSignal.aborted) cancel(); else agentSignal.addEventListener("abort", cancel, { once: true });
+      const outcome = await spawned.result.finally(() => { agentSignal.removeEventListener("abort", cancel); });
+      if (!outcome.ok) throw new WorkflowError(outcome.error.code as WorkflowErrorCode, outcome.error.message);
+      await store.complete(path, outcome.value);
+      return outcome.value;
+    } finally { await lifecycle.leave(); }
+  };
+  const refreshPausedRunAliases = async (run: NonNullable<ReturnType<typeof runs.get>>, context?: { model: { provider: string; id: string } | undefined; modelRegistry: ModelRegistryCapability | undefined; projectTrusted?: boolean }) => {
+    const loaded = await run.store.load();
+    const trustedProject = context?.projectTrusted ?? run.projectTrusted();
     const rootModel = context?.model ? { ...run.model, provider: context.model.provider, model: context.model.id } : run.model;
-    const inventory = modelInventory(rootModel, context?.modelRegistry);
-    const knownModels = context?.modelRegistry ? inventory.knownModels : new Set([...loaded.snapshot.models, ...inventory.knownModels]);
-    const availableModels = context?.modelRegistry ? inventory.availableModels : new Set([...loaded.snapshot.models, ...inventory.availableModels]);
-    const currentAliases = (await resolveLaunchAliases(registry, staticAliases, { cwd: run.store.cwd, projectTrusted: trustedProject, rootModel, knownModels, availableModels, signal: run.abortController.signal }, availableModels, knownModels, settingsPath)).aliases;
-    const blockedAliases = new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-    const blockedAliasTargets = Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-    const refreshed = resumedSnapshotSettings(loaded.snapshot, resolution, currentAliases);
-    const snapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
+    const { settingsPath, currentPolicy, previousAliases, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot } = await resumeLaunchPrologue({ snapshot: loaded.snapshot, cwd: run.store.cwd, trustedProject, rootModel, ...(context?.modelRegistry ? { modelRegistry: context.modelRegistry } : {}), signal: run.abortController.signal, withPreflight: false });
     await run.store.saveSnapshot(snapshot);
     scheduler.updateRunLimit(run.store.runId, snapshot.settings.concurrency);
-    run.executor = new WorkflowAgentExecutor({ cwd: run.store.cwd, agentDir: extensionAgentDir, model: run.model, tools: new Set(snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(currentPolicy) }, createSession);
+    run.executor = createAgentExecutor({ cwd: run.store.cwd, model: run.model, tools: activeSnapshotTools(snapshot.tools, "session"), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentResourcePolicy: frozenResourcePolicy(currentPolicy) });
     run.executor.setRunContext(workflowRunContext(run.store.cwd, run.store.sessionId, run.store.runId, loaded.snapshot.metadata, loaded.snapshot.args, run.abortController.signal));
     const drift = aliasDrift(previousAliases, currentAliases);
     if (drift.length) await run.store.appendEvent({ type: "warning", message: `Model alias mappings changed on resume: ${drift.join("; ")}` });
   };
-  const coldResumeRun = async (run: NonNullable<ReturnType<typeof runs.get>>, hasUI: boolean, ui: { select?: (prompt: string, options: string[]) => Promise<string | undefined> }, trustedProject: boolean, context?: { model: { provider: string; id: string } | undefined; modelRegistry: ModelRegistryCapability | undefined; signal?: AbortSignal | undefined; resolvedAliases?: Readonly<Record<string, string>>; blockedAliases?: ReadonlySet<string>; blockedAliasTargets?: Readonly<Record<string, string>> }) => {
+  const recoveryUi = (context: unknown): { hasUI: boolean; ui: { select?: (prompt: string, options: string[]) => Promise<string | undefined> } } => {
+    const host = object(context) ? context : undefined;
+    const ui = host && object(host.ui) ? host.ui as { select?: (prompt: string, options: string[]) => Promise<string | undefined> } : {};
+    return { hasUI: host?.hasUI === true, ui };
+  };
+  type ColdResumeResult = { value: JsonValue; resultPath: string };
+  const coldResumeRun = async (run: NonNullable<ReturnType<typeof runs.get>>, hasUI: boolean, ui: { select?: (prompt: string, options: string[]) => Promise<string | undefined> }, trustedProject: boolean, context?: { model: { provider: string; id: string } | undefined; modelRegistry: ModelRegistryCapability | undefined; signal?: AbortSignal | undefined; resolvedAliases?: Readonly<Record<string, string>>; blockedAliases?: ReadonlySet<string>; blockedAliasTargets?: Readonly<Record<string, string>> }, modeOverride?: boolean, waitForCompletion = true): Promise<ColdResumeResult | undefined> => {
     const loaded = await run.store.load();
+    const foreground = modeOverride ?? loaded.snapshot.launchMode === "foreground";
+    if (loaded.run.activeShells !== undefined) {
+      await persistRunState(run.store, run.metadata, (current) => {
+        const next = { ...current };
+        delete next.activeShells;
+        return next;
+      });
+    }
     await run.store.validateRetrySource();
     await run.store.validateBorrowedWorktrees();
     if (loaded.snapshot.identityVersion !== LAUNCH_SNAPSHOT_IDENTITY_VERSION) throw new WorkflowError("RESUME_INCOMPATIBLE", "Workflow launch snapshot identity version is incompatible");
@@ -1593,32 +2081,16 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     if ((loaded.snapshot.projectRoles?.length ?? 0) > 0 && !trustedProject) throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot restore project roles in an untrusted project");
     const missingRole = loaded.snapshot.agentTypes.find((role) => !loaded.snapshot.roles?.[role]);
     if (missingRole) throw new WorkflowError("RESUME_INCOMPATIBLE", `Role definition is missing from the launch snapshot: ${missingRole}`);
-    const active = new Set(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-    const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
-    if (missing) throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
-    const settingsPath = workflowSettingsPath(extensionAgentDir);
-    const resolution = resolveWorkflowSettings(run.store.cwd, trustedProject, settingsPath);
-    const currentPolicy = resolveAgentResourcePolicy(run.store.cwd, trustedProject, settingsPath);
-    const staticAliases = resolution.effective.modelAliases ?? {};
-    const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
     const rootModel = context?.model ? { ...run.model, provider: context.model.provider, model: context.model.id } : run.model;
-    const inventory = modelInventory(rootModel, context?.modelRegistry);
-    const knownModels = context?.modelRegistry ? inventory.knownModels : new Set([...loaded.snapshot.models, ...inventory.knownModels]);
-    const availableModels = context?.modelRegistry ? inventory.availableModels : new Set([...loaded.snapshot.models, ...inventory.availableModels]);
     const controller = new AbortController();
     if (context?.signal?.aborted) controller.abort(); else { context?.signal?.addEventListener("abort", () => { controller.abort(); }, { once: true }); }
     run.abortController = controller;
-    const currentAliases = context?.resolvedAliases ?? (await resolveLaunchAliases(registry, staticAliases, { cwd: run.store.cwd, projectTrusted: trustedProject, rootModel, knownModels, availableModels, signal: controller.signal }, availableModels, knownModels, settingsPath)).aliases;
-    const resumeAliases = { ...previousAliases, ...currentAliases };
-    const blockedAliases = context?.blockedAliases ?? new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-    const blockedAliasTargets = context?.blockedAliasTargets ?? Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-    const script = launchScriptForSnapshot(loaded.snapshot, registry);
-    preflight(script, { models: availableModels, tools: active, agentTypes: new Set(loaded.snapshot.agentTypes), modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, loaded.snapshot.schemas, loaded.snapshot.metadata, true);
-    const refreshed = resumedSnapshotSettings(loaded.snapshot, resolution, currentAliases);
-    const snapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
-    await run.store.saveSnapshot(snapshot);
+    const { settingsPath, currentPolicy, previousAliases, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot, script } = await resumeLaunchPrologue({ snapshot: loaded.snapshot, cwd: run.store.cwd, trustedProject, rootModel, ...(context?.modelRegistry ? { modelRegistry: context.modelRegistry } : {}), signal: controller.signal, ...(context?.resolvedAliases ? { resolvedAliases: context.resolvedAliases } : {}), ...(context?.blockedAliases ? { blockedAliases: context.blockedAliases } : {}), ...(context?.blockedAliasTargets ? { blockedAliasTargets: context.blockedAliasTargets } : {}), withPreflight: true });
+    if (!script) throw new WorkflowError("INTERNAL_ERROR", "Resume preflight did not produce a launch script");
+    const persistedSnapshot = modeOverride === undefined ? snapshot : createLaunchSnapshot({ ...snapshot, launchMode: foreground ? "foreground" : "background" });
+    await run.store.saveSnapshot(persistedSnapshot);
     scheduler.updateRunLimit(run.store.runId, snapshot.settings.concurrency);
-    run.executor = new WorkflowAgentExecutor({ cwd: run.store.cwd, agentDir: extensionAgentDir, model: rootModel, tools: new Set(snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(currentPolicy) }, createSession);
+    run.executor = createAgentExecutor({ cwd: run.store.cwd, model: rootModel, tools: activeSnapshotTools(snapshot.tools, "session"), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentResourcePolicy: frozenResourcePolicy(currentPolicy) });
     const drift = aliasDrift(previousAliases, currentAliases);
     if (drift.length) await run.store.appendEvent({ type: "warning", message: `Model alias mappings changed on resume: ${drift.join("; ")}` });
     const runContext = workflowRunContext(run.store.cwd, run.store.sessionId, run.store.runId, loaded.snapshot.metadata, loaded.snapshot.args, controller.signal);
@@ -1627,39 +2099,13 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     try { variables = await resolveWorkflowVariables(runContext, controller, registry); }
     catch (error) {
       const typed = asWorkflowError(error);
-      if (!["completed", "failed", "stopped"].includes(run.lifecycle.state)) { await run.lifecycle.terminal("failed", typed.code).catch(() => undefined); const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, error: { code: typed.code, message: typed.message } })); await eventPublisher.runFailed(run.store, run.metadata, typed, run.lifecycle.state === "interrupted" ? "interrupted" : "failed"); run.update?.(workflowToolUpdate(persisted)); if (!["stopped", "interrupted", "budget_exhausted"].includes(run.lifecycle.state)) await createWorkflowFailureDiagnostics(run.store, run.metadata, typed, persisted).then((diagnostic) => { deliverFailure(pi, diagnostic); }).catch(() => undefined); }
+      if (!HARD_TERMINAL_RUN_STATES.has(run.lifecycle.state)) { await run.lifecycle.terminal("failed", typed.code).catch(() => undefined); const persisted = await persistRunState(run.store, run.metadata, (current) => persistedFailure({ ...current }, typed)); await eventPublisher.runFailed(run.store, run.metadata, typed, run.lifecycle.state === "interrupted" ? "interrupted" : "failed"); run.update?.(workflowToolUpdate(persisted)); if (!["stopped", "interrupted", "budget_exhausted"].includes(run.lifecycle.state)) await createWorkflowFailureDiagnostics(run.store, run.metadata, typed, persisted).then((diagnostic) => { deliverFailure(pi, diagnostic); }).catch(() => undefined); }
       await cleanupTerminalRun(run.store.runId);
       throw typed;
     }
     await scheduler.cancelRun(run.store.runId);
     await run.lifecycle.resume();
-    const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: async (prompt, options, signal, identity) => {
-      await run.lifecycle.enter();
-      try {
-        const path = agentIdentityPath(identity);
-        const replayed = await run.store.replay(path);
-        if (replayed) {
-          return replayed.value;
-        }
-        const worktree = agentWorktree(identity);
-        const cwd = worktree.worktreeOwner ? (await persistWorktree(run.store, run.metadata, worktree.worktreeOwner)).cwd : run.store.cwd;
-        const role = typeof options.role === "string" ? options.role : undefined;
-        const model = typeof options.model === "string" ? options.model : undefined;
-        const thinking = parseThinking(options.thinking);
-        const requestedLabel = typeof options.label === "string" ? options.label : undefined;
-        const resolved = run.executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools as string[] } : {}) });
-        const label = displayAgentName(requestedLabel, role, resolved.model);
-        const tools = resolved.tools;
-        const schema = object(options.outputSchema) ? options.outputSchema : undefined;
-        const spawned = scheduler.spawn(run.store.runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
-        const cancel = () => { scheduler.cancel(spawned.id); };
-        signal.addEventListener("abort", cancel, { once: true });
-        const outcome = await spawned.result.finally(() => { signal.removeEventListener("abort", cancel); });
-        if (!outcome.ok) throw new WorkflowError(outcome.error.code as WorkflowErrorCode, outcome.error.message);
-        await run.store.complete(path, outcome.value);
-        return outcome.value;
-      } finally { await run.lifecycle.leave(); }
-      }, worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, false, hasUI ? ui : undefined), phase: phaseBridge(run.store, run.metadata, run.lifecycle), log: logBridge(run.lifecycle, run.metadata.name) }, run.store, runContext, variables, registry), controller.signal);
+    const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: workflowAgentHandler(run.store, run.metadata, run.lifecycle, run.executor, run.store.cwd, run.store.runId), worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, foreground, hasUI ? ui : undefined), phase: phaseBridge(run.store, run.metadata, run.lifecycle), log: logBridge(run.lifecycle, run.metadata.name) }, run.store, runContext, variables, registry), controller.signal);
     run.execution = execution;
     const completion = execution.result.then(async (value) => {
       await scheduler.flush();
@@ -1672,17 +2118,28 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       await scheduler.flush();
       const typed = error instanceof WorkflowError ? error : new WorkflowError(errorCode(error) ?? "INTERNAL_ERROR", errorText(error));
       if (!["stopped", "interrupted", "budget_exhausted"].includes(run.lifecycle.state)) await run.lifecycle.terminal(typed.code === "BUDGET_EXHAUSTED" ? "budget_exhausted" : "failed", typed.code);
-      const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot(), error: { code: typed.code, message: typed.message } }));
+      const persisted = await persistRunState(run.store, run.metadata, (current) => persistedFailure({ ...current, ...run.budget.snapshot() }, typed));
       const state = run.lifecycle.state === "stopped" || run.lifecycle.state === "interrupted" || run.lifecycle.state === "budget_exhausted" ? run.lifecycle.state : "failed";
       if (state === "failed") retryReservations.delete(persisted.retry?.lineageRootRunId ?? run.store.runId);
       await eventPublisher.runFailed(run.store, run.metadata, typed, state);
       run.update?.(workflowToolUpdate(persisted));
-      if (!["stopped", "interrupted", "budget_exhausted"].includes(run.lifecycle.state)) await createWorkflowFailureDiagnostics(run.store, run.metadata, typed, persisted).then((diagnostic) => { deliverFailure(pi, diagnostic); }).catch(() => undefined);
+      if (!["stopped", "interrupted", "budget_exhausted"].includes(run.lifecycle.state)) { const diagnostic = await createWorkflowFailureDiagnostics(run.store, run.metadata, typed, persisted); Object.defineProperty(typed, WORKFLOW_FAILURE_DIAGNOSTICS, { value: diagnostic }); }
+      throw typed;
     }).finally(() => cleanupTerminalRun(run.store.runId));
     run.completion = completion;
-    void completion;
+    if (!foreground || !waitForCompletion) {
+      void completion.then(async ({ value, resultPath }) => {
+        deliver(pi, completionDelivery(run.metadata.name, value, resultPath, await run.store.changedWorktrees()));
+      }, (error: unknown) => {
+        const diagnostic = failureDiagnosticsFrom(error);
+        if (diagnostic) deliverFailure(pi, diagnostic);
+        else deliver(pi, formatWorkflowFailureDeliveryFallback(run.metadata.name, run.store.runId, run.store.directory, error));
+      });
+      return undefined;
+    }
+    return completion;
   };
-  const applyBudgetDecision = async (request: BudgetApprovalRequest, approved: boolean, context?: unknown, signal?: AbortSignal): Promise<BudgetDecisionResult> => {
+  const applyBudgetDecision = async (request: BudgetApprovalRequest, approved: boolean, context?: unknown, signal?: AbortSignal, waitForCompletion = true): Promise<BudgetDecisionResult> => {
     const run = runs.get(request.runId);
     if (!run) throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${request.runId}`);
     if (!approved) return { state: "budget_exhausted", approved: false };
@@ -1691,14 +2148,30 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     const runtime = new WorkflowBudgetRuntime(nextBudget, nextVersion, request.consumed, run.budget.events, { active: false });
     run.budget = runtime;
     await persistRunState(run.store, run.metadata, (current) => { const next = { ...current, ...runtime.snapshot(), budgetVersion: nextVersion }; if (nextBudget) next.budget = nextBudget; else delete next.budget; return next; });
-    await coldResumeRun(run, false, {}, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) });
+    const { hasUI, ui } = recoveryUi(context);
+    const completed = await coldResumeRun(run, hasUI, ui, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) }, undefined, waitForCompletion);
+    if (completed) return { state: "completed", approved: true, value: completed.value, run: (await run.store.load()).run };
     return { state: "running", approved: true };
   };
-  const resumeWorkflowRun = async (runId: string, rawPatch?: unknown, context?: unknown, signal?: AbortSignal): Promise<Record<string, JsonValue>> => {
+  const resumeWorkflowRun = async (runId: string, rawPatch?: unknown, context?: unknown, signal?: AbortSignal, modeOverride?: boolean, waitForCompletion = true): Promise<Record<string, JsonValue>> => {
     const run = runs.get(runId);
-    if (!run) throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${runId}`);
+    if (!run) {
+      const host = object(context) ? context : {};
+      const cwd = typeof host.cwd === "string" ? host.cwd : undefined;
+      const sessionManager = object(host.sessionManager) ? host.sessionManager : undefined;
+      const sessionId = typeof sessionManager?.getSessionId === "function" ? String(Reflect.apply(sessionManager.getSessionId, sessionManager, [])) : undefined;
+      if (cwd && sessionId) {
+        try {
+          const state = (await new RunStore(cwd, sessionId, runId, home).load()).run.state;
+          throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("resume", state));
+        } catch (error) {
+          if (error instanceof WorkflowError) throw error;
+        }
+      }
+      throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run ${runId} in the current project and Pi session`);
+    }
     const loaded = await run.store.load();
-    if (loaded.run.state !== "budget_exhausted") throw new WorkflowError("RESUME_INCOMPATIBLE", "Only budget-exhausted runs can be resumed with workflow_resume");
+    if (loaded.run.state !== "budget_exhausted") throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("resume", loaded.run.state));
     const currentBudget = validateBudget(loaded.run.budget ?? loaded.snapshot.budget);
     const patch = rawPatch === undefined ? {} : validateBudgetPatch(rawPatch);
     const nextBudget = mergeBudget(currentBudget, patch);
@@ -1719,11 +2192,13 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       run.budget = runtime;
       await persistRunState(run.store, run.metadata, (current) => { const next = { ...current, ...runtime.snapshot(), budgetVersion: nextVersion }; if (nextBudget) next.budget = nextBudget; else delete next.budget; return next; });
     }
-    await coldResumeRun(run, false, {}, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) });
+    const { hasUI, ui } = recoveryUi(context);
+    const completed = await coldResumeRun(run, hasUI, ui, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) }, modeOverride, waitForCompletion);
+    if (completed) return { state: "completed", runId, value: completed.value, run: (await run.store.load()).run as unknown as JsonValue };
     return { state: "running" };
   };
   const retryReservations = new Set<string>();
-  const retryWorkflowRun = async (runId: string, context: unknown, signal?: AbortSignal): Promise<{ runId: string; parentRunId: string; state: "running" }> => {
+  const retryWorkflowRun = async (runId: string, context: unknown, signal?: AbortSignal, modeOverride?: boolean): Promise<{ runId: string; parentRunId: string; state: "running" | "completed"; value?: JsonValue; run?: PersistedRun }> => {
     if (typeof runId !== "string" || !runId.trim()) throw new WorkflowError("RESUME_INCOMPATIBLE", "workflow_retry requires an explicit run ID");
     const host = object(context) ? context : {};
     const cwd = typeof host.cwd === "string" ? host.cwd : undefined;
@@ -1733,8 +2208,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     await ensureSessionLease(cwd, sessionId);
     const sourceStore = new RunStore(cwd, sessionId, runId, home);
     let loaded: { run: PersistedRun; snapshot: Readonly<LaunchSnapshot> };
-    try { loaded = await sourceStore.load(); } catch (error) { throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot load failed source run ${runId}: ${errorText(error)}`); }
-    if (loaded.run.state !== "failed") throw new WorkflowError("RESUME_INCOMPATIBLE", `Only failed workflow runs can be retried; source is ${loaded.run.state}`);
+    try { loaded = await sourceStore.load(); } catch (error) { throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run ${runId} in the current project and Pi session: ${errorText(error)}`); }
+    if (loaded.run.state !== "failed") throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("retry", loaded.run.state));
     if (loaded.run.retry && (typeof loaded.run.retry.sourceRunId !== "string" || !loaded.run.retry.sourceRunId || typeof loaded.run.retry.lineageRootRunId !== "string" || !loaded.run.retry.lineageRootRunId || !Array.isArray(loaded.run.retry.completedPaths) || loaded.run.retry.completedPaths.some((path) => typeof path !== "string") || !Array.isArray(loaded.run.retry.incompletePaths) || loaded.run.retry.incompletePaths.some((path) => typeof path !== "string") || !Array.isArray(loaded.run.retry.namedWorktrees) || loaded.run.retry.namedWorktrees.some((name) => typeof name !== "string"))) throw new WorkflowError("RESUME_INCOMPATIBLE", "The source retry provenance is incomplete");
     const lineageRootRunId = loaded.run.retry?.lineageRootRunId ?? loaded.run.id;
     if (retryReservations.has(lineageRootRunId)) throw new WorkflowError("RESUME_INCOMPATIBLE", `An active retry already owns lineage ${lineageRootRunId}`);
@@ -1760,27 +2235,10 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       if ((loaded.snapshot.projectRoles?.length ?? 0) > 0 && !trustedProject) throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot restore project roles in an untrusted project");
       const missingRole = loaded.snapshot.agentTypes.find((role) => !loaded.snapshot.roles?.[role]);
       if (missingRole) throw new WorkflowError("RESUME_INCOMPATIBLE", `Role definition is missing from the launch snapshot: ${missingRole}`);
-      const active = new Set<string>(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-      const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
-      if (missing) throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
-      const settingsPath = workflowSettingsPath(extensionAgentDir);
-      const resolution = resolveWorkflowSettings(cwd, trustedProject, settingsPath);
-      const currentPolicy = resolveAgentResourcePolicy(cwd, trustedProject, settingsPath);
-      const staticAliases = resolution.effective.modelAliases ?? {};
-      const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
       const modelRegistry = contextHostCapabilities(context).modelRegistry;
       const hostModel = object(host.model) && typeof host.model.provider === "string" && typeof host.model.id === "string" ? { provider: host.model.provider, id: host.model.id } : { provider: "", id: "" };
       const rootModel: ModelSpec = { provider: hostModel.provider, model: hostModel.id, thinking: pi.getThinkingLevel() };
-      const inventory = modelInventory(rootModel, modelRegistry);
-      const knownModels = modelRegistry ? inventory.knownModels : new Set([...loaded.snapshot.models, ...inventory.knownModels]);
-      const availableModels = modelRegistry ? inventory.availableModels : new Set([...loaded.snapshot.models, ...inventory.availableModels]);
-      const resolvedAliases = await resolveLaunchAliases(registry, staticAliases, { cwd, projectTrusted: trustedProject, rootModel, knownModels, availableModels, signal: signal ?? new AbortController().signal }, availableModels, knownModels, settingsPath);
-      const currentAliases = resolvedAliases.aliases;
-      const resumeAliases = { ...previousAliases, ...currentAliases };
-      const blockedAliases = new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-      const blockedAliasTargets = Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-      const script = launchScriptForSnapshot(loaded.snapshot, registry);
-      preflight(script, { models: availableModels, tools: active, agentTypes: new Set(loaded.snapshot.agentTypes), modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, loaded.snapshot.schemas, loaded.snapshot.metadata, true);
+      const { active, settingsPath, currentPolicy, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot: childBaseSnapshot } = await resumeLaunchPrologue({ snapshot: loaded.snapshot, cwd, trustedProject, rootModel, ...(modelRegistry ? { modelRegistry } : {}), signal: signal ?? new AbortController().signal, withPreflight: true });
       await sourceStore.validateNamedWorktrees();
       for (const name of loaded.run.retry?.namedWorktrees ?? []) await sourceStore.resolveNamedWorktree(name);
       const completedPaths = (await sourceStore.replayableOperations()).map(({ path }) => path);
@@ -1789,8 +2247,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const budget = validateBudget(loaded.run.budget ?? loaded.snapshot.budget);
       const childRunId = randomUUID();
       const childStore = new RunStore(cwd, sessionId, childRunId, home);
-      const refreshed = resumedSnapshotSettings(loaded.snapshot, resolution, currentAliases);
-      const childSnapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
+      const childSnapshot = childBaseSnapshot;
       const childBudget = new WorkflowBudgetRuntime(budget, loaded.run.budgetVersion ?? 1, loaded.run.usage, loaded.run.budgetEvents);
       const childInitialBudget = childBudget.snapshot();
       const retry: WorkflowRetryProvenance = { sourceRunId: loaded.run.id, lineageRootRunId, completedPaths, incompletePaths, namedWorktrees };
@@ -1801,16 +2258,21 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const abortController = new AbortController();
       const providerErrorRecovery = createProviderErrorRecovery(context, availableModels, () => { abortController.abort(); });
       const providerPause = async () => { deliver(pi, `Workflow ${loaded.snapshot.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
-      const childRun = { executor: new WorkflowAgentExecutor({ cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => active.has(tool) || tool === "workflow_catalog")), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: loaded.snapshot.roles ?? {}, runStore: childStore, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(currentPolicy) }, createSession), store: childStore, metadata: loaded.snapshot.metadata, model, lifecycle, budget: childBudget, abortController, projectTrusted: () => projectTrusted(context), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) };
+      const childRun = { executor: createAgentExecutor({ cwd, model, tools: activeSnapshotTools(loaded.snapshot.tools, active), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: loaded.snapshot.roles ?? {}, runStore: childStore, providerPause, agentResourcePolicy: frozenResourcePolicy(currentPolicy) }), store: childStore, metadata: loaded.snapshot.metadata, model, lifecycle, budget: childBudget, abortController, projectTrusted: () => projectTrusted(context), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) };
       runs.set(childRunId, childRun);
       scheduler.addRun(childRunId, loaded.snapshot.settings.concurrency, () => { childBudget.checkAgentLaunch(); });
       await eventPublisher.runStarted(childStore, loaded.snapshot.metadata);
-      await coldResumeRun(childRun, false, {}, trustedProject, { model: hostModel, modelRegistry, resolvedAliases: currentAliases, blockedAliases, blockedAliasTargets, ...(signal ? { signal } : {}) });
+      const { hasUI, ui } = recoveryUi(context);
+      const completed = await coldResumeRun(childRun, hasUI, ui, trustedProject, { model: hostModel, modelRegistry, resolvedAliases: currentAliases, blockedAliases, blockedAliasTargets, ...(signal ? { signal } : {}) }, modeOverride);
       const completion = runs.get(childRunId)?.completion;
       if (completion) {
         childStarted = true;
         void completion.then(() => { retryReservations.delete(lineageRootRunId); }, () => { retryReservations.delete(lineageRootRunId); });
+      } else if (completed) {
+        childStarted = true;
+        retryReservations.delete(lineageRootRunId);
       }
+      if (completed) return { runId: childRunId, parentRunId: loaded.run.id, state: "completed", value: completed.value, run: (await childStore.load()).run };
       return { runId: childRunId, parentRunId: loaded.run.id, state: "running" };
     } finally {
       if (!childStarted) retryReservations.delete(lineageRootRunId);
@@ -1822,19 +2284,23 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     description: "Retry a failed workflow run by replaying its completed structural operations",
     parameters: WORKFLOW_RETRY_PARAMETERS,
     async execute(_id, params, signal, _onUpdate, ctx) {
-      try { const result = await retryWorkflowRun(params.runId, ctx, signal); return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result }; }
+      try { const result = await retryWorkflowRun(params.runId, ctx, signal, params.foreground); return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result }; }
       catch (error) { throw mainAgentError(error); }
     },
+    renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_retry", args, theme)); },
+    renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_retry", context.args, result, options.expanded, theme, context.isError), options.expanded); },
   });
   pi.registerTool({
     name: "workflow_resume",
     label: "Workflow Resume",
     description: "Resume an exhausted workflow with unchanged or patched aggregate budgets",
-    parameters: Type.Object({ runId: Type.String(), budget: Type.Optional(Type.Unknown()) }, { additionalProperties: false }),
+    parameters: Type.Object({ runId: Type.String(), budget: Type.Optional(Type.Unknown()), foreground: Type.Optional(Type.Boolean({ description: "Override the source launch mode for this recovery" })) }, { additionalProperties: false }),
     async execute(_id, params, signal, _onUpdate, ctx) {
-      try { const result = await resumeWorkflowRun(params.runId, params.budget, ctx, signal); return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result }; }
+      try { const result = await resumeWorkflowRun(params.runId, params.budget, ctx, signal, params.foreground); return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result }; }
       catch (error) { throw mainAgentError(error); }
     },
+    renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_resume", args, theme)); },
+    renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_resume", context.args, result, options.expanded, theme, context.isError), options.expanded); },
   });
   pi.on("session_start", async (_event, ctx) => {
     if (sessionStarted) return;
@@ -1851,10 +2317,23 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       if (loaded.run.state === "completed" || loaded.run.state === "failed" || loaded.run.state === "stopped") { terminalRunStates.set(runId, loaded.run.state); continue; }
       if (loaded.run.state !== "interrupted" && loaded.run.state !== "budget_exhausted") {
         const previousState = loaded.run.state;
-        await store.updateState((current) => ["completed", "failed", "stopped", "interrupted", "budget_exhausted"].includes(current.state) ? current : { ...current, state: "interrupted" });
+        await store.updateState((current) => {
+          if (["completed", "failed", "stopped", "interrupted", "budget_exhausted"].includes(current.state)) return current;
+          const next = { ...current, state: "interrupted" as const };
+          delete next.activeShells;
+          return next;
+        });
         loaded = { ...loaded, run: (await store.load()).run };
         await eventPublisher.runState(store, loaded.snapshot.metadata, previousState, "interrupted", "session_shutdown");
         loaded = { ...loaded, run: (await store.load()).run };
+      } else if (loaded.run.activeShells !== undefined) {
+        await store.updateState((current) => {
+          if (["completed", "failed", "stopped"].includes(current.state)) return current;
+          const next = { ...current };
+          delete next.activeShells;
+          return next;
+        });
+        loaded = { ...loaded, run: (await store.load()).run };
       }
       const model = modelSpec(loaded.snapshot.models[0] ?? "", { provider: ctx.model?.provider ?? "", model: ctx.model?.id ?? "", thinking: pi.getThinkingLevel() });
       const budget = validateBudget(loaded.run.budget ?? loaded.snapshot.budget);
@@ -1865,7 +2344,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const roleDefinitions = loaded.snapshot.roles ?? {};
       const abortController = new AbortController();
       const providerErrorRecovery = createProviderErrorRecovery(ctx, new Set(loaded.snapshot.models), () => { abortController.abort(); });
-      runs.set(runId, { executor: new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels: new Set(loaded.snapshot.models), knownModels: new Set(loaded.snapshot.models), ...(loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ? { modelAliases: loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases } : {}), ...(loaded.snapshot.settingsSources?.modelAliases ? { settingsPath: loaded.snapshot.settingsSources.modelAliases } : loaded.snapshot.settingsPath ? { settingsPath: loaded.snapshot.settingsPath } : {}), agentDefinitions: roleDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(snapshotResourcePolicy(loaded.snapshot, store.cwd, projectTrusted(ctx), workflowSettingsPath(extensionAgentDir))) }, createSession), store, metadata: loaded.snapshot.metadata, model, lifecycle, budget: budgetRuntime, abortController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) });
+      runs.set(runId, { executor: createAgentExecutor({ cwd: ctx.cwd, model, tools: activeSnapshotTools(loaded.snapshot.tools, "session"), availableModels: new Set(loaded.snapshot.models), knownModels: new Set(loaded.snapshot.models), ...(loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ? { modelAliases: loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases } : {}), ...(loaded.snapshot.settingsSources?.modelAliases ? { settingsPath: loaded.snapshot.settingsSources.modelAliases } : loaded.snapshot.settingsPath ? { settingsPath: loaded.snapshot.settingsPath } : {}), agentDefinitions: roleDefinitions, runStore: store, providerPause, agentResourcePolicy: frozenResourcePolicy(snapshotResourcePolicy(loaded.snapshot, store.cwd, projectTrusted(ctx), workflowSettingsPath(extensionAgentDir))) }), store, metadata: loaded.snapshot.metadata, model, lifecycle, budget: budgetRuntime, abortController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) });
       for (const checkpoint of await store.awaitingCheckpoints()) deliver(pi, `Workflow ${loaded.snapshot.metadata.name} checkpoint ${checkpoint.name}: ${checkpoint.prompt}\nContext: ${JSON.stringify(checkpoint.context)}\nRespond with workflow_respond.`);
       for (const decision of await store.pendingWorkflowDecisions()) deliver(pi, budgetDecisionDelivery(loaded.snapshot.metadata, decision));
       scheduler.restoreRun(runId, loaded.snapshot.settings.concurrency, loaded.snapshot.identityVersion === LAUNCH_SNAPSHOT_IDENTITY_VERSION ? await store.loadOwnership() : [], () => runs.get(runId)?.budget.checkAgentLaunch());
@@ -1880,7 +2359,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
         if (choice && choice !== "Skip") {
           const toResume = choice === "Resume all" ? interrupted : interrupted.filter((_, i) => labels[i] === choice);
           for (const run of toResume) {
-            try { await coldResumeRun(run, true, ctx.ui, projectTrusted(ctx), ctx); ctx.ui.notify(`Resumed workflow ${run.metadata.name}.`, "info"); }
+            try { await coldResumeRun(run, true, ctx.ui, projectTrusted(ctx), ctx, undefined, false); ctx.ui.notify(`Resumed workflow ${run.metadata.name}.`, "info"); }
             catch (err) { ctx.ui.notify(`Cannot resume ${run.metadata.name}: ${err instanceof Error ? err.message : String(err)}`, "warning"); }
           }
         }
@@ -1913,7 +2392,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const inventory = modelInventory(rootModel, modelRegistry);
       const knownModels = inventory.knownModels;
       const availableModels = inventory.availableModels;
-      const rootTools = pi.getActiveTools().filter((name) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(name));
+      const rootTools = pi.getActiveTools().filter((name) => !INTERNAL_WORKFLOW_TOOLS.includes(name));
       const trustedProject = projectTrusted(ctx);
       const launchCwd = typeof ctx.cwd === "string" ? ctx.cwd : process.cwd();
       const launch = workflowLaunchSettings(launchCwd, trustedProject, settingsPath, params.concurrency);
@@ -1937,45 +2416,33 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const projectRoles = roleNames.filter((role) => projectAgentDefinitions[role] !== undefined);
       const roleModels = roleNames.flatMap((role) => { const model = agentDefinitions[role]?.model; return model ? [modelCapability(model, modelAliases, knownModels, settingsPath)] : []; });
       const snapshotModels = [...new Set([rootModelName, ...checked.referenced.models, ...roleModels])];
-      const snapshot = createLaunchSnapshot({ script, args, metadata: checked.metadata, settings, settingsPath, settingsSources: { ...launch.resolution.sources, concurrency: params.concurrency === undefined ? launch.resolution.sources.concurrency : "per-run options" }, ...(functionName ? { launchKind: "function" as const, functionName } : {}), ...(Object.keys(modelAliases).length ? { modelAliases } : {}), ...(budget ? { budget } : {}), ...(checked.referenced.phases.length ? { phases: checked.referenced.phases } : {}), models: snapshotModels, tools: rootTools, agentTypes: checked.referenced.agentTypes, roles, projectRoles, schemas: checked.schemas });
+      const snapshot = createLaunchSnapshot({ script, args, metadata: checked.metadata, launchMode: params.foreground ? "foreground" : "background", settings, settingsPath, settingsSources: { ...launch.resolution.sources, concurrency: params.concurrency === undefined ? launch.resolution.sources.concurrency : "per-run options" }, ...(functionName ? { launchKind: "function" as const, functionName } : {}), ...(Object.keys(modelAliases).length ? { modelAliases } : {}), ...(budget ? { budget } : {}), ...(checked.referenced.phases.length ? { phases: checked.referenced.phases } : {}), models: snapshotModels, tools: rootTools, agentTypes: checked.referenced.agentTypes, roles, projectRoles, schemas: checked.schemas });
+      let persistedSnapshot = snapshot;
+      const captureFunctionRole = functionName ? async (role: string, model: ModelSpec): Promise<void> => {
+        const definition = agentDefinitions[role];
+        if (!definition) return;
+        const modelName = `${model.provider}/${model.model}`;
+        const hasProjectRole = projectAgentDefinitions[role] !== undefined;
+        if (persistedSnapshot.roles?.[role] !== undefined && (!hasProjectRole || persistedSnapshot.projectRoles?.includes(role)) && persistedSnapshot.models.includes(modelName)) return;
+        const roles = { ...(persistedSnapshot.roles ?? {}), [role]: definition };
+        const projectRoles = hasProjectRole ? [...new Set([...(persistedSnapshot.projectRoles ?? []), role])] : persistedSnapshot.projectRoles ?? [];
+        const models = [...new Set([...persistedSnapshot.models, modelName])];
+        persistedSnapshot = createLaunchSnapshot({ ...persistedSnapshot, models, roles, projectRoles });
+        await store.saveSnapshot(persistedSnapshot);
+      } : undefined;
       const budgetRuntime = new WorkflowBudgetRuntime(budget);
       const initialBudget = budgetRuntime.snapshot();
-      await store.create({ id: runId, workflowName: checked.metadata.name, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), state: "running", ...(parentRunId !== undefined ? { parentRunId } : {}), agents: [], nativeSessions: [], ...(budget ? { budget } : {}), budgetVersion: 1, ...initialBudget }, snapshot);
+      await store.create({ id: runId, workflowName: checked.metadata.name, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), state: "running", ...(parentRunId !== undefined ? { parentRunId } : {}), agents: [], nativeSessions: [], delivery: params.foreground ? { mode: "foreground", state: "attached", toolCallId } : { mode: "background", state: "pending" }, ...(budget ? { budget } : {}), budgetVersion: 1, ...initialBudget }, snapshot);
+      if (params.foreground) foregroundDeliveries.set(toolCallId, { store, inline: false });
       const lifecycle = lifecycleFor(store, "running", budgetRuntime, checked.metadata);
       const background = !params.foreground;
       const providerPause = async () => { if (background) deliver(pi, `Workflow ${checked.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
       const providerErrorRecovery = createProviderErrorRecovery(ctx, availableModels, () => { runController.abort(); });
-      const executor = new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model: rootModel, tools: new Set(rootTools), availableModels, knownModels, modelAliases, settingsPath, agentDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(launch.resourcePolicy), runContext }, createSession);
+      const executor = createAgentExecutor({ cwd: ctx.cwd, model: rootModel, tools: new Set(rootTools), availableModels, knownModels, modelAliases, settingsPath, agentDefinitions, runStore: store, providerPause, agentResourcePolicy: frozenResourcePolicy(launch.resourcePolicy), runContext });
       runs.set(runId, { executor, store, metadata: checked.metadata, model: rootModel, lifecycle, budget: budgetRuntime, abortController: runController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}), ...(params.foreground && onUpdate ? { update: onUpdate } : {}) });
       if (params.foreground && onUpdate) onUpdate(workflowToolUpdate((await store.load()).run));
       scheduler.addRun(runId, settings.concurrency, () => runs.get(runId)?.budget.checkAgentLaunch());
-      const execution = runWorkflow(script, args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal, identity), agent: async (prompt, options, agentSignal, identity) => {
-        await lifecycle.enter();
-        try {
-          const path = agentIdentityPath(identity);
-          const replayed = await store.replay(path);
-          if (replayed) {
-            return replayed.value;
-          }
-          const worktree = agentWorktree(identity);
-          const cwd = worktree.worktreeOwner ? (await persistWorktree(store, checked.metadata, worktree.worktreeOwner)).cwd : ctx.cwd;
-          const role = typeof options.role === "string" ? options.role : undefined;
-          const model = typeof options.model === "string" ? options.model : undefined;
-          const thinking = parseThinking(options.thinking);
-          const requestedLabel = typeof options.label === "string" ? options.label : undefined;
-          const resolved = executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: checked.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools as string[] } : {}) });
-          const label = displayAgentName(requestedLabel, role, resolved.model);
-          const tools = resolved.tools;
-          const schema = object(options.outputSchema) ? options.outputSchema : undefined;
-          const spawned = scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
-          const cancel = () => { scheduler.cancel(spawned.id); };
-          if (agentSignal.aborted) cancel(); else agentSignal.addEventListener("abort", cancel, { once: true });
-          const outcome = await spawned.result.finally(() => { agentSignal.removeEventListener("abort", cancel); });
-          if (!outcome.ok) throw new WorkflowError(outcome.error.code as WorkflowErrorCode, outcome.error.message);
-          await store.complete(path, outcome.value);
-          return outcome.value;
-        } finally { await lifecycle.leave(); }
-      }, worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, Boolean(params.foreground), params.foreground && ctx.hasUI ? ctx.ui : undefined, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(lifecycle, checked.metadata.name) }, store, runContext, variables, registry), runController.signal);
+      const execution = runWorkflow(script, args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal, identity), agent: workflowAgentHandler(store, checked.metadata, lifecycle, executor, ctx.cwd, runId, captureFunctionRole), worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, Boolean(params.foreground), params.foreground && ctx.hasUI ? ctx.ui : undefined, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(lifecycle, checked.metadata.name) }, store, runContext, variables, registry), runController.signal);
       (runs.get(runId) as NonNullable<ReturnType<typeof runs.get>>).execution = execution;
       await eventPublisher.runStarted(store, checked.metadata);
       const finish = execution.result.then(async (value) => {
@@ -1989,7 +2456,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
         await scheduler.flush();
         const typed = error instanceof WorkflowError ? error : new WorkflowError("INTERNAL_ERROR", String(error));
         if (!["stopped", "interrupted", "budget_exhausted"].includes(lifecycle.state)) await lifecycle.terminal(typed.code === "CANCELLED" ? "stopped" : typed.code === "BUDGET_EXHAUSTED" ? "budget_exhausted" : "failed", typed.code);
-        const persisted = await persistRunState(store, checked.metadata, (current) => ({ ...current, ...budgetRuntime.snapshot(), error: { code: typed.code, message: typed.message } }));
+        const persisted = await persistRunState(store, checked.metadata, (current) => persistedFailure({ ...current, ...budgetRuntime.snapshot() }, typed));
         const state = lifecycle.state === "stopped" || lifecycle.state === "interrupted" || lifecycle.state === "budget_exhausted" ? lifecycle.state : "failed";
         await eventPublisher.runFailed(store, checked.metadata, typed, state);
         const diagnostic = await createWorkflowFailureDiagnostics(store, checked.metadata, typed, persisted);
@@ -1999,16 +2466,37 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       });
       const completion = finish.finally(() => cleanupTerminalRun(runId));
       (runs.get(runId) as NonNullable<ReturnType<typeof runs.get>>).completion = completion;
+      const deliverFailureContent = (error: unknown): string => {
+        const diagnostic = failureDiagnosticsFrom(error);
+        return diagnostic ? formatWorkflowFailureDelivery(diagnostic) : formatWorkflowFailureDeliveryFallback(checked.metadata.name, runId, store.directory, error);
+      };
+      const queueForegroundDelivery = async (content: string): Promise<void> => {
+        const delivery = foregroundDeliveries.get(toolCallId);
+        if (!delivery) return;
+        await store.updateState((current) => {
+          if (!current.delivery || current.delivery.state === "delivered") return current;
+          return { ...current, delivery: { ...current.delivery, mode: "background", state: "pending" } };
+        });
+        if (delivery.inline) return;
+        scheduleForegroundDelivery(toolCallId, async () => {
+          if (delivery.inline) return;
+          pendingFailureDiagnostics.delete(toolCallId);
+          await deliverTerminal(store, content);
+        });
+      };
       if (background) {
         void completion.then(async ({ value, resultPath }) => {
-          deliver(pi, completionDelivery(checked.metadata.name, value, resultPath, await store.changedWorktrees()));
-        }, (error: unknown) => {
-          const diagnostic = failureDiagnosticsFrom(error);
-          if (diagnostic) deliverFailure(pi, diagnostic);
-          else deliver(pi, `Workflow ${checked.metadata.name} failed: ${formatWorkflowFailure(error)}`);
+          await deliverTerminal(store, completionDelivery(checked.metadata.name, value, resultPath, await store.changedWorktrees()));
+        }, async (error: unknown) => {
+          await deliverTerminal(store, deliverFailureContent(error));
         });
         return { content: [{ type: "text" as const, text: JSON.stringify({ runId, state: "running" }) }], details: { runId, preview: `Started workflow ${runId}.` } };
       }
+      void completion.then(async ({ value, resultPath }) => {
+        await queueForegroundDelivery(completionDelivery(checked.metadata.name, value, resultPath, await store.changedWorktrees()));
+      }, async (error: unknown) => {
+        await queueForegroundDelivery(deliverFailureContent(error));
+      });
       const { value } = await completion;
       const run = (await store.load()).run;
       return { content: [{ type: "text" as const, text: JSON.stringify(value) }, { type: "text" as const, text: `Workflow run ID: ${runId}` }], details: { runId, value, run } };
@@ -2050,7 +2538,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const loadStores = async () => {
         const entries = await Promise.all((await listRunIds(ctx.cwd, ctx.sessionManager.getSessionId(), home)).map(async (runId) => {
           const store = new RunStore(ctx.cwd, ctx.sessionManager.getSessionId(), runId, home);
-          try { return { store, loaded: await store.load() }; }
+          try { const loaded = await store.load(); return { store, loaded: { ...loaded, run: withLiveActivities(loaded.run) } }; }
           catch { if (!await store.isComplete()) await store.delete(true).catch(() => undefined); return undefined; }
         }));
         return entries.filter((entry): entry is { store: RunStore; loaded: { run: PersistedRun; snapshot: Readonly<LaunchSnapshot> } } => entry !== undefined);
@@ -2073,12 +2561,12 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
             return keepContext ? "dashboard" : "done";
           }
           if ((action === "budget-approve" || action === "budget-reject") && runId && rest[0]) {
-            const result = await answerBudgetDecision(runId, rest[0], action === "budget-approve", true, ctx);
+            const result = await answerBudgetDecision(runId, rest[0], action === "budget-approve", true, ctx, undefined, false);
             ctx.ui.notify(result ? `Budget adjustment ${rest[0]} ${result.approved ? "approved" : "rejected"}.` : "Budget proposal is not pending.", result ? "info" : "warning");
             return keepContext ? "dashboard" : "done";
           }
           if (action === "delete" && stored) {
-            if (!["completed", "failed", "stopped"].includes(stored.loaded.run.state)) { ctx.ui.notify("Stop the workflow before deleting it.", "warning"); return keepContext ? "dashboard" : "done"; }
+            if (!HARD_TERMINAL_RUN_STATES.has(stored.loaded.run.state)) { ctx.ui.notify("Stop the workflow before deleting it.", "warning"); return keepContext ? "dashboard" : "done"; }
             if (!await ctx.ui.confirm("Delete workflow?", `Delete ${stored.loaded.run.workflowName} (${stored.store.runId}) and all owned artifacts? This cannot be undone.`)) return keepContext ? "dashboard" : "done";
             await stored.store.delete(true); runs.delete(stored.store.runId); terminalRunStates.delete(stored.store.runId); ctx.ui.notify(`Deleted workflow ${stored.store.runId}.`, "info"); return keepContext ? "picker" : "done";
           }
@@ -2086,10 +2574,10 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           if (action === "resume" && run) {
             if (run.lifecycle.state === "budget_exhausted") {
               const patch: unknown = rest.length ? JSON.parse(rest.join(" ")) as unknown : undefined;
-              const result = await resumeWorkflowRun(run.store.runId, patch, ctx);
-              ctx.ui.notify(result.state === "running" ? `Resumed workflow ${run.store.runId}.` : `Budget adjustment for ${run.store.runId} is awaiting approval.`, result.state === "running" ? "info" : "warning");
+              const result = await resumeWorkflowRun(run.store.runId, patch, ctx, undefined, undefined, false);
+              ctx.ui.notify(result.state === "completed" ? `Workflow ${run.store.runId} completed.` : result.state === "running" ? `Resumed workflow ${run.store.runId}.` : `Budget adjustment for ${run.store.runId} is awaiting approval.`, result.state === "awaiting_approval" ? "warning" : "info");
             } else {
-              if (run.lifecycle.state === "interrupted") await coldResumeRun(run, ctx.hasUI, ctx.ui, projectTrusted(ctx), ctx);
+              if (run.lifecycle.state === "interrupted") await coldResumeRun(run, ctx.hasUI, ctx.ui, projectTrusted(ctx), ctx, undefined, false);
               else {
                 if (run.lifecycle.state === "paused") await refreshPausedRunAliases(run, { ...resumeHostContext(ctx), projectTrusted: projectTrusted(ctx) });
                 await run.lifecycle.resume();
@@ -2101,8 +2589,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           if (action === "adjust" && run?.lifecycle.state === "budget_exhausted") {
             const input = await uiHostCapabilities(ctx.ui)?.input?.call(ctx.ui, "Budget patch (JSON)", "{\"tokens\":{\"hard\":null}}" );
             if (input === undefined) return keepContext ? "dashboard" : "done";
-            const result = await resumeWorkflowRun(run.store.runId, JSON.parse(input), ctx);
-            ctx.ui.notify(result.state === "running" ? `Resumed workflow ${run.store.runId}.` : `Budget adjustment for ${run.store.runId} is awaiting approval.`, result.state === "running" ? "info" : "warning");
+            const result = await resumeWorkflowRun(run.store.runId, JSON.parse(input), ctx, undefined, undefined, false);
+            ctx.ui.notify(result.state === "completed" ? `Workflow ${run.store.runId} completed.` : result.state === "running" ? `Resumed workflow ${run.store.runId}.` : `Budget adjustment for ${run.store.runId} is awaiting approval.`, result.state === "awaiting_approval" ? "warning" : "info");
             return keepContext ? "dashboard" : "done";
           }
           if (action === "stop" && run) {
@@ -2201,7 +2689,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           }
           const sorted = navigatorAttentionSort(stores);
           const labels = navigatorRunLabels(sorted);
-          const terminalStates = new Set(["completed", "failed", "stopped"]);
+          const terminalStates = HARD_TERMINAL_RUN_STATES;
           const hasCompleted = sorted.some(({ loaded: { run } }) => run.state === "completed");
           const hasFailed = sorted.some(({ loaded: { run } }) => run.state === "failed");
           const pickerOptions = [...labels, ...(herdrPaneId() ? ["Inspect session in pane"] : []), "Model aliases", "Close", ...(hasCompleted ? ["Delete all completed"] : []), ...(hasFailed ? ["Delete all failed"] : [])];
@@ -2246,22 +2734,30 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           };
           const loadDashboard = async () => {
             const loaded = await store.load();
+            const liveRun = withLiveActivities(loaded.run);
             const checkpoints = await store.awaitingCheckpoints();
             const worktrees = await store.worktrees();
+            const completedOperations = ctx.mode === "tui" ? await store.replayableOperations().catch(() => []) : [];
+            const agentResults = new Map<string, JsonValue>();
+            for (const agent of liveRun.agents) {
+              if (agent.state !== "completed" || agent.parentId || !agent.resultPath) continue;
+              const operation = completedOperations.find((candidate) => candidate.path === agent.resultPath);
+              if (operation) agentResults.set(agent.id, operation.value);
+            }
             const actions = new Map<string, string>();
             const copies = new Map<string, { value: string; artifact: string }>();
             const reviews = new Map<string, AwaitingCheckpoint>();
             const add = (label: string, value: string) => { actions.set(label, `${value} ${store.runId}`); };
             const addCopy = (label: string, value: string, artifact: string) => { actions.set(label, "copy"); copies.set(label, { value, artifact }); };
-            if (loaded.run.state === "running") add("Pause", "pause");
-            if (["paused", "interrupted"].includes(loaded.run.state)) add("Resume", "resume");
-            if (loaded.run.state === "budget_exhausted") { actions.set("Resume unchanged", `resume ${store.runId}`); actions.set("Adjust budget", `adjust ${store.runId}`); }
+            if (liveRun.state === "running") add("Pause", "pause");
+            if (["paused", "interrupted"].includes(liveRun.state)) add("Resume", "resume");
+            if (liveRun.state === "budget_exhausted") { actions.set("Resume unchanged", `resume ${store.runId}`); actions.set("Adjust budget", `adjust ${store.runId}`); }
             for (const decision of await store.pendingWorkflowDecisions()) {
               const id = decision.proposalId.slice(0, 8);
               actions.set(`Approve budget ${id}`, `budget-approve ${store.runId} ${decision.proposalId}`);
               actions.set(`Reject budget ${id}`, `budget-reject ${store.runId} ${decision.proposalId}`);
             }
-            if (!terminalStates.has(loaded.run.state)) add("Stop", "stop");
+            if (!terminalStates.has(liveRun.state)) add("Stop", "stop");
             for (const cp of checkpoints) {
               if (ctx.mode === "tui") {
                 const label = `Review ${cp.name}`;
@@ -2273,96 +2769,131 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
               }
             }
             if (ctx.mode !== "tui") actions.set("Refresh", "refresh");
-            else actions.set("View script", "view-script");
-            if (loaded.run.agents.length) actions.set("Agents...", "agents");
-            if (terminalStates.has(loaded.run.state)) add("Delete", "delete");
+            else actions.set("Open script in editor", "open-script");
+            if (ctx.mode !== "tui" && liveRun.agents.length) actions.set("Agents...", "agents");
+            if (terminalStates.has(liveRun.state)) add("Delete", "delete");
             if (ctx.mode === "tui") {
               addCopy("Copy run path", store.directory, "run path");
               addCopy("Copy run ID", store.runId, "run ID");
             }
-            return { dashboard: formatWorkflowPhaseDashboard(loaded.run, loaded.snapshot, process.stdout.columns || 80).join("\n"), phaseModel: buildWorkflowPhaseModel(loaded.run, loaded.snapshot), run: loaded.run, snapshot: loaded.snapshot, actions, copies, reviews, script: loaded.snapshot.script, agents: loaded.run.agents, worktrees, cwd: loaded.run.cwd };
+            return { dashboard: formatWorkflowPhaseDashboard(liveRun, loaded.snapshot, process.stdout.columns || 80).join("\n"), phaseModel: buildWorkflowPhaseModel(liveRun, loaded.snapshot), run: liveRun, snapshot: loaded.snapshot, actions, copies, reviews, agentResults, agents: liveRun.agents, worktrees, cwd: liveRun.cwd };
           };
-          const selectAgent = async (dashboard: Awaited<ReturnType<typeof loadDashboard>>): Promise<void> => {
-            const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
-            const title = (agent: AgentRecord): string => agentBreadcrumb(agent, byId, true);
-            const labels = dashboard.agents.map((agent, index) => `#${String(index + 1)} ${title(agent)} [${agent.state}]`);
-            const selectedLabel = await ctx.ui.select("Agents", [...labels, "Back"]);
-            const selectedIndex = selectedLabel ? labels.indexOf(selectedLabel) : -1;
-            const selected = selectedIndex >= 0 ? dashboard.agents[selectedIndex] : undefined;
-            if (!selected) return;
-            const attempts = [...(selected.attemptDetails ?? [])].sort((left, right) => left.attempt - right.attempt);
-            const worktree = selected.worktreeOwner ? dashboard.worktrees.find((candidate) => candidate.owner === selected.worktreeOwner) : undefined;
-            const actions = [
-              ...(attempts.length && herdrPaneId() ? ["Fork as Pi session in pane"] : []),
+          const agentWorktreeFor = (dashboard: Awaited<ReturnType<typeof loadDashboard>>, agent: AgentRecord): WorktreeReference | undefined => agent.worktreeOwner ? dashboard.worktrees.find((candidate) => candidate.owner === agent.worktreeOwner) : undefined;
+          const agentActionLabels = (dashboard: Awaited<ReturnType<typeof loadDashboard>>, agent: AgentRecord): string[] => {
+            const worktree = agentWorktreeFor(dashboard, agent);
+            return [
+              ...(agent.attemptDetails?.length && herdrPaneId() ? ["Fork as Pi session in pane"] : []),
               ...(worktree ? ["Copy branch", "Copy worktree path"] : []),
+              ...(ctx.mode === "tui" && dashboard.agentResults.has(agent.id) ? ["Open result in editor"] : []),
               "Copy agent ID",
               "Back",
             ];
-            const chooseAttempt = async (): Promise<AgentAttemptSummary | undefined> => {
-              const choices = attempts.map((attempt) => `Attempt ${String(attempt.attempt)}`);
-              const choice = choices.length === 1 ? choices[0] : await ctx.ui.select("Fork attempts", [...choices, "Back"]);
-              const index = choice ? choices.indexOf(choice) : -1;
-              return index >= 0 ? attempts[index] : undefined;
-            };
+          };
+          const forkAgentSession = async (dashboard: Awaited<ReturnType<typeof loadDashboard>>, agent: AgentRecord): Promise<void> => {
+            const attempts = [...(agent.attemptDetails ?? [])].sort((left, right) => left.attempt - right.attempt);
+            const worktree = agentWorktreeFor(dashboard, agent);
+            const choices = attempts.map((attempt) => `Attempt ${String(attempt.attempt)}`);
+            const choice = choices.length === 1 ? choices[0] : await ctx.ui.select("Fork attempts", [...choices, "Back"]);
+            const index = choice ? choices.indexOf(choice) : -1;
+            const attempt = index >= 0 ? attempts[index] : undefined;
+            if (!attempt) return;
+            const running = !SETTLED_AGENT_STATES.has(agent.state) && attempt.attempt === attempts.at(-1)?.attempt && !attempt.error;
+            if (running && !await ctx.ui.confirm("Fork running attempt?", "This attempt is still running. The snapshot may end mid-turn and will not receive later updates. It opens read-only to avoid concurrent changes to the workflow agent's working directory. Continue?")) return;
+            try {
+              await openHerdrPane({ action: "fork", cwd: worktree?.cwd ?? attempt.setup?.cwd ?? dashboard.cwd, original: attempt.sessionFile, ...(running ? { readOnly: true } : {}) });
+              ctx.ui.notify("Forked Pi session in pane.", "info");
+            } catch (error) {
+              ctx.ui.notify(`Cannot fork Pi session in pane: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            }
+          };
+          const selectAgent = async (dashboard: Awaited<ReturnType<typeof loadDashboard>>, requestedAgentId?: string): Promise<void> => {
+            const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
+            const title = (agent: AgentRecord): string => agentBreadcrumb(agent, byId, true);
+            const labels = dashboard.agents.map((agent, index) => `#${String(index + 1)} ${title(agent)} [${agent.state}]`);
+            let selected: AgentRecord | undefined;
+            if (requestedAgentId) selected = dashboard.agents.find((agent) => agent.id === requestedAgentId);
+            else {
+              const selectedLabel = await ctx.ui.select("Agents", [...labels, "Back"]);
+              const selectedIndex = selectedLabel ? labels.indexOf(selectedLabel) : -1;
+              selected = selectedIndex >= 0 ? dashboard.agents[selectedIndex] : undefined;
+            }
+            if (!selected) return;
+            const worktree = agentWorktreeFor(dashboard, selected);
+            const actions = agentActionLabels(dashboard, selected);
             for (;;) {
               const action = await ctx.ui.select(title(selected), actions);
               if (!action || action === "Back") return;
               if (action === "Copy agent ID") { await copyArtifact(selected.id, "agent ID"); continue; }
               if (action === "Copy branch" && worktree) { await copyArtifact(worktree.branch, "branch"); continue; }
               if (action === "Copy worktree path" && worktree) { await copyArtifact(worktree.path, "worktree path"); continue; }
-              if (action === "Fork as Pi session in pane") {
-                const attempt = await chooseAttempt();
-                if (!attempt) continue;
-                const running = !SETTLED_AGENT_STATES.has(selected.state) && attempt.attempt === attempts.at(-1)?.attempt && !attempt.error;
-                if (running && !await ctx.ui.confirm("Fork running attempt?", "This attempt is still running. The snapshot may end mid-turn and will not receive later updates. It opens read-only to avoid concurrent changes to the workflow agent's working directory. Continue?")) continue;
-                try {
-                  await openHerdrPane({ action: "fork", cwd: worktree?.cwd ?? attempt.setup?.cwd ?? dashboard.cwd, original: attempt.sessionFile, ...(running ? { readOnly: true } : {}) });
-                  ctx.ui.notify("Forked Pi session in pane.", "info");
-                } catch (error) {
-                  ctx.ui.notify(`Cannot fork Pi session in pane: ${error instanceof Error ? error.message : String(error)}`, "warning");
-                }
-              }
+              if (action === "Fork as Pi session in pane") await forkAgentSession(dashboard, selected);
             }
           };
           for (;;) {
             let view = await loadDashboard();
             const actionChoice = ctx.mode === "tui"
               ? await ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) => {
-                  let options = [...view.actions.keys(), "Close"];
-                  let selectedIndex = 0;
                   let dashboardOffset = 0;
                   let refreshing = false;
                   let disposed = false;
+                  let detailsMode = false;
+                  let actionMode = false;
+                  let actionIndex = 0;
                   let stopRequested = false;
                   let stopStatus: string | undefined;
+                  let selectionNeedsScroll = true;
+                  let renderedWidth = 80;
+                  let refreshGeneration = 0;
                   const initialSelection = preserveWorkflowPhaseSelection(view.phaseModel, {});
-                  let selectedPhaseId = initialSelection.phaseId;
-                  let selectedAgentId = initialSelection.agentId;
-                  const terminalRows = () => Math.max(1, tuiRows(tui) - WORKFLOW_OVERLAY_BORDER_ROWS);
-                  const keyLabels: Record<string, string> = { up: "↑", down: "↓", left: "←", right: "→", tab: "tab", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
-                  const keyLabel = (binding: string, fallback: string) => {
-                    const keys = keybindingKeys(keybindings, binding);
-                    return keys?.length ? keys.map((key) => keyLabels[key] ?? key).join("/") : fallback;
+                  let tree = buildWorkflowPhaseTree(view.phaseModel);
+                  let selectedNodeId = initialSelection.nodeId ?? tree.nodes[0]?.id;
+                  let expandedNodeIds = new Set(initialSelection.expandedNodeIds ?? workflowPhaseTreeInitialExpanded(tree));
+                  const terminalRows = () => Math.max(1, tuiRows(tui) - WORKFLOW_PANEL_FOOTER_ROWS);
+                  const keyLabels: Record<string, string> = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
+                  const keyLabel = (binding: string, fallback: string) => workflowKeyLabel(keybindings, binding, fallback, keyLabels);
+                  const selectedAgentRecord = (): AgentRecord | undefined => {
+                    const node = selectedNodeId ? tree.byId.get(selectedNodeId) : tree.nodes[0];
+                    return node?.kind === "agent" && node.agentId ? view.agents.find((agent) => agent.id === node.agentId) : undefined;
                   };
-                  const dashboardLayout = () => {
-                    const rows = terminalRows();
-                    const hintRows = rows >= 4 ? 1 : 0;
-                    const separatorRows = rows >= 8 ? 1 : 0;
-                    const available = Math.max(1, rows - hintRows - separatorRows);
-                    const actionViewport = Math.min(options.length, Math.max(1, Math.ceil(available / 2)));
-                    return { rows, hintRows, separatorRows, actionViewport, dashboardViewport: available - actionViewport };
+                  const actionOptions = () => {
+                    const agent = selectedAgentRecord();
+                    return agent ? agentActionLabels(view, agent) : [...view.actions.keys(), "Back"];
                   };
-                  const updateDashboard = async (selectedOption: string | undefined) => {
-                    const phaseId = selectedPhaseId;
-                    const agentId = selectedAgentId;
+                  let editorRunning = false;
+                  const openArtifact = async (artifact: Promise<WorkflowArtifact>, label: string): Promise<void> => {
+                    if (editorRunning) return;
+                    editorRunning = true;
+                    try {
+                      const command = SettingsManager.create(view.cwd, extensionAgentDir, { projectTrusted: projectTrusted(ctx) }).getExternalEditorCommand();
+                      if (!command) { ctx.ui.notify(`Cannot open ${label}: no external editor is configured.`, "warning"); return; }
+                      const exitCode = await openWorkflowArtifact(tui, command, await artifact);
+                      if (exitCode !== 0) {
+                        const detail = exitCode === null ? "could not be started" : `exited with code ${String(exitCode)}`;
+                        ctx.ui.notify(`Cannot open ${label}: external editor ${detail}.`, "warning");
+                      }
+                    } catch (error) {
+                      ctx.ui.notify(`Cannot open ${label}: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                    } finally {
+                      editorRunning = false;
+                    }
+                  };
+                  const updateDashboard = async () => {
+                    const generation = ++refreshGeneration;
+                    const hadExpandableNodes = tree.nodes.some((node) => node.children.length > 0);
                     const next = await loadDashboard();
-                    if (disposed) return;
+                    if (disposed || generation !== refreshGeneration) return;
+                    const previousNodeId = selectedNodeId;
+                    const previousExpanded = expandedNodeIds;
+                    const selectedAction = actionMode ? actionOptions()[actionIndex] : undefined;
                     view = next;
-                    options = [...view.actions.keys(), "Close"];
-                    selectedIndex = Math.max(0, options.indexOf(selectedOption ?? ""));
-                    const preserved = preserveWorkflowPhaseSelection(view.phaseModel, { phaseId, agentId });
-                    selectedPhaseId = preserved.phaseId;
-                    selectedAgentId = preserved.agentId;
+                    tree = buildWorkflowPhaseTree(view.phaseModel);
+                    selectedNodeId = preserveWorkflowPhaseTreeSelection(tree, { nodeId: previousNodeId }).nodeId;
+                    expandedNodeIds = new Set([...previousExpanded].filter((id) => tree.byId.has(id)));
+                    if (!hadExpandableNodes && !expandedNodeIds.size && tree.nodes.some((node) => node.children.length > 0)) expandedNodeIds = new Set(workflowPhaseTreeInitialExpanded(tree));
+                    const nextActions = actionOptions();
+                    const preservedActionIndex = selectedAction ? nextActions.indexOf(selectedAction) : -1;
+                    actionIndex = preservedActionIndex >= 0 ? preservedActionIndex : selectedAction ? nextActions.length - 1 : Math.min(actionIndex, Math.max(0, nextActions.length - 1));
+                    selectionNeedsScroll = true;
                     tui.requestRender();
                   };
                   const requestStop = () => {
@@ -2370,14 +2901,14 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                     stopRequested = true;
                     stopStatus = undefined;
                     setWorkflowStatus(undefined);
-                    const selectedOption = options[selectedIndex];
                     void runAction(`stop ${store.runId}`, true, (status) => {
                       stopStatus = status;
                       setWorkflowStatus(status);
                       if (!disposed) tui.requestRender();
-                    }).then(() => updateDashboard(selectedOption)).catch((error: unknown) => {
+                    }).then(() => updateDashboard()).catch((error: unknown) => {
                       if (disposed) return;
                       stopStatus = `Could not stop workflow ${store.runId}: ${error instanceof Error ? error.message : String(error)}`;
+                      setWorkflowStatus(stopStatus);
                       tui.requestRender();
                     }).finally(() => {
                       stopRequested = false;
@@ -2387,110 +2918,122 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                   const timer = setInterval(() => {
                     if (refreshing || stopRequested) return;
                     refreshing = true;
-                    const selectedOption = options[selectedIndex];
-                    void updateDashboard(selectedOption).catch(() => undefined).finally(() => { refreshing = false; });
+                    void updateDashboard().catch(() => undefined).finally(() => { refreshing = false; });
                   }, 1000);
                   timer.unref();
-                  return borderWorkflowOverlay({
+                  return {
                     render(width: number) {
+                      renderedWidth = width;
+                      const narrow = width < 80;
                       const styles = themeWorkflowProgressStyles(theme);
-                      const phaseLines = formatWorkflowPhaseDashboard(view.run, view.snapshot, width, { phaseId: selectedPhaseId, agentId: selectedAgentId }, styles);
-                      const dashboardLines = stopStatus ? [styles.error(stopStatus), ...phaseLines] : phaseLines;
-                      const actionLines = options.map((option, index) => truncateToVisualLines(`${index === selectedIndex ? "→ " : "  "}${option}`, Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "");
-                      const layout = dashboardLayout();
-                      const hint = truncateToVisualLines(theme.fg("dim", `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.editor.cursorLeft", "←")}/${keyLabel("tui.editor.cursorRight", "→")} phases · ${keyLabel("tui.input.tab", "tab")} agents${dashboardLines.length > layout.dashboardViewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · ${keyLabel("tui.select.confirm", "enter")} select · ${keyLabel("tui.select.cancel", "esc")} close · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
-                      const compact = [...dashboardLines, "", ...actionLines, "", hint];
-                      if (compact.length <= layout.rows) { dashboardOffset = 0; return compact; }
-                      const maxOffset = Math.max(0, dashboardLines.length - layout.dashboardViewport);
+                      const agent = selectedAgentRecord();
+                      const actions = actionMode ? { title: agent ? "Agent actions" : "Run actions", options: actionOptions(), index: actionIndex } : undefined;
+                      const phaseLines = formatWorkflowPhaseDashboard(view.run, view.snapshot, width, { nodeId: selectedNodeId, expandedNodeIds: [...expandedNodeIds], ...(narrow && !detailsMode ? { treeOnly: true } : {}), ...(narrow && detailsMode ? { detailsOnly: true } : {}), ...(actions ? { actions } : {}) }, styles);
+                      const statusLines = stopStatus ? truncateToVisualLines(styles.error(stopStatus), Number.MAX_SAFE_INTEGER, width, 0).visualLines.map((line) => line.trimEnd()) : [];
+                      const content = [...statusLines, ...phaseLines];
+                      const rows = terminalRows();
+                      const hintRows = rows >= 3 ? 1 : 0;
+                      const viewport = Math.max(1, rows - hintRows);
+                      const maxOffset = Math.max(0, content.length - viewport);
+                      dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
+                      if (actionMode) {
+                        const label = actions?.options[actionIndex];
+                        const actionRow = label ? content.findIndex((line) => line.includes(label)) : -1;
+                        if (actionRow >= 0) {
+                          if (actionRow < dashboardOffset) dashboardOffset = actionRow;
+                          else if (actionRow >= dashboardOffset + viewport) dashboardOffset = actionRow - viewport + 1;
+                        }
+                      } else if (!detailsMode && selectionNeedsScroll) {
+                        const selectedRow = content.findIndex((line) => line.startsWith("→"));
+                        if (selectedRow >= 0) {
+                          if (selectedRow < dashboardOffset) dashboardOffset = selectedRow;
+                          else if (selectedRow >= dashboardOffset + viewport) dashboardOffset = selectedRow - viewport + 1;
+                        }
+                        selectionNeedsScroll = false;
+                      }
                       dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
-                      const actionStart = Math.min(Math.max(0, selectedIndex - layout.actionViewport + 1), Math.max(0, options.length - layout.actionViewport));
-                      return [
-                        ...dashboardLines.slice(dashboardOffset, dashboardOffset + layout.dashboardViewport),
-                        ...(layout.separatorRows && layout.dashboardViewport ? [""] : []),
-                        ...actionLines.slice(actionStart, actionStart + layout.actionViewport),
-                        ...(layout.hintRows ? [hint] : []),
-                      ];
+                      const hint = truncateToVisualLines(theme.fg("dim", actionMode ? `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.select.confirm", "enter")} run · ${keyLabel("tui.select.cancel", "esc")} tree` : `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} tree · ${keyLabel("tui.editor.cursorLeft", "←")}/${keyLabel("tui.editor.cursorRight", "→")} collapse/expand · ${keyLabel("tui.select.confirm", "enter")} inspect · a actions · ${keyLabel("tui.select.cancel", "esc")} ${narrow && detailsMode ? "tree" : "back"}${content.length > viewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
+                      return [...content.slice(dashboardOffset, dashboardOffset + viewport), ...(hintRows ? [hint] : [])];
                     },
                     invalidate() {},
                     handleInput(data: string) {
-                      if (stopRequested) return;
-                      const currentPhase = () => view.phaseModel.phases.find((phase) => phase.id === selectedPhaseId);
-                      const left = keybindings.matches(data, "tui.editor.cursorLeft");
-                      const right = keybindings.matches(data, "tui.editor.cursorRight");
-                      if (left || right) {
-                        const phases = view.phaseModel.phases;
-                        if (phases.length) {
-                          const currentIndex = Math.max(0, phases.findIndex((phase) => phase.id === selectedPhaseId));
-                          const delta = left ? -1 : 1;
-                          const nextPhase = phases[(currentIndex + delta + phases.length) % phases.length];
-                          selectedPhaseId = nextPhase?.id;
-                          selectedAgentId = nextPhase?.agents[0]?.id;
+                      if (stopRequested || editorRunning) return;
+                      const narrow = renderedWidth < 80;
+                      if (!actionMode && (data === "a" || data === "A")) { actionMode = true; actionIndex = 0; dashboardOffset = 0; tui.requestRender(); return; }
+                      if (actionMode) {
+                        const options = actionOptions();
+                        if (workflowKeyMatches(keybindings, data, "tui.select.cancel")) { actionMode = false; dashboardOffset = 0; tui.requestRender(); return; }
+                        if (workflowKeyMatches(keybindings, data, "tui.select.up")) actionIndex = (actionIndex + options.length - 1) % options.length;
+                        else if (workflowKeyMatches(keybindings, data, "tui.select.down")) actionIndex = (actionIndex + 1) % options.length;
+                        else if (workflowKeyMatches(keybindings, data, "tui.select.pageUp")) dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
+                        else if (workflowKeyMatches(keybindings, data, "tui.select.pageDown")) dashboardOffset += Math.max(1, terminalRows() - 1);
+                        else if (workflowKeyMatches(keybindings, data, "tui.select.confirm")) {
+                          const action = options[actionIndex];
+                          const agent = selectedAgentRecord();
+                          if (!action || action === "Back") { actionMode = false; dashboardOffset = 0; }
+                          else if (agent) {
+                            const worktree = agentWorktreeFor(view, agent);
+                            if (action === "Open result in editor") {
+                              const result = view.agentResults.get(agent.id);
+                              if (result !== undefined) void openArtifact(Promise.resolve(workflowResultArtifact(result)), "agent result");
+                            }
+                            else if (action === "Copy agent ID") void copyArtifact(agent.id, "agent ID");
+                            else if (action === "Copy branch" && worktree) void copyArtifact(worktree.branch, "branch");
+                            else if (action === "Copy worktree path" && worktree) void copyArtifact(worktree.path, "worktree path");
+                            else done(`__workflow_fork__:${agent.id}`);
+                          }
+                          else if (action === "Open script in editor") void openArtifact(readFile(join(store.directory, "workflow.js"), "utf8").then(workflowScriptArtifact), "workflow script");
+                          else if (action === "Stop") requestStop();
+                          else done(action);
                         }
+                        tui.requestRender();
+                        return;
                       }
-                      else if (keybindings.matches(data, "tui.input.tab")) {
-                        const agents = currentPhase()?.agents ?? [];
-                        if (agents.length) {
-                          const currentIndex = Math.max(0, agents.findIndex((agent) => agent.id === selectedAgentId));
-                          selectedAgentId = agents[(currentIndex + 1) % agents.length]?.id;
+                      const current = selectedNodeId ? tree.byId.get(selectedNodeId) : tree.nodes[0];
+                      if (workflowKeyMatches(keybindings, data, "tui.select.cancel")) {
+                        if (narrow && detailsMode) { detailsMode = false; selectionNeedsScroll = true; } else done("Back");
+                      } else if (narrow && detailsMode) {
+                        if (workflowKeyMatches(keybindings, data, "tui.select.pageUp")) dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
+                        else if (workflowKeyMatches(keybindings, data, "tui.select.pageDown")) dashboardOffset += Math.max(1, terminalRows() - 1);
+                        else if (workflowKeyMatches(keybindings, data, "tui.select.confirm")) {
+                          if (current?.kind === "agent" && current.agentId) { actionMode = true; actionIndex = 0; }
+                          else if (current?.children.length) { if (expandedNodeIds.has(current.id)) expandedNodeIds.delete(current.id); else expandedNodeIds.add(current.id); }
                         }
+                      } else if (workflowKeyMatches(keybindings, data, "tui.editor.cursorLeft")) {
+                        const next = navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, "left");
+                        selectedNodeId = next.nodeId; expandedNodeIds = new Set(next.expandedNodeIds); selectionNeedsScroll = true;
+                      } else if (workflowKeyMatches(keybindings, data, "tui.editor.cursorRight")) {
+                        const next = navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, "right");
+                        selectedNodeId = next.nodeId; expandedNodeIds = new Set(next.expandedNodeIds); selectionNeedsScroll = true;
+                      } else if (workflowKeyMatches(keybindings, data, "tui.select.up")) {
+                        const next = navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, "up");
+                        selectedNodeId = next.nodeId; selectionNeedsScroll = true;
+                      } else if (workflowKeyMatches(keybindings, data, "tui.select.down")) {
+                        const next = navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, "down");
+                        selectedNodeId = next.nodeId; selectionNeedsScroll = true;
+                      } else if (workflowKeyMatches(keybindings, data, "tui.select.pageUp")) dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
+                      else if (workflowKeyMatches(keybindings, data, "tui.select.pageDown")) dashboardOffset += Math.max(1, terminalRows() - 1);
+                      else if (workflowKeyMatches(keybindings, data, "tui.select.confirm")) {
+                        if (narrow) detailsMode = true;
+                        else if (current?.kind === "agent" && current.agentId) { actionMode = true; actionIndex = 0; }
+                        else if (current?.children.length) { if (expandedNodeIds.has(current.id)) expandedNodeIds.delete(current.id); else expandedNodeIds.add(current.id); }
                       }
-                      else if (keybindings.matches(data, "tui.select.up")) selectedIndex = (selectedIndex + options.length - 1) % options.length;
-                      else if (keybindings.matches(data, "tui.select.down")) selectedIndex = (selectedIndex + 1) % options.length;
-                      else if (keybindings.matches(data, "tui.select.pageUp")) {
-                        dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, dashboardLayout().dashboardViewport));
-                      }
-                      else if (keybindings.matches(data, "tui.select.pageDown")) {
-                        dashboardOffset += Math.max(1, dashboardLayout().dashboardViewport);
-                      }
-                      else if (keybindings.matches(data, "tui.select.confirm")) {
-                        if (options[selectedIndex] === "Stop") requestStop();
-                        else done(options[selectedIndex]);
-                      }
-                      else if (keybindings.matches(data, "tui.select.cancel")) done(undefined);
                       tui.requestRender();
                     },
                     dispose() { disposed = true; clearInterval(timer); setWorkflowStatus(undefined); },
-                  }, theme);
-                }, { overlay: true })
-              : await ctx.ui.select(view.dashboard, [...view.actions.keys(), "Close"]);
-            if (!actionChoice || actionChoice === "Close") return;
+                  };
+                })
+              : await ctx.ui.select(view.dashboard, [...view.actions.keys(), "Back"]);
+            if (!actionChoice || actionChoice === "Back") { stores = await loadStores(); break; }
             if (actionChoice === "Agents...") { await selectAgent(view); continue; }
-            if (actionChoice === "Refresh") continue;
-            if (actionChoice === "View script") {
-              await ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) => {
-                const highlighted = highlightCode(view.script, "javascript");
-                let offset = 0;
-                let renderedLines: string[] = [];
-                const viewport = () => Math.max(1, tuiRows(tui) - 3 - WORKFLOW_OVERLAY_BORDER_ROWS);
-                const move = (delta: number) => {
-                  const maxOffset = Math.max(0, renderedLines.length - viewport());
-                  offset = Math.max(0, Math.min(maxOffset, offset + delta));
-                };
-                return borderWorkflowOverlay({
-                  render(width: number) {
-                    renderedLines = highlighted.flatMap((line) => line ? truncateToVisualLines(line, Number.MAX_SAFE_INTEGER, width, 0).visualLines : [""]);
-                    const maxOffset = Math.max(0, renderedLines.length - viewport());
-                    offset = Math.min(offset, maxOffset);
-                    return [
-                      theme.fg("accent", "Workflow script"),
-                      ...renderedLines.slice(offset, offset + viewport()),
-                      "",
-                      theme.fg("dim", "↑↓/pgup/pgdn scroll · esc close"),
-                    ];
-                  },
-                  invalidate() {},
-                  handleInput(data: string) {
-                    if (keybindings.matches(data, "tui.select.up")) move(-1);
-                    else if (keybindings.matches(data, "tui.select.down")) move(1);
-                    else if (keybindings.matches(data, "tui.select.pageUp")) move(-viewport());
-                    else if (keybindings.matches(data, "tui.select.pageDown")) move(viewport());
-                    else if (keybindings.matches(data, "tui.select.cancel")) done(undefined);
-                    tui.requestRender();
-                  },
-                }, theme);
-              }, { overlay: true, overlayOptions: { anchor: "top-left", width: "100%", maxHeight: "100%" } });
+            if (actionChoice.startsWith("__workflow_agent__:")) { await selectAgent(view, actionChoice.slice("__workflow_agent__:".length)); continue; }
+            if (actionChoice.startsWith("__workflow_fork__:")) {
+              const agentId = actionChoice.slice("__workflow_fork__:".length);
+              const agent = view.agents.find((candidate) => candidate.id === agentId);
+              if (agent) await forkAgentSession(view, agent);
               continue;
             }
+            if (actionChoice === "Refresh") continue;
             const copy = view.copies.get(actionChoice);
             if (copy) { await copyArtifact(copy.value, copy.artifact); continue; }
             if (actionChoice.startsWith("Review ")) {
@@ -2521,7 +3064,9 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                     const currentLayout = layout();
                     const maxOffset = Math.max(0, renderedLines.length - currentLayout.contentViewport);
                     offset = Math.min(offset, maxOffset);
-                    const hint = truncateToVisualLines(theme.fg("dim", "↑↓/pgup/pgdn scroll · enter select · esc cancel"), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
+                    const keyLabels: Record<string, string> = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
+                    const keyLabel = (binding: string, fallback: string) => workflowKeyLabel(keybindings, binding, fallback, keyLabels);
+                    const hint = truncateToVisualLines(theme.fg("dim", `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")}/pgup/pgdn scroll · enter select · esc cancel`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
                     const controls = currentLayout.compactControls
                       ? [options.map((option, index) => `${index === selectedIndex ? "[" : " "}${option}${index === selectedIndex ? "]" : " "}`).join(" ")]
                       : options.map((option, index) => `${index === selectedIndex ? "→ " : "  "}${option}`);
@@ -2535,16 +3080,16 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                   },
                   invalidate() {},
                   handleInput(data: string) {
-                    if (keybindings.matches(data, "tui.select.up")) selectedIndex = (selectedIndex + options.length - 1) % options.length;
-                    else if (keybindings.matches(data, "tui.select.down")) selectedIndex = (selectedIndex + 1) % options.length;
-                    else if (keybindings.matches(data, "tui.select.pageUp")) move(-layout().contentViewport);
-                    else if (keybindings.matches(data, "tui.select.pageDown")) move(layout().contentViewport);
-                    else if (keybindings.matches(data, "tui.select.confirm")) done(options[selectedIndex] === "Cancel" ? undefined : options[selectedIndex] as "Approve" | "Reject");
-                    else if (keybindings.matches(data, "tui.select.cancel")) done(undefined);
+                    if (workflowKeyMatches(keybindings, data, "tui.select.up")) selectedIndex = (selectedIndex + options.length - 1) % options.length;
+                    else if (workflowKeyMatches(keybindings, data, "tui.select.down")) selectedIndex = (selectedIndex + 1) % options.length;
+                    else if (workflowKeyMatches(keybindings, data, "tui.select.pageUp")) move(-layout().contentViewport);
+                    else if (workflowKeyMatches(keybindings, data, "tui.select.pageDown")) move(layout().contentViewport);
+                    else if (workflowKeyMatches(keybindings, data, "tui.select.confirm")) done(options[selectedIndex] === "Cancel" ? undefined : options[selectedIndex] as "Approve" | "Reject");
+                    else if (workflowKeyMatches(keybindings, data, "tui.select.cancel")) done(undefined);
                     tui.requestRender();
                   },
                 }, theme);
-              }, { overlay: true, overlayOptions: { anchor: "top-left", width: "100%", maxHeight: "100%" } });
+              }, { overlay: true, overlayOptions: WORKFLOW_OVERLAY_OPTIONS });
               if (decision) {
                 const accepted = await answerCheckpoint(store.runId, checkpoint.name, decision === "Approve", true);
                 if (!accepted) ctx.ui.notify("Checkpoint is not awaiting a response.", "warning");
@@ -2564,9 +3109,9 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
   pi.on("session_shutdown", async () => {
     try {
       await Promise.all([...runs.entries()].map(async ([runId, run]) => {
-        if (["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state)) { await run.completion?.catch(() => undefined); return; }
-        if (!["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state)) {
-          try { await run.lifecycle.terminal("interrupted"); } catch (error) { if (!["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state)) throw error; }
+        const isTerminal = SHUTDOWN_TERMINAL_RUN_STATES.has(run.lifecycle.state);
+        if (!isTerminal) {
+          try { await run.lifecycle.terminal("interrupted"); } catch (error) { if (!SHUTDOWN_TERMINAL_RUN_STATES.has(run.lifecycle.state)) throw error; }
           run.abortController.abort();
           run.execution?.cancel();
           await scheduler.cancelRun(runId);