pi-extensible-workflows 3.0.0 → 3.2.0

package/src/host.ts

@@ -1,22 +1,27 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Type } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
-import { copyToClipboard, getAgentDir, highlightCode, truncateToVisualLines, type ExtensionAPI, type Theme } from "@earendil-works/pi-coding-agent";
-import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor, type AgentActivity, type AgentAttempt, type AgentDefinition, type AgentProgress, type AgentProviderFailure, type AgentProviderRecovery, type RegisteredAgentSetupHook, type SessionFactory } from "./agent-execution.js";
+import { copyToClipboard, getAgentDir, SettingsManager, truncateToVisualLines, type ExtensionAPI, type Theme } from "@earendil-works/pi-coding-agent";
+import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor, type AgentActivity, type AgentAttempt, type AgentDefinition, type AgentProgress, type AgentProviderFailure, type AgentProviderRecovery, type SessionFactory } from "./agent-execution.js";
 import { herdrPaneId, openHerdrPane } from "./herdr.js";
 import { acquireSessionLease, listRunIds, RunStore, SessionLease, structuralPath as operationPath } from "./persistence.js";
 import type { AwaitingCheckpoint, PersistedRun, WorktreeReference } 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, type WorkflowRegistryApi } from "./registry.js";
 import { agentIdentityPath, agentWorktree, encoded, executeShellCommand, persistActiveAgentAttempt, persistAgentAttempts, readShellResult, runWorkflow, shellIdentityPath } from "./execution.js";
-import { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WORKFLOW_AGENT_STATE_CHANGED_EVENT, WORKFLOW_BUDGET_EVENT, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, WORKFLOW_PHASE_CHANGED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, WORKFLOW_WORKTREE_CREATED_EVENT, WorkflowError, type AgentAttemptSummary, type AgentOptions, type AgentRecord, type BudgetApprovalRequest, type BudgetEvent, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type WorkflowBridge, type WorkflowCheckpointState, type WorkflowErrorCode, type WorkflowErrorShape, type WorkflowEventBase, type WorkflowFailureAgent, type WorkflowFailureDiagnostics, type WorkflowFunctionContext, type WorkflowExecution, type WorkflowMetadata, type WorkflowRetryProvenance, type WorkflowRunContext, type WorkflowSiblingAgent, type WorkflowWorktreeReference } from "./types.js";
+import { openWorkflowArtifact, workflowResultArtifact, workflowScriptArtifact, type WorkflowArtifact } from "./workflow-artifacts.js";
+import { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WORKFLOW_AGENT_STATE_CHANGED_EVENT, WORKFLOW_BUDGET_EVENT, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, WORKFLOW_PHASE_CHANGED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, WORKFLOW_WORKTREE_CREATED_EVENT, WorkflowError, type AgentOptions, type AgentRecord, type AgentResourcePolicy, type BudgetApprovalRequest, type BudgetEvent, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type WorkflowBridge, type WorkflowCatalogFunction, type WorkflowCatalogIndex, type WorkflowCatalogVariable, type WorkflowCheckpointState, type WorkflowErrorCode, type WorkflowErrorShape, type WorkflowEventBase, type WorkflowFailureAgent, type WorkflowFailureDiagnostics, type WorkflowFunctionContext, type WorkflowExecution, type WorkflowMetadata, type WorkflowModelAliasResolverContext, type WorkflowRetryProvenance, type WorkflowRunContext, type WorkflowSettings, type WorkflowSettingsResolution, type WorkflowSiblingAgent, type WorkflowWorktreeReference } from "./types.js";
 const SETTLED_AGENT_STATES: ReadonlySet<import("./types.js").AgentState> = new Set(["completed", "failed", "cancelled"]);
+const INTERNAL_WORKFLOW_TOOLS: readonly string[] = ["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"];
+const HARD_TERMINAL_RUN_STATES: ReadonlySet<string> = new Set(["completed", "failed", "stopped"]);
+const SHUTDOWN_TERMINAL_RUN_STATES: ReadonlySet<string> = new Set(["completed", "failed", "stopped", "budget_exhausted"]);
 export interface WorkflowProgressStyles {
   accent(text: string): string;
   success(text: string): string;
@@ -26,7 +31,25 @@ export interface WorkflowProgressStyles {
   dim(text: string): string;
   bold(text: string): string;
 }
+function snapshotResourcePolicy(snapshot: Readonly<LaunchSnapshot>, cwd: string, projectTrusted: boolean, globalSettingsPath: string): AgentResourcePolicy {
+  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: WorkflowProgressStyles = { accent: (text) => text, success: (text) => text, error: (text) => text, warning: (text) => text, muted: (text) => text, dim: (text) => text, bold: (text) => text };
+type WorkflowLaunchSettings = { settings: Readonly<WorkflowSettings>; resolution: WorkflowSettingsResolution; resourcePolicy: AgentResourcePolicy };
+function workflowLaunchSettings(cwd: string, projectTrusted: boolean, globalSettingsPath: string, concurrency?: number): WorkflowLaunchSettings {
+  const resolution = resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath);
+  const settings = Object.freeze({ ...resolution.effective, ...(concurrency === undefined ? {} : { concurrency }) });
+  return { settings, resolution, resourcePolicy: resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath) };
+}
+function frozenResourcePolicy(policy: AgentResourcePolicy): () => AgentResourcePolicy { return () => structuredClone(policy); }
+function resumedSnapshotSettings(snapshot: Readonly<LaunchSnapshot>, resolution: WorkflowSettingsResolution, modelAliases: Readonly<Record<string, string>>): { settings: WorkflowSettings; settingsSources?: NonNullable<LaunchSnapshot["settingsSources"]> } {
+  const settings: WorkflowSettings = { ...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: string): string {
@@ -71,7 +94,6 @@ function mainAgentError(error: unknown): WorkflowError {
   const typed = asWorkflowError(error);
   const presented = new WorkflowError(typed.code, formatWorkflowFailure(typed));
   Object.assign(presented, typed);
-  presented.message = formatWorkflowFailure(typed);
   return presented;
 }
 
@@ -126,7 +148,7 @@ export class RunLifecycle {
   }
 
   async terminal(state: "completed" | "failed" | "stopped" | "interrupted" | "budget_exhausted", reason?: string): Promise<void> {
-    if (["completed", "failed", "stopped"].includes(this.#state)) throw new WorkflowError("RESUME_INCOMPATIBLE", `${this.#state} runs are terminal`);
+    if (HARD_TERMINAL_RUN_STATES.has(this.#state)) throw new WorkflowError("RESUME_INCOMPATIBLE", `${this.#state} runs are terminal`);
     await this.#set(state, reason ?? state);
     for (const resolve of this.#waiters.splice(0)) resolve();
   }
@@ -146,23 +168,276 @@ export function formatWorkflowPreview(args: { script?: unknown; workflow?: unkno
   return [`workflow ${name}`, typeof args.description === "string" && args.description.trim() ? args.description.trim() : ""].filter(Boolean).join("\n");
 }
 export const WORKFLOW_TOOL_LABEL = "Workflow";
-export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow";
-export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow that orchestrates subagents. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Runs in the background by default; completion arrives as a follow-up message. Foreground results include the completed run ID. Use workflow_retry with an explicit failed run ID to replay completed structural operations; parentRunId only reuses named worktrees.";
+export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline parallel-to-summary path by default";
+export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow. Prefer a named inline script that fans out independent work with parallel(...), awaits the keyed results before interpolating them into one summarizing agent(...), and returns. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Advanced controls include registered functions, outputSchema, budgets, checkpoints, worktrees, retry/resume, CLI export, and pipelines. Use workflow_retry with an explicit failed run ID; parentRunId only reuses named worktrees. Runs are in the background by default; completion arrives as a follow-up message. Set foreground: true when the caller must wait for the final value. 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: "resume" | "retry", state: RunState): string {
+  if (action === "resume") {
+    if (state === "failed") return "Failed workflow runs must use workflow_retry({ runId })";
+    if (state === "completed") return "Completed workflow runs have no recovery action";
+    if (state === "stopped") return "Stopped workflow runs have no recovery action; launch a new workflow";
+    if (state === "interrupted") return "Interrupted workflow runs use /workflow resume, not workflow_resume";
+    return `Only budget-exhausted runs can be resumed with workflow_resume; source is ${state}`;
+  }
+  if (state === "budget_exhausted") return "Budget-exhausted workflow runs must use workflow_resume({ runId, budget? })";
+  if (state === "completed") return "Completed workflow runs have no recovery action";
+  if (state === "stopped") return "Stopped workflow runs cannot be retried; launch a new workflow";
+  if (state === "interrupted") return "Interrupted workflow runs use /workflow resume, not workflow_retry";
+  return `Only failed workflow runs can be retried; source is ${state}`;
+}
 export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
-  name: Type.Optional(Type.String({ description: "Required non-empty name for inline workflow runs; invalid for registered function launches" })),
+  name: Type.Optional(Type.String({ description: "Required non-empty name for the default inline workflow path; invalid for registered function launches" })),
   description: Type.Optional(Type.String({ description: "Optional human-readable workflow description" })),
-  script: Type.Optional(Type.String({ description: "Immutable workflow source without metadata" })),
-  workflow: Type.Optional(Type.String({ description: "Registered reusable function as an unqualified name" })),
+  script: Type.Optional(Type.String({ description: "Immutable inline workflow source; default to a named script that fans out with parallel(...) and awaits results before passing them to a summarizing agent(...)" })),
+  workflow: Type.Optional(Type.String({ description: "Advanced: registered reusable function as an unqualified name" })),
   args: Type.Optional(Type.Unknown({ description: "JSON-compatible workflow arguments" })),
-  foreground: Type.Optional(Type.Boolean({ description: "Wait for completion instead of running in the background" })),
-  concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 16 })),
-  budget: Type.Optional(Type.Unknown({ description: "Optional aggregate soft and hard run budgets" })),
-  parentRunId: Type.Optional(Type.String({ description: "Terminal run whose named worktrees may be reused" })),
+  foreground: Type.Optional(Type.Boolean({ description: "Wait for completion instead of the default background launch" })),
+  concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 16, description: "Advanced: optional per-run active-agent limit" })),
+  budget: Type.Optional(Type.Unknown({ description: "Advanced: optional aggregate soft and hard run budgets" })),
+  parentRunId: Type.Optional(Type.String({ description: "Advanced: terminal run whose named worktrees may be reused" })),
 });
 export const WORKFLOW_RETRY_PARAMETERS = Type.Object({ runId: Type.String({ description: "Explicit failed workflow run ID" }) });
 
 type WorkflowToolUpdate = { content: [{ type: "text"; text: string }]; details: { runId: string; run: PersistedRun } };
-
+export type WorkflowPhaseState = "not started" | "running" | "completed" | "failed" | "cancelled" | "interrupted" | "budget_exhausted";
+export interface WorkflowPhaseAgentCounts { total: number; completed: number; running: number; failed: number; cancelled: number; pending: number }
+export interface WorkflowPhaseView { id: string; name: string; occurrence: number; state: WorkflowPhaseState; observed: boolean; afterAgent?: number; agents: readonly AgentRecord[]; counts: WorkflowPhaseAgentCounts }
+export interface WorkflowPhaseModel { declaredPhases: readonly string[]; phases: readonly WorkflowPhaseView[]; currentPhaseIndex?: number; currentPhaseId?: string; counts: Readonly<Partial<Record<WorkflowPhaseState, number>>>; unassignedAgents?: readonly AgentRecord[] }
+type WorkflowPhaseSource = readonly string[] | Pick<LaunchSnapshot, "phases"> | undefined;
+function phaseNames(source: WorkflowPhaseSource): string[] {
+  const phases: readonly unknown[] = source === undefined ? [] : Array.isArray(source) ? source : (source as Pick<LaunchSnapshot, "phases">).phases ?? [];
+  return phases.filter((phase): phase is string => typeof phase === "string" && phase.trim() !== "").map((phase) => phase.trim());
+}
+function phaseAgentCounts(agents: readonly AgentRecord[]): WorkflowPhaseAgentCounts {
+  const counts: WorkflowPhaseAgentCounts = { 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: RunState, counts: WorkflowPhaseAgentCounts, isLatest: boolean): WorkflowPhaseState {
+  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: Pick<PersistedRun, "state" | "phase" | "phaseHistory" | "agents">, source?: WorkflowPhaseSource): WorkflowPhaseModel {
+  const declaredPhases = phaseNames(source);
+  const rawHistory: readonly unknown[] = Array.isArray(run.phaseHistory) ? run.phaseHistory : [];
+  const observed: Array<{ name: string; afterAgent: number }> = [];
+  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<number>();
+  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: Array<{ name: string; observedIndex?: number; declarationIndex?: number }> = 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<string, number>();
+  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: number | undefined;
+  for (let index = phases.length - 1; index >= 0; index -= 1) { if (phases[index]?.observed) { currentPhaseIndex = index; break; } }
+  const counts: Partial<Record<WorkflowPhaseState, number>> = {};
+  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: WorkflowPhaseModel = { declaredPhases, phases, counts };
+  if (current !== undefined && currentPhaseIndex !== undefined) { result.currentPhaseIndex = currentPhaseIndex; result.currentPhaseId = current.id; }
+  if (unassignedAgents.length) result.unassignedAgents = unassignedAgents;
+  return result;
+}
+export interface WorkflowPhaseSelection { phaseId?: string | undefined; agentId?: string | undefined; nodeId?: string | undefined; expandedNodeIds?: readonly string[] | undefined; treeOnly?: boolean | undefined; detailsOnly?: boolean | undefined; actions?: { title: string; options: readonly string[]; index: number } | undefined }
+export type WorkflowPhaseTreeNodeKind = "phase" | "operation" | "agent";
+export interface WorkflowPhaseTreeNode { id: string; kind: WorkflowPhaseTreeNodeKind; label: string; depth: number; phaseId: string; operationPath: readonly string[]; parentId?: string; children: readonly string[]; state: WorkflowPhaseState | AgentRecord["state"]; agentId?: string; agent?: AgentRecord; phase?: WorkflowPhaseView }
+export interface WorkflowPhaseTree { roots: readonly string[]; nodes: readonly WorkflowPhaseTreeNode[]; byId: ReadonlyMap<string, WorkflowPhaseTreeNode> }
+export interface WorkflowPhaseTreeSelection { nodeId?: string | undefined }
+export type WorkflowPhaseTreeDirection = "up" | "down" | "left" | "right";
+function workflowPhaseTreePath(kind: WorkflowPhaseTreeNodeKind, phaseId: string, operationPath: readonly string[], agentId?: string): string {
+  const root = `phase/${encodeURIComponent(phaseId)}`;
+  if (kind === "phase") return root;
+  const operation = operationPath.map((part) => encodeURIComponent(part)).join("/");
+  if (kind === "operation") return `${root}/operation/${operation}`;
+  return operation ? `${root}/operation/${operation}/agent/${encodeURIComponent(agentId ?? "")}` : `${root}/agent/${encodeURIComponent(agentId ?? "")}`;
+}
+function workflowPhaseTreeAggregateState(states: readonly AgentRecord["state"][]): AgentRecord["state"] {
+  if (!states.length || states.every((state) => state === "completed")) return "completed";
+  if (states.some((state) => state === "failed")) return "failed";
+  if (states.some((state) => state === "cancelled")) return "cancelled";
+  if (states.some((state) => state === "running")) return "running";
+  return "queued";
+}
+export function buildWorkflowPhaseTree(model: WorkflowPhaseModel): WorkflowPhaseTree {
+  type Draft = Omit<WorkflowPhaseTreeNode, "children"> & { children: string[] };
+  type AgentEntry = { agent: AgentRecord; node: Draft; path: readonly string[]; defaultParentId: string };
+  const drafts = new Map<string, Draft>();
+  const roots: string[] = [];
+  const add = (node: Omit<Draft, "children">, parentId?: string): Draft => {
+    const existing = drafts.get(node.id);
+    if (existing) return existing;
+    const draft: Draft = { ...node, ...(parentId === undefined ? {} : { parentId }), children: [] };
+    drafts.set(draft.id, draft);
+    if (parentId === undefined) roots.push(draft.id); else drafts.get(parentId)?.children.push(draft.id);
+    return draft;
+  };
+  const samePath = (left: readonly string[], right: readonly string[]): boolean => left.length === right.length && left.every((part, index) => part === right[index]);
+  const addPhase = (phaseId: string, label: string, agents: readonly AgentRecord[], phase?: WorkflowPhaseView): void => {
+    const phaseNode = add({ id: workflowPhaseTreePath("phase", phaseId, []), kind: "phase", label, depth: 0, phaseId, operationPath: [], state: phase?.state ?? workflowPhaseTreeAggregateState(agents.map((agent) => agent.state)), ...(phase ? { phase } : {}) });
+    const operationNodes = new Map<string, Draft>();
+    const entries: AgentEntry[] = agents.map((agent) => ({ agent, path: [...(agent.structuralPath ?? [])], node: undefined as unknown as Draft, defaultParentId: phaseNode.id }));
+    const agentEntries = new Map(entries.map((entry) => [entry.agent.id, entry]));
+    const acceptedParents = new Map<string, string>();
+    const wouldCycle = (childId: string, parentId: string): boolean => {
+      const seen = new Set<string>([childId]);
+      let current: string | undefined = parentId;
+      while (current) {
+        if (seen.has(current)) return true;
+        seen.add(current);
+        current = acceptedParents.get(current);
+      }
+      return false;
+    };
+    for (const entry of entries) {
+      const parent = entry.agent.parentId ? agentEntries.get(entry.agent.parentId) : undefined;
+      if (parent && !wouldCycle(entry.agent.id, parent.agent.id)) acceptedParents.set(entry.agent.id, parent.agent.id);
+    }
+    const operationChain = (path: readonly string[], owner: Draft, startIndex = 0): Draft => {
+      let parent = owner;
+      for (let index = startIndex; index < path.length; index += 1) {
+        const prefix = path.slice(0, index + 1);
+        const key = `${owner.id}:${JSON.stringify(prefix)}`;
+        const existing = operationNodes.get(key);
+        if (existing) { parent = existing; continue; }
+        const suffix = path.slice(startIndex, index + 1).map((part) => encodeURIComponent(part)).join("/");
+        const id = owner.id === phaseNode.id ? workflowPhaseTreePath("operation", phaseId, prefix) : `${owner.id}/operation/${suffix}`;
+        const operation = add({ id, kind: "operation", label: prefix.at(-1) ?? "", depth: 0, phaseId, operationPath: prefix, state: "queued", ...(phase ? { phase } : {}) }, parent.id);
+        operationNodes.set(key, operation);
+        parent = operation;
+      }
+      return parent;
+    };
+    for (const entry of entries) {
+      if (!acceptedParents.has(entry.agent.id)) entry.defaultParentId = operationChain(entry.path, phaseNode).id;
+    }
+    for (const entry of entries) {
+      entry.node = add({ id: workflowPhaseTreePath("agent", phaseId, entry.path, entry.agent.id), kind: "agent", label: entry.agent.label ?? entry.agent.name, depth: 0, phaseId, operationPath: entry.path, state: entry.agent.state, agentId: entry.agent.id, agent: entry.agent }, phaseNode.id);
+    }
+    const attach = (entry: AgentEntry, parentId: string): void => {
+      const previous = entry.node.parentId ? drafts.get(entry.node.parentId) : undefined;
+      if (previous) previous.children = previous.children.filter((childId) => childId !== entry.node.id);
+      entry.node.parentId = parentId;
+      const parent = drafts.get(parentId);
+      if (parent && !parent.children.includes(entry.node.id)) parent.children.push(entry.node.id);
+    };
+    for (const entry of entries) {
+      const parentId = acceptedParents.get(entry.agent.id);
+      const parent = parentId ? agentEntries.get(parentId) : undefined;
+      if (parent) {
+        if (samePath(entry.path, parent.path)) entry.defaultParentId = parent.node.id;
+        else {
+          const commonLength = entry.path.findIndex((part, index) => parent.path[index] !== part);
+          const startIndex = commonLength < 0 ? Math.min(entry.path.length, parent.path.length) : commonLength;
+          entry.defaultParentId = operationChain(entry.path, parent.node, startIndex).id;
+        }
+      }
+      attach(entry, entry.defaultParentId);
+    }
+    const setDepth = (node: Draft, depth: number, seen = new Set<string>()): void => {
+      if (seen.has(node.id)) return;
+      seen.add(node.id);
+      node.depth = depth;
+      for (const childId of node.children) { const child = drafts.get(childId); if (child) setDepth(child, depth + 1, seen); }
+    };
+    setDepth(phaseNode, 0);
+    const statesFor = (node: Draft, seen = new Set<string>()): AgentRecord["state"][] => {
+      if (seen.has(node.id)) return [];
+      const nextSeen = new Set(seen).add(node.id);
+      return node.children.flatMap((childId) => {
+        const child = drafts.get(childId);
+        return child?.kind === "agent" ? [child.agent?.state ?? "queued", ...statesFor(child, nextSeen)] : child ? statesFor(child, nextSeen) : [];
+      });
+    };
+    for (const operation of operationNodes.values()) operation.state = workflowPhaseTreeAggregateState(statesFor(operation));
+  };
+  for (const phase of model.phases) addPhase(phase.id, `${phase.name}${phase.occurrence > 1 ? ` #${String(phase.occurrence)}` : ""}`, phase.agents, phase);
+  if (model.unassignedAgents?.length) addPhase("unassigned", "Unassigned", model.unassignedAgents);
+  const nodes = [...drafts.values()].map((node) => ({ ...node, children: [...node.children] }));
+  return { roots, nodes, byId: new Map(nodes.map((node) => [node.id, node])) };
+}
+export function workflowPhaseTreeVisibleNodes(tree: WorkflowPhaseTree, expanded: ReadonlySet<string> = new Set()): readonly WorkflowPhaseTreeNode[] {
+  const visible: WorkflowPhaseTreeNode[] = [];
+  const visit = (id: string): void => {
+    const node = tree.byId.get(id);
+    if (!node) return;
+    visible.push(node);
+    if (expanded.has(node.id)) for (const childId of node.children) visit(childId);
+  };
+  for (const root of tree.roots) visit(root);
+  return visible;
+}
+export function workflowPhaseTreeInitialExpanded(tree: WorkflowPhaseTree): ReadonlySet<string> {
+  return new Set(tree.nodes.filter((node) => node.children.length > 0).map((node) => node.id));
+}
+export function preserveWorkflowPhaseTreeSelection(tree: WorkflowPhaseTree, selection: WorkflowPhaseTreeSelection): WorkflowPhaseTreeSelection {
+  const node = (selection.nodeId ? tree.byId.get(selection.nodeId) : undefined) ?? tree.nodes[0];
+  return node ? { nodeId: node.id } : {};
+}
+export function navigateWorkflowPhaseTree(tree: WorkflowPhaseTree, selectedNodeId: string | undefined, expandedNodeIds: ReadonlySet<string>, direction: WorkflowPhaseTreeDirection): { nodeId?: string; expandedNodeIds: ReadonlySet<string> } {
+  const expanded = new Set(expandedNodeIds);
+  const current = (selectedNodeId ? tree.byId.get(selectedNodeId) : undefined) ?? tree.nodes[0];
+  if (!current) return { expandedNodeIds: expanded };
+  if (direction === "left") {
+    if (current.children.length && expanded.delete(current.id)) return { nodeId: current.id, expandedNodeIds: expanded };
+    return { nodeId: current.parentId ?? current.id, expandedNodeIds: expanded };
+  }
+  if (direction === "right") {
+    if (current.children.length && !expanded.has(current.id)) { expanded.add(current.id); return { nodeId: current.id, expandedNodeIds: expanded }; }
+    return { nodeId: current.children[0] ?? current.id, expandedNodeIds: expanded };
+  }
+  const visible = workflowPhaseTreeVisibleNodes(tree, expanded);
+  const index = Math.max(0, visible.findIndex((node) => node.id === current.id));
+  const next = visible[(index + (direction === "up" ? visible.length - 1 : 1)) % visible.length];
+  return { nodeId: next?.id ?? current.id, expandedNodeIds: expanded };
+}
+export function preserveWorkflowPhaseSelection(model: WorkflowPhaseModel, selection: WorkflowPhaseSelection): WorkflowPhaseSelection {
+  const phase = model.phases.find((candidate) => candidate.id === selection.phaseId) ?? (model.currentPhaseIndex === undefined ? undefined : model.phases[model.currentPhaseIndex]) ?? model.phases[0];
+  if (!phase) return model.unassignedAgents?.length ? { nodeId: workflowPhaseTreePath("phase", "unassigned", []) } : {};
+  const tree = buildWorkflowPhaseTree(model);
+  const selectedAgent = selection.agentId ? phase.agents.find((candidate) => candidate.id === selection.agentId) : undefined;
+  const selectedCandidate = selection.nodeId ? tree.byId.get(selection.nodeId) : undefined;
+  const selected = selectedCandidate?.phaseId === phase.id ? selectedCandidate : selectedAgent ? tree.byId.get(workflowPhaseTreePath("agent", phase.id, selectedAgent.structuralPath ?? [], selectedAgent.id)) : undefined;
+  const nodeId = selected?.id ?? tree.byId.get(workflowPhaseTreePath("phase", phase.id, []))?.id;
+  return { phaseId: phase.id, ...(selection.agentId && phase.agents.some((agent) => agent.id === selection.agentId) ? { agentId: selection.agentId } : phase.agents[0] ? { agentId: phase.agents[0].id } : {}), ...(nodeId ? { nodeId } : {}), ...(selection.expandedNodeIds ? { expandedNodeIds: selection.expandedNodeIds } : {}) };
+}
 type AgentGroup = { label: string; entries: readonly { agent: AgentRecord; index: number; depth: number }[] };
 function agentGroupKey(agent: AgentRecord): string { return JSON.stringify([agent.structuralPath ?? [], agent.parentBreadcrumb ?? null]); }
 function agentGroupLabel(agents: readonly AgentRecord[]): string {
@@ -175,7 +450,8 @@ function agentGroups(agents: readonly AgentRecord[], allAgents: readonly AgentRe
   const groups = new Map<string, { agents: Array<{ agent: AgentRecord; index: number; depth: number }> }>();
   for (const [index, agent] of agents.entries()) {
     let depth = 0;
-    for (let parent = agent.parentId; parent && byId.has(parent); parent = byId.get(parent)?.parentId) depth += 1;
+    const seen = new Set<string>([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 });
@@ -191,23 +467,32 @@ function renderGroupedAgents(agents: readonly AgentRecord[], render: (entry: { a
     ...group.entries.map((entry) => render(entry, grouped)),
   ]);
 }
-function progressStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string {
-  if (state === "completed") return (text) => styles.success(text);
-  if (state === "failed" || state === "cancelled") return (text) => styles.error(text);
-  if (state === "running") return (text) => styles.accent(text);
-  return (text) => styles.muted(text);
+const RUN_STATE_GLYPH: Record<string, string> = { completed: "✓", failed: "✗", stopped: "✗", budget_exhausted: "!", awaiting_input: "●" };
+const AGENT_STATE_GLYPH: Record<string, string> = { completed: "✓", failed: "✗", cancelled: "✗" };
+function runStateGlyph(state: string, running: string): string { return state === "running" ? running : RUN_STATE_GLYPH[state] ?? "◆"; }
+function agentStateGlyph(state: string, running: string): string { return state === "running" ? running : AGENT_STATE_GLYPH[state] ?? "○"; }
+type ProgressStyleKey = "success" | "error" | "warning" | "accent" | "muted";
+const PROGRESS_STATE_STYLE: Record<string, ProgressStyleKey> = { completed: "success", failed: "error", cancelled: "error", running: "accent" };
+const WORKFLOW_ICON_STYLE: Record<string, ProgressStyleKey> = { completed: "success", failed: "error", stopped: "error", budget_exhausted: "warning", running: "accent" };
+const PHASE_STATE_STYLE: Record<string, ProgressStyleKey> = { completed: "success", failed: "error", cancelled: "error", running: "accent", interrupted: "warning", budget_exhausted: "warning" };
+function styleForState(map: Record<string, ProgressStyleKey>, state: string, styles: WorkflowProgressStyles): (text: string) => string {
+  const key = map[state] ?? "muted";
+  return (text) => styles[key](text);
 }
+function progressStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(PROGRESS_STATE_STYLE, state, styles); }
+function workflowIconStyle(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(WORKFLOW_ICON_STYLE, state, styles); }
+function phaseStyleForState(state: string, styles: WorkflowProgressStyles): (text: string) => string { return styleForState(PHASE_STATE_STYLE, state, styles); }
 export function formatWorkflowProgress(run: PersistedRun, spinner = "◇", styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES): string {
   const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
-  const workflowIcon = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "budget_exhausted" ? "!" : run.state === "running" ? spinner : "◆";
-  const workflowIconStyle = run.state === "completed" ? (text: string) => styles.success(text) : run.state === "failed" || run.state === "stopped" ? (text: string) => styles.error(text) : run.state === "budget_exhausted" ? (text: string) => styles.warning(text) : run.state === "running" ? (text: string) => styles.accent(text) : (text: string) => styles.muted(text);
+  const workflowIcon = runStateGlyph(run.state, spinner);
+  const iconStyle = workflowIconStyle(run.state, styles);
   const header = styles.bold(styles.accent(`Workflow: ${run.workflowName} (${String(done)}/${String(run.agents.length)} done)`));
-  const lines = [`${workflowIconStyle(workflowIcon)} ${header}`];
+  const lines = [`${iconStyle(workflowIcon)} ${header}`];
   const budgetWarning = run.state === "budget_exhausted" || (run.budgetEvents ?? []).some((event) => event.type === "hard_exhausted");
   lines.push(...formatCompactBudgetStatus(run).map((line) => `  ${budgetWarning ? styles.warning(line) : line}`));
   const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
   const renderAgents = (agents: readonly AgentRecord[], offset: number, nested: boolean) => renderGroupedAgents(agents, ({ agent, index, depth }, grouped) => {
-    const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? spinner : "○";
+    const icon = agentStateGlyph(agent.state, spinner);
     const indent = "  ".repeat((grouped ? 2 : 1) + depth);
     const activity = SETTLED_AGENT_STATES.has(agent.state) ? "" : formatAgentActivity(agent, spinner, styles);
     const name = grouped ? agent.label ?? agent.name : styledAgentBreadcrumb(agent, byId, styles);
@@ -242,8 +527,189 @@ function textBlock(text: string) {
     invalidate() {},
   };
 }
+function styledTextBlock(text: string) {
+  return {
+    render(width: number) {
+      return truncateWorkflowProgress(text, width);
+    },
+    invalidate() {},
+  };
+}
+function workflowCatalogBlock(text: string, expanded: boolean) {
+  return {
+    render(width: number) {
+      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() {},
+  };
+}
+
+type WorkflowControlResult = { details?: unknown; content?: readonly { type: string; text?: string }[] };
+function controlString(value: unknown): string | undefined { return typeof value === "string" && value.trim() ? value : undefined; }
+function controlValue(value: unknown): string {
+  if (value === null) return "removed";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+  const json = JSON.stringify(value);
+  return typeof json === "string" ? json : "unknown";
+}
+function controlTitle(name: string, theme: Theme): string { return theme.fg("toolTitle", theme.bold(name)); }
+function controlState(state: string, theme: Theme): string {
+  const color = state === "completed" || state === "running" || state === "stopped" ? "success" : state === "failed" || state === "unknown" ? "error" : state === "budget_exhausted" || state === "awaiting_approval" ? "warning" : "accent";
+  return theme.fg(color, state);
+}
+function controlAction(action: string, theme: Theme): string {
+  const color = /approved|stopped|started|resumed/.test(action) ? "success" : /rejected|failed/.test(action) ? "error" : "warning";
+  return theme.fg(color, action);
+}
+function budgetPatchEntries(value: unknown): string[] {
+  if (!object(value)) return value === undefined ? [] : [controlValue(value)];
+  return Object.entries(value).map(([dimension, limits]) => {
+    if (limits === null) return `${dimension}=removed`;
+    if (!object(limits)) return `${dimension}=${controlValue(limits)}`;
+    const parts = ["soft", "hard"].filter((key) => Object.prototype.hasOwnProperty.call(limits, key)).map((key) => `${key}=${controlValue(limits[key])}`);
+    return `${dimension} ${parts.join(" ")}`;
+  });
+}
+function budgetPatchSummary(value: unknown): string {
+  const entries = budgetPatchEntries(value);
+  return entries.length ? entries.join(", ") : "unchanged";
+}
+function budgetPatchDetails(value: unknown, theme: Theme): string[] {
+  const entries = budgetPatchEntries(value);
+  return entries.length ? [theme.fg("accent", theme.bold("Budget patch")), ...entries.map((entry) => `  ${theme.fg("toolOutput", entry)}`)] : [];
+}
+function workflowControlValue(result: WorkflowControlResult): unknown { return catalogResultValue(result); }
+function workflowControlCall(name: string, args: Record<string, unknown>, theme: Theme): string {
+  const runId = controlString(args.runId) ?? "(missing run ID)";
+  if (name === "workflow_respond") {
+    const proposalId = controlString(args.proposalId);
+    const target = proposalId ? `budget proposal ${proposalId}` : `checkpoint ${controlString(args.name) ?? "(missing name)"}`;
+    const decision = args.approved === true ? "approve" : "reject";
+    return [`${controlTitle(name, theme)} ${theme.fg("accent", runId)}`, `${theme.fg("muted", target)} · ${controlAction(decision, theme)}`].join("\n");
+  }
+  if (name === "workflow_resume") return args.budget === undefined ? `${controlTitle(name, theme)} ${theme.fg("accent", runId)}` : [`${controlTitle(name, theme)} ${theme.fg("accent", runId)}`, `${theme.fg("muted", "Budget")} ${theme.fg("toolOutput", budgetPatchSummary(args.budget))}`].join("\n");
+  if (name === "workflow_retry") return `${controlTitle(name, theme)} ${theme.fg("accent", runId)} ${theme.fg("muted", "failed run")}`;
+  return `${controlTitle(name, theme)} ${theme.fg("accent", runId)}`;
+}
+function workflowControlResult(name: string, args: Record<string, unknown>, result: WorkflowControlResult, expanded: boolean, theme: Theme, isError: boolean): string {
+  if (isError) {
+    const text = result.content?.filter(({ type }) => type === "text").map(({ text }) => text ?? "").join("\n").trim();
+    return theme.fg("error", text || `The ${name} tool failed.`);
+  }
+  const value = workflowControlValue(result);
+  if (!object(value)) return theme.fg("error", `The ${name} tool returned an invalid result.`);
+  const runId = controlString(args.runId) ?? controlString(value.runId) ?? "(unknown)";
+  const title = controlTitle(name, theme);
+  if (name === "workflow_stop") {
+    const state = controlString(value.state) ?? "unknown";
+    const action = value.stopped === true ? "stopped" : value.reason === "already_terminal" ? "already terminal" : value.reason === "unknown_run" ? "run not found" : "no change";
+    if (!expanded) return `${title}\nRun ${theme.fg("accent", runId)} · ${controlState(state, theme)} · ${controlAction(action, theme)}`;
+    return [title, `Run: ${theme.fg("accent", runId)}`, `State: ${controlState(state, theme)}`, `Action: ${controlAction(action, theme)}`, ...(controlString(value.reason) ? [`Reason: ${theme.fg("toolOutput", controlValue(value.reason))}`] : [])].join("\n");
+  }
+  if (name === "workflow_retry") {
+    const childRunId = controlString(value.runId) ?? "(unknown)";
+    const state = controlString(value.state) ?? "unknown";
+    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: string): string { return value.replace(/\s+/g, " ").trim(); }
+
+type CatalogToolResult = { details?: unknown; content?: readonly { type: string; text?: string }[] };
+
+function catalogResultValue(result: CatalogToolResult): unknown {
+  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) as unknown; } catch { return text; }
+}
+
+function isCatalogIndex(value: unknown): value is WorkflowCatalogIndex {
+  return object(value) && Array.isArray(value.functions) && Array.isArray(value.variables);
+}
+
+function isCatalogFunction(value: unknown): value is WorkflowCatalogFunction {
+  return object(value) && typeof value.name === "string" && typeof value.description === "string" && object(value.input) && object(value.output);
+}
+
+function isCatalogVariable(value: unknown): value is WorkflowCatalogVariable {
+  return object(value) && typeof value.name === "string" && typeof value.description === "string" && object(value.schema);
+}
+
+function isCatalogError(value: unknown): value is { error: { message: string } } {
+  return object(value) && object(value.error) && typeof value.error.message === "string";
+}
+
+function catalogSectionTitle(label: string, count: number, theme: Theme): string {
+  return theme.fg("accent", theme.bold(`${label} (${String(count)})`));
+}
+
+function catalogIndexEntries(entries: readonly { name: string; description: string }[], theme: Theme): string[] {
+  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: WorkflowCatalogIndex, theme: Theme): string {
+  const aliases = Object.prototype.propertyIsEnumerable.call(catalog, "modelAliases") ? Object.keys(catalog.modelAliases ?? {}).sort().map((name) => ({ name, kind: "static" as const, provenance: "settings" })) : catalog.modelAliasEntries ?? Object.keys(catalog.modelAliases ?? {}).sort().map((name) => ({ name, kind: "static" as const, 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: unknown, theme: Theme): string[] {
+  const json = JSON.stringify(schema, null, 2);
+  return json.split("\n").map((line) => `  ${theme.fg("toolOutput", line)}`);
+}
+
+function formatCatalogDetail(value: WorkflowCatalogFunction | WorkflowCatalogVariable | import("./types.js").WorkflowCatalogModelAlias, expanded: boolean, theme: Theme): string {
+  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: unknown, expanded: boolean, theme: Theme): string {
+  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 as unknown as import("./types.js").WorkflowCatalogModelAlias, 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 = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`);
+const ANSI_SGR_SOURCE = `${String.fromCharCode(27)}\\[[0-9;]*m`;
+const ANSI_SGR = new RegExp(ANSI_SGR_SOURCE);
 export function truncateWorkflowProgress(text: string, width: number): string[] {
   const safeWidth = Math.max(1, width);
   return text.split("\n").flatMap((line) => {
@@ -264,7 +730,7 @@ function themeWorkflowProgressStyles(theme: Theme): WorkflowProgressStyles {
     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: PersistedRun, theme: Theme) {
@@ -310,7 +776,7 @@ function navigatorRunLabels(entries: readonly { store: RunStore; loaded: { run:
   for (const { loaded: { run } } of entries) nameCount.set(run.workflowName, (nameCount.get(run.workflowName) ?? 0) + 1);
   return entries.map(({ store, loaded: { run } }) => {
     const done = run.agents.filter((a) => SETTLED_AGENT_STATES.has(a.state)).length;
-    const glyph = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "budget_exhausted" ? "!" : run.state === "running" ? "⠦" : run.state === "awaiting_input" ? "●" : "◆";
+    const glyph = runStateGlyph(run.state, "⠦");
     const suffix = (nameCount.get(run.workflowName) ?? 0) > 1 ? ` ${store.runId.slice(0, 8)}` : "";
     const cost = run.agents.reduce((sum, a) => sum + (a.accounting?.cost ?? 0), 0);
     const costStr = cost > 0 ? ` $${cost.toFixed(2)}` : "";
@@ -318,28 +784,29 @@ function navigatorRunLabels(entries: readonly { store: RunStore; loaded: { run:
   });
 }
 
-function agentBreadcrumbParts(agent: AgentRecord, byId: Map<string, AgentRecord>): string[] {
-  const name = agent.label ?? agent.name;
-  const parts: string[] = agent.parentBreadcrumb ? [agent.parentBreadcrumb] : [];
+export function agentBreadcrumbParts(agent: AgentRecord, byId: Map<string, AgentRecord>, includeStructuralPath = false): string[] {
+  const leaf = agent.label ?? agent.name;
+  const parts: string[] = includeStructuralPath && agent.structuralPath?.length ? [agent.structuralPath.join(" > ")] : [];
+  if (agent.parentBreadcrumb) parts.push(agent.parentBreadcrumb);
+  const ancestors: string[] = [];
   const seen = new Set<string>([agent.id]);
   for (let parentId = agent.parentId; parentId; parentId = byId.get(parentId)?.parentId) {
-    if (seen.has(parentId)) break; // ponytail: cycle guard for corrupt data
+    if (seen.has(parentId)) break;
     seen.add(parentId);
     const parent = byId.get(parentId);
-    if (parent) parts.push(parent.label ?? parent.name);
-    else break;
+    if (!parent) break;
+    ancestors.push(parent.label ?? parent.name);
   }
-  parts.push(name);
+  parts.push(...ancestors.reverse(), leaf);
   return parts;
 }
-function agentBreadcrumb(agent: AgentRecord, byId: Map<string, AgentRecord>): string {
-  const parts = agentBreadcrumbParts(agent, byId);
-  return parts.length > 1 ? parts.join(" > ") : parts[0] ?? "";
+export function agentBreadcrumb(agent: AgentRecord, byId: Map<string, AgentRecord>, includeStructuralPath = false): string {
+  return agentBreadcrumbParts(agent, byId, includeStructuralPath).join(" > ");
 }
 function styledAgentBreadcrumb(agent: AgentRecord, byId: Map<string, AgentRecord>, styles: WorkflowProgressStyles): string {
   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: AgentRecord, spinner: string, styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES): string {
@@ -358,7 +825,7 @@ export function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonl
   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)];
@@ -367,7 +834,7 @@ export function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonl
   lines.push("");
   const byId = new Map(run.agents.map((a) => [a.id, a]));
   const render = ({ agent, depth }: { agent: AgentRecord; index: number; depth: number }, grouped: boolean) => {
-    const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? "⠦" : "○";
+    const icon = agentStateGlyph(agent.state, "⠦");
     const breadcrumb = grouped ? agent.label ?? agent.name : agentBreadcrumb(agent, byId);
     const tokens = agent.accounting ? formatAccounting(agent.accounting) : "";
     const indent = "  ".repeat((grouped ? 2 : 1) + depth);
@@ -385,7 +852,7 @@ export function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonl
   return lines.join("\n");
 }
 
-export function formatNavigatorRun(loaded: { run: PersistedRun; snapshot: Readonly<LaunchSnapshot> }, checkpoints: readonly AwaitingCheckpoint[], _worktrees: readonly WorktreeReference[]): string {
+export function formatNavigatorRun(loaded: { run: PersistedRun; snapshot: Readonly<LaunchSnapshot> }, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[]): string {
   const { run, snapshot } = loaded;
   const lines = [
     `Workflow: ${run.workflowName}`,
@@ -395,11 +862,13 @@ export function formatNavigatorRun(loaded: { run: PersistedRun; snapshot: Readon
     `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}`);
   if (run.events?.length) lines.push(...run.events.map((event) => `Warning: ${event.message}`));
   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)");
   const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
@@ -417,10 +886,94 @@ export function formatNavigatorRun(loaded: { run: PersistedRun; snapshot: Readon
   lines.push("Checkpoints:");
   if (!checkpoints.length) lines.push("  (none)");
   for (const checkpoint of checkpoints) lines.push(`  ${checkpoint.name}: ${checkpoint.prompt} context=${JSON.stringify(checkpoint.context)}`);
-  lines.push(`Worktrees: ${String(_worktrees.length)}`);
+  lines.push(`Worktrees: ${String(worktrees.length)}`);
   lines.push(`Native Pi transcripts: ${String(run.nativeSessions.length)}`);
   return lines.join("\n");
 }
+export function formatWorkflowPhaseDashboard(run: PersistedRun, snapshot: Readonly<LaunchSnapshot>, width: number, selection: WorkflowPhaseSelection = {}, styles: WorkflowProgressStyles = PLAIN_WORKFLOW_PROGRESS_STYLES): string[] {
+  const safeWidth = Math.max(1, width);
+  const model = buildWorkflowPhaseModel(run, snapshot);
+  const tree = buildWorkflowPhaseTree(model);
+  const expanded = selection.expandedNodeIds === undefined ? workflowPhaseTreeInitialExpanded(tree) : new Set(selection.expandedNodeIds);
+  const wrap = (text: string, limit = safeWidth): string[] => truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, Math.max(1, limit), 0).visualLines.map((line) => line.trimEnd());
+  // ponytail: ANSI-only width, good enough for the ASCII labels the tree renders
+  const ansiPattern = new RegExp(ANSI_SGR_SOURCE, "g");
+  const visibleLength = (text: string): number => text.replace(ansiPattern, "").length;
+  const padTo = (text: string, limit: number): string => `${text}${" ".repeat(Math.max(0, limit - visibleLength(text)))}`;
+  const phaseStyle = (state: WorkflowPhaseState | AgentRecord["state"]): ((text: string) => string) => phaseStyleForState(state, styles);
+  const phase = selection.phaseId ? model.phases.find((candidate) => candidate.id === selection.phaseId) : undefined;
+  const selectedByAgent = selection.agentId ? tree.nodes.find((node) => node.kind === "agent" && node.agentId === selection.agentId && (!selection.phaseId || node.phaseId === selection.phaseId)) : undefined;
+  const selectedNode = (selection.nodeId ? tree.byId.get(selection.nodeId) : undefined) ?? selectedByAgent ?? (phase ? tree.byId.get(workflowPhaseTreePath("phase", phase.id, [])) : undefined) ?? (model.currentPhaseId ? tree.byId.get(workflowPhaseTreePath("phase", model.currentPhaseId, [])) : undefined) ?? tree.nodes[0];
+  const selectedPhase = selectedNode?.phase ?? (selectedNode ? model.phases.find((candidate) => candidate.id === selectedNode.phaseId) : undefined);
+  const visibleNodes = workflowPhaseTreeVisibleNodes(tree, expanded);
+  const nodeAgents = (node: WorkflowPhaseTreeNode): AgentRecord[] => {
+    const agents: AgentRecord[] = [];
+    const visit = (id: string): void => {
+      const child = tree.byId.get(id);
+      if (!child) return;
+      if (child.agent) agents.push(child.agent); else for (const childId of child.children) visit(childId);
+    };
+    if (node.agent) agents.push(node.agent); else for (const childId of node.children) visit(childId);
+    return agents;
+  };
+  const nodeStatus = (node: WorkflowPhaseTreeNode): string => phaseStyle(node.state)(node.state);
+  const nodeIcon = (node: WorkflowPhaseTreeNode): string => node.children.length ? expanded.has(node.id) ? "▾" : "▸" : node.kind === "agent" ? "•" : " ";
+  const treeLine = (node: WorkflowPhaseTreeNode): string => {
+    const selected = node.id === selectedNode?.id;
+    const state = progressStyleForState(node.state, styles);
+    return `${selected ? "→" : " "} ${"  ".repeat(node.depth)}${nodeIcon(node)} ${node.label} · ${state(node.state)}`;
+  };
+  const details = (node: WorkflowPhaseTreeNode | undefined): string[] => {
+    if (!node) return [styles.muted("No workflow node is selected")];
+    const agents = nodeAgents(node);
+    if (node.kind === "phase") {
+      const selected = node.phase;
+      const counts = selected?.counts ?? phaseAgentCounts(agents);
+      return [styles.bold(`Selected phase: ${node.label}`), `Status: ${nodeStatus(node)}`, `agents completed=${String(counts.completed)} running=${String(counts.running)} failed=${String(counts.failed)} cancelled=${String(counts.cancelled)} pending=${String(counts.pending)}`, `Agents: ${String(agents.length)}`];
+    }
+    if (node.kind === "operation") {
+      const states = phaseAgentCounts(agents);
+      return [styles.bold(`Selected operation: ${node.operationPath.join(" > ")}`), `Phase: ${node.phase?.name ?? node.phaseId}`, `Status: ${nodeStatus(node)}`, `agents completed=${String(states.completed)} running=${String(states.running)} failed=${String(states.failed)} cancelled=${String(states.cancelled)} pending=${String(states.pending)}`, `Agents: ${String(agents.length)}`];
+    }
+    const agent = node.agent;
+    if (!agent) return [styles.muted("Agent details are unavailable")];
+    const byId = new Map(run.agents.map((candidate) => [candidate.id, candidate]));
+    const result = [styles.bold(`Selected agent: ${agentBreadcrumb(agent, byId, true)}`), `State: ${phaseStyle(agent.state)(agent.state)}`, `Structural path: ${agent.structuralPath?.join(" > ") || "(root)"}`, `Model: ${agent.model.provider}/${agent.model.model}${agent.model.thinking ? `:${agent.model.thinking}` : ""}`, `Role: ${agent.role ?? "(none)"}`, `Tools: ${agent.tools.join(", ") || "(none)"}`, `Attempts: ${String(agent.attempts)}`, ...(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: readonly WorkflowPhaseState[] = ["not started", "running", "completed", "failed", "cancelled", "interrupted", "budget_exhausted"];
+  const statusSummary = stateNames.filter((state) => (model.counts[state] ?? 0) > 0).map((state) => `${String(model.counts[state])} ${state}`).join(" · ") || "0 phases";
+  const lines: string[] = [styles.bold(styles.accent(`Workflow: ${run.workflowName}`))];
+  if (run.error) lines.push(styles.error(`ERROR ${run.error.code}: ${run.error.message}`));
+  lines.push(`phase: ${run.phase ?? selectedPhase?.name ?? "none"}`, `Run state: ${run.state}`, `Phases: ${statusSummary}`);
+  for (const event of run.events ?? []) lines.push(styles.warning(`Warning: ${event.message}`));
+  lines.push(...formatCompactBudgetStatus(run));
+  const renderTree = (limit: number): string[] => [styles.bold("Tree"), ...(visibleNodes.length ? visibleNodes.flatMap((node) => wrap(treeLine(node), limit)) : [styles.muted("(empty)")])];
+  const actionRows = (): string[] => {
+    const actions = selection.actions;
+    if (!actions) return [];
+    return ["", styles.bold(actions.title), ...actions.options.map((option, index) => `${index === actions.index ? "→ " : "  "}${index === actions.index ? styles.accent(option) : option}`)];
+  };
+  const detailRows = (): string[] => [...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: AwaitingCheckpoint): string {
   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");
@@ -841,48 +1394,71 @@ function projectTrusted(ctx: unknown): boolean {
   const check = object(ctx) ? ctx.isProjectTrusted : undefined;
   return typeof check === "function" ? Boolean(Reflect.apply(check, ctx, [])) : true;
 }
+function asFn(value: unknown): ((...args: never[]) => unknown) | undefined { return typeof value === "function" ? value as (...args: never[]) => unknown : undefined; }
 type PiHostCapabilities = { registerEntryRenderer?: ExtensionAPI["registerEntryRenderer"]; events?: WorkflowEventSink };
-function isEntryRenderer(value: unknown): value is NonNullable<PiHostCapabilities["registerEntryRenderer"]> { return typeof value === "function"; }
 function isWorkflowEventSink(value: unknown): value is WorkflowEventSink { return object(value) && typeof value.emit === "function"; }
 function piHostCapabilities(pi: unknown): PiHostCapabilities {
   if (!object(pi)) return {};
-  const registerEntryRenderer = pi.registerEntryRenderer;
+  const registerEntryRenderer = asFn(pi.registerEntryRenderer) as NonNullable<PiHostCapabilities["registerEntryRenderer"]> | undefined;
   const events = pi.events;
-  return { ...(isEntryRenderer(registerEntryRenderer) ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
+  return { ...(registerEntryRenderer ? { registerEntryRenderer } : {}), ...(isWorkflowEventSink(events) ? { events } : {}) };
 }
 type ContextHostCapabilities = { modelRegistry?: ModelRegistryCapability };
 type ModelSummary = { provider: string; id: string };
 type ModelRegistryGetter = () => readonly ModelSummary[];
 type ModelRegistryCapability = { getAll?: ModelRegistryGetter; getAvailable?: ModelRegistryGetter };
-function isModelRegistryGetter(value: unknown): value is ModelRegistryGetter { return typeof value === "function"; }
 function contextHostCapabilities(ctx: unknown): ContextHostCapabilities {
   if (!object(ctx) || !object(ctx.modelRegistry)) return {};
   const registry = ctx.modelRegistry;
-  const getAll = registry.getAll;
-  const getAvailable = registry.getAvailable;
-  return { modelRegistry: { ...(isModelRegistryGetter(getAll) ? { getAll: () => getAll.call(registry) } : {}), ...(isModelRegistryGetter(getAvailable) ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
+  const getAll = (asFn(registry.getAll) as ModelRegistryGetter | undefined);
+  const getAvailable = (asFn(registry.getAvailable) as ModelRegistryGetter | undefined);
+  return { modelRegistry: { ...(getAll ? { getAll: () => getAll.call(registry) } : {}), ...(getAvailable ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
+}
+function modelInventory(root: ModelSpec | undefined, registry: ModelRegistryCapability | undefined): { knownModels: ReadonlySet<string>; availableModels: ReadonlySet<string> } {
+  const all = registry?.getAll?.() ?? registry?.getAvailable?.() ?? [];
+  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: unknown): { model: { provider: string; id: string } | undefined; modelRegistry: ModelRegistryCapability | undefined } {
+  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: WorkflowRegistryApi, staticAliases: Readonly<Record<string, string>>, context: Readonly<WorkflowModelAliasResolverContext>, availableModels: ReadonlySet<string>, knownModels: ReadonlySet<string>, settingsPath: string): Promise<{ aliases: Readonly<Record<string, string>>; dynamicNames: readonly string[] }> {
+  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;
+  }
 }
 type UiSelect = (title: string, options: string[]) => Promise<string | undefined>;
 type UiInput = (title: string, placeholder?: string) => Promise<string | undefined>;
 type UiSetStatus = (key: string, text?: string) => void;
 type UiHostCapabilities = { select?: UiSelect; input?: UiInput; setStatus?: UiSetStatus };
-function isUiSelect(value: unknown): value is UiSelect { return typeof value === "function"; }
-function isUiInput(value: unknown): value is UiInput { return typeof value === "function"; }
-function isUiSetStatus(value: unknown): value is UiSetStatus { return typeof value === "function"; }
 function uiHostCapabilities(ui: unknown): UiHostCapabilities | undefined {
   if (!object(ui)) return undefined;
-  const select = ui.select;
-  const input = ui.input;
-  const setStatus = ui.setStatus;
-  return { ...(isUiSelect(select) ? { select } : {}), ...(isUiInput(input) ? { input } : {}), ...(isUiSetStatus(setStatus) ? { setStatus } : {}) };
+  const select = (asFn(ui.select) as UiSelect | undefined);
+  const input = (asFn(ui.input) as UiInput | undefined);
+  const setStatus = (asFn(ui.setStatus) as UiSetStatus | undefined);
+  return { ...(select ? { select } : {}), ...(input ? { input } : {}), ...(setStatus ? { setStatus } : {}) };
 }
-type TuiHostCapabilities = { terminal?: { rows?: unknown } };
-function tuiHostCapabilities(tui: unknown): TuiHostCapabilities {
-  if (!object(tui) || !object(tui.terminal)) return {};
-  return { terminal: { ...(tui.terminal.rows === undefined ? {} : { rows: tui.terminal.rows }) } };
+function tuiRows(tui: unknown): number {
+  const rows = object(tui) && object(tui.terminal) ? tui.terminal.rows : undefined;
+  return typeof rows === "number" && Number.isFinite(rows) ? rows : 24;
 }
-function tuiRows(tui: unknown): number { const rows = tuiHostCapabilities(tui).terminal?.rows; return typeof rows === "number" && Number.isFinite(rows) ? rows : 24; }
 const WORKFLOW_OVERLAY_BORDER_ROWS = 2;
+const WORKFLOW_OVERLAY_TOP_MARGIN = 1;
+const WORKFLOW_OVERLAY_OPTIONS = { anchor: "top-left", width: "100%", maxHeight: "100%", margin: { top: WORKFLOW_OVERLAY_TOP_MARGIN } } as const;
 type WorkflowOverlayComponent = { render(width: number): string[]; invalidate(): void; handleInput?(data: string): void; dispose?(): void };
 function borderWorkflowOverlay(component: WorkflowOverlayComponent, theme: { fg(color: "border", text: string): string }): WorkflowOverlayComponent {
   return {
@@ -894,12 +1470,10 @@ function borderWorkflowOverlay(component: WorkflowOverlayComponent, theme: { fg(
   };
 }
 type KeybindingsHostCapabilities = { getKeys?: (name: string) => readonly string[] };
-function isKeybindingGetter(value: unknown): value is NonNullable<KeybindingsHostCapabilities["getKeys"]> { return typeof value === "function"; }
-function keybindingsHostCapabilities(keybindings: unknown): KeybindingsHostCapabilities {
-  if (!object(keybindings) || !isKeybindingGetter(keybindings.getKeys)) return {};
-  return { getKeys: keybindings.getKeys };
+function keybindingKeys(keybindings: unknown, name: string): readonly string[] | undefined {
+  const getKeys = object(keybindings) ? asFn(keybindings.getKeys) as NonNullable<KeybindingsHostCapabilities["getKeys"]> | undefined : undefined;
+  return getKeys ? getKeys.call(keybindings, name) : undefined;
 }
-function keybindingKeys(keybindings: unknown, name: string): readonly string[] | undefined { const getKeys = keybindingsHostCapabilities(keybindings).getKeys; return typeof getKeys === "function" ? getKeys.call(keybindings, name) : undefined; }
 
 export default function workflowExtension(pi: ExtensionAPI, home?: string, clipboard = copyToClipboard, createSession: SessionFactory = createNativeAgentSession, agentDir?: string) {
   beginWorkflowExtensionLoading();
@@ -993,10 +1567,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
   };
   const phaseBridge = (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle) => {
     let cursor = 0;
-    let executionPhase: string | undefined;
     return async (phase: string): Promise<void> => {
-      if (phase === executionPhase) return;
-      executionPhase = phase;
       await scheduler.flush();
       await lifecycle.enter();
       try {
@@ -1115,7 +1686,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
         let effective: { model: ModelSpec; requestedModel?: string; tools: readonly string[] };
         try { effective = run.executor.resolve(requested); }
         catch { effective = previous ? { model: previous.model, ...(previous.requestedModel ? { requestedModel: previous.requestedModel } : {}), tools: previous.tools } : { model: node.options.model ? modelSpec(node.options.model, run.model) : { ...run.model, ...(node.options.thinking ? { thinking: node.options.thinking } : {}) }, ...(node.options.model ? { requestedModel: node.options.model } : {}), tools: node.options.tools }; }
-        return { id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), structuralPath: [...(node.options.agentIdentity?.structuralPath ?? [])], ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.worktreeOwner ? { worktreeOwner: node.options.worktreeOwner } : {}), ...(node.options.role ? { role: node.options.role } : {}), ...(effective.requestedModel ? { requestedModel: effective.requestedModel } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}) };
+        const resultPath = !node.parentId && node.options.agentIdentity ? agentIdentityPath(node.options.agentIdentity) : undefined;
+        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 };
     });
@@ -1124,7 +1696,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
   });
   const cleanupTerminalRun = async (runId: string): Promise<void> => {
     const run = runs.get(runId);
-    if (!run || !["completed", "failed", "stopped"].includes(run.lifecycle.state)) return;
+    if (!run || !HARD_TERMINAL_RUN_STATES.has(run.lifecycle.state)) return;
     await scheduler.cancelRun(runId);
     await scheduler.flush();
     if (runs.get(runId) !== run) return;
@@ -1167,13 +1739,13 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     run.budget.recordEvent({ type, budgetVersion: request.budgetVersion, dimensions: [], usage: structuredClone(request.consumed), limits: structuredClone(request.proposed), at: Date.now(), proposalId: request.proposalId, previous: structuredClone(request.previous), proposed: structuredClone(request.proposed) });
     await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
   };
-  const answerBudgetDecision = async (runId: string, proposalId: string, approved: boolean, silent = false): Promise<BudgetDecisionResult | undefined> => {
+  const answerBudgetDecision = async (runId: string, proposalId: string, approved: boolean, silent = false, context?: unknown, signal?: AbortSignal): Promise<BudgetDecisionResult | undefined> => {
     const run = runs.get(runId);
     if (!run) return undefined;
     const request = await run.store.answerWorkflowDecision(proposalId, approved);
     if (!request) return undefined;
     await appendBudgetDecisionEvent(run, request, approved ? "adjustment_approved" : "adjustment_rejected");
-    const result = await applyBudgetDecision(request, approved);
+    const result = await applyBudgetDecision(request, approved, context, signal);
     if (!silent) deliver(pi, `Workflow ${run.metadata.name} budget adjustment ${proposalId}: ${approved ? "Approved" : "Rejected"}.`);
     return result;
   };
@@ -1223,20 +1795,22 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     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" as const, approved: false, reason: "proposal_not_pending" }; return { content: [{ type: "text" as const, text: JSON.stringify(denied) }], details: denied }; }
           return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: { ...result, reason: params.approved ? "approved" : "rejected" } };
         }
         if (!params.name) throw new WorkflowError("INVALID_METADATA", "workflow_respond requires name or proposalId");
         const accepted = await answerCheckpoint(params.runId, params.name, params.approved);
-        return { content: [{ type: "text" as const, text: accepted ? "Checkpoint response accepted." : "Checkpoint is not awaiting a response." }], details: { accepted, state: accepted ? "checkpoint_answered" : "not_pending", approved: params.approved, reason: "checkpoint" } as never };
+        return { content: [{ type: "text" as const, text: accepted ? "Checkpoint response accepted." : "Checkpoint is not awaiting a response." }], details: { accepted, state: accepted ? "checkpoint_answered" : "not_pending", approved: params.approved, reason: "checkpoint" } };
       } catch (error) {
         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",
@@ -1251,50 +1825,117 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
         throw mainAgentError(error);
       }
     },
+    renderCall(args, theme) { return styledTextBlock(workflowControlCall("workflow_stop", args, theme)); },
+    renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult("workflow_stop", context.args, result, options.expanded, theme, context.isError), options.expanded); },
   });
   let catalogRegistered = false;
   let sessionStarted = false;
-  const registerCatalog = () => {
+  const registerCatalog = (cwd: string, trustedProject: boolean) => {
     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) return;
+    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" as const, 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: NonNullable<ReturnType<typeof runs.get>>, context?: { model: { provider: string; id: string } | undefined; modelRegistry: { getAll?: () => Array<{ provider: string; id: string }>; getAvailable?: () => Array<{ provider: string; id: string }> } | undefined }) => {
-    const loaded = await run.store.load();
-    const active = new Set(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-    const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
+  const createAgentExecutor = (root: Omit<import("./agent-execution.js").AgentExecutionRoot, "agentDir" | "agentSetupHooks">) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, agentSetupHooks: registry.agentSetupHooks() }, createSession);
+  const activeSnapshotTools = (tools: readonly string[], active: ReadonlySet<string> | "session") => active === "session"
+    ? new Set(tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog"))
+    : new Set(tools.filter((tool) => active.has(tool) || tool === "workflow_catalog"));
+  const resumeLaunchPrologue = async (input: {
+    snapshot: Readonly<LaunchSnapshot>;
+    cwd: string;
+    trustedProject: boolean;
+    rootModel: ModelSpec;
+    modelRegistry?: ModelRegistryCapability | undefined;
+    signal: AbortSignal;
+    resolvedAliases?: Readonly<Record<string, string>>;
+    blockedAliases?: ReadonlySet<string>;
+    blockedAliasTargets?: Readonly<Record<string, string>>;
+    withPreflight: boolean;
+  }) => {
+    const active = new Set(pi.getActiveTools().filter((tool) => !INTERNAL_WORKFLOW_TOOLS.includes(tool)));
+    const missing = input.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
     if (missing) throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
     const settingsPath = workflowSettingsPath(extensionAgentDir);
-    const 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: ReturnType<typeof launchScriptForSnapshot> | undefined;
+    if (input.withPreflight) {
+      const resumeAliases = { ...previousAliases, ...currentAliases };
+      script = launchScriptForSnapshot(input.snapshot, registry);
+      preflight(script, { models: availableModels, tools: active, agentTypes: new Set(input.snapshot.agentTypes), modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, input.snapshot.schemas, input.snapshot.metadata, true);
+    }
+    const refreshed = resumedSnapshotSettings(input.snapshot, resolution, currentAliases);
+    const snapshot = createLaunchSnapshot({ ...input.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
+    return { active, settingsPath, resolution, currentPolicy, previousAliases, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot, script };
+  };
+  const workflowAgentHandler = (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle, executor: WorkflowAgentExecutor, cwd: string, runId: string) => async (prompt: string, options: Readonly<Record<string, JsonValue>>, agentSignal: AbortSignal, identity: import("./types.js").AgentIdentity) => {
+    await lifecycle.enter();
+    try {
+      const path = agentIdentityPath(identity);
+      const replayed = await store.replay(path);
+      if (replayed) {
+        return replayed.value;
+      }
+      const worktree = agentWorktree(identity);
+      const agentCwd = worktree.worktreeOwner ? (await persistWorktree(store, metadata, worktree.worktreeOwner)).cwd : cwd;
+      const role = typeof options.role === "string" ? options.role : undefined;
+      const model = typeof options.model === "string" ? options.model : undefined;
+      const thinking = parseThinking(options.thinking);
+      const requestedLabel = typeof options.label === "string" ? options.label : undefined;
+      const resolved = executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools as string[] } : {}) });
+      const label = displayAgentName(requestedLabel, role, resolved.model);
+      const tools = resolved.tools;
+      const schema = object(options.outputSchema) ? options.outputSchema : undefined;
+      const spawned = scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd: agentCwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
+      const cancel = () => { scheduler.cancel(spawned.id); };
+      if (agentSignal.aborted) cancel(); else agentSignal.addEventListener("abort", cancel, { once: true });
+      const outcome = await spawned.result.finally(() => { agentSignal.removeEventListener("abort", cancel); });
+      if (!outcome.ok) throw new WorkflowError(outcome.error.code as WorkflowErrorCode, outcome.error.message);
+      await store.complete(path, outcome.value);
+      return outcome.value;
+    } finally { await lifecycle.leave(); }
+  };
+  const refreshPausedRunAliases = async (run: NonNullable<ReturnType<typeof runs.get>>, context?: { model: { provider: string; id: string } | undefined; modelRegistry: ModelRegistryCapability | undefined; projectTrusted?: boolean }) => {
+    const loaded = await run.store.load();
+    const trustedProject = context?.projectTrusted ?? run.projectTrusted();
+    const rootModel = context?.model ? { ...run.model, provider: context.model.provider, model: context.model.id } : run.model;
+    const { 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() as unknown as readonly RegisteredAgentSetupHook[], 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) await run.store.appendEvent({ type: "warning", message: `Model alias mappings changed on resume: ${drift.join("; ")}` });
   };
-  const coldResumeRun = async (run: NonNullable<ReturnType<typeof runs.get>>, hasUI: boolean, ui: { select?: (prompt: string, options: string[]) => Promise<string | undefined> }, trustedProject: boolean, context?: { model: { provider: string; id: string } | undefined; modelRegistry: { getAll?: () => Array<{ provider: string; id: string }>; getAvailable?: () => Array<{ provider: string; id: string }> } | undefined }) => {
+  const coldResumeRun = async (run: NonNullable<ReturnType<typeof runs.get>>, hasUI: boolean, ui: { select?: (prompt: string, options: string[]) => Promise<string | undefined> }, trustedProject: boolean, context?: { model: { provider: string; id: string } | undefined; modelRegistry: ModelRegistryCapability | undefined; signal?: AbortSignal | undefined; resolvedAliases?: Readonly<Record<string, string>>; blockedAliases?: ReadonlySet<string>; blockedAliasTargets?: Readonly<Record<string, string>> }) => {
     const loaded = await run.store.load();
     await run.store.validateRetrySource();
     await run.store.validateBorrowedWorktrees();
@@ -1303,69 +1944,30 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     if ((loaded.snapshot.projectRoles?.length ?? 0) > 0 && !trustedProject) throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot restore project roles in an untrusted project");
     const missingRole = loaded.snapshot.agentTypes.find((role) => !loaded.snapshot.roles?.[role]);
     if (missingRole) throw new WorkflowError("RESUME_INCOMPATIBLE", `Role definition is missing from the launch snapshot: ${missingRole}`);
-    const active = new Set(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-    const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
-    if (missing) throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
-    const settingsPath = workflowSettingsPath(extensionAgentDir);
-    const 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() as unknown as readonly RegisteredAgentSetupHook[], 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: Readonly<Record<string, JsonValue>>;
     try { variables = await resolveWorkflowVariables(runContext, controller, registry); }
     catch (error) {
       const typed = asWorkflowError(error);
-      if (!["completed", "failed", "stopped"].includes(run.lifecycle.state)) { await run.lifecycle.terminal("failed", typed.code).catch(() => undefined); const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, error: { code: typed.code, message: typed.message } })); await eventPublisher.runFailed(run.store, run.metadata, typed, run.lifecycle.state === "interrupted" ? "interrupted" : "failed"); run.update?.(workflowToolUpdate(persisted)); if (!["stopped", "interrupted", "budget_exhausted"].includes(run.lifecycle.state)) await createWorkflowFailureDiagnostics(run.store, run.metadata, typed, persisted).then((diagnostic) => { deliverFailure(pi, diagnostic); }).catch(() => undefined); }
+      if (!HARD_TERMINAL_RUN_STATES.has(run.lifecycle.state)) { await run.lifecycle.terminal("failed", typed.code).catch(() => undefined); const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, error: { code: typed.code, message: typed.message } })); await eventPublisher.runFailed(run.store, run.metadata, typed, run.lifecycle.state === "interrupted" ? "interrupted" : "failed"); run.update?.(workflowToolUpdate(persisted)); if (!["stopped", "interrupted", "budget_exhausted"].includes(run.lifecycle.state)) await createWorkflowFailureDiagnostics(run.store, run.metadata, typed, persisted).then((diagnostic) => { deliverFailure(pi, diagnostic); }).catch(() => undefined); }
       await cleanupTerminalRun(run.store.runId);
       throw typed;
     }
     await scheduler.cancelRun(run.store.runId);
     await run.lifecycle.resume();
-    const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: async (prompt, options, signal, identity) => {
-      await run.lifecycle.enter();
-      try {
-        const path = agentIdentityPath(identity);
-        const replayed = await run.store.replay(path);
-        if (replayed) {
-          return replayed.value;
-        }
-        const worktree = agentWorktree(identity);
-        const cwd = worktree.worktreeOwner ? (await persistWorktree(run.store, run.metadata, worktree.worktreeOwner)).cwd : run.store.cwd;
-        const role = typeof options.role === "string" ? options.role : undefined;
-        const model = typeof options.model === "string" ? options.model : undefined;
-        const thinking = parseThinking(options.thinking);
-        const requestedLabel = typeof options.label === "string" ? options.label : undefined;
-        const resolved = run.executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools as string[] } : {}) });
-        const label = displayAgentName(requestedLabel, role, resolved.model);
-        const tools = resolved.tools;
-        const schema = object(options.outputSchema) ? options.outputSchema : undefined;
-        const spawned = scheduler.spawn(run.store.runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
-        const cancel = () => { scheduler.cancel(spawned.id); };
-        signal.addEventListener("abort", cancel, { once: true });
-        const outcome = await spawned.result.finally(() => { signal.removeEventListener("abort", cancel); });
-        if (!outcome.ok) throw new WorkflowError(outcome.error.code as WorkflowErrorCode, outcome.error.message);
-        await run.store.complete(path, outcome.value);
-        return outcome.value;
-      } finally { await run.lifecycle.leave(); }
-      }, worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, false, hasUI ? ui : undefined), phase: phaseBridge(run.store, run.metadata, run.lifecycle), log: logBridge(run.lifecycle, run.metadata.name) }, run.store, runContext, variables, registry), controller.signal);
+    const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: workflowAgentHandler(run.store, run.metadata, run.lifecycle, run.executor, run.store.cwd, run.store.runId), worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, 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();
@@ -1388,7 +1990,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     run.completion = completion;
     void completion;
   };
-  const applyBudgetDecision = async (request: BudgetApprovalRequest, approved: boolean): Promise<BudgetDecisionResult> => {
+  const applyBudgetDecision = async (request: BudgetApprovalRequest, approved: boolean, context?: unknown, signal?: AbortSignal): Promise<BudgetDecisionResult> => {
     const run = runs.get(request.runId);
     if (!run) throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${request.runId}`);
     if (!approved) return { state: "budget_exhausted", approved: false };
@@ -1397,14 +1999,28 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     const runtime = new WorkflowBudgetRuntime(nextBudget, nextVersion, request.consumed, run.budget.events, { active: false });
     run.budget = runtime;
     await persistRunState(run.store, run.metadata, (current) => { const next = { ...current, ...runtime.snapshot(), budgetVersion: nextVersion }; if (nextBudget) next.budget = nextBudget; else delete next.budget; return next; });
-    await coldResumeRun(run, false, {}, true);
+    await coldResumeRun(run, false, {}, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) });
     return { state: "running", approved: true };
   };
-  const resumeWorkflowRun = async (runId: string, rawPatch?: unknown): Promise<Record<string, JsonValue>> => {
+  const resumeWorkflowRun = async (runId: string, rawPatch?: unknown, context?: unknown, signal?: AbortSignal): Promise<Record<string, JsonValue>> => {
     const run = runs.get(runId);
-    if (!run) throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${runId}`);
+    if (!run) {
+      const host = object(context) ? context : {};
+      const cwd = typeof host.cwd === "string" ? host.cwd : undefined;
+      const sessionManager = object(host.sessionManager) ? host.sessionManager : undefined;
+      const sessionId = typeof sessionManager?.getSessionId === "function" ? String(Reflect.apply(sessionManager.getSessionId, sessionManager, [])) : undefined;
+      if (cwd && sessionId) {
+        try {
+          const state = (await new RunStore(cwd, sessionId, runId, home).load()).run.state;
+          throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("resume", state));
+        } catch (error) {
+          if (error instanceof WorkflowError) throw error;
+        }
+      }
+      throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run ${runId} in the current project and Pi session`);
+    }
     const loaded = await run.store.load();
-    if (loaded.run.state !== "budget_exhausted") throw new WorkflowError("RESUME_INCOMPATIBLE", "Only budget-exhausted runs can be resumed with workflow_resume");
+    if (loaded.run.state !== "budget_exhausted") throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("resume", loaded.run.state));
     const currentBudget = validateBudget(loaded.run.budget ?? loaded.snapshot.budget);
     const patch = rawPatch === undefined ? {} : validateBudgetPatch(rawPatch);
     const nextBudget = mergeBudget(currentBudget, patch);
@@ -1425,11 +2041,11 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       run.budget = runtime;
       await persistRunState(run.store, run.metadata, (current) => { const next = { ...current, ...runtime.snapshot(), budgetVersion: nextVersion }; if (nextBudget) next.budget = nextBudget; else delete next.budget; return next; });
     }
-    await coldResumeRun(run, false, {}, true);
+    await coldResumeRun(run, false, {}, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) });
     return { state: "running" };
   };
   const retryReservations = new Set<string>();
-  const retryWorkflowRun = async (runId: string, context: unknown): Promise<{ runId: string; parentRunId: string; state: "running" }> => {
+  const retryWorkflowRun = async (runId: string, context: unknown, signal?: AbortSignal): Promise<{ runId: string; parentRunId: string; state: "running" }> => {
     if (typeof runId !== "string" || !runId.trim()) throw new WorkflowError("RESUME_INCOMPATIBLE", "workflow_retry requires an explicit run ID");
     const host = object(context) ? context : {};
     const cwd = typeof host.cwd === "string" ? host.cwd : undefined;
@@ -1439,8 +2055,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     await ensureSessionLease(cwd, sessionId);
     const sourceStore = new RunStore(cwd, sessionId, runId, home);
     let loaded: { run: PersistedRun; snapshot: Readonly<LaunchSnapshot> };
-    try { loaded = await sourceStore.load(); } catch (error) { throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot load failed source run ${runId}: ${errorText(error)}`); }
-    if (loaded.run.state !== "failed") throw new WorkflowError("RESUME_INCOMPATIBLE", `Only failed workflow runs can be retried; source is ${loaded.run.state}`);
+    try { loaded = await sourceStore.load(); } catch (error) { throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run ${runId} in the current project and Pi session: ${errorText(error)}`); }
+    if (loaded.run.state !== "failed") throw new WorkflowError("RESUME_INCOMPATIBLE", workflowRecoveryGuidance("retry", loaded.run.state));
     if (loaded.run.retry && (typeof loaded.run.retry.sourceRunId !== "string" || !loaded.run.retry.sourceRunId || typeof loaded.run.retry.lineageRootRunId !== "string" || !loaded.run.retry.lineageRootRunId || !Array.isArray(loaded.run.retry.completedPaths) || loaded.run.retry.completedPaths.some((path) => typeof path !== "string") || !Array.isArray(loaded.run.retry.incompletePaths) || loaded.run.retry.incompletePaths.some((path) => typeof path !== "string") || !Array.isArray(loaded.run.retry.namedWorktrees) || loaded.run.retry.namedWorktrees.some((name) => typeof name !== "string"))) throw new WorkflowError("RESUME_INCOMPATIBLE", "The source retry provenance is incomplete");
     const lineageRootRunId = loaded.run.retry?.lineageRootRunId ?? loaded.run.id;
     if (retryReservations.has(lineageRootRunId)) throw new WorkflowError("RESUME_INCOMPATIBLE", `An active retry already owns lineage ${lineageRootRunId}`);
@@ -1466,22 +2082,10 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       if ((loaded.snapshot.projectRoles?.length ?? 0) > 0 && !trustedProject) throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot restore project roles in an untrusted project");
       const missingRole = loaded.snapshot.agentTypes.find((role) => !loaded.snapshot.roles?.[role]);
       if (missingRole) throw new WorkflowError("RESUME_INCOMPATIBLE", `Role definition is missing from the launch snapshot: ${missingRole}`);
-      const active = new Set<string>(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
-      const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
-      if (missing) throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
-      const settingsPath = workflowSettingsPath(extensionAgentDir);
-      const 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: ModelSpec = { 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);
       const completedPaths = (await sourceStore.replayableOperations()).map(({ path }) => path);
@@ -1490,7 +2094,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const budget = validateBudget(loaded.run.budget ?? loaded.snapshot.budget);
       const childRunId = randomUUID();
       const childStore = new RunStore(cwd, sessionId, childRunId, home);
-      const 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: WorkflowRetryProvenance = { sourceRunId: loaded.run.id, lineageRootRunId, completedPaths, incompletePaths, namedWorktrees };
@@ -1499,13 +2103,13 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       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() as unknown as readonly RegisteredAgentSetupHook[], 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;
@@ -1521,26 +2125,30 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     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) {
-      try { const result = await retryWorkflowRun(params.runId, ctx); return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result }; }
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      try { const result = await retryWorkflowRun(params.runId, ctx, signal); return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result }; }
       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) {
-      try { const result = await resumeWorkflowRun(params.runId, params.budget); return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result }; }
+    async execute(_id, params, signal, _onUpdate, ctx) {
+      try { const result = await resumeWorkflowRun(params.runId, params.budget, ctx, signal); return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result }; }
       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)) {
@@ -1565,7 +2173,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const roleDefinitions = loaded.snapshot.roles ?? {};
       const abortController = new AbortController();
       const providerErrorRecovery = createProviderErrorRecovery(ctx, new Set(loaded.snapshot.models), () => { abortController.abort(); });
-      runs.set(runId, { executor: new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels: new Set(loaded.snapshot.models), knownModels: new Set(loaded.snapshot.models), ...(loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ? { modelAliases: loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases } : {}), ...(loaded.snapshot.settingsPath ? { settingsPath: loaded.snapshot.settingsPath } : {}), agentDefinitions: roleDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks() as unknown as readonly RegisteredAgentSetupHook[], 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()) deliver(pi, budgetDecisionDelivery(loaded.snapshot.metadata, decision));
       scheduler.restoreRun(runId, loaded.snapshot.settings.concurrency, loaded.snapshot.identityVersion === LAUNCH_SNAPSHOT_IDENTITY_VERSION ? await store.loadOwnership() : [], () => runs.get(runId)?.budget.checkAgentLaunch());
@@ -1590,7 +2198,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
   });
   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")}`;
     return { systemPrompt: `${event.systemPrompt}\n\n${content}` };
@@ -1605,27 +2213,29 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       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: ModelSpec = { 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 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) as JsonValue;
       encoded(args);
-      const runController = new AbortController();
-      if (signal?.aborted) runController.abort(); else signal?.addEventListener("abort", () => { runController.abort(); }, { once: true });
       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);
@@ -1633,9 +2243,9 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       if (parentRunId !== undefined) await store.validateParentRun(parentRunId);
       const roles = Object.fromEntries(roleNames.map((role) => [role, agentDefinitions[role]])) as Record<string, AgentDefinition>;
       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" as const, 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" as const, functionName } : {}), ...(Object.keys(modelAliases).length ? { modelAliases } : {}), ...(budget ? { budget } : {}), ...(checked.referenced.phases.length ? { phases: checked.referenced.phases } : {}), models: snapshotModels, tools: rootTools, agentTypes: checked.referenced.agentTypes, roles, projectRoles, schemas: checked.schemas });
       const 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);
@@ -1643,37 +2253,11 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       const background = !params.foreground;
       const providerPause = async () => { if (background) deliver(pi, `Workflow ${checked.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
       const providerErrorRecovery = createProviderErrorRecovery(ctx, availableModels, () => { runController.abort(); });
-      const executor = new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model: rootModel, tools: new Set(rootTools), availableModels, knownModels, modelAliases: defaults.modelAliases ?? {}, settingsPath, agentDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks() as unknown as readonly RegisteredAgentSetupHook[], 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 as string[] } : {}) });
-          const label = displayAgentName(requestedLabel, role, resolved.model);
-          const tools = resolved.tools;
-          const schema = object(options.outputSchema) ? options.outputSchema : undefined;
-          const spawned = scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), agentOptions: options, agentIdentity: identity });
-          const cancel = () => { scheduler.cancel(spawned.id); };
-          if (agentSignal.aborted) cancel(); else agentSignal.addEventListener("abort", cancel, { once: true });
-          const outcome = await spawned.result.finally(() => { agentSignal.removeEventListener("abort", cancel); });
-          if (!outcome.ok) throw new WorkflowError(outcome.error.code as WorkflowErrorCode, outcome.error.message);
-          await store.complete(path, outcome.value);
-          return outcome.value;
-        } finally { await lifecycle.leave(); }
-      }, worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, Boolean(params.foreground), params.foreground && ctx.hasUI ? ctx.ui : undefined, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(lifecycle, checked.metadata.name) }, store, runContext, variables, registry), runController.signal);
+      const execution = runWorkflow(script, args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal, identity), agent: workflowAgentHandler(store, checked.metadata, lifecycle, executor, ctx.cwd, runId), worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, Boolean(params.foreground), params.foreground && ctx.hasUI ? ctx.ui : undefined, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(lifecycle, checked.metadata.name) }, store, runContext, variables, registry), runController.signal);
       (runs.get(runId) as NonNullable<ReturnType<typeof runs.get>>).execution = execution;
       await eventPublisher.runStarted(store, checked.metadata);
       const finish = execution.result.then(async (value) => {
@@ -1754,7 +2338,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
         return entries.filter((entry): entry is { store: RunStore; loaded: { run: PersistedRun; snapshot: Readonly<LaunchSnapshot> } } => 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: string | undefined) => {
         const setStatus = uiHostCapabilities(ctx.ui)?.setStatus;
         setStatus?.call(ctx.ui, "workflow-stop", text);
@@ -1771,12 +2355,12 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
             return keepContext ? "dashboard" : "done";
           }
           if ((action === "budget-approve" || action === "budget-reject") && runId && rest[0]) {
-            const result = await answerBudgetDecision(runId, rest[0], action === "budget-approve", true);
+            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)) { ctx.ui.notify("Stop the workflow before deleting it.", "warning"); return keepContext ? "dashboard" : "done"; }
+            if (!HARD_TERMINAL_RUN_STATES.has(stored.loaded.run.state)) { ctx.ui.notify("Stop the workflow before deleting it.", "warning"); return keepContext ? "dashboard" : "done"; }
             if (!await ctx.ui.confirm("Delete workflow?", `Delete ${stored.loaded.run.workflowName} (${stored.store.runId}) and all owned artifacts? This cannot be undone.`)) return keepContext ? "dashboard" : "done";
             await stored.store.delete(true); runs.delete(stored.store.runId); terminalRunStates.delete(stored.store.runId); ctx.ui.notify(`Deleted workflow ${stored.store.runId}.`, "info"); return keepContext ? "picker" : "done";
           }
@@ -1784,12 +2368,12 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           if (action === "resume" && run) {
             if (run.lifecycle.state === "budget_exhausted") {
               const patch: unknown = rest.length ? JSON.parse(rest.join(" ")) as unknown : undefined;
-              const result = await resumeWorkflowRun(run.store.runId, patch);
+              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 {
               if (run.lifecycle.state === "interrupted") await coldResumeRun(run, ctx.hasUI, ctx.ui, projectTrusted(ctx), ctx);
               else {
-                if (run.lifecycle.state === "paused") await refreshPausedRunAliases(run, ctx);
+                if (run.lifecycle.state === "paused") await refreshPausedRunAliases(run, { ...resumeHostContext(ctx), projectTrusted: projectTrusted(ctx) });
                 await run.lifecycle.resume();
               }
               ctx.ui.notify(`Resumed workflow ${run.store.runId}.`, "info");
@@ -1799,7 +2383,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           if (action === "adjust" && run?.lifecycle.state === "budget_exhausted") {
             const input = await uiHostCapabilities(ctx.ui)?.input?.call(ctx.ui, "Budget patch (JSON)", "{\"tokens\":{\"hard\":null}}" );
             if (input === undefined) return keepContext ? "dashboard" : "done";
-            const result = await resumeWorkflowRun(run.store.runId, JSON.parse(input));
+            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";
           }
@@ -1824,6 +2408,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       };
       const manageAliases = async (): Promise<void> => {
         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: Readonly<Record<string, string>>): Promise<string | undefined> => {
@@ -1834,13 +2420,13 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           return (await ctx.ui.input("Manual model ID", "provider/model[:thinking] or alias[:thinking]"))?.trim() || undefined;
         };
         const save = (aliases: Readonly<Record<string, string>>): boolean => {
-          try { saveModelAliases(settingsPath, aliases); ctx.ui.notify(`Saved model aliases to ${settingsPath}.`, "info"); return true; }
-          catch (error) { ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error"); return false; }
+          try { saveModelAliases(aliasSettingsPath, aliases); ctx.ui.notify(`Saved model aliases to ${aliasSettingsPath}.`, "info"); return true; }
+          catch (error) { ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error"); return false; }
         };
         for (;;) {
           let aliases: Readonly<Record<string, string>>;
-          try { aliases = loadSettings(settingsPath).modelAliases ?? {}; }
-          catch (error) { ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error"); return; }
+          try { const resolution = resolveWorkflowSettings(ctx.cwd, trustedProject, settingsPath); aliases = resolution.effective.modelAliases ?? {}; aliasSettingsPath = resolution.sources.modelAliases; }
+          catch (error) { ctx.ui.notify(`${trustedProject ? workflowProjectSettingsPath(ctx.cwd) : settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error"); return; }
           const names = Object.keys(aliases).sort();
           const listing = names.length ? names.map((name) => `${name} = ${aliases[name] ?? ""}`).join("\n") : "(none)";
           const options = ["Add alias", ...names.map((name) => `Edit ${name}`), ...names.map((name) => `Delete ${name}`), "Back"];
@@ -1853,8 +2439,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
             const target = await selectTarget(aliases);
             if (!target) continue;
             const next = { ...aliases, [name]: target };
-            try { validateModelAliases(next, settingsPath); } catch (error) { ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error"); continue; }
-            const parsed = resolveModelReference(target, next, new Set(available()), settingsPath);
+            try { validateModelAliases(next, aliasSettingsPath); } catch (error) { ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error"); continue; }
+            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?")) continue;
@@ -1867,8 +2453,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
             const target = await selectTarget(aliases);
             if (!target) continue;
             const next = { ...aliases, [edit[1]]: target };
-            try { validateModelAliases(next, settingsPath); } catch (error) { ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error"); continue; }
-            const parsed = resolveModelReference(target, next, new Set(available()), settingsPath);
+            try { validateModelAliases(next, aliasSettingsPath); } catch (error) { ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error"); continue; }
+            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?")) continue;
@@ -1897,9 +2483,10 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           }
           const sorted = navigatorAttentionSort(stores);
           const labels = navigatorRunLabels(sorted);
-          const terminalStates = new Set(["completed", "failed", "stopped"]);
+          const terminalStates = HARD_TERMINAL_RUN_STATES;
           const hasCompleted = sorted.some(({ loaded: { run } }) => run.state === "completed");
-          const 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;
           if (runChoice === "Inspect session in pane") {
@@ -1919,6 +2506,13 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
             }
             ctx.ui.notify("Deleted all completed workflow runs.", "info"); 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;
           const selected = sorted[runIndex];
@@ -1936,6 +2530,13 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
             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<string, JsonValue>();
+            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<string, string>();
             const copies = new Map<string, { value: string; artifact: string }>();
             const reviews = new Map<string, AwaitingCheckpoint>();
@@ -1961,96 +2562,135 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
               }
             }
             if (ctx.mode !== "tui") actions.set("Refresh", "refresh");
-            else actions.set("View script", "view-script");
-            if (loaded.run.agents.length) actions.set("Agents...", "agents");
+            else 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");
             if (ctx.mode === "tui") {
               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: Awaited<ReturnType<typeof loadDashboard>>): Promise<void> => {
-            const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
-            const title = (agent: AgentRecord): string => {
-              const parents: string[] = [];
-              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: Awaited<ReturnType<typeof loadDashboard>>, agent: AgentRecord): WorktreeReference | undefined => agent.worktreeOwner ? dashboard.worktrees.find((candidate) => candidate.owner === agent.worktreeOwner) : undefined;
+          const agentActionLabels = (dashboard: Awaited<ReturnType<typeof loadDashboard>>, agent: AgentRecord): string[] => {
+            const worktree = agentWorktreeFor(dashboard, agent);
+            return [
+              ...(agent.attemptDetails?.length && herdrPaneId() ? ["Fork as Pi session in pane"] : []),
               ...(worktree ? ["Copy branch", "Copy worktree path"] : []),
+              ...(ctx.mode === "tui" && dashboard.agentResults.has(agent.id) ? ["Open result in editor"] : []),
               "Copy agent ID",
               "Back",
             ];
-            const chooseAttempt = async (): Promise<AgentAttemptSummary | undefined> => {
-              const choices = attempts.map((attempt) => `Attempt ${String(attempt.attempt)}`);
-              const choice = choices.length === 1 ? choices[0] : await ctx.ui.select("Fork attempts", [...choices, "Back"]);
-              const index = choice ? choices.indexOf(choice) : -1;
-              return index >= 0 ? attempts[index] : undefined;
-            };
+          };
+          const forkAgentSession = async (dashboard: Awaited<ReturnType<typeof loadDashboard>>, agent: AgentRecord): Promise<void> => {
+            const attempts = [...(agent.attemptDetails ?? [])].sort((left, right) => left.attempt - right.attempt);
+            const worktree = agentWorktreeFor(dashboard, agent);
+            const choices = attempts.map((attempt) => `Attempt ${String(attempt.attempt)}`);
+            const choice = choices.length === 1 ? choices[0] : await ctx.ui.select("Fork attempts", [...choices, "Back"]);
+            const index = choice ? choices.indexOf(choice) : -1;
+            const attempt = index >= 0 ? attempts[index] : undefined;
+            if (!attempt) return;
+            const running = !SETTLED_AGENT_STATES.has(agent.state) && attempt.attempt === attempts.at(-1)?.attempt && !attempt.error;
+            if (running && !await ctx.ui.confirm("Fork running attempt?", "This attempt is still running. The snapshot may end mid-turn and will not receive later updates. It opens read-only to avoid concurrent changes to the workflow agent's working directory. Continue?")) return;
+            try {
+              await openHerdrPane({ action: "fork", cwd: worktree?.cwd ?? attempt.setup?.cwd ?? dashboard.cwd, original: attempt.sessionFile, ...(running ? { readOnly: true } : {}) });
+              ctx.ui.notify("Forked Pi session in pane.", "info");
+            } catch (error) {
+              ctx.ui.notify(`Cannot fork Pi session in pane: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            }
+          };
+          const selectAgent = async (dashboard: Awaited<ReturnType<typeof loadDashboard>>, requestedAgentId?: string): Promise<void> => {
+            const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
+            const title = (agent: AgentRecord): string => agentBreadcrumb(agent, byId, true);
+            const labels = dashboard.agents.map((agent, index) => `#${String(index + 1)} ${title(agent)} [${agent.state}]`);
+            let selected: AgentRecord | undefined;
+            if (requestedAgentId) selected = dashboard.agents.find((agent) => agent.id === requestedAgentId);
+            else {
+              const selectedLabel = await ctx.ui.select("Agents", [...labels, "Back"]);
+              const selectedIndex = selectedLabel ? labels.indexOf(selectedLabel) : -1;
+              selected = selectedIndex >= 0 ? dashboard.agents[selectedIndex] : undefined;
+            }
+            if (!selected) return;
+            const worktree = agentWorktreeFor(dashboard, selected);
+            const actions = agentActionLabels(dashboard, selected);
             for (;;) {
               const action = await ctx.ui.select(title(selected), actions);
               if (!action || action === "Back") return;
               if (action === "Copy agent ID") { await copyArtifact(selected.id, "agent ID"); continue; }
               if (action === "Copy branch" && worktree) { await copyArtifact(worktree.branch, "branch"); continue; }
               if (action === "Copy worktree path" && worktree) { await copyArtifact(worktree.path, "worktree path"); continue; }
-              if (action === "Fork as Pi session in pane") {
-                const attempt = await chooseAttempt();
-                if (!attempt) continue;
-                const running = !SETTLED_AGENT_STATES.has(selected.state) && attempt.attempt === attempts.at(-1)?.attempt && !attempt.error;
-                if (running && !await ctx.ui.confirm("Fork running attempt?", "This attempt is still running. The snapshot may end mid-turn and will not receive later updates. It opens read-only to avoid concurrent changes to the workflow agent's working directory. Continue?")) continue;
-                try {
-                  await openHerdrPane({ action: "fork", cwd: worktree?.cwd ?? attempt.setup?.cwd ?? dashboard.cwd, original: attempt.sessionFile, ...(running ? { readOnly: true } : {}) });
-                  ctx.ui.notify("Forked Pi session in pane.", "info");
-                } catch (error) {
-                  ctx.ui.notify(`Cannot fork Pi session in pane: ${error instanceof Error ? error.message : String(error)}`, "warning");
-                }
-              }
+              if (action === "Fork as Pi session in pane") await forkAgentSession(dashboard, selected);
             }
           };
           for (;;) {
             let view = await loadDashboard();
             const actionChoice = ctx.mode === "tui"
               ? await ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) => {
-                  let options = [...view.actions.keys(), "Close"];
-                  let selectedIndex = 0;
                   let dashboardOffset = 0;
                   let refreshing = false;
                   let disposed = false;
+                  let detailsMode = false;
+                  let actionMode = false;
+                  let actionIndex = 0;
                   let stopRequested = false;
                   let stopStatus: string | undefined;
+                  let selectionNeedsScroll = true;
+                  let renderedWidth = 80;
+                  let refreshGeneration = 0;
+                  const initialSelection = preserveWorkflowPhaseSelection(view.phaseModel, {});
+                  let 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: Record<string, string> = { up: "↑", down: "↓", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
+                  const keyLabels: Record<string, string> = { up: "↑", down: "↓", left: "←", right: "→", pageUp: "pgup", pageDown: "pgdn" };
                   const keyLabel = (binding: string, fallback: string) => {
                     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 = (): AgentRecord | undefined => {
+                    const node = selectedNodeId ? tree.byId.get(selectedNodeId) : tree.nodes[0];
+                    return node?.kind === "agent" && node.agentId ? view.agents.find((agent) => agent.id === node.agentId) : undefined;
+                  };
+                  const actionOptions = () => {
+                    const agent = selectedAgentRecord();
+                    return agent ? agentActionLabels(view, agent) : [...view.actions.keys(), "Back"];
                   };
-                  const updateDashboard = async (selectedOption: string | undefined) => {
+                  let editorRunning = false;
+                  const openArtifact = async (artifact: Promise<WorkflowArtifact>, label: string): Promise<void> => {
+                    if (editorRunning) return;
+                    editorRunning = true;
+                    try {
+                      const command = SettingsManager.create(view.cwd, extensionAgentDir, { projectTrusted: projectTrusted(ctx) }).getExternalEditorCommand();
+                      if (!command) { ctx.ui.notify(`Cannot open ${label}: no external editor is configured.`, "warning"); return; }
+                      const exitCode = await openWorkflowArtifact(tui, command, await artifact);
+                      if (exitCode !== 0) {
+                        const detail = exitCode === null ? "could not be started" : `exited with code ${String(exitCode)}`;
+                        ctx.ui.notify(`Cannot open ${label}: external editor ${detail}.`, "warning");
+                      }
+                    } catch (error) {
+                      ctx.ui.notify(`Cannot open ${label}: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                    } finally {
+                      editorRunning = false;
+                      tui.requestRender(true);
+                    }
+                  };
+                  const updateDashboard = async () => {
+                    const generation = ++refreshGeneration;
+                    const hadExpandableNodes = tree.nodes.some((node) => node.children.length > 0);
                     const next = await loadDashboard();
-                    if (disposed) return;
+                    if (disposed || generation !== refreshGeneration) return;
+                    const previousNodeId = selectedNodeId;
+                    const previousExpanded = expandedNodeIds;
+                    const selectedAction = actionMode ? actionOptions()[actionIndex] : undefined;
                     view = next;
-                    options = [...view.actions.keys(), "Close"];
-                    selectedIndex = Math.max(0, options.indexOf(selectedOption ?? ""));
+                    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 = () => {
@@ -2058,14 +2698,14 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                     stopRequested = true;
                     stopStatus = undefined;
                     setWorkflowStatus(undefined);
-                    const selectedOption = options[selectedIndex];
                     void runAction(`stop ${store.runId}`, true, (status) => {
                       stopStatus = status;
                       setWorkflowStatus(status);
                       if (!disposed) tui.requestRender();
-                    }).then(() => updateDashboard(selectedOption)).catch((error: unknown) => {
+                    }).then(() => updateDashboard()).catch((error: unknown) => {
                       if (disposed) return;
                       stopStatus = `Could not stop workflow ${store.runId}: ${error instanceof Error ? error.message : String(error)}`;
+                      setWorkflowStatus(stopStatus);
                       tui.requestRender();
                     }).finally(() => {
                       stopRequested = false;
@@ -2075,89 +2715,122 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                   const timer = setInterval(() => {
                     if (refreshing || stopRequested) return;
                     refreshing = true;
-                    const selectedOption = options[selectedIndex];
-                    void updateDashboard(selectedOption).catch(() => undefined).finally(() => { refreshing = false; });
+                    void updateDashboard().catch(() => undefined).finally(() => { refreshing = false; });
                   }, 1000);
                   timer.unref();
                   return borderWorkflowOverlay({
                     render(width: number) {
-                      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; }
-                      const maxOffset = Math.max(0, dashboardLines.length - layout.dashboardViewport);
+                      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;
+                      }
                       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: string) {
-                      if (stopRequested) 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 (stopRequested || editorRunning) return;
+                      const narrow = renderedWidth < 80;
+                      if (!actionMode && (data === "a" || data === "A")) { actionMode = true; actionIndex = 0; dashboardOffset = 0; tui.requestRender(); return; }
+                      if (actionMode) {
+                        const options = actionOptions();
+                        if (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;
                       }
+                      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(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 (options[selectedIndex] === "Stop") requestStop();
-                        else done(options[selectedIndex]);
+                        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;
             if (actionChoice === "Agents...") { await selectAgent(view); continue; }
-            if (actionChoice === "Refresh") continue;
-            if (actionChoice === "View script") {
-              await ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) => {
-                const highlighted = highlightCode(view.script, "javascript");
-                let offset = 0;
-                let renderedLines: string[] = [];
-                const viewport = () => Math.max(1, tuiRows(tui) - 3 - WORKFLOW_OVERLAY_BORDER_ROWS);
-                const move = (delta: number) => {
-                  const maxOffset = Math.max(0, renderedLines.length - viewport());
-                  offset = Math.max(0, Math.min(maxOffset, offset + delta));
-                };
-                return borderWorkflowOverlay({
-                  render(width: number) {
-                    renderedLines = highlighted.flatMap((line) => line ? truncateToVisualLines(line, Number.MAX_SAFE_INTEGER, width, 0).visualLines : [""]);
-                    const maxOffset = Math.max(0, renderedLines.length - viewport());
-                    offset = Math.min(offset, maxOffset);
-                    return [
-                      theme.fg("accent", "Workflow script"),
-                      ...renderedLines.slice(offset, offset + viewport()),
-                      "",
-                      theme.fg("dim", "↑↓/pgup/pgdn scroll · esc close"),
-                    ];
-                  },
-                  invalidate() {},
-                  handleInput(data: string) {
-                    if (keybindings.matches(data, "tui.select.up")) move(-1);
-                    else if (keybindings.matches(data, "tui.select.down")) move(1);
-                    else if (keybindings.matches(data, "tui.select.pageUp")) move(-viewport());
-                    else if (keybindings.matches(data, "tui.select.pageDown")) move(viewport());
-                    else if (keybindings.matches(data, "tui.select.cancel")) done(undefined);
-                    tui.requestRender();
-                  },
-                }, theme);
-              }, { overlay: true, overlayOptions: { anchor: "top-left", width: "100%", maxHeight: "100%" } });
+            if (actionChoice.startsWith("__workflow_agent__:")) { await selectAgent(view, actionChoice.slice("__workflow_agent__:".length)); continue; }
+            if (actionChoice.startsWith("__workflow_fork__:")) {
+              const agentId = actionChoice.slice("__workflow_fork__:".length);
+              const agent = view.agents.find((candidate) => candidate.id === agentId);
+              if (agent) await forkAgentSession(view, agent);
               continue;
             }
+            if (actionChoice === "Refresh") continue;
             const copy = view.copies.get(actionChoice);
             if (copy) { await copyArtifact(copy.value, copy.artifact); continue; }
             if (actionChoice.startsWith("Review ")) {
@@ -2211,7 +2884,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                     tui.requestRender();
                   },
                 }, theme);
-              }, { overlay: true, overlayOptions: { anchor: "top-left", width: "100%", maxHeight: "100%" } });
+              }, { overlay: true, overlayOptions: WORKFLOW_OVERLAY_OPTIONS });
               if (decision) {
                 const accepted = await answerCheckpoint(store.runId, checkpoint.name, decision === "Approve", true);
                 if (!accepted) ctx.ui.notify("Checkpoint is not awaiting a response.", "warning");
@@ -2231,9 +2904,9 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
   pi.on("session_shutdown", async () => {
     try {
       await Promise.all([...runs.entries()].map(async ([runId, run]) => {
-        if (["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state)) { await run.completion?.catch(() => undefined); return; }
-        if (!["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state)) {
-          try { await run.lifecycle.terminal("interrupted"); } catch (error) { if (!["completed", "failed", "stopped", "budget_exhausted"].includes(run.lifecycle.state)) throw error; }
+        const isTerminal = SHUTDOWN_TERMINAL_RUN_STATES.has(run.lifecycle.state);
+        if (!isTerminal) {
+          try { await run.lifecycle.terminal("interrupted"); } catch (error) { if (!SHUTDOWN_TERMINAL_RUN_STATES.has(run.lifecycle.state)) throw error; }
           run.abortController.abort();
           run.execution?.cancel();
           await scheduler.cancelRun(runId);