pi-extensible-workflows 3.1.0 → 3.3.0

package/dist/src/host.js

@@ -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 } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, getAgentDir, SettingsManager, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
 import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
 import { herdrPaneId, openHerdrPane } from "./herdr.js";
 import { acquireSessionLease, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
@@ -14,17 +15,21 @@ 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 } 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 } from "./types.js";
+import { openWorkflowArtifact, workflowResultArtifact, workflowScriptArtifact } 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 } from "./types.js";
 const SETTLED_AGENT_STATES = new Set(["completed", "failed", "cancelled"]);
+const INTERNAL_WORKFLOW_TOOLS = ["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"];
+const HARD_TERMINAL_RUN_STATES = new Set(["completed", "failed", "stopped"]);
+const SHUTDOWN_TERMINAL_RUN_STATES = new Set(["completed", "failed", "stopped", "budget_exhausted"]);
 function snapshotResourcePolicy(snapshot, cwd, projectTrusted, globalSettingsPath) {
     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 = { accent: (text) => text, success: (text) => text, error: (text) => text, warning: (text) => text, muted: (text) => text, dim: (text) => text, bold: (text) => text };
 function workflowLaunchSettings(cwd, projectTrusted, globalSettingsPath, concurrency) {
     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) { return () => structuredClone(policy); }
 function resumedSnapshotSettings(snapshot, resolution, modelAliases) {
@@ -81,9 +86,10 @@ function mainAgentError(error) {
     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) { return object(error) && typeof error.failedAt === "string" && error.failedAt ? error.failedAt : undefined; }
+function persistedFailure(run, error) { const failedAt = workflowFailedAt(error); return { ...run, error: { code: error.code, message: error.message, ...(failedAt ? { failedAt } : {}) }, ...(failedAt ? { failedAt } : {}) }; }
 export class RunLifecycle {
     changed;
     #state;
@@ -144,7 +150,7 @@ export class RunLifecycle {
         await this.enter();
     }
     async terminal(state, reason) {
-        if (["completed", "failed", "stopped"].includes(this.#state))
+        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))
@@ -165,20 +171,42 @@ export function formatWorkflowPreview(args) {
     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, state) {
+    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" })) });
 function phaseNames(source) {
     const phases = source === undefined ? [] : Array.isArray(source) ? source : source.phases ?? [];
     return phases.filter((phase) => typeof phase === "string" && phase.trim() !== "").map((phase) => phase.trim());
@@ -258,7 +286,7 @@ export function buildWorkflowPhaseModel(run, source) {
         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;
     for (let index = phases.length - 1; index >= 0; index -= 1) {
@@ -282,12 +310,197 @@ export function buildWorkflowPhaseModel(run, source) {
         result.unassignedAgents = unassignedAgents;
     return result;
 }
+function workflowPhaseTreePath(kind, phaseId, operationPath, agentId) {
+    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) {
+    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) {
+    const drafts = new Map();
+    const roots = [];
+    const add = (node, parentId) => {
+        const existing = drafts.get(node.id);
+        if (existing)
+            return existing;
+        const 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, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+    const addPhase = (phaseId, label, agents, phase) => {
+        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();
+        const entries = agents.map((agent) => ({ agent, path: [...(agent.structuralPath ?? [])], node: undefined, defaultParentId: phaseNode.id }));
+        const agentEntries = new Map(entries.map((entry) => [entry.agent.id, entry]));
+        const acceptedParents = new Map();
+        const wouldCycle = (childId, parentId) => {
+            const seen = new Set([childId]);
+            let current = 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, owner, startIndex = 0) => {
+            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, parentId) => {
+            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, depth, seen = new Set()) => {
+            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, seen = new Set()) => {
+            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, expanded = new Set()) {
+    const visible = [];
+    const visit = (id) => {
+        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) {
+    return new Set(tree.nodes.filter((node) => node.children.length > 0).map((node) => node.id));
+}
+export function preserveWorkflowPhaseTreeSelection(tree, selection) {
+    const node = (selection.nodeId ? tree.byId.get(selection.nodeId) : undefined) ?? tree.nodes[0];
+    return node ? { nodeId: node.id } : {};
+}
+export function navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, direction) {
+    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, selection) {
     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 }) };
+        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 } : {}) };
 }
 function agentGroupKey(agent) { return JSON.stringify([agent.structuralPath ?? [], agent.parentBreadcrumb ?? null]); }
 function agentGroupLabel(agents) {
@@ -322,28 +535,36 @@ function renderGroupedAgents(agents, render, allAgents = agents, groupLabel = (l
         ...group.entries.map((entry) => render(entry, grouped)),
     ]);
 }
-function progressStyleForState(state, styles) {
-    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, spinner = "◇", styles = PLAIN_WORKFLOW_PROGRESS_STYLES) {
+const RUN_STATE_GLYPH = { completed: "✓", failed: "✗", stopped: "✗", budget_exhausted: "!", awaiting_input: "●" };
+const AGENT_STATE_GLYPH = { completed: "✓", failed: "✗", cancelled: "✗" };
+function runStateGlyph(state, running) { return state === "running" ? running : RUN_STATE_GLYPH[state] ?? "◆"; }
+function agentStateGlyph(state, running) { return state === "running" ? running : AGENT_STATE_GLYPH[state] ?? "○"; }
+const PROGRESS_STATE_STYLE = { completed: "success", failed: "error", cancelled: "error", running: "accent" };
+const WORKFLOW_ICON_STYLE = { completed: "success", failed: "error", stopped: "error", budget_exhausted: "warning", running: "accent" };
+const PHASE_STATE_STYLE = { completed: "success", failed: "error", cancelled: "error", running: "accent", interrupted: "warning", budget_exhausted: "warning" };
+function styleForState(map, state, styles) {
+    const key = map[state] ?? "muted";
+    return (text) => styles[key](text);
+}
+function progressStyleForState(state, styles) { return styleForState(PROGRESS_STATE_STYLE, state, styles); }
+function workflowIconStyle(state, styles) { return styleForState(WORKFLOW_ICON_STYLE, state, styles); }
+function phaseStyleForState(state, styles) { return styleForState(PHASE_STATE_STYLE, state, styles); }
+export function formatWorkflowProgress(run, spinner = "◇", styles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now()) {
     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) => styles.success(text) : run.state === "failed" || run.state === "stopped" ? (text) => styles.error(text) : run.state === "budget_exhausted" ? (text) => styles.warning(text) : run.state === "running" ? (text) => styles.accent(text) : (text) => 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, offset, nested) => 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}` : ""}`;
@@ -392,6 +613,104 @@ function workflowCatalogBlock(text, expanded) {
         invalidate() { },
     };
 }
+function controlString(value) { return typeof value === "string" && value.trim() ? value : undefined; }
+function controlValue(value) {
+    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, theme) { return theme.fg("toolTitle", theme.bold(name)); }
+function controlState(state, theme) {
+    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, theme) {
+    const color = /approved|completed|stopped|started|resumed/.test(action) ? "success" : /rejected|failed/.test(action) ? "error" : "warning";
+    return theme.fg(color, action);
+}
+function budgetPatchEntries(value) {
+    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) {
+    const entries = budgetPatchEntries(value);
+    return entries.length ? entries.join(", ") : "unchanged";
+}
+function budgetPatchDetails(value, theme) {
+    const entries = budgetPatchEntries(value);
+    return entries.length ? [theme.fg("accent", theme.bold("Budget patch")), ...entries.map((entry) => `  ${theme.fg("toolOutput", entry)}`)] : [];
+}
+function workflowControlValue(result) { return catalogResultValue(result); }
+function workflowControlCall(name, args, theme) {
+    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, args, result, expanded, theme, isError) {
+    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) { return value.replace(/\s+/g, " ").trim(); }
 function catalogResultValue(result) {
     if (result.details !== undefined)
@@ -468,7 +787,8 @@ function formatWorkflowCatalog(value, expanded, theme) {
         return theme.fg("error", value.error.message);
     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, width) {
     const safeWidth = Math.max(1, width);
     return text.split("\n").flatMap((line) => {
@@ -539,7 +859,7 @@ function navigatorRunLabels(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)}` : "";
@@ -574,20 +894,46 @@ function styledAgentBreadcrumb(agent, byId, styles) {
         return parts[0] ?? "";
     return `${styles.muted(parts.slice(0, -1).join(" > "))} > ${styles.bold(parts[parts.length - 1] ?? "")}`;
 }
-function formatAgentActivity(agent, spinner, styles = PLAIN_WORKFLOW_PROGRESS_STYLES) {
+export function formatStalledDuration(durationMs) {
+    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, now) {
+    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, spinner, styles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now()) {
     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) {
+    return new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(value).toLowerCase();
 }
 function formatAccounting(accounting) {
     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`;
 }
-export function formatNavigatorDashboard(run, checkpoints, worktrees) {
+function formatAgentAccounting(accounting) {
+    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, checkpoints, worktrees, now = Date.now()) {
     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)];
@@ -598,7 +944,7 @@ export function formatNavigatorDashboard(run, checkpoints, worktrees) {
     lines.push("");
     const byId = new Map(run.agents.map((a) => [a.id, a]));
     const render = ({ agent, depth }, grouped) => {
-        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);
@@ -608,7 +954,7 @@ export function formatNavigatorDashboard(run, checkpoints, worktrees) {
             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");
@@ -621,7 +967,7 @@ export function formatNavigatorDashboard(run, checkpoints, worktrees) {
     }
     return lines.join("\n");
 }
-export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
+export function formatNavigatorRun(loaded, checkpoints, worktrees, now = Date.now()) {
     const { run, snapshot } = loaded;
     const lines = [
         `Workflow: ${run.workflowName}`,
@@ -657,6 +1003,9 @@ export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
             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:");
@@ -664,23 +1013,83 @@ export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
         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, snapshot, width, selection = {}, styles = PLAIN_WORKFLOW_PROGRESS_STYLES) {
+export function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {}, styles = PLAIN_WORKFLOW_PROGRESS_STYLES, now = Date.now()) {
     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, limit = safeWidth) => truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, Math.max(1, limit), 0).visualLines.map((line) => line.trimEnd());
-    const phaseStyle = (state) => 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) => `${phase.name}${phase.occurrence > 1 ? ` #${String(phase.occurrence)}` : ""}`;
-    const phaseCounts = (phase) => `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, selected) => `${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) => text.replace(ansiPattern, "").length;
+    const padTo = (text, limit) => `${text}${" ".repeat(Math.max(0, limit - visibleLength(text)))}`;
+    const phaseStyle = (state) => 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) => {
+        const agents = [];
+        const visit = (id) => {
+            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) => phaseStyle(node.state)(node.state);
+    const nodeIcon = (node) => node.children.length ? expanded.has(node.id) ? "▾" : "▸" : node.kind === "agent" ? "•" : " ";
+    const treeLine = (node) => {
+        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) => {
+        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 = ["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 = [styles.bold(styles.accent(`Workflow: ${run.workflowName}`))];
     if (run.error)
         lines.push(styles.error(`ERROR ${run.error.code}: ${run.error.message}`));
@@ -688,46 +1097,32 @@ export function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {
     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, selectedAgentId) => {
-        if (!agents.length)
-            return [styles.muted("Agents: none")];
-        const rendered = [];
-        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) => [styles.bold("Tree"), ...(visibleNodes.length ? visibleNodes.flatMap((node) => wrap(treeLine(node), limit)) : [styles.muted("(empty)")])];
+    const actionRows = () => {
+        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 = () => [...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] ?? ""}`);
+            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)
+    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));
 }
@@ -932,15 +1327,35 @@ export function formatWorkflowFailureDiagnostics(diagnostic) {
     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, maxBytes) { return utf8Prefix(value.replace(/\s+/g, " ").trim(), maxBytes) || "(unknown)"; }
+export function formatWorkflowFailureDelivery(diagnostic) {
+    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, runId, runDirectory, error) {
+    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) { return JSON.stringify(diagnostic); }
 function isWorkflowFailureDiagnostics(value) {
     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, content) {
+    if (typeof pi.sendMessage !== "function")
+        return;
     pi.sendMessage({ customType: "workflow", content, display: true }, { deliverAs: "followUp", triggerTurn: true });
 }
 function deliverFailure(pi, diagnostic) {
-    deliver(pi, `Workflow ${utf8Prefix(diagnostic.workflowName, 128)} failure diagnostics: ${serializeWorkflowFailureDiagnostics(diagnostic)}`);
+    deliver(pi, formatWorkflowFailureDelivery(diagnostic));
 }
 function safeEventError(error) {
     const code = errorCode(error) ?? "INTERNAL_ERROR";
@@ -1216,23 +1631,22 @@ function projectTrusted(ctx) {
     const check = object(ctx) ? ctx.isProjectTrusted : undefined;
     return typeof check === "function" ? Boolean(Reflect.apply(check, ctx, [])) : true;
 }
-function isEntryRenderer(value) { return typeof value === "function"; }
+function asFn(value) { return typeof value === "function" ? value : undefined; }
 function isWorkflowEventSink(value) { return object(value) && typeof value.emit === "function"; }
 function piHostCapabilities(pi) {
     if (!object(pi))
         return {};
-    const registerEntryRenderer = pi.registerEntryRenderer;
+    const registerEntryRenderer = asFn(pi.registerEntryRenderer);
     const events = pi.events;
-    return { ...(isEntryRenderer(registerEntryRenderer) ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
+    return { ...(registerEntryRenderer ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
 }
-function isModelRegistryGetter(value) { return typeof value === "function"; }
 function contextHostCapabilities(ctx) {
     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);
+    const getAvailable = asFn(registry.getAvailable);
+    return { modelRegistry: { ...(getAll ? { getAll: () => getAll.call(registry) } : {}), ...(getAvailable ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
 }
 function modelInventory(root, registry) {
     const all = registry?.getAll?.() ?? registry?.getAvailable?.() ?? [];
@@ -1266,24 +1680,22 @@ async function resolveLaunchAliases(registry, staticAliases, context, availableM
         throw error;
     }
 }
-function isUiSelect(value) { return typeof value === "function"; }
-function isUiInput(value) { return typeof value === "function"; }
-function isUiSetStatus(value) { return typeof value === "function"; }
 function uiHostCapabilities(ui) {
     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);
+    const input = asFn(ui.input);
+    const setStatus = asFn(ui.setStatus);
+    return { ...(select ? { select } : {}), ...(input ? { input } : {}), ...(setStatus ? { setStatus } : {}) };
 }
-function tuiHostCapabilities(tui) {
-    if (!object(tui) || !object(tui.terminal))
-        return {};
-    return { terminal: { ...(tui.terminal.rows === undefined ? {} : { rows: tui.terminal.rows }) } };
+function tuiRows(tui) {
+    const rows = object(tui) && object(tui.terminal) ? tui.terminal.rows : undefined;
+    return typeof rows === "number" && Number.isFinite(rows) ? rows : 24;
 }
-function tuiRows(tui) { 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 } };
 function borderWorkflowOverlay(component, theme) {
     return {
         ...component,
@@ -1293,14 +1705,19 @@ function borderWorkflowOverlay(component, theme) {
         },
     };
 }
-function isKeybindingGetter(value) { return typeof value === "function"; }
-function keybindingsHostCapabilities(keybindings) {
-    if (!object(keybindings) || !isKeybindingGetter(keybindings.getKeys))
-        return {};
-    return { getKeys: keybindings.getKeys };
+function keybindingKeys(keybindings, name) {
+    const getKeys = object(keybindings) ? asFn(keybindings.getKeys) : undefined;
+    return getKeys ? getKeys.call(keybindings, name) : undefined;
+}
+const WORKFLOW_VIM_KEYS = { "tui.select.up": "k", "tui.select.down": "j", "tui.editor.cursorLeft": "h", "tui.editor.cursorRight": "l" };
+function workflowKeyMatches(keybindings, data, binding) { return keybindings.matches(data, binding) || WORKFLOW_VIM_KEYS[binding] === data; }
+function workflowKeyLabel(keybindings, binding, fallback, labels) {
+    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, name) { const getKeys = keybindingsHostCapabilities(keybindings).getKeys; return typeof getKeys === "function" ? getKeys.call(keybindings, name) : undefined; }
-export default function workflowExtension(pi, home, clipboard = copyToClipboard, createSession = createNativeAgentSession, agentDir) {
+export default function workflowExtension(pi, home, clipboard = copyToClipboard, createSession = createNativeAgentSession, agentDir, additionalSkillPaths = []) {
     beginWorkflowExtensionLoading();
     const registry = loadingRegistry();
     const extensionAgentDir = agentDir ?? getAgentDir();
@@ -1353,16 +1770,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         });
     };
     const pendingFailureDiagnostics = new Map();
-    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", text: serializeWorkflowFailureDiagnostics(diagnostic) }], details: diagnostic, isError: true };
-    });
+    const foregroundDeliveries = new Map();
     const liveActivities = new Map();
+    const liveEventTimes = new Map();
     const setLiveActivity = (runId, agentId, activity) => {
         const activities = liveActivities.get(runId);
         if (activity) {
@@ -1377,12 +1787,27 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 liveActivities.delete(runId);
         }
     };
+    const setLiveEventTime = (runId, agentId, timestamp) => {
+        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) => {
         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();
     let sessionLease;
@@ -1410,6 +1835,52 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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", text: serializeWorkflowFailureDiagnostics(diagnostic) }], details: diagnostic, isError: true };
+    });
+    const deliverTerminal = async (store, content) => {
+        let claimed;
+        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, send) => {
+        const delivery = foregroundDeliveries.get(toolCallId);
+        if (!delivery || delivery.inline || typeof pi.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, metadata, lifecycle) => {
         let cursor = 0;
         return async (phase) => {
@@ -1462,10 +1933,25 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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);
-            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);
+                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();
@@ -1476,8 +1962,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             budget.transition(next);
         const persisted = await persistRunState(store, metadata, (current) => {
             const nextRun = { ...current, state: next, ...budget.snapshot() };
-            if (next === "running" || next === "completed")
+            if (next === "running" || next === "completed") {
                 delete nextRun.error;
+                delete nextRun.failedAt;
+            }
             return nextRun;
         });
         await eventPublisher.runState(store, metadata, previous, next, reason);
@@ -1492,28 +1980,31 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const onProgress = async (progress) => {
                 let runState;
                 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) => {
                 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); });
@@ -1558,7 +2049,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 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 };
         });
@@ -1567,7 +2060,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     });
     const cleanupTerminalRun = async (runId) => {
         const run = runs.get(runId);
-        if (!run || !["completed", "failed", "stopped"].includes(run.lifecycle.state))
+        if (!run || !HARD_TERMINAL_RUN_STATES.has(run.lifecycle.state))
             return;
         await scheduler.cancelRun(runId);
         await scheduler.flush();
@@ -1577,6 +2070,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         terminalRunStates.set(runId, run.lifecycle.state);
         run.checkpointResolvers.clear();
         liveActivities.delete(runId);
+        liveEventTimes.delete(runId);
         eventPublisher.removeRun(runId);
         runs.delete(runId);
     };
@@ -1617,7 +2111,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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, proposalId, approved, silent = false, context, signal) => {
+    const answerBudgetDecision = async (runId, proposalId, approved, silent = false, context, signal, waitForCompletion = true) => {
         const run = runs.get(runId);
         if (!run)
             return undefined;
@@ -1625,7 +2119,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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;
@@ -1705,6 +2199,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 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",
@@ -1720,6 +2216,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 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;
@@ -1751,37 +2249,100 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         });
         catalogRegistered = true;
     };
-    const refreshPausedRunAliases = async (run, context) => {
-        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) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, ...(additionalSkillPaths.length ? { additionalSkillPaths } : {}), agentSetupHooks: registry.agentSetupHooks() }, createSession);
+    const activeSnapshotTools = (tools, active) => 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) => {
+        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;
+        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, metadata, lifecycle, executor, cwd, runId, captureRole) => 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 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 } : {}) });
+            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, outcome.error.message);
+            await store.complete(path, outcome.value);
+            return outcome.value;
+        }
+        finally {
+            await lifecycle.leave();
+        }
+    };
+    const refreshPausedRunAliases = async (run, context) => {
+        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, hasUI, ui, trustedProject, context) => {
+    const recoveryUi = (context) => {
+        const host = object(context) ? context : undefined;
+        const ui = host && object(host.ui) ? host.ui : {};
+        return { hasUI: host?.hasUI === true, ui };
+    };
+    const coldResumeRun = async (run, hasUI, ui, trustedProject, context, modeOverride, waitForCompletion = true) => {
         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)
@@ -1793,19 +2354,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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();
@@ -1813,17 +2362,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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("; ")}` });
@@ -1835,9 +2380,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         }
         catch (error) {
             const typed = asWorkflowError(error);
-            if (!["completed", "failed", "stopped"].includes(run.lifecycle.state)) {
+            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) => ({ ...current, error: { code: typed.code, message: typed.message } }));
+                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))
@@ -1848,37 +2393,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         }
         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 } : {}) });
-                    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, 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();
@@ -1893,19 +2408,34 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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) => {
+                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, approved, context, signal) => {
+    const applyBudgetDecision = async (request, approved, context, signal, waitForCompletion = true) => {
         const run = runs.get(request.runId);
         if (!run)
             throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${request.runId}`);
@@ -1919,16 +2449,34 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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, rawPatch, context, signal) => {
+    const resumeWorkflowRun = async (runId, rawPatch, context, signal, modeOverride, waitForCompletion = true) => {
         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");
+            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);
@@ -1953,11 +2501,14 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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 };
         return { state: "running" };
     };
     const retryReservations = new Set();
-    const retryWorkflowRun = async (runId, context, signal) => {
+    const retryWorkflowRun = async (runId, context, signal, modeOverride) => {
         if (typeof runId !== "string" || !runId.trim())
             throw new WorkflowError("RESUME_INCOMPATIBLE", "workflow_retry requires an explicit run ID");
         const host = object(context) ? context : {};
@@ -1973,10 +2524,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             loaded = await sourceStore.load();
         }
         catch (error) {
-            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot load failed source run ${runId}: ${errorText(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", `Only failed workflow runs can be retried; source is ${loaded.run.state}`);
+            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;
@@ -2012,28 +2563,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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(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 = { 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);
@@ -2043,8 +2576,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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 = { sourceRunId: loaded.run.id, lineageRootRunId, completedPaths, incompletePaths, namedWorktrees };
@@ -2055,16 +2587,23 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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 {
@@ -2079,28 +2618,32 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         parameters: WORKFLOW_RETRY_PARAMETERS,
         async execute(_id, params, signal, _onUpdate, ctx) {
             try {
-                const result = await retryWorkflowRun(params.runId, ctx, signal);
+                const result = await retryWorkflowRun(params.runId, ctx, signal, params.foreground);
                 return { content: [{ type: "text", 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);
+                const result = await resumeWorkflowRun(params.runId, params.budget, ctx, signal, params.foreground);
                 return { content: [{ type: "text", 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)
@@ -2129,11 +2672,27 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 }
                 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" };
+                        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);
                 eventPublisher.seedBudget(runId, loaded.run.budgetEvents);
@@ -2143,7 +2702,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 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())
@@ -2161,7 +2720,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         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);
+                                await coldResumeRun(run, true, ctx.ui, projectTrusted(ctx), ctx, undefined, false);
                                 ctx.ui.notify(`Resumed workflow ${run.metadata.name}.`, "info");
                             }
                             catch (err) {
@@ -2205,7 +2764,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 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);
@@ -2233,54 +2792,38 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 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", 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", 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, model) => {
+                    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 } : {}) });
-                            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, 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).execution = execution;
                 await eventPublisher.runStarted(store, checked.metadata);
                 const finish = execution.result.then(async (value) => {
@@ -2296,7 +2839,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     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);
@@ -2307,18 +2850,41 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 });
                 const completion = finish.finally(() => cleanupTerminalRun(runId));
                 runs.get(runId).completion = completion;
+                const deliverFailureContent = (error) => {
+                    const diagnostic = failureDiagnosticsFrom(error);
+                    return diagnostic ? formatWorkflowFailureDelivery(diagnostic) : formatWorkflowFailureDeliveryFallback(checked.metadata.name, runId, store.directory, error);
+                };
+                const queueForegroundDelivery = async (content) => {
+                    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) => {
-                        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) => {
+                        await deliverTerminal(store, deliverFailureContent(error));
                     });
                     return { content: [{ type: "text", 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) => {
+                    await queueForegroundDelivery(deliverFailureContent(error));
+                });
                 const { value } = await completion;
                 const run = (await store.load()).run;
                 return { content: [{ type: "text", text: JSON.stringify(value) }, { type: "text", text: `Workflow run ID: ${runId}` }], details: { runId, value, run } };
@@ -2365,7 +2931,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 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() };
+                        const loaded = await store.load();
+                        return { store, loaded: { ...loaded, run: withLiveActivities(loaded.run) } };
                     }
                     catch {
                         if (!await store.isComplete())
@@ -2393,12 +2960,12 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         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)) {
+                        if (!HARD_TERMINAL_RUN_STATES.has(stored.loaded.run.state)) {
                             ctx.ui.notify("Stop the workflow before deleting it.", "warning");
                             return keepContext ? "dashboard" : "done";
                         }
@@ -2418,12 +2985,12 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     if (action === "resume" && run) {
                         if (run.lifecycle.state === "budget_exhausted") {
                             const patch = rest.length ? JSON.parse(rest.join(" ")) : 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);
+                                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) });
@@ -2437,8 +3004,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         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) {
@@ -2591,7 +3158,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     }
                     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"] : [])];
@@ -2659,18 +3226,28 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     };
                     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();
+                        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();
                         const copies = new Map();
                         const reviews = new Map();
                         const add = (label, value) => { actions.set(label, `${value} ${store.runId}`); };
                         const addCopy = (label, value, artifact) => { actions.set(label, "copy"); copies.set(label, { value, artifact }); };
-                        if (loaded.run.state === "running")
+                        if (liveRun.state === "running")
                             add("Pause", "pause");
-                        if (["paused", "interrupted"].includes(loaded.run.state))
+                        if (["paused", "interrupted"].includes(liveRun.state))
                             add("Resume", "resume");
-                        if (loaded.run.state === "budget_exhausted") {
+                        if (liveRun.state === "budget_exhausted") {
                             actions.set("Resume unchanged", `resume ${store.runId}`);
                             actions.set("Adjust budget", `adjust ${store.runId}`);
                         }
@@ -2679,7 +3256,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             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))
+                        if (!terminalStates.has(liveRun.state))
                             add("Stop", "stop");
                         for (const cp of checkpoints) {
                             if (ctx.mode === "tui") {
@@ -2695,40 +3272,64 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         if (ctx.mode !== "tui")
                             actions.set("Refresh", "refresh");
                         else
-                            actions.set("View script", "view-script");
-                        if (loaded.run.agents.length)
+                            actions.set("Open script in editor", "open-script");
+                        if (ctx.mode !== "tui" && liveRun.agents.length)
                             actions.set("Agents...", "agents");
-                        if (terminalStates.has(loaded.run.state))
+                        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 agentWorktreeFor = (dashboard, agent) => agent.worktreeOwner ? dashboard.worktrees.find((candidate) => candidate.owner === agent.worktreeOwner) : undefined;
+                    const agentActionLabels = (dashboard, agent) => {
+                        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 forkAgentSession = async (dashboard, agent) => {
+                        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) => {
+                    const selectAgent = async (dashboard, requestedAgentId) => {
                         const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
                         const title = (agent) => 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;
+                        let selected;
+                        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 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"] : []),
-                            ...(worktree ? ["Copy branch", "Copy worktree path"] : []),
-                            "Copy agent ID",
-                            "Back",
-                        ];
-                        const chooseAttempt = async () => {
-                            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 worktree = agentWorktreeFor(dashboard, selected);
+                        const actions = agentActionLabels(dashboard, selected);
                         for (;;) {
                             const action = await ctx.ui.select(title(selected), actions);
                             if (!action || action === "Back")
@@ -2745,63 +3346,83 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 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((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;
+                                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 = { up: "↑", down: "↓", left: "←", right: "→", tab: "tab", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
-                                const keyLabel = (binding, fallback) => {
-                                    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 = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
+                                const keyLabel = (binding, fallback) => workflowKeyLabel(keybindings, binding, fallback, keyLabels);
+                                const selectedAgentRecord = () => {
+                                    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) => {
-                                    const phaseId = selectedPhaseId;
-                                    const agentId = selectedAgentId;
+                                let editorRunning = false;
+                                const openArtifact = async (artifact, label) => {
+                                    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)
+                                    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 = () => {
@@ -2810,16 +3431,16 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     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) => {
+                                    }).then(() => updateDashboard()).catch((error) => {
                                         if (disposed)
                                             return;
                                         stopStatus = `Could not stop workflow ${store.runId}: ${error instanceof Error ? error.message : String(error)}`;
+                                        setWorkflowStatus(stopStatus);
                                         tui.requestRender();
                                     }).finally(() => {
                                         stopRequested = false;
@@ -2831,129 +3452,203 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     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) {
+                                        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 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;
                                         }
-                                        const maxOffset = Math.max(0, dashboardLines.length - layout.dashboardViewport);
                                         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) {
-                                        if (stopRequested)
+                                        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;
-                                        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;
+                                        }
+                                        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 (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;
+                                        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 (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 (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 (keybindings.matches(data, "tui.select.pageDown")) {
-                                            dashboardOffset += Math.max(1, dashboardLayout().dashboardViewport);
+                                        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 (keybindings.matches(data, "tui.select.confirm")) {
-                                            if (options[selectedIndex] === "Stop")
-                                                requestStop();
-                                            else
-                                                done(options[selectedIndex]);
+                                        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.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")
+                        if (actionChoice.startsWith("__workflow_agent__:")) {
+                            await selectAgent(view, actionChoice.slice("__workflow_agent__:".length));
                             continue;
-                        if (actionChoice === "View script") {
-                            await ctx.ui.custom((tui, theme, keybindings, done) => {
-                                const highlighted = highlightCode(view.script, "javascript");
-                                let offset = 0;
-                                let renderedLines = [];
-                                const viewport = () => Math.max(1, tuiRows(tui) - 3 - WORKFLOW_OVERLAY_BORDER_ROWS);
-                                const move = (delta) => {
-                                    const maxOffset = Math.max(0, renderedLines.length - viewport());
-                                    offset = Math.max(0, Math.min(maxOffset, offset + delta));
-                                };
-                                return borderWorkflowOverlay({
-                                    render(width) {
-                                        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) {
-                                        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_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);
@@ -2988,7 +3683,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                         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 = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
+                                        const keyLabel = (binding, fallback) => 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}`);
@@ -3002,22 +3699,22 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     },
                                     invalidate() { },
                                     handleInput(data) {
-                                        if (keybindings.matches(data, "tui.select.up"))
+                                        if (workflowKeyMatches(keybindings, data, "tui.select.up"))
                                             selectedIndex = (selectedIndex + options.length - 1) % options.length;
-                                        else if (keybindings.matches(data, "tui.select.down"))
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.down"))
                                             selectedIndex = (selectedIndex + 1) % options.length;
-                                        else if (keybindings.matches(data, "tui.select.pageUp"))
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.pageUp"))
                                             move(-layout().contentViewport);
-                                        else if (keybindings.matches(data, "tui.select.pageDown"))
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.pageDown"))
                                             move(layout().contentViewport);
-                                        else if (keybindings.matches(data, "tui.select.confirm"))
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.confirm"))
                                             done(options[selectedIndex] === "Cancel" ? undefined : options[selectedIndex]);
-                                        else if (keybindings.matches(data, "tui.select.cancel"))
+                                        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)
@@ -3044,16 +3741,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     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)) {
+                const isTerminal = SHUTDOWN_TERMINAL_RUN_STATES.has(run.lifecycle.state);
+                if (!isTerminal) {
                     try {
                         await run.lifecycle.terminal("interrupted");
                     }
                     catch (error) {
-                        if (!["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state))
+                        if (!SHUTDOWN_TERMINAL_RUN_STATES.has(run.lifecycle.state))
                             throw error;
                     }
                     run.abortController.abort();