pi-extensible-workflows 3.2.0 → 3.4.0

package/dist/src/host.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 import { Type } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
 import { copyToClipboard, getAgentDir, SettingsManager, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
-import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
+import { FairAgentScheduler, WorkflowAgentExecutor, localAgentTransport } from "./agent-execution.js";
 import { herdrPaneId, openHerdrPane } from "./herdr.js";
 import { acquireSessionLease, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
 import { budgetRelaxed, budgetUsage, mergeBudget, resumeBudgetAllowed, validateBudget, validateBudgetPatch, WorkflowBudgetRuntime } from "./budget.js";
@@ -15,8 +15,8 @@ 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 { openWorkflowArtifact, workflowResultArtifact, workflowScriptArtifact } from "./workflow-artifacts.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, workflowPromptArtifact, 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"]);
@@ -88,6 +88,8 @@ function mainAgentError(error) {
     Object.assign(presented, 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;
@@ -163,14 +165,14 @@ export class RunLifecycle {
 export function formatWorkflowPreview(args) {
     const explicitName = typeof args.name === "string" && args.name.trim() ? args.name.trim() : undefined;
     const registeredName = typeof args.workflow === "string" && args.workflow.trim() ? args.workflow.trim() : undefined;
-    const name = registeredName ?? explicitName ?? "workflow";
+    const name = explicitName ?? registeredName ?? "workflow";
     if (typeof args.script !== "string" || !args.script.trim())
-        return `workflow ${name}${registeredName ? "\nRegistered function" : ""}`;
+        return `workflow ${name}${registeredName ? `\nRegistered function${explicitName ? `: ${registeredName}` : ""}` : ""}`;
     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 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. Foreground results include the completed run ID. Recovery map: agent(..., { retries }) reruns one agent call in the same run for transient failures; workflow_retry({ runId }) replays a failed run into a child; workflow_resume({ runId, budget? }) continues a budget_exhausted run; parentRunId on a new launch only borrows named worktrees and never replays or resumes.";
+export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline or file-backed 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 and file-backed launches require a non-empty name; registered function launches may use name as an optional run label and otherwise 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")
@@ -194,17 +196,18 @@ function workflowRecoveryGuidance(action, state) {
     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 the default inline workflow path; invalid for registered function launches" })),
+    name: Type.Optional(Type.String({ description: "Optional run label; required and non-empty for inline or file-backed launches, defaults to the registered function name when omitted" })),
     description: Type.Optional(Type.String({ description: "Optional human-readable workflow description" })),
     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" })),
+    scriptPath: Type.Optional(Type.String({ description: "Path to a JavaScript workflow file, read once at launch and persisted as the inline source" })),
+    workflow: Type.Optional(Type.String({ description: "Advanced: registered reusable function as an unqualified name; name may optionally label the run" })),
     args: Type.Optional(Type.Unknown({ description: "JSON-compatible workflow arguments" })),
     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());
@@ -547,19 +550,36 @@ function styleForState(map, state, styles) {
 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) {
+function formatWorkflowRuntime(durationMs) {
+    const seconds = Math.max(0, Math.floor(durationMs / 1000));
+    if (seconds < 60)
+        return `${String(seconds)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60)
+        return `${String(minutes)}m${remainingSeconds ? ` ${String(remainingSeconds)}s` : ""}`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${String(hours)}h${remainingMinutes ? ` ${String(remainingMinutes)}m` : ""}`;
+}
+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 = 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 = [`${iconStyle(workflowIcon)} ${header}`];
+    const state = progressStyleForState(run.state, styles)(`[${run.state}]`);
+    const runtime = run.usage ? ` runtime=${formatWorkflowRuntime(run.usage.durationMs)}` : "";
+    const lines = [`${iconStyle(workflowIcon)} ${header} ${state}${runtime}`];
     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 = 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}` : ""}`;
@@ -581,6 +601,7 @@ function workflowToolUpdate(run) {
     return { content: [{ type: "text", text: formatWorkflowProgress(run) }], details: { runId: run.id, run } };
 }
 const workflowSpinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const WORKFLOW_PROGRESS_REFRESH_MS = 1_000;
 function textBlock(text) {
     return {
         render(width) {
@@ -623,7 +644,7 @@ function controlState(state, theme) {
     return theme.fg(color, state);
 }
 function controlAction(action, theme) {
-    const color = /approved|stopped|started|resumed/.test(action) ? "success" : /rejected|failed/.test(action) ? "error" : "warning";
+    const color = /approved|completed|stopped|started|resumed/.test(action) ? "success" : /rejected|failed/.test(action) ? "error" : "warning";
     return theme.fg(color, action);
 }
 function budgetPatchEntries(value) {
@@ -681,14 +702,15 @@ function workflowControlResult(name, args, result, expanded, theme, isError) {
     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("started", theme)}`].join("\n");
-        return [title, `Source run: ${theme.fg("accent", runId)}`, `Retry run: ${theme.fg("accent", childRunId)}`, `State: ${controlState(state, theme)}`, `Action: ${controlAction("started; completed work will be replayed", theme)}`].join("\n");
+            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" : "no change";
+        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");
@@ -809,14 +831,41 @@ function themeWorkflowProgressStyles(theme) {
         bold: (text) => typeof theme.bold === "function" ? theme.bold(text) : text,
     };
 }
-function workflowProgressBlock(run, theme) {
+function workflowProgressBlock(run, theme, progress, refresh, invalidate) {
     const styles = themeWorkflowProgressStyles(theme);
+    const currentRun = () => {
+        const displayed = progress?.run ?? run;
+        if (!progress || displayed.state !== "running")
+            return displayed;
+        const durationMs = Math.max(displayed.usage?.durationMs ?? 0, progress.runtimeBaseMs + Date.now() - progress.runtimeStartedAt);
+        return { ...displayed, usage: { ...budgetUsage(displayed.usage), durationMs } };
+    };
     return {
         render(width) {
             const frame = workflowSpinner[Math.floor(Date.now() / 80) % workflowSpinner.length] ?? "◇";
-            return truncateWorkflowProgress(formatWorkflowProgress(run, frame, styles), width);
+            return truncateWorkflowProgress(formatWorkflowProgress(currentRun(), frame, styles), width);
+        },
+        invalidate() {
+            const displayed = currentRun();
+            if (!progress || !refresh || displayed.state !== "running" || !displayed.agents.some((agent) => agent.state === "running"))
+                return;
+            const now = Date.now();
+            if (progress.refresh || now - progress.lastRefreshAt < WORKFLOW_PROGRESS_REFRESH_MS)
+                return;
+            progress.lastRefreshAt = now;
+            const inputRun = progress.inputRun;
+            const pending = refresh().then((next) => {
+                if (next && progress.inputRun === inputRun) {
+                    progress.run = next;
+                    invalidate?.();
+                }
+            }).catch(() => undefined);
+            progress.refresh = pending;
+            void pending.finally(() => {
+                if (progress.refresh === pending)
+                    delete progress.refresh;
+            });
         },
-        invalidate() { },
     };
 }
 export function formatBudgetStatus(run) {
@@ -888,15 +937,41 @@ 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`;
+}
+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) {
+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 });
@@ -922,7 +997,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");
@@ -935,7 +1010,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}`,
@@ -971,6 +1046,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:");
@@ -979,10 +1057,10 @@ export function formatNavigatorRun(loaded, checkpoints, worktrees) {
     for (const checkpoint of checkpoints)
         lines.push(`  ${checkpoint.name}: ${checkpoint.prompt} context=${JSON.stringify(checkpoint.context)}`);
     lines.push(`Worktrees: ${String(worktrees.length)}`);
-    lines.push(`Native Pi transcripts: ${String(run.nativeSessions.length)}`);
+    lines.push(`Agent sessions: ${String(run.agentSessions.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);
@@ -1022,7 +1100,8 @@ export function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {
     const treeLine = (node) => {
         const selected = node.id === selectedNode?.id;
         const state = progressStyleForState(node.state, styles);
-        return `${selected ? "→" : " "} ${"  ".repeat(node.depth)}${nodeIcon(node)} ${node.label} · ${state(node.state)}`;
+        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)
@@ -1041,12 +1120,15 @@ export function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {
         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)}`, ...(selection.actions ? [] : [styles.muted("enter for agent actions")])];
+        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)"}`, ...(agent.systemPrompt === undefined ? [] : [`System prompt: ${agent.systemPrompt}`]), `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"];
@@ -1130,8 +1212,8 @@ function boundedWorkflowFailureDiagnostics(value) {
                 ...(value.failedAgent.role ? { role: utf8Prefix(value.failedAgent.role, 128) } : {}),
                 structuralPath: value.failedAgent.structuralPath.slice(0, 8).map((part) => utf8Prefix(part, 128)),
                 attempt: value.failedAgent.attempt,
-                ...(value.failedAgent.sessionId ? { sessionId: utf8Prefix(value.failedAgent.sessionId, 256) } : {}),
-                ...(value.failedAgent.sessionFile ? { sessionFile: utf8Prefix(value.failedAgent.sessionFile, 1024) } : {}),
+                ...(value.failedAgent.transport ? { transport: utf8Prefix(value.failedAgent.transport, 128) } : {}),
+                ...(value.failedAgent.session ? { session: structuredClone(value.failedAgent.session) } : {}),
             } } : {}),
         completedSiblingAgents: (value.completedSiblingAgents ?? []).slice(0, 16).map((agent) => ({
             id: utf8Prefix(agent.id, 128),
@@ -1160,18 +1242,6 @@ function boundedWorkflowFailureDiagnostics(value) {
             bounded = { ...bounded, retry };
             continue;
         }
-        if (bounded.failedAgent?.sessionFile) {
-            const failedAgent = { ...bounded.failedAgent };
-            delete failedAgent.sessionFile;
-            bounded = { ...bounded, failedAgent };
-            continue;
-        }
-        if (bounded.failedAgent?.sessionId) {
-            const failedAgent = { ...bounded.failedAgent };
-            delete failedAgent.sessionId;
-            bounded = { ...bounded, failedAgent };
-            continue;
-        }
         if (Buffer.byteLength(bounded.artifacts.runDirectory) > 256) {
             bounded = { ...bounded, artifacts: { ...bounded.artifacts, runDirectory: utf8Prefix(bounded.artifacts.runDirectory, 256) } };
             continue;
@@ -1244,8 +1314,8 @@ async function createWorkflowFailureDiagnostics(store, metadata, error, run) {
         ...(failedAgentRecord.role ? { role: failedAgentRecord.role } : {}),
         structuralPath: [...(failedAgentRecord.structuralPath ?? [])],
         attempt: Math.max(1, failedAttempt?.attempt ?? failedAgentRecord.attempts),
-        ...(failedAttempt?.sessionId ? { sessionId: failedAttempt.sessionId } : {}),
-        ...(failedAttempt?.sessionFile ? { sessionFile: failedAttempt.sessionFile } : {}),
+        ...(failedAttempt?.transport ? { transport: failedAttempt.transport } : {}),
+        ...(failedAttempt?.session ? { session: failedAttempt.session } : {}),
     } : undefined;
     const completedSiblingAgents = run.agents.filter((agent) => {
         if (agent.state !== "completed" || agent.id === failedAgentRecord?.id)
@@ -1282,21 +1352,41 @@ async function createWorkflowFailureDiagnostics(store, metadata, error, run) {
     });
 }
 export function formatWorkflowFailureDiagnostics(diagnostic) {
-    const failedAgent = diagnostic.failedAgent ? `${diagnostic.failedAgent.label ?? diagnostic.failedAgent.id}${diagnostic.failedAgent.role ? ` role=${diagnostic.failedAgent.role}` : ""} attempt=${String(diagnostic.failedAgent.attempt)} path=${diagnostic.failedAgent.structuralPath.join(" > ") || "(root)"}${diagnostic.failedAgent.sessionFile ? ` session=${diagnostic.failedAgent.sessionFile}` : ""}` : "(not persisted)";
+    const failedAgent = diagnostic.failedAgent ? `${diagnostic.failedAgent.label ?? diagnostic.failedAgent.id}${diagnostic.failedAgent.role ? ` role=${diagnostic.failedAgent.role}` : ""} attempt=${String(diagnostic.failedAgent.attempt)} path=${diagnostic.failedAgent.structuralPath.join(" > ") || "(root)"}${diagnostic.failedAgent.session ? ` session=${diagnostic.failedAgent.session.transport}/${diagnostic.failedAgent.session.sessionId}` : ""}` : "(not persisted)";
     const siblingAgents = diagnostic.completedSiblingAgents;
     const siblings = siblingAgents ? siblingAgents.map((agent) => `${agent.label ?? agent.id}${agent.role ? ` role=${agent.role}` : ""} path=${agent.structuralPath.join(" > ") || "(root)"}`).join(", ") || "(none)" : diagnostic.completedSiblingPaths.map((path) => path.join(" > ") || "(root)").join(", ") || "(none)";
     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";
@@ -1633,6 +1723,7 @@ function tuiRows(tui) {
     const rows = object(tui) && object(tui.terminal) ? tui.terminal.rows : undefined;
     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 } };
@@ -1649,7 +1740,15 @@ function keybindingKeys(keybindings, name) {
     const getKeys = object(keybindings) ? asFn(keybindings.getKeys) : undefined;
     return getKeys ? getKeys.call(keybindings, name) : undefined;
 }
-export default function workflowExtension(pi, home, clipboard = copyToClipboard, createSession = createNativeAgentSession, agentDir) {
+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("/");
+}
+export default function workflowExtension(pi, home, clipboard = copyToClipboard, transport = localAgentTransport, agentDir, additionalSkillPaths = []) {
     beginWorkflowExtensionLoading();
     const registry = loadingRegistry();
     const extensionAgentDir = agentDir ?? getAgentDir();
@@ -1702,16 +1801,14 @@ 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 liveAgentSessions = new Map();
+    const setLiveAgentSession = (runId, agentId, session) => { const key = `${runId}:${agentId}`; if (session)
+        liveAgentSessions.set(key, session);
+    else
+        liveAgentSessions.delete(key); };
     const setLiveActivity = (runId, agentId, activity) => {
         const activities = liveActivities.get(runId);
         if (activity) {
@@ -1726,12 +1823,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;
@@ -1759,6 +1871,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) => {
@@ -1811,10 +1969,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();
@@ -1825,8 +1998,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);
@@ -1841,28 +2016,32 @@ 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, ...(progress.state ? { model: progress.state.model, tools: progress.state.tools, ...(progress.state.systemPrompt === undefined ? {} : { systemPrompt: progress.state.systemPrompt }) } : {}), 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, ...(progress.state ? { model: progress.state.model, tools: progress.state.tools, ...(progress.state.systemPrompt === undefined ? {} : { systemPrompt: progress.state.systemPrompt }) } : {}), 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) => {
+                setLiveAgentSession(runId, id, attempt.liveSession);
                 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); });
@@ -1872,10 +2051,12 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             await eventPublisher.agentStates(run.store, run.metadata, before.agents, completed.agents);
             const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
             setLiveActivity(runId, id);
+            setLiveAgentSession(runId, id);
             run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
             return result.value;
         }
         catch (error) {
+            setLiveAgentSession(runId, id);
             const attempts = error.attempts;
             if (attempts?.length) {
                 const before = (await run.store.load()).run;
@@ -1908,7 +2089,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     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 };
                 }
                 const resultPath = !node.parentId && node.options.agentIdentity ? agentIdentityPath(node.options.agentIdentity) : undefined;
-                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 } : {}) };
+                const lastEventAt = node.state === "running" ? previous?.state === "running" && previous.lastEventAt !== undefined ? previous.lastEventAt : Date.now() : previous?.lastEventAt;
+                return { ...(previous?.systemPrompt === undefined ? {} : { systemPrompt: previous.systemPrompt }), ...(node.prompt !== undefined ? { prompt: node.prompt } : previous?.prompt !== undefined ? { prompt: previous.prompt } : {}), 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 };
         });
@@ -1927,6 +2109,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         terminalRunStates.set(runId, run.lifecycle.state);
         run.checkpointResolvers.clear();
         liveActivities.delete(runId);
+        liveEventTimes.delete(runId);
+        for (const key of liveAgentSessions.keys())
+            if (key.startsWith(`${runId}:`))
+                liveAgentSessions.delete(key);
         eventPublisher.removeRun(runId);
         runs.delete(runId);
     };
@@ -1967,7 +2153,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;
@@ -1975,7 +2161,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;
@@ -2088,7 +2274,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         pi.registerTool({
             name: "workflow_catalog",
             label: "Workflow Catalog",
-            description: "List reusable workflow functions, variables, and model aliases, or load one entry in full",
+            description: "List reusable workflow functions, variables, and model aliases; pass `name` to load one entry in full",
             parameters: Type.Object({ name: Type.Optional(Type.String({ description: "Registered function, variable, or model alias name for full detail" })) }, { additionalProperties: false }),
             async execute(_id, params = {}) {
                 const context = { cwd, projectTrusted: trustedProject, globalSettingsPath: workflowSettingsPath(extensionAgentDir) };
@@ -2105,7 +2291,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         });
         catalogRegistered = true;
     };
-    const createAgentExecutor = (root) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, agentSetupHooks: registry.agentSetupHooks() }, createSession);
+    const createAgentExecutor = (root) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, ...(additionalSkillPaths.length ? { additionalSkillPaths } : {}), agentSetupHooks: registry.agentSetupHooks() }, transport);
     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"));
@@ -2135,7 +2321,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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) => async (prompt, options, agentSignal, identity) => {
+    const workflowAgentHandler = (store, metadata, lifecycle, executor, cwd, runId, captureRole) => async (prompt, options, agentSignal, identity) => {
         await lifecycle.enter();
         try {
             const path = agentIdentityPath(identity);
@@ -2150,6 +2336,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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;
@@ -2182,8 +2370,21 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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)
@@ -2206,7 +2407,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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");
-        await run.store.saveSnapshot(snapshot);
+        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 = 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);
@@ -2222,7 +2424,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const typed = asWorkflowError(error);
             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))
@@ -2233,7 +2435,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: 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, 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();
@@ -2248,19 +2450,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}`);
@@ -2274,10 +2491,13 @@ 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) {
             const host = object(context) ? context : {};
@@ -2323,11 +2543,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 : {};
@@ -2399,7 +2622,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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 };
-            await childStore.create({ id: childRunId, workflowName: loaded.snapshot.metadata.name, cwd, sessionId, state: "interrupted", parentRunId: loaded.run.id, retry, agents: [], nativeSessions: [], ...(budget ? { budget } : {}), budgetVersion: loaded.run.budgetVersion ?? 1, ...childInitialBudget }, childSnapshot);
+            await childStore.create({ id: childRunId, workflowName: loaded.snapshot.metadata.name, cwd, sessionId, state: "interrupted", parentRunId: loaded.run.id, retry, agents: [], agentSessions: [], ...(budget ? { budget } : {}), budgetVersion: loaded.run.budgetVersion ?? 1, ...childInitialBudget }, childSnapshot);
             const fallbackModel = { provider: hostModel.provider, model: hostModel.id, thinking: pi.getThinkingLevel() };
             const model = modelSpec(loaded.snapshot.models[0] ?? "", fallbackModel);
             const lifecycle = lifecycleFor(childStore, "interrupted", childBudget, loaded.snapshot.metadata);
@@ -2410,12 +2633,19 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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 {
@@ -2430,7 +2660,7 @@ 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) {
@@ -2444,10 +2674,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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) {
@@ -2484,11 +2714,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);
@@ -2516,7 +2762,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) {
@@ -2588,10 +2834,27 @@ 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: [], agentSessions: [], 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)
@@ -2602,7 +2865,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 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: workflowAgentHandler(store, checked.metadata, lifecycle, executor, ctx.cwd, runId), 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) => {
@@ -2618,7 +2881,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);
@@ -2629,18 +2892,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 } };
@@ -2666,8 +2952,33 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 clearInterval(state.workflowSpinner);
                 delete state.workflowSpinner;
             }
-            if (runDetails?.run)
-                return workflowProgressBlock(runDetails.run, theme);
+            if (runDetails?.run) {
+                const incoming = runDetails.run;
+                let progress = state.workflowProgress;
+                if (!isPartial || !progress || progress.runId !== incoming.id) {
+                    progress = undefined;
+                    delete state.workflowProgress;
+                    if (isPartial) {
+                        progress = { runId: incoming.id, inputRun: incoming, run: incoming, lastRefreshAt: 0, runtimeStartedAt: Date.now(), runtimeBaseMs: incoming.usage?.durationMs ?? 0 };
+                        state.workflowProgress = progress;
+                    }
+                }
+                else if (progress.inputRun !== incoming) {
+                    if (progress.run.state !== "running" && incoming.state === "running") {
+                        progress.runtimeBaseMs = incoming.usage?.durationMs ?? 0;
+                        progress.runtimeStartedAt = Date.now();
+                    }
+                    progress.inputRun = incoming;
+                    progress.run = incoming;
+                }
+                return workflowProgressBlock(progress?.run ?? incoming, theme, progress, async () => {
+                    const active = runs.get(incoming.id);
+                    const store = active?.store ?? new RunStore(incoming.cwd, incoming.sessionId, incoming.id, home);
+                    const loaded = await store.load();
+                    return withLiveActivities(loaded.run);
+                }, () => { if (state.workflowProgress === progress)
+                    context.invalidate(); });
+            }
             const content = result.content[0];
             return textBlock(isPartial ? "Workflow starting..." : runDetails?.preview ?? (content?.type === "text" ? content.text : "Workflow finished"));
         },
@@ -2687,7 +2998,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())
@@ -2715,7 +3027,7 @@ 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";
                     }
@@ -2740,12 +3052,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) });
@@ -2759,8 +3071,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) {
@@ -2981,11 +3293,12 @@ 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 loaded.run.agents) {
+                        for (const agent of liveRun.agents) {
                             if (agent.state !== "completed" || agent.parentId || !agent.resultPath)
                                 continue;
                             const operation = completedOperations.find((candidate) => candidate.path === agent.resultPath);
@@ -2997,11 +3310,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         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}`);
                         }
@@ -3010,7 +3323,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") {
@@ -3027,47 +3340,50 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             actions.set("Refresh", "refresh");
                         else
                             actions.set("Open script in editor", "open-script");
-                        if (ctx.mode !== "tui" && loaded.run.agents.length)
+                        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, agentResults, 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 agentAttemptActionContext = (dashboard, agent) => {
+                        const attempt = (agent.attemptDetails ?? []).reduce((latest, candidate) => !latest || candidate.attempt > latest.attempt ? candidate : latest, undefined);
+                        if (!attempt)
+                            return undefined;
+                        const liveCandidate = liveAgentSessions.get(`${dashboard.run.id}:${agent.id}`);
+                        const live = liveCandidate && attempt.session && liveCandidate.reference.transport === attempt.session.transport && liveCandidate.reference.sessionId === attempt.session.sessionId ? liveCandidate : undefined;
+                        const run = runs.get(dashboard.run.id);
+                        const ui = { notify: (message, level = "info") => { ctx.ui.notify(message, level); }, confirm: (title, message) => ctx.ui.confirm(title, message), select: (title, options) => { return ctx.ui.select(title, [...options]); }, input: (title, placeholder) => ctx.ui.input(title, placeholder) };
+                        const attemptSnapshot = deepFreeze(structuredClone(attempt));
+                        return { run: deepFreeze(structuredClone(dashboard.run)), agent: deepFreeze(structuredClone(agent)), attempt: attemptSnapshot, ...(attemptSnapshot.session ? { session: attemptSnapshot.session } : {}), ...(live ? { liveSession: live } : {}), signal: run?.abortController.signal ?? new AbortController().signal, ui: Object.freeze(ui) };
+                    };
+                    const visibleAgentAttemptActions = (dashboard, agent) => {
+                        const context = agentAttemptActionContext(dashboard, agent);
+                        if (!context)
+                            return [];
+                        return Object.entries(registry.agentAttemptActions()).filter(([, action]) => { try {
+                            return action.visible(context);
+                        }
+                        catch {
+                            return false;
+                        } });
+                    };
                     const agentActionLabels = (dashboard, agent) => {
                         const worktree = agentWorktreeFor(dashboard, agent);
                         return [
-                            ...(agent.attemptDetails?.length && herdrPaneId() ? ["Fork as Pi session in pane"] : []),
+                            ...visibleAgentAttemptActions(dashboard, agent).map(([, action]) => action.label),
                             ...(worktree ? ["Copy branch", "Copy worktree path"] : []),
+                            ...(ctx.mode === "tui" && agent.prompt !== undefined ? ["Open prompt in editor"] : []),
                             ...(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, requestedAgentId) => {
                         const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
                         const title = (agent) => agentBreadcrumb(agent, byId, true);
@@ -3088,6 +3404,19 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             const action = await ctx.ui.select(title(selected), actions);
                             if (!action || action === "Back")
                                 return;
+                            const extensionAction = visibleAgentAttemptActions(dashboard, selected).find(([, candidate]) => candidate.label === action);
+                            if (extensionAction) {
+                                const context = agentAttemptActionContext(dashboard, selected);
+                                if (context) {
+                                    try {
+                                        await extensionAction[1].run(context);
+                                    }
+                                    catch (error) {
+                                        ctx.ui.notify(`Agent attempt action failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+                                    }
+                                }
+                                return;
+                            }
                             if (action === "Copy agent ID") {
                                 await copyArtifact(selected.id, "agent ID");
                                 continue;
@@ -3100,8 +3429,6 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 await copyArtifact(worktree.path, "worktree path");
                                 continue;
                             }
-                            if (action === "Fork as Pi session in pane")
-                                await forkAgentSession(dashboard, selected);
                         }
                     };
                     for (;;) {
@@ -3123,12 +3450,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 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_OVERLAY_BORDER_ROWS);
+                                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) => {
-                                    const keys = keybindingKeys(keybindings, binding);
-                                    return keys?.length ? keys.map((key) => keyLabels[key] ?? key).join("/") : fallback;
-                                };
+                                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;
@@ -3159,7 +3483,6 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     }
                                     finally {
                                         editorRunning = false;
-                                        tui.requestRender(true);
                                     }
                                 };
                                 const updateDashboard = async () => {
@@ -3213,7 +3536,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     void updateDashboard().catch(() => undefined).finally(() => { refreshing = false; });
                                 }, 1000);
                                 timer.unref();
-                                return borderWorkflowOverlay({
+                                return {
                                     render(width) {
                                         renderedWidth = width;
                                         const narrow = width < 80;
@@ -3249,7 +3572,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                             selectionNeedsScroll = false;
                                         }
                                         dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
-                                        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" : "close"}${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] ?? "";
+                                        const hint = truncateToVisualLines(theme.fg("dim", actionMode ? `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.select.confirm", "enter")} run · ${keyLabel("tui.editor.cursorLeft", "←")} tree · ${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() { },
@@ -3266,21 +3589,21 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                         }
                                         if (actionMode) {
                                             const options = actionOptions();
-                                            if (keybindings.matches(data, "tui.select.cancel")) {
+                                            if (workflowKeyMatches(keybindings, data, "tui.select.cancel") || workflowKeyMatches(keybindings, data, "tui.editor.cursorLeft")) {
                                                 actionMode = false;
                                                 dashboardOffset = 0;
                                                 tui.requestRender();
                                                 return;
                                             }
-                                            if (keybindings.matches(data, "tui.select.up"))
+                                            if (workflowKeyMatches(keybindings, data, "tui.select.up"))
                                                 actionIndex = (actionIndex + options.length - 1) % options.length;
-                                            else if (keybindings.matches(data, "tui.select.down"))
+                                            else if (workflowKeyMatches(keybindings, data, "tui.select.down"))
                                                 actionIndex = (actionIndex + 1) % options.length;
-                                            else if (keybindings.matches(data, "tui.select.pageUp"))
+                                            else if (workflowKeyMatches(keybindings, data, "tui.select.pageUp"))
                                                 dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
-                                            else if (keybindings.matches(data, "tui.select.pageDown"))
+                                            else if (workflowKeyMatches(keybindings, data, "tui.select.pageDown"))
                                                 dashboardOffset += Math.max(1, terminalRows() - 1);
-                                            else if (keybindings.matches(data, "tui.select.confirm")) {
+                                            else if (workflowKeyMatches(keybindings, data, "tui.select.confirm")) {
                                                 const action = options[actionIndex];
                                                 const agent = selectedAgentRecord();
                                                 if (!action || action === "Back") {
@@ -3289,7 +3612,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                                 }
                                                 else if (agent) {
                                                     const worktree = agentWorktreeFor(view, agent);
-                                                    if (action === "Open result in editor") {
+                                                    if (action === "Open prompt in editor") {
+                                                        if (agent.prompt !== undefined)
+                                                            void openArtifact(Promise.resolve(workflowPromptArtifact(agent.prompt)), "agent prompt");
+                                                    }
+                                                    else if (action === "Open result in editor") {
                                                         const result = view.agentResults.get(agent.id);
                                                         if (result !== undefined)
                                                             void openArtifact(Promise.resolve(workflowResultArtifact(result)), "agent result");
@@ -3300,8 +3627,14 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                                         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 {
+                                                        const extensionAction = visibleAgentAttemptActions(view, agent).find(([, candidate]) => candidate.label === action);
+                                                        const actionContext = extensionAction ? agentAttemptActionContext(view, agent) : undefined;
+                                                        if (extensionAction && actionContext) {
+                                                            actionMode = false;
+                                                            void Promise.resolve(extensionAction[1].run(actionContext)).catch((error) => { ctx.ui.notify(`Agent attempt action failed: ${error instanceof Error ? error.message : String(error)}`, "error"); }).finally(() => { void updateDashboard(); });
+                                                        }
+                                                    }
                                                 }
                                                 else if (action === "Open script in editor")
                                                     void openArtifact(readFile(join(store.directory, "workflow.js"), "utf8").then(workflowScriptArtifact), "workflow script");
@@ -3314,20 +3647,20 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                             return;
                                         }
                                         const current = selectedNodeId ? tree.byId.get(selectedNodeId) : tree.nodes[0];
-                                        if (keybindings.matches(data, "tui.select.cancel")) {
+                                        if (workflowKeyMatches(keybindings, data, "tui.select.cancel")) {
                                             if (narrow && detailsMode) {
                                                 detailsMode = false;
                                                 selectionNeedsScroll = true;
                                             }
                                             else
-                                                done(undefined);
+                                                done("Back");
                                         }
                                         else if (narrow && detailsMode) {
-                                            if (keybindings.matches(data, "tui.select.pageUp"))
+                                            if (workflowKeyMatches(keybindings, data, "tui.select.pageUp"))
                                                 dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
-                                            else if (keybindings.matches(data, "tui.select.pageDown"))
+                                            else if (workflowKeyMatches(keybindings, data, "tui.select.pageDown"))
                                                 dashboardOffset += Math.max(1, terminalRows() - 1);
-                                            else if (keybindings.matches(data, "tui.select.confirm")) {
+                                            else if (workflowKeyMatches(keybindings, data, "tui.select.confirm")) {
                                                 if (current?.kind === "agent" && current.agentId) {
                                                     actionMode = true;
                                                     actionIndex = 0;
@@ -3340,33 +3673,33 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                                 }
                                             }
                                         }
-                                        else if (keybindings.matches(data, "tui.editor.cursorLeft")) {
+                                        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.editor.cursorRight")) {
+                                        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.up")) {
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.up")) {
                                             const next = navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, "up");
                                             selectedNodeId = next.nodeId;
                                             selectionNeedsScroll = true;
                                         }
-                                        else if (keybindings.matches(data, "tui.select.down")) {
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.down")) {
                                             const next = navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, "down");
                                             selectedNodeId = next.nodeId;
                                             selectionNeedsScroll = true;
                                         }
-                                        else if (keybindings.matches(data, "tui.select.pageUp"))
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.pageUp"))
                                             dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
-                                        else if (keybindings.matches(data, "tui.select.pageDown"))
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.pageDown"))
                                             dashboardOffset += Math.max(1, terminalRows() - 1);
-                                        else if (keybindings.matches(data, "tui.select.confirm")) {
+                                        else if (workflowKeyMatches(keybindings, data, "tui.select.confirm")) {
                                             if (narrow)
                                                 detailsMode = true;
                                             else if (current?.kind === "agent" && current.agentId) {
@@ -3383,11 +3716,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                         tui.requestRender();
                                     },
                                     dispose() { disposed = true; clearInterval(timer); setWorkflowStatus(undefined); },
-                                }, theme);
-                            }, { overlay: true, overlayOptions: WORKFLOW_OVERLAY_OPTIONS })
-                            : 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;
@@ -3396,13 +3731,6 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             await selectAgent(view, actionChoice.slice("__workflow_agent__:".length));
                             continue;
                         }
-                        if (actionChoice.startsWith("__workflow_fork__:")) {
-                            const agentId = actionChoice.slice("__workflow_fork__:".length);
-                            const agent = view.agents.find((candidate) => candidate.id === agentId);
-                            if (agent)
-                                await forkAgentSession(view, agent);
-                            continue;
-                        }
                         if (actionChoice === "Refresh")
                             continue;
                         const copy = view.copies.get(actionChoice);
@@ -3439,7 +3767,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}`);
@@ -3453,17 +3783,17 @@ 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();
                                     },