@sudocode-ai/local-server 0.1.6 → 0.1.8

package/dist/services/execution-service.js

@@ -6,140 +6,50 @@
  *
  * @module services/execution-service
  */
-import { PromptTemplateEngine } from "./prompt-template-engine.js";
 import { ExecutionLifecycleService } from "./execution-lifecycle.js";
 import { createExecution, getExecution, updateExecution, } from "./executions.js";
-import { getDefaultTemplate, getTemplateById } from "./prompt-templates.js";
 import { randomUUID } from "crypto";
-import { SimpleProcessManager } from "../execution/process/simple-manager.js";
-import { SimpleExecutionEngine } from "../execution/engine/simple-engine.js";
-import { ResilientExecutor } from "../execution/resilience/resilient-executor.js";
-import { LinearOrchestrator } from "../execution/workflow/linear-orchestrator.js";
-import { createAgUiSystem } from "../execution/output/ag-ui-integration.js";
+import { execSync } from "child_process";
 import { ExecutionLogsStore } from "./execution-logs-store.js";
+import { broadcastExecutionUpdate } from "./websocket.js";
+import { createExecutorForAgent } from "../execution/executors/executor-factory.js";
+import { PromptResolver } from "./prompt-resolver.js";
 /**
  * ExecutionService
  *
  * Manages the full lifecycle of issue-based executions:
- * - Preparing execution with template rendering
  * - Creating and starting executions with worktree isolation
  * - Creating follow-up executions that reuse worktrees
  * - Canceling and cleaning up executions
  */
 export class ExecutionService {
     db;
-    templateEngine;
+    projectId;
     lifecycleService;
     repoPath;
     transportManager;
     logsStore;
-    activeOrchestrators = new Map();
+    workerPool;
     /**
      * Create a new ExecutionService
      *
      * @param db - Database instance
+     * @param projectId - Project ID for WebSocket broadcasts
      * @param repoPath - Path to the git repository
      * @param lifecycleService - Optional execution lifecycle service (creates one if not provided)
      * @param transportManager - Optional transport manager for SSE streaming
      * @param logsStore - Optional execution logs store (creates one if not provided)
+     * @param workerPool - Optional worker pool for isolated execution processes
      */
-    constructor(db, repoPath, lifecycleService, transportManager, logsStore) {
+    constructor(db, projectId, repoPath, lifecycleService, transportManager, logsStore, workerPool) {
         this.db = db;
+        this.projectId = projectId;
         this.repoPath = repoPath;
-        this.templateEngine = new PromptTemplateEngine();
         this.lifecycleService =
             lifecycleService || new ExecutionLifecycleService(db, repoPath);
         this.transportManager = transportManager;
         this.logsStore = logsStore || new ExecutionLogsStore(db);
-    }
-    /**
-     * Prepare execution - load issue, render template, return preview
-     *
-     * This method loads the issue and related context, renders the template,
-     * and returns a preview for the user to review before starting execution.
-     *
-     * @param issueId - ID of issue to prepare execution for
-     * @param options - Optional template and config overrides
-     * @returns Execution prepare result with rendered prompt and context
-     */
-    async prepareExecution(issueId, options) {
-        // 1. Load issue
-        const issue = this.db
-            .prepare("SELECT * FROM issues WHERE id = ?")
-            .get(issueId);
-        if (!issue) {
-            throw new Error(`Issue ${issueId} not found`);
-        }
-        // 2. Load related specs (via implements/references relationships)
-        const relatedSpecs = this.db
-            .prepare(`
-      SELECT DISTINCT s.id, s.title
-      FROM specs s
-      JOIN relationships r ON r.to_id = s.id AND r.to_type = 'spec'
-      WHERE r.from_id = ? AND r.from_type = 'issue'
-        AND r.relationship_type IN ('implements', 'references')
-      ORDER BY s.title
-    `)
-            .all(issueId);
-        // 3. Build context for template rendering
-        const context = {
-            issueId: issue.id,
-            title: issue.title,
-            description: issue.content,
-            relatedSpecs: relatedSpecs.length > 0
-                ? relatedSpecs.map((s) => ({
-                    id: s.id,
-                    title: s.title,
-                }))
-                : undefined,
-        };
-        // 4. Get template (use custom template if provided, otherwise default)
-        let template;
-        if (options?.templateId) {
-            const customTemplate = getTemplateById(this.db, options.templateId);
-            if (!customTemplate) {
-                throw new Error(`Template ${options.templateId} not found`);
-            }
-            template = customTemplate.template;
-        }
-        else {
-            const defaultTemplate = getDefaultTemplate(this.db, "issue");
-            if (!defaultTemplate) {
-                throw new Error("Default issue template not found");
-            }
-            template = defaultTemplate.template;
-        }
-        // 5. Render template
-        const renderedPrompt = this.templateEngine.render(template, context);
-        // 6. Get default config
-        const defaultConfig = {
-            mode: "worktree",
-            model: "claude-sonnet-4",
-            baseBranch: "main",
-            checkpointInterval: 1,
-            continueOnStepFailure: false,
-            captureFileChanges: true,
-            captureToolCalls: true,
-            ...options?.config,
-        };
-        // 7. Validate
-        const warnings = [];
-        const errors = [];
-        if (!renderedPrompt.trim()) {
-            errors.push("Rendered prompt is empty");
-        }
-        return {
-            renderedPrompt,
-            issue: {
-                id: issue.id,
-                title: issue.title,
-                content: issue.content,
-            },
-            relatedSpecs,
-            defaultConfig,
-            warnings,
-            errors,
-        };
+        this.workerPool = workerPool;
     }
     /**
      * Create and start execution
@@ -151,9 +61,10 @@ export class ExecutionService {
      * @param issueId - ID of issue to execute
      * @param config - Execution configuration
      * @param prompt - Rendered prompt to execute
+     * @param agentType - Type of agent to use (defaults to 'claude-code')
      * @returns Created execution record
      */
-    async createExecution(issueId, config, prompt) {
+    async createExecution(issueId, config, prompt, agentType = "claude-code") {
         // 1. Validate
         if (!prompt.trim()) {
             throw new Error("Prompt cannot be empty");
@@ -165,23 +76,51 @@ export class ExecutionService {
             throw new Error(`Issue ${issueId} not found`);
         }
         // 2. Determine execution mode and create execution with worktree
+        // Store the original (unexpanded) prompt in the database
         const mode = config.mode || "worktree";
         let execution;
         let workDir;
         if (mode === "worktree") {
-            // Create execution with isolated worktree
-            const result = await this.lifecycleService.createExecutionWithWorktree({
-                issueId,
-                issueTitle: issue.title,
-                agentType: "claude-code",
-                targetBranch: config.baseBranch || "main",
-                repoPath: this.repoPath,
-                mode: mode,
-                prompt: prompt,
-                config: JSON.stringify(config),
-            });
-            execution = result.execution;
-            workDir = result.worktreePath;
+            // Check if we're reusing an existing worktree
+            if (config.reuseWorktreeId) {
+                // Reuse existing worktree
+                const existingExecution = this.db
+                    .prepare("SELECT * FROM executions WHERE id = ?")
+                    .get(config.reuseWorktreeId);
+                if (!existingExecution || !existingExecution.worktree_path) {
+                    throw new Error(`Cannot reuse worktree: execution ${config.reuseWorktreeId} not found or has no worktree`);
+                }
+                // Create execution record with the same worktree path
+                const executionId = randomUUID();
+                execution = createExecution(this.db, {
+                    id: executionId,
+                    issue_id: issueId,
+                    agent_type: agentType,
+                    mode: mode,
+                    prompt: prompt,
+                    config: JSON.stringify(config),
+                    target_branch: existingExecution.target_branch,
+                    branch_name: existingExecution.branch_name,
+                    worktree_path: existingExecution.worktree_path, // Reuse the same worktree path
+                });
+                workDir = existingExecution.worktree_path;
+            }
+            else {
+                // Create execution with isolated worktree
+                const result = await this.lifecycleService.createExecutionWithWorktree({
+                    issueId,
+                    issueTitle: issue.title,
+                    agentType: agentType,
+                    targetBranch: config.baseBranch || "main",
+                    repoPath: this.repoPath,
+                    mode: mode,
+                    prompt: prompt, // Store original (unexpanded) prompt
+                    config: JSON.stringify(config),
+                    createTargetBranch: config.createBaseBranch || false,
+                });
+                execution = result.execution;
+                workDir = result.worktreePath;
+            }
         }
         else {
             // Local mode - create execution without worktree
@@ -189,14 +128,40 @@ export class ExecutionService {
             execution = createExecution(this.db, {
                 id: executionId,
                 issue_id: issueId,
-                agent_type: "claude-code",
+                agent_type: agentType,
                 mode: mode,
-                prompt: prompt,
+                prompt: prompt, // Store original (unexpanded) prompt
                 config: JSON.stringify(config),
                 target_branch: config.baseBranch || "main",
                 branch_name: config.baseBranch || "main",
             });
             workDir = this.repoPath;
+            // Capture current commit as before_commit for local mode
+            try {
+                const beforeCommit = execSync("git rev-parse HEAD", {
+                    cwd: this.repoPath,
+                    encoding: "utf-8",
+                }).trim();
+                updateExecution(this.db, executionId, {
+                    before_commit: beforeCommit,
+                });
+                // Reload execution to get updated before_commit
+                const updatedExecution = getExecution(this.db, executionId);
+                if (updatedExecution) {
+                    execution = updatedExecution;
+                }
+            }
+            catch (error) {
+                console.warn("[ExecutionService] Failed to capture before_commit for local mode:", error instanceof Error ? error.message : String(error));
+                // Continue - this is supplementary data
+            }
+        }
+        // 3. Resolve prompt references for execution (done after storing original)
+        // Pass the issue ID so the issue content is automatically included even if not explicitly mentioned
+        const resolver = new PromptResolver(this.db);
+        const { resolvedPrompt, errors } = await resolver.resolve(prompt, new Set(), issueId);
+        if (errors.length > 0) {
+            console.warn(`[ExecutionService] Prompt resolution warnings:`, errors);
         }
         // Initialize empty logs for this execution
         try {
@@ -209,187 +174,76 @@ export class ExecutionService {
             });
             // Don't fail execution creation - logs are nice-to-have
         }
-        // 3. Build WorkflowDefinition
-        const workflow = {
-            id: `workflow-${execution.id}`,
-            steps: [
-                {
-                    id: "execute-issue",
-                    taskType: "issue",
-                    prompt,
-                    taskConfig: {
-                        model: config.model || "claude-sonnet-4",
-                        timeout: config.timeout,
-                        captureFileChanges: config.captureFileChanges ?? true,
-                        captureToolCalls: config.captureToolCalls ?? true,
-                    },
-                },
-            ],
+        // 3. Start execution (use worker pool if available, otherwise fall back to in-process)
+        if (this.workerPool) {
+            // Worker pool handles all execution logic in isolated process
+            const dbPath = this.db.name;
+            await this.workerPool.startExecution(execution, this.repoPath, dbPath);
+            // Broadcast execution creation
+            broadcastExecutionUpdate(this.projectId, execution.id, "created", execution, execution.issue_id || undefined);
+            return execution;
+        }
+        // 4. In-process execution with executor wrapper (fallback when no worker pool)
+        const wrapper = createExecutorForAgent(agentType, { workDir: this.repoPath }, // Agent-specific config (minimal for now)
+        {
+            workDir: this.repoPath,
+            lifecycleService: this.lifecycleService,
+            logsStore: this.logsStore,
+            projectId: this.projectId,
+            db: this.db,
+            transportManager: this.transportManager,
+        });
+        // Build execution task (prompt already resolved above)
+        const task = {
+            id: execution.id,
+            type: "issue",
+            entityId: issueId,
+            prompt: resolvedPrompt,
+            workDir: workDir,
             config: {
-                checkpointInterval: config.checkpointInterval ?? 1,
-                continueOnStepFailure: config.continueOnStepFailure ?? false,
                 timeout: config.timeout,
             },
             metadata: {
-                workDir,
+                model: config.model || "claude-sonnet-4",
+                captureFileChanges: config.captureFileChanges ?? true,
+                captureToolCalls: config.captureToolCalls ?? true,
                 issueId,
                 executionId: execution.id,
             },
+            priority: 0,
+            dependencies: [],
+            createdAt: new Date(),
         };
-        // 4. Create execution engine stack
-        const processManager = new SimpleProcessManager({
-            executablePath: "claude",
-            args: [
-                "--print",
-                "--output-format",
-                "stream-json",
-                "--dangerously-skip-permissions",
-            ],
-        });
-        let engine = new SimpleExecutionEngine(processManager, {
-            maxConcurrent: 1, // One task at a time for issue execution
+        // Execute with full lifecycle management (non-blocking)
+        wrapper.executeWithLifecycle(execution.id, task, workDir).catch((error) => {
+            console.error(`[ExecutionService] Execution ${execution.id} failed:`, error);
+            // Error is already handled by wrapper (status updated, broadcasts sent)
         });
-        let executor = new ResilientExecutor(engine);
-        // 5. Create AG-UI system (processor + adapter) if transport manager is available
-        let agUiAdapter;
-        if (this.transportManager) {
-            const agUiSystem = createAgUiSystem(execution.id);
-            agUiAdapter = agUiSystem.adapter;
-            // Connect adapter to transport for SSE streaming
-            this.transportManager.connectAdapter(agUiAdapter, execution.id);
-            // Connect processor to execution engine for real-time output parsing
-            // Buffer for incomplete lines (stream-json can split mid-line)
-            let lineBuffer = "";
-            engine = new SimpleExecutionEngine(processManager, {
-                maxConcurrent: 1,
-                // TODO: Factor out this logic for DRY principles.
-                onOutput: (data, type) => {
-                    if (type === "stdout") {
-                        // Append new data to buffer
-                        lineBuffer += data.toString();
-                        // Process complete lines (ending with \n)
-                        let newlineIndex;
-                        while ((newlineIndex = lineBuffer.indexOf("\n")) !== -1) {
-                            const line = lineBuffer.slice(0, newlineIndex);
-                            lineBuffer = lineBuffer.slice(newlineIndex + 1);
-                            if (line.trim()) {
-                                // 1. Persist raw log immediately (before processing)
-                                try {
-                                    this.logsStore.appendRawLog(execution.id, line);
-                                }
-                                catch (err) {
-                                    console.error("[ExecutionService] Failed to persist raw log (non-critical):", {
-                                        executionId: execution.id,
-                                        error: err instanceof Error ? err.message : String(err),
-                                    });
-                                    // Don't crash execution - logs are nice-to-have
-                                }
-                                // 2. Process through AG-UI pipeline for live clients
-                                agUiSystem.processor.processLine(line).catch((err) => {
-                                    console.error("[ExecutionService] Error processing output line:", {
-                                        error: err instanceof Error ? err.message : String(err),
-                                        line: line.slice(0, 100), // Log first 100 chars for debugging
-                                    });
-                                });
-                            }
-                        }
-                    }
-                },
-            });
-            executor = new ResilientExecutor(engine);
-        }
-        // 6. Create LinearOrchestrator
-        const orchestrator = new LinearOrchestrator(executor, undefined, // No storage/checkpointing for now
-        agUiAdapter, this.lifecycleService);
-        // 7. Register event handlers to update execution status in database
-        orchestrator.onWorkflowStart(() => {
-            try {
-                updateExecution(this.db, execution.id, {
-                    status: "running",
-                });
-            }
-            catch (error) {
-                console.error("[ExecutionService] Failed to update execution status to running", {
-                    executionId: execution.id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        });
-        orchestrator.onWorkflowComplete(() => {
-            console.log("[ExecutionService] Workflow completed successfully", {
-                executionId: execution.id,
-            });
-            try {
-                updateExecution(this.db, execution.id, {
-                    status: "completed",
-                    completed_at: new Date().toISOString(),
-                });
-            }
-            catch (error) {
-                console.error("[ExecutionService] Failed to update execution status to completed", {
-                    executionId: execution.id,
-                    error: error instanceof Error ? error.message : String(error),
-                    note: "Execution may have been deleted (e.g., due to CASCADE DELETE from issue deletion)",
-                });
-            }
-            // Remove orchestrator from active map
-            this.activeOrchestrators.delete(execution.id);
-        });
-        orchestrator.onWorkflowFailed((_executionId, error) => {
-            console.error("[ExecutionService] Workflow failed", {
-                executionId: execution.id,
-                error: error.message,
-                stack: error.stack,
-            });
-            try {
-                updateExecution(this.db, execution.id, {
-                    status: "failed",
-                    completed_at: new Date().toISOString(),
-                    error_message: error.message,
-                });
-            }
-            catch (updateError) {
-                console.error("[ExecutionService] Failed to update execution status to failed", {
-                    executionId: execution.id,
-                    error: updateError instanceof Error
-                        ? updateError.message
-                        : String(updateError),
-                    note: "Execution may have been deleted (e.g., due to CASCADE DELETE from issue deletion)",
-                });
-            }
-            // Remove orchestrator from active map
-            this.activeOrchestrators.delete(execution.id);
-        });
-        // 8. Start workflow execution (non-blocking)
-        orchestrator.startWorkflow(workflow, workDir, {
-            checkpointInterval: config.checkpointInterval,
-            executionId: execution.id,
-        });
-        // 9. Store orchestrator for later cancellation
-        this.activeOrchestrators.set(execution.id, orchestrator);
+        // Broadcast execution creation
+        broadcastExecutionUpdate(this.projectId, execution.id, "created", execution, execution.issue_id || undefined);
         return execution;
     }
     /**
-     * Create follow-up execution - reuse worktree from previous execution
+     * Create follow-up execution
      *
-     * Creates a new execution that reuses the worktree from a previous execution,
-     * appending feedback or additional context to the prompt.
+     * For worktree-based executions: reuses the worktree and resumes the session.
+     * For local/non-worktree executions: creates a new execution with feedback context.
      *
      * @param executionId - ID of previous execution to follow up on
      * @param feedback - Additional feedback/context to append to prompt
+     * @param options - Optional configuration
+     * @param options.includeOriginalPrompt - Whether to prepend the original issue content (default: false, assumes session resumption with full history)
      * @returns Created follow-up execution record
      */
-    async createFollowUp(executionId, feedback) {
+    async createFollowUp(executionId, feedback, options) {
         // 1. Get previous execution
         const prevExecution = getExecution(this.db, executionId);
         if (!prevExecution) {
             throw new Error(`Execution ${executionId} not found`);
         }
-        if (!prevExecution.worktree_path) {
-            throw new Error(`Cannot create follow-up: execution ${executionId} has no worktree`);
-        }
-        // Check if worktree still exists on filesystem, recreate if needed
-        if (this.lifecycleService) {
+        const hasWorktree = !!prevExecution.worktree_path;
+        // For worktree executions, check if worktree still exists on filesystem, recreate if needed
+        if (hasWorktree && this.lifecycleService) {
             const fs = await import("fs");
             const worktreeExists = fs.existsSync(prevExecution.worktree_path);
             if (!worktreeExists) {
@@ -405,30 +259,41 @@ export class ExecutionService {
                 });
             }
         }
-        // 2. Validate that previous execution has an issue_id
-        if (!prevExecution.issue_id) {
-            throw new Error("Previous execution must have an issue_id for follow-up");
-        }
-        // 3. Prepare execution to get rendered prompt
-        const prepareResult = await this.prepareExecution(prevExecution.issue_id);
-        // 4. Append feedback to prompt
-        const followUpPrompt = `${prepareResult.renderedPrompt}
-
-## Follow-up Feedback
-${feedback}
+        // TODO: Make it so follow-ups don't require an issue id.
+        // 2. Build follow-up prompt (default: just feedback, assumes session resumption)
+        let followUpPrompt = feedback;
+        if (options?.includeOriginalPrompt) {
+            // Optional: include original issue content if explicitly requested
+            if (!prevExecution.issue_id) {
+                throw new Error("Previous execution must have an issue_id to include original prompt");
+            }
+            // Get issue content directly from database
+            const issue = this.db
+                .prepare("SELECT content FROM issues WHERE id = ?")
+                .get(prevExecution.issue_id);
+            if (!issue) {
+                throw new Error(`Issue ${prevExecution.issue_id} not found`);
+            }
+            followUpPrompt = `${issue.content}
 
-Please continue working on this issue, taking into account the feedback above.`;
-        // 5. Create new execution record that references previous execution
+${feedback}`;
+        }
+        // 3. Create new execution record that references previous execution
+        // Default to 'claude-code' if agent_type is null (for backwards compatibility)
+        const agentType = (prevExecution.agent_type || "claude-code");
+        // Determine working directory: worktree path if available, otherwise repo path (local mode)
+        const workDir = hasWorktree ? prevExecution.worktree_path : this.repoPath;
         const newExecutionId = randomUUID();
         const newExecution = createExecution(this.db, {
             id: newExecutionId,
             issue_id: prevExecution.issue_id,
-            agent_type: "claude-code",
+            agent_type: agentType, // Use same agent as previous execution
             target_branch: prevExecution.target_branch,
             branch_name: prevExecution.branch_name,
-            // TODO: Handle case where worktree has been deleted.
-            worktree_path: prevExecution.worktree_path, // Reuse same worktree
+            worktree_path: prevExecution.worktree_path || undefined, // Reuse same worktree (undefined for local)
             config: prevExecution.config || undefined, // Preserve config (including cleanupMode) from previous execution
+            parent_execution_id: executionId, // Link to parent execution for follow-up chain
+            prompt: followUpPrompt, // Store original (unexpanded) follow-up prompt
         });
         // Initialize empty logs for this execution
         try {
@@ -441,149 +306,81 @@ Please continue working on this issue, taking into account the feedback above.`;
             });
             // Don't fail execution creation - logs are nice-to-have
         }
-        // 5. Build WorkflowDefinition
-        const workflow = {
-            id: `workflow-${newExecution.id}`,
-            steps: [
-                {
-                    id: "execute-followup",
-                    taskType: "issue",
-                    prompt: followUpPrompt,
-                    taskConfig: {
-                        model: "claude-sonnet-4",
-                        captureFileChanges: true,
-                        captureToolCalls: true,
-                    },
-                },
-            ],
+        // Collect already-expanded entities from parent execution chain
+        const alreadyExpandedIds = await this.collectExpandedEntitiesFromChain(executionId);
+        // Resolve prompt references for execution (done after storing original)
+        // Skip entities that were already expanded in parent executions
+        const resolver = new PromptResolver(this.db);
+        const { resolvedPrompt, errors } = await resolver.resolve(followUpPrompt, alreadyExpandedIds);
+        if (errors.length > 0) {
+            console.warn(`[ExecutionService] Follow-up prompt resolution warnings:`, errors);
+        }
+        // 4. Use executor wrapper with session resumption
+        const wrapper = createExecutorForAgent(agentType, { workDir: this.repoPath }, {
+            workDir: this.repoPath,
+            lifecycleService: this.lifecycleService,
+            logsStore: this.logsStore,
+            projectId: this.projectId,
+            db: this.db,
+            transportManager: this.transportManager,
+        });
+        // Use previous execution's session_id (the actual Claude UUID) if available
+        // This enables proper session resumption with Claude Code's --resume-session flag
+        // If no session_id was captured, we can't resume - this would start a new session
+        const sessionId = prevExecution.session_id;
+        if (!sessionId) {
+            console.warn(`[ExecutionService] No session_id found for execution ${executionId}, follow-up will start a new session`);
+        }
+        // Parse config to get model and other settings
+        const parsedConfig = prevExecution.config
+            ? JSON.parse(prevExecution.config)
+            : {};
+        // Build execution task for follow-up (use resolved prompt for agent)
+        const task = {
+            id: newExecution.id,
+            type: "issue",
+            entityId: prevExecution.issue_id ?? undefined,
+            prompt: resolvedPrompt,
+            workDir: workDir,
             config: {
-                checkpointInterval: 1,
-                continueOnStepFailure: false,
+                timeout: parsedConfig.timeout,
             },
             metadata: {
-                workDir: prevExecution.worktree_path,
-                issueId: prevExecution.issue_id,
+                model: parsedConfig.model || "claude-sonnet-4",
+                captureFileChanges: parsedConfig.captureFileChanges ?? true,
+                captureToolCalls: parsedConfig.captureToolCalls ?? true,
+                issueId: prevExecution.issue_id ?? undefined,
                 executionId: newExecution.id,
                 followUpOf: executionId,
             },
+            priority: 0,
+            dependencies: [],
+            createdAt: new Date(),
         };
-        // 6. Create execution engine stack
-        const processManager = new SimpleProcessManager({
-            executablePath: "claude",
-            args: [
-                "--print",
-                "--output-format",
-                "stream-json",
-                "--dangerously-skip-permissions",
-            ],
-        });
-        let engine = new SimpleExecutionEngine(processManager, {
-            maxConcurrent: 1,
-        });
-        let executor = new ResilientExecutor(engine);
-        // 7. Create AG-UI system (processor + adapter) if transport manager is available
-        let agUiAdapter;
-        if (this.transportManager) {
-            const agUiSystem = createAgUiSystem(newExecution.id);
-            agUiAdapter = agUiSystem.adapter;
-            this.transportManager.connectAdapter(agUiAdapter, newExecution.id);
-            // Connect processor to execution engine for real-time output parsing
-            // Buffer for incomplete lines (stream-json can split mid-line)
-            let lineBuffer = "";
-            engine = new SimpleExecutionEngine(processManager, {
-                maxConcurrent: 1,
-                // TODO: Factor out this logic for DRY principles.
-                onOutput: (data, type) => {
-                    if (type === "stdout") {
-                        // Append new data to buffer
-                        lineBuffer += data.toString();
-                        // Process complete lines (ending with \n)
-                        let newlineIndex;
-                        while ((newlineIndex = lineBuffer.indexOf("\n")) !== -1) {
-                            const line = lineBuffer.slice(0, newlineIndex);
-                            lineBuffer = lineBuffer.slice(newlineIndex + 1);
-                            if (line.trim()) {
-                                // 1. Persist raw log immediately (before processing)
-                                try {
-                                    this.logsStore.appendRawLog(newExecution.id, line);
-                                }
-                                catch (err) {
-                                    console.error("[ExecutionService] Failed to persist raw log (non-critical):", {
-                                        executionId: newExecution.id,
-                                        error: err instanceof Error ? err.message : String(err),
-                                    });
-                                    // Don't crash execution - logs are nice-to-have
-                                }
-                                // 2. Process through AG-UI pipeline for live clients
-                                agUiSystem.processor.processLine(line).catch((err) => {
-                                    console.error("[ExecutionService] Error processing output line:", {
-                                        error: err instanceof Error ? err.message : String(err),
-                                        line: line.slice(0, 100), // Log first 100 chars for debugging
-                                    });
-                                });
-                            }
-                        }
-                    }
-                },
+        // Execute follow-up (non-blocking)
+        // If we have a session ID, resume the session; otherwise start a new one
+        if (sessionId) {
+            wrapper
+                .resumeWithLifecycle(newExecution.id, sessionId, task, workDir)
+                .catch((error) => {
+                console.error(`[ExecutionService] Follow-up execution ${newExecution.id} failed:`, error);
+                // Error is already handled by wrapper (status updated, broadcasts sent)
             });
-            executor = new ResilientExecutor(engine);
         }
-        // 8. Create LinearOrchestrator
-        const orchestrator = new LinearOrchestrator(executor, undefined, agUiAdapter, this.lifecycleService);
-        // 9. Register event handlers
-        orchestrator.onWorkflowStart(() => {
-            try {
-                updateExecution(this.db, newExecution.id, {
-                    status: "running",
-                });
-            }
-            catch (error) {
-                console.error("[ExecutionService] Failed to update follow-up execution status to running", {
-                    executionId: newExecution.id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        });
-        orchestrator.onWorkflowComplete(() => {
-            try {
-                updateExecution(this.db, newExecution.id, {
-                    status: "completed",
-                    completed_at: new Date().toISOString(),
-                });
-            }
-            catch (error) {
-                console.error("[ExecutionService] Failed to update follow-up execution status to completed", {
-                    executionId: newExecution.id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            this.activeOrchestrators.delete(newExecution.id);
-        });
-        orchestrator.onWorkflowFailed((_execId, error) => {
-            try {
-                updateExecution(this.db, newExecution.id, {
-                    status: "failed",
-                    completed_at: new Date().toISOString(),
-                    error_message: error.message,
-                });
-            }
-            catch (updateError) {
-                console.error("[ExecutionService] Failed to update follow-up execution status to failed", {
-                    executionId: newExecution.id,
-                    error: updateError instanceof Error
-                        ? updateError.message
-                        : String(updateError),
-                });
-            }
-            this.activeOrchestrators.delete(newExecution.id);
-        });
-        // 10. Start workflow execution (non-blocking)
-        orchestrator.startWorkflow(workflow, prevExecution.worktree_path, {
-            checkpointInterval: 1,
-            executionId: newExecution.id,
-        });
-        // 11. Store orchestrator for later cancellation
-        this.activeOrchestrators.set(newExecution.id, orchestrator);
+        else {
+            // No session to resume, start a new execution with the follow-up prompt
+            wrapper
+                .executeWithLifecycle(newExecution.id, task, workDir)
+                .catch((error) => {
+                console.error(`[ExecutionService] Follow-up execution ${newExecution.id} failed:`, error);
+            });
+        }
+        // Broadcast execution creation
+        broadcastExecutionUpdate(this.projectId, newExecution.id, "created", newExecution, newExecution.issue_id || undefined);
+        // Also broadcast to parent execution channel
+        if (newExecution.parent_execution_id) {
+            broadcastExecutionUpdate(this.projectId, newExecution.parent_execution_id, "updated", newExecution, newExecution.issue_id || undefined);
+        }
         return newExecution;
     }
     /**
@@ -602,19 +399,26 @@ Please continue working on this issue, taking into account the feedback above.`;
         if (execution.status !== "running") {
             throw new Error(`Cannot cancel execution in ${execution.status} state`);
         }
-        // Get orchestrator from active map
-        const orchestrator = this.activeOrchestrators.get(executionId);
-        if (orchestrator) {
-            // Cancel via orchestrator
-            await orchestrator.cancelWorkflow(executionId);
-            // Remove from active map
-            this.activeOrchestrators.delete(executionId);
+        // Use worker pool cancellation if available
+        if (this.workerPool && this.workerPool.hasWorker(executionId)) {
+            await this.workerPool.cancelExecution(executionId);
+            return; // Worker pool handles DB updates and broadcasts
         }
-        // Update status in database (orchestrator.cancelWorkflow doesn't emit events for DB update)
+        // For in-process executions using AgentExecutorWrapper:
+        // The wrapper manages its own lifecycle and cancellation.
+        // We update the database status, which the wrapper may check,
+        // or we rely on process termination to stop execution.
+        // TODO: Add cancellation registry in AgentExecutorWrapper for direct process control
+        // Update status in database
         updateExecution(this.db, executionId, {
             status: "stopped",
             completed_at: new Date().toISOString(),
         });
+        // Broadcast status change
+        const updated = getExecution(this.db, executionId);
+        if (updated) {
+            broadcastExecutionUpdate(this.projectId, executionId, "status_changed", updated, updated.issue_id || undefined);
+        }
     }
     /**
      * Clean up execution resources
@@ -649,9 +453,10 @@ Please continue working on this issue, taking into account the feedback above.`;
      * when they're configured for manual cleanup.
      *
      * @param executionId - ID of execution whose worktree to delete
+     * @param deleteBranch - Whether to also delete the execution's branch (default: false)
      * @throws Error if execution not found, has no worktree, or worktree doesn't exist
      */
-    async deleteWorktree(executionId) {
+    async deleteWorktree(executionId, deleteBranch = false) {
         const execution = getExecution(this.db, executionId);
         if (!execution) {
             throw new Error(`Execution ${executionId} not found`);
@@ -670,6 +475,146 @@ Please continue working on this issue, taking into account the feedback above.`;
         const worktreeManager = this.lifecycleService.worktreeManager;
         // Clean up the worktree
         await worktreeManager.cleanupWorktree(execution.worktree_path, this.repoPath);
+        // Delete branch if requested and it was created by this execution
+        if (deleteBranch && execution.branch_name) {
+            try {
+                // A branch was created for this execution if:
+                // - branch_name is DIFFERENT from target_branch (autoCreateBranches was true)
+                // - This means a new worktree-specific branch was created
+                const wasCreatedByExecution = execution.branch_name !== execution.target_branch &&
+                    execution.branch_name !== "(detached)";
+                if (wasCreatedByExecution) {
+                    await worktreeManager.git.deleteBranch(this.repoPath, execution.branch_name, true // Force deletion
+                    );
+                    console.log(`[ExecutionService] Deleted execution-created branch: ${execution.branch_name}`);
+                }
+                else {
+                    console.log(`[ExecutionService] Skipping branch deletion - branch ${execution.branch_name} is the target branch (not created by execution)`);
+                }
+            }
+            catch (err) {
+                console.warn(`Failed to delete branch ${execution.branch_name} during worktree deletion:`, err);
+                // Continue even if branch deletion fails
+            }
+        }
+    }
+    /**
+     * Delete an execution and its entire chain
+     *
+     * Deletes the execution and all its follow-ups (descendants).
+     * Optionally deletes the worktree and/or branch.
+     *
+     * @param executionId - ID of execution to delete (can be root or any execution in chain)
+     * @param deleteBranch - Whether to also delete the execution's branch (default: false)
+     * @param deleteWorktree - Whether to also delete the execution's worktree (default: false)
+     * @throws Error if execution not found
+     */
+    async deleteExecution(executionId, deleteBranch = false, deleteWorktree = false) {
+        const execution = getExecution(this.db, executionId);
+        if (!execution) {
+            throw new Error(`Execution ${executionId} not found`);
+        }
+        // Find the root execution by traversing up parent_execution_id
+        let rootId = executionId;
+        let current = execution;
+        while (current.parent_execution_id) {
+            rootId = current.parent_execution_id;
+            const parent = getExecution(this.db, rootId);
+            if (!parent)
+                break;
+            current = parent;
+        }
+        // Get all executions in the chain (root + all descendants)
+        const chain = this.db
+            .prepare(`
+      WITH RECURSIVE execution_chain AS (
+        -- Base case: the root execution
+        SELECT * FROM executions WHERE id = ?
+        UNION ALL
+        -- Recursive case: children of executions in the chain
+        SELECT e.* FROM executions e
+        INNER JOIN execution_chain ec ON e.parent_execution_id = ec.id
+      )
+      SELECT * FROM execution_chain
+    `)
+            .all(rootId);
+        // Cancel any running executions in the chain
+        for (const exec of chain) {
+            if (exec.status === "running" || exec.status === "pending") {
+                try {
+                    await this.cancelExecution(exec.id);
+                }
+                catch (err) {
+                    console.warn(`Failed to cancel execution ${exec.id} during deletion:`, err);
+                    // Continue with deletion even if cancel fails
+                }
+            }
+        }
+        // Delete worktree if requested and it exists (only for root execution)
+        const rootExecution = chain.find((e) => e.id === rootId);
+        if (deleteWorktree && rootExecution?.worktree_path) {
+            try {
+                const fs = await import("fs");
+                if (fs.existsSync(rootExecution.worktree_path)) {
+                    await this.deleteWorktree(rootId);
+                }
+            }
+            catch (err) {
+                console.warn(`Failed to delete worktree during execution deletion:`, err);
+                // Continue with deletion even if worktree cleanup fails
+            }
+        }
+        // Delete branch if requested and it exists
+        // IMPORTANT: Only delete branches that were created specifically for this execution
+        if (deleteBranch && rootExecution?.branch_name) {
+            try {
+                // A branch was created for this execution if:
+                // - branch_name is DIFFERENT from target_branch (autoCreateBranches was true)
+                // - This means a new worktree-specific branch was created
+                //
+                // A branch was NOT created (reusing existing) if:
+                // - branch_name === target_branch (autoCreateBranches was false)
+                // - This means the worktree reused the target branch directly
+                const wasCreatedByExecution = rootExecution.branch_name !== rootExecution.target_branch &&
+                    rootExecution.branch_name !== "(detached)";
+                if (wasCreatedByExecution) {
+                    // Get worktree manager from lifecycle service to access git operations
+                    const worktreeManager = this.lifecycleService
+                        .worktreeManager;
+                    await worktreeManager.git.deleteBranch(this.repoPath, rootExecution.branch_name, true // Force deletion
+                    );
+                    console.log(`[ExecutionService] Deleted execution-created branch: ${rootExecution.branch_name}`);
+                }
+                else {
+                    console.log(`[ExecutionService] Skipping branch deletion - branch ${rootExecution.branch_name} is the target branch (not created by execution)`);
+                }
+            }
+            catch (err) {
+                console.warn(`Failed to delete branch ${rootExecution.branch_name} during execution deletion:`, err);
+                // Continue with deletion even if branch deletion fails
+            }
+        }
+        // Delete execution logs for all executions in the chain
+        for (const exec of chain) {
+            try {
+                this.logsStore.deleteLogs(exec.id);
+            }
+            catch (err) {
+                console.warn(`Failed to delete logs for execution ${exec.id}:`, err);
+                // Continue with deletion even if log cleanup fails
+            }
+        }
+        // Delete all executions in the chain from database
+        // Delete in reverse order (children first) to avoid foreign key issues
+        const chainIds = chain.map((e) => e.id);
+        const placeholders = chainIds.map(() => "?").join(",");
+        this.db
+            .prepare(`DELETE FROM executions WHERE id IN (${placeholders})`)
+            .run(...chainIds);
+        // Broadcast deletion event for each execution
+        for (const exec of chain) {
+            broadcastExecutionUpdate(this.projectId, exec.id, "deleted", { executionId: exec.id }, exec.issue_id || undefined);
+        }
     }
     /**
      * Shutdown execution service - cancel all active executions
@@ -678,21 +623,14 @@ Please continue working on this issue, taking into account the feedback above.`;
      * all running executions before the server exits.
      */
     async shutdown() {
-        const cancelPromises = [];
-        // Cancel all active orchestrators
-        for (const [executionId, orchestrator,] of this.activeOrchestrators.entries()) {
-            cancelPromises.push(orchestrator.cancelWorkflow(executionId).catch((error) => {
-                console.error("[ExecutionService] Error canceling execution", {
-                    executionId,
-                    error: error.message,
-                });
-            }));
+        // Shutdown worker pool if available
+        if (this.workerPool) {
+            await this.workerPool.shutdown();
         }
-        // Wait for all cancellations to complete (with timeout)
-        await Promise.race([
-            Promise.all(cancelPromises),
-            new Promise((resolve) => setTimeout(resolve, 5000)), // 5 second timeout
-        ]);
+        // For in-process executions using AgentExecutorWrapper:
+        // The wrapper manages its own lifecycle. Processes will be terminated
+        // when the Node.js process exits.
+        // TODO: Add active execution tracking to AgentExecutorWrapper for graceful shutdown
     }
     /**
      * List all executions for an issue
@@ -722,5 +660,52 @@ Please continue working on this issue, taking into account the feedback above.`;
     getExecution(executionId) {
         return getExecution(this.db, executionId);
     }
+    /**
+     * Check if there are any active executions
+     *
+     * @returns true if there are active worker pool executions
+     */
+    hasActiveExecutions() {
+        // Check worker pool for active executions
+        if (this.workerPool) {
+            return this.workerPool.getActiveWorkerCount() > 0;
+        }
+        // For in-process executions, we don't track them anymore
+        // Query the database for running executions as a fallback
+        const runningExecutions = this.db
+            .prepare("SELECT COUNT(*) as count FROM executions WHERE status = 'running'")
+            .get();
+        return runningExecutions.count > 0;
+    }
+    /**
+     * Collect entity IDs that were already expanded in parent executions
+     *
+     * Walks the execution chain backwards and resolves each prompt to extract
+     * which entities were referenced (and thus expanded) in previous executions.
+     * This prevents redundant expansion of the same entities in follow-ups.
+     *
+     * @param executionId - ID of the current execution
+     * @returns Set of entity IDs that were already expanded
+     */
+    async collectExpandedEntitiesFromChain(executionId) {
+        const expandedIds = new Set();
+        const resolver = new PromptResolver(this.db);
+        // Walk backwards through the execution chain
+        let currentExecId = executionId;
+        while (currentExecId) {
+            const execution = getExecution(this.db, currentExecId);
+            if (!execution || !execution.prompt)
+                break;
+            // Resolve the prompt to extract what entities were referenced
+            // Pass empty set so we expand everything in this pass (just to collect IDs)
+            // Pass the execution's issue_id as implicit to track if it was auto-included
+            const { expandedEntityIds } = await resolver.resolve(execution.prompt, new Set(), execution.issue_id || undefined);
+            // Add all expanded entity IDs from this execution
+            expandedEntityIds.forEach((id) => expandedIds.add(id));
+            // Move to parent execution
+            currentExecId = execution.parent_execution_id || null;
+        }
+        return expandedIds;
+    }
 }
 //# sourceMappingURL=execution-service.js.map