@exaudeus/workrail 3.25.0 → 3.26.1

package/dist/daemon/soul-template.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_SOUL_TEMPLATE = exports.DAEMON_SOUL_DEFAULT = void 0;
+exports.DAEMON_SOUL_DEFAULT = `\
+- Write code that follows the patterns already established in the codebase
+- Never skip tests. Run existing tests before and after changes
+- Prefer small, focused changes over large rewrites
+- If a step asks you to write code, write actual code -- do not write pseudocode or placeholders
+- Commit your work when you complete a logical unit`;
+exports.DAEMON_SOUL_TEMPLATE = `\
+# WorkRail Daemon Soul
+#
+# This file is injected into every WorkRail Auto daemon session system prompt under
+# "## Agent Rules and Philosophy". Edit it to customize the agent's behavior for
+# your environment: coding conventions, commit style, tool preferences, etc.
+#
+# Changes take effect on the next daemon session -- no restart required.
+#
+# The defaults below reflect general best practices. Override them freely.
+
+${exports.DAEMON_SOUL_DEFAULT}
+`;

package/dist/daemon/workflow-runner.d.ts

@@ -1,8 +1,10 @@
 import 'reflect-metadata';
+import type { AgentTool } from "./agent-loop.js";
 import type { V2ToolContext } from '../mcp/types.js';
 import type { DaemonRegistry } from '../v2/infra/in-memory/daemon-registry/index.js';
+import type { V2StartWorkflowOutputSchema } from '../mcp/output-schemas.js';
 export declare const DAEMON_SESSIONS_DIR: string;
-export declare const DAEMON_SOUL_DEFAULT = "- Write code that follows the patterns already established in the codebase\n- Never skip tests. Run existing tests before and after changes\n- Prefer small, focused changes over large rewrites\n- If a step asks you to write code, write actual code -- do not write pseudocode or placeholders\n- Commit your work when you complete a logical unit";
+export { DAEMON_SOUL_DEFAULT, DAEMON_SOUL_TEMPLATE } from './soul-template.js';
 export interface WorkflowTrigger {
     readonly workflowId: string;
     readonly goal: string;
@@ -11,12 +13,17 @@ export interface WorkflowTrigger {
     readonly referenceUrls?: readonly string[];
     readonly agentConfig?: {
         readonly model?: string;
+        readonly maxSessionMinutes?: number;
+        readonly maxTurns?: number;
     };
+    readonly _preAllocatedStartResponse?: import('zod').infer<typeof V2StartWorkflowOutputSchema>;
+    readonly soulFile?: string;
 }
 export interface WorkflowRunSuccess {
     readonly _tag: 'success';
     readonly workflowId: string;
     readonly stopReason: string;
+    readonly lastStepNotes?: string;
 }
 export interface WorkflowRunError {
     readonly _tag: 'error';
@@ -24,7 +31,20 @@ export interface WorkflowRunError {
     readonly message: string;
     readonly stopReason: string;
 }
-export type WorkflowRunResult = WorkflowRunSuccess | WorkflowRunError;
+export interface WorkflowRunTimeout {
+    readonly _tag: 'timeout';
+    readonly workflowId: string;
+    readonly reason: 'wall_clock' | 'max_turns';
+    readonly message: string;
+    readonly stopReason: string;
+}
+export interface WorkflowDeliveryFailed {
+    readonly _tag: 'delivery_failed';
+    readonly workflowId: string;
+    readonly stopReason: string;
+    readonly deliveryError: string;
+}
+export type WorkflowRunResult = WorkflowRunSuccess | WorkflowRunError | WorkflowRunTimeout | WorkflowDeliveryFailed;
 export interface OrphanedSession {
     readonly sessionId: string;
     readonly continueToken: string;
@@ -37,5 +57,7 @@ export declare function readDaemonSessionState(sessionId: string): Promise<{
 } | null>;
 export declare function readAllDaemonSessions(sessionsDir?: string): Promise<OrphanedSession[]>;
 export declare function runStartupRecovery(sessionsDir?: string): Promise<void>;
+export declare function makeBashTool(workspacePath: string, schemas: Record<string, any>): AgentTool;
+export declare function buildSessionRecap(notes: readonly string[]): string;
 export declare function buildSystemPrompt(trigger: WorkflowTrigger, sessionState: string, soulContent: string, workspaceContext: string | null): string;
 export declare function runWorkflow(trigger: WorkflowTrigger, ctx: V2ToolContext, apiKey: string, daemonRegistry?: DaemonRegistry): Promise<WorkflowRunResult>;

package/dist/daemon/workflow-runner.js

@@ -32,11 +32,16 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DAEMON_SOUL_DEFAULT = exports.DAEMON_SESSIONS_DIR = void 0;
+exports.DAEMON_SOUL_TEMPLATE = exports.DAEMON_SOUL_DEFAULT = exports.DAEMON_SESSIONS_DIR = void 0;
 exports.readDaemonSessionState = readDaemonSessionState;
 exports.readAllDaemonSessions = readAllDaemonSessions;
 exports.runStartupRecovery = runStartupRecovery;
+exports.makeBashTool = makeBashTool;
+exports.buildSessionRecap = buildSessionRecap;
 exports.buildSystemPrompt = buildSystemPrompt;
 exports.runWorkflow = runWorkflow;
 require("reflect-metadata");
@@ -46,12 +51,19 @@ const os = __importStar(require("node:os"));
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
 const node_crypto_1 = require("node:crypto");
-const pi_mono_loader_js_1 = require("./pi-mono-loader.js");
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const bedrock_sdk_1 = require("@anthropic-ai/bedrock-sdk");
+const agent_loop_js_1 = require("./agent-loop.js");
 const start_js_1 = require("../mcp/handlers/v2-execution/start.js");
 const index_js_1 = require("../mcp/handlers/v2-execution/index.js");
+const v2_token_ops_js_1 = require("../mcp/handlers/v2-token-ops.js");
+const index_js_2 = require("../v2/durable-core/ids/index.js");
+const node_outputs_js_1 = require("../v2/projections/node-outputs.js");
 const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
 const BASH_TIMEOUT_MS = 5 * 60 * 1000;
-const WORKFLOW_TIMEOUT_MS = 30 * 60 * 1000;
+const MAX_SESSION_RECAP_NOTES = 3;
+const MAX_SESSION_NOTE_CHARS = 800;
+const DEFAULT_SESSION_TIMEOUT_MINUTES = 30;
 exports.DAEMON_SESSIONS_DIR = path.join(os.homedir(), '.workrail', 'daemon-sessions');
 const MAX_ORPHAN_AGE_MS = 2 * 60 * 60 * 1000;
 const WORKRAIL_DIR = path.join(os.homedir(), '.workrail');
@@ -62,25 +74,10 @@ const WORKSPACE_CONTEXT_CANDIDATE_PATHS = [
     'AGENTS.md',
     '.github/AGENTS.md',
 ];
-exports.DAEMON_SOUL_DEFAULT = `\
-- Write code that follows the patterns already established in the codebase
-- Never skip tests. Run existing tests before and after changes
-- Prefer small, focused changes over large rewrites
-- If a step asks you to write code, write actual code -- do not write pseudocode or placeholders
-- Commit your work when you complete a logical unit`;
-const DAEMON_SOUL_TEMPLATE = `\
-# WorkRail Daemon Soul
-#
-# This file is injected into every WorkRail Auto daemon session system prompt under
-# "## Agent Rules and Philosophy". Edit it to customize the agent's behavior for
-# your environment: coding conventions, commit style, tool preferences, etc.
-#
-# Changes take effect on the next daemon session -- no restart required.
-#
-# The defaults below reflect general best practices. Override them freely.
-
-${exports.DAEMON_SOUL_DEFAULT}
-`;
+const soul_template_js_1 = require("./soul-template.js");
+var soul_template_js_2 = require("./soul-template.js");
+Object.defineProperty(exports, "DAEMON_SOUL_DEFAULT", { enumerable: true, get: function () { return soul_template_js_2.DAEMON_SOUL_DEFAULT; } });
+Object.defineProperty(exports, "DAEMON_SOUL_TEMPLATE", { enumerable: true, get: function () { return soul_template_js_2.DAEMON_SOUL_TEMPLATE; } });
 async function persistTokens(sessionId, continueToken, checkpointToken) {
     await fs.mkdir(exports.DAEMON_SESSIONS_DIR, { recursive: true });
     const sessionPath = path.join(exports.DAEMON_SESSIONS_DIR, `${sessionId}.json`);
@@ -186,8 +183,8 @@ async function clearStrayTmpFiles(sessionsDir) {
         }
     }
 }
-async function loadDaemonSoul() {
-    const soulPath = path.join(WORKRAIL_DIR, 'daemon-soul.md');
+async function loadDaemonSoul(resolvedPath) {
+    const soulPath = resolvedPath ?? path.join(WORKRAIL_DIR, 'daemon-soul.md');
     try {
         return await fs.readFile(soulPath, 'utf8');
     }
@@ -195,8 +192,8 @@ async function loadDaemonSoul() {
         const isEnoent = err instanceof Error && 'code' in err && err.code === 'ENOENT';
         if (isEnoent) {
             try {
-                await fs.mkdir(WORKRAIL_DIR, { recursive: true });
-                await fs.writeFile(soulPath, DAEMON_SOUL_TEMPLATE, 'utf8');
+                await fs.mkdir(path.dirname(soulPath), { recursive: true });
+                await fs.writeFile(soulPath, soul_template_js_1.DAEMON_SOUL_TEMPLATE, 'utf8');
                 console.log(`[WorkflowRunner] Created daemon-soul.md template at ${soulPath}`);
             }
             catch (writeErr) {
@@ -206,7 +203,7 @@ async function loadDaemonSoul() {
         else {
             console.warn(`[WorkflowRunner] Warning: could not read daemon-soul.md: ${err instanceof Error ? err.message : String(err)}`);
         }
-        return exports.DAEMON_SOUL_DEFAULT;
+        return soul_template_js_1.DAEMON_SOUL_DEFAULT;
     }
 }
 async function loadWorkspaceContext(workspacePath) {
@@ -249,37 +246,94 @@ async function loadWorkspaceContext(workspacePath) {
     console.log(`[WorkflowRunner] Injecting workspace context from: ${WORKSPACE_CONTEXT_CANDIDATE_PATHS.filter((p) => parts.some((part) => part.startsWith(`### ${p}`))).join(', ')}`);
     return combined;
 }
+async function loadSessionNotes(continueToken, ctx) {
+    try {
+        const resolvedResult = await (0, v2_token_ops_js_1.parseContinueTokenOrFail)(continueToken, ctx.v2.tokenCodecPorts, ctx.v2.tokenAliasStore);
+        if (resolvedResult.isErr()) {
+            console.warn(`[WorkflowRunner] Warning: could not decode continueToken for session recap: ${resolvedResult.error.message}`);
+            return [];
+        }
+        const sessionId = (0, index_js_2.asSessionId)(resolvedResult.value.sessionId);
+        const loadResult = await ctx.v2.sessionStore.load(sessionId);
+        if (loadResult.isErr()) {
+            console.warn(`[WorkflowRunner] Warning: could not load session store for recap: ${loadResult.error.code} -- ${loadResult.error.message}`);
+            return [];
+        }
+        const projectionResult = (0, node_outputs_js_1.projectNodeOutputsV2)(loadResult.value.events);
+        if (projectionResult.isErr()) {
+            console.warn(`[WorkflowRunner] Warning: could not project session outputs for recap: ${projectionResult.error.code} -- ${projectionResult.error.message}`);
+            return [];
+        }
+        const allNotes = [];
+        for (const nodeView of Object.values(projectionResult.value.nodesById)) {
+            for (const output of nodeView.currentByChannel.recap) {
+                if (output.payload.payloadKind === 'notes') {
+                    const note = output.payload.notesMarkdown.length > MAX_SESSION_NOTE_CHARS
+                        ? output.payload.notesMarkdown.slice(0, MAX_SESSION_NOTE_CHARS) + '\n[truncated]'
+                        : output.payload.notesMarkdown;
+                    allNotes.push(note);
+                }
+            }
+        }
+        return allNotes.slice(-MAX_SESSION_RECAP_NOTES);
+    }
+    catch (err) {
+        console.warn(`[WorkflowRunner] Warning: unexpected error loading session notes for recap: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
 let _schemas = null;
-async function getSchemas() {
+function getSchemas() {
     if (_schemas)
         return _schemas;
-    const { Type } = await (0, pi_mono_loader_js_1.loadPiAi)();
     _schemas = {
-        ContinueWorkflowParams: Type.Object({
-            continueToken: Type.String({
-                description: 'The continueToken from the previous start_workflow or continue_workflow call. Round-trip exactly as received.',
-            }),
-            intent: Type.Optional(Type.Union([Type.Literal('advance'), Type.Literal('rehydrate')], {
-                description: 'advance: I completed this step. rehydrate: remind me what the current step is.',
-            })),
-            notesMarkdown: Type.Optional(Type.String({
-                description: 'Notes on what you did in this step (10-30 lines, markdown).',
-            })),
-            context: Type.Optional(Type.Record(Type.String(), Type.Unknown(), {
-                description: 'Updated context variables (only changed values).',
-            })),
-        }),
-        BashParams: Type.Object({
-            command: Type.String({ description: 'Shell command to execute' }),
-            cwd: Type.Optional(Type.String({ description: 'Working directory for the command' })),
-        }),
-        ReadParams: Type.Object({
-            filePath: Type.String({ description: 'Absolute path to the file to read' }),
-        }),
-        WriteParams: Type.Object({
-            filePath: Type.String({ description: 'Absolute path to the file to write' }),
-            content: Type.String({ description: 'Content to write to the file' }),
-        }),
+        ContinueWorkflowParams: {
+            type: 'object',
+            properties: {
+                continueToken: {
+                    type: 'string',
+                    description: 'The continueToken from the previous start_workflow or continue_workflow call. Round-trip exactly as received.',
+                },
+                intent: {
+                    type: 'string',
+                    enum: ['advance', 'rehydrate'],
+                    description: 'advance: I completed this step. rehydrate: remind me what the current step is.',
+                },
+                notesMarkdown: {
+                    type: 'string',
+                    description: 'Notes on what you did in this step (10-30 lines, markdown).',
+                },
+                context: {
+                    type: 'object',
+                    additionalProperties: true,
+                    description: 'Updated context variables (only changed values).',
+                },
+            },
+            required: ['continueToken'],
+        },
+        BashParams: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Shell command to execute' },
+                cwd: { type: 'string', description: 'Working directory for the command' },
+            },
+            required: ['command'],
+        },
+        ReadParams: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to the file to read' },
+            },
+            required: ['filePath'],
+        },
+        WriteParams: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Absolute path to the file to write' },
+                content: { type: 'string', description: 'Content to write to the file' },
+            },
+            required: ['filePath', 'content'],
+        },
     };
     return _schemas;
 }
@@ -288,7 +342,7 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
         name: 'continue_workflow',
         description: 'Advance the WorkRail workflow to the next step. Call this after completing all work ' +
             'required by the current step. Include your notes in notesMarkdown.',
-        parameters: schemas['ContinueWorkflowParams'],
+        inputSchema: schemas['ContinueWorkflowParams'],
         label: 'Continue Workflow',
         execute: async (_toolCallId, params) => {
             const result = await (0, index_js_1.executeContinueWorkflow)({
@@ -309,7 +363,7 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
                 await persistTokens(sessionId, continueToken, checkpointToken);
             }
             if (out.isComplete) {
-                onComplete('Workflow session complete.');
+                onComplete(params.notesMarkdown);
                 return {
                     content: [{ type: 'text', text: 'Workflow complete. All steps have been executed.' }],
                     details: out,
@@ -330,21 +384,44 @@ function makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas
 function makeBashTool(workspacePath, schemas) {
     return {
         name: 'Bash',
-        description: 'Execute a shell command. Throws on non-zero exit code. ' +
+        description: 'Execute a shell command. Throws on failure (non-zero exit with stderr, or exit code 2+). ' +
+            'Exit code 1 with empty stderr is treated as "no match found" (standard grep semantics) and ' +
+            'returns empty output without throwing. ' +
             `Maximum execution time: ${BASH_TIMEOUT_MS / 1000}s.`,
-        parameters: schemas['BashParams'],
+        inputSchema: schemas['BashParams'],
         label: 'Bash',
         execute: async (_toolCallId, params) => {
             const cwd = params.cwd ?? workspacePath;
-            const { stdout, stderr } = await execAsync(params.command, {
-                cwd,
-                timeout: BASH_TIMEOUT_MS,
-            });
-            const output = [stdout, stderr].filter(Boolean).join('\n');
-            return {
-                content: [{ type: 'text', text: output || '(no output)' }],
-                details: { stdout, stderr },
-            };
+            try {
+                const { stdout, stderr } = await execAsync(params.command, {
+                    cwd,
+                    timeout: BASH_TIMEOUT_MS,
+                });
+                const output = [stdout, stderr].filter(Boolean).join('\n');
+                return {
+                    content: [{ type: 'text', text: output || '(no output)' }],
+                    details: { stdout, stderr },
+                };
+            }
+            catch (err) {
+                const e = err;
+                const stdout = String(e.stdout ?? '');
+                const stderr = String(e.stderr ?? '');
+                const rawCode = e.code;
+                const signal = e.signal;
+                if (rawCode === 1 && !stderr.trim()) {
+                    return {
+                        content: [{ type: 'text', text: stdout || '(no output)' }],
+                        details: { stdout, stderr },
+                    };
+                }
+                const exitInfo = rawCode != null
+                    ? `exit ${String(rawCode)}`
+                    : signal
+                        ? `signal ${String(signal)}`
+                        : 'exit unknown';
+                throw new Error(`Command failed: ${params.command} (${exitInfo})\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`);
+            }
         },
     };
 }
@@ -352,7 +429,7 @@ function makeReadTool(schemas) {
     return {
         name: 'Read',
         description: 'Read the contents of a file at the given absolute path.',
-        parameters: schemas['ReadParams'],
+        inputSchema: schemas['ReadParams'],
         label: 'Read',
         execute: async (_toolCallId, params) => {
             const content = await fs.readFile(params.filePath, 'utf8');
@@ -367,7 +444,7 @@ function makeWriteTool(schemas) {
     return {
         name: 'Write',
         description: 'Write content to a file at the given absolute path. Creates parent directories if needed.',
-        parameters: schemas['WriteParams'],
+        inputSchema: schemas['WriteParams'],
         label: 'Write',
         execute: async (_toolCallId, params) => {
             await fs.mkdir(path.dirname(params.filePath), { recursive: true });
@@ -379,6 +456,14 @@ function makeWriteTool(schemas) {
         },
     };
 }
+function buildSessionRecap(notes) {
+    if (notes.length === 0)
+        return '';
+    const formattedNotes = notes
+        .map((note, i) => `### Prior step ${i + 1}\n${note}`)
+        .join('\n\n');
+    return `<workrail_session_state>\nThe following notes summarize prior steps from this session:\n\n${formattedNotes}\n</workrail_session_state>`;
+}
 function buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext) {
     const lines = [
         'You are WorkRail Auto, an autonomous agent that executes workflows step by step.',
@@ -428,57 +513,62 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
     const sessionId = (0, node_crypto_1.randomUUID)();
     console.log(`[WorkflowRunner] Session started: sessionId=${sessionId} workflowId=${trigger.workflowId}`);
     daemonRegistry?.register(sessionId, trigger.workflowId);
-    let model;
-    try {
-        const { getModel } = await (0, pi_mono_loader_js_1.loadPiAi)();
-        if (trigger.agentConfig?.model) {
-            const slashIdx = trigger.agentConfig.model.indexOf('/');
-            if (slashIdx === -1) {
-                throw new Error(`agentConfig.model must be in "provider/model-id" format, got: "${trigger.agentConfig.model}"`);
-            }
-            const provider = trigger.agentConfig.model.slice(0, slashIdx);
-            const modelId = trigger.agentConfig.model.slice(slashIdx + 1);
-            model = getModel(provider, modelId);
+    let agentClient;
+    let modelId;
+    if (trigger.agentConfig?.model) {
+        const slashIdx = trigger.agentConfig.model.indexOf('/');
+        if (slashIdx === -1) {
+            daemonRegistry?.unregister(sessionId, 'failed');
+            return {
+                _tag: 'error',
+                workflowId: trigger.workflowId,
+                message: `agentConfig.model must be in "provider/model-id" format, got: "${trigger.agentConfig.model}"`,
+                stopReason: 'error',
+            };
+        }
+        const provider = trigger.agentConfig.model.slice(0, slashIdx);
+        modelId = trigger.agentConfig.model.slice(slashIdx + 1);
+        agentClient = provider === 'amazon-bedrock' ? new bedrock_sdk_1.AnthropicBedrock() : new sdk_1.default({ apiKey });
+    }
+    else {
+        const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
+        if (usesBedrock) {
+            agentClient = new bedrock_sdk_1.AnthropicBedrock();
+            modelId = 'us.anthropic.claude-sonnet-4-6';
         }
         else {
-            const usesBedrock = !!process.env['AWS_PROFILE'] || !!process.env['AWS_ACCESS_KEY_ID'];
-            if (usesBedrock) {
-                model = getModel('amazon-bedrock', 'us.anthropic.claude-sonnet-4-6');
-            }
-            else {
-                model = getModel('anthropic', 'claude-sonnet-4-5');
-            }
+            agentClient = new sdk_1.default({ apiKey });
+            modelId = 'claude-sonnet-4-5';
         }
     }
-    catch (err) {
-        daemonRegistry?.unregister(sessionId, 'failed');
-        return {
-            _tag: 'error',
-            workflowId: trigger.workflowId,
-            message: `Model not found: ${err instanceof Error ? err.message : String(err)}`,
-            stopReason: 'error',
-        };
-    }
     let isComplete = false;
     let pendingSteerText = null;
+    let lastStepNotes;
     const onAdvance = (stepText, _continueToken) => {
         pendingSteerText = stepText;
         daemonRegistry?.heartbeat(sessionId);
     };
-    const onComplete = (_notes) => {
+    const onComplete = (notes) => {
         isComplete = true;
+        lastStepNotes = notes;
     };
-    const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId: trigger.workflowId, workspacePath: trigger.workspacePath, goal: trigger.goal }, ctx, { is_autonomous: 'true' });
-    if (startResult.isErr()) {
-        daemonRegistry?.unregister(sessionId, 'failed');
-        return {
-            _tag: 'error',
-            workflowId: trigger.workflowId,
-            message: `start_workflow failed: ${startResult.error.kind} -- ${JSON.stringify(startResult.error)}`,
-            stopReason: 'error',
-        };
+    let firstStep;
+    if (trigger._preAllocatedStartResponse !== undefined) {
+        firstStep = trigger._preAllocatedStartResponse;
+    }
+    else {
+        const startResult = await (0, start_js_1.executeStartWorkflow)({ workflowId: trigger.workflowId, workspacePath: trigger.workspacePath, goal: trigger.goal }, ctx, { is_autonomous: 'true' });
+        if (startResult.isErr()) {
+            daemonRegistry?.unregister(sessionId, 'failed');
+            return {
+                _tag: 'error',
+                workflowId: trigger.workflowId,
+                message: `start_workflow failed: ${startResult.error.kind} -- ${JSON.stringify(startResult.error)}`,
+                stopReason: 'error',
+            };
+        }
+        firstStep = startResult.value.response;
     }
-    const firstStep = startResult.value.response;
     const startContinueToken = firstStep.continueToken ?? '';
     const startCheckpointToken = firstStep.checkpointToken ?? null;
     if (startContinueToken) {
@@ -489,36 +579,46 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
         daemonRegistry?.unregister(sessionId, 'completed');
         return { _tag: 'success', workflowId: trigger.workflowId, stopReason: 'stop' };
     }
-    const schemas = await getSchemas();
+    const schemas = getSchemas();
     const tools = [
         makeContinueWorkflowTool(sessionId, ctx, onAdvance, onComplete, schemas),
         makeBashTool(trigger.workspacePath, schemas),
         makeReadTool(schemas),
         makeWriteTool(schemas),
     ];
-    const [soulContent, workspaceContext] = await Promise.all([
-        loadDaemonSoul(),
+    const [soulContent, workspaceContext, sessionNotes] = await Promise.all([
+        loadDaemonSoul(trigger.soulFile),
         loadWorkspaceContext(trigger.workspacePath),
+        startContinueToken ? loadSessionNotes(startContinueToken, ctx) : Promise.resolve([]),
     ]);
+    const sessionState = buildSessionRecap(sessionNotes);
     const contextJson = trigger.context
         ? `\n\nTrigger context:\n\`\`\`json\n${JSON.stringify(trigger.context, null, 2)}\n\`\`\``
         : '';
     const initialPrompt = (firstStep.pending?.prompt ?? 'No step content available') +
         `\n\ncontinueToken: ${startContinueToken}` +
-        contextJson;
-    const { Agent } = await (0, pi_mono_loader_js_1.loadPiAgentCore)();
-    const agent = new Agent({
-        initialState: {
-            systemPrompt: buildSystemPrompt(trigger, '', soulContent, workspaceContext),
-            model,
-            tools,
-        },
-        getApiKey: async (_provider) => apiKey ?? '',
+        contextJson +
+        '\n\nComplete all step work, then call continue_workflow with your notes to begin.';
+    const agent = new agent_loop_js_1.AgentLoop({
+        systemPrompt: buildSystemPrompt(trigger, sessionState, soulContent, workspaceContext),
+        modelId,
+        tools,
+        client: agentClient,
         toolExecution: 'sequential',
     });
+    const sessionTimeoutMs = (trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES) * 60 * 1000;
+    const maxTurns = trigger.agentConfig?.maxTurns ?? 0;
+    let timeoutReason = null;
+    let turnCount = 0;
     const unsubscribe = agent.subscribe(async (event) => {
         if (event.type !== 'turn_end')
             return;
+        turnCount++;
+        if (maxTurns > 0 && turnCount >= maxTurns && timeoutReason === null) {
+            timeoutReason = 'max_turns';
+            agent.abort();
+            return;
+        }
         if (pendingSteerText !== null && !isComplete) {
             const text = pendingSteerText;
             pendingSteerText = null;
@@ -527,8 +627,16 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
     });
     let stopReason = 'stop';
     let errorMessage;
+    let timeoutHandle;
     try {
-        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Workflow timed out')), WORKFLOW_TIMEOUT_MS));
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                if (timeoutReason === null) {
+                    timeoutReason = 'wall_clock';
+                }
+                reject(new Error('Workflow timed out'));
+            }, sessionTimeoutMs);
+        });
         await Promise.race([agent.prompt(buildUserMessage(initialPrompt)), timeoutPromise])
             .catch((err) => {
             agent.abort();
@@ -552,6 +660,21 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
     }
     finally {
         unsubscribe();
+        if (timeoutHandle !== undefined)
+            clearTimeout(timeoutHandle);
+    }
+    if (timeoutReason !== null) {
+        daemonRegistry?.unregister(sessionId, 'failed');
+        const limitDescription = timeoutReason === 'wall_clock'
+            ? `${trigger.agentConfig?.maxSessionMinutes ?? DEFAULT_SESSION_TIMEOUT_MINUTES} minutes`
+            : `${trigger.agentConfig?.maxTurns} turns`;
+        return {
+            _tag: 'timeout',
+            workflowId: trigger.workflowId,
+            reason: timeoutReason,
+            message: `Workflow ${timeoutReason === 'wall_clock' ? 'timed out' : 'exceeded turn limit'} after ${limitDescription}`,
+            stopReason: 'aborted',
+        };
     }
     if (stopReason === 'error' || errorMessage) {
         daemonRegistry?.unregister(sessionId, 'failed');
@@ -569,5 +692,6 @@ async function runWorkflow(trigger, ctx, apiKey, daemonRegistry) {
         _tag: 'success',
         workflowId: trigger.workflowId,
         stopReason,
+        ...(lastStepNotes !== undefined ? { lastStepNotes } : {}),
     };
 }