pi-extensible-workflows 3.3.0 → 3.4.0

package/dist/src/agent-execution.js

@@ -4,7 +4,7 @@ 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)
@@ -12,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("");
@@ -21,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) {
@@ -44,11 +38,11 @@ function terminalProviderError(error) {
     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, fallbackModel, label, recovery, continuePrompt) {
+async function recoverTerminalProviderError(session, label, recovery, continuePrompt, getAssistant) {
     let continued = false;
     for (;;) {
         try {
-            throwIfTerminalAssistantError(session, fallbackModel);
+            throwIfTerminalAssistantError(session, getAssistant());
             return continued;
         }
         catch (error) {
@@ -91,7 +85,7 @@ function workflowSystemPromptPath(cwd, agentDir, projectTrusted) {
     const globalPaths = [join(homedir(), ".pi", WORKFLOW_DIRECTORY, "SYSTEM.md"), join(agentDir, WORKFLOW_DIRECTORY, "SYSTEM.md")];
     return globalPaths.find((path) => existsSync(path));
 }
-export async function createNativeAgentSession(input) {
+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 } : {};
@@ -150,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) {
@@ -179,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 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, createSession };
+    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) {
@@ -291,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),
@@ -310,7 +413,9 @@ 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;
@@ -323,6 +428,8 @@ export class WorkflowAgentExecutor {
             let systemPromptTurn = 0;
             let systemPromptWrite = Promise.resolve();
             let systemPromptWriteError;
+            let turnStarted = false;
+            let completedAttempt;
             const flushSystemPrompts = async () => {
                 await systemPromptWrite;
                 if (systemPromptWriteError)
@@ -331,7 +438,7 @@ export class WorkflowAgentExecutor {
             const report = (persist) => {
                 if (!session || !options.onProgress)
                     return;
-                const update = { accounting: accounting(session.getSessionStats()), toolCalls: [...toolCalls.values()], ...(activity ? { activity } : {}), ...(lastEventAt === undefined ? {} : { lastEventAt }), 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);
@@ -344,34 +451,48 @@ export class WorkflowAgentExecutor {
             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;
-                const sessionModel = setup.sessionInput.model;
-                const recoverTerminal = () => recoverTerminalProviderError(activeSession, sessionModel, options.label, options.providerErrorRecovery, async () => { try {
-                    await promptWithProviderPause(activeSession, providerContinuationPrompt, remaining(options.timeoutMs, started), executionSignal, this.root.providerPause);
+                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 {
-                        await promptWithProviderPause(activeSession, prompt, remaining(options.timeoutMs, started), executionSignal, this.root.providerPause);
+                        lastAssistant = (await promptWithProviderPause(activeSession, prompt, remaining(options.timeoutMs, started), attemptSignal, this.root.providerPause)).assistant;
                     }
                     catch (error) {
+                        lastAssistant = activeSession.getLastAssistant?.() ?? lastAssistant;
                         promptFailed = true;
                         promptError = error;
                     }
@@ -379,19 +500,35 @@ export class WorkflowAgentExecutor {
                     if (promptFailed && !hasSchemaResult() && !recovered)
                         throw promptError;
                 };
-                unsubscribe = activeSession.subscribe?.((event) => {
+                unsubscribe = activeSession.subscribe((event) => {
                     lastEventAt = Date.now();
                     let persist = false;
                     let shouldReport = false;
                     let removeToolCallId;
-                    if (event.type === "agent_start" && session?.systemPrompt !== undefined) {
+                    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();
+                                turnStarted = true;
+                            }
+                            catch (error) {
+                                budgetError ??= error instanceof WorkflowError ? error : new WorkflowError("BUDGET_EXHAUSTED", error instanceof Error ? error.message : String(error));
+                                void activeSession.abort();
+                            }
+                        }
+                    }
+                    if (event.type === "message_start" && event.message?.role === "assistant") {
                         if (!turnStarted) {
                             try {
                                 options.budget?.beforeTurn();
@@ -399,7 +536,7 @@ 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();
                             }
                         }
                         activity = { kind: "text", text: "responding" };
@@ -407,9 +544,10 @@ export class WorkflowAgentExecutor {
                     }
                     if (event.type === "message_update") {
                         const previousActivity = activity;
-                        if (["thinking_start", "thinking_delta", "thinking_end"].includes(event.assistantMessageEvent.type))
+                        const updateType = event.assistantMessageEvent?.type;
+                        if (updateType && ["thinking_start", "thinking_delta", "thinking_end"].includes(updateType))
                             activity = { kind: "reasoning", text: "reasoning" };
-                        else if (["text_start", "text_delta", "text_end", "toolcall_start", "toolcall_delta", "toolcall_end"].includes(event.assistantMessageEvent.type))
+                        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);
                     }
@@ -417,7 +555,8 @@ export class WorkflowAgentExecutor {
                         const previousActivity = activity;
                         activity = undefined;
                         shouldReport = activityChanged(previousActivity);
-                        if (event.message.role === "assistant") {
+                        if (event.message?.role === "assistant") {
+                            lastAssistant = event.message;
                             const needsMoreWork = hasToolCall(event.message);
                             const final = !needsMoreWork || (options.schema !== undefined && hasSchemaResult());
                             if (!budgetError) {
@@ -426,29 +565,29 @@ 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;
                             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 };
                         shouldReport = true;
                     }
-                    if (event.type === "tool_execution_update") {
+                    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;
@@ -464,9 +603,7 @@ export class WorkflowAgentExecutor {
                 });
                 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();
@@ -476,7 +613,7 @@ export class WorkflowAgentExecutor {
                 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)
@@ -505,24 +642,41 @@ export class WorkflowAgentExecutor {
                     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();
                     }
@@ -537,9 +691,19 @@ 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);
@@ -627,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);
@@ -766,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);
@@ -776,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);
@@ -887,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));
 }
@@ -904,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))
@@ -923,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)
@@ -931,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();
     }
 }