symphony-github 0.1.0

package/dist/agents/runner.js

@@ -0,0 +1,1190 @@
+import { existsSync, readdirSync, rmSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { TmuxService } from '../services/tmux.js';
+import { GitHubClient } from '../services/github.js';
+import { createWorktree, ensureClone, removeWorktree } from '../git/worktree.js';
+import { fetchOrigin, fetchBranchRef, findUnresolvedMergeMarkers, getConflictedFiles, getGitRoot, getHeadSha, getCommitCount, hasDiffBetweenRefs, hasUncommittedChanges, isGitWorktree, pushBranch, getMainBranch, resolveBranchRef, } from '../git/utils.js';
+import { launchAgentInPane, writeContextFiles, resolveAgent, buildAgentPromptCommand } from './launcher.js';
+import { generateRunId } from '../utils/slug.js';
+import { runSafe } from '../utils/shell.js';
+import { allowsAutomaticConflictResolution, allowsAutomaticMerge } from '../runModes.js';
+const SHELL_PROMPT_PATTERNS = [
+    /^\[[^\]]+\]\s*[$#%]\s*$/,
+    /^[^>\n]*[$#%]\s*$/,
+];
+const AGENT_PROMPT_PATTERNS = [
+    /^\s*>\s*\S?/,
+    /^\s*❯\s*\S?/,
+    /^\s*›\s*\S?/,
+    /^\s*│\s*>\s*\S?/,
+];
+const NEEDS_ATTENTION_PATTERNS = [
+    /approval/i,
+    /approve/i,
+    /review command/i,
+    /allow this command/i,
+    /permission/i,
+    /press enter to continue/i,
+    /continue\?/i,
+    /waiting for input/i,
+];
+const WORKING_PATTERNS = [
+    /thinking/i,
+    /planning/i,
+    /analyzing/i,
+    /building/i,
+    /staging/i,
+    /committing/i,
+    /finalizing/i,
+    /testing/i,
+    /running/i,
+    /searching/i,
+    /reviewing/i,
+    /writing/i,
+    /reading/i,
+    /editing/i,
+    /patching/i,
+    /generating/i,
+    /refactoring/i,
+    /fixing/i,
+    /checking/i,
+];
+const ACTIVE_PROMPT_TAIL_PATTERNS = [
+    /esc to interrupt/i,
+    /\(\d+[smh].*interrupt/i,
+    /considering/i,
+    /inspecting/i,
+    /implementing/i,
+    /verifying/i,
+    /staging/i,
+    /committing/i,
+    /finalizing/i,
+];
+const GIT_AUTOMATION_TIMEOUT_MS = 60_000;
+/**
+ * Execute a full agent run for an issue.
+ * Ported from symphony Python's runner.py + daemon.py.
+ */
+export class AgentRunner {
+    runtime;
+    github;
+    tmux;
+    settings;
+    onProgress;
+    constructor(settings, runtime, onProgress) {
+        this.settings = settings;
+        this.runtime = runtime;
+        this.github = new GitHubClient();
+        this.tmux = TmuxService.getInstance();
+        this.onProgress = onProgress;
+    }
+    /**
+     * Set up and launch an agent run, returning the pane info.
+     */
+    async startRun(repo, issue, comments, sessionName, mode) {
+        // Resolve agent
+        const agent = resolveAgent(issue, comments, repo, this.settings);
+        // Generate run ID
+        const runId = generateRunId(repo, issue.number);
+        // Create worktree
+        const worktree = await createWorktree(repo, issue.number, issue.title, this.settings.clone_root, this.settings.worktree_root);
+        // Write context files
+        writeContextFiles(worktree.path, issue, comments, repo);
+        const baseSha = await getHeadSha(worktree.path);
+        // Create run directory and manifest
+        const runDir = this.runtime.createRun({
+            run_id: runId,
+            repo,
+            issue_number: issue.number,
+            issue_title: issue.title,
+            issue_url: issue.html_url,
+            agent_name: agent.name,
+            agent_provider: agent.provider,
+            model: agent.model,
+            mode,
+            branch: worktree.branch,
+            worktree_path: worktree.path,
+            base_sha: baseSha,
+            started_at: new Date().toISOString(),
+            status: 'running',
+        });
+        // Create tmux pane (in a background window)
+        const paneId = await this.tmux.createWindow(sessionName, `${issue.number}-${agent.name}`, worktree.path);
+        this.runtime.updateManifest(runId, {
+            tmux_session: sessionName,
+            tmux_pane_id: paneId,
+        });
+        // Build run request
+        const request = {
+            repo,
+            issue,
+            agent,
+            mode,
+            worktree_path: worktree.path,
+            branch: worktree.branch,
+            run_id: runId,
+            run_dir: runDir,
+        };
+        // Launch agent in the pane
+        await launchAgentInPane(paneId, request, { swarmEnabled: this.settings.swarm?.enabled });
+        // Record event
+        this.runtime.appendEvent(runId, {
+            type: 'started',
+            agent: agent.name,
+            provider: agent.provider,
+            session_name: sessionName,
+            pane_id: paneId,
+        });
+        // Create pane info for TUI
+        const pane = {
+            id: runId,
+            slug: worktree.branch,
+            type: 'issue',
+            repo,
+            issue_number: issue.number,
+            issue_title: issue.title,
+            issue_url: issue.html_url,
+            agent_name: agent.name,
+            agent_provider: agent.provider,
+            run_id: runId,
+            mode,
+            status: 'running',
+            tmux_pane_id: paneId,
+            worktree_path: worktree.path,
+            branch: worktree.branch,
+            base_sha: baseSha,
+            started_at: new Date().toISOString(),
+        };
+        return { pane, runId };
+    }
+    /**
+     * Inspect a run and classify whether it is still working, needs review,
+     * needs attention, or has fully completed.
+     */
+    async checkRunStatus(pane) {
+        const worktreeState = pane.worktree_path
+            ? await this.inspectWorktreeState(pane.worktree_path, pane.branch || '', pane.base_sha)
+            : { commits: 0, has_uncommitted: false, head_sha: undefined, has_repo_changes: false };
+        const hasMeaningfulResult = worktreeState.has_repo_changes || worktreeState.has_uncommitted;
+        if (!pane.tmux_pane_id) {
+            if (hasMeaningfulResult) {
+                return {
+                    status: 'success',
+                    detail: 'Recovered completed worktree without a live tmux pane',
+                    result: this.buildSuccessResult(worktreeState),
+                };
+            }
+            return {
+                status: 'failed',
+                detail: 'Missing tmux pane id',
+                result: {
+                    success: false,
+                    exit_code: 1,
+                    error_summary: 'Missing tmux pane id',
+                    commits: 0,
+                    has_uncommitted: false,
+                    has_repo_changes: false,
+                },
+            };
+        }
+        // Check if the pane still exists
+        const exists = await this.tmux.paneExists(pane.tmux_pane_id);
+        if (!exists) {
+            if (hasMeaningfulResult) {
+                return {
+                    status: 'success',
+                    detail: 'Agent pane exited after producing repository changes',
+                    result: this.buildSuccessResult(worktreeState),
+                };
+            }
+            return {
+                status: 'failed',
+                detail: 'Agent pane terminated unexpectedly',
+                result: {
+                    success: false,
+                    exit_code: 1,
+                    error_summary: 'Agent pane terminated unexpectedly',
+                    commits: 0,
+                    has_uncommitted: false,
+                    has_repo_changes: false,
+                },
+            };
+        }
+        // Check pane content for completion indicators
+        const content = await this.tmux.getPaneContent(pane.tmux_pane_id, 30);
+        const lines = content.split('\n').map(l => l.trim()).filter(Boolean);
+        const recentLines = lines.slice(-8);
+        const recentContent = recentLines.join('\n');
+        // Check for shell prompt (agent has exited, back to shell)
+        const lastLine = lines[lines.length - 1] || '';
+        const isAtShellPrompt = SHELL_PROMPT_PATTERNS.some(pattern => pattern.test(lastLine));
+        if (isAtShellPrompt) {
+            return {
+                status: 'success',
+                result: this.buildSuccessResult(worktreeState),
+            };
+        }
+        const needsAttention = NEEDS_ATTENTION_PATTERNS.some(pattern => pattern.test(recentContent));
+        if (needsAttention) {
+            return {
+                status: 'needs_attention',
+                detail: 'Agent is waiting for approval or input',
+            };
+        }
+        let agentPromptIndex = -1;
+        for (let idx = recentLines.length - 1; idx >= 0; idx--) {
+            if (AGENT_PROMPT_PATTERNS.some(pattern => pattern.test(recentLines[idx] || ''))) {
+                agentPromptIndex = idx;
+                break;
+            }
+        }
+        if (hasMeaningfulResult && agentPromptIndex !== -1) {
+            const promptTail = recentLines
+                .slice(Math.max(0, agentPromptIndex - 3), agentPromptIndex)
+                .join('\n');
+            const promptStillBusy = ACTIVE_PROMPT_TAIL_PATTERNS.some(pattern => pattern.test(promptTail));
+            if (promptStillBusy) {
+                return {
+                    status: 'running',
+                    detail: 'Agent produced changes; waiting for terminal to settle',
+                };
+            }
+            return {
+                status: 'success',
+                detail: 'Agent finished work',
+                result: this.buildSuccessResult(worktreeState),
+            };
+        }
+        const stillWorking = WORKING_PATTERNS.some(pattern => pattern.test(recentContent));
+        if (stillWorking) {
+            return { status: 'running' };
+        }
+        if (hasMeaningfulResult) {
+            return {
+                status: 'success',
+                detail: 'Agent finished work',
+                result: this.buildSuccessResult(worktreeState),
+            };
+        }
+        return { status: 'running' };
+    }
+    async requestAgentExit(pane) {
+        if (!pane.tmux_pane_id)
+            return;
+        await this.tmux.sendKeys(pane.tmux_pane_id, 'C-d');
+    }
+    /**
+     * Handle post-run actions (push, PR, labels, comments).
+     */
+    async handleRunCompletion(pane, result) {
+        if (!pane.run_id || !pane.repo)
+            return;
+        const mode = pane.mode || this.runtime.getManifest(pane.run_id)?.mode || this.settings.mode;
+        const agent = this.getResolvedAgentForPane(pane);
+        let finalStatus = result.success ? 'success' : 'failed';
+        let finalDetail = result.success
+            ? (result.has_repo_changes || result.has_uncommitted
+                ? describeWorktreeState(result.commits, result.has_uncommitted)
+                : 'Completed without effective repository changes')
+            : (result.error_summary || 'Run failed');
+        let shouldCleanupArtifacts = false;
+        let shouldClosePane = false;
+        if (result.success) {
+            if (agent) {
+                this.recordAutomationProgress(pane, allowsAutomaticMerge(mode)
+                    ? 'Agent finished; finalizing merge automation'
+                    : 'Agent finished; finalizing PR automation');
+                const automation = await this.handleAutomaticCompletion(pane, result, mode, agent);
+                finalStatus = automation.status;
+                finalDetail = automation.detail;
+                shouldCleanupArtifacts = automation.cleanupArtifacts;
+                shouldClosePane = automation.closePane;
+                if (automation.mergedPr && pane.repo) {
+                    const syncResult = await this.syncLocalCheckouts(pane.repo);
+                    if (syncResult.detail) {
+                        finalDetail = `${finalDetail} (${syncResult.detail})`;
+                    }
+                }
+            }
+            else if (!result.has_repo_changes && !result.has_uncommitted) {
+                shouldCleanupArtifacts = true;
+                shouldClosePane = true;
+            }
+        }
+        if (shouldCleanupArtifacts) {
+            const cleanupResult = await this.cleanupRunArtifacts(pane);
+            if (!cleanupResult.cleaned) {
+                finalDetail = `${finalDetail} (cleanup failed: ${cleanupResult.reason})`;
+            }
+        }
+        if (shouldClosePane && pane.tmux_pane_id) {
+            try {
+                await this.tmux.killPane(pane.tmux_pane_id);
+            }
+            catch {
+                // Ignore pane cleanup failures.
+            }
+            pane.tmux_pane_id = undefined;
+        }
+        pane.status = finalStatus;
+        pane.status_detail = finalDetail;
+        this.runtime.updateManifest(pane.run_id, {
+            finished_at: new Date().toISOString(),
+            status: finalStatus,
+            exit_code: result.exit_code,
+            error_summary: result.error_summary,
+            status_detail: finalDetail,
+            commits: result.commits,
+            head_sha: result.head_sha,
+            tmux_pane_id: pane.tmux_pane_id,
+            worktree_path: pane.worktree_path,
+            branch: pane.branch,
+            base_sha: pane.base_sha,
+        });
+        this.runtime.appendEvent(pane.run_id, {
+            type: 'finished',
+            status: finalStatus,
+            commits: result.commits,
+            detail: finalDetail,
+        });
+    }
+    async inspectWorktreeState(worktreePath, branch, baseSha) {
+        const commits = baseSha
+            ? await getCommitCount(baseSha, 'HEAD', worktreePath)
+            : (branch
+                ? await getCommitCount(await getMainBranch(worktreePath), branch, worktreePath)
+                : 0);
+        const has_uncommitted = await hasUncommittedChanges(worktreePath);
+        const head_sha = commits > 0 ? await getHeadSha(worktreePath) : undefined;
+        const compareRef = baseSha || (branch ? await getMainBranch(worktreePath) : '');
+        const has_repo_changes = has_uncommitted
+            || (compareRef ? await hasDiffBetweenRefs(compareRef, 'HEAD', worktreePath) : commits > 0);
+        return { commits, has_uncommitted, head_sha, has_repo_changes };
+    }
+    buildSuccessResult(worktreeState) {
+        return {
+            success: true,
+            exit_code: 0,
+            commits: worktreeState.commits,
+            head_sha: worktreeState.head_sha,
+            has_uncommitted: worktreeState.has_uncommitted,
+            has_repo_changes: worktreeState.has_repo_changes,
+        };
+    }
+    recordAutomationProgress(pane, detail) {
+        pane.status = 'running';
+        pane.status_detail = detail;
+        if (!pane.run_id)
+            return;
+        this.runtime.updateManifest(pane.run_id, {
+            status: 'running',
+            status_detail: detail,
+            tmux_pane_id: pane.tmux_pane_id,
+            worktree_path: pane.worktree_path,
+            branch: pane.branch,
+        });
+        this.runtime.appendEvent(pane.run_id, {
+            type: 'status_updated',
+            status: 'running',
+            detail,
+        });
+        try {
+            void this.onProgress?.({ ...pane });
+        }
+        catch {
+            // Ignore reporting callback failures.
+        }
+    }
+    async handleAutomaticCompletion(pane, result, mode, agent) {
+        if (!pane.branch || !pane.worktree_path) {
+            return {
+                status: 'awaiting_review',
+                detail: 'Changes exist but branch metadata is missing; manual review required',
+                cleanupArtifacts: false,
+                closePane: false,
+                mergedPr: false,
+            };
+        }
+        if (result.has_uncommitted) {
+            const finalized = await this.finalizePendingChanges(pane);
+            if (!finalized.committed) {
+                return {
+                    status: 'awaiting_review',
+                    detail: finalized.detail,
+                    cleanupArtifacts: false,
+                    closePane: false,
+                    mergedPr: false,
+                };
+            }
+            const updatedState = await this.inspectWorktreeState(pane.worktree_path, pane.branch, pane.base_sha);
+            result.commits = updatedState.commits;
+            result.has_uncommitted = updatedState.has_uncommitted;
+            result.head_sha = updatedState.head_sha;
+            result.has_repo_changes = updatedState.has_repo_changes;
+        }
+        if (!result.has_repo_changes) {
+            return {
+                status: 'awaiting_review',
+                detail: result.commits > 0
+                    ? 'Agent produced commits, but the branch has no effective repository diff; refusing to auto-merge a no-op result'
+                    : 'Agent finished without repository changes; manual verification required',
+                cleanupArtifacts: false,
+                closePane: false,
+                mergedPr: false,
+            };
+        }
+        const markerValidation = await this.validateNoMergeMarkers(pane.worktree_path, `Branch ${pane.branch} still contains unresolved merge markers`);
+        if (!markerValidation.ok) {
+            return {
+                status: 'awaiting_review',
+                detail: markerValidation.detail,
+                cleanupArtifacts: false,
+                closePane: false,
+                mergedPr: false,
+            };
+        }
+        if (!agent.push) {
+            return {
+                status: 'awaiting_review',
+                detail: `Changes ready on ${pane.branch}; push is disabled, manual review required`,
+                cleanupArtifacts: false,
+                closePane: false,
+                mergedPr: false,
+            };
+        }
+        this.recordAutomationProgress(pane, `Pushing ${pane.branch} to origin`);
+        const pushed = await pushBranch(pane.branch, pane.worktree_path);
+        if (!pushed.ok) {
+            return {
+                status: 'awaiting_review',
+                detail: `Changes ready on ${pane.branch}; failed to push branch for review${pushed.detail ? `: ${pushed.detail}` : ''}`,
+                cleanupArtifacts: false,
+                closePane: false,
+                mergedPr: false,
+            };
+        }
+        let prNumber;
+        let prUrl;
+        let prFailureDetail = '';
+        if (agent.create_pr !== 'none') {
+            const mainBranch = await getMainBranch(pane.worktree_path);
+            this.recordAutomationProgress(pane, `Creating a pull request for ${pane.branch}`);
+            const createdPr = await this.github.createPr(pane.repo, {
+                title: `[Symphony] ${pane.issue_title || `Issue #${pane.issue_number}`}`,
+                body: [
+                    `Closes #${pane.issue_number}`,
+                    '',
+                    `Automated by Symphony agent \`${pane.agent_name}\`.`,
+                ].join('\n'),
+                head: pane.branch,
+                base: mainBranch,
+                draft: agent.create_pr === 'draft',
+            }, pane.worktree_path);
+            const foundPr = createdPr.pr
+                ? { pr: createdPr.pr, detail: createdPr.detail }
+                : await this.github.findOpenPrForBranch(pane.repo, pane.branch, pane.worktree_path);
+            const pr = createdPr.pr || foundPr.pr;
+            prFailureDetail = createdPr.detail || foundPr.detail || '';
+            if (pr) {
+                prNumber = pr.number;
+                prUrl = pr.html_url;
+                this.runtime.updateManifest(pane.run_id, {
+                    pr_url: pr.html_url,
+                    pr_number: pr.number,
+                });
+                if (allowsAutomaticMerge(mode)) {
+                    return this.attemptAutomaticMerge(pane, agent, pr, mode);
+                }
+                return {
+                    status: 'awaiting_review',
+                    detail: `PR #${pr.number} is ready for manual merge${prUrl ? `: ${prUrl}` : ''}`,
+                    cleanupArtifacts: false,
+                    closePane: false,
+                    mergedPr: false,
+                };
+            }
+        }
+        if (allowsAutomaticMerge(mode)) {
+            return {
+                status: 'awaiting_review',
+                detail: `Branch ${pane.branch} was pushed, but no PR is available for automatic merging${prFailureDetail ? `: ${prFailureDetail}` : ''}`,
+                cleanupArtifacts: false,
+                closePane: false,
+                mergedPr: false,
+            };
+        }
+        return {
+            status: 'awaiting_review',
+            detail: `Branch ${pane.branch} was pushed and is waiting for manual merge${prFailureDetail ? `: ${prFailureDetail}` : ''}`,
+            cleanupArtifacts: false,
+            closePane: false,
+            mergedPr: false,
+        };
+    }
+    async attemptAutomaticMerge(pane, agent, pr, mode) {
+        const maxAutomaticMergePasses = 3;
+        this.recordAutomationProgress(pane, `Inspecting PR #${pr.number} for automatic merge`);
+        let currentPr = await this.waitForPrState(pane.repo, pr.number, 10, pane.worktree_path) || await this.github.getPr(pane.repo, pr.number, pane.worktree_path) || pr;
+        if (currentPr.is_draft) {
+            this.recordAutomationProgress(pane, `Marking PR #${pr.number} ready for automatic merge`);
+            const readied = await this.github.readyPr(pane.repo, pr.number, pane.worktree_path);
+            if (!readied.ok) {
+                return {
+                    status: 'awaiting_review',
+                    detail: `PR #${pr.number} exists as a draft and could not be marked ready for merge${readied.detail ? `: ${readied.detail}` : ''}`,
+                    cleanupArtifacts: false,
+                    closePane: false,
+                    mergedPr: false,
+                };
+            }
+            currentPr = await this.waitForPrState(pane.repo, pr.number, 5, pane.worktree_path) || currentPr;
+        }
+        for (let pass = 1; pass <= maxAutomaticMergePasses; pass++) {
+            currentPr = await this.waitForPrState(pane.repo, pr.number, 8, pane.worktree_path) || currentPr;
+            if (currentPr.state && currentPr.state !== 'OPEN') {
+                if (currentPr.merged_at) {
+                    return {
+                        status: 'success',
+                        detail: `Merged PR #${pr.number} and cleaned up local artifacts`,
+                        cleanupArtifacts: true,
+                        closePane: true,
+                        mergedPr: true,
+                    };
+                }
+                return {
+                    status: 'awaiting_review',
+                    detail: `PR #${pr.number} is no longer open, but GitHub does not report it as merged`,
+                    cleanupArtifacts: false,
+                    closePane: false,
+                    mergedPr: false,
+                };
+            }
+            if (currentPr.mergeable === 'CONFLICTING') {
+                if (!allowsAutomaticConflictResolution(mode)) {
+                    return {
+                        status: 'awaiting_review',
+                        detail: `PR #${pr.number} has merge conflicts and is waiting for manual conflict resolution`,
+                        cleanupArtifacts: false,
+                        closePane: false,
+                        mergedPr: false,
+                    };
+                }
+                this.recordAutomationProgress(pane, `Resolving merge conflicts for PR #${pr.number} (pass ${pass})`);
+                const resolved = await this.resolveAutomergeConflicts(pane, agent, pr.number);
+                if (!resolved.resolved) {
+                    return {
+                        status: 'awaiting_review',
+                        detail: resolved.detail,
+                        cleanupArtifacts: false,
+                        closePane: false,
+                        mergedPr: false,
+                    };
+                }
+                currentPr = await this.waitForPrState(pane.repo, pr.number, 12, pane.worktree_path) || currentPr;
+                continue;
+            }
+            this.recordAutomationProgress(pane, `Attempting automatic merge for PR #${pr.number} (pass ${pass})`);
+            const mergeResult = await this.github.mergePr(pane.repo, pr.number, pane.worktree_path);
+            this.runtime.appendEvent(pane.run_id, {
+                type: mergeResult.status === 'merged' ? 'pr_merged' : 'pr_merge_pending',
+                pr_number: pr.number,
+            });
+            if (mergeResult.status === 'merged') {
+                return {
+                    status: 'success',
+                    detail: `Merged PR #${pr.number} and cleaned up local artifacts`,
+                    cleanupArtifacts: true,
+                    closePane: true,
+                    mergedPr: true,
+                };
+            }
+            const settledPr = await this.waitForPrResolution(pane.repo, pr.number, mergeResult.status === 'queued' ? 40 : 10, pane.worktree_path) || currentPr;
+            currentPr = settledPr;
+            if (currentPr.state && currentPr.state !== 'OPEN') {
+                if (currentPr.merged_at) {
+                    return {
+                        status: 'success',
+                        detail: `Merged PR #${pr.number} and cleaned up local artifacts`,
+                        cleanupArtifacts: true,
+                        closePane: true,
+                        mergedPr: true,
+                    };
+                }
+                return {
+                    status: 'awaiting_review',
+                    detail: `PR #${pr.number} is no longer open, but GitHub does not report it as merged`,
+                    cleanupArtifacts: false,
+                    closePane: false,
+                    mergedPr: false,
+                };
+            }
+            if (currentPr.mergeable === 'CONFLICTING') {
+                continue;
+            }
+            if (mergeResult.status === 'queued') {
+                return {
+                    status: 'awaiting_review',
+                    detail: `Automatic merge stayed queued for PR #${pr.number} after waiting for GitHub to settle`,
+                    cleanupArtifacts: false,
+                    closePane: false,
+                    mergedPr: false,
+                };
+            }
+            if (mergeResult.status === 'failed' && currentPr.mergeable === 'UNKNOWN' && pass < maxAutomaticMergePasses) {
+                continue;
+            }
+            return {
+                status: 'awaiting_review',
+                detail: mergeResult.detail || `PR #${pr.number} is ready, but auto-merge could not be completed automatically`,
+                cleanupArtifacts: false,
+                closePane: false,
+                mergedPr: false,
+            };
+        }
+        return {
+            status: 'awaiting_review',
+            detail: `PR #${pr.number} still has merge conflicts after the automatic resolution attempts`,
+            cleanupArtifacts: false,
+            closePane: false,
+            mergedPr: false,
+        };
+    }
+    async resolveAutomergeConflicts(pane, agent, prNumber) {
+        if (!pane.repo || !pane.worktree_path || !pane.branch) {
+            return {
+                resolved: false,
+                detail: `PR #${prNumber} conflicts, but the local worktree metadata is missing`,
+            };
+        }
+        const mainBranch = await getMainBranch(pane.worktree_path);
+        this.removeSymphonyArtifacts(pane.worktree_path);
+        const existingConflicts = await getConflictedFiles(pane.worktree_path);
+        if (existingConflicts.length > 0) {
+            await runSafe('git', ['merge', '--abort'], { cwd: pane.worktree_path });
+        }
+        if (await hasUncommittedChanges(pane.worktree_path)) {
+            const finalized = await this.finalizePendingChanges(pane);
+            if (!finalized.committed) {
+                return {
+                    resolved: false,
+                    detail: finalized.detail,
+                };
+            }
+        }
+        const fetchResult = await fetchOrigin(pane.worktree_path);
+        if (!fetchResult.ok) {
+            return {
+                resolved: false,
+                detail: `PR #${prNumber} could not fetch the latest ${mainBranch} before conflict resolution: ${fetchResult.detail || 'git fetch failed'}`,
+            };
+        }
+        await runSafe('git', ['merge', '--abort'], { cwd: pane.worktree_path });
+        const mergeSource = await fetchBranchRef(pane.worktree_path, 'origin', mainBranch);
+        const mergeRef = mergeSource.ref || await resolveBranchRef(pane.worktree_path, mainBranch);
+        if (!mergeRef) {
+            return {
+                resolved: false,
+                detail: `PR #${prNumber} could not locate a merge source for ${mainBranch}${mergeSource.detail ? `: ${mergeSource.detail}` : ''}`,
+            };
+        }
+        const mergeResult = await runSafe('git', ['merge', mergeRef, '--no-edit'], {
+            cwd: pane.worktree_path,
+            timeout: GIT_AUTOMATION_TIMEOUT_MS,
+        });
+        let conflictedFiles = await getConflictedFiles(pane.worktree_path);
+        if (mergeResult.exitCode !== 0 && conflictedFiles.length === 0) {
+            return {
+                resolved: false,
+                detail: `PR #${prNumber} could not merge ${mainBranch} into ${pane.branch}: ${mergeResult.stderr || mergeResult.stdout || 'git merge failed'}`,
+            };
+        }
+        if (conflictedFiles.length > 0) {
+            for (let attempt = 1; attempt <= 2; attempt++) {
+                const statusSnapshot = await runSafe('git', ['status', '--short', '--branch'], {
+                    cwd: pane.worktree_path,
+                });
+                const prompt = this.buildConflictResolutionPrompt(pane, mainBranch, mergeRef, conflictedFiles, statusSnapshot.stdout, attempt);
+                const agentResult = await this.runAgentPromptInWorktree(pane.worktree_path, agent, prompt, pane);
+                this.recordAutomationProgress(pane, `Attempted automatic merge-conflict resolution for PR #${prNumber} (pass ${attempt})`);
+                conflictedFiles = await getConflictedFiles(pane.worktree_path);
+                if (conflictedFiles.length === 0) {
+                    const mergeHead = await runSafe('git', ['rev-parse', '--verify', 'MERGE_HEAD'], {
+                        cwd: pane.worktree_path,
+                    });
+                    if (mergeHead.exitCode === 0) {
+                        await runSafe('git', ['add', '-A'], { cwd: pane.worktree_path });
+                        const commitResult = await runSafe('git', ['commit', '--no-edit'], { cwd: pane.worktree_path });
+                        if (commitResult.exitCode !== 0) {
+                            return {
+                                resolved: false,
+                                detail: `Conflicts were edited for PR #${prNumber}, but the merge commit could not be completed automatically`,
+                            };
+                        }
+                    }
+                    break;
+                }
+                if (attempt === 2 && agentResult.exitCode !== 0) {
+                    return {
+                        resolved: false,
+                        detail: `Automatic conflict resolution for PR #${prNumber} failed: ${agentResult.stderr || agentResult.stdout || 'agent exited non-zero'}`,
+                    };
+                }
+            }
+            conflictedFiles = await getConflictedFiles(pane.worktree_path);
+            if (conflictedFiles.length > 0) {
+                return {
+                    resolved: false,
+                    detail: `PR #${prNumber} still has merge conflicts after the automatic resolution attempt`,
+                };
+            }
+            const markerValidation = await this.validateNoMergeMarkers(pane.worktree_path, `PR #${prNumber} still contains unresolved merge markers after the automatic resolution attempt`);
+            if (!markerValidation.ok) {
+                return {
+                    resolved: false,
+                    detail: markerValidation.detail,
+                };
+            }
+        }
+        this.recordAutomationProgress(pane, `Pushing conflict-resolved branch ${pane.branch}`);
+        const pushed = await pushBranch(pane.branch, pane.worktree_path);
+        if (!pushed.ok) {
+            return {
+                resolved: false,
+                detail: `Conflicts were resolved locally for PR #${prNumber}, but pushing ${pane.branch} failed${pushed.detail ? `: ${pushed.detail}` : ''}`,
+            };
+        }
+        return {
+            resolved: true,
+            detail: `Resolved merge conflicts for PR #${prNumber} and pushed the updated branch`,
+        };
+    }
+    async runAgentPromptInWorktree(worktreePath, agent, prompt, pane) {
+        const timeoutMs = agent.timeout_min * 60 * 1000;
+        const env = this.buildAgentEnvironment(pane, agent);
+        const options = {
+            cwd: worktreePath,
+            env,
+            timeout: timeoutMs,
+        };
+        if (agent.provider === 'codex') {
+            // Run conflict-resolution prompts through a fresh non-interactive Codex invocation.
+            // Reusing the live pane is brittle because prompt-completion detection can get stuck
+            // on the agent's terminal transcript even after the merge has been resolved.
+            return runSafe('sh', ['-lc', buildCodexExecCommand(prompt, agent.permission_mode)], options);
+        }
+        const automationPaneId = await this.createAutomationPane(pane, worktreePath, agent.name);
+        const command = buildAgentPromptCommand(agent, prompt);
+        if (automationPaneId) {
+            try {
+                await this.tmux.sendShellCommand(automationPaneId, `cd "${worktreePath}"`);
+                await sleep(200);
+                for (const [key, value] of Object.entries(env)) {
+                    await this.tmux.sendShellCommand(automationPaneId, `export ${key}="${value.replace(/"/g, '\\"')}"`);
+                }
+                await sleep(200);
+                await this.tmux.sendShellCommand(automationPaneId, command);
+                return this.waitForAgentPromptCompletion(automationPaneId, timeoutMs);
+            }
+            finally {
+                try {
+                    await this.tmux.killPane(automationPaneId);
+                }
+                catch {
+                    // Ignore cleanup failures for automation panes.
+                }
+            }
+        }
+        return runSafe('sh', ['-lc', command], options);
+    }
+    async runPromptInExistingPane(paneId, prompt, timeoutMs) {
+        const initialContent = await this.tmux.getPaneContent(paneId, 120);
+        await this.tmux.pasteText(paneId, prompt);
+        await sleep(200);
+        await this.tmux.sendKeys(paneId, 'Enter');
+        return this.waitForExistingAgentPromptTurn(paneId, initialContent, timeoutMs);
+    }
+    async createAutomationPane(pane, worktreePath, agentName) {
+        const sessionName = pane.run_id
+            ? this.runtime.getManifest(pane.run_id)?.tmux_session
+            : undefined;
+        if (!sessionName || !(await this.tmux.sessionExists(sessionName))) {
+            return undefined;
+        }
+        const windowName = `${pane.issue_number || 'merge'}-${agentName}-resolve`.slice(0, 24);
+        return this.tmux.createWindow(sessionName, windowName, worktreePath);
+    }
+    async waitForAgentPromptCompletion(paneId, timeoutMs) {
+        const startedAt = Date.now();
+        let lastContent = '';
+        let previousContent = '';
+        let stablePromptPolls = 0;
+        while (Date.now() - startedAt < timeoutMs) {
+            if (!(await this.tmux.paneExists(paneId))) {
+                return {
+                    exitCode: 1,
+                    stdout: lastContent,
+                    stderr: 'Temporary automation pane terminated unexpectedly',
+                };
+            }
+            const content = await this.tmux.getPaneContent(paneId, 120);
+            lastContent = content || lastContent;
+            const lines = content.split('\n').map(line => line.trim()).filter(Boolean);
+            const recentLines = lines.slice(-12);
+            const recentContent = recentLines.join('\n');
+            const lastLine = recentLines[recentLines.length - 1] || '';
+            if (NEEDS_ATTENTION_PATTERNS.some(pattern => pattern.test(recentContent))) {
+                return {
+                    exitCode: 1,
+                    stdout: content,
+                    stderr: 'Conflict-resolution agent requested approval or interactive input',
+                };
+            }
+            if (SHELL_PROMPT_PATTERNS.some(pattern => pattern.test(lastLine))) {
+                return { exitCode: 0, stdout: content, stderr: '' };
+            }
+            const promptVisible = recentLines.some(line => AGENT_PROMPT_PATTERNS.some(pattern => pattern.test(line)));
+            if (promptVisible) {
+                stablePromptPolls = content === previousContent ? stablePromptPolls + 1 : 1;
+                if (stablePromptPolls >= 2) {
+                    return { exitCode: 0, stdout: content, stderr: '' };
+                }
+            }
+            else {
+                stablePromptPolls = 0;
+            }
+            previousContent = content;
+            await sleep(2000);
+        }
+        return {
+            exitCode: 124,
+            stdout: lastContent,
+            stderr: 'Timed out waiting for the conflict-resolution agent to finish',
+        };
+    }
+    async waitForExistingAgentPromptTurn(paneId, initialContent, timeoutMs) {
+        const startedAt = Date.now();
+        let lastContent = initialContent;
+        let previousContent = '';
+        let stablePromptPolls = 0;
+        let sawContentChange = false;
+        while (Date.now() - startedAt < timeoutMs) {
+            if (!(await this.tmux.paneExists(paneId))) {
+                return {
+                    exitCode: 1,
+                    stdout: lastContent,
+                    stderr: 'Existing agent pane terminated unexpectedly',
+                };
+            }
+            const content = await this.tmux.getPaneContent(paneId, 120);
+            lastContent = content || lastContent;
+            const lines = content.split('\n').map(line => line.trim()).filter(Boolean);
+            const recentLines = lines.slice(-12);
+            const recentContent = recentLines.join('\n');
+            const lastLine = recentLines[recentLines.length - 1] || '';
+            const promptVisible = recentLines.some(line => AGENT_PROMPT_PATTERNS.some(pattern => pattern.test(line)));
+            const shellPromptVisible = SHELL_PROMPT_PATTERNS.some(pattern => pattern.test(lastLine));
+            if (NEEDS_ATTENTION_PATTERNS.some(pattern => pattern.test(recentContent))) {
+                return {
+                    exitCode: 1,
+                    stdout: content,
+                    stderr: 'Conflict-resolution agent requested approval or interactive input',
+                };
+            }
+            if (content !== initialContent) {
+                sawContentChange = true;
+            }
+            const activelyWorking = ACTIVE_PROMPT_TAIL_PATTERNS.some(pattern => pattern.test(recentContent));
+            if (sawContentChange && (promptVisible || shellPromptVisible) && !activelyWorking) {
+                stablePromptPolls = content === previousContent ? stablePromptPolls + 1 : 1;
+                if (stablePromptPolls >= 2) {
+                    return { exitCode: 0, stdout: content, stderr: '' };
+                }
+            }
+            else {
+                stablePromptPolls = 0;
+            }
+            previousContent = content;
+            await sleep(2000);
+        }
+        return {
+            exitCode: 124,
+            stdout: lastContent,
+            stderr: 'Timed out waiting for the conflict-resolution agent to finish in the existing pane',
+        };
+    }
+    buildConflictResolutionPrompt(pane, mainBranch, mergeRef, conflictedFiles, statusSnapshot, attempt) {
+        return [
+            `You are resolving merge conflicts for GitHub issue #${pane.issue_number} in ${pane.repo}.`,
+            `Issue title: ${pane.issue_title || '(unknown title)'}`,
+            `The branch ${pane.branch} is being prepared for automatic merge and conflicts with ${mergeRef}.`,
+            '',
+            `A merge of ${mergeRef} (${mainBranch}) into the current branch has already been started in this worktree.`,
+            `This is automatic conflict-resolution pass ${attempt}. Do not work on unrelated feature changes.`,
+            'Read `.symphony/context.md` before editing so you preserve the current issue intent while resolving the conflict.',
+            'Run `git status` to inspect the merge state, resolve every conflict marker while preserving the current issue outcome, run targeted verification if needed, and complete the merge commit.',
+            'If the current issue requests exact replacement text, use that exact text instead of blending or paraphrasing conflicting wording.',
+            'Do not abandon the merge, reset the branch, or leave the repository mid-merge. Finish with a committed merge result on the current branch.',
+            'When the merge is complete, exit immediately. Do not produce a long summary, walkthrough, or code explanation.',
+            '',
+            'Current git status:',
+            statusSnapshot || '(status unavailable)',
+            '',
+            'Conflicted files:',
+            ...conflictedFiles.map(file => `- ${file}`),
+        ].join('\n');
+    }
+    hasAgentPrompt(content) {
+        const lines = content.split('\n').map(line => line.trim()).filter(Boolean);
+        return lines.slice(-12).some(line => AGENT_PROMPT_PATTERNS.some(pattern => pattern.test(line)));
+    }
+    buildAgentEnvironment(pane, agent) {
+        return {
+            ...agent.env,
+            SYMPHONY_REPO: pane.repo || '',
+            SYMPHONY_ISSUE_NUMBER: String(pane.issue_number || ''),
+            SYMPHONY_ISSUE_URL: pane.issue_url || '',
+            SYMPHONY_WORKTREE: pane.worktree_path || '',
+            SYMPHONY_BRANCH: pane.branch || '',
+            SYMPHONY_RUN_ID: pane.run_id || '',
+            SYMPHONY_AGENT: agent.name,
+            SYMPHONY_AGENT_PROVIDER: agent.provider,
+        };
+    }
+    async finalizePendingChanges(pane) {
+        if (!pane.worktree_path) {
+            return {
+                committed: false,
+                detail: 'Agent left uncommitted changes, but the worktree path is missing',
+            };
+        }
+        this.removeSymphonyArtifacts(pane.worktree_path);
+        await runSafe('git', ['add', '-A'], { cwd: pane.worktree_path });
+        const commitResult = await runSafe('git', [
+            'commit',
+            '-m',
+            `chore: finalize Symphony changes for issue #${pane.issue_number ?? ''}`.trim(),
+        ], {
+            cwd: pane.worktree_path,
+        });
+        if (commitResult.exitCode !== 0) {
+            return {
+                committed: false,
+                detail: `Agent left uncommitted changes and Symphony could not commit them automatically: ${commitResult.stderr || commitResult.stdout || 'git commit failed'}`,
+            };
+        }
+        this.recordAutomationProgress(pane, 'Committed leftover worktree changes before automatic merge handling');
+        return {
+            committed: true,
+            detail: 'Committed leftover worktree changes before automatic merge handling',
+        };
+    }
+    getResolvedAgentForPane(pane) {
+        if (!pane.agent_name)
+            return null;
+        const agentConfig = this.settings.agents[pane.agent_name];
+        if (!agentConfig)
+            return null;
+        return {
+            name: pane.agent_name,
+            provider: pane.agent_provider || agentConfig.provider,
+            model: agentConfig.model,
+            thinking: agentConfig.thinking,
+            create_pr: agentConfig.create_pr,
+            push: agentConfig.push,
+            timeout_min: agentConfig.timeout_min,
+            env: agentConfig.env || {},
+            command: agentConfig.command,
+            permission_mode: agentConfig.permission_mode || '',
+        };
+    }
+    async waitForPrState(repo, prNumber, attempts, cwd) {
+        let latest = null;
+        for (let idx = 0; idx < attempts; idx++) {
+            latest = await this.github.getPr(repo, prNumber, cwd);
+            if (latest && latest.mergeable && latest.mergeable !== 'UNKNOWN') {
+                return latest;
+            }
+            await sleep(1500);
+        }
+        return latest;
+    }
+    async waitForPrResolution(repo, prNumber, attempts, cwd) {
+        let latest = null;
+        for (let idx = 0; idx < attempts; idx++) {
+            latest = await this.github.getPr(repo, prNumber, cwd);
+            if (latest?.state && latest.state !== 'OPEN') {
+                return latest;
+            }
+            if (latest?.mergeable === 'CONFLICTING') {
+                return latest;
+            }
+            await sleep(1500);
+        }
+        return latest;
+    }
+    async validateNoMergeMarkers(repoPath, prefix) {
+        const markers = await findUnresolvedMergeMarkers(repoPath);
+        if (markers.length === 0) {
+            return { ok: true, detail: '' };
+        }
+        return {
+            ok: false,
+            detail: `${prefix}: ${markers.slice(0, 3).join('; ')}${markers.length > 3 ? ' ...' : ''}`,
+        };
+    }
+    removeSymphonyArtifacts(worktreePath) {
+        const symphonyDir = `${worktreePath}/.symphony`;
+        if (existsSync(symphonyDir)) {
+            rmSync(symphonyDir, { recursive: true, force: true });
+        }
+    }
+    async syncLocalCheckouts(repo) {
+        const syncSetting = (process.env.SYMPHONY_SYNC_LOCAL_CHECKOUTS || '').trim().toLowerCase();
+        if (['0', 'false', 'off', 'no'].includes(syncSetting)) {
+            return { synced: 0, detail: 'local checkout sync disabled via SYMPHONY_SYNC_LOCAL_CHECKOUTS' };
+        }
+        const candidates = await this.findLocalCheckoutCandidates(repo);
+        if (candidates.length === 0) {
+            return { synced: 0, detail: 'no matching local checkout found to sync' };
+        }
+        let synced = 0;
+        const notes = [];
+        for (const candidate of candidates) {
+            const result = await this.syncCheckout(candidate);
+            if (result.synced) {
+                synced += 1;
+            }
+            else if (result.detail) {
+                notes.push(`${basename(candidate)}: ${result.detail}`);
+            }
+        }
+        if (synced > 0) {
+            return {
+                synced,
+                detail: notes.length > 0
+                    ? `synced ${synced} local checkout(s); ${notes.join(' | ')}`
+                    : `synced ${synced} local checkout(s)`,
+            };
+        }
+        return {
+            synced: 0,
+            detail: notes.join(' | ') || 'found local checkout(s), but could not sync them',
+        };
+    }
+    async findLocalCheckoutCandidates(repo) {
+        const repoName = repo.split('/').at(-1) || repo;
+        const cwd = process.cwd();
+        const home = process.env.HOME || '';
+        const seedPaths = [
+            cwd,
+            dirname(cwd),
+            dirname(dirname(cwd)),
+            join(dirname(cwd), repoName),
+            join(dirname(dirname(cwd)), repoName),
+            ...(home ? [join(home, 'Symphony_Repositories'), join(home, 'code')] : []),
+        ];
+        const candidates = new Set();
+        for (const seed of seedPaths) {
+            const absoluteSeed = resolve(seed);
+            if (!existsSync(absoluteSeed))
+                continue;
+            if (basename(absoluteSeed) === repoName) {
+                candidates.add(absoluteSeed);
+            }
+            try {
+                for (const entry of readdirSync(absoluteSeed, { withFileTypes: true })) {
+                    if (entry.isDirectory() && entry.name === repoName) {
+                        candidates.add(join(absoluteSeed, entry.name));
+                    }
+                }
+            }
+            catch {
+                // Ignore unreadable directories while discovering sibling repos.
+            }
+        }
+        const matches = [];
+        for (const candidate of candidates) {
+            try {
+                const gitRoot = await getGitRoot(candidate);
+                if (resolve(gitRoot) !== resolve(candidate))
+                    continue;
+                if (await isGitWorktree(candidate))
+                    continue;
+                const remote = await runSafe('git', ['remote', 'get-url', 'origin'], { cwd: candidate });
+                if (remote.exitCode !== 0)
+                    continue;
+                const normalized = remote.stdout.trim();
+                if (normalized === `https://github.com/${repo}.git`
+                    || normalized === `git@github.com:${repo}.git`
+                    || normalized === `https://github.com/${repo}`
+                    || normalized === `git@github.com:${repo}`) {
+                    matches.push(candidate);
+                }
+            }
+            catch {
+                // Ignore non-git directories.
+            }
+        }
+        return matches;
+    }
+    async syncCheckout(repoPath) {
+        await runSafe('git', ['fetch', '--prune', 'origin'], { cwd: repoPath });
+        const mainBranch = await getMainBranch(repoPath);
+        const currentBranch = await runSafe('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: repoPath });
+        if (currentBranch.exitCode !== 0) {
+            return { synced: false, detail: 'could not detect current branch' };
+        }
+        if (currentBranch.stdout.trim() !== mainBranch) {
+            return { synced: false, detail: `skipped pull because checkout is on ${currentBranch.stdout.trim()}` };
+        }
+        if (await hasUncommittedChanges(repoPath)) {
+            return { synced: false, detail: 'skipped pull because checkout has local changes' };
+        }
+        const pullResult = await runSafe('git', ['pull', '--ff-only', 'origin', mainBranch], { cwd: repoPath });
+        if (pullResult.exitCode !== 0) {
+            return { synced: false, detail: `pull failed: ${pullResult.stderr || pullResult.stdout || 'unknown error'}` };
+        }
+        return { synced: true };
+    }
+    async cleanupRunArtifacts(pane) {
+        if (!pane.repo || !pane.worktree_path) {
+            return { cleaned: true };
+        }
+        try {
+            const clonePath = await ensureClone(pane.repo, this.settings.clone_root);
+            await removeWorktree(pane.worktree_path, clonePath, true, pane.branch);
+            pane.worktree_path = undefined;
+            return { cleaned: true };
+        }
+        catch (err) {
+            return {
+                cleaned: false,
+                reason: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+}
+function describeWorktreeState(commits, hasUncommitted) {
+    const parts = [`${commits} commit(s)`];
+    if (hasUncommitted) {
+        parts.push('uncommitted changes');
+    }
+    return `Ready for review: ${parts.join(', ')}`;
+}
+function buildCodexExecCommand(prompt, permissionMode) {
+    const escapedPrompt = prompt
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/`/g, '\\`')
+        .replace(/\$/g, '\\$');
+    const flags = permissionMode === 'bypassPermissions'
+        ? ' --dangerously-bypass-approvals-and-sandbox'
+        : permissionMode === 'acceptEdits'
+            ? ' --full-auto'
+            : '';
+    return `printf '%s\\n' "${escapedPrompt}" | codex exec${flags} -`;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=runner.js.map