@sudocode-ai/local-server 0.1.9 → 0.1.11

package/dist/services/worktree-sync-service.d.ts

@@ -42,6 +42,15 @@ export interface UncommittedFileStats {
     additions: number;
     deletions: number;
 }
+/**
+ * Info about potential local conflicts when including uncommitted files
+ */
+export interface PotentialLocalConflicts {
+    /** Number of files that may have merge conflicts */
+    count: number;
+    /** List of files that may have merge conflicts */
+    files: string[];
+}
 /**
  * Sync preview result
  */
@@ -55,6 +64,8 @@ export interface SyncPreviewResult {
     uncommittedJSONLChanges: string[];
     /** Stats about uncommitted changes in worktree (not included in sync by default) */
     uncommittedChanges?: UncommittedFileStats;
+    /** Files that may have merge conflicts if "include uncommitted" is selected */
+    potentialLocalConflicts?: PotentialLocalConflicts;
     executionStatus: ExecutionStatus;
     warnings: string[];
 }
@@ -67,6 +78,8 @@ export interface SyncResult {
     filesChanged: number;
     /** Whether there are unresolved merge conflicts (user must resolve manually) */
     hasConflicts?: boolean;
+    /** List of files that have merge conflicts requiring manual resolution */
+    filesWithConflicts?: string[];
     /** Number of uncommitted files copied from worktree (stage sync only) */
     uncommittedFilesIncluded?: number;
     error?: string;
@@ -221,13 +234,70 @@ export declare class WorktreeSyncService {
      */
     private _performSquashMergeAllowConflicts;
     /**
-     * Copy uncommitted files from worktree to local repo
+     * 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
+     */
+    private _hasLocalUncommittedChanges;
+    /**
+     * Detect potential local conflicts for uncommitted worktree files
      *
-     * Copies files that are modified or untracked in the worktree
-     * to the local repository working directory.
+     * 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
+     */
+    private _detectPotentialLocalConflicts;
+    /**
+     * 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
+     */
+    private _isFileUntracked;
+    /**
+     * 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
+     */
+    private _isJSONLFile;
+    /**
+     * 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
+     */
+    private _threeWayMergeFile;
+    /**
+     * 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
+     */
+    private _mergeJSONLFiles;
+    /**
+     * 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
-     * @returns Number of files copied
+     * @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
      */
     private _copyUncommittedFiles;
     /**
@@ -293,11 +363,13 @@ export declare class WorktreeSyncService {
      * @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
      */
     stageSync(executionId: string, options?: {
         includeUncommitted?: boolean;
+        overrideLocalChanges?: boolean;
     }): Promise<SyncResult>;
     /**
      * Check if worktree branch is an ancestor of target branch

package/dist/services/worktree-sync-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worktree-sync-service.d.ts","sourceRoot":"","sources":["../../src/services/worktree-sync-service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAIrE,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,MAAM,EACZ,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,4CAA4C,CAAC;AASpD;;GAEG;AACH,oBAAY,qBAAqB;IAC/B,WAAW,gBAAgB;IAC3B,gBAAgB,qBAAqB;IACrC,cAAc,mBAAmB;IACjC,kBAAkB,uBAAuB;IACzC,qBAAqB,0BAA0B;IAC/C,cAAc,mBAAmB;IACjC,cAAc,mBAAmB;IACjC,YAAY,iBAAiB;IAC7B,uBAAuB,4BAA4B;IACnD,oBAAoB,yBAAyB;IAC7C,mBAAmB,wBAAwB;CAC5C;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAGjC,IAAI,EAAE,qBAAqB;IAC3B,KAAK,CAAC,EAAE,KAAK;gBAFpB,OAAO,EAAE,MAAM,EACR,IAAI,EAAE,qBAAqB,EAC3B,KAAK,CAAC,EAAE,KAAK,YAAA;CAKvB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,cAAc,CAAC;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,uBAAuB,EAAE,MAAM,EAAE,CAAC;IAClC,oFAAoF;IACpF,kBAAkB,CAAC,EAAE,oBAAoB,CAAC;IAC1C,eAAe,EAAE,eAAe,CAAC;IACjC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,yEAAyE;IACzE,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;GAIG;AACH,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,QAAQ;IAJlB,OAAO,CAAC,OAAO,CAAa;gBAGlB,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,QAAQ,EAAE,MAAM;IAK1B;;;;;OAKG;IACG,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAiHlE;;;;;;;;OAQG;YACW,8BAA8B;IAoC5C;;;;;;;;OAQG;YACW,yBAAyB;IAgBvC;;;;;;;;;;;;;;OAcG;YACW,0BAA0B;IA6DxC;;;;;;;;;OASG;YACW,qBAAqB;IAenC;;;;;OAKG;IACH,OAAO,CAAC,oBAAoB;IAK5B;;;;;;;;OAQG;IACH,OAAO,CAAC,wBAAwB;IAqEhC;;;;;;OAMG;IAEH,OAAO,CAAC,iBAAiB;IAIzB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAsBpB;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAqBzB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAKvB;;;;;;;;OAQG;IACG,qBAAqB,CACzB,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,aAAa,EAAE,GAC9B,OAAO,CAAC,IAAI,CAAC;IAoDhB;;;;;;OAMG;YACW,iBAAiB;IA6B/B;;;;;;;;OAQG;IACG,sBAAsB,CAC1B,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EAAE,GACzB,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;;;;;;;OASG;IACH,OAAO,CAAC,iCAAiC;IAiDzC;;;;;;;;OAQG;YACW,qBAAqB;IA8DnC;;;;;;;OAOG;YACW,sBAAsB;IAsBpC;;;;OAIG;YACW,iBAAiB;IAsD/B;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAwBrB;;;;;;OAMG;YACW,mBAAmB;IA2BjC;;;;;;;;;;;OAWG;IACG,UAAU,CACd,WAAW,EAAE,MAAM,EACnB,mBAAmB,CAAC,EAAE,MAAM,GAC3B,OAAO,CAAC,UAAU,CAAC;IA8FtB;;;;;;;;;;;;;OAaG;IACG,SAAS,CACb,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;QAAE,kBAAkB,CAAC,EAAE,OAAO,CAAA;KAAE,GACzC,OAAO,CAAC,UAAU,CAAC;IAsHtB;;;;;;;;;OASG;IACH,OAAO,CAAC,WAAW;IAiBnB;;;;;;;;;;OAUG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAyJ7D"}
+{"version":3,"file":"worktree-sync-service.d.ts","sourceRoot":"","sources":["../../src/services/worktree-sync-service.ts"],"names":[],"mappings":"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"}

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

@@ -12,7 +12,8 @@ import { execSync } from "child_process";
 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 } from "@sudocode-ai/cli/dist/jsonl.js";
+import { writeJSONL, readJSONLSync, } from "@sudocode-ai/cli/dist/jsonl.js";
+import * as os from "os";
 /**
  * Worktree sync error codes
  */
@@ -125,6 +126,9 @@ export class WorktreeSyncService {
         //     `${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,
@@ -133,6 +137,7 @@ export class WorktreeSyncService {
             mergeBase,
             uncommittedJSONLChanges: uncommittedJSONL,
             uncommittedChanges,
+            potentialLocalConflicts,
             executionStatus: execution.status,
             warnings,
         };
@@ -550,15 +555,175 @@ export class WorktreeSyncService {
         return { filesChanged, hasConflicts };
     }
     /**
-     * Copy uncommitted files from worktree to local repo
+     * Check if a file has local uncommitted changes compared to HEAD
      *
-     * Copies files that are modified or untracked in the worktree
-     * to the local repository working directory.
+     * @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",
+            });
+            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",
+            });
+            return result.trim().length === 0; // Empty = untracked
+        }
+        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
-     * @returns Number of files copied
+     * @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) {
+    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,
@@ -578,10 +743,11 @@ export class WorktreeSyncService {
             .filter((line) => line.trim().length > 0);
         const allFiles = [...new Set([...modifiedFiles, ...untrackedFiles])];
         if (allFiles.length === 0) {
-            return 0;
+            return { filesCopied: 0, filesWithConflicts: [] };
         }
-        // Copy each file from worktree to local repo
+        // 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);
@@ -594,16 +760,39 @@ export class WorktreeSyncService {
             if (!fs.existsSync(destDir)) {
                 fs.mkdirSync(destDir, { recursive: true });
             }
-            // Copy file
-            fs.copyFileSync(srcPath, destPath);
-            // Stage the file
-            execSync(`git add ${this._escapeShellArg(filePath)}`, {
-                cwd: this.repoPath,
-                stdio: "pipe",
-            });
+            // 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;
+        return { filesCopied, filesWithConflicts };
     }
     /**
      * Resolve JSONL merge conflicts in the local repository
@@ -795,11 +984,28 @@ Synced changes from worktree execution.`;
             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,
                 };
@@ -841,11 +1047,12 @@ Synced changes from worktree execution.`;
      * @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 } = 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)
@@ -875,13 +1082,20 @@ Synced changes from worktree execution.`;
                 filesChanged = mergeResult.filesChanged;
                 hasConflicts = mergeResult.hasConflicts;
             }
-            // 7. Copy uncommitted files from worktree if requested
+            // 7. Copy uncommitted files from worktree if requested (with safe merging)
             let uncommittedFilesCopied = 0;
+            let filesWithConflicts = [];
             if (includeUncommitted && execution.worktree_path) {
-                uncommittedFilesCopied = await this._copyUncommittedFiles(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
+            // 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
@@ -891,11 +1105,20 @@ Synced changes from worktree execution.`;
                         encoding: "utf8",
                         stdio: "pipe",
                     });
-                    hasConflicts = conflictCheck.trim().length > 0;
+                    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 conflicts
-                    hasConflicts = false;
+                    // If command fails, assume no additional conflicts
                 }
             }
             // 9. Check if there are unresolved (non-JSONL) conflicts
@@ -904,6 +1127,7 @@ Synced changes from worktree execution.`;
                     success: false,
                     filesChanged,
                     hasConflicts: true,
+                    filesWithConflicts,
                     uncommittedFilesIncluded: uncommittedFilesCopied,
                     error: "Merge conflicts detected. Please resolve them manually.",
                     cleanupOffered: false,
@@ -1052,10 +1276,27 @@ Synced changes from worktree execution.`;
             }
             // 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,
                 };