pi-extensible-workflows 3.0.0 → 3.1.0

package/dist/src/host.js

@@ -10,13 +10,32 @@ import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor } f
 import { herdrPaneId, openHerdrPane } from "./herdr.js";
 import { acquireSessionLease, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
 import { budgetRelaxed, budgetUsage, mergeBudget, resumeBudgetAllowed, validateBudget, validateBudgetPatch, WorkflowBudgetRuntime } from "./budget.js";
-import { asWorkflowError, aliasDrift, createLaunchSnapshot, deepFreeze, errorCode, errorText, fail, isWorkflowAuthored, jsonValue, modelCapability, object, parseModelReference, parseThinking, positiveInteger, resolveModelReference, validateModelAliases } from "./utils.js";
-import { launchScriptForSnapshot, loadAgentDefinitions, loadSettings, preflight, resolveAgentResourcePolicy, saveModelAliases, validateAgentOptions, validateCheckpoint, validateShellOptions, validateWorkflowLaunchWithRegistry, workflowPrompt, workflowSettingsPath } from "./validation.js";
+import { asWorkflowError, aliasDrift, createLaunchSnapshot, deepFreeze, errorCode, errorText, fail, isWorkflowAuthored, jsonValue, modelAliasErrorName, modelCapability, object, parseModelReference, parseThinking, positiveInteger, resolveModelReference, validateModelAliases } from "./utils.js";
+import { launchScriptForSnapshot, loadAgentDefinitions, preflight, resolveAgentResourcePolicy, resolveWorkflowSettings, saveModelAliases, validateAgentOptions, validateCheckpoint, validateModelAliasAvailability, validateShellOptions, validateWorkflowLaunchWithRegistry, workflowProjectSettingsPath, workflowPrompt, workflowSettingsPath } from "./validation.js";
 import { beginWorkflowExtensionLoading, loadingRegistry, resetWorkflowRegistry } from "./registry.js";
 import { agentIdentityPath, agentWorktree, encoded, executeShellCommand, persistActiveAgentAttempt, persistAgentAttempts, readShellResult, runWorkflow, shellIdentityPath } from "./execution.js";
 import { ERROR_CODES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WORKFLOW_AGENT_STATE_CHANGED_EVENT, WORKFLOW_BUDGET_EVENT, WORKFLOW_CHECKPOINT_STATE_CHANGED_EVENT, WORKFLOW_PHASE_CHANGED_EVENT, WORKFLOW_RUN_COMPLETED_EVENT, WORKFLOW_RUN_FAILED_EVENT, WORKFLOW_RUN_RESUMED_EVENT, WORKFLOW_RUN_STARTED_EVENT, WORKFLOW_RUN_STATE_CHANGED_EVENT, WORKFLOW_WORKTREE_CREATED_EVENT, WorkflowError } from "./types.js";
 const SETTLED_AGENT_STATES = new Set(["completed", "failed", "cancelled"]);
+function snapshotResourcePolicy(snapshot, cwd, projectTrusted, globalSettingsPath) {
+    const empty = { skills: [], extensions: [] };
+    return { globalSettingsPath, projectSettingsPath: join(cwd, ".pi", "pi-extensible-workflows", "settings.json"), projectTrusted, global: empty, project: empty, effective: snapshot.settings.disabledAgentResources ?? empty, unmatchedSkills: [], unmatchedExtensions: [] };
+}
 const PLAIN_WORKFLOW_PROGRESS_STYLES = { accent: (text) => text, success: (text) => text, error: (text) => text, warning: (text) => text, muted: (text) => text, dim: (text) => text, bold: (text) => text };
+function workflowLaunchSettings(cwd, projectTrusted, globalSettingsPath, concurrency) {
+    const resolution = resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath);
+    const settings = Object.freeze({ ...resolution.effective, ...(concurrency === undefined ? {} : { concurrency }) });
+    return { settings, resolution, resourcePolicy: resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath), modelSettingsPath: resolution.sources.modelAliases };
+}
+function frozenResourcePolicy(policy) { return () => structuredClone(policy); }
+function resumedSnapshotSettings(snapshot, resolution, modelAliases) {
+    const settings = { ...snapshot.settings, concurrency: snapshot.settingsSources === undefined || snapshot.settingsSources.concurrency === "per-run options" ? snapshot.settings.concurrency : resolution.effective.concurrency, modelAliases };
+    if (resolution.effective.disabledAgentResources === undefined)
+        delete settings.disabledAgentResources;
+    else
+        settings.disabledAgentResources = resolution.effective.disabledAgentResources;
+    const settingsSources = snapshot.settingsSources === undefined ? undefined : { ...snapshot.settingsSources, modelAliases: resolution.sources.modelAliases, disabledAgentResources: resolution.sources.disabledAgentResources, concurrency: snapshot.settingsSources.concurrency === "per-run options" ? "per-run options" : resolution.sources.concurrency };
+    return { settings, ...(settingsSources === undefined ? {} : { settingsSources }) };
+}
 const WORKFLOW_FAILURE_DIAGNOSTICS = Symbol("workflowFailureDiagnostics");
 function workflowDetail(message) {
     const detail = message.trim().replace(new RegExp(`\\b(?:${ERROR_CODES.join("|")})\\b:?\\s*`, "g"), "").replace(/^\s*[A-Z][A-Z0-9_]+:\s*/, "").split("\n").filter((line) => !/^\s*at\s/.test(line)).join("\n").replace(/^Run \S+(?=\s(?:exceeded|is))/i, "Run").replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi, "the workflow").replace(/^(?:Pi )session \S+(?=\s(?:is|has))/i, "session").replace(/^(Unknown scheduler run|Missing production ownership record|Persisted agent belongs to another run):\s*\S+/i, "$1").replace(/\b(?:runId|sessionId|callSite|occurrence|failedAt|id)[:=]\s*\S+/gi, "").replace(/\s{2,}/g, " ").trim();
@@ -160,6 +179,116 @@ export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
     parentRunId: Type.Optional(Type.String({ description: "Terminal run whose named worktrees may be reused" })),
 });
 export const WORKFLOW_RETRY_PARAMETERS = Type.Object({ runId: Type.String({ description: "Explicit failed workflow run ID" }) });
+function phaseNames(source) {
+    const phases = source === undefined ? [] : Array.isArray(source) ? source : source.phases ?? [];
+    return phases.filter((phase) => typeof phase === "string" && phase.trim() !== "").map((phase) => phase.trim());
+}
+function phaseAgentCounts(agents) {
+    const counts = { total: agents.length, completed: 0, running: 0, failed: 0, cancelled: 0, pending: 0 };
+    for (const agent of agents) {
+        if (agent.state === "completed")
+            counts.completed += 1;
+        else if (agent.state === "running")
+            counts.running += 1;
+        else if (agent.state === "failed")
+            counts.failed += 1;
+        else if (agent.state === "cancelled")
+            counts.cancelled += 1;
+        else
+            counts.pending += 1;
+    }
+    return counts;
+}
+function phaseState(runState, counts, isLatest) {
+    if (!isLatest)
+        return "completed";
+    if (runState === "failed")
+        return "failed";
+    if (runState === "stopped")
+        return "cancelled";
+    if (runState === "interrupted")
+        return "interrupted";
+    if (runState === "budget_exhausted")
+        return "budget_exhausted";
+    if (counts.failed > 0)
+        return "failed";
+    if (counts.cancelled > 0)
+        return "cancelled";
+    if (counts.running > 0 || counts.pending > 0)
+        return "running";
+    return runState === "completed" ? "completed" : "running";
+}
+export function buildWorkflowPhaseModel(run, source) {
+    const declaredPhases = phaseNames(source);
+    const rawHistory = Array.isArray(run.phaseHistory) ? run.phaseHistory : [];
+    const observed = [];
+    let boundary = 0;
+    for (const record of rawHistory) {
+        if (!object(record) || typeof record.phase !== "string" || !record.phase.trim() || typeof record.afterAgent !== "number" || !Number.isSafeInteger(record.afterAgent))
+            continue;
+        boundary = Math.max(boundary, Math.min(run.agents.length, Math.max(0, record.afterAgent)));
+        observed.push({ name: record.phase.trim(), afterAgent: boundary });
+    }
+    if (!observed.length && typeof run.phase === "string" && run.phase.trim())
+        observed.push({ name: run.phase.trim(), afterAgent: 0 });
+    const observedEntries = observed.map((entry, index) => ({ ...entry, index, agents: run.agents.slice(entry.afterAgent, observed[index + 1]?.afterAgent ?? run.agents.length) }));
+    const matchedDeclarations = new Set();
+    const declarationIndices = observedEntries.map((entry) => {
+        const index = declaredPhases.findIndex((name, candidate) => !matchedDeclarations.has(candidate) && name === entry.name);
+        if (index >= 0)
+            matchedDeclarations.add(index);
+        return index >= 0 ? index : undefined;
+    });
+    const entries = observedEntries.map((entry, index) => ({ name: entry.name, observedIndex: index, ...(declarationIndices[index] === undefined ? {} : { declarationIndex: declarationIndices[index] }) }));
+    for (const [declarationIndex, name] of declaredPhases.entries()) {
+        if (matchedDeclarations.has(declarationIndex))
+            continue;
+        const insertion = entries.findIndex((entry) => entry.declarationIndex !== undefined && entry.declarationIndex > declarationIndex);
+        const pending = { name };
+        if (insertion < 0)
+            entries.push(pending);
+        else
+            entries.splice(insertion, 0, pending);
+    }
+    const occurrences = new Map();
+    const phases = entries.map((entry) => {
+        const occurrence = (occurrences.get(entry.name) ?? 0) + 1;
+        occurrences.set(entry.name, occurrence);
+        const observation = entry.observedIndex === undefined ? undefined : observedEntries[entry.observedIndex];
+        const agents = observation?.agents ?? [];
+        const counts = phaseAgentCounts(agents);
+        const state = observation ? phaseState(run.state, counts, entry.observedIndex === observedEntries.length - 1) : "not started";
+        return { id: `${entry.name}#${String(occurrence)}`, name: entry.name, occurrence, state, status: state, observed: observation !== undefined, ...(observation ? { afterAgent: observation.afterAgent } : {}), agents, counts };
+    });
+    let currentPhaseIndex;
+    for (let index = phases.length - 1; index >= 0; index -= 1) {
+        if (phases[index]?.observed) {
+            currentPhaseIndex = index;
+            break;
+        }
+    }
+    const counts = {};
+    for (const phase of phases)
+        counts[phase.state] = (counts[phase.state] ?? 0) + 1;
+    const current = currentPhaseIndex === undefined ? undefined : phases[currentPhaseIndex];
+    const assigned = new Set(observedEntries.flatMap(({ agents }) => agents.map((agent) => agent.id)));
+    const unassignedAgents = run.agents.filter((agent) => !assigned.has(agent.id));
+    const result = { declaredPhases, phases, counts };
+    if (current !== undefined && currentPhaseIndex !== undefined) {
+        result.currentPhaseIndex = currentPhaseIndex;
+        result.currentPhaseId = current.id;
+    }
+    if (unassignedAgents.length)
+        result.unassignedAgents = unassignedAgents;
+    return result;
+}
+export function preserveWorkflowPhaseSelection(model, selection) {
+    const phase = model.phases.find((candidate) => candidate.id === selection.phaseId) ?? (model.currentPhaseIndex === undefined ? undefined : model.phases[model.currentPhaseIndex]) ?? model.phases[0];
+    if (!phase)
+        return {};
+    const agentId = phase.agents.some((agent) => agent.id === selection.agentId) ? selection.agentId : phase.agents[0]?.id;
+    return { phaseId: phase.id, ...(agentId === undefined ? {} : { agentId }) };
+}
 function agentGroupKey(agent) { return JSON.stringify([agent.structuralPath ?? [], agent.parentBreadcrumb ?? null]); }
 function agentGroupLabel(agents) {
     const structural = agents[0]?.structuralPath ?? [];
@@ -171,8 +300,13 @@ function agentGroups(agents, allAgents = agents) {
     const groups = new Map();
     for (const [index, agent] of agents.entries()) {
         let depth = 0;
-        for (let parent = agent.parentId; parent && byId.has(parent); parent = byId.get(parent)?.parentId)
+        const seen = new Set([agent.id]);
+        for (let parent = agent.parentId; parent && byId.has(parent); parent = byId.get(parent)?.parentId) {
+            if (seen.has(parent))
+                break;
+            seen.add(parent);
             depth += 1;
+        }
         const key = agentGroupKey(agent);
         const group = groups.get(key) ?? { agents: [] };
         group.agents.push({ agent, index, depth });
@@ -239,6 +373,101 @@ function textBlock(text) {
         invalidate() { },
     };
 }
+function styledTextBlock(text) {
+    return {
+        render(width) {
+            return truncateWorkflowProgress(text, width);
+        },
+        invalidate() { },
+    };
+}
+function workflowCatalogBlock(text, expanded) {
+    return {
+        render(width) {
+            const safeWidth = Math.max(1, width);
+            if (!expanded)
+                return truncateWorkflowProgress(text, safeWidth);
+            return truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, safeWidth, 0).visualLines.map((line) => line.trimEnd());
+        },
+        invalidate() { },
+    };
+}
+function catalogText(value) { return value.replace(/\s+/g, " ").trim(); }
+function catalogResultValue(result) {
+    if (result.details !== undefined)
+        return result.details;
+    const text = result.content?.find((entry) => entry.type === "text")?.text;
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function isCatalogIndex(value) {
+    return object(value) && Array.isArray(value.functions) && Array.isArray(value.variables);
+}
+function isCatalogFunction(value) {
+    return object(value) && typeof value.name === "string" && typeof value.description === "string" && object(value.input) && object(value.output);
+}
+function isCatalogVariable(value) {
+    return object(value) && typeof value.name === "string" && typeof value.description === "string" && object(value.schema);
+}
+function isCatalogError(value) {
+    return object(value) && object(value.error) && typeof value.error.message === "string";
+}
+function catalogSectionTitle(label, count, theme) {
+    return theme.fg("accent", theme.bold(`${label} (${String(count)})`));
+}
+function catalogIndexEntries(entries, theme) {
+    const width = Math.max(0, ...entries.map((entry) => entry.name.length));
+    return entries.map((entry) => `  ${theme.fg("accent", entry.name.padEnd(width))}  ${theme.fg("toolOutput", catalogText(entry.description))}`);
+}
+function formatCatalogIndex(catalog, theme) {
+    const aliases = Object.prototype.propertyIsEnumerable.call(catalog, "modelAliases") ? Object.keys(catalog.modelAliases ?? {}).sort().map((name) => ({ name, kind: "static", provenance: "settings" })) : catalog.modelAliasEntries ?? Object.keys(catalog.modelAliases ?? {}).sort().map((name) => ({ name, kind: "static", provenance: "settings" }));
+    const aliasWidth = Math.max(0, ...aliases.map(({ name }) => name.length));
+    const aliasLines = aliases.map(({ name, kind, provenance }) => `  ${theme.fg("accent", name.padEnd(aliasWidth))}  ${theme.fg("toolOutput", `${kind} · ${provenance}`)}`);
+    return [
+        catalogSectionTitle("Functions", catalog.functions.length, theme),
+        ...catalogIndexEntries(catalog.functions, theme),
+        "",
+        catalogSectionTitle("Variables", catalog.variables.length, theme),
+        ...catalogIndexEntries(catalog.variables, theme),
+        "",
+        catalogSectionTitle("Model aliases", aliases.length, theme),
+        ...aliasLines,
+    ].join("\n");
+}
+function catalogSchemaLines(schema, theme) {
+    const json = JSON.stringify(schema, null, 2);
+    return json.split("\n").map((line) => `  ${theme.fg("toolOutput", line)}`);
+}
+function formatCatalogDetail(value, expanded, theme) {
+    if ("kind" in value)
+        return [theme.fg("accent", theme.bold("Model alias")), `  ${theme.fg("accent", value.name)}  ${theme.fg("toolOutput", `${value.kind} · ${value.provenance}`)}`].join("\n");
+    const kind = "input" in value ? "Function" : "Variable";
+    if (!expanded)
+        return [theme.fg("accent", theme.bold(kind)), `  ${theme.fg("accent", value.name)}  ${theme.fg("toolOutput", catalogText(value.description))}`, `  ${theme.fg("muted", "version")}: ${theme.fg("toolOutput", value.version)}  ${theme.fg("muted", "headline")}: ${theme.fg("toolOutput", catalogText(value.headline))}`].join("\n");
+    const lines = [theme.fg("accent", theme.bold(`${kind}: ${value.name}`)), `${theme.fg("muted", "description")}: ${theme.fg("toolOutput", value.description)}`, "", theme.fg("accent", theme.bold("Extension")), `  ${theme.fg("muted", "version")}: ${theme.fg("toolOutput", value.version)}`, `  ${theme.fg("muted", "headline")}: ${theme.fg("toolOutput", value.headline)}`, `  ${theme.fg("muted", "description")}: ${theme.fg("toolOutput", value.extensionDescription)}`, "", theme.fg("accent", theme.bold("Schema"))];
+    if ("input" in value)
+        lines.push(theme.fg("muted", "Input schema"), ...catalogSchemaLines(value.input, theme), "", theme.fg("muted", "Output schema"), ...catalogSchemaLines(value.output, theme));
+    else
+        lines.push(theme.fg("muted", "Variable schema"), ...catalogSchemaLines(value.schema, theme));
+    return lines.join("\n");
+}
+function formatWorkflowCatalog(value, expanded, theme) {
+    if (isCatalogIndex(value))
+        return formatCatalogIndex(value, theme);
+    if (isCatalogFunction(value) || isCatalogVariable(value))
+        return formatCatalogDetail(value, expanded, theme);
+    if (object(value) && typeof value.name === "string" && (value.kind === "static" || value.kind === "dynamic"))
+        return formatCatalogDetail(value, expanded, theme);
+    if (isCatalogError(value))
+        return theme.fg("error", value.error.message);
+    return theme.fg("error", "The workflow catalog returned an invalid result.");
+}
 const ANSI_SGR = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`);
 export function truncateWorkflowProgress(text, width) {
     const safeWidth = Math.max(1, width);
@@ -263,7 +492,7 @@ function themeWorkflowProgressStyles(theme) {
         warning: (text) => theme.fg("warning", text),
         muted: (text) => theme.fg("muted", text),
         dim: (text) => theme.fg("dim", text),
-        bold: (text) => theme.bold(text),
+        bold: (text) => typeof theme.bold === "function" ? theme.bold(text) : text,
     };
 }
 function workflowProgressBlock(run, theme) {
@@ -317,32 +546,33 @@ function navigatorRunLabels(entries) {
         return `${glyph} ${run.workflowName}${suffix}  ${run.state}  ${run.phase ?? ""}  ${String(done)}/${String(run.agents.length)} agents${costStr}`;
     });
 }
-function agentBreadcrumbParts(agent, byId) {
-    const name = agent.label ?? agent.name;
-    const parts = agent.parentBreadcrumb ? [agent.parentBreadcrumb] : [];
+export function agentBreadcrumbParts(agent, byId, includeStructuralPath = false) {
+    const leaf = agent.label ?? agent.name;
+    const parts = includeStructuralPath && agent.structuralPath?.length ? [agent.structuralPath.join(" > ")] : [];
+    if (agent.parentBreadcrumb)
+        parts.push(agent.parentBreadcrumb);
+    const ancestors = [];
     const seen = new Set([agent.id]);
     for (let parentId = agent.parentId; parentId; parentId = byId.get(parentId)?.parentId) {
         if (seen.has(parentId))
-            break; // ponytail: cycle guard for corrupt data
+            break;
         seen.add(parentId);
         const parent = byId.get(parentId);
-        if (parent)
-            parts.push(parent.label ?? parent.name);
-        else
+        if (!parent)
             break;
+        ancestors.push(parent.label ?? parent.name);
     }
-    parts.push(name);
+    parts.push(...ancestors.reverse(), leaf);
     return parts;
 }
-function agentBreadcrumb(agent, byId) {
-    const parts = agentBreadcrumbParts(agent, byId);
-    return parts.length > 1 ? parts.join(" > ") : parts[0] ?? "";
+export function agentBreadcrumb(agent, byId, includeStructuralPath = false) {
+    return agentBreadcrumbParts(agent, byId, includeStructuralPath).join(" > ");
 }
 function styledAgentBreadcrumb(agent, byId, styles) {
     const parts = agentBreadcrumbParts(agent, byId);
     if (parts.length <= 1)
         return parts[0] ?? "";
-    return `${styles.muted(parts.slice(0, -1).join(" > "))} > ${parts[parts.length - 1] ?? ""}`;
+    return `${styles.muted(parts.slice(0, -1).join(" > "))} > ${styles.bold(parts[parts.length - 1] ?? "")}`;
 }
 function formatAgentActivity(agent, spinner, styles = PLAIN_WORKFLOW_PROGRESS_STYLES) {
     const label = agent.activity?.kind === "reasoning" ? "reasoning" : agent.activity?.kind === "text" ? "responding" : agent.activity?.kind === "tool" ? agent.activity.text : [...(agent.toolCalls ?? [])].reverse().find(({ state }) => state === "running")?.name ?? "";
@@ -401,6 +631,7 @@ export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
         `Launch cwd: ${run.cwd}`,
         ...formatCompactBudgetStatus(run),
         `Launch models: ${snapshot.models.join(", ") || "(none)"}`,
+        `Settings: concurrency=${String(snapshot.settings.concurrency)}`,
     ];
     if (run.error)
         lines.push(`Run error: ${run.error.code}: ${run.error.message}`);
@@ -409,6 +640,8 @@ export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
     const aliases = snapshot.modelAliases ?? snapshot.settings.modelAliases;
     if (aliases && Object.keys(aliases).length)
         lines.push(`Model aliases: ${Object.entries(aliases).map(([name, target]) => `${name}=${target}`).join(", ")}`);
+    if (snapshot.settingsSources)
+        lines.push(`Settings sources: concurrency=${snapshot.settingsSources.concurrency}, modelAliases=${snapshot.settingsSources.modelAliases}, disabledAgentResources=${snapshot.settingsSources.disabledAgentResources}`);
     lines.push("Agents / ownership:");
     if (!run.agents.length)
         lines.push("  (none)");
@@ -435,6 +668,69 @@ export function formatNavigatorRun(loaded, checkpoints, _worktrees) {
     lines.push(`Native Pi transcripts: ${String(run.nativeSessions.length)}`);
     return lines.join("\n");
 }
+export function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {}, styles = PLAIN_WORKFLOW_PROGRESS_STYLES) {
+    const safeWidth = Math.max(1, width);
+    const model = buildWorkflowPhaseModel(run, snapshot);
+    const wrap = (text, limit = safeWidth) => truncateToVisualLines(text, Number.MAX_SAFE_INTEGER, Math.max(1, limit), 0).visualLines.map((line) => line.trimEnd());
+    const phaseStyle = (state) => state === "completed" ? (text) => styles.success(text) : state === "failed" || state === "cancelled" ? (text) => styles.error(text) : state === "running" ? (text) => styles.accent(text) : state === "interrupted" || state === "budget_exhausted" ? (text) => styles.warning(text) : (text) => styles.muted(text);
+    const phaseName = (phase) => `${phase.name}${phase.occurrence > 1 ? ` #${String(phase.occurrence)}` : ""}`;
+    const phaseCounts = (phase) => `agents completed=${String(phase.counts.completed)} running=${String(phase.counts.running)} failed=${String(phase.counts.failed)} cancelled=${String(phase.counts.cancelled)} pending=${String(phase.counts.pending)}`;
+    const phaseLine = (phase, selected) => `${selected ? "→" : " "} ${phaseName(phase)} · ${phaseStyle(phase.state)(phase.state)} · ${phaseCounts(phase)}`;
+    const stateNames = ["not started", "running", "completed", "failed", "cancelled", "interrupted", "budget_exhausted"];
+    const statusSummary = stateNames.filter((state) => (model.counts[state] ?? 0) > 0).map((state) => `${String(model.counts[state])} ${state}`).join(" · ") || "0 phases";
+    const selectedIndex = selection.phaseId ? model.phases.findIndex((phase) => phase.id === selection.phaseId) : -1;
+    const activeIndex = selectedIndex >= 0 ? selectedIndex : model.currentPhaseIndex ?? (model.phases.length ? 0 : -1);
+    const selectedPhase = activeIndex >= 0 ? model.phases[activeIndex] : undefined;
+    const lines = [styles.bold(styles.accent(`Workflow: ${run.workflowName}`))];
+    if (run.error)
+        lines.push(styles.error(`ERROR ${run.error.code}: ${run.error.message}`));
+    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, selectedAgentId) => {
+        if (!agents.length)
+            return [styles.muted("Agents: none")];
+        const rendered = [];
+        for (const agent of agents) {
+            const selected = agent.id === selectedAgentId;
+            const stateStyle = progressStyleForState(agent.state, styles);
+            const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? "⠦" : "○";
+            rendered.push(`${selected ? "→" : " "} ${stateStyle(icon)} ${styledAgentBreadcrumb(agent, byId, styles)} · ${stateStyle(agent.state)}`);
+            if (agent.state === "failed") {
+                const error = agent.attemptDetails?.at(-1)?.error;
+                if (error)
+                    rendered.push(styles.error(`  error: ${error.code}: ${error.message}`));
+            }
+        }
+        return rendered;
+    };
+    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) {
     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");
@@ -938,6 +1234,38 @@ function contextHostCapabilities(ctx) {
     const getAvailable = registry.getAvailable;
     return { modelRegistry: { ...(isModelRegistryGetter(getAll) ? { getAll: () => getAll.call(registry) } : {}), ...(isModelRegistryGetter(getAvailable) ? { getAvailable: () => getAvailable.call(registry) } : {}) } };
 }
+function modelInventory(root, registry) {
+    const all = registry?.getAll?.() ?? registry?.getAvailable?.() ?? [];
+    const available = registry?.getAvailable?.() ?? registry?.getAll?.() ?? [];
+    const knownModels = new Set(all.map((model) => `${model.provider}/${model.id}`));
+    const availableModels = new Set(available.map((model) => `${model.provider}/${model.id}`));
+    const rootName = root?.provider && root.model ? `${root.provider}/${root.model}` : undefined;
+    if (rootName) {
+        knownModels.add(rootName);
+        availableModels.add(rootName);
+    }
+    return { knownModels, availableModels };
+}
+function resumeHostContext(ctx) {
+    const model = object(ctx) && object(ctx.model) && typeof ctx.model.provider === "string" && typeof ctx.model.id === "string" ? { provider: ctx.model.provider, id: ctx.model.id } : undefined;
+    return { model, modelRegistry: contextHostCapabilities(ctx).modelRegistry };
+}
+async function resolveLaunchAliases(registry, staticAliases, context, availableModels, knownModels, settingsPath) {
+    const dynamic = typeof registry.resolveModelAliases === "function" ? await registry.resolveModelAliases(context, new Set(Object.keys(staticAliases))) : {};
+    const dynamicNames = Object.keys(dynamic);
+    try {
+        const aliases = validateModelAliases({ ...dynamic, ...staticAliases }, settingsPath);
+        validateModelAliasAvailability(aliases, dynamicNames, availableModels, knownModels, settingsPath);
+        return { aliases, dynamicNames };
+    }
+    catch (error) {
+        const name = modelAliasErrorName(error);
+        const descriptor = name && typeof registry.modelAliases === "function" ? registry.modelAliases().find((candidate) => candidate.name === name) : undefined;
+        if (descriptor && errorCode(error) !== "CANCELLED")
+            throw new WorkflowError(errorCode(error) ?? "CONFIG_ERROR", `${errorText(error)} (extension: ${descriptor.headline})`);
+        throw error;
+    }
+}
 function isUiSelect(value) { return typeof value === "function"; }
 function isUiInput(value) { return typeof value === "function"; }
 function isUiSetStatus(value) { return typeof value === "function"; }
@@ -1084,11 +1412,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     };
     const phaseBridge = (store, metadata, lifecycle) => {
         let cursor = 0;
-        let executionPhase;
         return async (phase) => {
-            if (phase === executionPhase)
-                return;
-            executionPhase = phase;
             await scheduler.flush();
             await lifecycle.enter();
             try {
@@ -1293,7 +1617,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         run.budget.recordEvent({ type, budgetVersion: request.budgetVersion, dimensions: [], usage: structuredClone(request.consumed), limits: structuredClone(request.proposed), at: Date.now(), proposalId: request.proposalId, previous: structuredClone(request.previous), proposed: structuredClone(request.proposed) });
         await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot() }));
     };
-    const answerBudgetDecision = async (runId, proposalId, approved, silent = false) => {
+    const answerBudgetDecision = async (runId, proposalId, approved, silent = false, context, signal) => {
         const run = runs.get(runId);
         if (!run)
             return undefined;
@@ -1301,7 +1625,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         if (!request)
             return undefined;
         await appendBudgetDecisionEvent(run, request, approved ? "adjustment_approved" : "adjustment_rejected");
-        const result = await applyBudgetDecision(request, approved);
+        const result = await applyBudgetDecision(request, approved, context, signal);
         if (!silent)
             deliver(pi, `Workflow ${run.metadata.name} budget adjustment ${proposalId}: ${approved ? "Approved" : "Rejected"}.`);
         return result;
@@ -1362,10 +1686,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         label: "Workflow Respond",
         description: "Approve or reject one pending workflow checkpoint or budget decision",
         parameters: Type.Object({ runId: Type.String(), name: Type.Optional(Type.String()), proposalId: Type.Optional(Type.String()), approved: Type.Boolean() }, { additionalProperties: false }),
-        async execute(_id, params) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
                 if (params.proposalId) {
-                    const result = await answerBudgetDecision(params.runId, params.proposalId, params.approved);
+                    const result = await answerBudgetDecision(params.runId, params.proposalId, params.approved, false, ctx, signal);
                     if (!result) {
                         const denied = { state: "budget_exhausted", approved: false, reason: "proposal_not_pending" };
                         return { content: [{ type: "text", text: JSON.stringify(denied) }], details: denied };
@@ -1399,22 +1723,31 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     });
     let catalogRegistered = false;
     let sessionStarted = false;
-    const registerCatalog = () => {
+    const registerCatalog = (cwd, trustedProject) => {
         if (catalogRegistered || !pi.getActiveTools().includes("workflow"))
             return;
-        const catalog = registry.catalog();
-        const hasAliases = Object.keys(catalog.modelAliases ?? {}).length > 0;
-        if (!catalog.functions.length && !catalog.variables.length && !hasAliases)
+        const catalog = registry.catalog({ cwd, projectTrusted: trustedProject, globalSettingsPath: workflowSettingsPath(extensionAgentDir) });
+        const hasAliases = Object.keys(catalog.modelAliases ?? {}).length > 0 || Boolean(catalog.modelAliasEntries?.length);
+        const hasSettings = catalog.settings !== undefined && [catalog.settings.globalSettingsPath, catalog.settings.projectSettingsPath].some((path) => existsSync(path));
+        if (!catalog.functions.length && !catalog.variables.length && !hasAliases && !hasSettings)
             return;
         pi.registerTool({
             name: "workflow_catalog",
             label: "Workflow Catalog",
             description: "List reusable workflow functions, variables, and model aliases, or load one entry in full",
-            parameters: Type.Object({ name: Type.Optional(Type.String({ description: "Registered function or variable name for full detail" })) }, { additionalProperties: false }),
+            parameters: Type.Object({ name: Type.Optional(Type.String({ description: "Registered function, variable, or model alias name for full detail" })) }, { additionalProperties: false }),
             async execute(_id, params = {}) {
-                const result = params.name === undefined ? registry.catalogIndex() : registry.catalogDetail(params.name);
+                const context = { cwd, projectTrusted: trustedProject, globalSettingsPath: workflowSettingsPath(extensionAgentDir) };
+                const result = params.name === undefined ? registry.catalogIndex(context) : registry.catalogDetail(params.name, context);
                 return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
-            }
+            },
+            renderCall(args, theme) {
+                const title = theme.fg("toolTitle", theme.bold("workflow_catalog"));
+                return styledTextBlock(args.name === undefined ? title : `${title} ${theme.fg("accent", args.name)}`);
+            },
+            renderResult(result, options, theme) {
+                return workflowCatalogBlock(formatWorkflowCatalog(catalogResultValue(result), options.expanded, theme), options.expanded);
+            },
         });
         catalogRegistered = true;
     };
@@ -1425,20 +1758,23 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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(), 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)
@@ -1462,28 +1798,35 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         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(), 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;
@@ -1562,7 +1905,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         run.completion = completion;
         void completion;
     };
-    const applyBudgetDecision = async (request, approved) => {
+    const applyBudgetDecision = async (request, approved, context, signal) => {
         const run = runs.get(request.runId);
         if (!run)
             throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${request.runId}`);
@@ -1576,10 +1919,10 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             next.budget = nextBudget;
         else
             delete next.budget; return next; });
-        await coldResumeRun(run, false, {}, true);
+        await coldResumeRun(run, false, {}, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) });
         return { state: "running", approved: true };
     };
-    const resumeWorkflowRun = async (runId, rawPatch) => {
+    const resumeWorkflowRun = async (runId, rawPatch, context, signal) => {
         const run = runs.get(runId);
         if (!run)
             throw new WorkflowError("RESUME_INCOMPATIBLE", `Unknown workflow run: ${runId}`);
@@ -1610,11 +1953,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             else
                 delete next.budget; return next; });
         }
-        await coldResumeRun(run, false, {}, true);
+        await coldResumeRun(run, false, {}, projectTrusted(context), { ...resumeHostContext(context), ...(signal ? { signal } : {}) });
         return { state: "running" };
     };
     const retryReservations = new Set();
-    const retryWorkflowRun = async (runId, context) => {
+    const retryWorkflowRun = async (runId, context, signal) => {
         if (typeof runId !== "string" || !runId.trim())
             throw new WorkflowError("RESUME_INCOMPATIBLE", "workflow_retry requires an explicit run ID");
         const host = object(context) ? context : {};
@@ -1674,19 +2017,23 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             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 = { 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);
@@ -1696,7 +2043,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const budget = validateBudget(loaded.run.budget ?? loaded.snapshot.budget);
             const childRunId = randomUUID();
             const childStore = new RunStore(cwd, sessionId, childRunId, home);
-            const childSnapshot = createLaunchSnapshot(loaded.snapshot);
+            const 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 = { sourceRunId: loaded.run.id, lineageRootRunId, completedPaths, incompletePaths, namedWorktrees };
@@ -1705,13 +2053,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const model = modelSpec(loaded.snapshot.models[0] ?? "", fallbackModel);
             const lifecycle = lifecycleFor(childStore, "interrupted", childBudget, loaded.snapshot.metadata);
             const abortController = new AbortController();
-            const providerErrorRecovery = createProviderErrorRecovery(context, resumeModels, () => { abortController.abort(); });
+            const providerErrorRecovery = createProviderErrorRecovery(context, availableModels, () => { abortController.abort(); });
             const providerPause = async () => { deliver(pi, `Workflow ${loaded.snapshot.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
-            const childRun = { executor: new WorkflowAgentExecutor({ cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => active.has(tool) || tool === "workflow_catalog")), availableModels: resumeModels, knownModels: resumeModels, modelAliases: currentAliases, settingsPath, agentDefinitions: loaded.snapshot.roles ?? {}, runStore: childStore, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: () => resolveAgentResourcePolicy(cwd, projectTrusted(context), settingsPath) }, createSession), store: childStore, metadata: loaded.snapshot.metadata, model, lifecycle, budget: childBudget, abortController, projectTrusted: () => projectTrusted(context), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) };
+            const childRun = { executor: 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;
@@ -1729,9 +2077,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         label: "Workflow Retry",
         description: "Retry a failed workflow run by replaying its completed structural operations",
         parameters: WORKFLOW_RETRY_PARAMETERS,
-        async execute(_id, params, _signal, _onUpdate, ctx) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
-                const result = await retryWorkflowRun(params.runId, ctx);
+                const result = await retryWorkflowRun(params.runId, ctx, signal);
                 return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
             }
             catch (error) {
@@ -1744,9 +2092,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         label: "Workflow Resume",
         description: "Resume an exhausted workflow with unchanged or patched aggregate budgets",
         parameters: Type.Object({ runId: Type.String(), budget: Type.Optional(Type.Unknown()) }, { additionalProperties: false }),
-        async execute(_id, params) {
+        async execute(_id, params, signal, _onUpdate, ctx) {
             try {
-                const result = await resumeWorkflowRun(params.runId, params.budget);
+                const result = await resumeWorkflowRun(params.runId, params.budget, ctx, signal);
                 return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
             }
             catch (error) {
@@ -1759,7 +2107,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             return;
         sessionStarted = true;
         registry.freeze();
-        registerCatalog();
+        registerCatalog(ctx.cwd, projectTrusted(ctx));
         await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
         try {
             for (const runId of await listRunIds(ctx.cwd, ctx.sessionManager.getSessionId(), home)) {
@@ -1795,7 +2143,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const roleDefinitions = loaded.snapshot.roles ?? {};
                 const abortController = new AbortController();
                 const providerErrorRecovery = createProviderErrorRecovery(ctx, new Set(loaded.snapshot.models), () => { abortController.abort(); });
-                runs.set(runId, { executor: new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model, tools: new Set(loaded.snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels: new Set(loaded.snapshot.models), knownModels: new Set(loaded.snapshot.models), ...(loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ? { modelAliases: loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases } : {}), ...(loaded.snapshot.settingsPath ? { settingsPath: loaded.snapshot.settingsPath } : {}), agentDefinitions: roleDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: () => resolveAgentResourcePolicy(store.cwd, projectTrusted(ctx), loaded.snapshot.settingsPath ?? workflowSettingsPath(extensionAgentDir)) }, createSession), store, metadata: loaded.snapshot.metadata, model, lifecycle, budget: budgetRuntime, abortController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) });
+                runs.set(runId, { executor: 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())
@@ -1832,7 +2180,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     pi.on("before_agent_start", (event, ctx) => {
         if (!pi.getActiveTools().includes("workflow"))
             return;
-        const roles = Object.entries(loadAgentDefinitions(ctx.cwd, extensionAgentDir, projectTrusted(ctx))).filter(([, definition]) => definition.description);
+        const roles = Object.entries(loadAgentDefinitions(ctx.cwd, extensionAgentDir, projectTrusted(ctx), typeof registry.roleDirectoryRegistrations === "function" ? registry.roleDirectoryRegistrations() : undefined)).filter(([, definition]) => definition.description);
         if (!roles.length)
             return;
         const content = `Workflow role descriptions:\n${roles.map(([name, definition]) => `- \`${name}\`: ${String(definition.description)}`).join("\n")}`;
@@ -1848,32 +2196,33 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             try {
                 const headless = object(ctx) && ctx.headless === true;
                 const settingsPath = workflowSettingsPath(extensionAgentDir);
-                const defaults = loadSettings(settingsPath);
                 if (!ctx.model)
                     throw new WorkflowError("UNKNOWN_MODEL", "A launching model is required");
-                const settings = Object.freeze({ concurrency: params.concurrency ?? defaults.concurrency, ...(defaults.modelAliases ? { modelAliases: defaults.modelAliases } : {}) });
                 const budget = validateBudget(params.budget);
                 const rootModel = { provider: ctx.model.provider, model: ctx.model.id, thinking: pi.getThinkingLevel() };
                 const rootModelName = `${rootModel.provider}/${rootModel.model}`;
                 const modelRegistry = contextHostCapabilities(ctx).modelRegistry;
-                const knownModels = new Set((modelRegistry?.getAll?.() ?? modelRegistry?.getAvailable?.() ?? [ctx.model]).map((model) => `${model.provider}/${model.id}`));
-                knownModels.add(rootModelName);
-                const availableModels = knownModels;
+                const 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 { script, checked, agentDefinitions, projectAgentDefinitions, roleNames, functionName } = validated;
-                await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
-                const runId = randomUUID();
-                const args = (params.args ?? null);
-                encoded(args);
+                const launchCwd = typeof ctx.cwd === "string" ? ctx.cwd : process.cwd();
+                const launch = workflowLaunchSettings(launchCwd, trustedProject, settingsPath, params.concurrency);
                 const runController = new AbortController();
                 if (signal?.aborted)
                     runController.abort();
                 else
                     signal?.addEventListener("abort", () => { runController.abort(); }, { once: true });
+                const resolvedAliases = await resolveLaunchAliases(registry, launch.settings.modelAliases ?? {}, { cwd: launchCwd, projectTrusted: trustedProject, rootModel, knownModels, availableModels, signal: runController.signal }, availableModels, knownModels, settingsPath);
+                const modelAliases = resolvedAliases.aliases;
+                const settings = Object.freeze({ ...launch.settings, ...(Object.keys(modelAliases).length ? { modelAliases } : {}) });
+                const validated = validateWorkflowLaunchWithRegistry({ ...params, args: params.args }, { cwd: ctx.cwd, agentDir: extensionAgentDir, projectTrusted: trustedProject, availableModels, rootTools: new Set(rootTools), modelAliases, knownModels, settingsPath }, registry);
+                const { script, checked, agentDefinitions, projectAgentDefinitions, roleNames, functionName } = validated;
+                await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
+                const runId = randomUUID();
+                const args = (params.args ?? null);
+                encoded(args);
                 const runContext = workflowRunContext(ctx.cwd, ctx.sessionManager.getSessionId(), runId, checked.metadata, args, runController.signal);
                 const variables = await resolveWorkflowVariables(runContext, runController, registry);
                 const store = new RunStore(ctx.cwd, ctx.sessionManager.getSessionId(), runId, home);
@@ -1882,9 +2231,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     await store.validateParentRun(parentRunId);
                 const roles = Object.fromEntries(roleNames.map((role) => [role, agentDefinitions[role]]));
                 const projectRoles = roleNames.filter((role) => projectAgentDefinitions[role] !== undefined);
-                const roleModels = roleNames.flatMap((role) => { const model = agentDefinitions[role]?.model; return model ? [modelCapability(model, defaults.modelAliases, knownModels, settingsPath)] : []; });
+                const roleModels = roleNames.flatMap((role) => { const model = agentDefinitions[role]?.model; return model ? [modelCapability(model, modelAliases, knownModels, settingsPath)] : []; });
                 const snapshotModels = [...new Set([rootModelName, ...checked.referenced.models, ...roleModels])];
-                const snapshot = createLaunchSnapshot({ script, args, metadata: checked.metadata, settings, settingsPath, ...(functionName ? { launchKind: "function", functionName } : {}), ...(defaults.modelAliases ? { modelAliases: defaults.modelAliases } : {}), ...(budget ? { budget } : {}), models: snapshotModels, tools: rootTools, agentTypes: checked.referenced.agentTypes, roles, projectRoles, schemas: checked.schemas });
+                const snapshot = createLaunchSnapshot({ script, args, metadata: checked.metadata, settings, settingsPath, settingsSources: { ...launch.resolution.sources, concurrency: params.concurrency === undefined ? launch.resolution.sources.concurrency : "per-run options" }, ...(functionName ? { launchKind: "function", functionName } : {}), ...(Object.keys(modelAliases).length ? { modelAliases } : {}), ...(budget ? { budget } : {}), ...(checked.referenced.phases.length ? { phases: checked.referenced.phases } : {}), models: snapshotModels, tools: rootTools, agentTypes: checked.referenced.agentTypes, roles, projectRoles, schemas: checked.schemas });
                 const budgetRuntime = new WorkflowBudgetRuntime(budget);
                 const initialBudget = budgetRuntime.snapshot();
                 await store.create({ id: runId, workflowName: checked.metadata.name, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), state: "running", ...(parentRunId !== undefined ? { parentRunId } : {}), agents: [], nativeSessions: [], ...(budget ? { budget } : {}), budgetVersion: 1, ...initialBudget }, snapshot);
@@ -1893,7 +2242,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const providerPause = async () => { if (background)
                     deliver(pi, `Workflow ${checked.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
                 const providerErrorRecovery = createProviderErrorRecovery(ctx, availableModels, () => { runController.abort(); });
-                const executor = new WorkflowAgentExecutor({ cwd: ctx.cwd, agentDir: extensionAgentDir, model: rootModel, tools: new Set(rootTools), availableModels, knownModels, modelAliases: defaults.modelAliases ?? {}, settingsPath, agentDefinitions, runStore: store, providerPause, agentSetupHooks: registry.agentSetupHooks(), agentResourcePolicy: () => resolveAgentResourcePolicy(ctx.cwd, projectTrusted(ctx), settingsPath), runContext }, createSession);
+                const executor = 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));
@@ -2027,7 +2376,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 return entries.filter((entry) => entry !== undefined);
             };
             let stores = await loadStores();
-            const usage = "Usage: /workflow [doctor|model-aliases], or /workflow pause|resume|stop|approve|reject|delete <run-id> [checkpoint or proposal-id]. Use workflow_resume for budget patches.";
+            const usage = "Usage: /workflow [doctor|model-aliases], or /workflow pause|resume|stop|approve|reject|delete <run-id> [checkpoint-name]. Approve/reject are for checkpoints only; use workflow_respond with a proposalId or the navigator's budget controls for budget decisions. Use workflow_resume for budget patches.";
             const setWorkflowStatus = (text) => {
                 const setStatus = uiHostCapabilities(ctx.ui)?.setStatus;
                 setStatus?.call(ctx.ui, "workflow-stop", text);
@@ -2044,7 +2393,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         return keepContext ? "dashboard" : "done";
                     }
                     if ((action === "budget-approve" || action === "budget-reject") && runId && rest[0]) {
-                        const result = await answerBudgetDecision(runId, rest[0], action === "budget-approve", true);
+                        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";
                     }
@@ -2069,7 +2418,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     if (action === "resume" && run) {
                         if (run.lifecycle.state === "budget_exhausted") {
                             const patch = rest.length ? JSON.parse(rest.join(" ")) : undefined;
-                            const result = await resumeWorkflowRun(run.store.runId, patch);
+                            const result = await resumeWorkflowRun(run.store.runId, patch, ctx);
                             ctx.ui.notify(result.state === "running" ? `Resumed workflow ${run.store.runId}.` : `Budget adjustment for ${run.store.runId} is awaiting approval.`, result.state === "running" ? "info" : "warning");
                         }
                         else {
@@ -2077,7 +2426,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 await coldResumeRun(run, ctx.hasUI, ctx.ui, projectTrusted(ctx), ctx);
                             else {
                                 if (run.lifecycle.state === "paused")
-                                    await refreshPausedRunAliases(run, ctx);
+                                    await refreshPausedRunAliases(run, { ...resumeHostContext(ctx), projectTrusted: projectTrusted(ctx) });
                                 await run.lifecycle.resume();
                             }
                             ctx.ui.notify(`Resumed workflow ${run.store.runId}.`, "info");
@@ -2088,7 +2437,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         const input = await uiHostCapabilities(ctx.ui)?.input?.call(ctx.ui, "Budget patch (JSON)", "{\"tokens\":{\"hard\":null}}");
                         if (input === undefined)
                             return keepContext ? "dashboard" : "done";
-                        const result = await resumeWorkflowRun(run.store.runId, JSON.parse(input));
+                        const result = await resumeWorkflowRun(run.store.runId, JSON.parse(input), ctx);
                         ctx.ui.notify(result.state === "running" ? `Resumed workflow ${run.store.runId}.` : `Budget adjustment for ${run.store.runId} is awaiting approval.`, result.state === "running" ? "info" : "warning");
                         return keepContext ? "dashboard" : "done";
                     }
@@ -2123,6 +2472,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             };
             const manageAliases = async () => {
                 const settingsPath = workflowSettingsPath(extensionAgentDir);
+                let aliasSettingsPath = settingsPath;
+                const trustedProject = projectTrusted(ctx);
                 const modelRegistry = contextHostCapabilities(ctx).modelRegistry;
                 const available = () => [...new Set((modelRegistry?.getAvailable?.() ?? []).map((model) => `${model.provider}/${model.id}`))].sort();
                 const selectTarget = async (aliases) => {
@@ -2136,22 +2487,24 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 };
                 const save = (aliases) => {
                     try {
-                        saveModelAliases(settingsPath, aliases);
-                        ctx.ui.notify(`Saved model aliases to ${settingsPath}.`, "info");
+                        saveModelAliases(aliasSettingsPath, aliases);
+                        ctx.ui.notify(`Saved model aliases to ${aliasSettingsPath}.`, "info");
                         return true;
                     }
                     catch (error) {
-                        ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                        ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
                         return false;
                     }
                 };
                 for (;;) {
                     let aliases;
                     try {
-                        aliases = loadSettings(settingsPath).modelAliases ?? {};
+                        const resolution = resolveWorkflowSettings(ctx.cwd, trustedProject, settingsPath);
+                        aliases = resolution.effective.modelAliases ?? {};
+                        aliasSettingsPath = resolution.sources.modelAliases;
                     }
                     catch (error) {
-                        ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                        ctx.ui.notify(`${trustedProject ? workflowProjectSettingsPath(ctx.cwd) : settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
                         return;
                     }
                     const names = Object.keys(aliases).sort();
@@ -2173,13 +2526,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             continue;
                         const next = { ...aliases, [name]: target };
                         try {
-                            validateModelAliases(next, settingsPath);
+                            validateModelAliases(next, aliasSettingsPath);
                         }
                         catch (error) {
-                            ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                            ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
                             continue;
                         }
-                        const parsed = resolveModelReference(target, next, new Set(available()), settingsPath);
+                        const parsed = resolveModelReference(target, next, new Set(available()), aliasSettingsPath);
                         if (!available().includes(`${parsed.provider}/${parsed.model}`)) {
                             ctx.ui.notify(`Warning: ${target} is not currently available in Pi.`, "warning");
                             if (!await ctx.ui.confirm("Save unknown model?", "Save this target for cross-machine portability?"))
@@ -2195,13 +2548,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             continue;
                         const next = { ...aliases, [edit[1]]: target };
                         try {
-                            validateModelAliases(next, settingsPath);
+                            validateModelAliases(next, aliasSettingsPath);
                         }
                         catch (error) {
-                            ctx.ui.notify(`${settingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                            ctx.ui.notify(`${aliasSettingsPath}: ${error instanceof Error ? error.message : String(error)}`, "error");
                             continue;
                         }
-                        const parsed = resolveModelReference(target, next, new Set(available()), settingsPath);
+                        const parsed = resolveModelReference(target, next, new Set(available()), aliasSettingsPath);
                         if (!available().includes(`${parsed.provider}/${parsed.model}`)) {
                             ctx.ui.notify(`Warning: ${target} is not currently available in Pi.`, "warning");
                             if (!await ctx.ui.confirm("Save unknown model?", "Save this target for cross-machine portability?"))
@@ -2240,7 +2593,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     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;
@@ -2273,6 +2627,20 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         stores = await loadStores();
                         continue;
                     }
+                    if (runChoice === "Delete all failed") {
+                        if (!await ctx.ui.confirm("Delete failed runs?", "Delete all failed workflow runs and their artifacts? This cannot be undone."))
+                            continue;
+                        for (const entry of sorted) {
+                            if (entry.loaded.run.state === "failed") {
+                                await entry.store.delete(true);
+                                runs.delete(entry.store.runId);
+                                terminalRunStates.delete(entry.store.runId);
+                            }
+                        }
+                        ctx.ui.notify("Deleted all failed workflow runs.", "info");
+                        stores = await loadStores();
+                        continue;
+                    }
                     const runIndex = labels.indexOf(runChoice);
                     if (runIndex < 0)
                         return;
@@ -2336,20 +2704,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                             addCopy("Copy run path", store.directory, "run path");
                             addCopy("Copy run ID", store.runId, "run ID");
                         }
-                        return { dashboard: formatNavigatorDashboard(loaded.run, checkpoints, worktrees), actions, copies, reviews, script: loaded.snapshot.script, agents: loaded.run.agents, worktrees, cwd: loaded.run.cwd };
+                        return { dashboard: formatWorkflowPhaseDashboard(loaded.run, loaded.snapshot, process.stdout.columns || 80).join("\n"), phaseModel: buildWorkflowPhaseModel(loaded.run, loaded.snapshot), run: loaded.run, snapshot: loaded.snapshot, actions, copies, reviews, script: loaded.snapshot.script, agents: loaded.run.agents, worktrees, cwd: loaded.run.cwd };
                     };
                     const selectAgent = async (dashboard) => {
                         const byId = new Map(dashboard.agents.map((agent) => [agent.id, agent]));
-                        const title = (agent) => {
-                            const parents = [];
-                            for (let parentId = agent.parentId; parentId; parentId = byId.get(parentId)?.parentId) {
-                                const parent = byId.get(parentId);
-                                if (!parent)
-                                    break;
-                                parents.unshift(parent.label ?? parent.name);
-                            }
-                            return [...((agent.structuralPath ?? []).length ? [(agent.structuralPath ?? []).join(" > ")] : []), ...(agent.parentBreadcrumb ? [agent.parentBreadcrumb] : []), ...parents, agent.label ?? agent.name].join(" > ");
-                        };
+                        const title = (agent) => agentBreadcrumb(agent, byId, true);
                         const labels = dashboard.agents.map((agent, index) => `#${String(index + 1)} ${title(agent)} [${agent.state}]`);
                         const selectedLabel = await ctx.ui.select("Agents", [...labels, "Back"]);
                         const selectedIndex = selectedLabel ? labels.indexOf(selectedLabel) : -1;
@@ -2414,8 +2773,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 let disposed = false;
                                 let stopRequested = false;
                                 let stopStatus;
+                                const initialSelection = preserveWorkflowPhaseSelection(view.phaseModel, {});
+                                let selectedPhaseId = initialSelection.phaseId;
+                                let selectedAgentId = initialSelection.agentId;
                                 const terminalRows = () => Math.max(1, tuiRows(tui) - WORKFLOW_OVERLAY_BORDER_ROWS);
-                                const keyLabels = { up: "↑", down: "↓", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
+                                const keyLabels = { up: "↑", down: "↓", left: "←", right: "→", tab: "tab", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
                                 const keyLabel = (binding, fallback) => {
                                     const keys = keybindingKeys(keybindings, binding);
                                     return keys?.length ? keys.map((key) => keyLabels[key] ?? key).join("/") : fallback;
@@ -2429,12 +2791,17 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     return { rows, hintRows, separatorRows, actionViewport, dashboardViewport: available - actionViewport };
                                 };
                                 const updateDashboard = async (selectedOption) => {
+                                    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 = () => {
@@ -2470,11 +2837,12 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 timer.unref();
                                 return borderWorkflowOverlay({
                                     render(width) {
-                                        const dashboard = stopStatus ? `${view.dashboard}\n\n${stopStatus}` : view.dashboard;
-                                        const dashboardLines = truncateToVisualLines(theme.fg("accent", dashboard), Number.MAX_SAFE_INTEGER, width, 1).visualLines;
+                                        const 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;
@@ -2494,7 +2862,27 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                     handleInput(data) {
                                         if (stopRequested)
                                             return;
-                                        if (keybindings.matches(data, "tui.select.up"))
+                                        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;