pi-extensible-workflows 3.0.0 → 3.1.0

package/src/host.ts

@@ -6,16 +6,16 @@ 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 { 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 { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WORKFLOW_AGENT_STATE_CHANGED_EVENT, WORKFLOW_BUDGET_EVENT, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, WORKFLOW_PHASE_CHANGED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, WORKFLOW_WORKTREE_CREATED_EVENT, WorkflowError, type AgentAttemptSummary, type AgentOptions, type AgentRecord, type AgentResourcePolicy, type BudgetApprovalRequest, type BudgetEvent, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type WorkflowBridge, type WorkflowCatalogFunction, type WorkflowCatalogIndex, type WorkflowCatalogVariable, type WorkflowCheckpointState, type WorkflowErrorCode, type WorkflowErrorShape, type WorkflowEventBase, type WorkflowFailureAgent, type WorkflowFailureDiagnostics, type WorkflowFunctionContext, type WorkflowExecution, type WorkflowMetadata, type WorkflowModelAliasResolverContext, type WorkflowRetryProvenance, type WorkflowRunContext, type WorkflowSettings, type WorkflowSettingsResolution, type WorkflowSiblingAgent, type WorkflowWorktreeReference } from "./types.js";
 const SETTLED_AGENT_STATES: ReadonlySet<import("./types.js").AgentState> = new Set(["completed", "failed", "cancelled"]);
 export interface WorkflowProgressStyles {
   accent(text: string): string;
@@ -26,7 +26,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: join(cwd, ".pi", "pi-extensible-workflows", "settings.json"), projectTrusted, global: empty, project: empty, effective: snapshot.settings.disabledAgentResources ?? empty, unmatchedSkills: [], unmatchedExtensions: [] };
+}
 const PLAIN_WORKFLOW_PROGRESS_STYLES: WorkflowProgressStyles = { accent: (text) => text, success: (text) => text, error: (text) => text, warning: (text) => text, muted: (text) => text, dim: (text) => text, bold: (text) => text };
+type WorkflowLaunchSettings = { settings: Readonly<WorkflowSettings>; resolution: WorkflowSettingsResolution; resourcePolicy: AgentResourcePolicy; modelSettingsPath: string };
+function workflowLaunchSettings(cwd: string, projectTrusted: boolean, globalSettingsPath: string, concurrency?: number): WorkflowLaunchSettings {
+  const resolution = resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath);
+  const settings = Object.freeze({ ...resolution.effective, ...(concurrency === undefined ? {} : { concurrency }) });
+  return { settings, resolution, resourcePolicy: resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath), modelSettingsPath: resolution.sources.modelAliases };
+}
+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 {
@@ -162,7 +180,91 @@ export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
 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; status: 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, status: 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 }
+export function preserveWorkflowPhaseSelection(model: WorkflowPhaseModel, selection: WorkflowPhaseSelection): WorkflowPhaseSelection {
+  const phase = model.phases.find((candidate) => candidate.id === selection.phaseId) ?? (model.currentPhaseIndex === undefined ? undefined : model.phases[model.currentPhaseIndex]) ?? model.phases[0];
+  if (!phase) return {};
+  const agentId = phase.agents.some((agent) => agent.id === selection.agentId) ? selection.agentId : phase.agents[0]?.id;
+  return { phaseId: phase.id, ...(agentId === undefined ? {} : { agentId }) };
+}
 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 +277,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 });
@@ -242,6 +345,99 @@ 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() {},
+  };
+}
+
+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`);
 export function truncateWorkflowProgress(text: string, width: number): string[] {
@@ -264,7 +460,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) {
@@ -318,28 +514,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 {
@@ -395,11 +592,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]));
@@ -421,6 +620,60 @@ export function formatNavigatorRun(loaded: { run: PersistedRun; snapshot: Readon
   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 wrap = (text: string, limit = safeWidth): string[] => truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, Math.max(1, limit), 0).visualLines.map((line) => line.trimEnd());
+  const phaseStyle = (state: WorkflowPhaseState): ((text: string) => string) => state === "completed" ? (text) => styles.success(text) : state === "failed" || state === "cancelled" ? (text) => styles.error(text) : state === "running" ? (text) => styles.accent(text) : state === "interrupted" || state === "budget_exhausted" ? (text) => styles.warning(text) : (text) => styles.muted(text);
+  const phaseName = (phase: WorkflowPhaseView): string => `${phase.name}${phase.occurrence > 1 ? ` #${String(phase.occurrence)}` : ""}`;
+  const phaseCounts = (phase: WorkflowPhaseView): string => `agents completed=${String(phase.counts.completed)} running=${String(phase.counts.running)} failed=${String(phase.counts.failed)} cancelled=${String(phase.counts.cancelled)} pending=${String(phase.counts.pending)}`;
+  const phaseLine = (phase: WorkflowPhaseView, selected: boolean): string => `${selected ? "→" : " "} ${phaseName(phase)} · ${phaseStyle(phase.state)(phase.state)} · ${phaseCounts(phase)}`;
+  const stateNames: readonly WorkflowPhaseState[] = ["not started", "running", "completed", "failed", "cancelled", "interrupted", "budget_exhausted"];
+  const statusSummary = stateNames.filter((state) => (model.counts[state] ?? 0) > 0).map((state) => `${String(model.counts[state])} ${state}`).join(" · ") || "0 phases";
+  const selectedIndex = selection.phaseId ? model.phases.findIndex((phase) => phase.id === selection.phaseId) : -1;
+  const activeIndex = selectedIndex >= 0 ? selectedIndex : model.currentPhaseIndex ?? (model.phases.length ? 0 : -1);
+  const selectedPhase = activeIndex >= 0 ? model.phases[activeIndex] : undefined;
+  const lines: string[] = [styles.bold(styles.accent(`Workflow: ${run.workflowName}`))];
+  if (run.error) lines.push(styles.error(`ERROR ${run.error.code}: ${run.error.message}`));
+  lines.push(`phase: ${run.phase ?? selectedPhase?.name ?? "none"}`, `Run state: ${run.state}`, `Phases: ${statusSummary}`);
+  for (const event of run.events ?? []) lines.push(styles.warning(`Warning: ${event.message}`));
+  lines.push(...formatCompactBudgetStatus(run));
+  const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
+  const renderAgentLines = (agents: readonly AgentRecord[], selectedAgentId: string | undefined): string[] => {
+    if (!agents.length) return [styles.muted("Agents: none")];
+    const rendered: string[] = [];
+    for (const agent of agents) {
+      const selected = agent.id === selectedAgentId;
+      const stateStyle = progressStyleForState(agent.state, styles);
+      const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? "⠦" : "○";
+      rendered.push(`${selected ? "→" : " "} ${stateStyle(icon)} ${styledAgentBreadcrumb(agent, byId, styles)} · ${stateStyle(agent.state)}`);
+      if (agent.state === "failed") {
+        const error = agent.attemptDetails?.at(-1)?.error;
+        if (error) rendered.push(styles.error(`  error: ${error.code}: ${error.message}`));
+      }
+    }
+    return rendered;
+  };
+  if (!model.phases.length) {
+    lines.push(styles.muted("Phases: no declared or observed phases (legacy snapshot)"), styles.bold("Agents"), ...renderAgentLines(run.agents, selection.agentId));
+    return lines.flatMap((line) => wrap(line));
+  }
+  const selectedAgent = selectedPhase?.agents.find((agent) => agent.id === selection.agentId) ?? selectedPhase?.agents[0];
+  if (safeWidth >= 80) {
+    const sidebarWidth = Math.min(38, Math.max(24, Math.floor(safeWidth * 0.36)));
+    const detailWidth = Math.max(1, safeWidth - sidebarWidth - 3);
+    const sidebar = [styles.bold("Phases"), ...model.phases.flatMap((phase, index) => wrap(phaseLine(phase, index === activeIndex), sidebarWidth))];
+    const detail = selectedPhase ? [styles.bold(`Phase: ${phaseName(selectedPhase)}`), ...wrap(`Status: ${phaseStyle(selectedPhase.state)(selectedPhase.state)}`, detailWidth), ...wrap(phaseCounts(selectedPhase), detailWidth), "Agents", ...renderAgentLines(selectedPhase.agents, selectedAgent?.id).flatMap((line) => wrap(line, detailWidth))] : [styles.muted("No phase is selected")];
+    const rows = Math.max(sidebar.length, detail.length);
+    for (let index = 0; index < rows; index += 1) lines.push(`${sidebar[index] ?? ""} | ${detail[index] ?? ""}`);
+  } else {
+    lines.push(styles.bold("Phases"));
+    for (const [index, phase] of model.phases.entries()) lines.push(...wrap(phaseLine(phase, index === activeIndex)));
+    if (selectedPhase) lines.push("", styles.bold(`Selected phase: ${phaseName(selectedPhase)}`), ...wrap(`Status: ${phaseStyle(selectedPhase.state)(selectedPhase.state)}`), ...wrap(phaseCounts(selectedPhase)), styles.bold("Agents"), ...renderAgentLines(selectedPhase.agents, selectedAgent?.id).flatMap((line) => wrap(line)));
+  }
+  if (model.unassignedAgents?.length) 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");
@@ -862,6 +1115,33 @@ function contextHostCapabilities(ctx: unknown): ContextHostCapabilities {
   const getAvailable = registry.getAvailable;
   return { modelRegistry: { ...(isModelRegistryGetter(getAll) ? { getAll: () => getAll.call(registry) } : {}), ...(isModelRegistryGetter(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;
@@ -993,10 +1273,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 {
@@ -1167,13 +1444,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,16 +1500,16 @@ 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);
       }
@@ -1254,47 +1531,60 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
   });
   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 refreshPausedRunAliases = async (run: NonNullable<ReturnType<typeof runs.get>>, context?: { model: { provider: string; id: string } | undefined; modelRegistry: ModelRegistryCapability | undefined; projectTrusted?: boolean }) => {
     const loaded = await run.store.load();
     const active = new Set(pi.getActiveTools().filter((tool) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(tool)));
     const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
     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 trustedProject = context?.projectTrusted ?? run.projectTrusted();
+    const resolution = resolveWorkflowSettings(run.store.cwd, trustedProject, settingsPath);
+    const currentPolicy = resolveAgentResourcePolicy(run.store.cwd, trustedProject, settingsPath);
+    const staticAliases = resolution.effective.modelAliases ?? {};
     const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
-    const 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 rootModel = context?.model ? { ...run.model, provider: context.model.provider, model: context.model.id } : run.model;
+    const inventory = modelInventory(rootModel, context?.modelRegistry);
+    const knownModels = context?.modelRegistry ? inventory.knownModels : new Set([...loaded.snapshot.models, ...inventory.knownModels]);
+    const availableModels = context?.modelRegistry ? inventory.availableModels : new Set([...loaded.snapshot.models, ...inventory.availableModels]);
+    const currentAliases = (await resolveLaunchAliases(registry, staticAliases, { cwd: run.store.cwd, projectTrusted: trustedProject, rootModel, knownModels, availableModels, signal: run.abortController.signal }, availableModels, knownModels, settingsPath)).aliases;
     const blockedAliases = new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
     const blockedAliasTargets = Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
-    const snapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, settings: { ...loaded.snapshot.settings, modelAliases: currentAliases }, modelAliases: currentAliases });
+    const refreshed = resumedSnapshotSettings(loaded.snapshot, resolution, currentAliases);
+    const snapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
     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 = new WorkflowAgentExecutor({ cwd: run.store.cwd, agentDir: extensionAgentDir, model: run.model, tools: new Set(snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(currentPolicy) }, createSession);
     run.executor.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();
@@ -1307,26 +1597,30 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     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 resolution = resolveWorkflowSettings(run.store.cwd, trustedProject, settingsPath);
+    const currentPolicy = resolveAgentResourcePolicy(run.store.cwd, trustedProject, settingsPath);
+    const staticAliases = resolution.effective.modelAliases ?? {};
     const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
-    const 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 rootModel = context?.model ? { ...run.model, provider: context.model.provider, model: context.model.id } : run.model;
+    const inventory = modelInventory(rootModel, context?.modelRegistry);
+    const knownModels = context?.modelRegistry ? inventory.knownModels : new Set([...loaded.snapshot.models, ...inventory.knownModels]);
+    const availableModels = context?.modelRegistry ? inventory.availableModels : new Set([...loaded.snapshot.models, ...inventory.availableModels]);
+    const controller = new AbortController();
+    if (context?.signal?.aborted) controller.abort(); else { context?.signal?.addEventListener("abort", () => { controller.abort(); }, { once: true }); }
+    run.abortController = controller;
+    const currentAliases = context?.resolvedAliases ?? (await resolveLaunchAliases(registry, staticAliases, { cwd: run.store.cwd, projectTrusted: trustedProject, rootModel, knownModels, availableModels, signal: controller.signal }, availableModels, knownModels, settingsPath)).aliases;
     const resumeAliases = { ...previousAliases, ...currentAliases };
-    const blockedAliases = 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 blockedAliases = context?.blockedAliases ?? new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
+    const blockedAliasTargets = context?.blockedAliasTargets ?? Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
     const script = launchScriptForSnapshot(loaded.snapshot, registry);
-    preflight(script, { models: 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 });
+    preflight(script, { models: availableModels, tools: active, agentTypes: new Set(loaded.snapshot.agentTypes), modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, loaded.snapshot.schemas, loaded.snapshot.metadata, true);
+    const refreshed = resumedSnapshotSettings(loaded.snapshot, resolution, currentAliases);
+    const snapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
     await run.store.saveSnapshot(snapshot);
-    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 = new WorkflowAgentExecutor({ cwd: run.store.cwd, agentDir: extensionAgentDir, model: rootModel, tools: new Set(snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: snapshot.roles ?? {}, runStore: run.store, providerPause: async () => { deliver(pi, `Workflow ${snapshot.metadata.name} paused: provider limit.`); await run.lifecycle.providerPause(); }, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(currentPolicy) }, createSession);
     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>>;
@@ -1388,7 +1682,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,10 +1691,10 @@ 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}`);
     const loaded = await run.store.load();
@@ -1425,11 +1719,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;
@@ -1470,18 +1764,23 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
       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 resolution = resolveWorkflowSettings(cwd, trustedProject, settingsPath);
+      const currentPolicy = resolveAgentResourcePolicy(cwd, trustedProject, settingsPath);
+      const staticAliases = resolution.effective.modelAliases ?? {};
       const previousAliases = loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ?? {};
       const modelRegistry = contextHostCapabilities(context).modelRegistry;
-      const 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 rootModel: ModelSpec = { provider: hostModel.provider, model: hostModel.id, thinking: pi.getThinkingLevel() };
+      const inventory = modelInventory(rootModel, modelRegistry);
+      const knownModels = modelRegistry ? inventory.knownModels : new Set([...loaded.snapshot.models, ...inventory.knownModels]);
+      const availableModels = modelRegistry ? inventory.availableModels : new Set([...loaded.snapshot.models, ...inventory.availableModels]);
+      const resolvedAliases = await resolveLaunchAliases(registry, staticAliases, { cwd, projectTrusted: trustedProject, rootModel, knownModels, availableModels, signal: signal ?? new AbortController().signal }, availableModels, knownModels, settingsPath);
+      const currentAliases = resolvedAliases.aliases;
       const resumeAliases = { ...previousAliases, ...currentAliases };
+      const blockedAliases = new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
+      const blockedAliasTargets = Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
       const script = launchScriptForSnapshot(loaded.snapshot, registry);
-      preflight(script, { models: resumeModels, tools: active, agentTypes: new Set(loaded.snapshot.agentTypes), modelAliases: resumeAliases, knownModels: resumeModels, settingsPath, skipModelAvailability: true }, loaded.snapshot.schemas, loaded.snapshot.metadata, true);
+      preflight(script, { models: availableModels, tools: active, agentTypes: new Set(loaded.snapshot.agentTypes), modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, loaded.snapshot.schemas, loaded.snapshot.metadata, true);
       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 +1789,8 @@ 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 refreshed = resumedSnapshotSettings(loaded.snapshot, resolution, currentAliases);
+      const childSnapshot = createLaunchSnapshot({ ...loaded.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
       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 +1799,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: new WorkflowAgentExecutor({ cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => active.has(tool) || tool === "workflow_catalog")), availableModels, knownModels, modelAliases: currentAliases, blockedAliases, blockedAliasTargets, settingsPath, agentDefinitions: loaded.snapshot.roles ?? {}, runStore: childStore, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(currentPolicy) }, createSession), store: childStore, metadata: loaded.snapshot.metadata, model, lifecycle, budget: childBudget, abortController, projectTrusted: () => projectTrusted(context), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) };
       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,8 +1821,8 @@ 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); }
     },
   });
@@ -1531,8 +1831,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     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); }
     },
   });
@@ -1540,7 +1840,7 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
     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 +1865,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: new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels: new Set(loaded.snapshot.models), knownModels: new Set(loaded.snapshot.models), ...(loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ? { modelAliases: loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases } : {}), ...(loaded.snapshot.settingsSources?.modelAliases ? { settingsPath: loaded.snapshot.settingsSources.modelAliases } : loaded.snapshot.settingsPath ? { settingsPath: loaded.snapshot.settingsPath } : {}), agentDefinitions: roleDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(snapshotResourcePolicy(loaded.snapshot, store.cwd, projectTrusted(ctx), workflowSettingsPath(extensionAgentDir))) }, createSession), store, metadata: loaded.snapshot.metadata, model, lifecycle, budget: budgetRuntime, abortController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) });
       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 +1890,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 +1905,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 inventory = modelInventory(rootModel, modelRegistry);
+      const knownModels = inventory.knownModels;
+      const availableModels = inventory.availableModels;
       const rootTools = pi.getActiveTools().filter((name) => !["workflow", "workflow_respond", "workflow_stop", "workflow_resume", "workflow_retry", "workflow_catalog"].includes(name));
       const 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 +1935,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,7 +1945,7 @@ 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 = new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model: rootModel, tools: new Set(rootTools), availableModels, knownModels, modelAliases, settingsPath, agentDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: frozenResourcePolicy(launch.resourcePolicy), runContext }, createSession);
       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());
@@ -1754,7 +2056,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,7 +2073,7 @@ 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";
           }
@@ -1784,12 +2086,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 +2101,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 +2126,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 +2138,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 +2157,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 +2171,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;
@@ -1899,7 +2203,8 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
           const labels = navigatorRunLabels(sorted);
           const terminalStates = new Set(["completed", "failed", "stopped"]);
           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 +2224,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];
@@ -1968,19 +2280,11 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
               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, script: loaded.snapshot.script, 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 title = (agent: AgentRecord): string => agentBreadcrumb(agent, byId, true);
             const labels = dashboard.agents.map((agent, index) => `#${String(index + 1)} ${title(agent)} [${agent.state}]`);
             const selectedLabel = await ctx.ui.select("Agents", [...labels, "Back"]);
             const selectedIndex = selectedLabel ? labels.indexOf(selectedLabel) : -1;
@@ -2031,8 +2335,11 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                   let disposed = false;
                   let stopRequested = false;
                   let stopStatus: string | undefined;
+                  const initialSelection = preserveWorkflowPhaseSelection(view.phaseModel, {});
+                  let selectedPhaseId = initialSelection.phaseId;
+                  let selectedAgentId = initialSelection.agentId;
                   const terminalRows = () => Math.max(1, tuiRows(tui) - WORKFLOW_OVERLAY_BORDER_ROWS);
-                  const keyLabels: Record<string, string> = { up: "↑", down: "↓", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
+                  const keyLabels: Record<string, string> = { up: "↑", down: "↓", left: "←", right: "→", tab: "tab", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
                   const keyLabel = (binding: string, fallback: string) => {
                     const keys = keybindingKeys(keybindings, binding);
                     return keys?.length ? keys.map((key) => keyLabels[key] ?? key).join("/") : fallback;
@@ -2046,11 +2353,16 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                     return { rows, hintRows, separatorRows, actionViewport, dashboardViewport: available - actionViewport };
                   };
                   const updateDashboard = async (selectedOption: string | undefined) => {
+                    const phaseId = selectedPhaseId;
+                    const agentId = selectedAgentId;
                     const next = await loadDashboard();
                     if (disposed) return;
                     view = next;
                     options = [...view.actions.keys(), "Close"];
                     selectedIndex = Math.max(0, options.indexOf(selectedOption ?? ""));
+                    const preserved = preserveWorkflowPhaseSelection(view.phaseModel, { phaseId, agentId });
+                    selectedPhaseId = preserved.phaseId;
+                    selectedAgentId = preserved.agentId;
                     tui.requestRender();
                   };
                   const requestStop = () => {
@@ -2081,11 +2393,12 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                   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 styles = themeWorkflowProgressStyles(theme);
+                      const phaseLines = formatWorkflowPhaseDashboard(view.run, view.snapshot, width, { phaseId: selectedPhaseId, agentId: selectedAgentId }, styles);
+                      const dashboardLines = stopStatus ? [styles.error(stopStatus), ...phaseLines] : phaseLines;
                       const actionLines = options.map((option, index) => truncateToVisualLines(`${index === selectedIndex ? "→ " : "  "}${option}`, Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "");
                       const layout = dashboardLayout();
-                      const hint = truncateToVisualLines(theme.fg("dim", `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} 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 hint = truncateToVisualLines(theme.fg("dim", `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} actions · ${keyLabel("tui.editor.cursorLeft", "←")}/${keyLabel("tui.editor.cursorRight", "→")} phases · ${keyLabel("tui.input.tab", "tab")} agents${dashboardLines.length > layout.dashboardViewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · ${keyLabel("tui.select.confirm", "enter")} select · ${keyLabel("tui.select.cancel", "esc")} close · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
                       const compact = [...dashboardLines, "", ...actionLines, "", hint];
                       if (compact.length <= layout.rows) { dashboardOffset = 0; return compact; }
                       const maxOffset = Math.max(0, dashboardLines.length - layout.dashboardViewport);
@@ -2101,7 +2414,27 @@ export default function workflowExtension(pi: ExtensionAPI, home?: string, clipb
                     invalidate() {},
                     handleInput(data: string) {
                       if (stopRequested) return;
-                      if (keybindings.matches(data, "tui.select.up")) selectedIndex = (selectedIndex + options.length - 1) % options.length;
+                      const currentPhase = () => view.phaseModel.phases.find((phase) => phase.id === selectedPhaseId);
+                      const left = keybindings.matches(data, "tui.editor.cursorLeft");
+                      const right = keybindings.matches(data, "tui.editor.cursorRight");
+                      if (left || right) {
+                        const phases = view.phaseModel.phases;
+                        if (phases.length) {
+                          const currentIndex = Math.max(0, phases.findIndex((phase) => phase.id === selectedPhaseId));
+                          const delta = left ? -1 : 1;
+                          const nextPhase = phases[(currentIndex + delta + phases.length) % phases.length];
+                          selectedPhaseId = nextPhase?.id;
+                          selectedAgentId = nextPhase?.agents[0]?.id;
+                        }
+                      }
+                      else if (keybindings.matches(data, "tui.input.tab")) {
+                        const agents = currentPhase()?.agents ?? [];
+                        if (agents.length) {
+                          const currentIndex = Math.max(0, agents.findIndex((agent) => agent.id === selectedAgentId));
+                          selectedAgentId = agents[(currentIndex + 1) % agents.length]?.id;
+                        }
+                      }
+                      else if (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));