sudocode 1.1.20 → 1.1.22

package/node_modules/@sudocode-ai/local-server/dist/services/worktree-sync-service.js

@@ -1,1602 +0,0 @@
-/**
- * Worktree Sync Service
- *
- * Orchestrates worktree sync operations including conflict detection,
- * JSONL resolution, git operations, and database updates.
- *
- * @module services/worktree-sync-service
- */
-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, 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
- */
-export var WorktreeSyncErrorCode;
-(function (WorktreeSyncErrorCode) {
-    WorktreeSyncErrorCode["NO_WORKTREE"] = "NO_WORKTREE";
-    WorktreeSyncErrorCode["WORKTREE_MISSING"] = "WORKTREE_MISSING";
-    WorktreeSyncErrorCode["BRANCH_MISSING"] = "BRANCH_MISSING";
-    WorktreeSyncErrorCode["DIRTY_WORKING_TREE"] = "DIRTY_WORKING_TREE";
-    WorktreeSyncErrorCode["TARGET_BRANCH_MISSING"] = "TARGET_BRANCH_MISSING";
-    WorktreeSyncErrorCode["NO_COMMON_BASE"] = "NO_COMMON_BASE";
-    WorktreeSyncErrorCode["CODE_CONFLICTS"] = "CODE_CONFLICTS";
-    WorktreeSyncErrorCode["MERGE_FAILED"] = "MERGE_FAILED";
-    WorktreeSyncErrorCode["JSONL_RESOLUTION_FAILED"] = "JSONL_RESOLUTION_FAILED";
-    WorktreeSyncErrorCode["DATABASE_SYNC_FAILED"] = "DATABASE_SYNC_FAILED";
-    WorktreeSyncErrorCode["EXECUTION_NOT_FOUND"] = "EXECUTION_NOT_FOUND";
-})(WorktreeSyncErrorCode || (WorktreeSyncErrorCode = {}));
-/**
- * Worktree sync error class
- */
-export class WorktreeSyncError extends Error {
-    code;
-    cause;
-    constructor(message, code, cause) {
-        super(message);
-        this.code = code;
-        this.cause = cause;
-        this.name = "WorktreeSyncError";
-    }
-}
-/**
- * WorktreeSyncService
- *
- * Main service class for orchestrating worktree sync operations
- */
-export class WorktreeSyncService {
-    db;
-    repoPath;
-    gitSync;
-    constructor(db, repoPath) {
-        this.db = db;
-        this.repoPath = repoPath;
-        this.gitSync = new GitSyncCli(repoPath);
-    }
-    /**
-     * Preview sync without making changes
-     *
-     * @param executionId - Execution ID to preview sync for
-     * @returns Preview result with conflicts, diff, and warnings
-     */
-    async previewSync(executionId) {
-        // 1. Load execution and validate
-        const execution = await this._loadAndValidateExecution(executionId);
-        // 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: {
-                    hasConflicts: false,
-                    codeConflicts: [],
-                    jsonlConflicts: [],
-                    totalFiles: 0,
-                    summary: "",
-                },
-                diff: { files: [], additions: 0, deletions: 0 },
-                commits: [],
-                mergeBase: "",
-                uncommittedJSONLChanges: [],
-                uncommittedChanges: { files: [], additions: 0, deletions: 0 },
-                executionStatus: execution.status,
-                warnings: [criticalPreconditionError],
-            };
-        }
-        // 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);
-        // 6. Get diff summary (use main repo to see all changes)
-        const diff = this.gitSync.getDiff(mergeBase, execution.branch_name);
-        // 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 local working tree status (categorizes JSONL vs other uncommitted changes)
-        const localWorkingTreeStatus = this.gitSync.getWorkingTreeStatus();
-        let localUncommittedJsonl;
-        if (!localWorkingTreeStatus.isClean) {
-            if (localWorkingTreeStatus.hasOnlyJsonlChanges) {
-                // Only JSONL files uncommitted - can still sync, will auto-merge
-                localUncommittedJsonl = {
-                    files: localWorkingTreeStatus.uncommittedJsonlFiles,
-                    willAutoMerge: true,
-                };
-                // Don't add warning - info will be shown in UI
-            }
-            else {
-                // Non-JSONL files are uncommitted - block sync
-                warnings.push("Local working tree has uncommitted changes. Stash or commit them first.");
-                canSync = false;
-                // Still include JSONL info for context
-                if (localWorkingTreeStatus.uncommittedJsonlFiles.length > 0) {
-                    localUncommittedJsonl = {
-                        files: localWorkingTreeStatus.uncommittedJsonlFiles,
-                        willAutoMerge: false, // Can't auto-merge if there are other uncommitted files
-                    };
-                }
-            }
-        }
-        // Warn if execution is running/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 may be required.`);
-        }
-        // 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,
-            diff,
-            commits,
-            mergeBase,
-            uncommittedJSONLChanges: uncommittedJSONL,
-            uncommittedChanges,
-            potentialLocalConflicts,
-            localUncommittedJsonl,
-            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
-     *
-     * Used by previewSync() and will be used in i-9gz4 (squash sync)
-     *
-     * @param executionId - Execution ID to load
-     * @returns Execution record
-     * @throws WorktreeSyncError if execution not found
-     */
-    async _loadAndValidateExecution(executionId) {
-        const stmt = this.db.prepare("SELECT * FROM executions WHERE id = ?");
-        const execution = stmt.get(executionId);
-        if (!execution) {
-            throw new WorktreeSyncError(`Execution ${executionId} not found`, WorktreeSyncErrorCode.EXECUTION_NOT_FOUND);
-        }
-        return execution;
-    }
-    /**
-     * Validate preconditions for sync
-     *
-     * Used by previewSync() and will be used in i-9gz4 (squash sync)
-     *
-     * Checks:
-     * - Worktree exists
-     * - Worktree branch exists
-     * - Local working tree is clean (or only has JSONL changes which can be auto-merged)
-     * - Target branch exists
-     * - Branches have common base
-     *
-     * @param execution - Execution to validate
-     * @param options - Options to control validation behavior
-     * @param options.skipDirtyWorkingTreeCheck - Skip the dirty working tree check entirely
-     * @param options.allowJsonlOnlyChanges - Allow sync if only JSONL files are uncommitted (they'll be auto-merged)
-     * @throws WorktreeSyncError if any precondition fails
-     */
-    async _validateSyncPreconditions(execution, options) {
-        const { skipDirtyWorkingTreeCheck = false, allowJsonlOnlyChanges = false } = options || {};
-        // 1. Check worktree path exists
-        if (!execution.worktree_path) {
-            throw new WorktreeSyncError("No worktree path for execution", WorktreeSyncErrorCode.NO_WORKTREE);
-        }
-        // 2. Check worktree still exists on filesystem
-        if (!fs.existsSync(execution.worktree_path)) {
-            throw new WorktreeSyncError("Worktree no longer exists", WorktreeSyncErrorCode.WORKTREE_MISSING);
-        }
-        // 3. Get list of branches
-        const branches = this._getBranches();
-        // 4. Check worktree branch exists
-        if (!branches.includes(execution.branch_name)) {
-            throw new WorktreeSyncError(`Worktree branch '${execution.branch_name}' not found`, WorktreeSyncErrorCode.BRANCH_MISSING);
-        }
-        // 5. Check target branch exists
-        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 (skip for stage mode since it doesn't commit)
-        if (!skipDirtyWorkingTreeCheck) {
-            const workingTreeStatus = this.gitSync.getWorkingTreeStatus();
-            if (!workingTreeStatus.isClean) {
-                // If only JSONL files are uncommitted and allowJsonlOnlyChanges is true, allow sync
-                if (allowJsonlOnlyChanges && workingTreeStatus.hasOnlyJsonlChanges) {
-                    // This is OK - JSONL files will be auto-merged
-                }
-                else if (workingTreeStatus.uncommittedOtherFiles.length > 0) {
-                    // Non-JSONL files are uncommitted - block sync
-                    throw new WorktreeSyncError("Local working tree has uncommitted changes. Stash or commit them first.", WorktreeSyncErrorCode.DIRTY_WORKING_TREE);
-                }
-                else {
-                    // Only JSONL files but allowJsonlOnlyChanges is false - block sync
-                    throw new WorktreeSyncError("Local working tree has uncommitted changes. Stash or commit them first.", WorktreeSyncErrorCode.DIRTY_WORKING_TREE);
-                }
-            }
-        }
-        // 7. Verify branches have common base
-        try {
-            this.gitSync.getMergeBase(execution.branch_name, execution.target_branch);
-        }
-        catch (error) {
-            throw new WorktreeSyncError("Worktree and target branch have diverged without common history", WorktreeSyncErrorCode.NO_COMMON_BASE, error);
-        }
-    }
-    /**
-     * Saved state of uncommitted JSONL files for restoration after merge
-     */
-    _savedUncommittedJsonl = null;
-    /**
-     * Save uncommitted JSONL files before merge operation
-     *
-     * Reads both the uncommitted (working tree) and committed (HEAD) versions
-     * of each JSONL file, then resets the working tree copy to HEAD.
-     * The saved versions can be restored with _restoreUncommittedJsonl().
-     *
-     * @returns Map of file paths to their uncommitted and pre-committed content
-     */
-    async _saveUncommittedJsonl() {
-        const status = this.gitSync.getWorkingTreeStatus();
-        const savedFiles = new Map();
-        for (const filePath of status.uncommittedJsonlFiles) {
-            const fullPath = path.join(this.repoPath, filePath);
-            // Read current uncommitted content from working tree
-            let uncommittedContent = "";
-            if (fs.existsSync(fullPath)) {
-                uncommittedContent = fs.readFileSync(fullPath, "utf8");
-            }
-            // Read committed version from HEAD
-            let preCommittedContent = "";
-            try {
-                preCommittedContent = execSync(`git show HEAD:${this._escapeShellArg(filePath)}`, {
-                    cwd: this.repoPath,
-                    encoding: "utf8",
-                    stdio: "pipe",
-                });
-            }
-            catch {
-                // File might not exist at HEAD (new file), use empty content
-                preCommittedContent = "";
-            }
-            savedFiles.set(filePath, { uncommittedContent, preCommittedContent });
-            // Reset the file to HEAD so it doesn't interfere with merge
-            try {
-                execSync(`git checkout HEAD -- ${this._escapeShellArg(filePath)}`, {
-                    cwd: this.repoPath,
-                    stdio: "pipe",
-                });
-            }
-            catch {
-                // If file doesn't exist at HEAD, remove it from working tree
-                if (fs.existsSync(fullPath)) {
-                    fs.unlinkSync(fullPath);
-                }
-            }
-        }
-        this._savedUncommittedJsonl = savedFiles;
-        return savedFiles;
-    }
-    /**
-     * Restore uncommitted JSONL files after merge operation
-     *
-     * Performs a three-way merge:
-     * - base: pre-merge committed version (from HEAD before merge)
-     * - ours: saved uncommitted local changes
-     * - theirs: post-merge result
-     *
-     * The merged result is written back to the working tree.
-     */
-    async _restoreUncommittedJsonl() {
-        if (!this._savedUncommittedJsonl || this._savedUncommittedJsonl.size === 0) {
-            return;
-        }
-        for (const [filePath, saved] of this._savedUncommittedJsonl) {
-            const fullPath = path.join(this.repoPath, filePath);
-            // Read post-merge version from working tree
-            let postMergeContent = "";
-            if (fs.existsSync(fullPath)) {
-                postMergeContent = fs.readFileSync(fullPath, "utf8");
-            }
-            // Parse all three versions as JSONL entities
-            const parseJsonl = (content) => {
-                if (!content.trim())
-                    return [];
-                return content
-                    .split("\n")
-                    .filter((line) => line.trim())
-                    .map((line) => {
-                    try {
-                        return JSON.parse(line);
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter((entity) => entity !== null);
-            };
-            const baseEntities = parseJsonl(saved.preCommittedContent);
-            const oursEntities = parseJsonl(saved.uncommittedContent);
-            const theirsEntities = parseJsonl(postMergeContent);
-            // Perform three-way merge using the merge resolver
-            const { entities: merged } = mergeThreeWay(baseEntities, oursEntities, theirsEntities);
-            // Write merged result back to working tree
-            await writeJSONL(fullPath, merged);
-        }
-        // Clear saved state
-        this._savedUncommittedJsonl = null;
-    }
-    /**
-     * Create safety snapshot before sync
-     *
-     * Creates a git tag pointing to current target branch HEAD
-     * for rollback capability
-     *
-     * @param executionId - Execution ID
-     * @param targetBranch - Target branch name
-     * @returns Tag name created
-     */
-    async _createSafetySnapshot(executionId, targetBranch) {
-        const tagName = `sudocode-sync-before-${executionId}`;
-        // Get current commit of target branch
-        const currentCommit = this._getCurrentCommit(targetBranch);
-        // Create annotated tag
-        this.gitSync.createSafetyTag(tagName, currentCommit);
-        return tagName;
-    }
-    /**
-     * Get all uncommitted files from worktree
-     *
-     * @param worktreePath - Path to worktree
-     * @returns Array of all uncommitted file paths
-     */
-    _getUncommittedFiles(worktreePath) {
-        const gitSyncWorktree = new GitSyncCli(worktreePath);
-        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
-     *
-     * TODO: Will be used in i-7ya6 (sync preview)
-     *
-     * @returns true if clean, false if dirty
-     */
-    // @ts-expect-error - Foundation method, will be used in i-7ya6
-    _isLocalTreeClean() {
-        return this.gitSync.isWorkingTreeClean();
-    }
-    /**
-     * Get list of branches in repository
-     *
-     * @returns Array of branch names
-     */
-    _getBranches() {
-        try {
-            const output = execSync("git branch --format='%(refname:short)'", {
-                cwd: this.repoPath,
-                encoding: "utf8",
-                stdio: "pipe",
-                shell: "/bin/bash",
-            });
-            return output
-                .split("\n")
-                .map((line) => line.trim())
-                .filter((line) => line.length > 0);
-        }
-        catch (error) {
-            throw new WorktreeSyncError(`Failed to get branch list: ${error.message}`, WorktreeSyncErrorCode.BRANCH_MISSING, error);
-        }
-    }
-    /**
-     * Get current commit SHA for a branch
-     *
-     * @param branchName - Branch name
-     * @returns Commit SHA
-     */
-    _getCurrentCommit(branchName) {
-        try {
-            const output = execSync(`git rev-parse ${this._escapeShellArg(branchName)}`, {
-                cwd: this.repoPath,
-                encoding: "utf8",
-                stdio: "pipe",
-            });
-            return output.trim();
-        }
-        catch (error) {
-            throw new WorktreeSyncError(`Failed to get commit for branch ${branchName}: ${error.message}`, WorktreeSyncErrorCode.BRANCH_MISSING, error);
-        }
-    }
-    /**
-     * Escape shell argument for safe command execution
-     *
-     * @param arg - Argument to escape
-     * @returns Escaped argument
-     */
-    _escapeShellArg(arg) {
-        // Escape single quotes and wrap in single quotes
-        return `'${arg.replace(/'/g, "'\\''")}'`;
-    }
-    /**
-     * Resolve JSONL conflicts using three-way merge
-     *
-     * Used in squash sync to auto-resolve JSONL conflicts
-     *
-     * @param execution - Execution record
-     * @param jsonlConflicts - List of JSONL conflicts to resolve
-     * @throws WorktreeSyncError if resolution fails
-     */
-    async resolveJSONLConflicts(execution, jsonlConflicts) {
-        if (jsonlConflicts.length === 0) {
-            return;
-        }
-        const mergeBase = this.gitSync.getMergeBase(execution.branch_name, execution.target_branch);
-        for (const conflict of jsonlConflicts) {
-            try {
-                // Read three versions of the file
-                const baseVersion = await this._readJSONLVersion(conflict.filePath, mergeBase);
-                const ourVersion = await this._readJSONLVersion(conflict.filePath, execution.target_branch);
-                const theirVersion = await this._readJSONLVersion(conflict.filePath, execution.branch_name);
-                // Perform three-way merge
-                const { entities: merged } = mergeThreeWay(baseVersion, ourVersion, theirVersion);
-                // Write resolved version to local repo
-                const resolvedPath = path.join(this.repoPath, conflict.filePath);
-                await writeJSONL(resolvedPath, merged);
-                // Stage the resolved file
-                execSync(`git add ${this._escapeShellArg(conflict.filePath)}`, {
-                    cwd: this.repoPath,
-                    stdio: "pipe",
-                });
-            }
-            catch (error) {
-                throw new WorktreeSyncError(`Failed to resolve JSONL conflict in ${conflict.filePath}: ${error.message}`, WorktreeSyncErrorCode.JSONL_RESOLUTION_FAILED, error);
-            }
-        }
-    }
-    /**
-     * Read JSONL file at a specific git revision
-     *
-     * @param filePath - Relative path to JSONL file
-     * @param revision - Git revision (commit SHA or branch name)
-     * @returns Array of JSONL entities
-     */
-    async _readJSONLVersion(filePath, revision) {
-        try {
-            // Get file content at revision using git show
-            const content = execSync(`git show ${this._escapeShellArg(revision)}:${this._escapeShellArg(filePath)}`, {
-                cwd: this.repoPath,
-                encoding: "utf8",
-                stdio: "pipe",
-            });
-            // Parse JSONL content
-            const lines = content
-                .split("\n")
-                .filter((line) => line.trim().length > 0);
-            return lines.map((line) => JSON.parse(line));
-        }
-        catch (error) {
-            // File might not exist at this revision (new file)
-            if (error.status === 128) {
-                return [];
-            }
-            throw error;
-        }
-    }
-    /**
-     * Commit uncommitted JSONL files in worktree
-     *
-     * Used during sync to include uncommitted JSONL changes
-     *
-     * @param worktreePath - Path to worktree
-     * @param uncommittedFiles - List of uncommitted JSONL file paths
-     * @throws WorktreeSyncError if commit fails
-     */
-    async commitUncommittedJSONL(worktreePath, uncommittedFiles) {
-        if (uncommittedFiles.length === 0) {
-            return;
-        }
-        try {
-            // Stage all uncommitted JSONL files
-            for (const file of uncommittedFiles) {
-                execSync(`git add ${this._escapeShellArg(file)}`, {
-                    cwd: worktreePath,
-                    stdio: "pipe",
-                });
-            }
-            // Create commit with descriptive message
-            const fileList = uncommittedFiles.join(", ");
-            const message = `Auto-commit uncommitted JSONL changes before sync\n\nFiles: ${fileList}`;
-            execSync(`git commit --no-verify -m ${this._escapeShellArg(message)}`, {
-                cwd: worktreePath,
-                stdio: "pipe",
-            });
-        }
-        catch (error) {
-            throw new WorktreeSyncError(`Failed to commit uncommitted JSONL files: ${error.message}`, WorktreeSyncErrorCode.DATABASE_SYNC_FAILED, error);
-        }
-    }
-    /**
-     * 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 and hasConflicts flag
-     */
-    _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 {
-            execSync(`git merge --squash ${this._escapeShellArg(sourceBranch)}`, {
-                cwd: this.repoPath,
-                stdio: "pipe",
-            });
-        }
-        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",
-            });
-            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
-     *
-     * This is a TWO-WAY merge (no base version available).
-     * Used for merging uncommitted local + worktree JSONL files during stage sync.
-     *
-     * Uses `resolveEntities` for simple UUID-based deduplication, which is appropriate
-     * for two-way scenarios where we don't have a common base version.
-     *
-     * @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,
-        });
-        // Two-way merge: Combine and resolve using UUID-based deduplication
-        // This is correct for two-way scenarios (no base version)
-        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
-     *
-     * Uses three-way merge when we have base/ours/theirs versions from git.
-     * This enables proper three-way merge semantics with YAML-based line-level merging.
-     *
-     * @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);
-        // Try to use three-way merge by getting base/ours/theirs from git
-        // This is more accurate than parsing conflict markers
-        const relativePath = path.relative(this.repoPath, filePath);
-        try {
-            // Get base version from merge-base (git stage 1)
-            let baseEntities = [];
-            try {
-                // Note: Using execSync with _escapeShellArg for consistency with rest of file
-                const baseContent = execSync(`git show :1:${this._escapeShellArg(relativePath)}`, {
-                    cwd: this.repoPath,
-                    encoding: "utf8",
-                    stdio: "pipe",
-                });
-                baseEntities = this._parseJSONLContent(baseContent);
-            }
-            catch {
-                // No base version (new file or file didn't exist at merge-base)
-                baseEntities = [];
-            }
-            // Get ours version (git stage 2)
-            let oursEntities = [];
-            try {
-                const oursContent = execSync(`git show :2:${this._escapeShellArg(relativePath)}`, {
-                    cwd: this.repoPath,
-                    encoding: "utf8",
-                    stdio: "pipe",
-                });
-                oursEntities = this._parseJSONLContent(oursContent);
-            }
-            catch {
-                // No ours version
-                oursEntities = [];
-            }
-            // Get theirs version (git stage 3)
-            let theirsEntities = [];
-            try {
-                const theirsContent = execSync(`git show :3:${this._escapeShellArg(relativePath)}`, {
-                    cwd: this.repoPath,
-                    encoding: "utf8",
-                    stdio: "pipe",
-                });
-                theirsEntities = this._parseJSONLContent(theirsContent);
-            }
-            catch {
-                // No theirs version
-                theirsEntities = [];
-            }
-            // If we have at least ours and theirs (or base), use three-way merge
-            // This provides proper three-way semantics with YAML-based line-level merging
-            if (oursEntities.length > 0 || theirsEntities.length > 0 || baseEntities.length > 0) {
-                const { entities: resolved } = mergeThreeWay(baseEntities, oursEntities, theirsEntities);
-                // Write back resolved entities
-                await writeJSONL(filePath, resolved);
-                // Stage the resolved file
-                execSync(`git add ${this._escapeShellArg(relativePath)}`, {
-                    cwd: this.repoPath,
-                    stdio: "pipe",
-                });
-                return;
-            }
-        }
-        catch (error) {
-            // If three-way merge fails, fall back to two-way resolution below
-            console.warn(`Three-way merge failed for ${relativePath}, using fallback resolution:`, error);
-        }
-        // Fallback: Use two-way resolution from conflict markers
-        // This is used when git stages are not available (manual conflict resolution)
-        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
-                        }
-                    }
-                }
-            }
-        }
-        // Two-way resolution: Use resolveEntities for UUID-based deduplication
-        // This is appropriate when we don't have a true base version
-        const { entities: resolved } = resolveEntities(allEntities, {
-            verbose: false,
-        });
-        // Write back resolved entities
-        await writeJSONL(filePath, resolved);
-        // Stage the resolved file
-        execSync(`git add ${this._escapeShellArg(relativePath)}`, {
-            cwd: this.repoPath,
-            stdio: "pipe",
-        });
-    }
-    /**
-     * Parse JSONL content into entities
-     *
-     * Helper function for parsing JSONL content from git or files.
-     *
-     * @param content - JSONL content as string
-     * @returns Array of parsed entities
-     */
-    _parseJSONLContent(content) {
-        if (!content.trim())
-            return [];
-        return content
-            .split("\n")
-            .filter((line) => line.trim())
-            .map((line) => {
-            try {
-                return JSON.parse(line);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter((entity) => entity !== null);
-    }
-    /**
-     * Generate commit message for squash sync
-     *
-     * @param execution - Execution record
-     * @param commitCount - Number of commits being squashed
-     * @returns Generated commit message
-     */
-    _generateCommitMessage(execution, commitCount) {
-        const issueId = execution.issue_id || "unknown";
-        const branchName = execution.branch_name;
-        return `Squash merge from ${branchName} (${commitCount} commit${commitCount !== 1 ? "s" : ""})
-
-Issue: ${issueId}
-Execution: ${execution.id}
-
-Synced changes from worktree execution.`;
-    }
-    /**
-     * Create commit with staged changes
-     *
-     * @param message - Commit message
-     * @returns Commit SHA
-     * @throws WorktreeSyncError if commit fails
-     */
-    _createCommit(message) {
-        try {
-            execSync(`git commit --no-verify -m ${this._escapeShellArg(message)}`, {
-                cwd: this.repoPath,
-                stdio: "pipe",
-            });
-            // Get the commit SHA
-            const sha = execSync("git rev-parse HEAD", {
-                cwd: this.repoPath,
-                encoding: "utf8",
-                stdio: "pipe",
-            }).trim();
-            return sha;
-        }
-        catch (error) {
-            throw new WorktreeSyncError(`Failed to create commit: ${error.message}`, WorktreeSyncErrorCode.MERGE_FAILED, error);
-        }
-    }
-    /**
-     * Rollback to safety snapshot
-     *
-     * @param targetBranch - Target branch to reset
-     * @param tagName - Safety tag to rollback to
-     * @throws WorktreeSyncError if rollback fails
-     */
-    async _rollbackToSnapshot(targetBranch, tagName) {
-        try {
-            // Checkout target branch
-            execSync(`git checkout ${this._escapeShellArg(targetBranch)}`, {
-                cwd: this.repoPath,
-                stdio: "pipe",
-            });
-            // Reset to tag
-            execSync(`git reset --hard ${this._escapeShellArg(tagName)}`, {
-                cwd: this.repoPath,
-                stdio: "pipe",
-            });
-            console.log(`Rolled back ${targetBranch} to ${tagName}`);
-        }
-        catch (error) {
-            throw new WorktreeSyncError(`Failed to rollback to snapshot ${tagName}: ${error.message}`, WorktreeSyncErrorCode.MERGE_FAILED, error);
-        }
-    }
-    /**
-     * Perform squash sync operation
-     *
-     * 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
-     * @returns Sync result with details
-     * @throws WorktreeSyncError if sync fails
-     */
-    async squashSync(executionId, customCommitMessage) {
-        // 1. Load and validate execution
-        const execution = await this._loadAndValidateExecution(executionId);
-        // 2. Validate preconditions (allow JSONL-only changes, they'll be auto-merged)
-        await this._validateSyncPreconditions(execution, { allowJsonlOnlyChanges: true });
-        // 3. Save uncommitted JSONL files before merge (will be restored after)
-        const savedJsonlFiles = await this._saveUncommittedJsonl();
-        const hasUncommittedJsonl = savedJsonlFiles.size > 0;
-        // 4. Preview sync to get info (we'll proceed even with conflicts)
-        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
-        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. 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 ||
-                this._generateCommitMessage(execution, preview.commits.length);
-            // 10. Create commit
-            const finalCommit = this._createCommit(commitMessage);
-            // 11. Restore uncommitted JSONL files with three-way merge
-            if (hasUncommittedJsonl) {
-                await this._restoreUncommittedJsonl();
-            }
-            // 12. Return success result
-            return {
-                success: true,
-                finalCommit,
-                filesChanged: mergeResult.filesChanged,
-                cleanupOffered: true,
-            };
-        }
-        catch (error) {
-            // Restore uncommitted JSONL files even on failure (to avoid losing user changes)
-            if (hasUncommittedJsonl) {
-                try {
-                    await this._restoreUncommittedJsonl();
-                }
-                catch (restoreError) {
-                    console.error("Failed to restore uncommitted JSONL files:", restoreError);
-                }
-            }
-            // 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(`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 (allow JSONL-only changes, they'll be auto-merged)
-        await this._validateSyncPreconditions(execution, { allowJsonlOnlyChanges: true });
-        // 3. Save uncommitted JSONL files before merge (will be restored after)
-        const savedJsonlFiles = await this._saveUncommittedJsonl();
-        const hasUncommittedJsonl = savedJsonlFiles.size > 0;
-        // 4. 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. Restore uncommitted JSONL files with three-way merge
-            if (hasUncommittedJsonl) {
-                await this._restoreUncommittedJsonl();
-            }
-            // 14. Return success result
-            return {
-                success: true,
-                finalCommit,
-                filesChanged,
-                cleanupOffered: true,
-            };
-        }
-        catch (error) {
-            // Restore uncommitted JSONL files even on failure (to avoid losing user changes)
-            if (hasUncommittedJsonl) {
-                try {
-                    await this._restoreUncommittedJsonl();
-                }
-                catch (restoreError) {
-                    console.error("Failed to restore uncommitted JSONL files:", restoreError);
-                }
-            }
-            // 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