pi-extensible-workflows 3.2.0 → 3.4.0

package/dist/src/agent-execution.js

@@ -1,9 +1,10 @@
-import { realpathSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { Type } from "@earendil-works/pi-ai";
 import { Value } from "typebox/value";
 import { createAgentSession, DefaultPackageManager, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
-import { jsonObject, disabledResources, mergeAgentResourceExclusions, modelAliasName, modelCapability, resolveModelReference, unmatchedResourcePatterns } from "./utils.js";
+import { deepFreeze, jsonObject, disabledResources, mergeAgentResourceExclusions, modelAliasName, modelCapability, resolveModelReference, unmatchedResourcePatterns } from "./utils.js";
 import { WorkflowError } from "./types.js";
 function parseModel(value, fallback, thinking, aliases = {}, knownModels, settingsPath) {
     if (!value)
@@ -11,8 +12,7 @@ function parseModel(value, fallback, thinking, aliases = {}, knownModels, settin
     const parsed = resolveModelReference(value, aliases, knownModels, settingsPath);
     return { ...parsed, ...(thinking ? { thinking } : !parsed.thinking && fallback.thinking ? { thinking: fallback.thinking } : {}) };
 }
-function text(messages) {
-    const message = [...messages].reverse().find((item) => item.role === "assistant");
+function text(message) {
     if (!message || !Array.isArray(message.content))
         return "";
     return message.content.filter((part) => typeof part === "object" && part !== null && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string").map((part) => part.text).join("");
@@ -20,19 +20,14 @@ function text(messages) {
 function hasToolCall(message) {
     return typeof message === "object" && message !== null && Array.isArray(message.content) && message.content.some((part) => typeof part === "object" && part !== null && part.type === "toolCall");
 }
-function latestAssistantHasToolCall(messages) {
-    const message = [...messages].reverse().find((item) => item.role === "assistant");
-    return hasToolCall(message);
-}
-function throwIfTerminalAssistantError(session, fallbackModel) {
-    const message = [...session.messages].reverse().find((item) => item.role === "assistant");
+function latestAssistantHasToolCall(message) { return hasToolCall(message); }
+function throwIfTerminalAssistantError(session, message) {
     if (message?.stopReason !== "error")
         return;
-    const provider = session.model?.provider ?? fallbackModel.provider;
-    const model = session.model?.model ?? session.model?.id ?? fallbackModel.model;
-    const error = message.errorMessage ?? "Native Pi assistant ended with a terminal provider error";
+    const state = session.getState();
+    const error = message.errorMessage ?? "Workflow agent session ended with a terminal provider error";
     const failure = new WorkflowError("AGENT_FAILED", error);
-    Object.defineProperty(failure, "terminalProviderError", { value: { provider, model, error }, configurable: true });
+    Object.defineProperty(failure, "terminalProviderError", { value: { provider: state.model.provider, model: state.model.model, error }, configurable: true });
     throw failure;
 }
 function terminalProviderError(error) {
@@ -42,6 +37,37 @@ function terminalProviderError(error) {
     const candidate = value;
     return typeof candidate.provider === "string" && typeof candidate.model === "string" && typeof candidate.error === "string" ? { provider: candidate.provider, model: candidate.model, error: candidate.error } : undefined;
 }
+const providerContinuationPrompt = "The provider error was transient. Continue the task from your current state.";
+async function recoverTerminalProviderError(session, label, recovery, continuePrompt, getAssistant) {
+    let continued = false;
+    for (;;) {
+        try {
+            throwIfTerminalAssistantError(session, getAssistant());
+            return continued;
+        }
+        catch (error) {
+            const typed = error instanceof WorkflowError ? error : new WorkflowError("AGENT_FAILED", error instanceof Error ? error.message : String(error));
+            const terminal = terminalProviderError(typed);
+            if (!terminal || !recovery)
+                throw error;
+            let action;
+            try {
+                action = await recovery({ label, ...terminal });
+            }
+            catch {
+                Object.assign(typed, { providerRecoveryHandled: true, providerRecoveryFailed: true });
+                throw typed;
+            }
+            if (action === "retry") {
+                continued = true;
+                await continuePrompt();
+                continue;
+            }
+            Object.assign(typed, { providerRecoveryHandled: true, providerRecovery: action });
+            throw typed;
+        }
+    }
+}
 function accounting(stats) {
     return { input: stats.tokens.input, output: stats.tokens.output, cacheRead: stats.tokens.cacheRead, cacheWrite: stats.tokens.cacheWrite, cost: stats.cost };
 }
@@ -51,8 +77,18 @@ function canonicalSourcePath(path) { try {
 catch {
     return resolve(path);
 } }
-export async function createNativeAgentSession(input) {
+const WORKFLOW_DIRECTORY = "pi-extensible-workflows";
+function workflowSystemPromptPath(cwd, agentDir, projectTrusted) {
+    const projectPath = join(cwd, ".pi", WORKFLOW_DIRECTORY, "SYSTEM.md");
+    if (projectTrusted && existsSync(projectPath))
+        return projectPath;
+    const globalPaths = [join(homedir(), ".pi", WORKFLOW_DIRECTORY, "SYSTEM.md"), join(agentDir, WORKFLOW_DIRECTORY, "SYSTEM.md")];
+    return globalPaths.find((path) => existsSync(path));
+}
+export async function createLocalPiSession(input) {
     const agentDir = input.agentDir ?? getAgentDir();
+    const systemPromptSource = workflowSystemPromptPath(input.cwd, agentDir, input.resourcePolicy?.projectTrusted ?? true);
+    const systemPromptOptions = input.systemPrompt !== undefined ? { systemPromptOverride: () => input.systemPrompt } : systemPromptSource !== undefined ? { systemPrompt: systemPromptSource } : {};
     const manager = input.agentDir ? SessionManager.create(input.cwd, join(agentDir, "sessions")) : SessionManager.create(input.cwd);
     manager.appendSessionInfo(input.sessionLabel);
     const modelRuntime = await ModelRuntime.create({ authPath: join(agentDir, "auth.json"), modelsPath: join(agentDir, "models.json") });
@@ -87,18 +123,19 @@ export async function createNativeAgentSession(input) {
             noExtensions: true,
             additionalExtensionPaths: extensionPaths,
             noSkills: true,
-            additionalSkillPaths: skillPaths,
+            additionalSkillPaths: [...new Set([...skillPaths, ...(input.additionalSkillPaths ?? [])])],
             ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}),
             skillsOverride: (base) => {
                 const disabledSkills = updateSkillMatches(base.skills);
                 return { ...base, skills: base.skills.filter(({ name }) => !disabledSkills.has(name)) };
             },
             ...(input.systemPromptAppend ? { appendSystemPromptOverride: (base) => [...base, input.systemPromptAppend ?? ""] } : {}),
+            ...systemPromptOptions,
         });
         await resourceLoader.reload();
     }
-    else if (input.systemPromptAppend || input.extensionFactories?.length) {
-        resourceLoader = new DefaultResourceLoader({ cwd: input.cwd, agentDir, ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}), ...(input.systemPromptAppend ? { appendSystemPromptOverride: (base) => [...base, input.systemPromptAppend ?? ""] } : {}) });
+    else if (input.systemPrompt !== undefined || systemPromptSource !== undefined || input.systemPromptAppend || input.extensionFactories?.length || input.additionalSkillPaths?.length) {
+        resourceLoader = new DefaultResourceLoader({ cwd: input.cwd, agentDir, ...(input.additionalSkillPaths?.length ? { additionalSkillPaths: [...input.additionalSkillPaths] } : {}), ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}), ...systemPromptOptions, ...(input.systemPromptAppend ? { appendSystemPromptOverride: (base) => [...base, input.systemPromptAppend ?? ""] } : {}) });
         await resourceLoader.reload();
     }
     const { session } = await createAgentSession({ ...(input.options ?? {}), cwd: input.cwd, agentDir, modelRuntime, model, ...(settingsManager ? { settingsManager } : {}), ...(input.model.thinking ? { thinkingLevel: input.model.thinking } : {}), tools, ...(customTools.length ? { customTools } : {}), ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}), ...(resourceLoader ? { resourceLoader } : {}), sessionManager: manager });
@@ -107,6 +144,72 @@ export async function createNativeAgentSession(input) {
         getToolDefinitions: () => session.getAllTools().map(({ name, description, parameters, promptGuidelines }) => ({ name, description, parameters, ...(promptGuidelines ? { promptGuidelines } : {}) })),
     });
 }
+function workflowAgentMessage(message) { return message ? { role: message.role, ...(message.content === undefined ? {} : { content: message.content }), ...(message.stopReason === undefined ? {} : { stopReason: message.stopReason }), ...(message.errorMessage === undefined ? {} : { errorMessage: message.errorMessage }), ...(message.usage === undefined ? {} : { usage: message.usage }) } : undefined; }
+function workflowAgentStats(stats) { return { tokens: { input: stats.tokens.input, output: stats.tokens.output, cacheRead: stats.tokens.cacheRead, cacheWrite: stats.tokens.cacheWrite, total: stats.tokens.total }, cost: stats.cost }; }
+function workflowAgentState(native, prepared) {
+    const tools = native.agent?.state.tools.map(({ name }) => name) ?? prepared.tools;
+    const model = native.model?.provider && (native.model.model ?? native.model.id) ? { provider: native.model.provider, model: native.model.model ?? native.model.id ?? prepared.model.model, ...(prepared.model.thinking ? { thinking: prepared.model.thinking } : {}) } : { ...prepared.model };
+    return { model, ...(model.thinking ? { thinking: model.thinking } : {}), tools: [...tools], ...(native.systemPrompt === undefined ? {} : { systemPrompt: native.systemPrompt }) };
+}
+function localSessionEvent(event) { return event; }
+export async function createLocalWorkflowAgentSession(prepared, context) {
+    void context;
+    const input = {
+        cwd: prepared.cwd, model: { ...prepared.model }, tools: [...prepared.tools], sessionLabel: prepared.sessionLabel,
+        ...(prepared.agentDir ? { agentDir: prepared.agentDir } : {}), ...(prepared.customTools?.length ? { customTools: [...prepared.customTools] } : {}),
+        ...(prepared.resultTool ? { resultTool: prepared.resultTool } : {}), ...(prepared.systemPrompt === undefined ? {} : { systemPrompt: prepared.systemPrompt }),
+        ...(prepared.systemPromptAppend ? { systemPromptAppend: prepared.systemPromptAppend } : {}), ...(prepared.extensionFactories?.length ? { extensionFactories: [...prepared.extensionFactories] } : {}),
+        ...(prepared.additionalSkillPaths?.length ? { additionalSkillPaths: [...prepared.additionalSkillPaths] } : {}), ...(prepared.resourcePolicy ? { resourcePolicy: structuredClone(prepared.resourcePolicy) } : {}), ...(prepared.options ? { options: { ...prepared.options } } : {}),
+    };
+    const native = await createLocalPiSession(input);
+    let disposal;
+    let aborting;
+    let prompting;
+    let disposed = false;
+    const startAbort = () => aborting ??= Promise.resolve().then(() => native.abort?.()).then(() => undefined).finally(() => { aborting = undefined; });
+    const reference = { transport: "local", sessionId: native.sessionId, ...(native.sessionFile ? { locator: { sessionFile: native.sessionFile } } : {}) };
+    const session = {
+        reference,
+        getState: () => Object.freeze(workflowAgentState(native, prepared)),
+        getSessionStats: () => workflowAgentStats(native.getSessionStats()),
+        subscribe(listener) { listener({ type: "state_changed", state: workflowAgentState(native, prepared) }); return native.subscribe?.((event) => { listener(localSessionEvent(event)); }) ?? (() => undefined); },
+        getLastAssistant: () => workflowAgentMessage([...native.messages].reverse().find((message) => message.role === "assistant")),
+        async prompt(text) {
+            if (disposed)
+                throw new WorkflowError("INTERNAL_ERROR", "Local workflow session is disposed");
+            const prompt = Promise.resolve().then(async () => { await native.prompt(text); const assistant = workflowAgentMessage([...native.messages].reverse().find((message) => message.role === "assistant")); return assistant ? { assistant } : {}; });
+            prompting = prompt;
+            try {
+                return await prompt;
+            }
+            finally {
+                if (prompting === prompt)
+                    prompting = undefined;
+            }
+        },
+        async steer(text) { if (!native.steer)
+            throw new WorkflowError("INTERNAL_ERROR", "Local workflow session does not support steering"); await native.steer(text); },
+        async abort() { if (disposed)
+            return; await startAbort(); },
+        async dispose() {
+            disposal ??= (async () => {
+                disposed = true;
+                try {
+                    await startAbort();
+                }
+                catch { /* Abort failure must not prevent the prompt from settling. */ }
+                try {
+                    await prompting;
+                }
+                catch { /* Prompt rejection is expected after abort during teardown. */ }
+                native.dispose();
+            })();
+            await disposal;
+        },
+    };
+    return session;
+}
+export const localAgentTransport = Object.freeze({ id: "local", createSession: createLocalWorkflowAgentSession });
 function changedOption(options, baseline, key) { return JSON.stringify(options[key]) !== JSON.stringify(baseline[key]); }
 function validThinking(value) { return typeof value === "string" && ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value); }
 function isChildAgentToolParams(value) {
@@ -136,51 +239,94 @@ function fallbackSetupContext(root, options, signal) {
 function resourcePolicySummary(policy) {
     return { skills: [...policy.effective.skills], extensions: [...policy.effective.extensions], excludedSkills: [...(policy.excludedSkills ?? [])], excludedExtensions: [...(policy.excludedExtensions ?? [])], unmatchedSkills: [...policy.unmatchedSkills], unmatchedExtensions: [...policy.unmatchedExtensions] };
 }
-async function prepareAgentSetup(root, createSession, task, options, resolved, cwd, attempt, signal, customTools, resultTool) {
+function resourcePolicyWidened(ceiling, candidate) {
+    if (!ceiling)
+        return false;
+    if (!candidate)
+        return true;
+    if (!ceiling.projectTrusted && candidate.projectTrusted)
+        return true;
+    return ceiling.effective.skills.some((pattern) => !candidate.effective.skills.includes(pattern)) || ceiling.effective.extensions.some((pattern) => !candidate.effective.extensions.includes(pattern));
+}
+function preparedAgentSession(input) {
+    const prepared = {
+        cwd: input.cwd, model: Object.freeze({ ...input.model }), tools: Object.freeze([...input.tools]), sessionLabel: input.sessionLabel,
+        ...(input.agentDir ? { agentDir: input.agentDir } : {}), ...(input.customTools?.length ? { customTools: Object.freeze([...input.customTools]) } : {}), ...(input.resultTool ? { resultTool: input.resultTool } : {}), ...(input.options ? { options: Object.freeze(structuredClone(input.options)) } : {}),
+        ...(input.systemPrompt === undefined ? {} : { systemPrompt: input.systemPrompt }), ...(input.systemPromptAppend ? { systemPromptAppend: input.systemPromptAppend } : {}),
+        ...(input.extensionFactories?.length ? { extensionFactories: Object.freeze([...input.extensionFactories]) } : {}), ...(input.additionalSkillPaths?.length ? { additionalSkillPaths: Object.freeze([...input.additionalSkillPaths]) } : {}),
+        ...(input.resourcePolicy ? { resourcePolicy: Object.freeze(structuredClone(input.resourcePolicy)) } : {}),
+    };
+    return deepFreeze(prepared);
+}
+function agentSetupSummary(setup, hookNames) {
+    const model = setup.sessionInput.model;
+    return { hookNames: [...hookNames], model: { provider: model.provider, model: model.model, ...(model.thinking ? { thinking: model.thinking } : {}) }, tools: [...setup.sessionInput.tools], cwd: setup.sessionInput.cwd, ...(setup.sessionInput.resourcePolicy ? { disabledAgentResources: resourcePolicySummary(setup.sessionInput.resourcePolicy) } : {}) };
+}
+async function prepareAgentSetup(root, transport, task, options, resolved, cwd, attempt, signal, customTools, resultTool) {
     const setupSignal = signal ?? root.runContext?.signal ?? new AbortController().signal;
     const baselineOptions = structuredClone(options.agentOptions ?? {});
     const baseResourcePolicy = await root.agentResourcePolicy?.();
     const roleExclusions = options.role ? root.agentDefinitions?.[options.role]?.disabledAgentResources : undefined;
     const resourcePolicy = baseResourcePolicy && roleExclusions ? { ...baseResourcePolicy, effective: mergeAgentResourceExclusions(baseResourcePolicy.effective, roleExclusions) } : baseResourcePolicy;
-    const sessionInput = { cwd, model: { ...resolved.model }, tools: [...resolved.tools], sessionLabel: `${options.workflowName}:${options.label}:attempt-${String(attempt)}`, ...(root.agentDir ? { agentDir: root.agentDir } : {}), ...(customTools.length ? { customTools: [...customTools] } : {}), ...(resultTool ? { resultTool } : {}), systemPromptAppend: resolved.systemPromptAppend, ...(resourcePolicy ? { resourcePolicy } : {}), options: structuredClone(baselineOptions) };
-    const setup = { prompt: task, options: sessionInput.options ?? {}, sessionInput, createSession };
+    const resourcePolicyCeiling = resourcePolicy ? structuredClone(resourcePolicy) : undefined;
+    const sessionInput = { cwd, model: { ...resolved.model }, tools: [...resolved.tools], sessionLabel: `${options.workflowName}:${options.label}:attempt-${String(attempt)}`, ...(root.agentDir ? { agentDir: root.agentDir } : {}), ...(root.additionalSkillPaths?.length ? { additionalSkillPaths: [...root.additionalSkillPaths] } : {}), ...(customTools.length ? { customTools: [...customTools] } : {}), ...(resultTool ? { resultTool } : {}), ...(resolved.systemPrompt !== undefined ? { systemPrompt: resolved.systemPrompt } : {}), systemPromptAppend: resolved.systemPromptAppend, ...(resourcePolicy ? { resourcePolicy } : {}), options: structuredClone(baselineOptions) };
+    const setup = { prompt: task, options: sessionInput.options ?? {}, sessionInput, prepared: preparedAgentSession(sessionInput), transport };
     const base = fallbackSetupContext(root, options, setupSignal);
     const context = Object.freeze({ run: base.run, identity: base.identity, attempt, signal: setupSignal });
     const hookNames = [];
     for (const hook of [...(root.agentSetupHooks ?? [])].sort((left, right) => left.priority - right.priority || (left.name < right.name ? -1 : left.name > right.name ? 1 : 0))) {
         if (setupSignal.aborted)
-            throw new WorkflowError("CANCELLED", "Agent cancelled");
+            return { setup, summary: agentSetupSummary(setup, hookNames), failure: { error: new WorkflowError("CANCELLED", "Agent cancelled") } };
         try {
             await hook.setup(setup, context);
         }
         catch (error) {
-            if (setupSignal.reason !== undefined)
-                throw new WorkflowError("CANCELLED", "Agent cancelled");
-            throw error;
+            setup.prepared = preparedAgentSession(setup.sessionInput);
+            return { setup, summary: agentSetupSummary(setup, hookNames), failure: { error: setupSignal.reason !== undefined ? new WorkflowError("CANCELLED", "Agent cancelled") : error } };
         }
+        setup.prepared = preparedAgentSession(setup.sessionInput);
         hookNames.push(hook.name);
         if (setupSignal.reason !== undefined)
-            throw new WorkflowError("CANCELLED", "Agent cancelled");
-    }
-    setup.sessionInput.options = setup.options;
-    if (changedOption(setup.options, baselineOptions, "model") && typeof setup.options.model === "string")
-        setup.sessionInput.model = parseModel(setup.options.model, setup.sessionInput.model, changedOption(setup.options, baselineOptions, "thinking") && validThinking(setup.options.thinking) ? setup.options.thinking : undefined, root.modelAliases, root.knownModels ?? root.availableModels, root.settingsPath);
-    if (changedOption(setup.options, baselineOptions, "thinking") && validThinking(setup.options.thinking))
-        setup.sessionInput.model = { ...setup.sessionInput.model, thinking: setup.options.thinking };
-    if (changedOption(setup.options, baselineOptions, "tools") && Array.isArray(setup.options.tools) && setup.options.tools.every((tool) => typeof tool === "string"))
-        setup.sessionInput.tools = [...setup.options.tools];
-    if (changedOption(setup.options, baselineOptions, "cwd") && typeof setup.options.cwd === "string")
-        setup.sessionInput.cwd = setup.options.cwd;
-    const model = setup.sessionInput.model;
-    const summary = { hookNames: [...hookNames], model: { provider: model.provider, model: model.model, ...(model.thinking ? { thinking: model.thinking } : {}) }, tools: [...setup.sessionInput.tools], cwd: setup.sessionInput.cwd, ...(setup.sessionInput.resourcePolicy ? { disabledAgentResources: resourcePolicySummary(setup.sessionInput.resourcePolicy) } : {}) };
-    return { setup, summary };
+            return { setup, summary: agentSetupSummary(setup, hookNames), failure: { error: new WorkflowError("CANCELLED", "Agent cancelled") } };
+    }
+    try {
+        if (resourcePolicyWidened(resourcePolicyCeiling, setup.sessionInput.resourcePolicy))
+            throw new WorkflowError("INVALID_METADATA", "Agent setup widened the prepared resource policy");
+        setup.sessionInput.options = setup.options;
+        if (changedOption(setup.options, baselineOptions, "model") && typeof setup.options.model === "string")
+            setup.sessionInput.model = parseModel(setup.options.model, setup.sessionInput.model, changedOption(setup.options, baselineOptions, "thinking") && validThinking(setup.options.thinking) ? setup.options.thinking : undefined, root.modelAliases, root.knownModels ?? root.availableModels, root.settingsPath);
+        if (changedOption(setup.options, baselineOptions, "thinking") && validThinking(setup.options.thinking))
+            setup.sessionInput.model = { ...setup.sessionInput.model, thinking: setup.options.thinking };
+        if (changedOption(setup.options, baselineOptions, "tools") && Array.isArray(setup.options.tools) && setup.options.tools.every((tool) => typeof tool === "string"))
+            setup.sessionInput.tools = [...setup.options.tools];
+        if (changedOption(setup.options, baselineOptions, "cwd") && typeof setup.options.cwd === "string")
+            setup.sessionInput.cwd = setup.options.cwd;
+        const customToolNames = new Set([...(setup.sessionInput.customTools ?? []).map(({ name }) => name), ...(setup.sessionInput.resultTool ? [setup.sessionInput.resultTool.name] : [])]);
+        const widened = setup.sessionInput.tools.find((tool) => !resolved.tools.includes(tool) && !customToolNames.has(tool));
+        const outsideTool = widened ?? setup.sessionInput.tools.find((tool) => !root.tools.has(tool) && !customToolNames.has(tool));
+        if (outsideTool)
+            throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the prepared agent policy: ${outsideTool}`);
+    }
+    catch (error) {
+        setup.prepared = preparedAgentSession(setup.sessionInput);
+        return { setup, summary: agentSetupSummary(setup, hookNames), failure: { error } };
+    }
+    setup.prepared = preparedAgentSession(setup.sessionInput);
+    return { setup, summary: agentSetupSummary(setup, hookNames) };
+}
+function attemptRecord(transport, attempt, session, setup, stats, result, error) {
+    return { attempt, transport, session: session.reference, ...(result === undefined ? {} : { result }), ...(error ? { error } : {}), accounting: stats, setup };
+}
+function errorWithAttempts(error, attempts) {
+    const typed = error instanceof Error ? error : new Error(typeof error === "string" ? error : String(error));
+    return Object.assign(typed, { attempts });
 }
 export class WorkflowAgentExecutor {
     root;
-    createSession;
-    constructor(root, createSession = createNativeAgentSession) {
+    transport;
+    constructor(root, transport = localAgentTransport) {
         this.root = root;
-        this.createSession = createSession;
+        this.transport = transport;
     }
     setRunContext(runContext) { this.root.runContext = runContext; }
     resolve(options, inheritedTools) {
@@ -206,7 +352,8 @@ export class WorkflowAgentExecutor {
         const availableModels = this.root.knownModels ?? this.root.availableModels ?? new Set([modelCapability(this.root.model)]);
         if (!availableModels.has(modelCapability(model)))
             throw new WorkflowError("UNKNOWN_MODEL", `Unknown model${requestedModel ? ` ${requestedModel} resolved to ${modelCapability(model)}` : ""}${this.root.settingsPath ? ` (settings: ${this.root.settingsPath})` : ""}`);
-        return { model, ...(alias && requestedModel ? { requestedModel } : {}), tools: [...requested], systemPromptAppend: definition?.prompt ?? "" };
+        const overrideSystemPrompt = definition?.overrideSystemPrompt === true;
+        return { model, ...(alias && requestedModel ? { requestedModel } : {}), tools: [...requested], ...(overrideSystemPrompt ? { systemPrompt: definition.prompt ?? "" } : {}), systemPromptAppend: overrideSystemPrompt ? "" : definition?.prompt ?? "" };
     }
     async execute(task, options, signal, customTools = [], setSteer, beforeRetry) {
         const executionSignal = signal ?? this.root.runContext?.signal;
@@ -247,16 +394,16 @@ export class WorkflowAgentExecutor {
         const attempts = [];
         let maxAttempts = (options.retries ?? 0) + 1;
         for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            const attemptSignal = executionSignal ?? new AbortController().signal;
             if (recoveryModel)
                 resolved = this.resolve({ ...options, modelOverride: recoveryModel });
             options.budget?.beforeAttempt();
             let schemaResult;
             let session;
             let setup;
-            let setupSummary;
+            let setupSummary = { hookNames: [], model: { ...resolved.model }, tools: [...resolved.tools], cwd };
             let setupFailed = false;
             let budgetError;
-            let turnStarted = false;
             const hasSchemaResult = () => schemaResult !== undefined;
             const resultTool = options.schema ? {
                 name: "workflow_result", label: "Workflow Result", description: "Submit the terminal structured workflow result", parameters: Type.Unsafe(options.schema),
@@ -266,17 +413,23 @@ export class WorkflowAgentExecutor {
                     if (schemaResult !== undefined)
                         return { content: [{ type: "text", text: "Result has already been accepted." }], details: {}, isError: true };
                     schemaResult = structuredClone(value);
-                    void session?.abort?.();
+                    const currentSession = session;
+                    if (currentSession)
+                        void currentSession.abort();
                     return { content: [{ type: "text", text: "Result accepted." }], details: {} };
                 },
             } : undefined;
             const toolCalls = new Map();
             let activity;
+            let lastEventAt;
+            let lastReportedEventAt;
             let progress = Promise.resolve();
             let unsubscribe;
             let systemPromptTurn = 0;
             let systemPromptWrite = Promise.resolve();
             let systemPromptWriteError;
+            let turnStarted = false;
+            let completedAttempt;
             const flushSystemPrompts = async () => {
                 await systemPromptWrite;
                 if (systemPromptWriteError)
@@ -285,33 +438,85 @@ export class WorkflowAgentExecutor {
             const report = (persist) => {
                 if (!session || !options.onProgress)
                     return;
-                const update = { accounting: accounting(session.getSessionStats()), toolCalls: [...toolCalls.values()], ...(activity ? { activity } : {}), persist };
+                const update = { accounting: accounting(session.getSessionStats()), toolCalls: [...toolCalls.values()], state: session.getState(), ...(activity ? { activity } : {}), ...(lastEventAt === undefined ? {} : { lastEventAt }), persist };
+                if (lastEventAt !== undefined)
+                    lastReportedEventAt = lastEventAt;
                 progress = progress.then(() => options.onProgress?.(update)).then(() => undefined);
             };
+            const reportTimestamp = () => {
+                if (lastEventAt !== undefined && lastReportedEventAt !== undefined && lastEventAt - lastReportedEventAt < 1000)
+                    return;
+                report(false);
+            };
+            const activityChanged = (previous) => previous?.kind !== activity?.kind || previous?.text !== activity?.text;
             try {
                 setupFailed = true;
-                const prepared = await prepareAgentSetup(this.root, this.createSession, task, options, resolved, cwd, attempt, executionSignal, customTools, resultTool);
+                const prepared = await prepareAgentSetup(this.root, this.transport, task, options, resolved, cwd, attempt, attemptSignal, customTools, resultTool);
                 setup = prepared.setup;
                 setupSummary = prepared.summary;
+                if (prepared.failure)
+                    throw prepared.failure.error;
                 setupFailed = false;
-                if (executionSignal?.aborted)
+                if (attemptSignal.aborted)
                     throw new WorkflowError("CANCELLED", "Agent cancelled");
                 const started = Date.now();
-                session = await setup.createSession(setup.sessionInput);
+                const transportSignal = attemptSignal;
+                await options.onAttempt?.({ attempt, transport: setup.transport.id, accounting: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }, setup: setupSummary });
+                const transportBase = fallbackSetupContext(this.root, options, transportSignal);
+                const createdSession = await setup.transport.createSession(setup.prepared, Object.freeze({ run: transportBase.run, identity: transportBase.identity, attempt, signal: transportSignal }));
+                if (createdSession.reference.transport !== setup.transport.id) {
+                    await createdSession.dispose();
+                    throw new WorkflowError("INTERNAL_ERROR", `Agent transport ${setup.transport.id} created a session for ${createdSession.reference.transport}`);
+                }
+                session = createdSession;
+                await options.onAttempt?.({ attempt, transport: setup.transport.id, session: session.reference, liveSession: session, accounting: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }, setup: setupSummary });
+                const preparedTools = new Set([...setup.prepared.tools, ...(setup.prepared.customTools ?? []).map(({ name }) => name), ...(setup.prepared.resultTool ? [setup.prepared.resultTool.name] : [])]);
+                if (session.getState().tools.some((tool) => !preparedTools.has(tool)))
+                    throw new WorkflowError("INTERNAL_ERROR", `Agent transport ${setup.transport.id} widened the prepared tool policy`);
                 if (setup.sessionInput.resourcePolicy)
                     setupSummary = { ...setupSummary, disabledAgentResources: resourcePolicySummary(setup.sessionInput.resourcePolicy) };
-                const includeAttemptSetup = Boolean(this.root.agentSetupHooks?.length || setup.sessionInput.resourcePolicy);
-                await options.onAttempt?.({ attempt, sessionId: session.sessionId, sessionFile: requiredFile(session.sessionFile), ...(includeAttemptSetup ? { setup: setupSummary } : {}) });
                 const activeSession = session;
-                unsubscribe = activeSession.subscribe?.((event) => {
-                    if (event.type === "agent_start" && session?.systemPrompt !== undefined) {
+                let lastAssistant;
+                const recoverTerminal = () => recoverTerminalProviderError(activeSession, options.label, options.providerErrorRecovery, async () => { try {
+                    lastAssistant = (await promptWithProviderPause(activeSession, providerContinuationPrompt, remaining(options.timeoutMs, started), attemptSignal, this.root.providerPause)).assistant;
+                }
+                catch (error) {
+                    lastAssistant = activeSession.getLastAssistant?.() ?? lastAssistant;
+                    if (!hasSchemaResult())
+                        throw error;
+                } }, () => lastAssistant);
+                const promptAndRecover = async (prompt) => {
+                    let promptFailed = false;
+                    let promptError;
+                    try {
+                        lastAssistant = (await promptWithProviderPause(activeSession, prompt, remaining(options.timeoutMs, started), attemptSignal, this.root.providerPause)).assistant;
+                    }
+                    catch (error) {
+                        lastAssistant = activeSession.getLastAssistant?.() ?? lastAssistant;
+                        promptFailed = true;
+                        promptError = error;
+                    }
+                    const recovered = await recoverTerminal();
+                    if (promptFailed && !hasSchemaResult() && !recovered)
+                        throw promptError;
+                };
+                unsubscribe = activeSession.subscribe((event) => {
+                    lastEventAt = Date.now();
+                    let persist = false;
+                    let shouldReport = false;
+                    let removeToolCallId;
+                    if (event.type === "agent_start" && session?.getState().systemPrompt !== undefined) {
                         if (this.root.runStore) {
                             systemPromptTurn += 1;
-                            const entry = { sessionId: session.sessionId, attempt, turn: systemPromptTurn, prompt: session.systemPrompt };
+                            const entry = { sessionId: session.reference.sessionId, attempt, turn: systemPromptTurn, prompt: session.getState().systemPrompt ?? "" };
                             systemPromptWrite = systemPromptWrite.then(() => this.root.runStore?.recordSystemPrompt(entry)).then(() => undefined).catch((error) => { systemPromptWriteError ??= error; });
                         }
                     }
-                    if (event.type === "message_start" && event.message.role === "assistant") {
+                    if (event.type === "state_changed") {
+                        shouldReport = true;
+                        persist = true;
+                    }
+                    if (event.type === "turnStarted" || event.type === "turn_started") {
                         if (!turnStarted) {
                             try {
                                 options.budget?.beforeTurn();
@@ -319,15 +524,39 @@ export class WorkflowAgentExecutor {
                             }
                             catch (error) {
                                 budgetError ??= error instanceof WorkflowError ? error : new WorkflowError("BUDGET_EXHAUSTED", error instanceof Error ? error.message : String(error));
-                                void session?.abort?.();
+                                void activeSession.abort();
+                            }
+                        }
+                    }
+                    if (event.type === "message_start" && event.message?.role === "assistant") {
+                        if (!turnStarted) {
+                            try {
+                                options.budget?.beforeTurn();
+                                turnStarted = true;
+                            }
+                            catch (error) {
+                                budgetError ??= error instanceof WorkflowError ? error : new WorkflowError("BUDGET_EXHAUSTED", error instanceof Error ? error.message : String(error));
+                                void activeSession.abort();
                             }
                         }
                         activity = { kind: "text", text: "responding" };
-                        report(false);
+                        shouldReport = true;
+                    }
+                    if (event.type === "message_update") {
+                        const previousActivity = activity;
+                        const updateType = event.assistantMessageEvent?.type;
+                        if (updateType && ["thinking_start", "thinking_delta", "thinking_end"].includes(updateType))
+                            activity = { kind: "reasoning", text: "reasoning" };
+                        else if (updateType && ["text_start", "text_delta", "text_end", "toolcall_start", "toolcall_delta", "toolcall_end"].includes(updateType))
+                            activity = { kind: "text", text: "responding" };
+                        shouldReport = activityChanged(previousActivity);
                     }
                     if (event.type === "message_end") {
+                        const previousActivity = activity;
                         activity = undefined;
-                        if (event.message.role === "assistant") {
+                        shouldReport = activityChanged(previousActivity);
+                        if (event.message?.role === "assistant") {
+                            lastAssistant = event.message;
                             const needsMoreWork = hasToolCall(event.message);
                             const final = !needsMoreWork || (options.schema !== undefined && hasSchemaResult());
                             if (!budgetError) {
@@ -336,113 +565,118 @@ export class WorkflowAgentExecutor {
                                     if (!final) {
                                         const instruction = options.budget?.instruction();
                                         if (instruction)
-                                            void session?.steer?.(instruction);
+                                            void activeSession.steer(instruction);
                                     }
                                 }
                                 catch (error) {
                                     budgetError ??= error instanceof WorkflowError ? error : new WorkflowError("BUDGET_EXHAUSTED", error instanceof Error ? error.message : String(error));
-                                    void session?.abort?.();
+                                    void activeSession.abort();
                                 }
                             }
                             turnStarted = false;
-                            report(true);
+                            persist = true;
                         }
                     }
-                    if (event.type === "tool_execution_start") {
+                    if (event.type === "tool_execution_start" && event.toolCallId && event.toolName) {
                         toolCalls.set(event.toolCallId, { id: event.toolCallId, name: event.toolName, state: "running" });
                         activity = { kind: "tool", text: event.toolName };
-                        report(false);
+                        shouldReport = true;
+                    }
+                    if (event.type === "tool_execution_update" && event.toolName) {
+                        const previousActivity = activity;
+                        activity = { kind: "tool", text: event.toolName };
+                        shouldReport = activityChanged(previousActivity);
                     }
-                    if (event.type === "tool_execution_end") {
+                    if (event.type === "tool_execution_end" && event.toolCallId && event.toolName) {
                         toolCalls.set(event.toolCallId, { id: event.toolCallId, name: event.toolName, state: event.isError ? "failed" : "completed" });
                         if (activity?.kind === "tool" && activity.text === event.toolName)
                             activity = undefined;
-                        report(false);
-                        toolCalls.delete(event.toolCallId);
+                        shouldReport = true;
+                        removeToolCallId = event.toolCallId;
                     }
+                    if (shouldReport || persist)
+                        report(persist);
+                    else
+                        reportTimestamp();
+                    if (removeToolCallId)
+                        toolCalls.delete(removeToolCallId);
                 });
                 report(false);
                 if (setSteer) {
-                    if (!session.steer)
-                        throw new WorkflowError("INTERNAL_ERROR", "Native Pi session does not support steering");
-                    setSteer((message) => session?.steer?.(message));
+                    setSteer((message) => activeSession.steer(message));
                 }
                 const context = [`Workflow: ${options.workflowName}`, `Agent: ${options.label}`, options.phase ? `Phase: ${options.phase}` : "", options.parent ? `Parent: ${options.parent}` : "", "You own this task and any direct child agents you create. Return child results to your parent; do not leave descendants running.", attempt > 1 ? `Retry attempt ${String(attempt)}. Previous state: ${options.retryState ?? attempts.at(-1)?.error?.message ?? "failed attempt"}` : ""].filter(Boolean).join("\n");
                 const instruction = options.budget?.instruction();
                 const promptText = `${context}\n\nTask:\n${setup.prompt}${instruction ? `\n\n${instruction}` : ""}`;
                 options.budget?.beforeTurn();
                 turnStarted = true;
-                try {
-                    await promptWithProviderPause(session, promptText, remaining(options.timeoutMs, started), executionSignal, this.root.providerPause);
-                }
-                catch (error) {
-                    if (!hasSchemaResult())
-                        throw error;
-                }
-                throwIfTerminalAssistantError(session, setup.sessionInput.model);
+                await promptAndRecover(promptText);
                 {
                     const completedAccounting = accounting(session.getSessionStats());
-                    options.budget?.afterTurn(completedAccounting, options.schema !== undefined ? hasSchemaResult() : !latestAssistantHasToolCall(session.messages));
+                    options.budget?.afterTurn(completedAccounting, options.schema !== undefined ? hasSchemaResult() : !latestAssistantHasToolCall(lastAssistant));
                     turnStarted = false;
                 }
                 if (budgetError)
                     throw budgetError;
                 if (options.schema) {
                     if (!hasSchemaResult()) {
-                        try {
-                            options.budget?.beforeTurn();
-                            turnStarted = true;
-                            await promptWithProviderPause(session, "Submit the final result now by calling workflow_result exactly once. Do not return prose.", remaining(options.timeoutMs, started), executionSignal, this.root.providerPause);
-                            {
-                                const completedAccounting = accounting(session.getSessionStats());
-                                options.budget?.afterTurn(completedAccounting, true);
-                                turnStarted = false;
-                            }
-                        }
-                        catch (error) {
-                            if (!hasSchemaResult())
-                                throw error;
+                        options.budget?.beforeTurn();
+                        turnStarted = true;
+                        await promptAndRecover("Submit the final result now by calling workflow_result exactly once. Do not return prose.");
+                        {
+                            const completedAccounting = accounting(session.getSessionStats());
+                            options.budget?.afterTurn(completedAccounting, true);
+                            turnStarted = false;
                         }
                     }
-                    throwIfTerminalAssistantError(session, setup.sessionInput.model);
                     if (!hasSchemaResult()) {
-                        try {
-                            options.budget?.beforeTurn();
-                            turnStarted = true;
-                            await promptWithProviderPause(session, "Your result was missing or invalid. Repair it by calling workflow_result exactly once with a schema-valid value.", remaining(options.timeoutMs, started), executionSignal, this.root.providerPause);
-                            {
-                                const completedAccounting = accounting(session.getSessionStats());
-                                options.budget?.afterTurn(completedAccounting, true);
-                                turnStarted = false;
-                            }
-                        }
-                        catch (error) {
-                            if (!hasSchemaResult())
-                                throw error;
+                        options.budget?.beforeTurn();
+                        turnStarted = true;
+                        await promptAndRecover("Your result was missing or invalid. Repair it by calling workflow_result exactly once with a schema-valid value.");
+                        {
+                            const completedAccounting = accounting(session.getSessionStats());
+                            options.budget?.afterTurn(completedAccounting, true);
+                            turnStarted = false;
                         }
-                        throwIfTerminalAssistantError(session, setup.sessionInput.model);
                     }
                     if (schemaResult === undefined)
                         throw new WorkflowError("RESULT_INVALID", "Agent did not submit a valid workflow_result after one repair");
                 }
-                const value = options.schema ? schemaResult : text(session.messages);
+                const value = options.schema ? schemaResult : text(lastAssistant);
                 if (options.worktreeOwner)
                     await this.root.runStore?.snapshotWorktree(options.worktreeOwner);
                 report(true);
                 await progress;
                 await flushSystemPrompts();
-                unsubscribe?.();
+                unsubscribe();
                 const attemptAccounting = accounting(session.getSessionStats());
-                const includeCompletedSetup = Boolean(this.root.agentSetupHooks?.length || setup.sessionInput.resourcePolicy);
-                attempts.push({ attempt, sessionId: session.sessionId, sessionFile: requiredFile(session.sessionFile), result: value, accounting: attemptAccounting, ...(includeCompletedSetup ? { setup: setupSummary } : {}) });
-                session.dispose();
+                completedAttempt = attemptRecord(setup.transport.id, attempt, session, setupSummary, attemptAccounting, value);
+                attempts.push(completedAttempt);
+                try {
+                    await options.onAttempt?.(completedAttempt);
+                }
+                finally {
+                    await session.dispose();
+                }
                 return { value, attempts, cwd: setupSummary.cwd };
             }
             catch (error) {
-                const typed = budgetError ?? (error instanceof WorkflowError ? error : new WorkflowError(executionSignal?.aborted && setupFailed ? "CANCELLED" : "AGENT_FAILED", error instanceof Error ? error.message : String(error)));
+                if (completedAttempt)
+                    throw errorWithAttempts(error, attempts);
+                const typed = budgetError ?? (error instanceof WorkflowError ? error : new WorkflowError(attemptSignal.aborted && setupFailed ? "CANCELLED" : "AGENT_FAILED", error instanceof Error ? error.message : String(error)));
+                if (!session) {
+                    const failedAttempt = { attempt, transport: setup?.transport.id ?? this.transport.id, accounting: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }, error: { code: typed.code, message: typed.message }, setup: setupSummary };
+                    attempts.push(failedAttempt);
+                    try {
+                        await options.onAttempt?.(failedAttempt);
+                    }
+                    catch (persistenceError) {
+                        throw errorWithAttempts(persistenceError, attempts);
+                    }
+                }
                 if (session) {
                     report(true);
-                    await progress;
+                    await progress.catch(() => undefined);
                     try {
                         await flushSystemPrompts();
                     }
@@ -457,36 +691,52 @@ export class WorkflowAgentExecutor {
                             budgetError ??= budgetFailure instanceof WorkflowError ? budgetFailure : new WorkflowError("BUDGET_EXHAUSTED", budgetFailure instanceof Error ? budgetFailure.message : String(budgetFailure));
                         }
                     }
-                    const includeFailedSetup = Boolean(this.root.agentSetupHooks?.length || setup?.sessionInput.resourcePolicy);
-                    attempts.push({ attempt, sessionId: session.sessionId, sessionFile: requiredFile(session.sessionFile), error: { code: typed.code, message: typed.message }, accounting: attemptAccounting, ...(includeFailedSetup && setupSummary ? { setup: setupSummary } : {}) });
-                    session.dispose();
+                    const failedAttempt = attemptRecord(setup?.transport.id ?? this.transport.id, attempt, session, setupSummary, attemptAccounting, undefined, { code: typed.code, message: typed.message });
+                    attempts.push(failedAttempt);
+                    try {
+                        try {
+                            await options.onAttempt?.(failedAttempt);
+                        }
+                        finally {
+                            await session.dispose();
+                        }
+                    }
+                    catch (persistenceError) {
+                        throw errorWithAttempts(persistenceError, attempts);
+                    }
                 }
                 if (options.worktreeOwner && typed.code !== "WORKTREE_FAILED")
                     await this.root.runStore?.snapshotWorktree(options.worktreeOwner).catch(() => undefined);
                 const terminal = terminalProviderError(typed);
-                if (terminal && options.providerErrorRecovery) {
-                    let recovery;
+                const recoveryState = typed;
+                let recovery = recoveryState.providerRecovery;
+                if (terminal && options.providerErrorRecovery && !recoveryState.providerRecoveryHandled) {
                     try {
                         recovery = await options.providerErrorRecovery({ label: options.label, ...terminal });
                     }
                     catch {
                         throw Object.assign(typed, { attempts });
                     }
-                    if (recovery === "retry" || typeof recovery === "object" && typeof recovery.model === "string") {
-                        if (typeof recovery === "object") {
-                            try {
-                                const selected = resolveModelReference(recovery.model, this.root.modelAliases, this.root.knownModels ?? this.root.availableModels, this.root.settingsPath);
-                                recoveryModel = selected.thinking === undefined && resolved.model.thinking ? { ...selected, thinking: resolved.model.thinking } : selected;
-                            }
-                            catch {
-                                throw Object.assign(typed, { attempts });
-                            }
-                        }
+                    if (recovery === "retry") {
                         maxAttempts += 1;
                         beforeRetry?.();
                         continue;
                     }
                 }
+                if (recoveryState.providerRecoveryFailed || recovery === "abort")
+                    throw Object.assign(typed, { attempts });
+                if (typeof recovery === "object" && typeof recovery.model === "string") {
+                    try {
+                        const selected = resolveModelReference(recovery.model, this.root.modelAliases, this.root.knownModels ?? this.root.availableModels, this.root.settingsPath);
+                        recoveryModel = selected.thinking === undefined && resolved.model.thinking ? { ...selected, thinking: resolved.model.thinking } : selected;
+                    }
+                    catch {
+                        throw Object.assign(typed, { attempts });
+                    }
+                    maxAttempts += 1;
+                    beforeRetry?.();
+                    continue;
+                }
                 if (attempt === maxAttempts || setupFailed || typed.code === "CANCELLED" || typed.code === "WORKTREE_FAILED" || typed.code === "RESUME_INCOMPATIBLE")
                     throw Object.assign(typed, { attempts });
                 beforeRetry?.();
@@ -541,7 +791,7 @@ export class FairAgentScheduler {
         const id = `${runId}:${String(++this.#nextId)}`;
         let resolveResult = () => undefined;
         const promise = new Promise((resolve) => { resolveResult = resolve; });
-        const node = { id, runId, ...(parentId ? { parentId } : {}), options: effective, children: new Set(), collected: false, state: "queued", controller: new AbortController(), promise, resolve: resolveResult, task: async () => undefined, restored: false };
+        const node = { id, runId, ...(parentId ? { parentId } : {}), prompt, options: effective, children: new Set(), collected: false, state: "queued", controller: new AbortController(), promise, resolve: resolveResult, task: async () => undefined, restored: false };
         node.task = async () => {
             if (node.controller.signal.aborted) {
                 this.#release(node.runId);
@@ -680,7 +930,7 @@ export class FairAgentScheduler {
         return [agentTool, resultTool, steerTool];
     }
     snapshot() {
-        return [...this.#nodes.values()].map(({ id, parentId, options, state }) => ({ id, ...(parentId ? { parentId } : {}), label: options.label, state, options }));
+        return [...this.#nodes.values()].map(({ id, parentId, prompt, options, state }) => ({ id, ...(parentId ? { parentId } : {}), ...(prompt === undefined ? {} : { prompt }), label: options.label, state, options }));
     }
     restoreRun(runId, limit, ownership, beforeLaunch) {
         this.addRun(runId, limit, beforeLaunch);
@@ -690,7 +940,7 @@ export class FairAgentScheduler {
                 throw new WorkflowError("RESUME_INCOMPATIBLE", `Persisted agent belongs to another run: ${record.id}`);
             let resolveResult = () => undefined;
             const promise = new Promise((resolve) => { resolveResult = resolve; });
-            const node = { id: record.id, runId, ...(record.parentId ? { parentId: record.parentId } : {}), options: this.#inherit(undefined, record.options), children: new Set(), collected: false, state: record.state, controller: new AbortController(), promise, resolve: resolveResult, task: async () => undefined, restored: true };
+            const node = { id: record.id, runId, ...(record.parentId ? { parentId: record.parentId } : {}), ...(record.prompt === undefined ? {} : { prompt: record.prompt }), options: this.#inherit(undefined, record.options), children: new Set(), collected: false, state: record.state, controller: new AbortController(), promise, resolve: resolveResult, task: async () => undefined, restored: true };
             this.#nodes.set(node.id, node);
             run.logical += 1;
             this.#nextId = Math.max(this.#nextId, Number(node.id.slice(node.id.lastIndexOf(":") + 1)) || 0);
@@ -801,11 +1051,6 @@ export class FairAgentScheduler {
     }
 }
 function resolvePath(path) { return path.replace(/[\\/]+$/, ""); }
-function requiredFile(file) {
-    if (!file)
-        throw new WorkflowError("INTERNAL_ERROR", "Workflow agents require persisted native Pi sessions");
-    return file;
-}
 function remaining(timeoutMs, started) {
     return timeoutMs === null || timeoutMs === undefined ? timeoutMs : Math.max(1, timeoutMs - (Date.now() - started));
 }
@@ -818,8 +1063,7 @@ function providerLimited(error) {
 async function promptWithProviderPause(session, text, timeoutMs, signal, pause) {
     for (;;) {
         try {
-            await withTimeout(session.prompt(text), timeoutMs, signal, session);
-            return;
+            return await withTimeout(session.prompt(text), timeoutMs, signal, session);
         }
         catch (error) {
             if (!pause || !providerLimited(error))
@@ -837,7 +1081,7 @@ async function withTimeout(work, timeoutMs, signal, session) {
     const timeout = timeoutMs ? new Promise((_, reject) => { timer = setTimeout(() => { state.interrupted = true; reject(new WorkflowError("AGENT_TIMEOUT", "Agent attempt timed out")); }, timeoutMs); }) : new Promise(() => { });
     const cancelled = signal ? new Promise((_, reject) => { abort = () => { state.interrupted = true; reject(new WorkflowError("CANCELLED", "Agent cancelled")); }; signal.addEventListener("abort", abort, { once: true }); }) : new Promise(() => { });
     try {
-        await Promise.race([work, timeout, cancelled]);
+        return await Promise.race([work, timeout, cancelled]);
     }
     finally {
         if (timer)
@@ -845,6 +1089,6 @@ async function withTimeout(work, timeoutMs, signal, session) {
         if (abort)
             signal?.removeEventListener("abort", abort);
         if (state.interrupted)
-            await session.abort?.();
+            await session.abort();
     }
 }