@sudocode-ai/local-server 0.1.10 → 0.1.12

package/dist/workflow/engines/orchestrator-engine.js

@@ -0,0 +1,749 @@
+/**
+ * Orchestrator Workflow Engine
+ *
+ * Agent-managed workflow execution. The orchestrator is itself an execution
+ * (Claude Code agent) that controls workflow steps via MCP tools.
+ *
+ * Key differences from SequentialWorkflowEngine:
+ * - No internal execution loop - orchestrator agent handles execution
+ * - Wakeup mechanism - events trigger follow-up executions
+ * - MCP tools for step control - orchestrator uses workflow_* and execute_* tools
+ */
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { getIssue } from "@sudocode-ai/cli/dist/operations/issues.js";
+import { BaseWorkflowEngine } from "../base-workflow-engine.js";
+import { WorkflowCycleError, WorkflowStateError, WorkflowStepNotFoundError, } from "../workflow-engine.js";
+import { WorkflowPromptBuilder } from "../services/prompt-builder.js";
+import { registerExecutionCallback, } from "../../services/execution-event-callbacks.js";
+// =============================================================================
+// Orchestrator Workflow Engine
+// =============================================================================
+/**
+ * Orchestrator Workflow Engine implementation.
+ *
+ * This engine spawns an orchestrator agent (Claude Code execution) that controls
+ * the workflow using MCP tools. The orchestrator makes decisions about:
+ * - Which issues to execute
+ * - How to handle failures
+ * - When to escalate to the user
+ *
+ * Events from step executions trigger "wakeups" - follow-up messages to the
+ * orchestrator that inform it of completed work.
+ *
+ * @example
+ * ```typescript
+ * const engine = new OrchestratorWorkflowEngine({
+ *   db,
+ *   executionService,
+ *   wakeupService,
+ *   config: {
+ *     repoPath: '/path/to/repo',
+ *     dbPath: '/path/to/.sudocode/cache.db',
+ *   },
+ * });
+ *
+ * // Create workflow from a goal
+ * const workflow = await engine.createWorkflow({
+ *   type: "goal",
+ *   goal: "Implement user authentication with OAuth"
+ * });
+ *
+ * // Start orchestrator
+ * await engine.startWorkflow(workflow.id);
+ * ```
+ */
+export class OrchestratorWorkflowEngine extends BaseWorkflowEngine {
+    executionService;
+    lifecycleService;
+    wakeupService;
+    promptBuilder;
+    config;
+    unregisterExecutionCallback;
+    constructor(deps) {
+        super(deps.db, deps.eventEmitter);
+        this.executionService = deps.executionService;
+        this.lifecycleService = deps.lifecycleService;
+        this.wakeupService = deps.wakeupService;
+        this.promptBuilder = new WorkflowPromptBuilder();
+        this.config = deps.config;
+        // Register callback to record workflow events when executions complete
+        this.setupExecutionCallbacks();
+    }
+    // ===========================================================================
+    // Configuration
+    // ===========================================================================
+    /**
+     * Update the server URL after dynamic port discovery.
+     * Called by ProjectContext when the actual server port is known.
+     */
+    setServerUrl(serverUrl) {
+        this.config.serverUrl = serverUrl;
+    }
+    /**
+     * Get the wakeup service for registering await conditions.
+     * Used by the API endpoint for await_events MCP tool.
+     */
+    getWakeupService() {
+        return this.wakeupService;
+    }
+    // ===========================================================================
+    // Execution Event Callbacks
+    // ===========================================================================
+    /**
+     * Set up callbacks to record workflow events when executions complete/fail.
+     *
+     * When an execution that belongs to a workflow completes or fails, we need to:
+     * 1. Find the corresponding workflow step
+     * 2. Update the step status
+     * 3. Record a workflow event (step_completed or step_failed)
+     * 4. Trigger a wakeup so the orchestrator can react
+     */
+    setupExecutionCallbacks() {
+        this.unregisterExecutionCallback = registerExecutionCallback(async (event, data) => {
+            // Only handle events from workflow executions
+            if (!data.workflowId) {
+                return;
+            }
+            // Get the workflow
+            const workflow = await this.getWorkflow(data.workflowId);
+            if (!workflow) {
+                console.warn(`[OrchestratorEngine] Workflow not found for execution event: ${data.workflowId}`);
+                return;
+            }
+            // Find the step for this execution
+            const step = workflow.steps.find((s) => s.executionId === data.executionId);
+            if (!step) {
+                // Might be the orchestrator execution itself, not a step
+                console.debug(`[OrchestratorEngine] No step found for execution ${data.executionId} in workflow ${data.workflowId}`);
+                return;
+            }
+            // Clear any pending timeout for this execution
+            this.wakeupService.clearExecutionTimeout(data.executionId);
+            // Determine event type and update step status
+            const eventType = event === "completed" ? "step_completed" : "step_failed";
+            const newStepStatus = event === "completed" ? "completed" : "failed";
+            // Update step status in workflow
+            const updatedSteps = workflow.steps.map((s) => s.id === step.id
+                ? { ...s, status: newStepStatus }
+                : s);
+            this.updateWorkflow(data.workflowId, { steps: updatedSteps });
+            // Record workflow event for orchestrator
+            await this.wakeupService.recordEvent({
+                workflowId: data.workflowId,
+                type: eventType,
+                executionId: data.executionId,
+                stepId: step.id,
+                payload: {
+                    issueId: step.issueId,
+                    error: data.error,
+                },
+            });
+            // Trigger wakeup so orchestrator can react
+            await this.wakeupService.triggerWakeup(data.workflowId);
+            console.log(`[OrchestratorEngine] Recorded ${eventType} for step ${step.id} in workflow ${data.workflowId}`);
+        });
+    }
+    /**
+     * Clean up the execution callback when the engine is disposed.
+     */
+    dispose() {
+        if (this.unregisterExecutionCallback) {
+            this.unregisterExecutionCallback();
+            this.unregisterExecutionCallback = undefined;
+        }
+    }
+    // ===========================================================================
+    // Workflow Creation
+    // ===========================================================================
+    /**
+     * Create a new workflow from a source definition.
+     *
+     * For orchestrator workflows, goal-based sources create empty workflows
+     * that the orchestrator populates dynamically.
+     *
+     * @param source - How to determine workflow scope (spec, issues, root_issue, or goal)
+     * @param config - Optional configuration overrides
+     * @returns The created workflow
+     * @throws WorkflowCycleError if dependency cycles are detected
+     */
+    async createWorkflow(source, config) {
+        // 1. Resolve source to issue IDs
+        const issueIds = await this.resolveSource(source);
+        // 2. Handle goal-based workflows (no initial issues)
+        if (source.type === "goal" && issueIds.length === 0) {
+            const workflow = this.buildWorkflow({
+                source,
+                steps: [],
+                config: config || {},
+                repoPath: this.config.repoPath,
+            });
+            this.saveWorkflow(workflow);
+            return workflow;
+        }
+        // 3. Build dependency graph
+        const graph = this.analyzeDependencies(issueIds);
+        // 4. Check for cycles
+        if (graph.cycles && graph.cycles.length > 0) {
+            throw new WorkflowCycleError(graph.cycles);
+        }
+        // 5. Create steps from graph
+        const steps = this.createStepsFromGraph(graph);
+        // 6. Build workflow object
+        const workflow = this.buildWorkflow({
+            source,
+            steps,
+            config: config || {},
+            repoPath: this.config.repoPath,
+        });
+        // 7. Save to database
+        this.saveWorkflow(workflow);
+        return workflow;
+    }
+    // ===========================================================================
+    // Workflow Lifecycle
+    // ===========================================================================
+    /**
+     * Start executing a pending workflow.
+     *
+     * Spawns an orchestrator execution (Claude Code agent) with workflow MCP tools.
+     * The orchestrator will use these tools to control step execution.
+     *
+     * @param workflowId - The workflow to start
+     * @throws WorkflowNotFoundError if workflow doesn't exist
+     * @throws WorkflowStateError if workflow is not in pending state
+     */
+    async startWorkflow(workflowId) {
+        console.log(`[OrchestratorWorkflowEngine] startWorkflow called for ${workflowId}`);
+        const workflow = await this.getWorkflowOrThrow(workflowId);
+        // Validate state
+        if (workflow.status !== "pending") {
+            throw new WorkflowStateError(workflowId, workflow.status, "start");
+        }
+        // Create workflow-level worktree if not already present
+        if (!workflow.worktreePath) {
+            console.log(`[OrchestratorWorkflowEngine] Creating workflow worktree for ${workflowId}`);
+            const { worktreePath, branchName } = await this.createWorkflowWorktreeHelper(workflow, this.config.repoPath, this.lifecycleService);
+            // Update local workflow reference with worktree info
+            workflow.worktreePath = worktreePath;
+            workflow.branchName = branchName;
+        }
+        // Update status to running
+        const updated = this.updateWorkflow(workflowId, {
+            status: "running",
+            startedAt: new Date().toISOString(),
+        });
+        // Emit workflow started event
+        this.eventEmitter.emit({
+            type: "workflow_started",
+            workflowId,
+            workflow: updated,
+            timestamp: Date.now(),
+        });
+        // Spawn orchestrator execution
+        console.log(`[OrchestratorWorkflowEngine] Spawning orchestrator for workflow ${workflowId}`);
+        await this.spawnOrchestrator(updated);
+    }
+    /**
+     * Pause a running workflow.
+     *
+     * Sets pause status and records an event. The orchestrator will be notified
+     * via wakeup when it checks workflow status.
+     *
+     * @param workflowId - The workflow to pause
+     * @throws WorkflowNotFoundError if workflow doesn't exist
+     * @throws WorkflowStateError if workflow is not running
+     */
+    async pauseWorkflow(workflowId) {
+        const workflow = await this.getWorkflowOrThrow(workflowId);
+        if (workflow.status !== "running") {
+            throw new WorkflowStateError(workflowId, workflow.status, "pause");
+        }
+        // Cancel ALL running executions (orchestrator chain + step executions)
+        await this.cancelAllWorkflowExecutions(workflow);
+        // Cancel pending wakeup
+        this.wakeupService.cancelPendingWakeup(workflowId);
+        // Clear any await state
+        this.wakeupService.clearAwaitState(workflowId);
+        // Update status
+        this.updateWorkflow(workflowId, { status: "paused" });
+        // Record pause event for orchestrator
+        await this.wakeupService.recordEvent({
+            workflowId,
+            type: "workflow_paused",
+            payload: {},
+        });
+        // Emit event
+        this.eventEmitter.emit({
+            type: "workflow_paused",
+            workflowId,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Resume a paused workflow.
+     *
+     * Uses Claude Code's session resume to continue the orchestrator from where it left off.
+     * This preserves the full conversation history and context.
+     *
+     * @param workflowId - The workflow to resume
+     * @param message - Optional message to send with the resume (defaults to "Workflow resumed. Continue execution.")
+     * @throws WorkflowNotFoundError if workflow doesn't exist
+     * @throws WorkflowStateError if workflow is not paused
+     */
+    async resumeWorkflow(workflowId, message) {
+        const workflow = await this.getWorkflowOrThrow(workflowId);
+        if (workflow.status !== "paused") {
+            throw new WorkflowStateError(workflowId, workflow.status, "resume");
+        }
+        // Get the session ID to resume
+        const sessionId = workflow.orchestratorSessionId;
+        if (!sessionId) {
+            throw new Error(`Cannot resume workflow ${workflowId}: no orchestrator session ID found`);
+        }
+        // Update status first
+        this.updateWorkflow(workflowId, { status: "running" });
+        // Build the resume prompt
+        const resumePrompt = message || "Workflow resumed. Continue execution.";
+        // Build agent config with resume flag
+        const agentConfig = this.buildOrchestratorConfig(workflow);
+        const agentType = workflow.config.orchestratorAgentType ?? "claude-code";
+        console.log(`[OrchestratorWorkflowEngine] Resuming workflow ${workflowId} with session ${sessionId}`);
+        // Create new execution that resumes the session
+        // Link to the previous orchestrator execution for chain tracking
+        const previousExecutionId = workflow.orchestratorExecutionId;
+        const execution = await this.executionService.createExecution(null, // No issue - this is the orchestrator
+        {
+            mode: "worktree",
+            baseBranch: workflow.baseBranch,
+            reuseWorktreePath: workflow.worktreePath,
+            resume: sessionId, // Resume the previous session
+            parentExecutionId: previousExecutionId, // Link to previous execution in chain
+            ...agentConfig,
+        }, resumePrompt, agentType);
+        // Update workflow with new orchestrator execution ID
+        // Note: session_id should remain the same for resumed sessions
+        this.updateWorkflow(workflowId, {
+            orchestratorExecutionId: execution.id,
+            orchestratorSessionId: execution.session_id || sessionId,
+        });
+        // Record resume event for tracking
+        await this.wakeupService.recordEvent({
+            workflowId,
+            type: "workflow_resumed",
+            payload: {
+                resumedFromSession: sessionId,
+                previousExecutionId,
+                newExecutionId: execution.id,
+            },
+        });
+        // Mark any pending events as processed (they're now part of the resumed session context)
+        const pendingEvents = this.wakeupService.getUnprocessedEvents(workflowId);
+        if (pendingEvents.length > 0) {
+            this.wakeupService.markEventsProcessed(pendingEvents.map((e) => e.id));
+        }
+        // Emit event
+        this.eventEmitter.emit({
+            type: "workflow_resumed",
+            workflowId,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Cancel a workflow, stopping the orchestrator and any running executions.
+     *
+     * @param workflowId - The workflow to cancel
+     * @throws WorkflowNotFoundError if workflow doesn't exist
+     * @throws WorkflowStateError if workflow is already completed/failed/cancelled
+     */
+    async cancelWorkflow(workflowId) {
+        const workflow = await this.getWorkflowOrThrow(workflowId);
+        // Check if already in terminal state
+        if (["completed", "failed", "cancelled"].includes(workflow.status)) {
+            throw new WorkflowStateError(workflowId, workflow.status, "cancel");
+        }
+        // Cancel ALL running executions (orchestrator chain + step executions)
+        await this.cancelAllWorkflowExecutions(workflow);
+        // Cancel pending wakeup
+        this.wakeupService.cancelPendingWakeup(workflowId);
+        // Clear any await state
+        this.wakeupService.clearAwaitState(workflowId);
+        // Update status
+        this.updateWorkflow(workflowId, {
+            status: "cancelled",
+            completedAt: new Date().toISOString(),
+        });
+        // Emit event
+        this.eventEmitter.emit({
+            type: "workflow_cancelled",
+            workflowId,
+            timestamp: Date.now(),
+        });
+    }
+    // ===========================================================================
+    // Step Control
+    // ===========================================================================
+    /**
+     * Retry a failed step.
+     *
+     * Records an event for the orchestrator to handle.
+     * The orchestrator decides how to actually retry.
+     *
+     * @param workflowId - The workflow containing the step
+     * @param stepId - The step to retry
+     * @throws WorkflowNotFoundError if workflow doesn't exist
+     * @throws WorkflowStepNotFoundError if step doesn't exist
+     */
+    async retryStep(workflowId, stepId) {
+        const workflow = await this.getWorkflowOrThrow(workflowId);
+        const step = workflow.steps.find((s) => s.id === stepId);
+        if (!step) {
+            throw new WorkflowStepNotFoundError(workflowId, stepId);
+        }
+        // Record event for orchestrator
+        await this.wakeupService.recordEvent({
+            workflowId,
+            type: "step_started", // Re-use step_started as retry signal
+            stepId,
+            payload: {
+                action: "retry",
+                issueId: step.issueId,
+            },
+        });
+    }
+    /**
+     * Skip a step.
+     *
+     * Records an event for the orchestrator to handle.
+     * The orchestrator decides how to handle dependents.
+     *
+     * @param workflowId - The workflow containing the step
+     * @param stepId - The step to skip
+     * @param reason - Optional reason for skipping
+     * @throws WorkflowNotFoundError if workflow doesn't exist
+     * @throws WorkflowStepNotFoundError if step doesn't exist
+     */
+    async skipStep(workflowId, stepId, reason) {
+        const workflow = await this.getWorkflowOrThrow(workflowId);
+        const step = workflow.steps.find((s) => s.id === stepId);
+        if (!step) {
+            throw new WorkflowStepNotFoundError(workflowId, stepId);
+        }
+        // Record event for orchestrator
+        await this.wakeupService.recordEvent({
+            workflowId,
+            type: "step_skipped",
+            stepId,
+            payload: {
+                action: "skip",
+                issueId: step.issueId,
+                reason: reason || "Manually skipped",
+            },
+        });
+    }
+    // ===========================================================================
+    // Escalation
+    // ===========================================================================
+    /**
+     * Trigger a wakeup for an escalation response.
+     *
+     * Called by the API when a user responds to an escalation.
+     * Immediately triggers the orchestrator to resume with the response.
+     *
+     * @param workflowId - The workflow to wake up
+     */
+    async triggerEscalationWakeup(workflowId) {
+        await this.wakeupService.triggerWakeup(workflowId);
+    }
+    // ===========================================================================
+    // Private: Orchestrator Spawning
+    // ===========================================================================
+    /**
+     * Spawn an orchestrator execution (Claude Code agent).
+     *
+     * The orchestrator is given:
+     * - Workflow MCP tools for control
+     * - Initial prompt with workflow context
+     * - Access to sudocode MCP tools for issue management
+     */
+    async spawnOrchestrator(workflow) {
+        // Get issues for initial prompt
+        const issues = this.getIssuesForWorkflow(workflow);
+        // Build initial prompt
+        const prompt = this.promptBuilder.buildInitialPrompt(workflow, issues);
+        // Build agent config with MCP servers
+        const agentConfig = this.buildOrchestratorConfig(workflow);
+        // Determine agent type (default to claude-code)
+        const agentType = workflow.config.orchestratorAgentType ?? "claude-code";
+        // Log the full config being passed to createExecution
+        // Orchestrator runs in the workflow's worktree so it can see step changes
+        const fullConfig = {
+            mode: "worktree",
+            baseBranch: workflow.baseBranch,
+            reuseWorktreePath: workflow.worktreePath,
+            ...agentConfig,
+        };
+        console.log("[OrchestratorWorkflowEngine] Creating execution with config:", JSON.stringify(fullConfig, null, 2));
+        // Create orchestrator execution
+        const execution = await this.executionService.createExecution(null, // No issue - this is the orchestrator itself
+        fullConfig, prompt, agentType);
+        // Store orchestrator execution ID and session ID on workflow
+        this.updateWorkflow(workflow.id, {
+            orchestratorExecutionId: execution.id,
+            orchestratorSessionId: execution.session_id,
+        });
+    }
+    /**
+     * Build the orchestrator agent configuration.
+     *
+     * Configures MCP servers for workflow control and sudocode access.
+     * Enables dangerouslySkipPermissions for automated workflow execution.
+     */
+    buildOrchestratorConfig(workflow) {
+        const config = {
+            // Orchestrator runs autonomously - must skip permission prompts
+            dangerouslySkipPermissions: true,
+        };
+        // Add workflow MCP server
+        // Note: When running in dev mode (tsx/ts-node), __dirname points to src/
+        // but we need the compiled dist/ path. Detect and fix this.
+        let mcpServerPath = this.config.mcpServerPath;
+        if (!mcpServerPath) {
+            const defaultPath = path.join(__dirname, "../mcp/index.js");
+            // If path contains /src/, replace with /dist/ to get compiled version
+            mcpServerPath = defaultPath.includes("/src/")
+                ? defaultPath.replace("/src/", "/dist/")
+                : defaultPath;
+        }
+        console.log("[OrchestratorWorkflowEngine] MCP server path:", mcpServerPath);
+        const mcpArgs = [
+            mcpServerPath,
+            "--workflow-id",
+            workflow.id,
+            "--server-url",
+            this.config.serverUrl,
+            "--project-id",
+            this.config.projectId,
+            "--repo-path",
+            this.config.repoPath,
+        ];
+        config.mcpServers = {
+            "sudocode-workflow": {
+                command: "node",
+                args: mcpArgs,
+            },
+        };
+        // Log the MCP run command for local testing
+        console.log("[OrchestratorWorkflowEngine] MCP server config for workflow", workflow.id);
+        console.log("[OrchestratorWorkflowEngine] To test MCP locally, run:\n" +
+            `  node ${mcpArgs.join(" ")}`);
+        // Set model if specified
+        if (workflow.config.orchestratorModel) {
+            config.model = workflow.config.orchestratorModel;
+        }
+        // Add system prompt extension for orchestrator role
+        config.appendSystemPrompt = `
+You are a workflow orchestrator managing the execution of coding tasks.
+You have access to workflow MCP tools to control execution flow.
+
+IMPORTANT: You are orchestrating workflow "${workflow.id}".
+Use the workflow tools to:
+- Check workflow status with workflow_status
+- Execute issues with execute_issue
+- Inspect results with execution_trajectory and execution_changes
+- Handle failures appropriately based on the workflow config
+- Mark the workflow complete when done with workflow_complete
+`;
+        return config;
+    }
+    /**
+     * Get issues for the workflow (for initial prompt).
+     */
+    getIssuesForWorkflow(workflow) {
+        const issues = [];
+        for (const step of workflow.steps) {
+            const issue = getIssue(this.db, step.issueId);
+            if (issue) {
+                issues.push(issue);
+            }
+        }
+        return issues;
+    }
+    /**
+     * Cancel ALL running executions for a workflow.
+     * This includes:
+     * 1. The entire orchestrator execution chain (root + all follow-ups)
+     * 2. All step executions linked to this workflow
+     */
+    async cancelAllWorkflowExecutions(workflow) {
+        const cancelledIds = new Set();
+        // 1. Cancel the entire orchestrator execution chain
+        if (workflow.orchestratorExecutionId) {
+            // Get the root orchestrator execution by traversing up parent_execution_id
+            let rootId = workflow.orchestratorExecutionId;
+            let safetyCounter = 100; // Prevent infinite loops
+            while (safetyCounter > 0) {
+                const parent = this.db
+                    .prepare("SELECT parent_execution_id FROM executions WHERE id = ?")
+                    .get(rootId);
+                if (!parent || !parent.parent_execution_id) {
+                    break;
+                }
+                rootId = parent.parent_execution_id;
+                safetyCounter--;
+            }
+            // Get all executions in the chain (root + all descendants)
+            const chainExecutions = this.db
+                .prepare(`
+          WITH RECURSIVE execution_chain AS (
+            -- Base case: the root execution
+            SELECT id, status FROM executions WHERE id = ?
+            UNION ALL
+            -- Recursive case: children of executions in the chain
+            SELECT e.id, e.status FROM executions e
+            INNER JOIN execution_chain ec ON e.parent_execution_id = ec.id
+          )
+          SELECT id, status FROM execution_chain
+          WHERE status IN ('pending', 'running', 'preparing')
+        `)
+                .all(rootId);
+            console.log(`[OrchestratorEngine] Cancelling ${chainExecutions.length} orchestrator executions in chain`);
+            for (const { id } of chainExecutions) {
+                if (cancelledIds.has(id))
+                    continue;
+                try {
+                    await this.executionService.cancelExecution(id);
+                    cancelledIds.add(id);
+                }
+                catch (error) {
+                    console.warn(`Failed to cancel orchestrator execution ${id}:`, error);
+                }
+            }
+        }
+        // 2. Cancel all step executions linked to this workflow
+        const stepExecutions = this.db
+            .prepare(`
+        SELECT id FROM executions
+        WHERE workflow_execution_id = ?
+          AND status IN ('pending', 'running', 'preparing')
+      `)
+            .all(workflow.id);
+        console.log(`[OrchestratorEngine] Cancelling ${stepExecutions.length} step executions`);
+        for (const { id } of stepExecutions) {
+            if (cancelledIds.has(id))
+                continue;
+            try {
+                await this.executionService.cancelExecution(id);
+                cancelledIds.add(id);
+            }
+            catch (error) {
+                console.warn(`Failed to cancel step execution ${id}:`, error);
+            }
+        }
+        console.log(`[OrchestratorEngine] Cancelled ${cancelledIds.size} total executions for workflow ${workflow.id}`);
+    }
+    // ===========================================================================
+    // Recovery
+    // ===========================================================================
+    /**
+     * Recover orphaned workflows on server restart.
+     *
+     * Finds workflows in 'running' status whose orchestrator execution
+     * is no longer running, and triggers a wakeup to resume them.
+     */
+    async recoverOrphanedWorkflows() {
+        console.log("[OrchestratorEngine] Checking for orphaned workflows...");
+        // Find workflows in 'running' status
+        const runningWorkflows = this.db
+            .prepare(`SELECT * FROM workflows WHERE status = 'running'`)
+            .all();
+        let recoveredCount = 0;
+        for (const row of runningWorkflows) {
+            // Parse the workflow row
+            const workflow = {
+                id: row.id,
+                title: row.title,
+                source: JSON.parse(row.source),
+                status: row.status,
+                steps: JSON.parse(row.steps),
+                worktreePath: row.worktree_path ?? undefined,
+                branchName: row.branch_name ?? undefined,
+                baseBranch: row.base_branch,
+                currentStepIndex: row.current_step_index,
+                orchestratorExecutionId: row.orchestrator_execution_id ?? undefined,
+                orchestratorSessionId: row.orchestrator_session_id ?? undefined,
+                config: JSON.parse(row.config),
+                createdAt: row.created_at,
+                updatedAt: row.updated_at,
+                startedAt: row.started_at ?? undefined,
+                completedAt: row.completed_at ?? undefined,
+            };
+            // Skip if no orchestrator execution
+            if (!workflow.orchestratorExecutionId) {
+                console.warn(`[OrchestratorEngine] Workflow ${workflow.id} running but no orchestrator`);
+                continue;
+            }
+            // Check orchestrator execution status
+            const orchestrator = this.db
+                .prepare(`SELECT status FROM executions WHERE id = ?`)
+                .get(workflow.orchestratorExecutionId);
+            // If orchestrator is not running, trigger recovery
+            if (!orchestrator || orchestrator.status !== "running") {
+                console.log(`[OrchestratorEngine] Recovering workflow ${workflow.id} ` +
+                    `(orchestrator status: ${orchestrator?.status ?? "not found"})`);
+                try {
+                    // Record recovery event
+                    await this.wakeupService.recordEvent({
+                        workflowId: workflow.id,
+                        type: "orchestrator_wakeup",
+                        payload: {
+                            reason: "recovery",
+                            previousStatus: orchestrator?.status,
+                        },
+                    });
+                    // Trigger wakeup to resume
+                    await this.wakeupService.triggerWakeup(workflow.id);
+                    recoveredCount++;
+                }
+                catch (err) {
+                    console.error(`[OrchestratorEngine] Failed to recover workflow ${workflow.id}:`, err);
+                }
+            }
+        }
+        console.log(`[OrchestratorEngine] Recovery complete: ${recoveredCount}/${runningWorkflows.length} workflows recovered`);
+    }
+    /**
+     * Mark stale running executions as failed.
+     *
+     * Called during recovery to clean up executions that were running
+     * when the server crashed.
+     */
+    async markStaleExecutionsAsFailed() {
+        console.log("[OrchestratorEngine] Checking for stale executions...");
+        const staleExecutions = this.db
+            .prepare(`
+        SELECT id, workflow_execution_id FROM executions
+        WHERE status = 'running'
+          AND workflow_execution_id IS NOT NULL
+      `)
+            .all();
+        for (const exec of staleExecutions) {
+            console.log(`[OrchestratorEngine] Marking stale execution ${exec.id} as failed`);
+            this.db
+                .prepare(`
+          UPDATE executions
+          SET status = 'failed',
+              error_message = 'Execution was running when server restarted',
+              completed_at = ?
+          WHERE id = ?
+        `)
+                .run(new Date().toISOString(), exec.id);
+        }
+        if (staleExecutions.length > 0) {
+            console.log(`[OrchestratorEngine] Marked ${staleExecutions.length} stale executions as failed`);
+        }
+    }
+}
+//# sourceMappingURL=orchestrator-engine.js.map