pi-extensible-workflows 3.0.0 → 3.2.0

package/dist/src/host.js

@@ -1,22 +1,46 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Type } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
-import { copyToClipboard, getAgentDir, highlightCode, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, getAgentDir, SettingsManager, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
 import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
 import { herdrPaneId, openHerdrPane } from "./herdr.js";
 import { acquireSessionLease, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
 import { budgetRelaxed, budgetUsage, mergeBudget, resumeBudgetAllowed, validateBudget, validateBudgetPatch, WorkflowBudgetRuntime } from "./budget.js";
-import { asWorkflowError, aliasDrift, createLaunchSnapshot, deepFreeze, errorCode, errorText, fail, isWorkflowAuthored, jsonValue, modelCapability, object, parseModelReference, parseThinking, positiveInteger, resolveModelReference, validateModelAliases } from "./utils.js";
-import { launchScriptForSnapshot, loadAgentDefinitions, loadSettings, preflight, resolveAgentResourcePolicy, saveModelAliases, validateAgentOptions, validateCheckpoint, validateShellOptions, validateWorkflowLaunchWithRegistry, workflowPrompt, workflowSettingsPath } from "./validation.js";
+import { asWorkflowError, aliasDrift, createLaunchSnapshot, deepFreeze, errorCode, errorText, fail, isWorkflowAuthored, jsonValue, modelAliasErrorName, modelCapability, object, parseModelReference, parseThinking, positiveInteger, resolveModelReference, validateModelAliases } from "./utils.js";
+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";
 const SETTLED_AGENT_STATES = new Set(["completed", "failed", "cancelled"]);
+const INTERNAL_WORKFLOW_TOOLS = ["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"];
+const HARD_TERMINAL_RUN_STATES = new Set(["completed", "failed", "stopped"]);
+const SHUTDOWN_TERMINAL_RUN_STATES = new Set(["completed", "failed", "stopped", "budget_exhausted"]);
+function snapshotResourcePolicy(snapshot, cwd, projectTrusted, globalSettingsPath) {
+    const empty = { skills: [], extensions: [] };
+    return { globalSettingsPath, projectSettingsPath: workflowProjectSettingsPath(cwd), projectTrusted, global: empty, project: empty, effective: snapshot.settings.disabledAgentResources ?? empty, unmatchedSkills: [], unmatchedExtensions: [] };
+}
 const PLAIN_WORKFLOW_PROGRESS_STYLES = { accent: (text) => text, success: (text) => text, error: (text) => text, warning: (text) => text, muted: (text) => text, dim: (text) => text, bold: (text) => text };
+function workflowLaunchSettings(cwd, projectTrusted, globalSettingsPath, concurrency) {
+    const resolution = resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath);
+    const settings = Object.freeze({ ...resolution.effective, ...(concurrency === undefined ? {} : { concurrency }) });
+    return { settings, resolution, resourcePolicy: resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath) };
+}
+function frozenResourcePolicy(policy) { return () => structuredClone(policy); }
+function resumedSnapshotSettings(snapshot, resolution, modelAliases) {
+    const settings = { ...snapshot.settings, concurrency: snapshot.settingsSources === undefined || snapshot.settingsSources.concurrency === "per-run options" ? snapshot.settings.concurrency : resolution.effective.concurrency, modelAliases };
+    if (resolution.effective.disabledAgentResources === undefined)
+        delete settings.disabledAgentResources;
+    else
+        settings.disabledAgentResources = resolution.effective.disabledAgentResources;
+    const settingsSources = snapshot.settingsSources === undefined ? undefined : { ...snapshot.settingsSources, modelAliases: resolution.sources.modelAliases, disabledAgentResources: resolution.sources.disabledAgentResources, concurrency: snapshot.settingsSources.concurrency === "per-run options" ? "per-run options" : resolution.sources.concurrency };
+    return { settings, ...(settingsSources === undefined ? {} : { settingsSources }) };
+}
 const WORKFLOW_FAILURE_DIAGNOSTICS = Symbol("workflowFailureDiagnostics");
 function workflowDetail(message) {
     const detail = message.trim().replace(new RegExp(`\\b(?:${ERROR_CODES.join("|")})\\b:?\\s*`, "g"), "").replace(/^\s*[A-Z][A-Z0-9_]+:\s*/, "").split("\n").filter((line) => !/^\s*at\s/.test(line)).join("\n").replace(/^Run \S+(?=\s(?:exceeded|is))/i, "Run").replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi, "the workflow").replace(/^(?:Pi )session \S+(?=\s(?:is|has))/i, "session").replace(/^(Unknown scheduler run|Missing production ownership record|Persisted agent belongs to another run):\s*\S+/i, "$1").replace(/\b(?:runId|sessionId|callSite|occurrence|failedAt|id)[:=]\s*\S+/gi, "").replace(/\s{2,}/g, " ").trim();
@@ -62,7 +86,6 @@ function mainAgentError(error) {
     const typed = asWorkflowError(error);
     const presented = new WorkflowError(typed.code, formatWorkflowFailure(typed));
     Object.assign(presented, typed);
-    presented.message = formatWorkflowFailure(typed);
     return presented;
 }
 export class RunLifecycle {
@@ -125,7 +148,7 @@ export class RunLifecycle {
         await this.enter();
     }
     async terminal(state, reason) {
-        if (["completed", "failed", "stopped"].includes(this.#state))
+        if (HARD_TERMINAL_RUN_STATES.has(this.#state))
             throw new WorkflowError("RESUME_INCOMPATIBLE", `${this.#state} runs are terminal`);
         await this.#set(state, reason ?? state);
         for (const resolve of this.#waiters.splice(0))
@@ -146,20 +169,337 @@ export function formatWorkflowPreview(args) {
     return [`workflow ${name}`, typeof args.description === "string" && args.description.trim() ? args.description.trim() : ""].filter(Boolean).join("\n");
 }
 export const WORKFLOW_TOOL_LABEL = "Workflow";
-export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow";
-export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow that orchestrates subagents. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Runs in the background by default; completion arrives as a follow-up message. Foreground results include the completed run ID. Use workflow_retry with an explicit failed run ID to replay completed structural operations; parentRunId only reuses named worktrees.";
+export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline parallel-to-summary path by default";
+export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow. Prefer a named inline script that fans out independent work with parallel(...), awaits the keyed results before interpolating them into one summarizing agent(...), and returns. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Advanced controls include registered functions, outputSchema, budgets, checkpoints, worktrees, retry/resume, CLI export, and pipelines. Use workflow_retry with an explicit failed run ID; parentRunId only reuses named worktrees. Runs are in the background by default; completion arrives as a follow-up message. Set foreground: true when the caller must wait for the final value. 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.";
+function workflowRecoveryGuidance(action, state) {
+    if (action === "resume") {
+        if (state === "failed")
+            return "Failed workflow runs must use workflow_retry({ runId })";
+        if (state === "completed")
+            return "Completed workflow runs have no recovery action";
+        if (state === "stopped")
+            return "Stopped workflow runs have no recovery action; launch a new workflow";
+        if (state === "interrupted")
+            return "Interrupted workflow runs use /workflow resume, not workflow_resume";
+        return `Only budget-exhausted runs can be resumed with workflow_resume; source is ${state}`;
+    }
+    if (state === "budget_exhausted")
+        return "Budget-exhausted workflow runs must use workflow_resume({ runId, budget? })";
+    if (state === "completed")
+        return "Completed workflow runs have no recovery action";
+    if (state === "stopped")
+        return "Stopped workflow runs cannot be retried; launch a new workflow";
+    if (state === "interrupted")
+        return "Interrupted workflow runs use /workflow resume, not workflow_retry";
+    return `Only failed workflow runs can be retried; source is ${state}`;
+}
 export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
-    name: Type.Optional(Type.String({ description: "Required non-empty name for inline workflow runs; invalid for registered function launches" })),
+    name: Type.Optional(Type.String({ description: "Required non-empty name for the default inline workflow path; invalid for registered function launches" })),
     description: Type.Optional(Type.String({ description: "Optional human-readable workflow description" })),
-    script: Type.Optional(Type.String({ description: "Immutable workflow source without metadata" })),
-    workflow: Type.Optional(Type.String({ description: "Registered reusable function as an unqualified name" })),
+    script: Type.Optional(Type.String({ description: "Immutable inline workflow source; default to a named script that fans out with parallel(...) and awaits results before passing them to a summarizing agent(...)" })),
+    workflow: Type.Optional(Type.String({ description: "Advanced: registered reusable function as an unqualified name" })),
     args: Type.Optional(Type.Unknown({ description: "JSON-compatible workflow arguments" })),
-    foreground: Type.Optional(Type.Boolean({ description: "Wait for completion instead of running in the background" })),
-    concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 16 })),
-    budget: Type.Optional(Type.Unknown({ description: "Optional aggregate soft and hard run budgets" })),
-    parentRunId: Type.Optional(Type.String({ description: "Terminal run whose named worktrees may be reused" })),
+    foreground: Type.Optional(Type.Boolean({ description: "Wait for completion instead of the default background launch" })),
+    concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 16, description: "Advanced: optional per-run active-agent limit" })),
+    budget: Type.Optional(Type.Unknown({ description: "Advanced: optional aggregate soft and hard run budgets" })),
+    parentRunId: Type.Optional(Type.String({ description: "Advanced: terminal run whose named worktrees may be reused" })),
 });
 export const WORKFLOW_RETRY_PARAMETERS = Type.Object({ runId: Type.String({ description: "Explicit failed workflow run ID" }) });
+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());
+}
+function phaseAgentCounts(agents) {
+    const counts = { total: agents.length, completed: 0, running: 0, failed: 0, cancelled: 0, pending: 0 };
+    for (const agent of agents) {
+        if (agent.state === "completed")
+            counts.completed += 1;
+        else if (agent.state === "running")
+            counts.running += 1;
+        else if (agent.state === "failed")
+            counts.failed += 1;
+        else if (agent.state === "cancelled")
+            counts.cancelled += 1;
+        else
+            counts.pending += 1;
+    }
+    return counts;
+}
+function phaseState(runState, counts, isLatest) {
+    if (!isLatest)
+        return "completed";
+    if (runState === "failed")
+        return "failed";
+    if (runState === "stopped")
+        return "cancelled";
+    if (runState === "interrupted")
+        return "interrupted";
+    if (runState === "budget_exhausted")
+        return "budget_exhausted";
+    if (counts.failed > 0)
+        return "failed";
+    if (counts.cancelled > 0)
+        return "cancelled";
+    if (counts.running > 0 || counts.pending > 0)
+        return "running";
+    return runState === "completed" ? "completed" : "running";
+}
+export function buildWorkflowPhaseModel(run, source) {
+    const declaredPhases = phaseNames(source);
+    const rawHistory = Array.isArray(run.phaseHistory) ? run.phaseHistory : [];
+    const observed = [];
+    let boundary = 0;
+    for (const record of rawHistory) {
+        if (!object(record) || typeof record.phase !== "string" || !record.phase.trim() || typeof record.afterAgent !== "number" || !Number.isSafeInteger(record.afterAgent))
+            continue;
+        boundary = Math.max(boundary, Math.min(run.agents.length, Math.max(0, record.afterAgent)));
+        observed.push({ name: record.phase.trim(), afterAgent: boundary });
+    }
+    if (!observed.length && typeof run.phase === "string" && run.phase.trim())
+        observed.push({ name: run.phase.trim(), afterAgent: 0 });
+    const observedEntries = observed.map((entry, index) => ({ ...entry, index, agents: run.agents.slice(entry.afterAgent, observed[index + 1]?.afterAgent ?? run.agents.length) }));
+    const matchedDeclarations = new Set();
+    const declarationIndices = observedEntries.map((entry) => {
+        const index = declaredPhases.findIndex((name, candidate) => !matchedDeclarations.has(candidate) && name === entry.name);
+        if (index >= 0)
+            matchedDeclarations.add(index);
+        return index >= 0 ? index : undefined;
+    });
+    const entries = observedEntries.map((entry, index) => ({ name: entry.name, observedIndex: index, ...(declarationIndices[index] === undefined ? {} : { declarationIndex: declarationIndices[index] }) }));
+    for (const [declarationIndex, name] of declaredPhases.entries()) {
+        if (matchedDeclarations.has(declarationIndex))
+            continue;
+        const insertion = entries.findIndex((entry) => entry.declarationIndex !== undefined && entry.declarationIndex > declarationIndex);
+        const pending = { name };
+        if (insertion < 0)
+            entries.push(pending);
+        else
+            entries.splice(insertion, 0, pending);
+    }
+    const occurrences = new Map();
+    const phases = entries.map((entry) => {
+        const occurrence = (occurrences.get(entry.name) ?? 0) + 1;
+        occurrences.set(entry.name, occurrence);
+        const observation = entry.observedIndex === undefined ? undefined : observedEntries[entry.observedIndex];
+        const agents = observation?.agents ?? [];
+        const counts = phaseAgentCounts(agents);
+        const state = observation ? phaseState(run.state, counts, entry.observedIndex === observedEntries.length - 1) : "not started";
+        return { id: `${entry.name}#${String(occurrence)}`, name: entry.name, occurrence, state, observed: observation !== undefined, ...(observation ? { afterAgent: observation.afterAgent } : {}), agents, counts };
+    });
+    let currentPhaseIndex;
+    for (let index = phases.length - 1; index >= 0; index -= 1) {
+        if (phases[index]?.observed) {
+            currentPhaseIndex = index;
+            break;
+        }
+    }
+    const counts = {};
+    for (const phase of phases)
+        counts[phase.state] = (counts[phase.state] ?? 0) + 1;
+    const current = currentPhaseIndex === undefined ? undefined : phases[currentPhaseIndex];
+    const assigned = new Set(observedEntries.flatMap(({ agents }) => agents.map((agent) => agent.id)));
+    const unassignedAgents = run.agents.filter((agent) => !assigned.has(agent.id));
+    const result = { declaredPhases, phases, counts };
+    if (current !== undefined && currentPhaseIndex !== undefined) {
+        result.currentPhaseIndex = currentPhaseIndex;
+        result.currentPhaseId = current.id;
+    }
+    if (unassignedAgents.length)
+        result.unassignedAgents = unassignedAgents;
+    return result;
+}
+function workflowPhaseTreePath(kind, phaseId, operationPath, agentId) {
+    const root = `phase/${encodeURIComponent(phaseId)}`;
+    if (kind === "phase")
+        return root;
+    const operation = operationPath.map((part) => encodeURIComponent(part)).join("/");
+    if (kind === "operation")
+        return `${root}/operation/${operation}`;
+    return operation ? `${root}/operation/${operation}/agent/${encodeURIComponent(agentId ?? "")}` : `${root}/agent/${encodeURIComponent(agentId ?? "")}`;
+}
+function workflowPhaseTreeAggregateState(states) {
+    if (!states.length || states.every((state) => state === "completed"))
+        return "completed";
+    if (states.some((state) => state === "failed"))
+        return "failed";
+    if (states.some((state) => state === "cancelled"))
+        return "cancelled";
+    if (states.some((state) => state === "running"))
+        return "running";
+    return "queued";
+}
+export function buildWorkflowPhaseTree(model) {
+    const drafts = new Map();
+    const roots = [];
+    const add = (node, parentId) => {
+        const existing = drafts.get(node.id);
+        if (existing)
+            return existing;
+        const draft = { ...node, ...(parentId === undefined ? {} : { parentId }), children: [] };
+        drafts.set(draft.id, draft);
+        if (parentId === undefined)
+            roots.push(draft.id);
+        else
+            drafts.get(parentId)?.children.push(draft.id);
+        return draft;
+    };
+    const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+    const addPhase = (phaseId, label, agents, phase) => {
+        const phaseNode = add({ id: workflowPhaseTreePath("phase", phaseId, []), kind: "phase", label, depth: 0, phaseId, operationPath: [], state: phase?.state ?? workflowPhaseTreeAggregateState(agents.map((agent) => agent.state)), ...(phase ? { phase } : {}) });
+        const operationNodes = new Map();
+        const entries = agents.map((agent) => ({ agent, path: [...(agent.structuralPath ?? [])], node: undefined, defaultParentId: phaseNode.id }));
+        const agentEntries = new Map(entries.map((entry) => [entry.agent.id, entry]));
+        const acceptedParents = new Map();
+        const wouldCycle = (childId, parentId) => {
+            const seen = new Set([childId]);
+            let current = parentId;
+            while (current) {
+                if (seen.has(current))
+                    return true;
+                seen.add(current);
+                current = acceptedParents.get(current);
+            }
+            return false;
+        };
+        for (const entry of entries) {
+            const parent = entry.agent.parentId ? agentEntries.get(entry.agent.parentId) : undefined;
+            if (parent && !wouldCycle(entry.agent.id, parent.agent.id))
+                acceptedParents.set(entry.agent.id, parent.agent.id);
+        }
+        const operationChain = (path, owner, startIndex = 0) => {
+            let parent = owner;
+            for (let index = startIndex; index < path.length; index += 1) {
+                const prefix = path.slice(0, index + 1);
+                const key = `${owner.id}:${JSON.stringify(prefix)}`;
+                const existing = operationNodes.get(key);
+                if (existing) {
+                    parent = existing;
+                    continue;
+                }
+                const suffix = path.slice(startIndex, index + 1).map((part) => encodeURIComponent(part)).join("/");
+                const id = owner.id === phaseNode.id ? workflowPhaseTreePath("operation", phaseId, prefix) : `${owner.id}/operation/${suffix}`;
+                const operation = add({ id, kind: "operation", label: prefix.at(-1) ?? "", depth: 0, phaseId, operationPath: prefix, state: "queued", ...(phase ? { phase } : {}) }, parent.id);
+                operationNodes.set(key, operation);
+                parent = operation;
+            }
+            return parent;
+        };
+        for (const entry of entries) {
+            if (!acceptedParents.has(entry.agent.id))
+                entry.defaultParentId = operationChain(entry.path, phaseNode).id;
+        }
+        for (const entry of entries) {
+            entry.node = add({ id: workflowPhaseTreePath("agent", phaseId, entry.path, entry.agent.id), kind: "agent", label: entry.agent.label ?? entry.agent.name, depth: 0, phaseId, operationPath: entry.path, state: entry.agent.state, agentId: entry.agent.id, agent: entry.agent }, phaseNode.id);
+        }
+        const attach = (entry, parentId) => {
+            const previous = entry.node.parentId ? drafts.get(entry.node.parentId) : undefined;
+            if (previous)
+                previous.children = previous.children.filter((childId) => childId !== entry.node.id);
+            entry.node.parentId = parentId;
+            const parent = drafts.get(parentId);
+            if (parent && !parent.children.includes(entry.node.id))
+                parent.children.push(entry.node.id);
+        };
+        for (const entry of entries) {
+            const parentId = acceptedParents.get(entry.agent.id);
+            const parent = parentId ? agentEntries.get(parentId) : undefined;
+            if (parent) {
+                if (samePath(entry.path, parent.path))
+                    entry.defaultParentId = parent.node.id;
+                else {
+                    const commonLength = entry.path.findIndex((part, index) => parent.path[index] !== part);
+                    const startIndex = commonLength < 0 ? Math.min(entry.path.length, parent.path.length) : commonLength;
+                    entry.defaultParentId = operationChain(entry.path, parent.node, startIndex).id;
+                }
+            }
+            attach(entry, entry.defaultParentId);
+        }
+        const setDepth = (node, depth, seen = new Set()) => {
+            if (seen.has(node.id))
+                return;
+            seen.add(node.id);
+            node.depth = depth;
+            for (const childId of node.children) {
+                const child = drafts.get(childId);
+                if (child)
+                    setDepth(child, depth + 1, seen);
+            }
+        };
+        setDepth(phaseNode, 0);
+        const statesFor = (node, seen = new Set()) => {
+            if (seen.has(node.id))
+                return [];
+            const nextSeen = new Set(seen).add(node.id);
+            return node.children.flatMap((childId) => {
+                const child = drafts.get(childId);
+                return child?.kind === "agent" ? [child.agent?.state ?? "queued", ...statesFor(child, nextSeen)] : child ? statesFor(child, nextSeen) : [];
+            });
+        };
+        for (const operation of operationNodes.values())
+            operation.state = workflowPhaseTreeAggregateState(statesFor(operation));
+    };
+    for (const phase of model.phases)
+        addPhase(phase.id, `${phase.name}${phase.occurrence > 1 ? ` #${String(phase.occurrence)}` : ""}`, phase.agents, phase);
+    if (model.unassignedAgents?.length)
+        addPhase("unassigned", "Unassigned", model.unassignedAgents);
+    const nodes = [...drafts.values()].map((node) => ({ ...node, children: [...node.children] }));
+    return { roots, nodes, byId: new Map(nodes.map((node) => [node.id, node])) };
+}
+export function workflowPhaseTreeVisibleNodes(tree, expanded = new Set()) {
+    const visible = [];
+    const visit = (id) => {
+        const node = tree.byId.get(id);
+        if (!node)
+            return;
+        visible.push(node);
+        if (expanded.has(node.id))
+            for (const childId of node.children)
+                visit(childId);
+    };
+    for (const root of tree.roots)
+        visit(root);
+    return visible;
+}
+export function workflowPhaseTreeInitialExpanded(tree) {
+    return new Set(tree.nodes.filter((node) => node.children.length > 0).map((node) => node.id));
+}
+export function preserveWorkflowPhaseTreeSelection(tree, selection) {
+    const node = (selection.nodeId ? tree.byId.get(selection.nodeId) : undefined) ?? tree.nodes[0];
+    return node ? { nodeId: node.id } : {};
+}
+export function navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, direction) {
+    const expanded = new Set(expandedNodeIds);
+    const current = (selectedNodeId ? tree.byId.get(selectedNodeId) : undefined) ?? tree.nodes[0];
+    if (!current)
+        return { expandedNodeIds: expanded };
+    if (direction === "left") {
+        if (current.children.length && expanded.delete(current.id))
+            return { nodeId: current.id, expandedNodeIds: expanded };
+        return { nodeId: current.parentId ?? current.id, expandedNodeIds: expanded };
+    }
+    if (direction === "right") {
+        if (current.children.length && !expanded.has(current.id)) {
+            expanded.add(current.id);
+            return { nodeId: current.id, expandedNodeIds: expanded };
+        }
+        return { nodeId: current.children[0] ?? current.id, expandedNodeIds: expanded };
+    }
+    const visible = workflowPhaseTreeVisibleNodes(tree, expanded);
+    const index = Math.max(0, visible.findIndex((node) => node.id === current.id));
+    const next = visible[(index + (direction === "up" ? visible.length - 1 : 1)) % visible.length];
+    return { nodeId: next?.id ?? current.id, expandedNodeIds: expanded };
+}
+export function preserveWorkflowPhaseSelection(model, selection) {
+    const phase = model.phases.find((candidate) => candidate.id === selection.phaseId) ?? (model.currentPhaseIndex === undefined ? undefined : model.phases[model.currentPhaseIndex]) ?? model.phases[0];
+    if (!phase)
+        return model.unassignedAgents?.length ? { nodeId: workflowPhaseTreePath("phase", "unassigned", []) } : {};
+    const tree = buildWorkflowPhaseTree(model);
+    const selectedAgent = selection.agentId ? phase.agents.find((candidate) => candidate.id === selection.agentId) : undefined;
+    const selectedCandidate = selection.nodeId ? tree.byId.get(selection.nodeId) : undefined;
+    const selected = selectedCandidate?.phaseId === phase.id ? selectedCandidate : selectedAgent ? tree.byId.get(workflowPhaseTreePath("agent", phase.id, selectedAgent.structuralPath ?? [], selectedAgent.id)) : undefined;
+    const nodeId = selected?.id ?? tree.byId.get(workflowPhaseTreePath("phase", phase.id, []))?.id;
+    return { phaseId: phase.id, ...(selection.agentId && phase.agents.some((agent) => agent.id === selection.agentId) ? { agentId: selection.agentId } : phase.agents[0] ? { agentId: phase.agents[0].id } : {}), ...(nodeId ? { nodeId } : {}), ...(selection.expandedNodeIds ? { expandedNodeIds: selection.expandedNodeIds } : {}) };
+}
 function agentGroupKey(agent) { return JSON.stringify([agent.structuralPath ?? [], agent.parentBreadcrumb ?? null]); }
 function agentGroupLabel(agents) {
     const structural = agents[0]?.structuralPath ?? [];
@@ -171,8 +511,13 @@ function agentGroups(agents, allAgents = agents) {
     const groups = new Map();
     for (const [index, agent] of agents.entries()) {
         let depth = 0;
-        for (let parent = agent.parentId; parent && byId.has(parent); parent = byId.get(parent)?.parentId)
+        const seen = new Set([agent.id]);
+        for (let parent = agent.parentId; parent && byId.has(parent); parent = byId.get(parent)?.parentId) {
+            if (seen.has(parent))
+                break;
+            seen.add(parent);
             depth += 1;
+        }
         const key = agentGroupKey(agent);
         const group = groups.get(key) ?? { agents: [] };
         group.agents.push({ agent, index, depth });
@@ -188,26 +533,31 @@ function renderGroupedAgents(agents, render, allAgents = agents, groupLabel = (l
         ...group.entries.map((entry) => render(entry, grouped)),
     ]);
 }
-function progressStyleForState(state, styles) {
-    if (state === "completed")
-        return (text) => styles.success(text);
-    if (state === "failed" || state === "cancelled")
-        return (text) => styles.error(text);
-    if (state === "running")
-        return (text) => styles.accent(text);
-    return (text) => styles.muted(text);
+const RUN_STATE_GLYPH = { completed: "✓", failed: "✗", stopped: "✗", budget_exhausted: "!", awaiting_input: "●" };
+const AGENT_STATE_GLYPH = { completed: "✓", failed: "✗", cancelled: "✗" };
+function runStateGlyph(state, running) { return state === "running" ? running : RUN_STATE_GLYPH[state] ?? "◆"; }
+function agentStateGlyph(state, running) { return state === "running" ? running : AGENT_STATE_GLYPH[state] ?? "○"; }
+const PROGRESS_STATE_STYLE = { completed: "success", failed: "error", cancelled: "error", running: "accent" };
+const WORKFLOW_ICON_STYLE = { completed: "success", failed: "error", stopped: "error", budget_exhausted: "warning", running: "accent" };
+const PHASE_STATE_STYLE = { completed: "success", failed: "error", cancelled: "error", running: "accent", interrupted: "warning", budget_exhausted: "warning" };
+function styleForState(map, state, styles) {
+    const key = map[state] ?? "muted";
+    return (text) => styles[key](text);
 }
+function progressStyleForState(state, styles) { return styleForState(PROGRESS_STATE_STYLE, state, styles); }
+function workflowIconStyle(state, styles) { return styleForState(WORKFLOW_ICON_STYLE, state, styles); }
+function phaseStyleForState(state, styles) { return styleForState(PHASE_STATE_STYLE, state, styles); }
 export function formatWorkflowProgress(run, spinner = "◇", styles = PLAIN_WORKFLOW_PROGRESS_STYLES) {
     const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
-    const workflowIcon = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "budget_exhausted" ? "!" : run.state === "running" ? spinner : "◆";
-    const workflowIconStyle = run.state === "completed" ? (text) => styles.success(text) : run.state === "failed" || run.state === "stopped" ? (text) => styles.error(text) : run.state === "budget_exhausted" ? (text) => styles.warning(text) : run.state === "running" ? (text) => styles.accent(text) : (text) => styles.muted(text);
+    const workflowIcon = runStateGlyph(run.state, spinner);
+    const iconStyle = workflowIconStyle(run.state, styles);
     const header = styles.bold(styles.accent(`Workflow: ${run.workflowName} (${String(done)}/${String(run.agents.length)} done)`));
-    const lines = [`${workflowIconStyle(workflowIcon)} ${header}`];
+    const lines = [`${iconStyle(workflowIcon)} ${header}`];
     const budgetWarning = run.state === "budget_exhausted" || (run.budgetEvents ?? []).some((event) => event.type === "hard_exhausted");
     lines.push(...formatCompactBudgetStatus(run).map((line) => `  ${budgetWarning ? styles.warning(line) : line}`));
     const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
     const renderAgents = (agents, offset, nested) => renderGroupedAgents(agents, ({ agent, index, depth }, grouped) => {
-        const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? spinner : "○";
+        const icon = agentStateGlyph(agent.state, spinner);
         const indent = "  ".repeat((grouped ? 2 : 1) + depth);
         const activity = SETTLED_AGENT_STATES.has(agent.state) ? "" : formatAgentActivity(agent, spinner, styles);
         const name = grouped ? agent.label ?? agent.name : styledAgentBreadcrumb(agent, byId, styles);
@@ -239,7 +589,200 @@ function textBlock(text) {
         invalidate() { },
     };
 }
-const ANSI_SGR = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`);
+function styledTextBlock(text) {
+    return {
+        render(width) {
+            return truncateWorkflowProgress(text, width);
+        },
+        invalidate() { },
+    };
+}
+function workflowCatalogBlock(text, expanded) {
+    return {
+        render(width) {
+            const safeWidth = Math.max(1, width);
+            if (!expanded)
+                return truncateWorkflowProgress(text, safeWidth);
+            return truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, safeWidth, 0).visualLines.map((line) => line.trimEnd());
+        },
+        invalidate() { },
+    };
+}
+function controlString(value) { return typeof value === "string" && value.trim() ? value : undefined; }
+function controlValue(value) {
+    if (value === null)
+        return "removed";
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    const json = JSON.stringify(value);
+    return typeof json === "string" ? json : "unknown";
+}
+function controlTitle(name, theme) { return theme.fg("toolTitle", theme.bold(name)); }
+function controlState(state, theme) {
+    const color = state === "completed" || state === "running" || state === "stopped" ? "success" : state === "failed" || state === "unknown" ? "error" : state === "budget_exhausted" || state === "awaiting_approval" ? "warning" : "accent";
+    return theme.fg(color, state);
+}
+function controlAction(action, theme) {
+    const color = /approved|stopped|started|resumed/.test(action) ? "success" : /rejected|failed/.test(action) ? "error" : "warning";
+    return theme.fg(color, action);
+}
+function budgetPatchEntries(value) {
+    if (!object(value))
+        return value === undefined ? [] : [controlValue(value)];
+    return Object.entries(value).map(([dimension, limits]) => {
+        if (limits === null)
+            return `${dimension}=removed`;
+        if (!object(limits))
+            return `${dimension}=${controlValue(limits)}`;
+        const parts = ["soft", "hard"].filter((key) => Object.prototype.hasOwnProperty.call(limits, key)).map((key) => `${key}=${controlValue(limits[key])}`);
+        return `${dimension} ${parts.join(" ")}`;
+    });
+}
+function budgetPatchSummary(value) {
+    const entries = budgetPatchEntries(value);
+    return entries.length ? entries.join(", ") : "unchanged";
+}
+function budgetPatchDetails(value, theme) {
+    const entries = budgetPatchEntries(value);
+    return entries.length ? [theme.fg("accent", theme.bold("Budget patch")), ...entries.map((entry) => `  ${theme.fg("toolOutput", entry)}`)] : [];
+}
+function workflowControlValue(result) { return catalogResultValue(result); }
+function workflowControlCall(name, args, theme) {
+    const runId = controlString(args.runId) ?? "(missing run ID)";
+    if (name === "workflow_respond") {
+        const proposalId = controlString(args.proposalId);
+        const target = proposalId ? `budget proposal ${proposalId}` : `checkpoint ${controlString(args.name) ?? "(missing name)"}`;
+        const decision = args.approved === true ? "approve" : "reject";
+        return [`${controlTitle(name, theme)} ${theme.fg("accent", runId)}`, `${theme.fg("muted", target)} · ${controlAction(decision, theme)}`].join("\n");
+    }
+    if (name === "workflow_resume")
+        return args.budget === undefined ? `${controlTitle(name, theme)} ${theme.fg("accent", runId)}` : [`${controlTitle(name, theme)} ${theme.fg("accent", runId)}`, `${theme.fg("muted", "Budget")} ${theme.fg("toolOutput", budgetPatchSummary(args.budget))}`].join("\n");
+    if (name === "workflow_retry")
+        return `${controlTitle(name, theme)} ${theme.fg("accent", runId)} ${theme.fg("muted", "failed run")}`;
+    return `${controlTitle(name, theme)} ${theme.fg("accent", runId)}`;
+}
+function workflowControlResult(name, args, result, expanded, theme, isError) {
+    if (isError) {
+        const text = result.content?.filter(({ type }) => type === "text").map(({ text }) => text ?? "").join("\n").trim();
+        return theme.fg("error", text || `The ${name} tool failed.`);
+    }
+    const value = workflowControlValue(result);
+    if (!object(value))
+        return theme.fg("error", `The ${name} tool returned an invalid result.`);
+    const runId = controlString(args.runId) ?? controlString(value.runId) ?? "(unknown)";
+    const title = controlTitle(name, theme);
+    if (name === "workflow_stop") {
+        const state = controlString(value.state) ?? "unknown";
+        const action = value.stopped === true ? "stopped" : value.reason === "already_terminal" ? "already terminal" : value.reason === "unknown_run" ? "run not found" : "no change";
+        if (!expanded)
+            return `${title}\nRun ${theme.fg("accent", runId)} · ${controlState(state, theme)} · ${controlAction(action, theme)}`;
+        return [title, `Run: ${theme.fg("accent", runId)}`, `State: ${controlState(state, theme)}`, `Action: ${controlAction(action, theme)}`, ...(controlString(value.reason) ? [`Reason: ${theme.fg("toolOutput", controlValue(value.reason))}`] : [])].join("\n");
+    }
+    if (name === "workflow_retry") {
+        const childRunId = controlString(value.runId) ?? "(unknown)";
+        const state = controlString(value.state) ?? "unknown";
+        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");
+    }
+    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";
+        if (!expanded)
+            return [title, `Run ${theme.fg("accent", runId)} · ${controlState(state, theme)} · ${controlAction(action, theme)}`, ...(proposalId ? [`Proposal ${theme.fg("accent", proposalId)}`] : [])].join("\n");
+        return [title, `Run: ${theme.fg("accent", runId)}`, `State: ${controlState(state, theme)}`, `Action: ${controlAction(action, theme)}`, ...(proposalId ? [`Proposal: ${theme.fg("accent", proposalId)}`] : []), ...budgetPatchDetails(args.budget, theme)].join("\n");
+    }
+    const proposalId = controlString(args.proposalId);
+    const checkpointName = controlString(args.name);
+    const target = proposalId ? `Budget proposal ${theme.fg("accent", proposalId)}` : `Checkpoint ${theme.fg("accent", checkpointName ?? "(missing)")}`;
+    const accepted = value.accepted === true;
+    const approved = value.approved === true;
+    const reason = controlString(value.reason);
+    const action = reason === "proposal_not_pending" ? "not pending" : reason === "checkpoint" && !accepted ? "not pending" : approved ? "approved" : "rejected";
+    const state = controlString(value.state);
+    if (!expanded)
+        return [title, target, `Run ${theme.fg("accent", runId)} · ${controlAction(action, theme)}${state ? ` · ${controlState(state, theme)}` : ""}`].join("\n");
+    return [title, `Run: ${theme.fg("accent", runId)}`, `Target: ${target}`, `Action: ${controlAction(action, theme)}`, ...(state ? [`State: ${controlState(state, theme)}`] : []), ...(reason ? [`Reason: ${theme.fg("toolOutput", reason)}`] : [])].join("\n");
+}
+function catalogText(value) { return value.replace(/\s+/g, " ").trim(); }
+function catalogResultValue(result) {
+    if (result.details !== undefined)
+        return result.details;
+    const text = result.content?.find((entry) => entry.type === "text")?.text;
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function isCatalogIndex(value) {
+    return object(value) && Array.isArray(value.functions) && Array.isArray(value.variables);
+}
+function isCatalogFunction(value) {
+    return object(value) && typeof value.name === "string" && typeof value.description === "string" && object(value.input) && object(value.output);
+}
+function isCatalogVariable(value) {
+    return object(value) && typeof value.name === "string" && typeof value.description === "string" && object(value.schema);
+}
+function isCatalogError(value) {
+    return object(value) && object(value.error) && typeof value.error.message === "string";
+}
+function catalogSectionTitle(label, count, theme) {
+    return theme.fg("accent", theme.bold(`${label} (${String(count)})`));
+}
+function catalogIndexEntries(entries, theme) {
+    const width = Math.max(0, ...entries.map((entry) => entry.name.length));
+    return entries.map((entry) => `  ${theme.fg("accent", entry.name.padEnd(width))}  ${theme.fg("toolOutput", catalogText(entry.description))}`);
+}
+function formatCatalogIndex(catalog, theme) {
+    const aliases = Object.prototype.propertyIsEnumerable.call(catalog, "modelAliases") ? Object.keys(catalog.modelAliases ?? {}).sort().map((name) => ({ name, kind: "static", provenance: "settings" })) : catalog.modelAliasEntries ?? Object.keys(catalog.modelAliases ?? {}).sort().map((name) => ({ name, kind: "static", provenance: "settings" }));
+    const aliasWidth = Math.max(0, ...aliases.map(({ name }) => name.length));
+    const aliasLines = aliases.map(({ name, kind, provenance }) => `  ${theme.fg("accent", name.padEnd(aliasWidth))}  ${theme.fg("toolOutput", `${kind} · ${provenance}`)}`);
+    return [
+        catalogSectionTitle("Functions", catalog.functions.length, theme),
+        ...catalogIndexEntries(catalog.functions, theme),
+        "",
+        catalogSectionTitle("Variables", catalog.variables.length, theme),
+        ...catalogIndexEntries(catalog.variables, theme),
+        "",
+        catalogSectionTitle("Model aliases", aliases.length, theme),
+        ...aliasLines,
+    ].join("\n");
+}
+function catalogSchemaLines(schema, theme) {
+    const json = JSON.stringify(schema, null, 2);
+    return json.split("\n").map((line) => `  ${theme.fg("toolOutput", line)}`);
+}
+function formatCatalogDetail(value, expanded, theme) {
+    if ("kind" in value)
+        return [theme.fg("accent", theme.bold("Model alias")), `  ${theme.fg("accent", value.name)}  ${theme.fg("toolOutput", `${value.kind} · ${value.provenance}`)}`].join("\n");
+    const kind = "input" in value ? "Function" : "Variable";
+    if (!expanded)
+        return [theme.fg("accent", theme.bold(kind)), `  ${theme.fg("accent", value.name)}  ${theme.fg("toolOutput", catalogText(value.description))}`, `  ${theme.fg("muted", "version")}: ${theme.fg("toolOutput", value.version)}  ${theme.fg("muted", "headline")}: ${theme.fg("toolOutput", catalogText(value.headline))}`].join("\n");
+    const lines = [theme.fg("accent", theme.bold(`${kind}: ${value.name}`)), `${theme.fg("muted", "description")}: ${theme.fg("toolOutput", value.description)}`, "", theme.fg("accent", theme.bold("Extension")), `  ${theme.fg("muted", "version")}: ${theme.fg("toolOutput", value.version)}`, `  ${theme.fg("muted", "headline")}: ${theme.fg("toolOutput", value.headline)}`, `  ${theme.fg("muted", "description")}: ${theme.fg("toolOutput", value.extensionDescription)}`, "", theme.fg("accent", theme.bold("Schema"))];
+    if ("input" in value)
+        lines.push(theme.fg("muted", "Input schema"), ...catalogSchemaLines(value.input, theme), "", theme.fg("muted", "Output schema"), ...catalogSchemaLines(value.output, theme));
+    else
+        lines.push(theme.fg("muted", "Variable schema"), ...catalogSchemaLines(value.schema, theme));
+    return lines.join("\n");
+}
+function formatWorkflowCatalog(value, expanded, theme) {
+    if (isCatalogIndex(value))
+        return formatCatalogIndex(value, theme);
+    if (isCatalogFunction(value) || isCatalogVariable(value))
+        return formatCatalogDetail(value, expanded, theme);
+    if (object(value) && typeof value.name === "string" && (value.kind === "static" || value.kind === "dynamic"))
+        return formatCatalogDetail(value, expanded, theme);
+    if (isCatalogError(value))
+        return theme.fg("error", value.error.message);
+    return theme.fg("error", "The workflow catalog returned an invalid result.");
+}
+const ANSI_SGR_SOURCE = `${String.fromCharCode(27)}\\[[0-9;]*m`;
+const ANSI_SGR = new RegExp(ANSI_SGR_SOURCE);
 export function truncateWorkflowProgress(text, width) {
     const safeWidth = Math.max(1, width);
     return text.split("\n").flatMap((line) => {
@@ -263,7 +806,7 @@ function themeWorkflowProgressStyles(theme) {
         warning: (text) => theme.fg("warning", text),
         muted: (text) => theme.fg("muted", text),
         dim: (text) => theme.fg("dim", text),
-        bold: (text) => theme.bold(text),
+        bold: (text) => typeof theme.bold === "function" ? theme.bold(text) : text,
     };
 }
 function workflowProgressBlock(run, theme) {
@@ -310,39 +853,40 @@ function navigatorRunLabels(entries) {
         nameCount.set(run.workflowName, (nameCount.get(run.workflowName) ?? 0) + 1);
     return entries.map(({ store, loaded: { run } }) => {
         const done = run.agents.filter((a) => SETTLED_AGENT_STATES.has(a.state)).length;
-        const glyph = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "budget_exhausted" ? "!" : run.state === "running" ? "⠦" : run.state === "awaiting_input" ? "●" : "◆";
+        const glyph = runStateGlyph(run.state, "⠦");
         const suffix = (nameCount.get(run.workflowName) ?? 0) > 1 ? ` ${store.runId.slice(0, 8)}` : "";
         const cost = run.agents.reduce((sum, a) => sum + (a.accounting?.cost ?? 0), 0);
         const costStr = cost > 0 ? ` $${cost.toFixed(2)}` : "";
         return `${glyph} ${run.workflowName}${suffix}  ${run.state}  ${run.phase ?? ""}  ${String(done)}/${String(run.agents.length)} agents${costStr}`;
     });
 }
-function agentBreadcrumbParts(agent, byId) {
-    const name = agent.label ?? agent.name;
-    const parts = agent.parentBreadcrumb ? [agent.parentBreadcrumb] : [];
+export function agentBreadcrumbParts(agent, byId, includeStructuralPath = false) {
+    const leaf = agent.label ?? agent.name;
+    const parts = includeStructuralPath && agent.structuralPath?.length ? [agent.structuralPath.join(" > ")] : [];
+    if (agent.parentBreadcrumb)
+        parts.push(agent.parentBreadcrumb);
+    const ancestors = [];
     const seen = new Set([agent.id]);
     for (let parentId = agent.parentId; parentId; parentId = byId.get(parentId)?.parentId) {
         if (seen.has(parentId))
-            break; // ponytail: cycle guard for corrupt data
+            break;
         seen.add(parentId);
         const parent = byId.get(parentId);
-        if (parent)
-            parts.push(parent.label ?? parent.name);
-        else
+        if (!parent)
             break;
+        ancestors.push(parent.label ?? parent.name);
     }
-    parts.push(name);
+    parts.push(...ancestors.reverse(), leaf);
     return parts;
 }
-function agentBreadcrumb(agent, byId) {
-    const parts = agentBreadcrumbParts(agent, byId);
-    return parts.length > 1 ? parts.join(" > ") : parts[0] ?? "";
+export function agentBreadcrumb(agent, byId, includeStructuralPath = false) {
+    return agentBreadcrumbParts(agent, byId, includeStructuralPath).join(" > ");
 }
 function styledAgentBreadcrumb(agent, byId, styles) {
     const parts = agentBreadcrumbParts(agent, byId);
     if (parts.length <= 1)
         return parts[0] ?? "";
-    return `${styles.muted(parts.slice(0, -1).join(" > "))} > ${parts[parts.length - 1] ?? ""}`;
+    return `${styles.muted(parts.slice(0, -1).join(" > "))} > ${styles.bold(parts[parts.length - 1] ?? "")}`;
 }
 function formatAgentActivity(agent, spinner, styles = PLAIN_WORKFLOW_PROGRESS_STYLES) {
     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 ?? "";
@@ -357,7 +901,7 @@ export function formatNavigatorDashboard(run, checkpoints, worktrees) {
     const done = run.agents.filter((a) => SETTLED_AGENT_STATES.has(a.state)).length;
     const totalAccounting = run.agents.reduce((sum, a) => ({ input: sum.input + (a.accounting?.input ?? 0), output: sum.output + (a.accounting?.output ?? 0), cacheRead: sum.cacheRead + (a.accounting?.cacheRead ?? 0), cacheWrite: sum.cacheWrite + (a.accounting?.cacheWrite ?? 0), cost: sum.cost + (a.accounting?.cost ?? 0) }), { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 });
     const hasAccounting = run.agents.some((a) => a.accounting);
-    const glyph = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "budget_exhausted" ? "!" : run.state === "running" ? "⠦" : run.state === "awaiting_input" ? "●" : "◆";
+    const glyph = runStateGlyph(run.state, "⠦");
     const header = `${glyph} ${run.workflowName}`;
     const meta = [run.state, run.phase ? `phase: ${run.phase}` : "", `${String(done)}/${String(run.agents.length)} agents`, hasAccounting ? formatAccounting(totalAccounting) : "", totalAccounting.cost > 0 ? `$${totalAccounting.cost.toFixed(2)}` : ""].filter(Boolean).join(" · ");
     const lines = [header, meta, ...formatCompactBudgetStatus(run)];
@@ -368,7 +912,7 @@ export function formatNavigatorDashboard(run, checkpoints, worktrees) {
     lines.push("");
     const byId = new Map(run.agents.map((a) => [a.id, a]));
     const render = ({ agent, depth }, grouped) => {
-        const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? "⠦" : "○";
+        const icon = agentStateGlyph(agent.state, "⠦");
         const breadcrumb = grouped ? agent.label ?? agent.name : agentBreadcrumb(agent, byId);
         const tokens = agent.accounting ? formatAccounting(agent.accounting) : "";
         const indent = "  ".repeat((grouped ? 2 : 1) + depth);
@@ -391,7 +935,7 @@ export function formatNavigatorDashboard(run, checkpoints, worktrees) {
     }
     return lines.join("\n");
 }
-export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
+export function formatNavigatorRun(loaded, checkpoints, worktrees) {
     const { run, snapshot } = loaded;
     const lines = [
         `Workflow: ${run.workflowName}`,
@@ -401,6 +945,7 @@ export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
         `Launch cwd: ${run.cwd}`,
         ...formatCompactBudgetStatus(run),
         `Launch models: ${snapshot.models.join(", ") || "(none)"}`,
+        `Settings: concurrency=${String(snapshot.settings.concurrency)}`,
     ];
     if (run.error)
         lines.push(`Run error: ${run.error.code}: ${run.error.message}`);
@@ -409,6 +954,8 @@ export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
     const aliases = snapshot.modelAliases ?? snapshot.settings.modelAliases;
     if (aliases && Object.keys(aliases).length)
         lines.push(`Model aliases: ${Object.entries(aliases).map(([name, target]) => `${name}=${target}`).join(", ")}`);
+    if (snapshot.settingsSources)
+        lines.push(`Settings sources: concurrency=${snapshot.settingsSources.concurrency}, modelAliases=${snapshot.settingsSources.modelAliases}, disabledAgentResources=${snapshot.settingsSources.disabledAgentResources}`);
     lines.push("Agents / ownership:");
     if (!run.agents.length)
         lines.push("  (none)");
@@ -431,10 +978,115 @@ export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
         lines.push("  (none)");
     for (const checkpoint of checkpoints)
         lines.push(`  ${checkpoint.name}: ${checkpoint.prompt} context=${JSON.stringify(checkpoint.context)}`);
-    lines.push(`Worktrees: ${String(_worktrees.length)}`);
+    lines.push(`Worktrees: ${String(worktrees.length)}`);
     lines.push(`Native Pi transcripts: ${String(run.nativeSessions.length)}`);
     return lines.join("\n");
 }
+export function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {}, styles = PLAIN_WORKFLOW_PROGRESS_STYLES) {
+    const safeWidth = Math.max(1, width);
+    const model = buildWorkflowPhaseModel(run, snapshot);
+    const tree = buildWorkflowPhaseTree(model);
+    const expanded = selection.expandedNodeIds === undefined ? workflowPhaseTreeInitialExpanded(tree) : new Set(selection.expandedNodeIds);
+    const wrap = (text, limit = safeWidth) => truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, Math.max(1, limit), 0).visualLines.map((line) => line.trimEnd());
+    // ponytail: ANSI-only width, good enough for the ASCII labels the tree renders
+    const ansiPattern = new RegExp(ANSI_SGR_SOURCE, "g");
+    const visibleLength = (text) => text.replace(ansiPattern, "").length;
+    const padTo = (text, limit) => `${text}${" ".repeat(Math.max(0, limit - visibleLength(text)))}`;
+    const phaseStyle = (state) => phaseStyleForState(state, styles);
+    const phase = selection.phaseId ? model.phases.find((candidate) => candidate.id === selection.phaseId) : undefined;
+    const selectedByAgent = selection.agentId ? tree.nodes.find((node) => node.kind === "agent" && node.agentId === selection.agentId && (!selection.phaseId || node.phaseId === selection.phaseId)) : undefined;
+    const selectedNode = (selection.nodeId ? tree.byId.get(selection.nodeId) : undefined) ?? selectedByAgent ?? (phase ? tree.byId.get(workflowPhaseTreePath("phase", phase.id, [])) : undefined) ?? (model.currentPhaseId ? tree.byId.get(workflowPhaseTreePath("phase", model.currentPhaseId, [])) : undefined) ?? tree.nodes[0];
+    const selectedPhase = selectedNode?.phase ?? (selectedNode ? model.phases.find((candidate) => candidate.id === selectedNode.phaseId) : undefined);
+    const visibleNodes = workflowPhaseTreeVisibleNodes(tree, expanded);
+    const nodeAgents = (node) => {
+        const agents = [];
+        const visit = (id) => {
+            const child = tree.byId.get(id);
+            if (!child)
+                return;
+            if (child.agent)
+                agents.push(child.agent);
+            else
+                for (const childId of child.children)
+                    visit(childId);
+        };
+        if (node.agent)
+            agents.push(node.agent);
+        else
+            for (const childId of node.children)
+                visit(childId);
+        return agents;
+    };
+    const nodeStatus = (node) => phaseStyle(node.state)(node.state);
+    const nodeIcon = (node) => node.children.length ? expanded.has(node.id) ? "▾" : "▸" : node.kind === "agent" ? "•" : " ";
+    const treeLine = (node) => {
+        const selected = node.id === selectedNode?.id;
+        const state = progressStyleForState(node.state, styles);
+        return `${selected ? "→" : " "} ${"  ".repeat(node.depth)}${nodeIcon(node)} ${node.label} · ${state(node.state)}`;
+    };
+    const details = (node) => {
+        if (!node)
+            return [styles.muted("No workflow node is selected")];
+        const agents = nodeAgents(node);
+        if (node.kind === "phase") {
+            const selected = node.phase;
+            const counts = selected?.counts ?? phaseAgentCounts(agents);
+            return [styles.bold(`Selected phase: ${node.label}`), `Status: ${nodeStatus(node)}`, `agents completed=${String(counts.completed)} running=${String(counts.running)} failed=${String(counts.failed)} cancelled=${String(counts.cancelled)} pending=${String(counts.pending)}`, `Agents: ${String(agents.length)}`];
+        }
+        if (node.kind === "operation") {
+            const states = phaseAgentCounts(agents);
+            return [styles.bold(`Selected operation: ${node.operationPath.join(" > ")}`), `Phase: ${node.phase?.name ?? node.phaseId}`, `Status: ${nodeStatus(node)}`, `agents completed=${String(states.completed)} running=${String(states.running)} failed=${String(states.failed)} cancelled=${String(states.cancelled)} pending=${String(states.pending)}`, `Agents: ${String(agents.length)}`];
+        }
+        const agent = node.agent;
+        if (!agent)
+            return [styles.muted("Agent details are unavailable")];
+        const byId = new Map(run.agents.map((candidate) => [candidate.id, candidate]));
+        const result = [styles.bold(`Selected agent: ${agentBreadcrumb(agent, byId, true)}`), `State: ${phaseStyle(agent.state)(agent.state)}`, `Structural path: ${agent.structuralPath?.join(" > ") || "(root)"}`, `Model: ${agent.model.provider}/${agent.model.model}${agent.model.thinking ? `:${agent.model.thinking}` : ""}`, `Role: ${agent.role ?? "(none)"}`, `Tools: ${agent.tools.join(", ") || "(none)"}`, `Attempts: ${String(agent.attempts)}`, ...(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}`);
+        return result;
+    };
+    const stateNames = ["not started", "running", "completed", "failed", "cancelled", "interrupted", "budget_exhausted"];
+    const statusSummary = stateNames.filter((state) => (model.counts[state] ?? 0) > 0).map((state) => `${String(model.counts[state])} ${state}`).join(" · ") || "0 phases";
+    const lines = [styles.bold(styles.accent(`Workflow: ${run.workflowName}`))];
+    if (run.error)
+        lines.push(styles.error(`ERROR ${run.error.code}: ${run.error.message}`));
+    lines.push(`phase: ${run.phase ?? selectedPhase?.name ?? "none"}`, `Run state: ${run.state}`, `Phases: ${statusSummary}`);
+    for (const event of run.events ?? [])
+        lines.push(styles.warning(`Warning: ${event.message}`));
+    lines.push(...formatCompactBudgetStatus(run));
+    const renderTree = (limit) => [styles.bold("Tree"), ...(visibleNodes.length ? visibleNodes.flatMap((node) => wrap(treeLine(node), limit)) : [styles.muted("(empty)")])];
+    const actionRows = () => {
+        const actions = selection.actions;
+        if (!actions)
+            return [];
+        return ["", styles.bold(actions.title), ...actions.options.map((option, index) => `${index === actions.index ? "→ " : "  "}${index === actions.index ? styles.accent(option) : option}`)];
+    };
+    const detailRows = () => [...details(selectedNode), ...actionRows()];
+    if (safeWidth >= 80) {
+        const sidebarWidth = Math.min(42, Math.max(24, Math.floor((safeWidth - 3) * 0.38)));
+        const detailWidth = Math.max(1, safeWidth - sidebarWidth - 3);
+        const sidebar = renderTree(sidebarWidth).flatMap((line) => wrap(line, sidebarWidth));
+        const detail = detailRows().flatMap((line) => wrap(line, detailWidth));
+        const rows = Math.max(sidebar.length, detail.length);
+        for (let index = 0; index < rows; index += 1)
+            lines.push(`${padTo(sidebar[index] ?? "", sidebarWidth)} | ${detail[index] ?? ""}`);
+    }
+    else if (selection.detailsOnly) {
+        lines.push(...detailRows().flatMap((line) => wrap(line)));
+    }
+    else {
+        lines.push(...renderTree(safeWidth));
+        if (!selection.treeOnly)
+            lines.push("", ...detailRows().flatMap((line) => wrap(line)));
+    }
+    if (model.unassignedAgents?.length && !tree.nodes.some((node) => node.phaseId === "unassigned"))
+        lines.push(...wrap(styles.muted(`Unassigned agents: ${String(model.unassignedAgents.length)}`)));
+    return lines.flatMap((line) => wrap(line));
+}
 function formatCheckpointReview(checkpoint) {
     const context = JSON.stringify(checkpoint.context, null, 2);
     return [`Name: ${checkpoint.name}`, "Prompt:", checkpoint.prompt, context === "null" ? "Context: null" : "Context:", ...(context === "null" ? [] : [context])].join("\n");
@@ -920,42 +1572,70 @@ function projectTrusted(ctx) {
     const check = object(ctx) ? ctx.isProjectTrusted : undefined;
     return typeof check === "function" ? Boolean(Reflect.apply(check, ctx, [])) : true;
 }
-function isEntryRenderer(value) { return typeof value === "function"; }
+function asFn(value) { return typeof value === "function" ? value : undefined; }
 function isWorkflowEventSink(value) { return object(value) && typeof value.emit === "function"; }
 function piHostCapabilities(pi) {
     if (!object(pi))
         return {};
-    const registerEntryRenderer = pi.registerEntryRenderer;
+    const registerEntryRenderer = asFn(pi.registerEntryRenderer);
     const events = pi.events;
-    return { ...(isEntryRenderer(registerEntryRenderer) ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
+    return { ...(registerEntryRenderer ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
 }
-function isModelRegistryGetter(value) { return typeof value === "function"; }
 function contextHostCapabilities(ctx) {
     if (!object(ctx) || !object(ctx.modelRegistry))
         return {};
     const registry = ctx.modelRegistry;
-    const getAll = registry.getAll;
-    const getAvailable = registry.getAvailable;
-    return { modelRegistry: { ...(isModelRegistryGetter(getAll) ? { getAll: () => getAll.call(registry) } : {}), ...(isModelRegistryGetter(getAvailable) ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
+    const getAll = asFn(registry.getAll);
+    const getAvailable = asFn(registry.getAvailable);
+    return { modelRegistry: { ...(getAll ? { getAll: () => getAll.call(registry) } : {}), ...(getAvailable ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
+}
+function modelInventory(root, registry) {
+    const all = registry?.getAll?.() ?? registry?.getAvailable?.() ?? [];
+    const available = registry?.getAvailable?.() ?? registry?.getAll?.() ?? [];
+    const knownModels = new Set(all.map((model) => `${model.provider}/${model.id}`));
+    const availableModels = new Set(available.map((model) => `${model.provider}/${model.id}`));
+    const rootName = root?.provider && root.model ? `${root.provider}/${root.model}` : undefined;
+    if (rootName) {
+        knownModels.add(rootName);
+        availableModels.add(rootName);
+    }
+    return { knownModels, availableModels };
+}
+function resumeHostContext(ctx) {
+    const model = object(ctx) && object(ctx.model) && typeof ctx.model.provider === "string" && typeof ctx.model.id === "string" ? { provider: ctx.model.provider, id: ctx.model.id } : undefined;
+    return { model, modelRegistry: contextHostCapabilities(ctx).modelRegistry };
+}
+async function resolveLaunchAliases(registry, staticAliases, context, availableModels, knownModels, settingsPath) {
+    const dynamic = typeof registry.resolveModelAliases === "function" ? await registry.resolveModelAliases(context, new Set(Object.keys(staticAliases))) : {};
+    const dynamicNames = Object.keys(dynamic);
+    try {
+        const aliases = validateModelAliases({ ...dynamic, ...staticAliases }, settingsPath);
+        validateModelAliasAvailability(aliases, dynamicNames, availableModels, knownModels, settingsPath);
+        return { aliases, dynamicNames };
+    }
+    catch (error) {
+        const name = modelAliasErrorName(error);
+        const descriptor = name && typeof registry.modelAliases === "function" ? registry.modelAliases().find((candidate) => candidate.name === name) : undefined;
+        if (descriptor && errorCode(error) !== "CANCELLED")
+            throw new WorkflowError(errorCode(error) ?? "CONFIG_ERROR", `${errorText(error)} (extension: ${descriptor.headline})`);
+        throw error;
+    }
 }
-function isUiSelect(value) { return typeof value === "function"; }
-function isUiInput(value) { return typeof value === "function"; }
-function isUiSetStatus(value) { return typeof value === "function"; }
 function uiHostCapabilities(ui) {
     if (!object(ui))
         return undefined;
-    const select = ui.select;
-    const input = ui.input;
-    const setStatus = ui.setStatus;
-    return { ...(isUiSelect(select) ? { select } : {}), ...(isUiInput(input) ? { input } : {}), ...(isUiSetStatus(setStatus) ? { setStatus } : {}) };
+    const select = asFn(ui.select);
+    const input = asFn(ui.input);
+    const setStatus = asFn(ui.setStatus);
+    return { ...(select ? { select } : {}), ...(input ? { input } : {}), ...(setStatus ? { setStatus } : {}) };
 }
-function tuiHostCapabilities(tui) {
-    if (!object(tui) || !object(tui.terminal))
-        return {};
-    return { terminal: { ...(tui.terminal.rows === undefined ? {} : { rows: tui.terminal.rows }) } };
+function tuiRows(tui) {
+    const rows = object(tui) && object(tui.terminal) ? tui.terminal.rows : undefined;
+    return typeof rows === "number" && Number.isFinite(rows) ? rows : 24;
 }
-function tuiRows(tui) { const rows = tuiHostCapabilities(tui).terminal?.rows; return typeof rows === "number" && Number.isFinite(rows) ? rows : 24; }
 const WORKFLOW_OVERLAY_BORDER_ROWS = 2;
+const WORKFLOW_OVERLAY_TOP_MARGIN = 1;
+const WORKFLOW_OVERLAY_OPTIONS = { anchor: "top-left", width: "100%", maxHeight: "100%", margin: { top: WORKFLOW_OVERLAY_TOP_MARGIN } };
 function borderWorkflowOverlay(component, theme) {
     return {
         ...component,
@@ -965,13 +1645,10 @@ function borderWorkflowOverlay(component, theme) {
         },
     };
 }
-function isKeybindingGetter(value) { return typeof value === "function"; }
-function keybindingsHostCapabilities(keybindings) {
-    if (!object(keybindings) || !isKeybindingGetter(keybindings.getKeys))
-        return {};
-    return { getKeys: keybindings.getKeys };
+function keybindingKeys(keybindings, name) {
+    const getKeys = object(keybindings) ? asFn(keybindings.getKeys) : undefined;
+    return getKeys ? getKeys.call(keybindings, name) : undefined;
 }
-function keybindingKeys(keybindings, name) { const getKeys = keybindingsHostCapabilities(keybindings).getKeys; return typeof getKeys === "function" ? getKeys.call(keybindings, name) : undefined; }
 export default function workflowExtension(pi, home, clipboard = copyToClipboard, createSession = createNativeAgentSession, agentDir) {
     beginWorkflowExtensionLoading();
     const registry = loadingRegistry();
@@ -1084,11 +1761,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     };
     const phaseBridge = (store, metadata, lifecycle) => {
         let cursor = 0;
-        let executionPhase;
         return async (phase) => {
-            if (phase === executionPhase)
-                return;
-            executionPhase = phase;
             await scheduler.flush();
             await lifecycle.enter();
             try {
@@ -1234,7 +1907,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 catch {
                     effective = previous ? { model: previous.model, ...(previous.requestedModel ? { requestedModel: previous.requestedModel } : {}), tools: previous.tools } : { model: node.options.model ? modelSpec(node.options.model, run.model) : { ...run.model, ...(node.options.thinking ? { thinking: node.options.thinking } : {}) }, ...(node.options.model ? { requestedModel: node.options.model } : {}), tools: node.options.tools };
                 }
-                return { id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), structuralPath: [...(node.options.agentIdentity?.structuralPath ?? [])], ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.worktreeOwner ? { worktreeOwner: node.options.worktreeOwner } : {}), ...(node.options.role ? { role: node.options.role } : {}), ...(effective.requestedModel ? { requestedModel: effective.requestedModel } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}) };
+                const resultPath = !node.parentId && node.options.agentIdentity ? agentIdentityPath(node.options.agentIdentity) : undefined;
+                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 } : {}) };
             });
             return { ...current, agents };
         });
@@ -1243,7 +1917,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     });
     const cleanupTerminalRun = async (runId) => {
         const run = runs.get(runId);
-        if (!run || !["completed", "failed", "stopped"].includes(run.lifecycle.state))
+        if (!run || !HARD_TERMINAL_RUN_STATES.has(run.lifecycle.state))
             return;
         await scheduler.cancelRun(runId);
         await scheduler.flush();
@@ -1293,7 +1967,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) => {
+    const answerBudgetDecision = async (runId, proposalId, approved, silent = false, context, signal) => {
         const run = runs.get(runId);
         if (!run)
             return undefined;
@@ -1301,7 +1975,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);
+        const result = await applyBudgetDecision(request, approved, context, signal);
         if (!silent)
             deliver(pi, `Workflow ${run.metadata.name} budget adjustment ${proposalId}: ${approved ? "Approved" : "Rejected"}.`);
         return result;
@@ -1362,10 +2036,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         label: "Workflow Respond",
         description: "Approve or reject one pending workflow checkpoint or budget decision",
         parameters: Type.Object({ runId: Type.String(), name: Type.Optional(Type.String()), proposalId: Type.Optional(Type.String()), approved: Type.Boolean() }, { additionalProperties: false }),
-        async execute(_id, params) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
                 if (params.proposalId) {
-                    const result = await answerBudgetDecision(params.runId, params.proposalId, params.approved);
+                    const result = await answerBudgetDecision(params.runId, params.proposalId, params.approved, false, ctx, signal);
                     if (!result) {
                         const denied = { state: "budget_exhausted", approved: false, reason: "proposal_not_pending" };
                         return { content: [{ type: "text", text: JSON.stringify(denied) }], details: denied };
@@ -1381,6 +2055,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 throw mainAgentError(error);
             }
         },
+        renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_respond", args, theme)); },
+        renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_respond", context.args, result, options.expanded, theme, context.isError), options.expanded); },
     });
     pi.registerTool({
         name: "workflow_stop",
@@ -1396,49 +2072,111 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 throw mainAgentError(error);
             }
         },
+        renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_stop", args, theme)); },
+        renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_stop", context.args, result, options.expanded, theme, context.isError), options.expanded); },
     });
     let catalogRegistered = false;
     let sessionStarted = false;
-    const registerCatalog = () => {
+    const registerCatalog = (cwd, trustedProject) => {
         if (catalogRegistered || !pi.getActiveTools().includes("workflow"))
             return;
-        const catalog = registry.catalog();
-        const hasAliases = Object.keys(catalog.modelAliases ?? {}).length > 0;
-        if (!catalog.functions.length && !catalog.variables.length && !hasAliases)
+        const catalog = registry.catalog({ cwd, projectTrusted: trustedProject, globalSettingsPath: workflowSettingsPath(extensionAgentDir) });
+        const hasAliases = Object.keys(catalog.modelAliases ?? {}).length > 0 || Boolean(catalog.modelAliasEntries?.length);
+        const hasSettings = catalog.settings !== undefined && [catalog.settings.globalSettingsPath, catalog.settings.projectSettingsPath].some((path) => existsSync(path));
+        if (!catalog.functions.length && !catalog.variables.length && !hasAliases && !hasSettings)
             return;
         pi.registerTool({
             name: "workflow_catalog",
             label: "Workflow Catalog",
             description: "List reusable workflow functions, variables, and model aliases, or load one entry in full",
-            parameters: Type.Object({ name: Type.Optional(Type.String({ description: "Registered function or variable name for full detail" })) }, { additionalProperties: false }),
+            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 result = params.name === undefined ? registry.catalogIndex() : registry.catalogDetail(params.name);
+                const context = { cwd, projectTrusted: trustedProject, globalSettingsPath: workflowSettingsPath(extensionAgentDir) };
+                const result = params.name === undefined ? registry.catalogIndex(context) : registry.catalogDetail(params.name, context);
                 return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
-            }
+            },
+            renderCall(args, theme) {
+                const title = theme.fg("toolTitle", theme.bold("workflow_catalog"));
+                return styledTextBlock(args.name === undefined ? title : `${title} ${theme.fg("accent", args.name)}`);
+            },
+            renderResult(result, options, theme) {
+                return workflowCatalogBlock(formatWorkflowCatalog(catalogResultValue(result), options.expanded, theme), options.expanded);
+            },
         });
         catalogRegistered = true;
     };
-    const refreshPausedRunAliases = async (run, context) => {
-        const loaded = await run.store.load();
-        const active = new Set(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-        const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
+    const createAgentExecutor = (root) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, agentSetupHooks: registry.agentSetupHooks() }, createSession);
+    const activeSnapshotTools = (tools, active) => active === "session"
+        ? new Set(tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog"))
+        : new Set(tools.filter((tool) => active.has(tool) || tool === "workflow_catalog"));
+    const resumeLaunchPrologue = async (input) => {
+        const active = new Set(pi.getActiveTools().filter((tool) => !INTERNAL_WORKFLOW_TOOLS.includes(tool)));
+        const missing = input.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
         if (missing)
             throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
         const settingsPath = workflowSettingsPath(extensionAgentDir);
-        const currentSettings = loadSettings(settingsPath);
-        resolveAgentResourcePolicy(run.store.cwd, run.projectTrusted(), settingsPath);
-        const currentAliases = currentSettings.modelAliases ?? {};
-        const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
-        const modelRegistry = context?.modelRegistry;
-        const knownModels = new Set((modelRegistry?.getAll?.() ?? modelRegistry?.getAvailable?.() ?? []).map((model) => `${model.provider}/${model.id}`));
-        if (context?.model)
-            knownModels.add(`${context.model.provider}/${context.model.id}`);
-        const resumeModels = modelRegistry ? knownModels : new Set([...loaded.snapshot.models, ...knownModels]);
-        const blockedAliases = new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-        const blockedAliasTargets = Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-        const snapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, settings: { ...loaded.snapshot.settings, modelAliases: currentAliases }, modelAliases: currentAliases });
+        const resolution = resolveWorkflowSettings(input.cwd, input.trustedProject, settingsPath);
+        const currentPolicy = resolveAgentResourcePolicy(input.cwd, input.trustedProject, settingsPath);
+        const staticAliases = resolution.effective.modelAliases ?? {};
+        const previousAliases = input.snapshot.modelAliases ?? input.snapshot.settings.modelAliases ?? {};
+        const inventory = modelInventory(input.rootModel, input.modelRegistry);
+        const knownModels = input.modelRegistry ? inventory.knownModels : new Set([...input.snapshot.models, ...inventory.knownModels]);
+        const availableModels = input.modelRegistry ? inventory.availableModels : new Set([...input.snapshot.models, ...inventory.availableModels]);
+        const currentAliases = input.resolvedAliases ?? (await resolveLaunchAliases(registry, staticAliases, { cwd: input.cwd, projectTrusted: input.trustedProject, rootModel: input.rootModel, knownModels, availableModels, signal: input.signal }, availableModels, knownModels, settingsPath)).aliases;
+        const blockedAliases = input.blockedAliases ?? new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
+        const blockedAliasTargets = input.blockedAliasTargets ?? Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
+        let script;
+        if (input.withPreflight) {
+            const resumeAliases = { ...previousAliases, ...currentAliases };
+            script = launchScriptForSnapshot(input.snapshot, registry);
+            preflight(script, { models: availableModels, tools: active, agentTypes: new Set(input.snapshot.agentTypes), modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, input.snapshot.schemas, input.snapshot.metadata, true);
+        }
+        const refreshed = resumedSnapshotSettings(input.snapshot, resolution, currentAliases);
+        const snapshot = createLaunchSnapshot({ ...input.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
+        return { active, settingsPath, resolution, currentPolicy, previousAliases, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot, script };
+    };
+    const workflowAgentHandler = (store, metadata, lifecycle, executor, cwd, runId) => async (prompt, options, agentSignal, identity) => {
+        await lifecycle.enter();
+        try {
+            const path = agentIdentityPath(identity);
+            const replayed = await store.replay(path);
+            if (replayed) {
+                return replayed.value;
+            }
+            const worktree = agentWorktree(identity);
+            const agentCwd = worktree.worktreeOwner ? (await persistWorktree(store, metadata, worktree.worktreeOwner)).cwd : cwd;
+            const role = typeof options.role === "string" ? options.role : undefined;
+            const model = typeof options.model === "string" ? options.model : undefined;
+            const thinking = parseThinking(options.thinking);
+            const requestedLabel = typeof options.label === "string" ? options.label : undefined;
+            const resolved = executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools } : {}) });
+            const label = displayAgentName(requestedLabel, role, resolved.model);
+            const tools = resolved.tools;
+            const schema = object(options.outputSchema) ? options.outputSchema : undefined;
+            const spawned = scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd: agentCwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
+            const cancel = () => { scheduler.cancel(spawned.id); };
+            if (agentSignal.aborted)
+                cancel();
+            else
+                agentSignal.addEventListener("abort", cancel, { once: true });
+            const outcome = await spawned.result.finally(() => { agentSignal.removeEventListener("abort", cancel); });
+            if (!outcome.ok)
+                throw new WorkflowError(outcome.error.code, outcome.error.message);
+            await store.complete(path, outcome.value);
+            return outcome.value;
+        }
+        finally {
+            await lifecycle.leave();
+        }
+    };
+    const refreshPausedRunAliases = async (run, context) => {
+        const loaded = await run.store.load();
+        const trustedProject = context?.projectTrusted ?? run.projectTrusted();
+        const rootModel = context?.model ? { ...run.model, provider: context.model.provider, model: context.model.id } : run.model;
+        const { settingsPath, currentPolicy, previousAliases, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot } = await resumeLaunchPrologue({ snapshot: loaded.snapshot, cwd: run.store.cwd, trustedProject, rootModel, ...(context?.modelRegistry ? { modelRegistry: context.modelRegistry } : {}), signal: run.abortController.signal, withPreflight: false });
         await run.store.saveSnapshot(snapshot);
-        run.executor = new WorkflowAgentExecutor({ cwd: run.store.cwd, agentDir: extensionAgentDir, model: run.model, tools: new Set(snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels: resumeModels, knownModels: resumeModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: () => resolveAgentResourcePolicy(run.store.cwd, run.projectTrusted(), settingsPath) }, createSession);
+        scheduler.updateRunLimit(run.store.runId, snapshot.settings.concurrency);
+        run.executor = createAgentExecutor({ cwd: run.store.cwd, model: run.model, tools: activeSnapshotTools(snapshot.tools, "session"), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentResourcePolicy: frozenResourcePolicy(currentPolicy) });
         run.executor.setRunContext(workflowRunContext(run.store.cwd, run.store.sessionId, run.store.runId, loaded.snapshot.metadata, loaded.snapshot.args, run.abortController.signal));
         const drift = aliasDrift(previousAliases, currentAliases);
         if (drift.length)
@@ -1457,33 +2195,23 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         const missingRole = loaded.snapshot.agentTypes.find((role) => !loaded.snapshot.roles?.[role]);
         if (missingRole)
             throw new WorkflowError("RESUME_INCOMPATIBLE", `Role definition is missing from the launch snapshot: ${missingRole}`);
-        const active = new Set(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-        const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
-        if (missing)
-            throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
-        const settingsPath = workflowSettingsPath(extensionAgentDir);
-        const currentSettings = loadSettings(settingsPath);
-        resolveAgentResourcePolicy(run.store.cwd, trustedProject, settingsPath);
-        const currentAliases = currentSettings.modelAliases ?? {};
-        const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
-        const modelRegistry = context?.modelRegistry;
-        const knownModels = new Set((modelRegistry?.getAll?.() ?? modelRegistry?.getAvailable?.() ?? []).map((model) => `${model.provider}/${model.id}`));
-        if (context?.model)
-            knownModels.add(`${context.model.provider}/${context.model.id}`);
-        const resumeModels = modelRegistry ? knownModels : new Set([...loaded.snapshot.models, ...knownModels]);
-        const resumeAliases = { ...previousAliases, ...currentAliases };
-        const blockedAliases = new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-        const blockedAliasTargets = Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-        const script = launchScriptForSnapshot(loaded.snapshot, registry);
-        preflight(script, { models: resumeModels, tools: active, agentTypes: new Set(loaded.snapshot.agentTypes), modelAliases: resumeAliases, knownModels: resumeModels, settingsPath, skipModelAvailability: true }, loaded.snapshot.schemas, loaded.snapshot.metadata, true);
-        const snapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, settings: { ...loaded.snapshot.settings, modelAliases: currentAliases }, modelAliases: currentAliases });
+        const rootModel = context?.model ? { ...run.model, provider: context.model.provider, model: context.model.id } : run.model;
+        const controller = new AbortController();
+        if (context?.signal?.aborted)
+            controller.abort();
+        else {
+            context?.signal?.addEventListener("abort", () => { controller.abort(); }, { once: true });
+        }
+        run.abortController = controller;
+        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);
-        run.executor = new WorkflowAgentExecutor({ cwd: run.store.cwd, agentDir: extensionAgentDir, model: run.model, tools: new Set(snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels: resumeModels, knownModels: resumeModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: () => resolveAgentResourcePolicy(run.store.cwd, run.projectTrusted(), settingsPath) }, createSession);
+        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);
         if (drift.length)
             await run.store.appendEvent({ type: "warning", message: `Model alias mappings changed on resume: ${drift.join("; ")}` });
-        const controller = new AbortController();
-        run.abortController = controller;
         const runContext = workflowRunContext(run.store.cwd, run.store.sessionId, run.store.runId, loaded.snapshot.metadata, loaded.snapshot.args, controller.signal);
         run.executor.setRunContext(runContext);
         let variables;
@@ -1492,7 +2220,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         }
         catch (error) {
             const typed = asWorkflowError(error);
-            if (!["completed", "failed", "stopped"].includes(run.lifecycle.state)) {
+            if (!HARD_TERMINAL_RUN_STATES.has(run.lifecycle.state)) {
                 await run.lifecycle.terminal("failed", typed.code).catch(() => undefined);
                 const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, error: { code: typed.code, message: typed.message } }));
                 await eventPublisher.runFailed(run.store, run.metadata, typed, run.lifecycle.state === "interrupted" ? "interrupted" : "failed");
@@ -1505,37 +2233,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         }
         await scheduler.cancelRun(run.store.runId);
         await run.lifecycle.resume();
-        const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: async (prompt, options, signal, identity) => {
-                await run.lifecycle.enter();
-                try {
-                    const path = agentIdentityPath(identity);
-                    const replayed = await run.store.replay(path);
-                    if (replayed) {
-                        return replayed.value;
-                    }
-                    const worktree = agentWorktree(identity);
-                    const cwd = worktree.worktreeOwner ? (await persistWorktree(run.store, run.metadata, worktree.worktreeOwner)).cwd : run.store.cwd;
-                    const role = typeof options.role === "string" ? options.role : undefined;
-                    const model = typeof options.model === "string" ? options.model : undefined;
-                    const thinking = parseThinking(options.thinking);
-                    const requestedLabel = typeof options.label === "string" ? options.label : undefined;
-                    const resolved = run.executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools } : {}) });
-                    const label = displayAgentName(requestedLabel, role, resolved.model);
-                    const tools = resolved.tools;
-                    const schema = object(options.outputSchema) ? options.outputSchema : undefined;
-                    const spawned = scheduler.spawn(run.store.runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
-                    const cancel = () => { scheduler.cancel(spawned.id); };
-                    signal.addEventListener("abort", cancel, { once: true });
-                    const outcome = await spawned.result.finally(() => { signal.removeEventListener("abort", cancel); });
-                    if (!outcome.ok)
-                        throw new WorkflowError(outcome.error.code, outcome.error.message);
-                    await run.store.complete(path, outcome.value);
-                    return outcome.value;
-                }
-                finally {
-                    await run.lifecycle.leave();
-                }
-            }, worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, false, hasUI ? ui : undefined), phase: phaseBridge(run.store, run.metadata, run.lifecycle), log: logBridge(run.lifecycle, run.metadata.name) }, run.store, runContext, variables, registry), controller.signal);
+        const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: workflowAgentHandler(run.store, run.metadata, run.lifecycle, run.executor, run.store.cwd, run.store.runId), worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, 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);
         run.execution = execution;
         const completion = execution.result.then(async (value) => {
             await scheduler.flush();
@@ -1562,7 +2260,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         run.completion = completion;
         void completion;
     };
-    const applyBudgetDecision = async (request, approved) => {
+    const applyBudgetDecision = async (request, approved, context, signal) => {
         const run = runs.get(request.runId);
         if (!run)
             throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${request.runId}`);
@@ -1576,16 +2274,31 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             next.budget = nextBudget;
         else
             delete next.budget; return next; });
-        await coldResumeRun(run, false, {}, true);
+        await coldResumeRun(run, false, {}, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) });
         return { state: "running", approved: true };
     };
-    const resumeWorkflowRun = async (runId, rawPatch) => {
+    const resumeWorkflowRun = async (runId, rawPatch, context, signal) => {
         const run = runs.get(runId);
-        if (!run)
-            throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${runId}`);
+        if (!run) {
+            const host = object(context) ? context : {};
+            const cwd = typeof host.cwd === "string" ? host.cwd : undefined;
+            const sessionManager = object(host.sessionManager) ? host.sessionManager : undefined;
+            const sessionId = typeof sessionManager?.getSessionId === "function" ? String(Reflect.apply(sessionManager.getSessionId, sessionManager, [])) : undefined;
+            if (cwd && sessionId) {
+                try {
+                    const state = (await new RunStore(cwd, sessionId, runId, home).load()).run.state;
+                    throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("resume", state));
+                }
+                catch (error) {
+                    if (error instanceof WorkflowError)
+                        throw error;
+                }
+            }
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run ${runId} in the current project and Pi session`);
+        }
         const loaded = await run.store.load();
         if (loaded.run.state !== "budget_exhausted")
-            throw new WorkflowError("RESUME_INCOMPATIBLE", "Only budget-exhausted runs can be resumed with workflow_resume");
+            throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("resume", loaded.run.state));
         const currentBudget = validateBudget(loaded.run.budget ?? loaded.snapshot.budget);
         const patch = rawPatch === undefined ? {} : validateBudgetPatch(rawPatch);
         const nextBudget = mergeBudget(currentBudget, patch);
@@ -1610,11 +2323,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             else
                 delete next.budget; return next; });
         }
-        await coldResumeRun(run, false, {}, true);
+        await coldResumeRun(run, false, {}, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) });
         return { state: "running" };
     };
     const retryReservations = new Set();
-    const retryWorkflowRun = async (runId, context) => {
+    const retryWorkflowRun = async (runId, context, signal) => {
         if (typeof runId !== "string" || !runId.trim())
             throw new WorkflowError("RESUME_INCOMPATIBLE", "workflow_retry requires an explicit run ID");
         const host = object(context) ? context : {};
@@ -1630,10 +2343,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             loaded = await sourceStore.load();
         }
         catch (error) {
-            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot load failed source run ${runId}: ${errorText(error)}`);
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run ${runId} in the current project and Pi session: ${errorText(error)}`);
         }
         if (loaded.run.state !== "failed")
-            throw new WorkflowError("RESUME_INCOMPATIBLE", `Only failed workflow runs can be retried; source is ${loaded.run.state}`);
+            throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("retry", loaded.run.state));
         if (loaded.run.retry && (typeof loaded.run.retry.sourceRunId !== "string" || !loaded.run.retry.sourceRunId || typeof loaded.run.retry.lineageRootRunId !== "string" || !loaded.run.retry.lineageRootRunId || !Array.isArray(loaded.run.retry.completedPaths) || loaded.run.retry.completedPaths.some((path) => typeof path !== "string") || !Array.isArray(loaded.run.retry.incompletePaths) || loaded.run.retry.incompletePaths.some((path) => typeof path !== "string") || !Array.isArray(loaded.run.retry.namedWorktrees) || loaded.run.retry.namedWorktrees.some((name) => typeof name !== "string")))
             throw new WorkflowError("RESUME_INCOMPATIBLE", "The source retry provenance is incomplete");
         const lineageRootRunId = loaded.run.retry?.lineageRootRunId ?? loaded.run.id;
@@ -1669,24 +2382,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const missingRole = loaded.snapshot.agentTypes.find((role) => !loaded.snapshot.roles?.[role]);
             if (missingRole)
                 throw new WorkflowError("RESUME_INCOMPATIBLE", `Role definition is missing from the launch snapshot: ${missingRole}`);
-            const active = new Set(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-            const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
-            if (missing)
-                throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
-            const settingsPath = workflowSettingsPath(extensionAgentDir);
-            const currentSettings = loadSettings(settingsPath);
-            resolveAgentResourcePolicy(cwd, trustedProject, settingsPath);
-            const currentAliases = currentSettings.modelAliases ?? {};
-            const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
             const modelRegistry = contextHostCapabilities(context).modelRegistry;
-            const knownModels = new Set((modelRegistry?.getAll?.() ?? modelRegistry?.getAvailable?.() ?? []).map((model) => `${model.provider}/${model.id}`));
             const hostModel = object(host.model) && typeof host.model.provider === "string" && typeof host.model.id === "string" ? { provider: host.model.provider, id: host.model.id } : { provider: "", id: "" };
-            if (hostModel.provider && hostModel.id)
-                knownModels.add(`${hostModel.provider}/${hostModel.id}`);
-            const resumeModels = modelRegistry ? knownModels : new Set([...loaded.snapshot.models, ...knownModels]);
-            const resumeAliases = { ...previousAliases, ...currentAliases };
-            const script = launchScriptForSnapshot(loaded.snapshot, registry);
-            preflight(script, { models: resumeModels, tools: active, agentTypes: new Set(loaded.snapshot.agentTypes), modelAliases: resumeAliases, knownModels: resumeModels, settingsPath, skipModelAvailability: true }, loaded.snapshot.schemas, loaded.snapshot.metadata, true);
+            const rootModel = { provider: hostModel.provider, model: hostModel.id, thinking: pi.getThinkingLevel() };
+            const { active, settingsPath, currentPolicy, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot: childBaseSnapshot } = await resumeLaunchPrologue({ snapshot: loaded.snapshot, cwd, trustedProject, rootModel, ...(modelRegistry ? { modelRegistry } : {}), signal: signal ?? new AbortController().signal, withPreflight: true });
             await sourceStore.validateNamedWorktrees();
             for (const name of loaded.run.retry?.namedWorktrees ?? [])
                 await sourceStore.resolveNamedWorktree(name);
@@ -1696,7 +2395,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const budget = validateBudget(loaded.run.budget ?? loaded.snapshot.budget);
             const childRunId = randomUUID();
             const childStore = new RunStore(cwd, sessionId, childRunId, home);
-            const childSnapshot = createLaunchSnapshot(loaded.snapshot);
+            const childSnapshot = childBaseSnapshot;
             const childBudget = new WorkflowBudgetRuntime(budget, loaded.run.budgetVersion ?? 1, loaded.run.usage, loaded.run.budgetEvents);
             const childInitialBudget = childBudget.snapshot();
             const retry = { sourceRunId: loaded.run.id, lineageRootRunId, completedPaths, incompletePaths, namedWorktrees };
@@ -1705,13 +2404,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const model = modelSpec(loaded.snapshot.models[0] ?? "", fallbackModel);
             const lifecycle = lifecycleFor(childStore, "interrupted", childBudget, loaded.snapshot.metadata);
             const abortController = new AbortController();
-            const providerErrorRecovery = createProviderErrorRecovery(context, resumeModels, () => { abortController.abort(); });
+            const providerErrorRecovery = createProviderErrorRecovery(context, availableModels, () => { abortController.abort(); });
             const providerPause = async () => { deliver(pi, `Workflow ${loaded.snapshot.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
-            const childRun = { executor: new WorkflowAgentExecutor({ cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => active.has(tool) || tool === "workflow_catalog")), availableModels: resumeModels, knownModels: resumeModels, modelAliases: currentAliases, settingsPath, agentDefinitions: loaded.snapshot.roles ?? {}, runStore: childStore, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: () => resolveAgentResourcePolicy(cwd, projectTrusted(context), settingsPath) }, createSession), store: childStore, metadata: loaded.snapshot.metadata, model, lifecycle, budget: childBudget, abortController, projectTrusted: () => projectTrusted(context), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) };
+            const childRun = { executor: createAgentExecutor({ cwd, model, tools: activeSnapshotTools(loaded.snapshot.tools, active), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: loaded.snapshot.roles ?? {}, runStore: childStore, providerPause, agentResourcePolicy: frozenResourcePolicy(currentPolicy) }), store: childStore, metadata: loaded.snapshot.metadata, model, lifecycle, budget: childBudget, abortController, projectTrusted: () => projectTrusted(context), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) };
             runs.set(childRunId, childRun);
             scheduler.addRun(childRunId, loaded.snapshot.settings.concurrency, () => { childBudget.checkAgentLaunch(); });
             await eventPublisher.runStarted(childStore, loaded.snapshot.metadata);
-            await coldResumeRun(childRun, false, {}, trustedProject, { model: hostModel, modelRegistry: modelRegistry ? { getAll: () => [...(modelRegistry.getAll?.() ?? [])], getAvailable: () => [...(modelRegistry.getAvailable?.() ?? [])] } : undefined });
+            await coldResumeRun(childRun, false, {}, trustedProject, { model: hostModel, modelRegistry, resolvedAliases: currentAliases, blockedAliases, blockedAliasTargets, ...(signal ? { signal } : {}) });
             const completion = runs.get(childRunId)?.completion;
             if (completion) {
                 childStarted = true;
@@ -1729,37 +2428,41 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         label: "Workflow Retry",
         description: "Retry a failed workflow run by replaying its completed structural operations",
         parameters: WORKFLOW_RETRY_PARAMETERS,
-        async execute(_id, params, _signal, _onUpdate, ctx) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
-                const result = await retryWorkflowRun(params.runId, ctx);
+                const result = await retryWorkflowRun(params.runId, ctx, signal);
                 return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
             }
             catch (error) {
                 throw mainAgentError(error);
             }
         },
+        renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_retry", args, theme)); },
+        renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_retry", context.args, result, options.expanded, theme, context.isError), options.expanded); },
     });
     pi.registerTool({
         name: "workflow_resume",
         label: "Workflow Resume",
         description: "Resume an exhausted workflow with unchanged or patched aggregate budgets",
         parameters: Type.Object({ runId: Type.String(), budget: Type.Optional(Type.Unknown()) }, { additionalProperties: false }),
-        async execute(_id, params) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
-                const result = await resumeWorkflowRun(params.runId, params.budget);
+                const result = await resumeWorkflowRun(params.runId, params.budget, ctx, signal);
                 return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
             }
             catch (error) {
                 throw mainAgentError(error);
             }
         },
+        renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_resume", args, theme)); },
+        renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_resume", context.args, result, options.expanded, theme, context.isError), options.expanded); },
     });
     pi.on("session_start", async (_event, ctx) => {
         if (sessionStarted)
             return;
         sessionStarted = true;
         registry.freeze();
-        registerCatalog();
+        registerCatalog(ctx.cwd, projectTrusted(ctx));
         await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
         try {
             for (const runId of await listRunIds(ctx.cwd, ctx.sessionManager.getSessionId(), home)) {
@@ -1795,7 +2498,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const roleDefinitions = loaded.snapshot.roles ?? {};
                 const abortController = new AbortController();
                 const providerErrorRecovery = createProviderErrorRecovery(ctx, new Set(loaded.snapshot.models), () => { abortController.abort(); });
-                runs.set(runId, { executor: new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels: new Set(loaded.snapshot.models), knownModels: new Set(loaded.snapshot.models), ...(loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ? { modelAliases: loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases } : {}), ...(loaded.snapshot.settingsPath ? { settingsPath: loaded.snapshot.settingsPath } : {}), agentDefinitions: roleDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: () => resolveAgentResourcePolicy(store.cwd, projectTrusted(ctx), loaded.snapshot.settingsPath ?? workflowSettingsPath(extensionAgentDir)) }, createSession), store, metadata: loaded.snapshot.metadata, model, lifecycle, budget: budgetRuntime, abortController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) });
+                runs.set(runId, { executor: createAgentExecutor({ cwd: ctx.cwd, model, tools: activeSnapshotTools(loaded.snapshot.tools, "session"), availableModels: new Set(loaded.snapshot.models), knownModels: new Set(loaded.snapshot.models), ...(loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ? { modelAliases: loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases } : {}), ...(loaded.snapshot.settingsSources?.modelAliases ? { settingsPath: loaded.snapshot.settingsSources.modelAliases } : loaded.snapshot.settingsPath ? { settingsPath: loaded.snapshot.settingsPath } : {}), agentDefinitions: roleDefinitions, runStore: store, providerPause, agentResourcePolicy: frozenResourcePolicy(snapshotResourcePolicy(loaded.snapshot, store.cwd, projectTrusted(ctx), workflowSettingsPath(extensionAgentDir))) }), store, metadata: loaded.snapshot.metadata, model, lifecycle, budget: budgetRuntime, abortController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) });
                 for (const checkpoint of await store.awaitingCheckpoints())
                     deliver(pi, `Workflow ${loaded.snapshot.metadata.name} checkpoint ${checkpoint.name}: ${checkpoint.prompt}\nContext: ${JSON.stringify(checkpoint.context)}\nRespond with workflow_respond.`);
                 for (const decision of await store.pendingWorkflowDecisions())
@@ -1832,7 +2535,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     pi.on("before_agent_start", (event, ctx) => {
         if (!pi.getActiveTools().includes("workflow"))
             return;
-        const roles = Object.entries(loadAgentDefinitions(ctx.cwd, extensionAgentDir, projectTrusted(ctx))).filter(([, definition]) => definition.description);
+        const roles = Object.entries(loadAgentDefinitions(ctx.cwd, extensionAgentDir, projectTrusted(ctx), typeof registry.roleDirectoryRegistrations === "function" ? registry.roleDirectoryRegistrations() : undefined)).filter(([, definition]) => definition.description);
         if (!roles.length)
             return;
         const content = `Workflow role descriptions:\n${roles.map(([name, definition]) => `- \`${name}\`: ${String(definition.description)}`).join("\n")}`;
@@ -1848,32 +2551,33 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             try {
                 const headless = object(ctx) && ctx.headless === true;
                 const settingsPath = workflowSettingsPath(extensionAgentDir);
-                const defaults = loadSettings(settingsPath);
                 if (!ctx.model)
                     throw new WorkflowError("UNKNOWN_MODEL", "A launching model is required");
-                const settings = Object.freeze({ concurrency: params.concurrency ?? defaults.concurrency, ...(defaults.modelAliases ? { modelAliases: defaults.modelAliases } : {}) });
                 const budget = validateBudget(params.budget);
                 const rootModel = { provider: ctx.model.provider, model: ctx.model.id, thinking: pi.getThinkingLevel() };
                 const rootModelName = `${rootModel.provider}/${rootModel.model}`;
                 const modelRegistry = contextHostCapabilities(ctx).modelRegistry;
-                const knownModels = new Set((modelRegistry?.getAll?.() ?? modelRegistry?.getAvailable?.() ?? [ctx.model]).map((model) => `${model.provider}/${model.id}`));
-                knownModels.add(rootModelName);
-                const availableModels = knownModels;
-                const rootTools = pi.getActiveTools().filter((name) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(name));
+                const inventory = modelInventory(rootModel, modelRegistry);
+                const knownModels = inventory.knownModels;
+                const availableModels = inventory.availableModels;
+                const rootTools = pi.getActiveTools().filter((name) => !INTERNAL_WORKFLOW_TOOLS.includes(name));
                 const trustedProject = projectTrusted(ctx);
-                if (typeof ctx.cwd === "string")
-                    resolveAgentResourcePolicy(ctx.cwd, trustedProject, settingsPath);
-                const validated = validateWorkflowLaunchWithRegistry({ ...params, args: params.args }, { cwd: ctx.cwd, agentDir: extensionAgentDir, projectTrusted: trustedProject, availableModels, rootTools: new Set(rootTools), modelAliases: defaults.modelAliases ?? {}, knownModels, settingsPath }, registry);
-                const { script, checked, agentDefinitions, projectAgentDefinitions, roleNames, functionName } = validated;
-                await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
-                const runId = randomUUID();
-                const args = (params.args ?? null);
-                encoded(args);
+                const launchCwd = typeof ctx.cwd === "string" ? ctx.cwd : process.cwd();
+                const launch = workflowLaunchSettings(launchCwd, trustedProject, settingsPath, params.concurrency);
                 const runController = new AbortController();
                 if (signal?.aborted)
                     runController.abort();
                 else
                     signal?.addEventListener("abort", () => { runController.abort(); }, { once: true });
+                const resolvedAliases = await resolveLaunchAliases(registry, launch.settings.modelAliases ?? {}, { cwd: launchCwd, projectTrusted: trustedProject, rootModel, knownModels, availableModels, signal: runController.signal }, availableModels, knownModels, settingsPath);
+                const modelAliases = resolvedAliases.aliases;
+                const settings = Object.freeze({ ...launch.settings, ...(Object.keys(modelAliases).length ? { modelAliases } : {}) });
+                const validated = validateWorkflowLaunchWithRegistry({ ...params, args: params.args }, { cwd: ctx.cwd, agentDir: extensionAgentDir, projectTrusted: trustedProject, availableModels, rootTools: new Set(rootTools), modelAliases, knownModels, settingsPath }, registry);
+                const { script, checked, agentDefinitions, projectAgentDefinitions, roleNames, functionName } = validated;
+                await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
+                const runId = randomUUID();
+                const args = (params.args ?? null);
+                encoded(args);
                 const runContext = workflowRunContext(ctx.cwd, ctx.sessionManager.getSessionId(), runId, checked.metadata, args, runController.signal);
                 const variables = await resolveWorkflowVariables(runContext, runController, registry);
                 const store = new RunStore(ctx.cwd, ctx.sessionManager.getSessionId(), runId, home);
@@ -1882,9 +2586,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     await store.validateParentRun(parentRunId);
                 const roles = Object.fromEntries(roleNames.map((role) => [role, agentDefinitions[role]]));
                 const projectRoles = roleNames.filter((role) => projectAgentDefinitions[role] !== undefined);
-                const roleModels = roleNames.flatMap((role) => { const model = agentDefinitions[role]?.model; return model ? [modelCapability(model, defaults.modelAliases, knownModels, settingsPath)] : []; });
+                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, ...(functionName ? { launchKind: "function", functionName } : {}), ...(defaults.modelAliases ? { modelAliases: defaults.modelAliases } : {}), ...(budget ? { budget } : {}), models: snapshotModels, tools: rootTools, agentTypes: checked.referenced.agentTypes, roles, projectRoles, schemas: checked.schemas });
+                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 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);
@@ -1893,45 +2597,12 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const providerPause = async () => { if (background)
                     deliver(pi, `Workflow ${checked.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
                 const providerErrorRecovery = createProviderErrorRecovery(ctx, availableModels, () => { runController.abort(); });
-                const executor = new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model: rootModel, tools: new Set(rootTools), availableModels, knownModels, modelAliases: defaults.modelAliases ?? {}, settingsPath, agentDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: () => resolveAgentResourcePolicy(ctx.cwd, projectTrusted(ctx), settingsPath), runContext }, createSession);
+                const executor = createAgentExecutor({ cwd: ctx.cwd, model: rootModel, tools: new Set(rootTools), availableModels, knownModels, modelAliases, settingsPath, agentDefinitions, runStore: store, providerPause, agentResourcePolicy: frozenResourcePolicy(launch.resourcePolicy), runContext });
                 runs.set(runId, { executor, store, metadata: checked.metadata, model: rootModel, lifecycle, budget: budgetRuntime, abortController: runController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}), ...(params.foreground && onUpdate ? { update: onUpdate } : {}) });
                 if (params.foreground && onUpdate)
                     onUpdate(workflowToolUpdate((await store.load()).run));
                 scheduler.addRun(runId, settings.concurrency, () => runs.get(runId)?.budget.checkAgentLaunch());
-                const execution = runWorkflow(script, args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal, identity), agent: async (prompt, options, agentSignal, identity) => {
-                        await lifecycle.enter();
-                        try {
-                            const path = agentIdentityPath(identity);
-                            const replayed = await store.replay(path);
-                            if (replayed) {
-                                return replayed.value;
-                            }
-                            const worktree = agentWorktree(identity);
-                            const cwd = worktree.worktreeOwner ? (await persistWorktree(store, checked.metadata, worktree.worktreeOwner)).cwd : ctx.cwd;
-                            const role = typeof options.role === "string" ? options.role : undefined;
-                            const model = typeof options.model === "string" ? options.model : undefined;
-                            const thinking = parseThinking(options.thinking);
-                            const requestedLabel = typeof options.label === "string" ? options.label : undefined;
-                            const resolved = executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: checked.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools } : {}) });
-                            const label = displayAgentName(requestedLabel, role, resolved.model);
-                            const tools = resolved.tools;
-                            const schema = object(options.outputSchema) ? options.outputSchema : undefined;
-                            const spawned = scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
-                            const cancel = () => { scheduler.cancel(spawned.id); };
-                            if (agentSignal.aborted)
-                                cancel();
-                            else
-                                agentSignal.addEventListener("abort", cancel, { once: true });
-                            const outcome = await spawned.result.finally(() => { agentSignal.removeEventListener("abort", cancel); });
-                            if (!outcome.ok)
-                                throw new WorkflowError(outcome.error.code, outcome.error.message);
-                            await store.complete(path, outcome.value);
-                            return outcome.value;
-                        }
-                        finally {
-                            await lifecycle.leave();
-                        }
-                    }, worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, Boolean(params.foreground), params.foreground && ctx.hasUI ? ctx.ui : undefined, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(lifecycle, checked.metadata.name) }, store, runContext, variables, registry), runController.signal);
+                const execution = runWorkflow(script, args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal, identity), agent: workflowAgentHandler(store, checked.metadata, lifecycle, executor, ctx.cwd, runId), 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) => {
@@ -2027,7 +2698,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 return entries.filter((entry) => entry !== undefined);
             };
             let stores = await loadStores();
-            const usage = "Usage: /workflow [doctor|model-aliases], or /workflow pause|resume|stop|approve|reject|delete <run-id> [checkpoint or proposal-id]. Use workflow_resume for budget patches.";
+            const usage = "Usage: /workflow [doctor|model-aliases], or /workflow pause|resume|stop|approve|reject|delete <run-id> [checkpoint-name]. Approve/reject are for checkpoints only; use workflow_respond with a proposalId or the navigator's budget controls for budget decisions. Use workflow_resume for budget patches.";
             const setWorkflowStatus = (text) => {
                 const setStatus = uiHostCapabilities(ctx.ui)?.setStatus;
                 setStatus?.call(ctx.ui, "workflow-stop", text);
@@ -2044,12 +2715,12 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         return keepContext ? "dashboard" : "done";
                     }
                     if ((action === "budget-approve" || action === "budget-reject") && runId && rest[0]) {
-                        const result = await answerBudgetDecision(runId, rest[0], action === "budget-approve", true);
+                        const result = await answerBudgetDecision(runId, rest[0], action === "budget-approve", true, ctx);
                         ctx.ui.notify(result ? `Budget adjustment ${rest[0]} ${result.approved ? "approved" : "rejected"}.` : "Budget proposal is not pending.", result ? "info" : "warning");
                         return keepContext ? "dashboard" : "done";
                     }
                     if (action === "delete" && stored) {
-                        if (!["completed", "failed", "stopped"].includes(stored.loaded.run.state)) {
+                        if (!HARD_TERMINAL_RUN_STATES.has(stored.loaded.run.state)) {
                             ctx.ui.notify("Stop the workflow before deleting it.", "warning");
                             return keepContext ? "dashboard" : "done";
                         }
@@ -2069,7 +2740,7 @@ 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);
+                            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");
                         }
                         else {
@@ -2077,7 +2748,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 await coldResumeRun(run, ctx.hasUI, ctx.ui, projectTrusted(ctx), ctx);
                             else {
                                 if (run.lifecycle.state === "paused")
-                                    await refreshPausedRunAliases(run, ctx);
+                                    await refreshPausedRunAliases(run, { ...resumeHostContext(ctx), projectTrusted: projectTrusted(ctx) });
                                 await run.lifecycle.resume();
                             }
                             ctx.ui.notify(`Resumed workflow ${run.store.runId}.`, "info");
@@ -2088,7 +2759,7 @@ 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));
+                        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");
                         return keepContext ? "dashboard" : "done";
                     }
@@ -2123,6 +2794,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             };
             const manageAliases = async () => {
                 const settingsPath = workflowSettingsPath(extensionAgentDir);
+                let aliasSettingsPath = settingsPath;
+                const trustedProject = projectTrusted(ctx);
                 const modelRegistry = contextHostCapabilities(ctx).modelRegistry;
                 const available = () => [...new Set((modelRegistry?.getAvailable?.() ?? []).map((model) => `${model.provider}/${model.id}`))].sort();
                 const selectTarget = async (aliases) => {
@@ -2136,22 +2809,24 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 };
                 const save = (aliases) => {
                     try {
-                        saveModelAliases(settingsPath, aliases);
-                        ctx.ui.notify(`Saved model aliases to ${settingsPath}.`, "info");
+                        saveModelAliases(aliasSettingsPath, aliases);
+                        ctx.ui.notify(`Saved model aliases to ${aliasSettingsPath}.`, "info");
                         return true;
                     }
                     catch (error) {
-                        ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                        ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
                         return false;
                     }
                 };
                 for (;;) {
                     let aliases;
                     try {
-                        aliases = loadSettings(settingsPath).modelAliases ?? {};
+                        const resolution = resolveWorkflowSettings(ctx.cwd, trustedProject, settingsPath);
+                        aliases = resolution.effective.modelAliases ?? {};
+                        aliasSettingsPath = resolution.sources.modelAliases;
                     }
                     catch (error) {
-                        ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                        ctx.ui.notify(`${trustedProject ? workflowProjectSettingsPath(ctx.cwd) : settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
                         return;
                     }
                     const names = Object.keys(aliases).sort();
@@ -2173,13 +2848,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             continue;
                         const next = { ...aliases, [name]: target };
                         try {
-                            validateModelAliases(next, settingsPath);
+                            validateModelAliases(next, aliasSettingsPath);
                         }
                         catch (error) {
-                            ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                            ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
                             continue;
                         }
-                        const parsed = resolveModelReference(target, next, new Set(available()), settingsPath);
+                        const parsed = resolveModelReference(target, next, new Set(available()), aliasSettingsPath);
                         if (!available().includes(`${parsed.provider}/${parsed.model}`)) {
                             ctx.ui.notify(`Warning: ${target} is not currently available in Pi.`, "warning");
                             if (!await ctx.ui.confirm("Save unknown model?", "Save this target for cross-machine portability?"))
@@ -2195,13 +2870,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             continue;
                         const next = { ...aliases, [edit[1]]: target };
                         try {
-                            validateModelAliases(next, settingsPath);
+                            validateModelAliases(next, aliasSettingsPath);
                         }
                         catch (error) {
-                            ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                            ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
                             continue;
                         }
-                        const parsed = resolveModelReference(target, next, new Set(available()), settingsPath);
+                        const parsed = resolveModelReference(target, next, new Set(available()), aliasSettingsPath);
                         if (!available().includes(`${parsed.provider}/${parsed.model}`)) {
                             ctx.ui.notify(`Warning: ${target} is not currently available in Pi.`, "warning");
                             if (!await ctx.ui.confirm("Save unknown model?", "Save this target for cross-machine portability?"))
@@ -2238,9 +2913,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     }
                     const sorted = navigatorAttentionSort(stores);
                     const labels = navigatorRunLabels(sorted);
-                    const terminalStates = new Set(["completed", "failed", "stopped"]);
+                    const terminalStates = HARD_TERMINAL_RUN_STATES;
                     const hasCompleted = sorted.some(({ loaded: { run } }) => run.state === "completed");
-                    const pickerOptions = [...labels, ...(herdrPaneId() ? ["Inspect session in pane"] : []), "Model aliases", "Close", ...(hasCompleted ? ["Delete all completed"] : [])];
+                    const hasFailed = sorted.some(({ loaded: { run } }) => run.state === "failed");
+                    const pickerOptions = [...labels, ...(herdrPaneId() ? ["Inspect session in pane"] : []), "Model aliases", "Close", ...(hasCompleted ? ["Delete all completed"] : []), ...(hasFailed ? ["Delete all failed"] : [])];
                     const runChoice = await ctx.ui.select("Workflows\n", pickerOptions);
                     if (!runChoice || runChoice === "Close")
                         return;
@@ -2273,6 +2949,20 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         stores = await loadStores();
                         continue;
                     }
+                    if (runChoice === "Delete all failed") {
+                        if (!await ctx.ui.confirm("Delete failed runs?", "Delete all failed workflow runs and their artifacts? This cannot be undone."))
+                            continue;
+                        for (const entry of sorted) {
+                            if (entry.loaded.run.state === "failed") {
+                                await entry.store.delete(true);
+                                runs.delete(entry.store.runId);
+                                terminalRunStates.delete(entry.store.runId);
+                            }
+                        }
+                        ctx.ui.notify("Deleted all failed workflow runs.", "info");
+                        stores = await loadStores();
+                        continue;
+                    }
                     const runIndex = labels.indexOf(runChoice);
                     if (runIndex < 0)
                         return;
@@ -2293,6 +2983,15 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         const loaded = await store.load();
                         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) {
+                            if (agent.state !== "completed" || agent.parentId || !agent.resultPath)
+                                continue;
+                            const operation = completedOperations.find((candidate) => candidate.path === agent.resultPath);
+                            if (operation)
+                                agentResults.set(agent.id, operation.value);
+                        }
                         const actions = new Map();
                         const copies = new Map();
                         const reviews = new Map();
@@ -2327,8 +3026,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         if (ctx.mode !== "tui")
                             actions.set("Refresh", "refresh");
                         else
-                            actions.set("View script", "view-script");
-                        if (loaded.run.agents.length)
+                            actions.set("Open script in editor", "open-script");
+                        if (ctx.mode !== "tui" && loaded.run.agents.length)
                             actions.set("Agents...", "agents");
                         if (terminalStates.has(loaded.run.state))
                             add("Delete", "delete");
@@ -2336,40 +3035,55 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             addCopy("Copy run path", store.directory, "run path");
                             addCopy("Copy run ID", store.runId, "run ID");
                         }
-                        return { dashboard: formatNavigatorDashboard(loaded.run, checkpoints, worktrees), actions, copies, reviews, script: loaded.snapshot.script, agents: loaded.run.agents, worktrees, cwd: loaded.run.cwd };
+                        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 };
                     };
-                    const selectAgent = async (dashboard) => {
-                        const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
-                        const title = (agent) => {
-                            const parents = [];
-                            for (let parentId = agent.parentId; parentId; parentId = byId.get(parentId)?.parentId) {
-                                const parent = byId.get(parentId);
-                                if (!parent)
-                                    break;
-                                parents.unshift(parent.label ?? parent.name);
-                            }
-                            return [...((agent.structuralPath ?? []).length ? [(agent.structuralPath ?? []).join(" > ")] : []), ...(agent.parentBreadcrumb ? [agent.parentBreadcrumb] : []), ...parents, agent.label ?? agent.name].join(" > ");
-                        };
-                        const labels = dashboard.agents.map((agent, index) => `#${String(index + 1)} ${title(agent)} [${agent.state}]`);
-                        const selectedLabel = await ctx.ui.select("Agents", [...labels, "Back"]);
-                        const selectedIndex = selectedLabel ? labels.indexOf(selectedLabel) : -1;
-                        const selected = selectedIndex >= 0 ? dashboard.agents[selectedIndex] : undefined;
-                        if (!selected)
-                            return;
-                        const attempts = [...(selected.attemptDetails ?? [])].sort((left, right) => left.attempt - right.attempt);
-                        const worktree = selected.worktreeOwner ? dashboard.worktrees.find((candidate) => candidate.owner === selected.worktreeOwner) : undefined;
-                        const actions = [
-                            ...(attempts.length && herdrPaneId() ? ["Fork as Pi session in pane"] : []),
+                    const agentWorktreeFor = (dashboard, agent) => agent.worktreeOwner ? dashboard.worktrees.find((candidate) => candidate.owner === agent.worktreeOwner) : undefined;
+                    const agentActionLabels = (dashboard, agent) => {
+                        const worktree = agentWorktreeFor(dashboard, agent);
+                        return [
+                            ...(agent.attemptDetails?.length && herdrPaneId() ? ["Fork as Pi session in pane"] : []),
                             ...(worktree ? ["Copy branch", "Copy worktree path"] : []),
+                            ...(ctx.mode === "tui" && dashboard.agentResults.has(agent.id) ? ["Open result in editor"] : []),
                             "Copy agent ID",
                             "Back",
                         ];
-                        const chooseAttempt = async () => {
-                            const choices = attempts.map((attempt) => `Attempt ${String(attempt.attempt)}`);
-                            const choice = choices.length === 1 ? choices[0] : await ctx.ui.select("Fork attempts", [...choices, "Back"]);
-                            const index = choice ? choices.indexOf(choice) : -1;
-                            return index >= 0 ? attempts[index] : undefined;
-                        };
+                    };
+                    const 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);
+                        const labels = dashboard.agents.map((agent, index) => `#${String(index + 1)} ${title(agent)} [${agent.state}]`);
+                        let selected;
+                        if (requestedAgentId)
+                            selected = dashboard.agents.find((agent) => agent.id === requestedAgentId);
+                        else {
+                            const selectedLabel = await ctx.ui.select("Agents", [...labels, "Back"]);
+                            const selectedIndex = selectedLabel ? labels.indexOf(selectedLabel) : -1;
+                            selected = selectedIndex >= 0 ? dashboard.agents[selectedIndex] : undefined;
+                        }
+                        if (!selected)
+                            return;
+                        const worktree = agentWorktreeFor(dashboard, selected);
+                        const actions = agentActionLabels(dashboard, selected);
                         for (;;) {
                             const action = await ctx.ui.select(title(selected), actions);
                             if (!action || action === "Back")
@@ -2386,55 +3100,87 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 await copyArtifact(worktree.path, "worktree path");
                                 continue;
                             }
-                            if (action === "Fork as Pi session in pane") {
-                                const attempt = await chooseAttempt();
-                                if (!attempt)
-                                    continue;
-                                const running = !SETTLED_AGENT_STATES.has(selected.state) && attempt.attempt === attempts.at(-1)?.attempt && !attempt.error;
-                                if (running && !await ctx.ui.confirm("Fork running attempt?", "This attempt is still running. The snapshot may end mid-turn and will not receive later updates. It opens read-only to avoid concurrent changes to the workflow agent's working directory. Continue?"))
-                                    continue;
-                                try {
-                                    await openHerdrPane({ action: "fork", cwd: worktree?.cwd ?? attempt.setup?.cwd ?? dashboard.cwd, original: attempt.sessionFile, ...(running ? { readOnly: true } : {}) });
-                                    ctx.ui.notify("Forked Pi session in pane.", "info");
-                                }
-                                catch (error) {
-                                    ctx.ui.notify(`Cannot fork Pi session in pane: ${error instanceof Error ? error.message : String(error)}`, "warning");
-                                }
-                            }
+                            if (action === "Fork as Pi session in pane")
+                                await forkAgentSession(dashboard, selected);
                         }
                     };
                     for (;;) {
                         let view = await loadDashboard();
                         const actionChoice = ctx.mode === "tui"
                             ? await ctx.ui.custom((tui, theme, keybindings, done) => {
-                                let options = [...view.actions.keys(), "Close"];
-                                let selectedIndex = 0;
                                 let dashboardOffset = 0;
                                 let refreshing = false;
                                 let disposed = false;
+                                let detailsMode = false;
+                                let actionMode = false;
+                                let actionIndex = 0;
                                 let stopRequested = false;
                                 let stopStatus;
+                                let selectionNeedsScroll = true;
+                                let renderedWidth = 80;
+                                let refreshGeneration = 0;
+                                const initialSelection = preserveWorkflowPhaseSelection(view.phaseModel, {});
+                                let 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 keyLabels = { up: "↑", down: "↓", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
+                                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 dashboardLayout = () => {
-                                    const rows = terminalRows();
-                                    const hintRows = rows >= 4 ? 1 : 0;
-                                    const separatorRows = rows >= 8 ? 1 : 0;
-                                    const available = Math.max(1, rows - hintRows - separatorRows);
-                                    const actionViewport = Math.min(options.length, Math.max(1, Math.ceil(available / 2)));
-                                    return { rows, hintRows, separatorRows, actionViewport, dashboardViewport: available - actionViewport };
+                                const selectedAgentRecord = () => {
+                                    const node = selectedNodeId ? tree.byId.get(selectedNodeId) : tree.nodes[0];
+                                    return node?.kind === "agent" && node.agentId ? view.agents.find((agent) => agent.id === node.agentId) : undefined;
+                                };
+                                const actionOptions = () => {
+                                    const agent = selectedAgentRecord();
+                                    return agent ? agentActionLabels(view, agent) : [...view.actions.keys(), "Back"];
+                                };
+                                let editorRunning = false;
+                                const openArtifact = async (artifact, label) => {
+                                    if (editorRunning)
+                                        return;
+                                    editorRunning = true;
+                                    try {
+                                        const command = SettingsManager.create(view.cwd, extensionAgentDir, { projectTrusted: projectTrusted(ctx) }).getExternalEditorCommand();
+                                        if (!command) {
+                                            ctx.ui.notify(`Cannot open ${label}: no external editor is configured.`, "warning");
+                                            return;
+                                        }
+                                        const exitCode = await openWorkflowArtifact(tui, command, await artifact);
+                                        if (exitCode !== 0) {
+                                            const detail = exitCode === null ? "could not be started" : `exited with code ${String(exitCode)}`;
+                                            ctx.ui.notify(`Cannot open ${label}: external editor ${detail}.`, "warning");
+                                        }
+                                    }
+                                    catch (error) {
+                                        ctx.ui.notify(`Cannot open ${label}: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                                    }
+                                    finally {
+                                        editorRunning = false;
+                                        tui.requestRender(true);
+                                    }
                                 };
-                                const updateDashboard = async (selectedOption) => {
+                                const updateDashboard = async () => {
+                                    const generation = ++refreshGeneration;
+                                    const hadExpandableNodes = tree.nodes.some((node) => node.children.length > 0);
                                     const next = await loadDashboard();
-                                    if (disposed)
+                                    if (disposed || generation !== refreshGeneration)
                                         return;
+                                    const previousNodeId = selectedNodeId;
+                                    const previousExpanded = expandedNodeIds;
+                                    const selectedAction = actionMode ? actionOptions()[actionIndex] : undefined;
                                     view = next;
-                                    options = [...view.actions.keys(), "Close"];
-                                    selectedIndex = Math.max(0, options.indexOf(selectedOption ?? ""));
+                                    tree = buildWorkflowPhaseTree(view.phaseModel);
+                                    selectedNodeId = preserveWorkflowPhaseTreeSelection(tree, { nodeId: previousNodeId }).nodeId;
+                                    expandedNodeIds = new Set([...previousExpanded].filter((id) => tree.byId.has(id)));
+                                    if (!hadExpandableNodes && !expandedNodeIds.size && tree.nodes.some((node) => node.children.length > 0))
+                                        expandedNodeIds = new Set(workflowPhaseTreeInitialExpanded(tree));
+                                    const nextActions = actionOptions();
+                                    const preservedActionIndex = selectedAction ? nextActions.indexOf(selectedAction) : -1;
+                                    actionIndex = preservedActionIndex >= 0 ? preservedActionIndex : selectedAction ? nextActions.length - 1 : Math.min(actionIndex, Math.max(0, nextActions.length - 1));
+                                    selectionNeedsScroll = true;
                                     tui.requestRender();
                                 };
                                 const requestStop = () => {
@@ -2443,16 +3189,16 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     stopRequested = true;
                                     stopStatus = undefined;
                                     setWorkflowStatus(undefined);
-                                    const selectedOption = options[selectedIndex];
                                     void runAction(`stop ${store.runId}`, true, (status) => {
                                         stopStatus = status;
                                         setWorkflowStatus(status);
                                         if (!disposed)
                                             tui.requestRender();
-                                    }).then(() => updateDashboard(selectedOption)).catch((error) => {
+                                    }).then(() => updateDashboard()).catch((error) => {
                                         if (disposed)
                                             return;
                                         stopStatus = `Could not stop workflow ${store.runId}: ${error instanceof Error ? error.message : String(error)}`;
+                                        setWorkflowStatus(stopStatus);
                                         tui.requestRender();
                                     }).finally(() => {
                                         stopRequested = false;
@@ -2464,59 +3210,181 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     if (refreshing || stopRequested)
                                         return;
                                     refreshing = true;
-                                    const selectedOption = options[selectedIndex];
-                                    void updateDashboard(selectedOption).catch(() => undefined).finally(() => { refreshing = false; });
+                                    void updateDashboard().catch(() => undefined).finally(() => { refreshing = false; });
                                 }, 1000);
                                 timer.unref();
                                 return borderWorkflowOverlay({
                                     render(width) {
-                                        const dashboard = stopStatus ? `${view.dashboard}\n\n${stopStatus}` : view.dashboard;
-                                        const dashboardLines = truncateToVisualLines(theme.fg("accent", dashboard), Number.MAX_SAFE_INTEGER, width, 1).visualLines;
-                                        const actionLines = options.map((option, index) => truncateToVisualLines(`${index === selectedIndex ? "→ " : "  "}${option}`, Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "");
-                                        const layout = dashboardLayout();
-                                        const hint = truncateToVisualLines(theme.fg("dim", `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} navigate${dashboardLines.length > layout.dashboardViewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · ${keyLabel("tui.select.confirm", "enter")} select · ${keyLabel("tui.select.cancel", "esc")} close · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
-                                        const compact = [...dashboardLines, "", ...actionLines, "", hint];
-                                        if (compact.length <= layout.rows) {
-                                            dashboardOffset = 0;
-                                            return compact;
+                                        renderedWidth = width;
+                                        const narrow = width < 80;
+                                        const styles = themeWorkflowProgressStyles(theme);
+                                        const agent = selectedAgentRecord();
+                                        const actions = actionMode ? { title: agent ? "Agent actions" : "Run actions", options: actionOptions(), index: actionIndex } : undefined;
+                                        const phaseLines = formatWorkflowPhaseDashboard(view.run, view.snapshot, width, { nodeId: selectedNodeId, expandedNodeIds: [...expandedNodeIds], ...(narrow && !detailsMode ? { treeOnly: true } : {}), ...(narrow && detailsMode ? { detailsOnly: true } : {}), ...(actions ? { actions } : {}) }, styles);
+                                        const statusLines = stopStatus ? truncateToVisualLines(styles.error(stopStatus), Number.MAX_SAFE_INTEGER, width, 0).visualLines.map((line) => line.trimEnd()) : [];
+                                        const content = [...statusLines, ...phaseLines];
+                                        const rows = terminalRows();
+                                        const hintRows = rows >= 3 ? 1 : 0;
+                                        const viewport = Math.max(1, rows - hintRows);
+                                        const maxOffset = Math.max(0, content.length - viewport);
+                                        dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
+                                        if (actionMode) {
+                                            const label = actions?.options[actionIndex];
+                                            const actionRow = label ? content.findIndex((line) => line.includes(label)) : -1;
+                                            if (actionRow >= 0) {
+                                                if (actionRow < dashboardOffset)
+                                                    dashboardOffset = actionRow;
+                                                else if (actionRow >= dashboardOffset + viewport)
+                                                    dashboardOffset = actionRow - viewport + 1;
+                                            }
+                                        }
+                                        else if (!detailsMode && selectionNeedsScroll) {
+                                            const selectedRow = content.findIndex((line) => line.startsWith("→"));
+                                            if (selectedRow >= 0) {
+                                                if (selectedRow < dashboardOffset)
+                                                    dashboardOffset = selectedRow;
+                                                else if (selectedRow >= dashboardOffset + viewport)
+                                                    dashboardOffset = selectedRow - viewport + 1;
+                                            }
+                                            selectionNeedsScroll = false;
                                         }
-                                        const maxOffset = Math.max(0, dashboardLines.length - layout.dashboardViewport);
                                         dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
-                                        const actionStart = Math.min(Math.max(0, selectedIndex - layout.actionViewport + 1), Math.max(0, options.length - layout.actionViewport));
-                                        return [
-                                            ...dashboardLines.slice(dashboardOffset, dashboardOffset + layout.dashboardViewport),
-                                            ...(layout.separatorRows && layout.dashboardViewport ? [""] : []),
-                                            ...actionLines.slice(actionStart, actionStart + layout.actionViewport),
-                                            ...(layout.hintRows ? [hint] : []),
-                                        ];
+                                        const hint = truncateToVisualLines(theme.fg("dim", actionMode ? `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.select.confirm", "enter")} run · ${keyLabel("tui.select.cancel", "esc")} tree` : `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} tree · ${keyLabel("tui.editor.cursorLeft", "←")}/${keyLabel("tui.editor.cursorRight", "→")} collapse/expand · ${keyLabel("tui.select.confirm", "enter")} inspect · a actions · ${keyLabel("tui.select.cancel", "esc")} ${narrow && detailsMode ? "tree" : "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] ?? "";
+                                        return [...content.slice(dashboardOffset, dashboardOffset + viewport), ...(hintRows ? [hint] : [])];
                                     },
                                     invalidate() { },
                                     handleInput(data) {
-                                        if (stopRequested)
+                                        if (stopRequested || editorRunning)
+                                            return;
+                                        const narrow = renderedWidth < 80;
+                                        if (!actionMode && (data === "a" || data === "A")) {
+                                            actionMode = true;
+                                            actionIndex = 0;
+                                            dashboardOffset = 0;
+                                            tui.requestRender();
                                             return;
-                                        if (keybindings.matches(data, "tui.select.up"))
-                                            selectedIndex = (selectedIndex + options.length - 1) % options.length;
-                                        else if (keybindings.matches(data, "tui.select.down"))
-                                            selectedIndex = (selectedIndex + 1) % options.length;
-                                        else if (keybindings.matches(data, "tui.select.pageUp")) {
-                                            dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, dashboardLayout().dashboardViewport));
                                         }
-                                        else if (keybindings.matches(data, "tui.select.pageDown")) {
-                                            dashboardOffset += Math.max(1, dashboardLayout().dashboardViewport);
+                                        if (actionMode) {
+                                            const options = actionOptions();
+                                            if (keybindings.matches(data, "tui.select.cancel")) {
+                                                actionMode = false;
+                                                dashboardOffset = 0;
+                                                tui.requestRender();
+                                                return;
+                                            }
+                                            if (keybindings.matches(data, "tui.select.up"))
+                                                actionIndex = (actionIndex + options.length - 1) % options.length;
+                                            else if (keybindings.matches(data, "tui.select.down"))
+                                                actionIndex = (actionIndex + 1) % options.length;
+                                            else if (keybindings.matches(data, "tui.select.pageUp"))
+                                                dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
+                                            else if (keybindings.matches(data, "tui.select.pageDown"))
+                                                dashboardOffset += Math.max(1, terminalRows() - 1);
+                                            else if (keybindings.matches(data, "tui.select.confirm")) {
+                                                const action = options[actionIndex];
+                                                const agent = selectedAgentRecord();
+                                                if (!action || action === "Back") {
+                                                    actionMode = false;
+                                                    dashboardOffset = 0;
+                                                }
+                                                else if (agent) {
+                                                    const worktree = agentWorktreeFor(view, agent);
+                                                    if (action === "Open result in editor") {
+                                                        const result = view.agentResults.get(agent.id);
+                                                        if (result !== undefined)
+                                                            void openArtifact(Promise.resolve(workflowResultArtifact(result)), "agent result");
+                                                    }
+                                                    else if (action === "Copy agent ID")
+                                                        void copyArtifact(agent.id, "agent ID");
+                                                    else if (action === "Copy branch" && worktree)
+                                                        void copyArtifact(worktree.branch, "branch");
+                                                    else if (action === "Copy worktree path" && worktree)
+                                                        void copyArtifact(worktree.path, "worktree path");
+                                                    else
+                                                        done(`__workflow_fork__:${agent.id}`);
+                                                }
+                                                else if (action === "Open script in editor")
+                                                    void openArtifact(readFile(join(store.directory, "workflow.js"), "utf8").then(workflowScriptArtifact), "workflow script");
+                                                else if (action === "Stop")
+                                                    requestStop();
+                                                else
+                                                    done(action);
+                                            }
+                                            tui.requestRender();
+                                            return;
                                         }
-                                        else if (keybindings.matches(data, "tui.select.confirm")) {
-                                            if (options[selectedIndex] === "Stop")
-                                                requestStop();
+                                        const current = selectedNodeId ? tree.byId.get(selectedNodeId) : tree.nodes[0];
+                                        if (keybindings.matches(data, "tui.select.cancel")) {
+                                            if (narrow && detailsMode) {
+                                                detailsMode = false;
+                                                selectionNeedsScroll = true;
+                                            }
                                             else
-                                                done(options[selectedIndex]);
+                                                done(undefined);
+                                        }
+                                        else if (narrow && detailsMode) {
+                                            if (keybindings.matches(data, "tui.select.pageUp"))
+                                                dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
+                                            else if (keybindings.matches(data, "tui.select.pageDown"))
+                                                dashboardOffset += Math.max(1, terminalRows() - 1);
+                                            else if (keybindings.matches(data, "tui.select.confirm")) {
+                                                if (current?.kind === "agent" && current.agentId) {
+                                                    actionMode = true;
+                                                    actionIndex = 0;
+                                                }
+                                                else if (current?.children.length) {
+                                                    if (expandedNodeIds.has(current.id))
+                                                        expandedNodeIds.delete(current.id);
+                                                    else
+                                                        expandedNodeIds.add(current.id);
+                                                }
+                                            }
+                                        }
+                                        else if (keybindings.matches(data, "tui.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")) {
+                                            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")) {
+                                            const next = navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, "up");
+                                            selectedNodeId = next.nodeId;
+                                            selectionNeedsScroll = true;
+                                        }
+                                        else if (keybindings.matches(data, "tui.select.down")) {
+                                            const next = navigateWorkflowPhaseTree(tree, selectedNodeId, expandedNodeIds, "down");
+                                            selectedNodeId = next.nodeId;
+                                            selectionNeedsScroll = true;
+                                        }
+                                        else if (keybindings.matches(data, "tui.select.pageUp"))
+                                            dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, terminalRows() - 1));
+                                        else if (keybindings.matches(data, "tui.select.pageDown"))
+                                            dashboardOffset += Math.max(1, terminalRows() - 1);
+                                        else if (keybindings.matches(data, "tui.select.confirm")) {
+                                            if (narrow)
+                                                detailsMode = true;
+                                            else if (current?.kind === "agent" && current.agentId) {
+                                                actionMode = true;
+                                                actionIndex = 0;
+                                            }
+                                            else if (current?.children.length) {
+                                                if (expandedNodeIds.has(current.id))
+                                                    expandedNodeIds.delete(current.id);
+                                                else
+                                                    expandedNodeIds.add(current.id);
+                                            }
                                         }
-                                        else if (keybindings.matches(data, "tui.select.cancel"))
-                                            done(undefined);
                                         tui.requestRender();
                                     },
                                     dispose() { disposed = true; clearInterval(timer); setWorkflowStatus(undefined); },
                                 }, theme);
-                            }, { overlay: true })
+                            }, { overlay: true, overlayOptions: WORKFLOW_OVERLAY_OPTIONS })
                             : await ctx.ui.select(view.dashboard, [...view.actions.keys(), "Close"]);
                         if (!actionChoice || actionChoice === "Close")
                             return;
@@ -2524,48 +3392,19 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             await selectAgent(view);
                             continue;
                         }
-                        if (actionChoice === "Refresh")
+                        if (actionChoice.startsWith("__workflow_agent__:")) {
+                            await selectAgent(view, actionChoice.slice("__workflow_agent__:".length));
                             continue;
-                        if (actionChoice === "View script") {
-                            await ctx.ui.custom((tui, theme, keybindings, done) => {
-                                const highlighted = highlightCode(view.script, "javascript");
-                                let offset = 0;
-                                let renderedLines = [];
-                                const viewport = () => Math.max(1, tuiRows(tui) - 3 - WORKFLOW_OVERLAY_BORDER_ROWS);
-                                const move = (delta) => {
-                                    const maxOffset = Math.max(0, renderedLines.length - viewport());
-                                    offset = Math.max(0, Math.min(maxOffset, offset + delta));
-                                };
-                                return borderWorkflowOverlay({
-                                    render(width) {
-                                        renderedLines = highlighted.flatMap((line) => line ? truncateToVisualLines(line, Number.MAX_SAFE_INTEGER, width, 0).visualLines : [""]);
-                                        const maxOffset = Math.max(0, renderedLines.length - viewport());
-                                        offset = Math.min(offset, maxOffset);
-                                        return [
-                                            theme.fg("accent", "Workflow script"),
-                                            ...renderedLines.slice(offset, offset + viewport()),
-                                            "",
-                                            theme.fg("dim", "↑↓/pgup/pgdn scroll · esc close"),
-                                        ];
-                                    },
-                                    invalidate() { },
-                                    handleInput(data) {
-                                        if (keybindings.matches(data, "tui.select.up"))
-                                            move(-1);
-                                        else if (keybindings.matches(data, "tui.select.down"))
-                                            move(1);
-                                        else if (keybindings.matches(data, "tui.select.pageUp"))
-                                            move(-viewport());
-                                        else if (keybindings.matches(data, "tui.select.pageDown"))
-                                            move(viewport());
-                                        else if (keybindings.matches(data, "tui.select.cancel"))
-                                            done(undefined);
-                                        tui.requestRender();
-                                    },
-                                }, theme);
-                            }, { overlay: true, overlayOptions: { anchor: "top-left", width: "100%", maxHeight: "100%" } });
+                        }
+                        if (actionChoice.startsWith("__workflow_fork__:")) {
+                            const agentId = actionChoice.slice("__workflow_fork__:".length);
+                            const agent = view.agents.find((candidate) => candidate.id === agentId);
+                            if (agent)
+                                await forkAgentSession(view, agent);
                             continue;
                         }
+                        if (actionChoice === "Refresh")
+                            continue;
                         const copy = view.copies.get(actionChoice);
                         if (copy) {
                             await copyArtifact(copy.value, copy.artifact);
@@ -2629,7 +3468,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                         tui.requestRender();
                                     },
                                 }, theme);
-                            }, { overlay: true, overlayOptions: { anchor: "top-left", width: "100%", maxHeight: "100%" } });
+                            }, { overlay: true, overlayOptions: WORKFLOW_OVERLAY_OPTIONS });
                             if (decision) {
                                 const accepted = await answerCheckpoint(store.runId, checkpoint.name, decision === "Approve", true);
                                 if (!accepted)
@@ -2656,16 +3495,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     pi.on("session_shutdown", async () => {
         try {
             await Promise.all([...runs.entries()].map(async ([runId, run]) => {
-                if (["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state)) {
-                    await run.completion?.catch(() => undefined);
-                    return;
-                }
-                if (!["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state)) {
+                const isTerminal = SHUTDOWN_TERMINAL_RUN_STATES.has(run.lifecycle.state);
+                if (!isTerminal) {
                     try {
                         await run.lifecycle.terminal("interrupted");
                     }
                     catch (error) {
-                        if (!["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state))
+                        if (!SHUTDOWN_TERMINAL_RUN_STATES.has(run.lifecycle.state))
                             throw error;
                     }
                     run.abortController.abort();