@marcoscale98/pi-extensible-workflows 5.17.0-fork.1 → 6.2.1-fork.1

package/dist/src/host.js

@@ -12,19 +12,19 @@ import { registerWorkflowNavigator, uiHostCapabilities } from "./host-navigator.
 import { acquireSessionLease, isPersistedRun, listPersistedSessionIds, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
 import { retainTerminalRuns } from "./retention.js";
 import { validateBudget, WorkflowBudgetRuntime } from "./budget.js";
-import { SerialLane, asWorkflowError, createLaunchSnapshot, errorCode, errorText, fail, isNodeError, jsonValue, mergeWorkflowExtensionSettings, modelAliasErrorName, modelCapability, object, parseModelReference, positiveInteger, sanitizeDisplayText, validateModelAliases } from "./utils.js";
-import { loadSettings, preflight, resolveAgentResourcePolicy, resolveWorkflowSettings, validateCheckpoint, validateModelAliasAvailability, validateWorkflowLaunchWithRegistry, workflowProjectSettingsPath, workflowSettingsPath } from "./validation.js";
-import { loadAgentDefinitions, loadProjectAgentDefinitions } from "./roles.js";
+import { SerialLane, asWorkflowError, createLaunchSnapshot, errorCode, errorText, fail, isNodeError, jsonValue, modelAliasErrorName, object, parseModelReference, positiveInteger, reachableTools, resolveModelReference, VIRTUAL_MODEL_PROVIDER, sanitizeDisplayText, validateModelAliases } from "./utils.js";
+import { loadCodemodeToolsSetting, preflight, resolveAgentResourcePolicy, staticAgentPreparationOptions, resolveWorkflowSettings, validateCheckpoint, validateModelAliasAvailability, validateWorkflowLaunchWithRegistry, workflowProjectSettingsPath, workflowSettingsPath, workflowToolExposure } from "./validation.js";
 import { beginWorkflowExtensionLoading, loadingRegistry, resetWorkflowRegistryIfIdle, retainWorkflowRegistry } from "./registry.js";
-import { agentHandleTurnPath, agentIdentityPath, agentWorktree, encoded, executeShellCommand, persistActiveAgentAttempt, persistAgentAttempts, readShellResult, runWorkflow, shellIdentityPath } from "./execution.js";
+import { agentHandleTurnPath, agentIdentityPath, agentWorktree, encoded, executeShellCommand, persistActiveAgentAttempt, persistAgentAttempts, readShellResult, runWorkflow, shellIdentityPath, toolIdentityPath } from "./execution.js";
+import { prepareScriptToolLoadout, scriptTool, scriptToolContext, scriptToolValue, validateScriptToolReferences } from "./script-tools.js";
 import backgroundWidget from "./background-widget.js";
 import { showChangelogNotice } from "./changelog.js";
 import { createTrajectoryRunLoader, createTrajectoryRunMetadataLoader, createTrajectorySubagentLoader, createTrajectorySubagentMetadataLoader, createTrajectoryTranscriptLoader } from "./trajectory.js";
 import { getTrajectoryHost } from "./trajectory-host-handle.js";
 import { getSubagentManager } from "./subagent-manager-handle.js";
-import { HARD_TERMINAL_RUN_STATES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, WORKFLOW_BLOCKED_EVENT, WorkflowError, isContextFileScope, isExternallyEndedRunState, isHardTerminalRunState, roleNameOf } from "./types.js";
-import { SETTLED_AGENT_STATES, catalogResultValue, formatWorkflowCatalog, styledTextBlock, textBlock, workflowCatalogBlock, workflowControlCall, workflowControlResult, workflowProgressBlock, } from "./host-view.js";
-import { DELIVERY_LIMIT_BYTES, ForegroundDeliveryController, markWorkflowFailureDiagnostics, WORKFLOW_LOG_ENTRY, completionDescriptor, completionDeliveryFromStore, createWorkflowFailureDiagnostics, failureDiagnosticsFrom, formatWorkflowFailure, formatWorkflowFailureDelivery, formatWorkflowFailureDeliveryFallback, formatWorkflowFailureDiagnostics, isWorkflowFailureDiagnostics, serializeWorkflowFailureDiagnostics, utf8Prefix, } from "./host-delivery.js";
+import { HARD_TERMINAL_RUN_STATES, LAUNCH_SNAPSHOT_IDENTITY_VERSION, THINKING_LEVELS, WORKFLOW_BLOCKED_EVENT, WorkflowError, isContextFileScope, isExternallyEndedRunState, isHardTerminalRunState } from "./types.js";
+import { SETTLED_AGENT_STATES, catalogResultValue, formatWorkflowCatalog, styledTextBlock, textBlock, workflowCatalogBlock, workflowControlCall, workflowControlResult, workflowProgressBlock } from "./host-view.js";
+import { DELIVERY_LIMIT_BYTES, ForegroundDeliveryController, markWorkflowFailureDiagnostics, WORKFLOW_LOG_ENTRY, completionDescriptor, completionDeliveryFromStore, createWorkflowFailureDiagnostics, failureDiagnosticsFrom, formatWorkflowFailure, formatWorkflowFailureDelivery, formatWorkflowFailureDeliveryFallback, formatWorkflowFailureDiagnostics, isWorkflowFailureDiagnostics, serializeWorkflowFailureDiagnostics, utf8Prefix } from "./host-delivery.js";
 export { agentBreadcrumb, agentBreadcrumbParts, formatBudgetStatus, formatNavigatorDashboard, formatNavigatorRun, formatStalledDuration, formatWorkflowPhaseDashboard, formatWorkflowProgress, navigatorAttentionSort, truncateWorkflowProgress, } from "./host-view.js";
 export { buildWorkflowPhaseModel, buildWorkflowPhaseTree, navigateWorkflowPhaseTree, preserveWorkflowPhaseSelection, preserveWorkflowPhaseTreeSelection, workflowPhaseTreeInitialExpanded, workflowPhaseTreeVisibleNodes } from "./host-phases.js";
 export { formatWorkflowFailure, formatWorkflowFailureDelivery, formatWorkflowFailureDiagnostics } from "./host-delivery.js";
@@ -55,6 +55,13 @@ function mainAgentError(error) {
     Object.assign(presented, typed);
     return presented;
 }
+/** The structured counterpart of {@link completionControlContent}: the result without the persisted run, with the full value. */
+function completionControlValue(result, controlRunId) {
+    const record = { ...(controlRunId === undefined ? {} : { runId: controlRunId }), ...result };
+    delete record.run;
+    delete record.completion;
+    return record;
+}
 function completionControlContent(result, controlRunId) {
     const record = object(result) ? { ...result } : undefined;
     if (record && controlRunId !== undefined && record.runId === undefined)
@@ -76,27 +83,6 @@ function completionControlContent(result, controlRunId) {
     delete record.run;
     return JSON.stringify({ ...record, value });
 }
-/** Persists a role definition (and its model) into the launch snapshot the first time an agent uses it, so later replays and retries see the definition the run actually ran with. */
-function roleCapture(store, initial, definitions, projectDefinitions) {
-    let persisted = initial;
-    return {
-        get snapshot() { return persisted; },
-        async capture(role, model) {
-            const definition = definitions[role];
-            if (!definition)
-                return;
-            const modelName = `${model.provider}/${model.model}`;
-            const hasProjectRole = projectDefinitions[role] !== undefined;
-            if (persisted.roles?.[role] !== undefined && (!hasProjectRole || persisted.projectRoles?.includes(role)) && persisted.models.includes(modelName))
-                return;
-            const roles = { ...(persisted.roles ?? {}), [role]: definition };
-            const projectRoles = hasProjectRole ? [...new Set([...(persisted.projectRoles ?? []), role])] : persisted.projectRoles ?? [];
-            const models = [...new Set([...persisted.models, modelName])];
-            persisted = createLaunchSnapshot({ ...persisted, models, roles, projectRoles });
-            await store.saveSnapshot(persisted);
-        },
-    };
-}
 export function formatWorkflowPreview(args) {
     const name = typeof args.name === "string" && args.name.trim() ? args.name.trim() : "workflow";
     if (typeof args.script !== "string" || !args.script.trim())
@@ -104,7 +90,7 @@ export function formatWorkflowPreview(args) {
     return [`workflow ${name}`, typeof args.description === "string" && args.description.trim() ? args.description.trim() : ""].filter(Boolean).join("\n");
 }
 export const WORKFLOW_TOOL_LABEL = "Workflow";
-export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline or file-backed parallel-to-summary path by default";
+export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline or file-backed parallel-to-summary path by default. Scripts call this session's tools as `await tools.<name>(args)`, outside withWorktree: a tool resolves to its text unless its description gives a `tools.<name>(args)` result shape, and failures reject";
 export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow. Prefer a named inline script that fans out independent work with parallel(...), awaits the keyed results before interpolating them into one summarizing agent(...), and returns. Provide exactly one of script or scriptPath and a non-empty name. Registered catalog functions are available as globals inside the script; call them there, for example return await someFunction(args). Advanced controls include registered functions, outputSchema, budgets, checkpoints, worktrees, retry/resume, CLI export, and pipelines. Runs are in the background by default; completion arrives as a follow-up message. Set foreground: true when the caller must wait for the final value. Manage runs from the interactive /workflow picker; use workflow_status, workflow_resume, workflow_retry, workflow_stop, and workflow_respond for explicit tool controls. If a foreground call detaches before its result is accepted, its terminal success or failure is promoted to one follow-up message. Foreground results include the completed run ID. Recovery inherits the source launch mode; legacy snapshots without launchMode recover in the background. Set foreground: true or false on workflow_resume/workflow_retry to override it; foreground recovery waits for terminal value and run details, while background recovery returns immediately and delivers completion or failure as a follow-up. After failure follow-ups, especially CANCELLED or interrupted runs, call workflow_status({ runId }) before recovery or replacement work, then pass its state as expectedState to workflow_retry/workflow_resume so recovery cannot act on a state that changed. Recovery map: agent(..., { retries }) reruns one agent call in the same run for transient failures; workflow_retry({ runId, expectedState?, foreground? }) replays a failed run into a child; workflow_resume({ runId, expectedState?, budget?, foreground? }) continues a budget_exhausted run; parentRunId on a new launch only borrows named worktrees and never replays or resumes.";
 export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
     name: Type.String({ description: "Required non-empty workflow name" }),
@@ -119,6 +105,21 @@ export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
 }, { additionalProperties: false });
 export const WORKFLOW_STATUS_PARAMETERS = Type.Object({ runId: Type.String({ description: "Workflow run ID visible in the current project" }) }, { additionalProperties: false });
 export const WORKFLOW_RETRY_PARAMETERS = Type.Object({ runId: Type.String({ description: "Explicit failed workflow run ID" }), expectedState: Type.Optional(Type.String({ description: "Persisted source state observed before recovery" })), foreground: Type.Optional(Type.Boolean({ description: "Override the source launch mode for this recovery" })) });
+// Structured results codemode scripts receive instead of the JSON text; nested records stay loose so they cannot drift from persistence.
+const WORKFLOW_ERROR_OUTPUT = Type.Object({ code: Type.String(), message: Type.String() });
+const WORKFLOW_LAUNCH_OUTPUT = Type.Object({ runId: Type.String(), state: Type.String(), detached: Type.Optional(Type.Boolean()), value: Type.Optional(Type.Unknown()) });
+const WORKFLOW_STATUS_OUTPUT = Type.Object({ runId: Type.String(), workflowName: Type.String(), state: Type.String(), error: Type.Optional(WORKFLOW_ERROR_OUTPUT), failedAt: Type.Optional(Type.String()), budget: Type.Optional(Type.Unknown()), usage: Type.Optional(Type.Unknown()), phase: Type.Optional(Type.String()), delivery: Type.Optional(Type.Object({ mode: Type.String(), state: Type.String() })), agents: Type.Array(Type.Object({ id: Type.String(), label: Type.Optional(Type.String()), path: Type.String(), state: Type.String(), lastEventAt: Type.Optional(Type.Number()), accounting: Type.Optional(Type.Unknown()) })) });
+const WORKFLOW_STOP_OUTPUT = Type.Object({ runId: Type.String(), state: Type.String(), stopped: Type.Boolean(), reason: Type.Optional(Type.String()) });
+const WORKFLOW_RECOVERY_OUTPUT = Type.Object({ state: Type.String(), runId: Type.Optional(Type.String()), parentRunId: Type.Optional(Type.String()), proposalId: Type.Optional(Type.String()), value: Type.Optional(Type.Unknown()) });
+const WORKFLOW_RESPOND_OUTPUT = Type.Object({ state: Type.String(), approved: Type.Boolean(), reason: Type.String(), accepted: Type.Optional(Type.Boolean()), runId: Type.Optional(Type.String()), value: Type.Optional(Type.Unknown()) });
+const WORKFLOW_CATALOG_ALIAS_OUTPUT = Type.Object({ name: Type.String(), kind: Type.String(), provenance: Type.String(), version: Type.Optional(Type.String()), headline: Type.Optional(Type.String()) });
+// The index without a name; with one, the function, the model alias, or { error }.
+const WORKFLOW_CATALOG_OUTPUT = Type.Union([
+    Type.Object({ functions: Type.Array(Type.Object({ name: Type.String(), description: Type.String(), input: Type.Unknown() })), modelAliasEntries: Type.Optional(Type.Array(WORKFLOW_CATALOG_ALIAS_OUTPUT)), settings: Type.Optional(Type.Unknown()) }),
+    Type.Object({ name: Type.String(), version: Type.String(), headline: Type.String(), description: Type.String(), input: Type.Unknown(), output: Type.Unknown() }),
+    WORKFLOW_CATALOG_ALIAS_OUTPUT,
+    Type.Object({ error: Type.Object({ code: Type.String(), name: Type.String(), message: Type.String() }) }),
+]);
 function workflowToolUpdate(run) {
     //NOTE: renderers read details.run; the partial text stays O(1) so high-frequency updates never format the whole tree.
     const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
@@ -204,7 +205,45 @@ function modelInventory(root, registry) {
 }
 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, deliveryContext: completionContext(ctx) };
+    return { model, modelRegistry: contextHostCapabilities(ctx).modelRegistry, deliveryContext: completionContext(ctx), toolContext: scriptToolContext(ctx) };
+}
+// State is rewritten on every update, so large shell inputs and errors are kept as prefixes.
+const SCRIPT_CALL_TEXT_LIMIT_BYTES = 16 * 1024;
+function scriptCallInput(input) {
+    const text = JSON.stringify(input);
+    const bytes = Buffer.byteLength(text);
+    return bytes <= SCRIPT_CALL_TEXT_LIMIT_BYTES ? { input } : { input: utf8Prefix(text, SCRIPT_CALL_TEXT_LIMIT_BYTES), inputBytes: bytes };
+}
+/** Records a script call as started, replacing the record of an attempt that an interruption left unfinished. */
+function startScriptCall(run, call) {
+    const recorded = { ...call, ...(run.phase === undefined ? {} : { phase: run.phase }) };
+    const calls = run.scriptCalls ?? [];
+    return { ...run, scriptCalls: calls.some(({ path }) => path === call.path) ? calls.map((current) => current.path === call.path ? recorded : current) : [...calls, recorded] };
+}
+function finishScriptCall(run, path, error) {
+    const finishedAt = Date.now();
+    return { ...run, scriptCalls: (run.scriptCalls ?? []).map((call) => call.path === path ? { ...call, finishedAt, ...(error ? { error: { code: error.code, ...(call.kind === "shell" ? { message: utf8Prefix(error.message, SCRIPT_CALL_TEXT_LIMIT_BYTES) } : {}) } } : {}) } : call) };
+}
+/** Lists workflow model aliases in `/model` as virtual models; needs a Pi host with `registerVirtualModel`. */
+function registerAliasVirtualModels(pi, names, settingsPath) {
+    const register = object(pi) ? asFn(pi.registerVirtualModel) : undefined;
+    if (!register)
+        return;
+    for (const name of names) {
+        const definition = {
+            provider: VIRTUAL_MODEL_PROVIDER, id: name, name: `${name} (workflow alias)`, thinkingLevels: THINKING_LEVELS,
+            route: (request, ctx) => {
+                // Settings are read per request so alias edits apply without a reload.
+                const aliases = resolveWorkflowSettings(ctx.cwd, projectTrusted(ctx), settingsPath).effective.modelAliases ?? {};
+                const target = resolveModelReference(name, aliases, new Set(ctx.modelRegistry.getAll().map((model) => `${model.provider}/${model.id}`)), settingsPath);
+                const model = ctx.modelRegistry.find(target.provider, target.model);
+                if (!model)
+                    throw new WorkflowError("UNKNOWN_MODEL", `Unknown model alias ${name} resolved to ${target.provider}/${target.model}`);
+                return { model, thinkingLevel: request.thinkingLevel };
+            },
+        };
+        Reflect.apply(register, pi, [definition]);
+    }
 }
 async function resolveLaunchAliases(registry, staticAliases, context, availableModels, knownModels, settingsPath) {
     const dynamic = typeof registry.resolveModelAliases === "function" ? await registry.resolveModelAliases(context, new Set(Object.keys(staticAliases))) : {};
@@ -222,6 +261,21 @@ async function resolveLaunchAliases(registry, staticAliases, context, availableM
         throw error;
     }
 }
+/**
+ * Prepares each completely static agent configuration in inspection mode, so preparation plugins resolve their own aliases
+ * and options without persisting a configuration. Any preparation failure rejects launch before effects; cancellation stops
+ * the remaining inspections.
+ */
+async function inspectStaticAgentConfigurations(executor, script, workflowName, signal, functions) {
+    // NOTE: inspection uses the launch cwd; agents inside withWorktree(...) prepare against their checkout at runtime.
+    for (const agentOptions of staticAgentPreparationOptions(script, functions)) {
+        if (signal.aborted)
+            throw new WorkflowError("CANCELLED", "Workflow launch cancelled");
+        await executor.prepare({ label: "agent", workflowName, agentOptions }, undefined, signal, "inspection");
+    }
+    if (signal.aborted)
+        throw new WorkflowError("CANCELLED", "Workflow launch cancelled");
+}
 export default function workflowExtension(pi, home, clipboard = copyToClipboard, transport = localAgentTransport, agentDir, additionalSkillPaths = []) {
     beginWorkflowExtensionLoading();
     const registry = loadingRegistry();
@@ -237,10 +291,14 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
     });
     let backgroundWidgetEnabled = true;
     try {
-        backgroundWidgetEnabled = loadSettings(workflowSettingsPath(extensionAgentDir)).backgroundWidget ?? true;
+        const globalSettings = resolveWorkflowSettings(process.cwd(), false, workflowSettingsPath(extensionAgentDir)).effective;
+        backgroundWidgetEnabled = globalSettings.backgroundWidget ?? true;
+        // Registered at load, before Pi resolves --model and restores the session model. Project aliases need project trust, which is unknown here.
+        registerAliasVirtualModels(pi, Object.keys(globalSettings.modelAliases ?? {}), workflowSettingsPath(extensionAgentDir));
     }
     catch { /* Keep the optional UI enabled; the launch path reports settings errors. */ }
     const backgroundWidgetController = backgroundWidget(pi, backgroundWidgetEnabled);
+    const codemodeTools = loadCodemodeToolsSetting(extensionAgentDir);
     const logBridge = (store, lifecycle, workflowName) => async (message) => {
         const timestamp = Date.now();
         const bounded = utf8Prefix(message, DELIVERY_LIMIT_BYTES);
@@ -273,6 +331,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         return skillPath ? { skillPaths: [skillPath] } : undefined;
     });
     const runs = new Map();
+    // Extension load failures a headless launcher reported for this host. They hold for the whole process, so every executor,
+    // including those that paused resume, cold resume and retry create, keeps failing ownerless options closed.
+    let extensionLoad;
     const deliveryController = new ForegroundDeliveryController({ runs, ...(typeof pi.sendMessage === "function" ? { deliver: (content) => { deliver(pi, content); } } : {}) });
     let releaseWorkflowRegistry;
     const providerRecoveryLane = new SerialLane();
@@ -552,7 +613,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 return readShellResult(replayed.value);
             const shellStartedAt = Date.now();
             let shellPhaseIndex = -1;
-            const started = await persistRunState(store, metadata, (current) => {
+            // Env values stay out of the record: they may carry secrets, and a shared trajectory publishes run state.
+            const call = { kind: "shell", name: "shell", path, ...scriptCallInput({ command, ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }), ...(options.env === undefined ? {} : { env: Object.keys(options.env) }), ...(identity.worktreeOwner ? { worktree: identity.worktreeOwner } : {}) }), startedAt: shellStartedAt };
+            let failure;
+            const started = await persistRunState(store, metadata, (run) => {
+                const current = startScriptCall(run, call);
                 const history = current.phaseHistory ?? [];
                 if (current.phase !== undefined)
                     shellPhaseIndex = current.phaseHistoryIndex ?? (history.length ? history.length - 1 : 0);
@@ -573,8 +638,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 await store.complete(path, result);
                 return result;
             }
+            catch (error) {
+                failure = asWorkflowError(error);
+                throw error;
+            }
             finally {
-                const stopped = await persistRunState(store, metadata, (current) => {
+                const stopped = await persistRunState(store, metadata, (run) => {
+                    const current = finishScriptCall(run, path, failure);
                     const phaseActivities = [...(current.activeShellsByPhase ?? [])];
                     const phaseActivityIndex = phaseActivities.findIndex(({ phaseIndex }) => phaseIndex === shellPhaseIndex);
                     const phaseActivity = phaseActivities[phaseActivityIndex];
@@ -599,6 +669,64 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             await lifecycle.leave();
         }
     };
+    /** A script `tools.<id>(args)` call: replayed from the journal, otherwise run through the session's tool pipeline and journaled. */
+    const toolForRun = async (store, lifecycle, context, identifier, args, signal, identity) => {
+        await lifecycle.enter();
+        try {
+            const path = toolIdentityPath(identifier, args, identity);
+            const replayed = await store.replay(path);
+            if (replayed)
+                return replayed.value;
+            if (!context)
+                fail("UNKNOWN_TOOL", `tools.${identifier} needs a run launched or recovered by a Pi tool call; runs resumed from /workflow or at session start, and headless launches, only replay journaled tool calls`);
+            // Rendering is best-effort: it must never lose or mask a completed call.
+            const render = async () => { try {
+                const update = runs.get(store.runId)?.update;
+                if (update)
+                    update(workflowToolUpdate(withLiveActivities((await store.load()).run)));
+            }
+            catch { /* best-effort progress */ } };
+            // Inspection writes must not prevent execution, mask errors, or reject a journaled success.
+            const record = async (update) => { try {
+                await store.updateState(update);
+            }
+            catch { /* best-effort call metadata */ } };
+            let value;
+            try {
+                const tool = scriptTool(context, identifier);
+                if (!tool)
+                    fail("UNKNOWN_TOOL", `tools.${identifier} is not a tool this session can call`);
+                const cancelled = () => signal.aborted;
+                if (cancelled())
+                    fail("CANCELLED", "Workflow cancelled");
+                await record((run) => startScriptCall(run, { kind: "tool", name: tool.name, path, startedAt: Date.now() }));
+                const finished = liveAgents.toolStarted(store.runId, tool.name);
+                try {
+                    await render();
+                    const outcome = await context.executeTool(tool.name, args, { signal });
+                    if (cancelled())
+                        fail("CANCELLED", "Workflow cancelled");
+                    value = scriptToolValue(tool, outcome);
+                }
+                finally {
+                    finished();
+                }
+            }
+            catch (error) {
+                // A stale context throws plain errors from ctx.tools; report them as tool failures.
+                const failure = error instanceof WorkflowError ? error : new WorkflowError("TOOL_FAILED", `tools.${identifier}: ${errorText(error)}`);
+                await record((run) => finishScriptCall(run, path, failure));
+                throw failure;
+            }
+            await store.complete(path, value);
+            await record((run) => finishScriptCall(run, path));
+            await render();
+            return value;
+        }
+        finally {
+            await lifecycle.leave();
+        }
+    };
     const lifecycleFor = (store, state, metadata) => new RunLifecycle(state, async (next, previous, reason) => {
         const run = runs.get(store.runId);
         if (!run)
@@ -685,7 +813,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const persisted = await persistRunState(run.store, run.metadata, (current) => ({ ...current, ...run.budget.snapshot(), agents: current.agents.map((agent) => agent.id === id ? { ...agent, lastEventAt } : agent) }));
                 run.update?.(workflowToolUpdate(withLiveActivities(persisted)));
             };
-            const result = await run.executor.execute(prompt, { label: options.label, workflowName: run.metadata.name, tuiIndex, tuiLabel: options.requestedLabel ?? options.label, agentNodeId: id, ...(options.extensionSettings === undefined ? {} : { inheritedExtensionSettings: options.extensionSettings }), onProgress, onAttempt, budget, ...(run.providerErrorRecovery ? { providerErrorRecovery: run.providerErrorRecovery } : {}), ...(parentId ? { parent: parentId, cwd: options.cwd, ...(options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}) } : options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}), ...(options.model ? { model: options.model } : {}), ...(options.role ? { role: options.role } : {}), ...(options.contextFiles ? { contextFiles: options.contextFiles } : {}), tools: options.tools, ...(options.skills ? { skills: options.skills } : {}), ...(options.extensions ? { extensions: options.extensions } : {}), effectiveTools: options.tools, ...(options.schema ? { schema: options.schema } : {}), ...(options.retries === undefined ? {} : { retries: options.retries }), ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }), ...(options.sessionPath ? { sessionPath: options.sessionPath } : {}), ...(options.agentOptions ? { agentOptions: options.agentOptions } : {}), ...(options.agentIdentity ? { agentIdentity: options.agentIdentity } : {}) }, signal, scheduler.toolsFor(id, (role, tools, model, inheritedTools, skills, extensions) => run.executor.resolve({ label: "child", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(role ? { role } : {}), ...(tools !== undefined ? { tools } : {}), ...(skills !== undefined ? { skills } : {}), ...(extensions !== undefined ? { extensions } : {}) }, inheritedTools).tools), setSteer, () => { scheduler.cancelChildren(id); scheduler.retry(id); });
+            const result = await run.executor.execute(prompt, { label: options.label, workflowName: run.metadata.name, tuiIndex, tuiLabel: options.requestedLabel ?? options.label, agentNodeId: id, ...(options.extensionSettings === undefined ? {} : { inheritedExtensionSettings: options.extensionSettings }), onProgress, onAttempt, budget, ...(run.providerErrorRecovery ? { providerErrorRecovery: run.providerErrorRecovery } : {}), ...(parentId ? { parent: parentId, cwd: options.cwd, ...(options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}) } : options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}), ...(options.model ? { model: options.model } : {}), ...(options.contextFiles ? { contextFiles: options.contextFiles } : {}), tools: options.tools, ...(options.skills ? { skills: options.skills } : {}), ...(options.extensions ? { extensions: options.extensions } : {}), effectiveTools: options.tools, ...(options.schema ? { schema: options.schema } : {}), ...(options.retries === undefined ? {} : { retries: options.retries }), ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }), ...(options.sessionPath ? { sessionPath: options.sessionPath } : {}), ...(options.agentOptions ? { agentOptions: options.agentOptions } : {}), ...(options.agentIdentity ? { agentIdentity: options.agentIdentity } : {}), ...(options.configuration ? { configuration: options.configuration } : {}), ...(options.capabilities ? { capabilities: options.capabilities } : {}), ...(options.projectTrusted === undefined ? {} : { projectTrusted: options.projectTrusted }), ...(options.inheritedExcludeTools ? { inheritedExcludeTools: options.inheritedExcludeTools } : {}), onConfiguration: (configuration) => scheduler.setConfiguration(id, configuration) }, signal, scheduler.toolsFor(id), setSteer, () => { scheduler.cancelChildren(id); scheduler.retry(id); });
             cancelDeferredProgress();
             const before = (await run.store.load()).run;
             await persistAgentAttempts(run.store, id, result.attempts);
@@ -723,7 +851,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const existing = new Map(current.agents.map((agent) => [agent.id, agent]));
             const agents = ownership.map((node) => {
                 const previous = existing.get(node.id);
-                const requested = { label: node.options.label, workflowName: run.metadata.name, ...(node.options.skills ? { skills: node.options.skills } : {}), ...(node.options.extensions ? { extensions: node.options.extensions } : {}), ...(node.options.model ? { model: node.options.model } : {}), ...(node.options.role ? { role: node.options.role } : {}), ...(node.options.contextFiles ? { contextFiles: node.options.contextFiles } : {}) };
+                const requested = { label: node.options.label, workflowName: run.metadata.name, ...(node.options.skills ? { skills: node.options.skills } : {}), ...(node.options.extensions ? { extensions: node.options.extensions } : {}), ...(node.options.model ? { model: node.options.model } : {}), ...(node.options.contextFiles ? { contextFiles: node.options.contextFiles } : {}), ...(node.options.configuration ? { configuration: node.options.configuration } : {}) };
                 let effective;
                 try {
                     effective = { ...run.executor.resolve({ ...requested, effectiveTools: node.options.tools }), tools: node.options.tools };
@@ -732,12 +860,11 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     effective = previous ? { model: previous.model, ...(previous.requestedModel ? { requestedModel: previous.requestedModel } : {}), tools: previous.tools } : { model: node.options.model ? modelSpec(node.options.model, run.model) : run.model, ...(node.options.model ? { requestedModel: node.options.model } : {}), tools: node.options.tools };
                 }
                 const resultPath = !node.parentId && node.options.agentIdentity ? agentIdentityPath(node.options.agentIdentity) : undefined;
-                const nodeRole = roleNameOf(node.options.role);
                 const now = Date.now();
                 const lastEventAt = node.state === "running" ? previous?.state === "running" && previous.lastEventAt !== undefined ? previous.lastEventAt : now : previous?.lastEventAt;
                 const startedAt = previous?.startedAt ?? (node.state === "running" ? now : undefined);
                 const durationMs = previous?.durationMs ?? (SETTLED_AGENT_STATES.has(node.state) && startedAt !== undefined ? Math.max(0, now - startedAt) : undefined);
-                return { ...(previous?.systemPrompt === undefined ? {} : { systemPrompt: previous.systemPrompt }), ...(node.prompt !== undefined ? { prompt: node.prompt } : previous?.prompt !== undefined ? { prompt: previous.prompt } : {}), id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), structuralPath: [...(node.options.agentIdentity?.structuralPath ?? [])], ...(resultPath ? { resultPath } : {}), ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.worktreeOwner ? { worktreeOwner: node.options.worktreeOwner } : {}), ...(node.options.agentIdentity?.handle === undefined ? {} : { handle: node.options.agentIdentity.handle, ...(node.options.agentIdentity.turn === undefined ? {} : { turn: node.options.agentIdentity.turn }), ...(node.options.continuity ? { continuity: node.options.continuity } : {}) }), ...(nodeRole ? { role: nodeRole } : {}), ...(effective.requestedModel ? { requestedModel: effective.requestedModel } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(startedAt === undefined ? {} : { startedAt }), ...(durationMs === undefined ? {} : { durationMs }), ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}), ...(lastEventAt === undefined ? {} : { lastEventAt }) };
+                return { ...(previous?.systemPrompt === undefined ? {} : { systemPrompt: previous.systemPrompt }), ...(node.prompt !== undefined ? { prompt: node.prompt } : previous?.prompt !== undefined ? { prompt: previous.prompt } : {}), id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), structuralPath: [...(node.options.agentIdentity?.structuralPath ?? [])], ...(resultPath ? { resultPath } : {}), ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.worktreeOwner ? { worktreeOwner: node.options.worktreeOwner } : {}), ...(node.options.agentIdentity?.handle === undefined ? {} : { handle: node.options.agentIdentity.handle, ...(node.options.agentIdentity.turn === undefined ? {} : { turn: node.options.agentIdentity.turn }), ...(node.options.continuity ? { continuity: node.options.continuity } : {}) }), ...(effective.requestedModel ? { requestedModel: effective.requestedModel } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(startedAt === undefined ? {} : { startedAt }), ...(durationMs === undefined ? {} : { durationMs }), ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}), ...(lastEventAt === undefined ? {} : { lastEventAt }) };
             });
             return { ...current, agents };
         });
@@ -884,16 +1011,18 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             return decision;
         };
     };
-    const registerControlTool = (name, label, description, parameters, run) => {
+    const registerControlTool = (name, label, description, parameters, outputSchema, run) => {
         pi.registerTool({
             name,
             label,
             description,
             parameters,
+            outputSchema,
+            ...workflowToolExposure(name, codemodeTools),
             async execute(_id, params, signal, _onUpdate, ctx) {
                 try {
                     const result = await run(params, signal, ctx);
-                    return { content: [{ type: "text", text: result.text }], details: result.details };
+                    return { content: [{ type: "text", text: result.text }], details: result.details, structuredContent: result.structured };
                 }
                 catch (error) {
                     throw mainAgentError(error);
@@ -903,27 +1032,29 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             renderResult(result, options, theme, context) { return workflowCatalogBlock(workflowControlResult(name, context.args, result, options.expanded, theme, context.isError), options.expanded); },
         });
     };
-    registerControlTool("workflow_respond", "Workflow Respond", "Approve or reject one pending workflow checkpoint or budget decision", Type.Object({ runId: Type.String(), name: Type.Optional(Type.String()), proposalId: Type.Optional(Type.String()), approved: Type.Boolean() }, { additionalProperties: false }), async (params, signal, ctx) => {
+    registerControlTool("workflow_respond", "Workflow Respond", "Approve or reject one pending workflow checkpoint or budget decision", Type.Object({ runId: Type.String(), name: Type.Optional(Type.String()), proposalId: Type.Optional(Type.String()), approved: Type.Boolean() }, { additionalProperties: false }), WORKFLOW_RESPOND_OUTPUT, async (params, signal, ctx) => {
         if (params.proposalId) {
             const result = await recovery.answerBudgetDecision(params.runId, params.proposalId, params.approved, false, ctx, signal);
             if (!result) {
                 const denied = { state: "budget_exhausted", approved: false, reason: "proposal_not_pending" };
-                return { text: JSON.stringify(denied), details: denied };
+                return { text: JSON.stringify(denied), details: denied, structured: denied };
             }
-            return { text: completionControlContent(result, params.runId), details: { ...result, reason: params.approved ? "approved" : "rejected" } };
+            const reason = params.approved ? "approved" : "rejected";
+            return { text: completionControlContent(result, params.runId), details: { ...result, reason }, structured: { ...completionControlValue(result, params.runId), reason } };
         }
         if (!params.name)
             throw new WorkflowError("INVALID_METADATA", "workflow_respond requires name or proposalId");
         const accepted = await answerCheckpoint(params.runId, params.name, params.approved);
-        return { text: accepted ? "Checkpoint response accepted." : "Checkpoint is not awaiting a response.", details: { accepted, state: accepted ? "checkpoint_answered" : "not_pending", approved: params.approved, reason: "checkpoint" } };
+        const details = { accepted, state: accepted ? "checkpoint_answered" : "not_pending", approved: params.approved, reason: "checkpoint" };
+        return { text: accepted ? "Checkpoint response accepted." : "Checkpoint is not awaiting a response.", details, structured: details };
     });
-    registerControlTool("workflow_stop", "Workflow Stop", "Stop an active workflow run by ID", Type.Object({ runId: Type.String() }, { additionalProperties: false }), async (params) => {
+    registerControlTool("workflow_stop", "Workflow Stop", "Stop an active workflow run by ID", Type.Object({ runId: Type.String() }, { additionalProperties: false }), WORKFLOW_STOP_OUTPUT, async (params) => {
         const result = await stopWorkflowRun(params.runId);
-        return { text: JSON.stringify(result), details: result };
+        return { text: JSON.stringify(result), details: result, structured: result };
     });
-    registerControlTool("workflow_status", "Workflow Status", "Read a compact summary of a workflow run in the current project", WORKFLOW_STATUS_PARAMETERS, async (params, _signal, ctx) => {
+    registerControlTool("workflow_status", "Workflow Status", "Read a compact summary of a workflow run in the current project", WORKFLOW_STATUS_PARAMETERS, WORKFLOW_STATUS_OUTPUT, async (params, _signal, ctx) => {
         const result = await workflowStatusRun(params.runId, ctx);
-        return { text: JSON.stringify(result), details: result };
+        return { text: JSON.stringify(result), details: result, structured: result };
     });
     let catalogRegistered = false;
     let sessionStarted = false;
@@ -937,13 +1068,15 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             return;
         pi.registerTool({
             name: "workflow_catalog",
+            ...workflowToolExposure("workflow_catalog", codemodeTools),
+            outputSchema: WORKFLOW_CATALOG_OUTPUT,
             label: "Workflow Catalog",
             description: "List reusable workflow functions and model aliases; pass `name` to load one entry in full",
             parameters: Type.Object({ name: Type.Optional(Type.String({ description: "Registered function or model alias name for full detail" })) }, { additionalProperties: false }),
             async execute(_id, params = {}) {
                 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 };
+                return { content: [{ type: "text", text: JSON.stringify(result) }], details: result, structuredContent: result };
             },
             renderCall(args, theme) {
                 const title = theme.fg("toolTitle", theme.bold("workflow_catalog"));
@@ -955,26 +1088,12 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         });
         catalogRegistered = true;
     };
-    const createAgentExecutor = (root) => new WorkflowAgentExecutor({ ...root, agentDir: extensionAgentDir, ...(additionalSkillPaths.length ? { additionalSkillPaths } : {}), agentSetupHooks: registry.agentSetupHooks(), validateExtensionSettings: registry.validateExtensionSettings, onResourceWarning: (message) => { deliverWarning(pi, message); }, onAgentSettings: (agentId, settings) => { scheduler.setExtensionSettings(agentId, settings); } }, transport);
-    // Resumed runs keep the role definitions frozen in their snapshot and fall back to the current definitions for roles a
-    // registered function reaches for the first time after the restart; those are captured into the snapshot like at launch.
-    const resumeRoles = (store, snapshot, cwd, trustedProject) => {
-        let current = {};
-        let project = {};
-        try {
-            current = loadAgentDefinitions(cwd, extensionAgentDir, trustedProject, registry.roleDirectoryRegistrations());
-            project = trustedProject ? loadProjectAgentDefinitions(cwd) : {};
-        }
-        catch { /* Unreadable current roles leave the resume with the snapshot roles, as before. */ }
-        const definitions = { ...current, ...(snapshot.roles ?? {}) };
-        const captured = roleCapture(store, snapshot, definitions, project);
-        return { definitions, capture: (role, model) => captured.capture(role, model) };
-    };
+    const createAgentExecutor = (root) => new WorkflowAgentExecutor({ ...root, ...(extensionLoad ? { extensionLoad } : {}), agentDir: extensionAgentDir, ...(additionalSkillPaths.length ? { additionalSkillPaths } : {}), agentPreparationHooks: registry.agentPreparationHooks(), agentSetupHooks: registry.agentSetupHooks(), validateExtensionSettings: registry.validateExtensionSettings, onResourceWarning: root.onResourceWarning ?? ((message) => { deliverWarning(pi, message); }), onAgentSettings: (agentId, settings) => { scheduler.setExtensionSettings(agentId, settings); }, onAgentCapabilities: (agentId, capabilities, projectTrusted) => { scheduler.setAttemptCapabilities(agentId, capabilities, projectTrusted); } }, transport);
     const activeSnapshotTools = (tools, active) => active === "session"
-        ? new Set(tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog"))
+        ? new Set(tools.filter((tool) => reachableTools(pi).includes(tool) && tool !== "workflow_catalog"))
         : new Set(tools.filter((tool) => active.has(tool) || tool === "workflow_catalog"));
     const resumeLaunchPrologue = async (input) => {
-        const active = new Set(pi.getActiveTools().filter((tool) => !INTERNAL_WORKFLOW_TOOLS.includes(tool)));
+        const active = new Set(reachableTools(pi).filter((tool) => !INTERNAL_WORKFLOW_TOOLS.includes(tool)));
         const missing = input.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
         if (missing)
             throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
@@ -983,27 +1102,27 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         const extensionSettings = input.snapshot.settings.extensionSettings;
         const extensionSettingsPath = input.snapshot.settingsSources?.extensionSettings ?? input.snapshot.settingsPath ?? settingsPath;
         registry.validateExtensionSettings(extensionSettings, { source: "effective", cwd: input.cwd, projectTrusted: input.trustedProject, settingsPath: extensionSettingsPath });
-        for (const [role, definition] of Object.entries(input.snapshot.roles ?? {}))
-            registry.validateExtensionSettings(mergeWorkflowExtensionSettings(extensionSettings, definition.extensionSettings), { source: "role", cwd: input.cwd, projectTrusted: input.trustedProject, settingsPath: extensionSettingsPath, role });
         const currentPolicy = resolveAgentResourcePolicy(input.cwd, input.trustedProject, settingsPath);
         const staticAliases = resolution.effective.modelAliases ?? {};
         const previousAliases = input.snapshot.modelAliases ?? input.snapshot.settings.modelAliases ?? {};
         const inventory = modelInventory(input.rootModel, input.modelRegistry);
         const knownModels = input.modelRegistry ? inventory.knownModels : new Set([...input.snapshot.models, ...inventory.knownModels]);
         const availableModels = input.modelRegistry ? inventory.availableModels : new Set([...input.snapshot.models, ...inventory.availableModels]);
-        const currentAliases = input.resolvedAliases ?? (await resolveLaunchAliases(registry, staticAliases, { cwd: input.cwd, projectTrusted: input.trustedProject, rootModel: input.rootModel, knownModels, availableModels, signal: input.signal }, availableModels, knownModels, settingsPath)).aliases;
+        const resolved = input.resolvedAliases ? { aliases: input.resolvedAliases, dynamicNames: input.resolvedDynamicAliasNames ?? [] } : await resolveLaunchAliases(registry, staticAliases, { cwd: input.cwd, projectTrusted: input.trustedProject, rootModel: input.rootModel, knownModels, availableModels, signal: input.signal }, availableModels, knownModels, settingsPath);
+        const currentAliases = resolved.aliases;
+        const dynamicAliasNames = resolved.dynamicNames;
         const blockedAliases = input.blockedAliases ?? new Set(Object.keys(previousAliases).filter((name) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
         const blockedAliasTargets = input.blockedAliasTargets ?? Object.fromEntries(Object.entries(previousAliases).filter(([name]) => !Object.prototype.hasOwnProperty.call(currentAliases, name)));
         const script = input.withPreflight ? input.snapshot.script : undefined;
         if (script !== undefined) {
             const resumeAliases = { ...previousAliases, ...currentAliases };
-            preflight(script, { models: availableModels, tools: active, agentTypes: new Set(input.snapshot.agentTypes), modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, input.snapshot.schemas, input.snapshot.metadata, true);
+            preflight(script, { models: availableModels, tools: active, modelAliases: resumeAliases, knownModels, settingsPath, skipModelAvailability: true }, input.snapshot.schemas, input.snapshot.metadata, true);
         }
         const refreshed = resumedSnapshotSettings(input.snapshot, resolution, currentAliases);
         const snapshot = createLaunchSnapshot({ ...input.snapshot, settingsPath, ...refreshed, modelAliases: currentAliases });
-        return { active, settingsPath, resolution, currentPolicy, previousAliases, knownModels, availableModels, currentAliases, blockedAliases, blockedAliasTargets, snapshot, script };
+        return { active, settingsPath, resolution, currentPolicy, previousAliases, knownModels, availableModels, currentAliases, dynamicAliasNames, blockedAliases, blockedAliasTargets, snapshot, script };
     };
-    const workflowAgentHandler = (store, metadata, lifecycle, executor, cwd, runId, captureRole) => {
+    const workflowAgentHandler = (store, metadata, lifecycle, executor, cwd, runId) => {
         // Replay lookup and spawn are serialised per run so concurrent agent(...) calls reach the scheduler in call order.
         const admission = new SerialLane();
         return async (prompt, options, agentSignal, identity) => {
@@ -1016,21 +1135,21 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                         return { replayed };
                     const worktree = agentWorktree(identity);
                     const agentCwd = worktree.worktreeOwner ? (await persistWorktree(store, metadata, worktree.worktreeOwner)).cwd : cwd;
-                    const role = typeof options.role === "string" ? options.role : undefined;
                     const model = typeof options.model === "string" ? options.model : undefined;
                     const requestedLabel = typeof options.label === "string" ? options.label : undefined;
                     const skills = Array.isArray(options.skills) ? options.skills : undefined;
                     const extensions = Array.isArray(options.extensions) ? options.extensions : undefined;
                     const contextFiles = Array.isArray(options.contextFiles) && options.contextFiles.every(isContextFileScope) ? options.contextFiles : undefined;
-                    const resolved = executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: metadata.name, ...(model ? { model } : {}), ...(role ? { role } : {}), ...(contextFiles ? { contextFiles } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools } : {}), ...(skills ? { skills } : {}), ...(extensions ? { extensions } : {}) });
-                    if (role)
-                        await captureRole?.(role, resolved.model);
-                    const label = displayAgentName(requestedLabel, role, resolved.model);
+                    // A paused resume replaces the run executor with refreshed aliases; new identities must prepare against it.
+                    const current = runs.get(runId)?.executor ?? executor;
+                    const configuration = await current.prepare({ label: requestedLabel ?? "agent", workflowName: metadata.name, agentOptions: options, agentIdentity: identity, ...(worktree.worktreeOwner ? { worktreeOwner: worktree.worktreeOwner } : {}) }, agentCwd, agentSignal);
+                    const resolved = configuration;
+                    const label = requestedLabel ?? configuration.label ?? resolved.model.model;
                     const tools = resolved.tools;
                     const schema = object(options.outputSchema) ? options.outputSchema : undefined;
                     const sessionPath = identity.handle !== undefined && identity.turn !== undefined ? await handleTurnInput(store, identity.handle, identity.turn) : undefined;
                     const continuity = identity.handle === undefined ? undefined : sessionPath ? "continued" : "fresh";
-                    return { spawned: scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd: agentCwd, tools, ...(skills ? { skills } : {}), ...(extensions ? { extensions } : {}), ...worktree, ...(model ? { model } : {}), ...(role ? { role } : {}), ...(contextFiles ? { contextFiles } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), ...(sessionPath ? { sessionPath } : {}), ...(continuity ? { continuity } : {}), agentOptions: options, agentIdentity: identity }) };
+                    return { spawned: scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd: agentCwd, tools, ...(skills ? { skills } : {}), ...(extensions ? { extensions } : {}), ...worktree, ...(model ? { model } : {}), ...(contextFiles ? { contextFiles } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}), ...(sessionPath ? { sessionPath } : {}), ...(continuity ? { continuity } : {}), agentOptions: options, agentIdentity: identity, configuration }) };
                 });
                 if ("replayed" in admitted)
                     return admitted.replayed.value;
@@ -1053,7 +1172,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         };
     };
     const recovery = createWorkflowRecovery({
-        pi, home, runs, scheduler, eventPublisher, persistRunState, projectTrusted, resumeHostContext, ensureSessionLease, coordinateRunMutation, createAgentExecutor, activeSnapshotTools, frozenResourcePolicy, resolveLaunchPrologue: resumeLaunchPrologue, resumeRoles, workflowAgentHandler, shellForRun, resolveWorktree, checkpointBridge, phaseBridge, logBridge, lifecycleFor, createProviderErrorRecovery, cleanupTerminalRun, deliver: (content) => { deliver(pi, content); }, deliverTerminal: deliveryController.deliverTerminal, workflowToolUpdate, registry, modelSpec,
+        pi, home, runs, scheduler, eventPublisher, persistRunState, projectTrusted, resumeHostContext, ensureSessionLease, coordinateRunMutation, createAgentExecutor, activeSnapshotTools, frozenResourcePolicy, resolveLaunchPrologue: resumeLaunchPrologue, workflowAgentHandler, shellForRun, toolForRun, resolveWorktree, checkpointBridge, phaseBridge, logBridge, lifecycleFor, createProviderErrorRecovery, cleanupTerminalRun, deliver: (content) => { deliver(pi, content); }, deliverTerminal: deliveryController.deliverTerminal, workflowToolUpdate, registry, modelSpec,
     });
     const resumeSelectedWorkflow = async (runId, foreground, context, budgetPatch) => {
         const run = runs.get(runId);
@@ -1074,9 +1193,8 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 await deliveryController.moveForegroundToBackground(runId);
             if (foreground && !wasAttached) {
                 run.foreground = true;
-                const loaded = await run.store.load();
                 await persistRunState(run.store, run.metadata, (current) => ({ ...current, delivery: { ...(current.delivery ?? {}), mode: "foreground", state: "attached" } }));
-                await run.store.saveSnapshot(createLaunchSnapshot({ ...loaded.snapshot, launchMode: "foreground" }));
+                await run.store.setLaunchMode("foreground");
             }
             else if (!foreground)
                 run.foreground = false;
@@ -1120,13 +1238,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
         const completed = await recovery.coldResumeRun(run, hasUI, ui, projectTrusted(context), recoveryContext, foreground, foreground);
         return completed ? { workflowName: run.metadata.name, state: "completed", attached: false, value: completed.value } : { workflowName: run.metadata.name, state: "running", attached: false };
     };
-    registerControlTool("workflow_retry", "Workflow Retry", "Retry a failed workflow run by replaying its completed structural operations", WORKFLOW_RETRY_PARAMETERS, async (params, signal, ctx) => {
+    registerControlTool("workflow_retry", "Workflow Retry", "Retry a failed workflow run by replaying its completed structural operations", WORKFLOW_RETRY_PARAMETERS, WORKFLOW_RECOVERY_OUTPUT, async (params, signal, ctx) => {
         const result = await recovery.retryWorkflowRun(params.runId, ctx, signal, params.foreground, params.expectedState);
-        return { text: completionControlContent(result), details: result };
+        return { text: completionControlContent(result), details: result, structured: completionControlValue(result) };
     });
-    registerControlTool("workflow_resume", "Workflow Resume", "Resume an exhausted workflow with unchanged or patched aggregate budgets", Type.Object({ runId: Type.String(), expectedState: Type.Optional(Type.String({ description: "Persisted source state observed before recovery" })), budget: Type.Optional(Type.Unknown()), foreground: Type.Optional(Type.Boolean({ description: "Override the source launch mode for this recovery" })) }, { additionalProperties: false }), async (params, signal, ctx) => {
+    registerControlTool("workflow_resume", "Workflow Resume", "Resume an exhausted workflow with unchanged or patched aggregate budgets", Type.Object({ runId: Type.String(), expectedState: Type.Optional(Type.String({ description: "Persisted source state observed before recovery" })), budget: Type.Optional(Type.Unknown()), foreground: Type.Optional(Type.Boolean({ description: "Override the source launch mode for this recovery" })) }, { additionalProperties: false }), WORKFLOW_RECOVERY_OUTPUT, async (params, signal, ctx) => {
         const result = await recovery.resumeWorkflowRun(params.runId, params.budget, ctx, signal, params.foreground, true, params.expectedState);
-        return { text: completionControlContent(result), details: result };
+        return { text: completionControlContent(result), details: result, structured: completionControlValue(result) };
     });
     const deliverStaleTerminal = async (store, run) => {
         if (!((run.delivery?.mode === "foreground" && run.delivery.state === "attached") || (run.delivery?.mode === "background" && run.delivery.state === "pending")))
@@ -1211,10 +1329,9 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const budgetRuntime = new WorkflowBudgetRuntime(budget, loaded.run.budgetVersion ?? 1, loaded.run.usage, loaded.run.budgetEvents, { active: loaded.run.state === "running" });
                 const lifecycle = lifecycleFor(store, loaded.run.state, loaded.snapshot.metadata);
                 const providerPause = async () => { deliver(pi, `Workflow ${loaded.snapshot.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
-                const roleDefinitions = loaded.snapshot.roles ?? {};
                 const abortController = new AbortController();
                 const providerErrorRecovery = createProviderErrorRecovery(ctx, new Set(loaded.snapshot.models), () => { abortController.abort(); });
-                runs.set(runId, { executor: createAgentExecutor({ cwd: ctx.cwd, model, tools: activeSnapshotTools(loaded.snapshot.tools, "session"), resourceSelectors: snapshotResourcePolicy(loaded.snapshot, store.cwd, projectTrusted(ctx), workflowSettingsPath(extensionAgentDir)).effective, extensionSettings: loaded.snapshot.settings.extensionSettings, availableModels: new Set(loaded.snapshot.models), knownModels: new Set(loaded.snapshot.models), ...(loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases ? { modelAliases: loaded.snapshot.modelAliases ?? loaded.snapshot.settings.modelAliases } : {}), ...(loaded.snapshot.settingsSources?.modelAliases ? { settingsPath: loaded.snapshot.settingsSources.modelAliases } : loaded.snapshot.settingsPath ? { settingsPath: loaded.snapshot.settingsPath } : {}), agentDefinitions: roleDefinitions, runStore: store, providerPause, agentResourcePolicy: frozenResourcePolicy(snapshotResourcePolicy(loaded.snapshot, store.cwd, projectTrusted(ctx), workflowSettingsPath(extensionAgentDir))) }), store, metadata: loaded.snapshot.metadata, model, lifecycle, budget: budgetRuntime, abortController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) });
+                runs.set(runId, { executor: createAgentExecutor({ cwd: ctx.cwd, projectTrusted: projectTrusted(ctx), model, tools: activeSnapshotTools(loaded.snapshot.tools, "session"), resourceSelectors: snapshotResourcePolicy(loaded.snapshot, store.cwd, projectTrusted(ctx), workflowSettingsPath(extensionAgentDir)).effective, extensionSettings: loaded.snapshot.settings.extensionSettings, 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 } : {}), runStore: store, providerPause, agentResourcePolicy: frozenResourcePolicy(snapshotResourcePolicy(loaded.snapshot, store.cwd, projectTrusted(ctx), workflowSettingsPath(extensionAgentDir))) }), store, metadata: loaded.snapshot.metadata, model, lifecycle, budget: budgetRuntime, abortController, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}) });
                 for (const checkpoint of await store.awaitingCheckpoints())
                     deliver(pi, `Workflow ${loaded.snapshot.metadata.name} checkpoint ${checkpoint.name}: ${checkpoint.prompt}\nContext: ${JSON.stringify(checkpoint.context)}\nRespond with workflow_respond.`);
                 for (const decision of await store.pendingWorkflowDecisions())
@@ -1253,21 +1370,14 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             throw error;
         }
     });
-    pi.on("before_agent_start", (event, ctx) => {
-        if (!pi.getActiveTools().includes("workflow"))
-            return;
-        const roles = Object.entries(loadAgentDefinitions(ctx.cwd, extensionAgentDir, projectTrusted(ctx), typeof registry.roleDirectoryRegistrations === "function" ? registry.roleDirectoryRegistrations() : undefined)).filter(([, definition]) => definition.description);
-        if (!roles.length)
-            return;
-        const content = `Workflow role descriptions:\n${roles.map(([name, definition]) => `- \`${name}\`: ${String(definition.description)}`).join("\n")}`;
-        return { systemPrompt: `${event.systemPrompt}\n\n${content}` };
-    });
     const workflowTool = {
         name: "workflow",
         label: WORKFLOW_TOOL_LABEL,
         description: WORKFLOW_TOOL_DESCRIPTION,
         promptSnippet: WORKFLOW_TOOL_PROMPT_SNIPPET,
         parameters: WORKFLOW_TOOL_PARAMETERS,
+        outputSchema: WORKFLOW_LAUNCH_OUTPUT,
+        prepareLoadout: prepareScriptToolLoadout,
         async execute(toolCallId, params, signal, onUpdate, ctx) {
             let resolveDetached;
             let foregroundStore;
@@ -1275,7 +1385,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             const detachedResult = params.foreground ? new Promise((resolve) => { resolveDetached = resolve; }) : undefined;
             const detachedToolResult = (run) => {
                 const detached = { runId: run.id, state: "running", detached: true };
-                return { content: [{ type: "text", text: JSON.stringify(detached) }], details: { ...detached, run, preview: `Moved workflow ${run.id} to background.` } };
+                return { content: [{ type: "text", text: JSON.stringify(detached) }], details: { ...detached, run, preview: `Moved workflow ${run.id} to background.` }, structuredContent: detached };
             };
             try {
                 const headless = object(ctx) && ctx.headless === true;
@@ -1289,7 +1399,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const inventory = modelInventory(rootModel, modelRegistry);
                 const knownModels = inventory.knownModels;
                 const availableModels = inventory.availableModels;
-                const rootTools = pi.getActiveTools().filter((name) => !INTERNAL_WORKFLOW_TOOLS.includes(name));
+                const rootTools = reachableTools(pi).filter((name) => !INTERNAL_WORKFLOW_TOOLS.includes(name));
                 const trustedProject = projectTrusted(ctx);
                 const launchCwd = typeof ctx.cwd === "string" ? ctx.cwd : process.cwd();
                 const launch = workflowLaunchSettings(launchCwd, trustedProject, settingsPath, params.concurrency);
@@ -1308,23 +1418,33 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 if (trustedProject && launch.resolution.project.extensionSettings !== undefined)
                     registry.validateExtensionSettings(launch.resolution.project.extensionSettings, { source: "project", cwd: ctx.cwd, projectTrusted: true, settingsPath: launch.resolution.projectSettingsPath });
                 const validated = validateWorkflowLaunchWithRegistry(params, { cwd: ctx.cwd, agentDir: extensionAgentDir, projectTrusted: trustedProject, availableModels, rootTools: new Set(rootTools), modelAliases, knownModels, settingsPath, ...(settings.extensionSettings === undefined ? {} : { extensionSettings: settings.extensionSettings }) }, registry);
-                const { script, checked, agentDefinitions, projectAgentDefinitions, roleNames } = validated;
+                const { script, checked } = validated;
+                const toolContext = scriptToolContext(ctx);
+                validateScriptToolReferences(script, toolContext);
+                // Headless hosts that tolerated extension load failures report them with the extensions they loaded.
+                const strings = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+                const loadErrors = object(ctx) ? strings(ctx.extensionLoadErrors) : [];
+                if (loadErrors.length)
+                    extensionLoad = Object.freeze({ errors: loadErrors, loaded: object(ctx) ? strings(ctx.loadedExtensionPaths) : [] });
+                const executorRoot = { cwd: ctx.cwd, projectTrusted: launch.resourcePolicy.projectTrusted, model: rootModel, tools: new Set(rootTools), resourceSelectors: launch.resourcePolicy.effective, extensionSettings: settings.extensionSettings, availableModels, knownModels, modelAliases, dynamicModelAliasNames: resolvedAliases.dynamicNames, settingsPath, agentResourcePolicy: frozenResourcePolicy(launch.resourcePolicy) };
+                // Runtime emits the same resource warnings, so inspection stays silent.
+                await inspectStaticAgentConfigurations(createAgentExecutor({ ...executorRoot, onResourceWarning: () => undefined }), script, checked.metadata.name, runController.signal, registry.functions());
                 await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
+                // Cancellation can arrive while the lease or a queued parent validation is pending; no run may be created after it.
+                const assertLaunchActive = () => { if (runController.signal.aborted)
+                    throw new WorkflowError("CANCELLED", "Workflow launch cancelled"); };
+                assertLaunchActive();
                 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 store = new RunStore(ctx.cwd, ctx.sessionManager.getSessionId(), runId, home);
                 const parentRunId = params.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, modelAliases, knownModels, settingsPath)] : []; });
-                const snapshotModels = [...new Set([rootModelName, ...checked.referenced.models, ...roleModels])];
-                const snapshot = createLaunchSnapshot({ script, args, metadata: checked.metadata, launchMode: params.foreground ? "foreground" : "background", settings, settingsPath, settingsSources: { ...launch.resolution.sources, concurrency: params.concurrency === undefined ? launch.resolution.sources.concurrency : "per-run options" }, ...(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 capturedRoles = roleCapture(store, snapshot, agentDefinitions, projectAgentDefinitions);
+                const snapshotModels = [...new Set([rootModelName, ...checked.referenced.models])];
+                const snapshot = createLaunchSnapshot({ script, args, metadata: checked.metadata, launchMode: params.foreground ? "foreground" : "background", settings, settingsPath, settingsSources: { ...launch.resolution.sources, concurrency: params.concurrency === undefined ? launch.resolution.sources.concurrency : "per-run options" }, ...(Object.keys(modelAliases).length ? { modelAliases } : {}), ...(budget ? { budget } : {}), ...(checked.referenced.phases.length ? { phases: checked.referenced.phases } : {}), models: snapshotModels, tools: rootTools, agentConfigurations: {}, schemas: checked.schemas });
                 const budgetRuntime = new WorkflowBudgetRuntime(budget);
                 const initialBudget = budgetRuntime.snapshot();
-                const createRun = () => store.create({ id: runId, workflowName: checked.metadata.name, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), state: "running", ...(parentRunId !== undefined ? { parentRunId } : {}), agents: [], agentSessions: [], delivery: params.foreground ? { mode: "foreground", state: "attached", toolCallId } : { mode: "background", state: "pending" }, ...(budget ? { budget } : {}), budgetVersion: 1, ...initialBudget }, snapshot);
+                const createRun = () => { assertLaunchActive(); return store.create({ id: runId, workflowName: checked.metadata.name, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), state: "running", ...(parentRunId !== undefined ? { parentRunId } : {}), agents: [], agentSessions: [], delivery: params.foreground ? { mode: "foreground", state: "attached", toolCallId } : { mode: "background", state: "pending" }, ...(budget ? { budget } : {}), budgetVersion: 1, ...initialBudget }, snapshot); };
                 // Parent validation and persistence share the mutation lane so a manual deletion cannot remove the parent between the two.
                 if (parentRunId !== undefined)
                     await coordinateRunMutation(async () => { await store.validateParentRun(parentRunId); await createRun(); });
@@ -1352,7 +1472,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                                 activeRun.foreground = false;
                                 delete activeRun.update;
                             }
-                            await store.saveSnapshot(createLaunchSnapshot({ ...capturedRoles.snapshot, launchMode: "background" }));
+                            await store.setLaunchMode("background");
                             for (const checkpoint of await store.awaitingCheckpoints())
                                 deliverBackgroundCheckpoint(checked.metadata.name, runId, checkpoint);
                             signal?.removeEventListener("abort", onForegroundAbort);
@@ -1369,13 +1489,13 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 const providerPause = async () => { if (!foregroundAttached)
                     deliver(pi, `Workflow ${checked.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
                 const providerErrorRecovery = createProviderErrorRecovery(ctx, availableModels, () => { runController.abort(); });
-                const executor = createAgentExecutor({ cwd: ctx.cwd, model: rootModel, tools: new Set(rootTools), resourceSelectors: launch.resourcePolicy.effective, extensionSettings: settings.extensionSettings, availableModels, knownModels, modelAliases, settingsPath, agentDefinitions, runStore: store, providerPause, agentResourcePolicy: frozenResourcePolicy(launch.resourcePolicy), runContext });
+                const executor = createAgentExecutor({ ...executorRoot, runStore: store, providerPause, runContext });
                 const runRecord = { executor, store, metadata: checked.metadata, model: rootModel, lifecycle, budget: budgetRuntime, abortController: runController, foreground: foregroundAttached, projectTrusted: () => projectTrusted(ctx), checkpointResolvers: new Map(), ...(providerErrorRecovery ? { providerErrorRecovery } : {}), ...(params.foreground && onUpdate ? { update: onUpdate } : {}) };
                 runs.set(runId, runRecord);
                 if (params.foreground && onUpdate)
                     onUpdate(workflowToolUpdate((await store.load()).run));
                 scheduler.addRun(runId, settings.concurrency, () => runs.get(runId)?.budget.checkAgentLaunch(), settings.extensionSettings);
-                const execution = runWorkflow(script, args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal, identity), agent: workflowAgentHandler(store, checked.metadata, lifecycle, executor, ctx.cwd, runId, (role, model) => capturedRoles.capture(role, model)), worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, () => runs.get(runId)?.foreground ?? foregroundAttached, ctx.hasUI ? ctx.ui : undefined, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(store, lifecycle, checked.metadata.name) }, store, runContext, registry, settings.extensionSettings), runController.signal);
+                const execution = runWorkflow(script, args, withWorkflowFunctions({ tool: (identifier, toolArgs, signal, identity) => toolForRun(store, lifecycle, toolContext, identifier, toolArgs, signal, identity), shell: (command, options, signal, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal, identity), agent: workflowAgentHandler(store, checked.metadata, lifecycle, executor, ctx.cwd, runId), worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, () => runs.get(runId)?.foreground ?? foregroundAttached, ctx.hasUI ? ctx.ui : undefined, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(store, lifecycle, checked.metadata.name) }, store, runContext, registry, settings.extensionSettings), runController.signal);
                 runRecord.execution = execution;
                 await eventPublisher.runStarted(store, checked.metadata);
                 const finish = execution.result.then(async (value) => {
@@ -1416,7 +1536,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                     }, async (error) => {
                         await deliveryController.deliverTerminal(store, deliverFailureContent(error), true);
                     });
-                    return { content: [{ type: "text", text: JSON.stringify({ runId, state: "running" }) }], details: { runId, preview: `Started workflow ${runId}.` } };
+                    return { content: [{ type: "text", text: JSON.stringify({ runId, state: "running" }) }], details: { runId, preview: `Started workflow ${runId}.` }, structuredContent: { runId, state: "running" } };
                 }
                 void completion.then(async (result) => {
                     await deliveryController.deliverDetachedTerminal(toolCallId, completionContent("background", result));
@@ -1442,7 +1562,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
                 }
                 deliveryController.foregroundDeliveries.delete(toolCallId);
                 const run = (await store.load()).run;
-                return { content: [{ type: "text", text: foregroundDelivery.content }, ...(foregroundDelivery.inlined ? [{ type: "text", text: `Workflow run ID: ${runId}` }] : [])], details: { runId, value, run } };
+                return { content: [{ type: "text", text: foregroundDelivery.content }, ...(foregroundDelivery.inlined ? [{ type: "text", text: `Workflow run ID: ${runId}` }] : [])], details: { runId, value, run }, structuredContent: { runId, state: "completed", value } };
             }
             catch (error) {
                 if (params.foreground && foregroundStore && completionInstalled) {
@@ -1529,7 +1649,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
             return textBlock(isPartial ? "Workflow starting..." : runDetails?.preview ?? (content?.type === "text" ? content.text : "Workflow finished"));
         },
     };
-    pi.registerTool(workflowTool);
+    pi.registerTool({ ...workflowTool, ...workflowToolExposure(workflowTool.name, codemodeTools) });
     registerWorkflowNavigator({ pi, home, clipboard, extensionAgentDir, runs, terminalRunStates, hardTerminalRunStates: HARD_TERMINAL_RUN_STATES, ensureSessionLease, coordinateRunMutation, answerCheckpoint, recovery, stopWorkflowRun, moveForegroundToBackground: deliveryController.moveForegroundToBackground, isForegroundAttached: deliveryController.isForegroundAttached, liveAgents, registry, projectTrusted, resumeHostContext, resumeSelectedWorkflow, reportBlocked: reportWorkflowBlocked, trajectoryProvider, setNavigatorOpen: (open) => { if (open)
             backgroundWidgetController.suspend();
         else
@@ -1561,6 +1681,7 @@ export default function workflowExtension(pi, home, clipboard = copyToClipboard,
 }
 class LiveAgentRegistry {
     #byRun = new Map();
+    #tools = new Map();
     get(runId, agentId) { return this.#byRun.get(runId)?.get(agentId); }
     setSession(runId, agentId, session) {
         if (session)
@@ -1587,19 +1708,29 @@ class LiveAgentRegistry {
         if (timestamp !== undefined)
             this.#state(runId, agentId).lastEventAt = timestamp;
     }
-    deleteRun(runId) { this.#byRun.delete(runId); }
-    /** Overlays live activity and freshness onto a persisted run; returns the input when nothing is live. */
+    /** Marks a script tool call in flight until the returned callback runs. */
+    toolStarted(runId, name) {
+        const call = { name, startedAt: Date.now() };
+        const calls = this.#tools.get(runId) ?? new Set();
+        this.#tools.set(runId, calls.add(call));
+        return () => { calls.delete(call); if (!calls.size && this.#tools.get(runId) === calls)
+            this.#tools.delete(runId); };
+    }
+    deleteRun(runId) { this.#byRun.delete(runId); this.#tools.delete(runId); }
+    /** Overlays live activity, freshness, and script tool calls onto a persisted run; returns the input when nothing is live. */
     overlay(run) {
+        const tools = this.#tools.get(run.id);
+        const withTools = tools?.size ? { ...run, activeTools: [...tools].map((call) => ({ ...call })) } : run;
         const agents = this.#byRun.get(run.id);
         if (!agents?.size)
-            return run;
+            return withTools;
         const next = run.agents.map((agent) => {
             const live = agents.get(agent.id);
             if (!live || (live.activity === undefined && live.lastEventAt === undefined))
                 return agent;
             return { ...agent, ...(live.activity === undefined ? {} : { activity: live.activity }), ...(live.lastEventAt === undefined ? {} : { lastEventAt: live.lastEventAt }) };
         });
-        return next.some((agent, index) => agent !== run.agents[index]) ? { ...run, agents: next } : run;
+        return next.some((agent, index) => agent !== run.agents[index]) ? { ...withTools, agents: next } : withTools;
     }
     #state(runId, agentId) {
         const agents = this.#byRun.get(runId) ?? new Map();
@@ -1660,9 +1791,6 @@ async function handleTurnInput(store, handle, turn) {
     }
     return target;
 }
-function displayAgentName(label, role, model) {
-    return label ?? role ?? model.model;
-}
 function modelSpec(value, fallback) {
     try {
         const parsed = parseModelReference(value);