@sudocode-ai/local-server 0.1.7 → 0.1.9

package/dist/routes/executions.js

@@ -2,47 +2,171 @@
  * Executions API routes (mapped to /api)
  *
  * Provides REST API for managing issue executions.
+ *
+ * Note: All routes require X-Project-ID header via requireProject() middleware
  */
 import { Router } from "express";
-import { ExecutionService } from "../services/execution-service.js";
-import { ExecutionLogsStore } from "../services/execution-logs-store.js";
+import { execSync } from "child_process";
+import { NormalizedEntryToAgUiAdapter } from "../execution/output/normalized-to-ag-ui-adapter.js";
+import { AgUiEventAdapter } from "../execution/output/ag-ui-adapter.js";
+import { agentRegistryService } from "../services/agent-registry.js";
+import { AgentNotFoundError, AgentNotImplementedError, AgentError, } from "../errors/agent-errors.js";
+import { WorktreeSyncService, WorktreeSyncError, WorktreeSyncErrorCode, } from "../services/worktree-sync-service.js";
+import { ExecutionChangesService } from "../services/execution-changes-service.js";
+/**
+ * Get WorktreeSyncService instance for a request
+ *
+ * @param req - Express request with project context
+ * @returns WorktreeSyncService instance
+ */
+function getWorktreeSyncService(req) {
+    const db = req.project.db;
+    const repoPath = req.project.path;
+    return new WorktreeSyncService(db, repoPath);
+}
+/**
+ * Get HTTP status code for WorktreeSyncError
+ *
+ * @param error - WorktreeSyncError instance
+ * @returns HTTP status code
+ */
+function getStatusCodeForSyncError(error) {
+    switch (error.code) {
+        case WorktreeSyncErrorCode.NO_WORKTREE:
+        case WorktreeSyncErrorCode.WORKTREE_MISSING:
+        case WorktreeSyncErrorCode.BRANCH_MISSING:
+        case WorktreeSyncErrorCode.TARGET_BRANCH_MISSING:
+        case WorktreeSyncErrorCode.EXECUTION_NOT_FOUND:
+            return 404; // Not found
+        case WorktreeSyncErrorCode.DIRTY_WORKING_TREE:
+        case WorktreeSyncErrorCode.CODE_CONFLICTS:
+        case WorktreeSyncErrorCode.NO_COMMON_BASE:
+            return 400; // Bad request (user must fix)
+        case WorktreeSyncErrorCode.MERGE_FAILED:
+        case WorktreeSyncErrorCode.JSONL_RESOLUTION_FAILED:
+        case WorktreeSyncErrorCode.DATABASE_SYNC_FAILED:
+            return 500; // Internal error
+        default:
+            return 500;
+    }
+}
 /**
  * Create executions router
  *
- * @param db - Database instance
- * @param repoPath - Path to git repository
- * @param transportManager - Optional transport manager for SSE streaming
- * @param executionService - Optional execution service instance
- * @param logsStore - Optional execution logs store instance
+ * Note: ExecutionService and ExecutionLogsStore are accessed via req.project
+ * which is injected by the requireProject() middleware
+ *
  * @returns Express router with execution endpoints
  */
-export function createExecutionsRouter(db, repoPath, transportManager, executionService, logsStore) {
+export function createExecutionsRouter() {
     const router = Router();
-    const service = executionService ||
-        new ExecutionService(db, repoPath, undefined, transportManager);
-    const store = logsStore || new ExecutionLogsStore(db);
     /**
-     * POST /api/issues/:issueId/executions/prepare
+     * GET /api/executions
      *
-     * Prepare an execution - render template and show preview
+     * List all executions with filtering and pagination
+     *
+     * Query parameters:
+     * - limit?: number (default: 50)
+     * - offset?: number (default: 0)
+     * - status?: ExecutionStatus | ExecutionStatus[] (comma-separated for multiple)
+     * - issueId?: string
+     * - sortBy?: 'created_at' | 'updated_at' (default: 'created_at')
+     * - order?: 'asc' | 'desc' (default: 'desc')
+     * - since?: ISO date string - only return executions created after this date
+     * - includeRunning?: 'true' - when used with 'since', also include running executions regardless of age
      */
-    router.post("/issues/:issueId/executions/prepare", async (req, res) => {
+    router.get("/executions", (req, res) => {
         try {
-            const { issueId } = req.params;
-            const options = req.body || {};
-            const result = await service.prepareExecution(issueId, options);
+            // Parse query parameters
+            const limit = req.query.limit
+                ? parseInt(req.query.limit, 10)
+                : undefined;
+            const offset = req.query.offset
+                ? parseInt(req.query.offset, 10)
+                : undefined;
+            // Parse status (can be single value or comma-separated array)
+            let status = undefined;
+            if (req.query.status) {
+                const statusParam = req.query.status;
+                status = statusParam.includes(",")
+                    ? statusParam.split(",").map((s) => s.trim())
+                    : statusParam;
+            }
+            const issueId = req.query.issueId;
+            const sortBy = req.query.sortBy || undefined;
+            const order = req.query.order || undefined;
+            const since = req.query.since;
+            const includeRunning = req.query.includeRunning === "true";
+            // Validate limit and offset
+            if (limit !== undefined && (isNaN(limit) || limit < 0)) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "Invalid limit parameter",
+                });
+                return;
+            }
+            if (offset !== undefined && (isNaN(offset) || offset < 0)) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "Invalid offset parameter",
+                });
+                return;
+            }
+            // Validate sortBy
+            if (sortBy && sortBy !== "created_at" && sortBy !== "updated_at") {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "Invalid sortBy parameter. Must be 'created_at' or 'updated_at'",
+                });
+                return;
+            }
+            // Validate order
+            if (order && order !== "asc" && order !== "desc") {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "Invalid order parameter. Must be 'asc' or 'desc'",
+                });
+                return;
+            }
+            // Validate since (should be valid ISO date)
+            if (since) {
+                const sinceDate = new Date(since);
+                if (isNaN(sinceDate.getTime())) {
+                    res.status(400).json({
+                        success: false,
+                        data: null,
+                        message: "Invalid since parameter. Must be a valid ISO date string",
+                    });
+                    return;
+                }
+            }
+            // Call service method
+            const result = req.project.executionService.listAll({
+                limit,
+                offset,
+                status,
+                issueId,
+                sortBy,
+                order,
+                since,
+                includeRunning,
+            });
             res.json({
                 success: true,
                 data: result,
             });
         }
         catch (error) {
-            console.error("[API Route] ERROR: Failed to prepare execution:", error);
+            console.error("Error listing executions:", error);
             res.status(500).json({
                 success: false,
                 data: null,
                 error_data: error instanceof Error ? error.message : String(error),
-                message: "Failed to prepare execution",
+                message: "Failed to list executions",
             });
         }
     });
@@ -54,7 +178,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
     router.post("/issues/:issueId/executions", async (req, res) => {
         try {
             const { issueId } = req.params;
-            const { config, prompt } = req.body;
+            const { config, prompt, agentType } = req.body;
             // Validate required fields
             if (!prompt) {
                 res.status(400).json({
@@ -64,7 +188,22 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
                 });
                 return;
             }
-            const execution = await service.createExecution(issueId, config || {}, prompt);
+            // Validate agentType if provided
+            if (agentType) {
+                // Check if agent exists in registry
+                if (!agentRegistryService.hasAgent(agentType)) {
+                    const availableAgents = agentRegistryService
+                        .getAvailableAgents()
+                        .map((a) => a.name);
+                    throw new AgentNotFoundError(agentType, availableAgents);
+                }
+                // Check if agent is implemented
+                if (!agentRegistryService.isAgentImplemented(agentType)) {
+                    throw new AgentNotImplementedError(agentType);
+                }
+            }
+            const execution = await req.project.executionService.createExecution(issueId, config || {}, prompt, agentType // Optional, defaults to 'claude-code' in service
+            );
             res.status(201).json({
                 success: true,
                 data: execution,
@@ -72,7 +211,39 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
         }
         catch (error) {
             console.error("[API Route] ERROR: Failed to create execution:", error);
-            // Handle specific error cases
+            // Handle agent-specific errors with enhanced error responses
+            if (error instanceof AgentNotFoundError) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                    details: error.details,
+                });
+                return;
+            }
+            if (error instanceof AgentNotImplementedError) {
+                res.status(501).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                    details: error.details,
+                });
+                return;
+            }
+            if (error instanceof AgentError) {
+                // Generic agent error (400 by default)
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                    details: error.details,
+                });
+                return;
+            }
+            // Handle other errors (backwards compatibility)
             const errorMessage = error instanceof Error ? error.message : String(error);
             const statusCode = errorMessage.includes("not found") ? 404 : 500;
             res.status(statusCode).json({
@@ -91,7 +262,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
     router.get("/executions/:executionId", (req, res) => {
         try {
             const { executionId } = req.params;
-            const execution = service.getExecution(executionId);
+            const execution = req.project.executionService.getExecution(executionId);
             if (!execution) {
                 res.status(404).json({
                     success: false,
@@ -115,16 +286,86 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
             });
         }
     });
+    /**
+     * GET /api/executions/:executionId/chain
+     *
+     * Get execution chain (root execution + all follow-ups)
+     *
+     * Returns the full chain of executions starting from the root.
+     * If the requested execution is a follow-up, finds the root and returns the full chain.
+     * Executions are ordered chronologically (oldest first).
+     */
+    router.get("/executions/:executionId/chain", (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const db = req.project.db;
+            // Get the requested execution
+            const execution = req.project.executionService.getExecution(executionId);
+            if (!execution) {
+                res.status(404).json({
+                    success: false,
+                    data: null,
+                    message: `Execution not found: ${executionId}`,
+                });
+                return;
+            }
+            // 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 = req.project.executionService.getExecution(rootId);
+                if (!parent)
+                    break;
+                current = parent;
+            }
+            // Get all executions in the chain (root + all descendants)
+            // Using recursive CTE to get all descendants
+            const chain = 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
+        ORDER BY created_at ASC
+      `)
+                .all(rootId);
+            res.json({
+                success: true,
+                data: {
+                    rootId,
+                    executions: chain,
+                },
+            });
+        }
+        catch (error) {
+            console.error("Error getting execution chain:", error);
+            res.status(500).json({
+                success: false,
+                data: null,
+                error_data: error instanceof Error ? error.message : String(error),
+                message: "Failed to get execution chain",
+            });
+        }
+    });
     /**
      * GET /api/executions/:executionId/logs
      *
-     * Get raw execution logs for historical replay
+     * Get AG-UI events for historical replay
+     *
+     * Fetches NormalizedEntry logs from storage and converts them to AG-UI events on-demand.
+     * This preserves full structured data in storage while serving UI-ready events to frontend.
      */
-    router.get("/executions/:executionId/logs", (req, res) => {
+    router.get("/executions/:executionId/logs", async (req, res) => {
         try {
             const { executionId } = req.params;
             // Verify execution exists
-            const execution = service.getExecution(executionId);
+            const execution = req.project.executionService.getExecution(executionId);
             if (!execution) {
                 res.status(404).json({
                     success: false,
@@ -133,14 +374,27 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
                 });
                 return;
             }
-            // Fetch raw logs and metadata
-            const logs = store.getRawLogs(executionId);
-            const metadata = store.getLogMetadata(executionId);
+            // Fetch normalized entries from storage
+            const normalizedEntries = req.project.logsStore.getNormalizedEntries(executionId);
+            const metadata = req.project.logsStore.getLogMetadata(executionId);
+            // Convert NormalizedEntry to AG-UI events on-demand
+            const events = [];
+            // Create a temporary AG-UI adapter to collect events
+            const agUiAdapter = new AgUiEventAdapter(executionId);
+            agUiAdapter.onEvent((event) => {
+                events.push(event);
+            });
+            // Create normalized adapter to transform entries
+            const normalizedAdapter = new NormalizedEntryToAgUiAdapter(agUiAdapter);
+            // Process all normalized entries through the adapter
+            for (const entry of normalizedEntries) {
+                await normalizedAdapter.processEntry(entry);
+            }
             res.json({
                 success: true,
                 data: {
                     executionId,
-                    logs,
+                    events,
                     metadata: metadata
                         ? {
                             lineCount: metadata.line_count,
@@ -167,6 +421,93 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
             });
         }
     });
+    /**
+     * GET /api/executions/:executionId/changes
+     *
+     * Get code changes (file list + diff statistics) for an execution
+     *
+     * Calculates changes on-demand from commit SHAs. Supports:
+     * - Committed changes (commit-to-commit diff)
+     * - Uncommitted changes (working tree diff)
+     * - Unavailable states with clear error reasons
+     */
+    router.get("/executions/:executionId/changes", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const db = req.project.db;
+            const repoPath = req.project.path;
+            // Create changes service
+            const changesService = new ExecutionChangesService(db, repoPath);
+            // Get changes
+            const result = await changesService.getChanges(executionId);
+            res.json({
+                success: true,
+                data: result,
+            });
+        }
+        catch (error) {
+            console.error("[GET /executions/:id/changes] Error:", error);
+            res.status(500).json({
+                success: false,
+                data: null,
+                error_data: error instanceof Error ? error.message : String(error),
+                message: "Failed to calculate changes",
+            });
+        }
+    });
+    /**
+     * GET /api/executions/:executionId/changes/file
+     *
+     * Get diff content for a specific file in an execution
+     *
+     * Query params:
+     * - filePath: Path to the file to get diff for
+     */
+    router.get("/executions/:executionId/changes/file", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const { filePath } = req.query;
+            if (!filePath || typeof filePath !== "string") {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "filePath query parameter is required",
+                });
+                return;
+            }
+            const db = req.project.db;
+            const repoPath = req.project.path;
+            // Create changes service
+            const changesService = new ExecutionChangesService(db, repoPath);
+            // Get file diff
+            const result = await changesService.getFileDiff(executionId, filePath);
+            if (!result.success) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: result.error || "Failed to get file diff",
+                });
+                return;
+            }
+            res.json({
+                success: true,
+                data: {
+                    filePath,
+                    oldContent: result.oldContent,
+                    newContent: result.newContent,
+                },
+            });
+        }
+        catch (error) {
+            console.error("[GET /executions/:id/changes/file] Error:", error);
+            res.status(500).json({
+                success: false,
+                data: null,
+                error_data: error instanceof Error ? error.message : String(error),
+                message: "Failed to get file diff",
+            });
+        }
+    });
     /**
      * GET /api/issues/:issueId/executions
      *
@@ -175,7 +516,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
     router.get("/issues/:issueId/executions", (req, res) => {
         try {
             const { issueId } = req.params;
-            const executions = service.listExecutions(issueId);
+            const executions = req.project.executionService.listExecutions(issueId);
             res.json({
                 success: true,
                 data: executions,
@@ -209,7 +550,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
                 });
                 return;
             }
-            const followUpExecution = await service.createFollowUp(executionId, feedback);
+            const followUpExecution = await req.project.executionService.createFollowUp(executionId, feedback);
             res.status(201).json({
                 success: true,
                 data: followUpExecution,
@@ -232,14 +573,14 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
         }
     });
     /**
-     * DELETE /api/executions/:executionId
+     * POST /api/executions/:executionId/cancel
      *
      * Cancel a running execution
      */
-    router.delete("/executions/:executionId", async (req, res) => {
+    router.post("/executions/:executionId/cancel", async (req, res) => {
         try {
             const { executionId } = req.params;
-            await service.cancelExecution(executionId);
+            await req.project.executionService.cancelExecution(executionId);
             res.json({
                 success: true,
                 data: { executionId },
@@ -259,6 +600,51 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
             });
         }
     });
+    /**
+     * DELETE /api/executions/:executionId
+     *
+     * Delete an execution and its entire chain (or cancel if ?cancel=true)
+     *
+     * Query parameters:
+     * - cancel: if "true", cancel the execution instead of deleting it
+     * - deleteBranch: if "true", also delete the execution's branch
+     * - deleteWorktree: if "true", also delete the execution's worktree
+     */
+    router.delete("/executions/:executionId", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const { cancel, deleteBranch, deleteWorktree } = req.query;
+            // If cancel query param is true, cancel the execution
+            if (cancel === "true") {
+                await req.project.executionService.cancelExecution(executionId);
+                res.json({
+                    success: true,
+                    data: { executionId },
+                    message: "Execution cancelled successfully",
+                });
+                return;
+            }
+            // Otherwise, delete the execution and its chain
+            await req.project.executionService.deleteExecution(executionId, deleteBranch === "true", deleteWorktree === "true");
+            res.json({
+                success: true,
+                data: { executionId },
+                message: "Execution deleted successfully",
+            });
+        }
+        catch (error) {
+            console.error("Error deleting/cancelling execution:", error);
+            // Handle specific error cases
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const statusCode = errorMessage.includes("not found") ? 404 : 500;
+            res.status(statusCode).json({
+                success: false,
+                data: null,
+                error_data: errorMessage,
+                message: "Failed to delete/cancel execution",
+            });
+        }
+    });
     /**
      * GET /api/executions/:executionId/worktree
      *
@@ -267,7 +653,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
     router.get("/executions/:executionId/worktree", async (req, res) => {
         try {
             const { executionId } = req.params;
-            const exists = await service.worktreeExists(executionId);
+            const exists = await req.project.executionService.worktreeExists(executionId);
             res.json({
                 success: true,
                 data: { exists },
@@ -287,11 +673,15 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
      * DELETE /api/executions/:executionId/worktree
      *
      * Delete the worktree for an execution
+     *
+     * Query parameters:
+     * - deleteBranch: if "true", also delete the execution's branch
      */
     router.delete("/executions/:executionId/worktree", async (req, res) => {
         try {
             const { executionId } = req.params;
-            await service.deleteWorktree(executionId);
+            const { deleteBranch } = req.query;
+            await req.project.executionService.deleteWorktree(executionId, deleteBranch === "true");
             res.json({
                 success: true,
                 data: { executionId },
@@ -318,6 +708,371 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
             });
         }
     });
+    /**
+     * GET /api/executions/:executionId/sync/preview
+     *
+     * Preview sync changes and detect conflicts
+     *
+     * Returns preview of what would happen if sync is performed,
+     * including conflicts, diff, commits, and warnings.
+     */
+    router.get("/executions/:executionId/sync/preview", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            // Get worktree sync service
+            const syncService = getWorktreeSyncService(req);
+            // Preview sync
+            const preview = await syncService.previewSync(executionId);
+            res.json({
+                success: true,
+                data: preview,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to preview sync for execution ${req.params.executionId}:`, error);
+            if (error instanceof WorktreeSyncError) {
+                const statusCode = getStatusCodeForSyncError(error);
+                res.status(statusCode).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    data: null,
+                    error: "Internal server error",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    });
+    /**
+     * POST /api/executions/:executionId/sync/squash
+     *
+     * Perform squash sync operation
+     *
+     * Combines all worktree changes into a single commit on the target branch.
+     * Automatically resolves JSONL conflicts using merge-resolver.
+     *
+     * Request body:
+     * - commitMessage?: string - Optional custom commit message
+     */
+    router.post("/executions/:executionId/sync/squash", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const { commitMessage } = req.body || {};
+            // Get worktree sync service
+            const syncService = getWorktreeSyncService(req);
+            // Check if squashSync method exists
+            if (typeof syncService.squashSync !== "function") {
+                res.status(501).json({
+                    success: false,
+                    data: null,
+                    error: "Squash sync not yet implemented",
+                    message: "The squashSync operation is not available yet",
+                });
+                return;
+            }
+            // Perform squash sync
+            const result = await syncService.squashSync(executionId, commitMessage);
+            res.json({
+                success: true,
+                data: result,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to squash sync execution ${req.params.executionId}:`, error);
+            if (error instanceof WorktreeSyncError) {
+                const statusCode = getStatusCodeForSyncError(error);
+                res.status(statusCode).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    data: null,
+                    error: "Internal server error",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    });
+    /**
+     * POST /api/executions/:executionId/sync/stage
+     *
+     * Perform stage sync operation
+     *
+     * Applies committed worktree changes to the working directory without committing.
+     * Changes are left staged, ready for the user to commit manually.
+     *
+     * Request body:
+     * - includeUncommitted?: boolean - If true, also copy uncommitted files from worktree
+     */
+    router.post("/executions/:executionId/sync/stage", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const { includeUncommitted } = req.body || {};
+            // Get worktree sync service
+            const syncService = getWorktreeSyncService(req);
+            // Perform stage sync with options
+            const result = await syncService.stageSync(executionId, {
+                includeUncommitted: includeUncommitted === true,
+            });
+            res.json({
+                success: true,
+                data: result,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to stage sync execution ${req.params.executionId}:`, error);
+            if (error instanceof WorktreeSyncError) {
+                const statusCode = getStatusCodeForSyncError(error);
+                res.status(statusCode).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    data: null,
+                    error: "Internal server error",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    });
+    /**
+     * POST /api/executions/:executionId/sync/preserve
+     *
+     * Perform preserve sync operation
+     *
+     * Merges all commits from worktree branch to target branch, preserving commit history.
+     * Only includes committed changes - uncommitted changes are excluded.
+     */
+    router.post("/executions/:executionId/sync/preserve", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            // Get worktree sync service
+            const syncService = getWorktreeSyncService(req);
+            // Perform preserve sync
+            const result = await syncService.preserveSync(executionId);
+            res.json({
+                success: true,
+                data: result,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to preserve sync execution ${req.params.executionId}:`, error);
+            if (error instanceof WorktreeSyncError) {
+                const statusCode = getStatusCodeForSyncError(error);
+                res.status(statusCode).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    data: null,
+                    error: "Internal server error",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    });
+    /**
+     * POST /api/executions/:executionId/commit
+     *
+     * Commit uncommitted changes for an execution
+     *
+     * Commits changes to the appropriate branch based on execution mode:
+     * - Local mode: Commits to target_branch (current branch)
+     * - Worktree mode: Commits to branch_name (temp branch) in worktree
+     *
+     * Request body:
+     * - message: string (required) - Commit message
+     */
+    router.post("/executions/:executionId/commit", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const { message } = req.body;
+            // Validate commit message
+            if (!message || typeof message !== "string" || !message.trim()) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "Commit message is required and must be non-empty",
+                });
+                return;
+            }
+            const db = req.project.db;
+            const repoPath = req.project.path;
+            // Load execution from database
+            const execution = db
+                .prepare("SELECT * FROM executions WHERE id = ?")
+                .get(executionId);
+            if (!execution) {
+                res.status(404).json({
+                    success: false,
+                    data: null,
+                    message: "Execution not found",
+                });
+                return;
+            }
+            // Determine working directory and target branch
+            // IMPORTANT: If worktree_path exists, always use it - this is more reliable than the mode field
+            // which may not be set correctly on follow-up executions
+            const hasWorktree = !!execution.worktree_path;
+            const workingDir = hasWorktree ? execution.worktree_path : repoPath;
+            const targetBranch = hasWorktree
+                ? execution.branch_name
+                : execution.target_branch || "main";
+            console.log(`[Commit] Execution ${executionId}: hasWorktree=${hasWorktree}, workingDir=${workingDir}, targetBranch=${targetBranch}, mode=${execution.mode}`);
+            // Get current uncommitted files from working directory instead of stale database field
+            // This ensures we're working with the current state
+            let filesChanged = [];
+            try {
+                // Get modified tracked files
+                const modifiedOutput = execSync("git diff --name-only", {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                // Get staged files
+                const stagedOutput = execSync("git diff --cached --name-only", {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                // Get untracked files
+                const untrackedOutput = execSync("git ls-files --others --exclude-standard", {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                console.log(`[Commit] Git status in ${workingDir}:`, {
+                    modified: modifiedOutput.trim().split("\n").filter(Boolean),
+                    staged: stagedOutput.trim().split("\n").filter(Boolean),
+                    untracked: untrackedOutput.trim().split("\n").filter(Boolean),
+                });
+                // Combine all files, removing duplicates
+                const allFiles = new Set();
+                for (const output of [
+                    modifiedOutput,
+                    stagedOutput,
+                    untrackedOutput,
+                ]) {
+                    output
+                        .split("\n")
+                        .filter((line) => line.trim())
+                        .forEach((file) => allFiles.add(file));
+                }
+                filesChanged = Array.from(allFiles);
+            }
+            catch (error) {
+                console.error("Failed to get uncommitted files:", error);
+            }
+            // Validate has uncommitted changes
+            if (filesChanged.length === 0) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "No files to commit",
+                });
+                return;
+            }
+            // Execute git operations
+            try {
+                // Add all changes (more reliable than adding specific files)
+                // This catches any files that might have been missed in detection
+                execSync("git add -A", {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                console.log(`[Commit] Staged all changes with git add -A`);
+                // Verify something is staged
+                const stagedAfterAdd = execSync("git diff --cached --name-only", {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                }).trim();
+                if (!stagedAfterAdd) {
+                    console.log(`[Commit] No files staged after git add -A`);
+                    res.status(400).json({
+                        success: false,
+                        data: null,
+                        message: "No files staged for commit after git add",
+                    });
+                    return;
+                }
+                console.log(`[Commit] Files staged: ${stagedAfterAdd.split("\n").filter(Boolean).join(", ")}`);
+                // Commit using -F - to read message from stdin (safer than shell escaping)
+                const { spawnSync } = await import("child_process");
+                const commitResult = spawnSync("git", ["commit", "-m", message], {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                if (commitResult.status !== 0) {
+                    const errorOutput = commitResult.stderr || commitResult.stdout || "Unknown error";
+                    console.error(`[Commit] git commit failed:`, errorOutput);
+                    throw new Error(`git commit failed: ${errorOutput}`);
+                }
+                console.log(`[Commit] git commit output:`, commitResult.stdout);
+                // Get commit SHA
+                const commitSha = execSync("git rev-parse HEAD", {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                }).trim();
+                console.log(`[Commit] Successfully committed ${filesChanged.length} files: ${commitSha}`);
+                // Note: We do NOT update execution.after_commit here
+                // That field represents the state at execution completion time
+                // Manual commits after execution are tracked separately
+                res.json({
+                    success: true,
+                    data: {
+                        commitSha,
+                        filesCommitted: filesChanged.length,
+                        branch: targetBranch,
+                    },
+                    message: `Successfully committed ${filesChanged.length} file${filesChanged.length !== 1 ? "s" : ""}`,
+                });
+            }
+            catch (gitError) {
+                console.error("Git operation failed:", gitError);
+                const errorMessage = gitError instanceof Error ? gitError.message : String(gitError);
+                res.status(500).json({
+                    success: false,
+                    data: null,
+                    message: "Git commit failed",
+                    error: errorMessage,
+                });
+            }
+        }
+        catch (error) {
+            console.error(`Failed to commit for execution ${req.params.executionId}:`, error);
+            res.status(500).json({
+                success: false,
+                data: null,
+                error: "Internal server error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
     return router;
 }
 //# sourceMappingURL=executions.js.map