@sudocode-ai/local-server 0.1.8 → 0.1.10

package/dist/services/worktree-sync-service.js

@@ -9,10 +9,11 @@
 import * as fs from "fs";
 import * as path from "path";
 import { execSync } from "child_process";
-import { GitSyncCli } from "../execution/worktree/git-sync-cli.js";
-import { ConflictDetector } from "../execution/worktree/conflict-detector.js";
-import { mergeThreeWay } from "@sudocode-ai/cli/dist/merge-resolver.js";
-import { writeJSONL } from "@sudocode-ai/cli/dist/jsonl.js";
+import { GitSyncCli, } from "../execution/worktree/git-sync-cli.js";
+import { ConflictDetector, } from "../execution/worktree/conflict-detector.js";
+import { mergeThreeWay, hasGitConflictMarkers, parseMergeConflictFile, resolveEntities, } from "@sudocode-ai/cli/dist/merge-resolver.js";
+import { writeJSONL, readJSONLSync, } from "@sudocode-ai/cli/dist/jsonl.js";
+import * as os from "os";
 /**
  * Worktree sync error codes
  */
@@ -52,12 +53,10 @@ export class WorktreeSyncService {
     db;
     repoPath;
     gitSync;
-    conflictDetector;
     constructor(db, repoPath) {
         this.db = db;
         this.repoPath = repoPath;
         this.gitSync = new GitSyncCli(repoPath);
-        this.conflictDetector = new ConflictDetector(repoPath);
     }
     /**
      * Preview sync without making changes
@@ -68,12 +67,10 @@ export class WorktreeSyncService {
     async previewSync(executionId) {
         // 1. Load execution and validate
         const execution = await this._loadAndValidateExecution(executionId);
-        // 2. Validate preconditions
-        try {
-            await this._validateSyncPreconditions(execution);
-        }
-        catch (error) {
-            // Return preview with error details
+        // 2. Validate critical preconditions (ones that prevent us from getting any info)
+        // These are "hard" failures - we can't get diff/commits if these fail
+        const criticalPreconditionError = await this._validateCriticalPreconditions(execution);
+        if (criticalPreconditionError) {
             return {
                 canSync: false,
                 conflicts: {
@@ -87,37 +84,51 @@ export class WorktreeSyncService {
                 commits: [],
                 mergeBase: "",
                 uncommittedJSONLChanges: [],
+                uncommittedChanges: { files: [], additions: 0, deletions: 0 },
                 executionStatus: execution.status,
-                warnings: [error.message],
+                warnings: [criticalPreconditionError],
             };
         }
-        // 3. Find merge base
+        // 3. Create ConflictDetector instance for worktree context
+        const worktreeConflictDetector = new ConflictDetector(execution.worktree_path);
+        // 4. Find merge base (use main repo since it has both branches)
         const mergeBase = this.gitSync.getMergeBase(execution.branch_name, execution.target_branch);
         // 4. Get commit list
         const commits = this.gitSync.getCommitList(mergeBase, execution.branch_name);
-        // 5. Get diff summary
+        // 6. Get diff summary (use main repo to see all changes)
         const diff = this.gitSync.getDiff(mergeBase, execution.branch_name);
-        // 6. Detect conflicts
-        const conflicts = this.conflictDetector.detectConflicts(execution.branch_name, execution.target_branch);
-        // 7. Check for uncommitted JSONL changes
-        const uncommittedJSONL = this._getUncommittedJSONLFiles(execution.worktree_path);
-        // 8. Generate warnings
+        // 7. Detect conflicts (use worktree for conflict detection)
+        const conflicts = worktreeConflictDetector.detectConflicts(execution.branch_name, execution.target_branch);
+        // 7. Check for uncommitted changes in worktree (not included by default)
+        const uncommittedFiles = this._getUncommittedFiles(execution.worktree_path);
+        const uncommittedJSONL = uncommittedFiles.filter((file) => file.endsWith(".jsonl") &&
+            (file.includes(".sudocode/") || file.startsWith(".sudocode/")));
+        const uncommittedChanges = this._getUncommittedFileStats(execution.worktree_path);
+        // 8. Generate warnings and check "soft" preconditions
         const warnings = [];
+        let canSync = true;
+        // Check if local working tree is clean (soft precondition - we can still show preview)
+        if (!this.gitSync.isWorkingTreeClean()) {
+            warnings.push("Local working tree has uncommitted changes. Stash or commit them first.");
+            canSync = false;
+        }
         // Warn if execution is running/paused
-        if (execution.status === "running" ||
-            execution.status === "paused") {
+        if (execution.status === "running" || execution.status === "paused") {
             warnings.push("Execution is currently active. Synced state may not reflect final execution result.");
         }
         // Warn about code conflicts
         if (conflicts.codeConflicts.length > 0) {
-            warnings.push(`${conflicts.codeConflicts.length} code conflict(s) detected. Manual resolution required.`);
-        }
-        // Warn about uncommitted JSONL
-        if (uncommittedJSONL.length > 0) {
-            warnings.push(`${uncommittedJSONL.length} uncommitted JSONL file(s) will be included in sync.`);
+            warnings.push(`${conflicts.codeConflicts.length} code conflict(s) detected. Manual resolution may be required.`);
         }
-        // 9. Determine if sync can proceed
-        const canSync = conflicts.codeConflicts.length === 0;
+        // Note about uncommitted files (not included by default)
+        // if (uncommittedChanges && uncommittedChanges.files.length > 0) {
+        //   warnings.push(
+        //     `${uncommittedChanges.files.length} uncommitted file(s) in worktree will NOT be included (only committed changes are synced).`
+        //   );
+        // }
+        // 9. Detect potential local conflicts for uncommitted files
+        // These are files in worktree that also have local changes or are untracked locally
+        const potentialLocalConflicts = this._detectPotentialLocalConflicts(uncommittedChanges?.files || []);
         return {
             canSync,
             conflicts,
@@ -125,10 +136,49 @@ export class WorktreeSyncService {
             commits,
             mergeBase,
             uncommittedJSONLChanges: uncommittedJSONL,
+            uncommittedChanges,
+            potentialLocalConflicts,
             executionStatus: execution.status,
             warnings,
         };
     }
+    /**
+     * Validate critical preconditions that prevent us from getting any sync info
+     *
+     * These are "hard" failures - if these fail, we can't get diff/commits info.
+     * Returns an error message if validation fails, null if validation passes.
+     *
+     * @param execution - Execution to validate
+     * @returns Error message if validation fails, null if validation passes
+     */
+    async _validateCriticalPreconditions(execution) {
+        // 1. Check worktree path exists
+        if (!execution.worktree_path) {
+            return "No worktree path for execution";
+        }
+        // 2. Check worktree still exists on filesystem
+        if (!fs.existsSync(execution.worktree_path)) {
+            return "Worktree no longer exists";
+        }
+        // 3. Get list of branches
+        const branches = this._getBranches();
+        // 4. Check worktree branch exists
+        if (!branches.includes(execution.branch_name)) {
+            return `Worktree branch '${execution.branch_name}' not found`;
+        }
+        // 5. Check target branch exists
+        if (!branches.includes(execution.target_branch)) {
+            return `Target branch '${execution.target_branch}' not found`;
+        }
+        // 6. Verify branches have common base
+        try {
+            this.gitSync.getMergeBase(execution.branch_name, execution.target_branch);
+        }
+        catch (error) {
+            return "Worktree and target branch have diverged without common history";
+        }
+        return null;
+    }
     /**
      * Load execution from database and validate it exists
      *
@@ -161,7 +211,8 @@ export class WorktreeSyncService {
      * @param execution - Execution to validate
      * @throws WorktreeSyncError if any precondition fails
      */
-    async _validateSyncPreconditions(execution) {
+    async _validateSyncPreconditions(execution, options) {
+        const { skipDirtyWorkingTreeCheck = false } = options || {};
         // 1. Check worktree path exists
         if (!execution.worktree_path) {
             throw new WorktreeSyncError("No worktree path for execution", WorktreeSyncErrorCode.NO_WORKTREE);
@@ -180,8 +231,8 @@ export class WorktreeSyncService {
         if (!branches.includes(execution.target_branch)) {
             throw new WorktreeSyncError(`Target branch '${execution.target_branch}' not found`, WorktreeSyncErrorCode.TARGET_BRANCH_MISSING);
         }
-        // 6. Check local working tree is clean
-        if (!this.gitSync.isWorkingTreeClean()) {
+        // 6. Check local working tree is clean (skip for stage mode since it doesn't commit)
+        if (!skipDirtyWorkingTreeCheck && !this.gitSync.isWorkingTreeClean()) {
             throw new WorktreeSyncError("Local working tree has uncommitted changes. Stash or commit them first.", WorktreeSyncErrorCode.DIRTY_WORKING_TREE);
         }
         // 7. Verify branches have common base
@@ -211,20 +262,85 @@ export class WorktreeSyncService {
         return tagName;
     }
     /**
-     * Get uncommitted JSONL files from worktree
-     *
-     * Used by previewSync() and will be used in i-3wmx (JSONL conflict resolution)
+     * Get all uncommitted files from worktree
      *
      * @param worktreePath - Path to worktree
-     * @returns Array of uncommitted JSONL file paths
+     * @returns Array of all uncommitted file paths
      */
-    _getUncommittedJSONLFiles(worktreePath) {
+    _getUncommittedFiles(worktreePath) {
         const gitSyncWorktree = new GitSyncCli(worktreePath);
-        // Get all uncommitted files
-        const uncommitted = gitSyncWorktree.getUncommittedFiles();
-        // Filter for JSONL files in .sudocode/
-        return uncommitted.filter((file) => file.endsWith(".jsonl") &&
-            (file.includes(".sudocode/") || file.startsWith(".sudocode/")));
+        return gitSyncWorktree.getUncommittedFiles();
+    }
+    /**
+     * Get uncommitted file stats from worktree
+     *
+     * Returns list of files and aggregate additions/deletions stats
+     * for uncommitted changes in the worktree.
+     *
+     * @param worktreePath - Path to worktree
+     * @returns Uncommitted file stats
+     */
+    _getUncommittedFileStats(worktreePath) {
+        try {
+            // Get modified files
+            const modifiedOutput = execSync("git diff --numstat", {
+                cwd: worktreePath,
+                encoding: "utf8",
+                stdio: "pipe",
+            });
+            // Get untracked files
+            const untrackedFiles = execSync("git ls-files --others --exclude-standard", {
+                cwd: worktreePath,
+                encoding: "utf8",
+                stdio: "pipe",
+            })
+                .split("\n")
+                .filter((line) => line.trim().length > 0);
+            // Parse modified file stats
+            let additions = 0;
+            let deletions = 0;
+            const modifiedFiles = [];
+            for (const line of modifiedOutput.split("\n")) {
+                if (!line.trim())
+                    continue;
+                const parts = line.split("\t");
+                if (parts.length >= 3) {
+                    const add = parts[0] === "-" ? 0 : parseInt(parts[0], 10) || 0;
+                    const del = parts[1] === "-" ? 0 : parseInt(parts[1], 10) || 0;
+                    additions += add;
+                    deletions += del;
+                    modifiedFiles.push(parts[2]);
+                }
+            }
+            // Count lines in untracked files as additions
+            for (const filePath of untrackedFiles) {
+                try {
+                    const fullPath = path.join(worktreePath, filePath);
+                    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+                        const content = fs.readFileSync(fullPath, "utf-8");
+                        additions += content.split("\n").length;
+                    }
+                }
+                catch (e) {
+                    // Skip files we can't read
+                }
+            }
+            // Combine all files
+            const allFiles = [...new Set([...modifiedFiles, ...untrackedFiles])];
+            return {
+                files: allFiles,
+                additions,
+                deletions,
+            };
+        }
+        catch (error) {
+            // Return empty stats on error
+            return {
+                files: [],
+                additions: 0,
+                deletions: 0,
+            };
+        }
     }
     /**
      * Check if local working tree is clean
@@ -340,7 +456,9 @@ export class WorktreeSyncService {
                 stdio: "pipe",
             });
             // Parse JSONL content
-            const lines = content.split("\n").filter((line) => line.trim().length > 0);
+            const lines = content
+                .split("\n")
+                .filter((line) => line.trim().length > 0);
             return lines.map((line) => JSON.parse(line));
         }
         catch (error) {
@@ -385,39 +503,376 @@ export class WorktreeSyncService {
         }
     }
     /**
-     * Perform git merge --squash operation
+     * Perform git merge --squash operation, allowing conflicts
+     *
+     * This method doesn't throw on conflicts.
+     * Instead, it returns information about whether conflicts occurred.
      *
      * @param sourceBranch - Branch to merge from (worktree branch)
      * @param targetBranch - Branch to merge into
-     * @returns Object with filesChanged count
-     * @throws WorktreeSyncError if merge fails
+     * @returns Object with filesChanged count and hasConflicts flag
      */
-    _performSquashMerge(sourceBranch, targetBranch) {
+    _performSquashMergeAllowConflicts(sourceBranch, targetBranch) {
+        // Checkout target branch
+        execSync(`git checkout ${this._escapeShellArg(targetBranch)}`, {
+            cwd: this.repoPath,
+            stdio: "pipe",
+        });
+        // Perform squash merge - may fail with conflicts
+        let hasConflicts = false;
         try {
-            // Checkout target branch
-            execSync(`git checkout ${this._escapeShellArg(targetBranch)}`, {
+            execSync(`git merge --squash ${this._escapeShellArg(sourceBranch)}`, {
                 cwd: this.repoPath,
                 stdio: "pipe",
             });
-            // Perform squash merge
-            execSync(`git merge --squash ${this._escapeShellArg(sourceBranch)}`, {
+        }
+        catch (error) {
+            // Check if this is a conflict situation (exit code 1) or a real error
+            // git merge --squash returns 1 on conflicts but stages what it can
+            hasConflicts = true;
+        }
+        // Count staged files (including conflicted ones)
+        const statusOutput = execSync("git diff --cached --name-only", {
+            cwd: this.repoPath,
+            encoding: "utf8",
+            stdio: "pipe",
+        });
+        const filesChanged = statusOutput
+            .split("\n")
+            .filter((line) => line.trim().length > 0).length;
+        // Check for actual conflicts in the working tree
+        try {
+            const conflictCheck = execSync("git diff --name-only --diff-filter=U", {
+                cwd: this.repoPath,
+                encoding: "utf8",
+                stdio: "pipe",
+            });
+            hasConflicts = conflictCheck.trim().length > 0;
+        }
+        catch (e) {
+            // If this fails, assume no conflicts
+        }
+        return { filesChanged, hasConflicts };
+    }
+    /**
+     * Check if a file has local uncommitted changes compared to HEAD
+     *
+     * @param filePath - Relative path to the file
+     * @returns true if file has uncommitted changes, false otherwise
+     */
+    _hasLocalUncommittedChanges(filePath) {
+        try {
+            // git diff --quiet exits with 1 if there are changes, 0 if clean
+            execSync(`git diff --quiet HEAD -- ${this._escapeShellArg(filePath)}`, {
                 cwd: this.repoPath,
                 stdio: "pipe",
             });
-            // Count staged files
-            const statusOutput = execSync("git diff --cached --name-only", {
+            return false; // Exit 0 = no changes
+        }
+        catch {
+            return true; // Exit 1 = has changes
+        }
+    }
+    /**
+     * Detect potential local conflicts for uncommitted worktree files
+     *
+     * Checks which uncommitted worktree files also exist locally with changes
+     * or are untracked locally. These files may have merge conflicts when synced.
+     *
+     * @param worktreeFiles - List of uncommitted files in worktree
+     * @returns Info about files that may have conflicts
+     */
+    _detectPotentialLocalConflicts(worktreeFiles) {
+        const conflictFiles = [];
+        for (const filePath of worktreeFiles) {
+            const localPath = path.join(this.repoPath, filePath);
+            const localFileExists = fs.existsSync(localPath);
+            if (localFileExists) {
+                // Check if local file has uncommitted changes vs HEAD or is untracked
+                const hasChangesVsHead = this._hasLocalUncommittedChanges(filePath);
+                const isUntracked = this._isFileUntracked(filePath);
+                if (hasChangesVsHead || isUntracked) {
+                    conflictFiles.push(filePath);
+                }
+            }
+        }
+        return {
+            count: conflictFiles.length,
+            files: conflictFiles,
+        };
+    }
+    /**
+     * Check if a file is untracked by git (not in the index)
+     *
+     * @param filePath - Relative path to the file
+     * @returns true if file is untracked, false if tracked
+     */
+    _isFileUntracked(filePath) {
+        try {
+            // git ls-files returns the file path if it's tracked, empty if not
+            const result = execSync(`git ls-files -- ${this._escapeShellArg(filePath)}`, {
                 cwd: this.repoPath,
                 encoding: "utf8",
                 stdio: "pipe",
             });
-            const filesChanged = statusOutput
-                .split("\n")
-                .filter((line) => line.trim().length > 0).length;
-            return { filesChanged };
+            return result.trim().length === 0; // Empty = untracked
         }
-        catch (error) {
-            throw new WorktreeSyncError(`Failed to perform squash merge: ${error.message}`, WorktreeSyncErrorCode.MERGE_FAILED, error);
+        catch {
+            return true; // Assume untracked on error
+        }
+    }
+    /**
+     * Check if a file is a JSONL file in the .sudocode directory
+     *
+     * @param filePath - Relative path to the file
+     * @returns true if file is a .sudocode JSONL file
+     */
+    _isJSONLFile(filePath) {
+        return (filePath.endsWith(".jsonl") &&
+            (filePath.startsWith(".sudocode/") || filePath.includes("/.sudocode/")));
+    }
+    /**
+     * Perform three-way merge on a file using git merge-file
+     *
+     * Uses HEAD as base, local working copy as "ours", and worktree version as "theirs".
+     * Modifies the local file in place, inserting conflict markers if needed.
+     *
+     * @param filePath - Relative path to the file in local repo
+     * @param worktreeFilePath - Absolute path to the file in worktree
+     * @returns true if there are conflicts, false if merge was clean
+     */
+    _threeWayMergeFile(filePath, worktreeFilePath) {
+        const localFilePath = path.join(this.repoPath, filePath);
+        // Create temp file for base version from HEAD
+        const tempDir = os.tmpdir();
+        const baseTempFile = path.join(tempDir, `sudocode-merge-base-${Date.now()}-${path.basename(filePath)}`);
+        try {
+            // Get base version from HEAD
+            let baseContent = "";
+            try {
+                baseContent = execSync(`git show HEAD:${this._escapeShellArg(filePath)}`, {
+                    cwd: this.repoPath,
+                    encoding: "utf8",
+                    stdio: "pipe",
+                });
+            }
+            catch {
+                // File might be new (not in HEAD), use empty base
+                baseContent = "";
+            }
+            fs.writeFileSync(baseTempFile, baseContent, "utf8");
+            // git merge-file modifies the first file in place
+            // Returns 0 if clean merge, >0 for number of conflicts, -1 for error
+            try {
+                execSync(`git merge-file -L "LOCAL" -L "BASE" -L "WORKTREE" ${this._escapeShellArg(localFilePath)} ${this._escapeShellArg(baseTempFile)} ${this._escapeShellArg(worktreeFilePath)}`, {
+                    cwd: this.repoPath,
+                    stdio: "pipe",
+                });
+                return false; // Exit 0 = clean merge, no conflicts
+            }
+            catch (error) {
+                // Exit code > 0 means conflicts (number of conflicts)
+                // Exit code < 0 means error
+                if (error.status > 0) {
+                    return true; // Has conflicts
+                }
+                // Real error - rethrow
+                throw error;
+            }
+        }
+        finally {
+            // Clean up temp file
+            if (fs.existsSync(baseTempFile)) {
+                fs.unlinkSync(baseTempFile);
+            }
+        }
+    }
+    /**
+     * Merge two JSONL files using UUID-based resolution
+     *
+     * Reads both local and worktree versions, merges entities by UUID,
+     * and writes the result back to the local file.
+     *
+     * @param localFilePath - Absolute path to local JSONL file
+     * @param worktreeFilePath - Absolute path to worktree JSONL file
+     */
+    async _mergeJSONLFiles(localFilePath, worktreeFilePath) {
+        // Read both versions
+        const localEntities = readJSONLSync(localFilePath, { skipErrors: true });
+        const worktreeEntities = readJSONLSync(worktreeFilePath, {
+            skipErrors: true,
+        });
+        // Combine and resolve using UUID-based deduplication
+        const allEntities = [...localEntities, ...worktreeEntities];
+        const { entities: merged } = resolveEntities(allEntities);
+        // Write merged result back to local file
+        await writeJSONL(localFilePath, merged);
+    }
+    /**
+     * Copy uncommitted files from worktree to local repo with safe merging
+     *
+     * For files with local uncommitted changes:
+     * - JSONL files: Uses UUID-based merge resolution
+     * - Other files: Uses git merge-file for three-way merge with conflict markers
+     *
+     * Files without local changes are copied directly.
+     *
+     * @param worktreePath - Path to the worktree
+     * @param options - Optional settings
+     * @param options.overrideLocalChanges - If true, skip merge and overwrite local changes
+     * @returns Object with filesCopied count and list of files with conflicts
+     */
+    async _copyUncommittedFiles(worktreePath, options) {
+        const { overrideLocalChanges = false } = options || {};
+        // Get list of uncommitted/untracked files in worktree
+        const modifiedOutput = execSync("git diff --name-only", {
+            cwd: worktreePath,
+            encoding: "utf8",
+            stdio: "pipe",
+        });
+        const untrackedOutput = execSync("git ls-files --others --exclude-standard", {
+            cwd: worktreePath,
+            encoding: "utf8",
+            stdio: "pipe",
+        });
+        const modifiedFiles = modifiedOutput
+            .split("\n")
+            .filter((line) => line.trim().length > 0);
+        const untrackedFiles = untrackedOutput
+            .split("\n")
+            .filter((line) => line.trim().length > 0);
+        const allFiles = [...new Set([...modifiedFiles, ...untrackedFiles])];
+        if (allFiles.length === 0) {
+            return { filesCopied: 0, filesWithConflicts: [] };
+        }
+        // Process each file from worktree
+        let filesCopied = 0;
+        const filesWithConflicts = [];
+        for (const filePath of allFiles) {
+            const srcPath = path.join(worktreePath, filePath);
+            const destPath = path.join(this.repoPath, filePath);
+            // Check if source file exists
+            if (!fs.existsSync(srcPath)) {
+                continue;
+            }
+            // Create destination directory if needed
+            const destDir = path.dirname(destPath);
+            if (!fs.existsSync(destDir)) {
+                fs.mkdirSync(destDir, { recursive: true });
+            }
+            // Check if local file has uncommitted changes or is untracked
+            // We need to merge if: (1) file exists locally AND (2) either has changes vs HEAD or is untracked
+            const localFileExists = fs.existsSync(destPath);
+            const localHasChangesVsHead = localFileExists && this._hasLocalUncommittedChanges(filePath);
+            const localIsUntracked = localFileExists && this._isFileUntracked(filePath);
+            const needsMerge = !overrideLocalChanges && (localHasChangesVsHead || localIsUntracked);
+            let hasConflicts = false;
+            if (!needsMerge) {
+                // No local changes OR override mode - copy directly (overwrites local)
+                fs.copyFileSync(srcPath, destPath);
+            }
+            else if (this._isJSONLFile(filePath)) {
+                // JSONL file with local changes - use UUID-based merge
+                await this._mergeJSONLFiles(destPath, srcPath);
+            }
+            else {
+                // Other file with local changes - use three-way merge
+                hasConflicts = this._threeWayMergeFile(filePath, srcPath);
+                if (hasConflicts) {
+                    filesWithConflicts.push(filePath);
+                }
+            }
+            // Stage the file ONLY if it doesn't have conflicts
+            // Files with conflict markers should remain unstaged so VS Code can detect them
+            if (!hasConflicts) {
+                execSync(`git add ${this._escapeShellArg(filePath)}`, {
+                    cwd: this.repoPath,
+                    stdio: "pipe",
+                });
+            }
+            filesCopied++;
         }
+        return { filesCopied, filesWithConflicts };
+    }
+    /**
+     * Resolve JSONL merge conflicts in the local repository
+     *
+     * Checks for git conflict markers in issues.jsonl and specs.jsonl,
+     * and resolves them using the merge-resolver logic.
+     *
+     * @returns Number of files resolved
+     */
+    async _resolveJSONLConflicts() {
+        const sudocodePath = path.join(this.repoPath, ".sudocode");
+        const issuesPath = path.join(sudocodePath, "issues.jsonl");
+        const specsPath = path.join(sudocodePath, "specs.jsonl");
+        let filesResolved = 0;
+        // Check and resolve issues.jsonl
+        if (fs.existsSync(issuesPath) && hasGitConflictMarkers(issuesPath)) {
+            await this._resolveJSONLFile(issuesPath);
+            filesResolved++;
+        }
+        // Check and resolve specs.jsonl
+        if (fs.existsSync(specsPath) && hasGitConflictMarkers(specsPath)) {
+            await this._resolveJSONLFile(specsPath);
+            filesResolved++;
+        }
+        return filesResolved;
+    }
+    /**
+     * Resolve conflicts in a single JSONL file
+     *
+     * @param filePath - Path to the JSONL file with conflicts
+     */
+    async _resolveJSONLFile(filePath) {
+        // Read file with conflict markers
+        const content = fs.readFileSync(filePath, "utf8");
+        // Parse conflicts
+        const sections = parseMergeConflictFile(content);
+        // Extract all entities (from both clean and conflict sections)
+        const allEntities = [];
+        for (const section of sections) {
+            if (section.type === "clean") {
+                for (const line of section.lines) {
+                    if (line.trim()) {
+                        try {
+                            allEntities.push(JSON.parse(line));
+                        }
+                        catch {
+                            // Skip malformed lines
+                        }
+                    }
+                }
+            }
+            else {
+                // Conflict section - include both ours and theirs
+                for (const line of [
+                    ...(section.ours || []),
+                    ...(section.theirs || []),
+                ]) {
+                    if (line.trim()) {
+                        try {
+                            allEntities.push(JSON.parse(line));
+                        }
+                        catch {
+                            // Skip malformed lines
+                        }
+                    }
+                }
+            }
+        }
+        // Resolve conflicts
+        const { entities: resolved } = resolveEntities(allEntities, {
+            verbose: false,
+        });
+        // Write back resolved entities
+        await writeJSONL(filePath, resolved);
+        // Stage the resolved file
+        const relativePath = path.relative(this.repoPath, filePath);
+        execSync(`git add ${this._escapeShellArg(relativePath)}`, {
+            cwd: this.repoPath,
+            stdio: "pipe",
+        });
     }
     /**
      * Generate commit message for squash sync
@@ -489,8 +944,9 @@ Synced changes from worktree execution.`;
     /**
      * Perform squash sync operation
      *
-     * Squashes all worktree commits into a single commit on the target branch.
-     * Auto-resolves JSONL conflicts but blocks on code conflicts.
+     * Squashes all committed worktree changes into a single commit on the target branch.
+     * Only includes committed changes - uncommitted changes are excluded.
+     * If merge conflicts occur, they are left for the user to resolve manually.
      *
      * @param executionId - Execution ID to sync
      * @param customCommitMessage - Optional custom commit message
@@ -502,34 +958,57 @@ Synced changes from worktree execution.`;
         const execution = await this._loadAndValidateExecution(executionId);
         // 2. Validate preconditions
         await this._validateSyncPreconditions(execution);
-        // 3. Preview sync to check for conflicts
+        // 3. Preview sync to get info (we'll proceed even with conflicts)
         const preview = await this.previewSync(executionId);
-        // 4. Block if code conflicts exist
-        if (preview.conflicts.codeConflicts.length > 0) {
+        // 4. Check if there are any commits to merge
+        if (preview.commits.length === 0) {
             return {
                 success: false,
                 filesChanged: 0,
-                conflictsResolved: 0,
-                uncommittedJSONLIncluded: false,
-                error: `Cannot sync: ${preview.conflicts.codeConflicts.length} code conflict(s) detected. Please resolve manually.`,
+                error: "No commits to merge. Only committed changes are included in sync.",
+            };
+        }
+        // 5. Check if worktree branch is already merged into target
+        if (this._isAncestor(execution.branch_name, execution.target_branch)) {
+            return {
+                success: false,
+                filesChanged: 0,
+                error: "Target branch is already up to date with worktree changes. Nothing to merge.",
             };
         }
         let safetyTag;
         try {
-            // 5. Handle uncommitted JSONL files
-            const uncommittedJSONL = preview.uncommittedJSONLChanges;
-            if (uncommittedJSONL.length > 0) {
-                await this.commitUncommittedJSONL(execution.worktree_path, uncommittedJSONL);
-            }
-            // 6. Create safety snapshot
+            // 6. Create safety snapshot (before any changes)
             safetyTag = await this._createSafetySnapshot(executionId, execution.target_branch);
-            // 7. Perform git merge --squash
-            const mergeResult = this._performSquashMerge(execution.branch_name, execution.target_branch);
-            // 8. Resolve JSONL conflicts
-            let conflictsResolved = 0;
-            if (preview.conflicts.jsonlConflicts.length > 0) {
-                await this.resolveJSONLConflicts(execution, preview.conflicts.jsonlConflicts);
-                conflictsResolved = preview.conflicts.jsonlConflicts.length;
+            // 7. Perform git merge --squash (may have conflicts)
+            const mergeResult = this._performSquashMergeAllowConflicts(execution.branch_name, execution.target_branch);
+            // 8. Check if there are unresolved conflicts
+            if (mergeResult.hasConflicts) {
+                // Get list of files with conflicts
+                let filesWithConflicts = [];
+                try {
+                    const conflictCheck = execSync("git diff --name-only --diff-filter=U", {
+                        cwd: this.repoPath,
+                        encoding: "utf8",
+                        stdio: "pipe",
+                    });
+                    filesWithConflicts = conflictCheck
+                        .trim()
+                        .split("\n")
+                        .filter((f) => f.length > 0);
+                }
+                catch {
+                    // If command fails, leave empty
+                }
+                // Return with conflicts info - user must resolve manually
+                return {
+                    success: false,
+                    filesChanged: mergeResult.filesChanged,
+                    hasConflicts: true,
+                    filesWithConflicts,
+                    error: "Merge conflicts detected. Please resolve them manually and commit.",
+                    cleanupOffered: false,
+                };
             }
             // 9. Generate commit message
             const commitMessage = customCommitMessage ||
@@ -541,8 +1020,6 @@ Synced changes from worktree execution.`;
                 success: true,
                 finalCommit,
                 filesChanged: mergeResult.filesChanged,
-                conflictsResolved,
-                uncommittedJSONLIncluded: uncommittedJSONL.length > 0,
                 cleanupOffered: true,
             };
         }
@@ -559,5 +1036,297 @@ Synced changes from worktree execution.`;
             throw new WorktreeSyncError(`Squash sync failed: ${error.message}`, WorktreeSyncErrorCode.MERGE_FAILED, error);
         }
     }
+    /**
+     * 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.
+     * Only includes committed changes by default - uncommitted changes are excluded
+     * unless includeUncommitted is true.
+     *
+     * @param executionId - Execution ID to sync
+     * @param options - Optional settings
+     * @param options.includeUncommitted - If true, also copy uncommitted files from worktree
+     * @param options.overrideLocalChanges - If true, overwrite local changes instead of merging
+     * @returns Sync result with details
+     * @throws WorktreeSyncError if sync fails
+     */
+    async stageSync(executionId, options) {
+        const { includeUncommitted = false, overrideLocalChanges = false } = options || {};
+        // 1. Load and validate execution
+        const execution = await this._loadAndValidateExecution(executionId);
+        // 2. Validate preconditions (skip dirty working tree check - stage mode doesn't commit)
+        await this._validateSyncPreconditions(execution, {
+            skipDirtyWorkingTreeCheck: true,
+        });
+        // 3. Preview sync to get info
+        const preview = await this.previewSync(executionId);
+        // 4. Check if there's anything to sync
+        const hasCommits = preview.commits.length > 0;
+        if (!hasCommits && !includeUncommitted) {
+            return {
+                success: false,
+                filesChanged: 0,
+                error: "No commits to merge. Only committed changes are included in sync.",
+            };
+        }
+        let safetyTag;
+        try {
+            // 5. Create safety snapshot (before any changes)
+            safetyTag = await this._createSafetySnapshot(executionId, execution.target_branch);
+            let filesChanged = 0;
+            let hasConflicts = false;
+            // 6. Perform git merge --squash for committed changes (if any)
+            if (hasCommits) {
+                const mergeResult = this._performSquashMergeAllowConflicts(execution.branch_name, execution.target_branch);
+                filesChanged = mergeResult.filesChanged;
+                hasConflicts = mergeResult.hasConflicts;
+            }
+            // 7. Copy uncommitted files from worktree if requested (with safe merging)
+            let uncommittedFilesCopied = 0;
+            let filesWithConflicts = [];
+            if (includeUncommitted && execution.worktree_path) {
+                const copyResult = await this._copyUncommittedFiles(execution.worktree_path, { overrideLocalChanges });
+                uncommittedFilesCopied = copyResult.filesCopied;
+                filesWithConflicts = copyResult.filesWithConflicts;
+                filesChanged += uncommittedFilesCopied;
+                // If we have conflicts from uncommitted files merge, mark hasConflicts
+                if (filesWithConflicts.length > 0) {
+                    hasConflicts = true;
+                }
+            }
+            // 8. Auto-resolve JSONL conflicts if any (from git merge --squash)
+            const jsonlFilesResolved = await this._resolveJSONLConflicts();
+            if (jsonlFilesResolved > 0) {
+                // Re-check for remaining conflicts after JSONL resolution
+                try {
+                    const conflictCheck = execSync("git diff --name-only --diff-filter=U", {
+                        cwd: this.repoPath,
+                        encoding: "utf8",
+                        stdio: "pipe",
+                    });
+                    const remainingConflictFiles = conflictCheck
+                        .trim()
+                        .split("\n")
+                        .filter((f) => f.length > 0);
+                    hasConflicts = remainingConflictFiles.length > 0;
+                    // Add any remaining conflict files not already tracked
+                    for (const file of remainingConflictFiles) {
+                        if (!filesWithConflicts.includes(file)) {
+                            filesWithConflicts.push(file);
+                        }
+                    }
+                }
+                catch {
+                    // If command fails, assume no additional conflicts
+                }
+            }
+            // 9. Check if there are unresolved (non-JSONL) conflicts
+            if (hasConflicts) {
+                return {
+                    success: false,
+                    filesChanged,
+                    hasConflicts: true,
+                    filesWithConflicts,
+                    uncommittedFilesIncluded: uncommittedFilesCopied,
+                    error: "Merge conflicts detected. Please resolve them manually.",
+                    cleanupOffered: false,
+                };
+            }
+            // 10. Return success result WITHOUT creating a commit
+            // Changes remain staged for user to commit manually
+            return {
+                success: true,
+                filesChanged,
+                uncommittedFilesIncluded: uncommittedFilesCopied,
+                cleanupOffered: true,
+            };
+        }
+        catch (error) {
+            // Rollback to safety snapshot on failure
+            if (safetyTag) {
+                try {
+                    await this._rollbackToSnapshot(execution.target_branch, safetyTag);
+                }
+                catch (rollbackError) {
+                    console.error(`Failed to rollback to snapshot ${safetyTag}:`, rollbackError);
+                }
+            }
+            throw new WorktreeSyncError(`Stage sync failed: ${error.message}`, WorktreeSyncErrorCode.MERGE_FAILED, error);
+        }
+    }
+    /**
+     * Check if worktree branch is an ancestor of target branch
+     *
+     * If the worktree branch is an ancestor, it means target already has all
+     * the commits from the worktree (e.g., via a previous sync).
+     *
+     * @param worktreeBranch - Worktree branch name
+     * @param targetBranch - Target branch name
+     * @returns true if worktree branch is an ancestor of target branch
+     */
+    _isAncestor(worktreeBranch, targetBranch) {
+        try {
+            execSync(`git merge-base --is-ancestor ${this._escapeShellArg(worktreeBranch)} ${this._escapeShellArg(targetBranch)}`, {
+                cwd: this.repoPath,
+                stdio: "pipe",
+            });
+            // Exit code 0 means worktreeBranch IS an ancestor of targetBranch
+            return true;
+        }
+        catch {
+            // Exit code 1 means NOT an ancestor, which is what we want for merging
+            return false;
+        }
+    }
+    /**
+     * Perform preserve sync operation
+     *
+     * Merges all commits from worktree branch to target branch, preserving commit history.
+     * Only includes committed changes - uncommitted changes are excluded.
+     * If merge conflicts occur, they are left for the user to resolve manually.
+     *
+     * @param executionId - Execution ID to sync
+     * @returns Sync result with details
+     * @throws WorktreeSyncError if sync fails
+     */
+    async preserveSync(executionId) {
+        // 1. Load and validate execution
+        const execution = await this._loadAndValidateExecution(executionId);
+        // 2. Validate preconditions
+        await this._validateSyncPreconditions(execution);
+        // 3. Preview sync to get info
+        const preview = await this.previewSync(executionId);
+        // 4. Check if there are any commits to merge
+        if (preview.commits.length === 0) {
+            return {
+                success: false,
+                filesChanged: 0,
+                error: "No commits to merge. Only committed changes are included in sync.",
+            };
+        }
+        // 5. Check if worktree branch is already merged into target
+        // This happens if a previous sync (squash or preserve) already merged these commits
+        if (this._isAncestor(execution.branch_name, execution.target_branch)) {
+            return {
+                success: false,
+                filesChanged: 0,
+                error: "Target branch is already up to date with worktree changes. Nothing to merge.",
+            };
+        }
+        let safetyTag;
+        try {
+            // 6. Create safety snapshot (before any changes)
+            safetyTag = await this._createSafetySnapshot(executionId, execution.target_branch);
+            // 7. Checkout target branch
+            execSync(`git checkout ${this._escapeShellArg(execution.target_branch)}`, {
+                cwd: this.repoPath,
+                stdio: "pipe",
+            });
+            // 8. Perform regular merge (preserves commit history)
+            let hasConflicts = false;
+            let filesChanged = 0;
+            try {
+                execSync(`git merge ${this._escapeShellArg(execution.branch_name)}`, {
+                    cwd: this.repoPath,
+                    stdio: "pipe",
+                });
+            }
+            catch (error) {
+                // Merge may have failed due to conflicts
+                hasConflicts = true;
+            }
+            // 9. Count files changed
+            try {
+                const diffOutput = execSync(`git diff --name-only ${this._escapeShellArg(safetyTag)}..HEAD`, {
+                    cwd: this.repoPath,
+                    encoding: "utf8",
+                    stdio: "pipe",
+                });
+                filesChanged = diffOutput
+                    .split("\n")
+                    .filter((line) => line.trim().length > 0).length;
+            }
+            catch {
+                // If merge is in progress, count staged/conflicted files
+                const statusOutput = execSync("git diff --name-only --cached", {
+                    cwd: this.repoPath,
+                    encoding: "utf8",
+                    stdio: "pipe",
+                });
+                filesChanged = statusOutput
+                    .split("\n")
+                    .filter((line) => line.trim().length > 0).length;
+            }
+            // 10. Auto-resolve JSONL conflicts if any
+            const jsonlFilesResolved = await this._resolveJSONLConflicts();
+            if (jsonlFilesResolved > 0) {
+                // Re-check for remaining conflicts
+                try {
+                    const conflictCheck = execSync("git diff --name-only --diff-filter=U", {
+                        cwd: this.repoPath,
+                        encoding: "utf8",
+                        stdio: "pipe",
+                    });
+                    hasConflicts = conflictCheck.trim().length > 0;
+                }
+                catch {
+                    hasConflicts = false;
+                }
+            }
+            // 11. Check if there are unresolved conflicts
+            if (hasConflicts) {
+                // Get list of files with conflicts
+                let filesWithConflicts = [];
+                try {
+                    const conflictCheck = execSync("git diff --name-only --diff-filter=U", {
+                        cwd: this.repoPath,
+                        encoding: "utf8",
+                        stdio: "pipe",
+                    });
+                    filesWithConflicts = conflictCheck
+                        .trim()
+                        .split("\n")
+                        .filter((f) => f.length > 0);
+                }
+                catch {
+                    // If command fails, leave empty
+                }
+                return {
+                    success: false,
+                    filesChanged,
+                    hasConflicts: true,
+                    filesWithConflicts,
+                    error: "Merge conflicts detected. Please resolve them manually and commit.",
+                    cleanupOffered: false,
+                };
+            }
+            // 12. Get the final commit SHA
+            const finalCommit = execSync("git rev-parse HEAD", {
+                cwd: this.repoPath,
+                encoding: "utf8",
+                stdio: "pipe",
+            }).trim();
+            // 13. Return success result
+            return {
+                success: true,
+                finalCommit,
+                filesChanged,
+                cleanupOffered: true,
+            };
+        }
+        catch (error) {
+            // Rollback to safety snapshot on failure
+            if (safetyTag) {
+                try {
+                    await this._rollbackToSnapshot(execution.target_branch, safetyTag);
+                }
+                catch (rollbackError) {
+                    console.error(`Failed to rollback to snapshot ${safetyTag}:`, rollbackError);
+                }
+            }
+            throw new WorktreeSyncError(`Preserve sync failed: ${error.message}`, WorktreeSyncErrorCode.MERGE_FAILED, error);
+        }
+    }
 }
 //# sourceMappingURL=worktree-sync-service.js.map