symphony-github 0.1.0

package/dist/services/daemon.js

@@ -0,0 +1,836 @@
+import { EventEmitter } from 'node:events';
+import { GitHubClient } from './github.js';
+import { StateStore } from './state.js';
+import { RuntimeStore } from './runtime.js';
+import { TmuxService } from './tmux.js';
+import { GitHubProgressReporter } from './githubProgressReporter.js';
+import { AgentRunner } from '../agents/runner.js';
+import { resolveAgent } from '../agents/launcher.js';
+import { evaluateTrigger } from '../triggers/index.js';
+import { getTriggerForRepo, getModeForRepo } from '../config/index.js';
+import { allowsAutomaticMerge } from '../runModes.js';
+import { DirectorService } from '../swarm/director.js';
+import { describeDuplicateMatch, findDuplicateMatch } from '../utils/duplicateDetection.js';
+/**
+ * GitHub issue polling daemon.
+ * Ported from symphony Python's daemon.py.
+ */
+export class Daemon extends EventEmitter {
+    settings;
+    github;
+    state;
+    runtime;
+    tmux;
+    runner;
+    reporter;
+    director = null;
+    sessionName;
+    running = false;
+    activeRuns = new Map();
+    pollTimer = null;
+    suppressIntermediateUpdatesUntil = new Map();
+    startupCandidates = new Map();
+    startupReposScanned = new Set();
+    launchQueue = new Map();
+    constructor(settings, sessionName) {
+        super();
+        this.settings = settings;
+        this.sessionName = sessionName;
+        this.github = new GitHubClient();
+        this.state = new StateStore(settings.state_file);
+        this.runtime = new RuntimeStore(settings.runtime_root);
+        this.tmux = TmuxService.getInstance();
+        this.reporter = new GitHubProgressReporter(settings, this.github, this.runtime, this.tmux);
+        this.runner = new AgentRunner(settings, this.runtime, pane => this.handleRunnerProgress(pane));
+        if (settings.swarm?.enabled) {
+            this.director = new DirectorService(settings, this.runtime);
+        }
+    }
+    getActiveRuns() {
+        return [
+            ...Array.from(this.launchQueue.values()).map(candidate => this.candidateToPendingPane(candidate)),
+            ...Array.from(this.activeRuns.values()),
+        ];
+    }
+    getRecentRuns(limit = 20) {
+        return this.runtime.listRuns(limit);
+    }
+    isRunning() {
+        return this.running;
+    }
+    async finalizeRun(runId) {
+        const pane = this.activeRuns.get(runId);
+        if (!pane)
+            return false;
+        await this.runner.requestAgentExit(pane);
+        this.setPaneStatus(pane, 'running', 'Finalizing agent session');
+        this.suppressIntermediateUpdatesUntil.set(runId, Date.now() + 5000);
+        return true;
+    }
+    async resumeRun(runId) {
+        const pane = this.activeRuns.get(runId);
+        if (!pane)
+            return false;
+        this.setPaneStatus(pane, 'running', 'Review resumed in pane');
+        this.suppressIntermediateUpdatesUntil.set(runId, Date.now() + 10000);
+        return true;
+    }
+    async pauseRun(runId) {
+        const pane = this.activeRuns.get(runId);
+        if (!pane?.tmux_pane_id)
+            return false;
+        await this.tmux.sendKeys(pane.tmux_pane_id, 'C-c');
+        this.setPaneStatus(pane, 'needs_attention', 'Agent interrupted by user');
+        this.suppressIntermediateUpdatesUntil.set(runId, Date.now() + 10000);
+        return true;
+    }
+    async stopAndLabelRun(runId) {
+        const pane = this.activeRuns.get(runId);
+        if (!pane?.repo || !pane.issue_number)
+            return false;
+        const trigger = getTriggerForRepo(this.settings, pane.repo);
+        if (trigger.claim_label) {
+            try {
+                await this.github.removeLabel(pane.repo, pane.issue_number, trigger.claim_label);
+            }
+            catch { /* ignore */ }
+        }
+        if (trigger.ignore_labels?.length > 0) {
+            try {
+                await this.github.addLabels(pane.repo, pane.issue_number, [trigger.ignore_labels[0]]);
+            }
+            catch { /* ignore */ }
+        }
+        this.state.markHandled(pane.repo, pane.issue_number, runId);
+        if (pane.tmux_pane_id) {
+            try {
+                await this.tmux.killPane(pane.tmux_pane_id);
+            }
+            catch { /* ignore */ }
+        }
+        this.state.removeActiveRun(pane.repo, runId);
+        this.activeRuns.delete(runId);
+        this.state.save();
+        this.emit('run_completed', { ...pane, status: 'failed', status_detail: 'Stopped and labeled by user' });
+        return true;
+    }
+    async prepareStartupRecovery() {
+        this.startupCandidates.clear();
+        this.startupReposScanned = new Set(this.settings.repos.map(repoConfig => repoConfig.repo));
+        const recovered = await this.restoreTrackedRuns();
+        const recoveredIssueKeys = new Set(recovered
+            .filter(pane => pane.repo && pane.issue_number)
+            .map(pane => `${pane.repo}#${pane.issue_number}`));
+        const pending = [];
+        for (const repoConfig of this.settings.repos) {
+            const repo = repoConfig.repo;
+            const trigger = getTriggerForRepo(this.settings, repo);
+            const mode = getModeForRepo(this.settings, repo);
+            if (!trigger.include_existing_open_issues) {
+                continue;
+            }
+            let issues;
+            try {
+                issues = await this.listStartupCandidateIssues(repo);
+            }
+            catch (err) {
+                this.emit('error', new Error(`Failed to inspect open issues for ${repo}: ${err}`));
+                continue;
+            }
+            for (const issue of issues) {
+                const issueKey = `${repo}#${issue.number}`;
+                if (recoveredIssueKeys.has(issueKey))
+                    continue;
+                if (trigger.done_label && hasLabel(issue, trigger.done_label))
+                    continue;
+                let comments;
+                try {
+                    comments = await this.github.listIssueComments(repo, issue.number);
+                }
+                catch {
+                    comments = [];
+                }
+                const decision = evaluateTrigger(issue, comments, trigger, {
+                    isHandled: this.state.isHandled(repo, issue.number),
+                    hasActiveRun: false,
+                    hasOpenPr: false,
+                    isClaimed: false,
+                    processedCommentIds: new Set(this.state.getProcessedCommentIds(repo)),
+                });
+                const isClaimed = Boolean(trigger.claim_label && hasLabel(issue, trigger.claim_label));
+                if (!decision.should_run && !isClaimed) {
+                    continue;
+                }
+                const agentName = this.resolveAgentName(repo, issue, comments);
+                const reason = isClaimed && !decision.should_run
+                    ? `Claimed issue found without a live tmux pane (${trigger.claim_label})`
+                    : decision.reason;
+                const candidate = {
+                    id: issueKey,
+                    repo,
+                    issue,
+                    comments,
+                    mode,
+                    reason,
+                    matched_by: decision.matched_by,
+                    is_claimed: isClaimed,
+                    agent_name: agentName,
+                };
+                this.startupCandidates.set(candidate.id, candidate);
+                pending.push({
+                    id: candidate.id,
+                    repo,
+                    issue_number: issue.number,
+                    issue_title: issue.title,
+                    issue_url: issue.html_url,
+                    reason: candidate.reason,
+                    matched_by: candidate.matched_by,
+                    is_claimed: candidate.is_claimed,
+                    agent_name: candidate.agent_name,
+                });
+            }
+        }
+        pending.sort((left, right) => {
+            if (left.repo !== right.repo)
+                return left.repo.localeCompare(right.repo);
+            return left.issue_number - right.issue_number;
+        });
+        return { recovered, pending };
+    }
+    async listStartupCandidateIssues(repo) {
+        return this.github.listOpenIssues(repo);
+    }
+    async launchStartupIssues(selectedIds) {
+        for (const id of selectedIds) {
+            const candidate = this.startupCandidates.get(id);
+            if (!candidate)
+                continue;
+            this.enqueueCandidate(candidate);
+        }
+        await this.drainLaunchQueue();
+    }
+    completeStartupRecovery() {
+        const now = new Date().toISOString();
+        for (const repo of this.startupReposScanned) {
+            this.state.setIssueCursor(repo, now);
+            this.state.setCommentCursor(repo, now);
+        }
+        this.startupCandidates.clear();
+        this.startupReposScanned.clear();
+        this.state.save();
+    }
+    /**
+     * Start the polling loop. Launches director if swarm mode is enabled.
+     */
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.emit('status', 'Daemon started');
+        // Launch director pane(s) if swarm mode is enabled
+        if (this.director) {
+            try {
+                const directorPanes = await this.director.start(this.sessionName);
+                for (const pane of directorPanes) {
+                    this.emit('run_started', pane);
+                }
+                this.emit('status', `Swarm director launched (${directorPanes.length} pane(s))`);
+            }
+            catch (err) {
+                this.emit('error', new Error(`Failed to launch director: ${err}`));
+            }
+        }
+        this.poll();
+    }
+    /**
+     * Stop the polling loop.
+     */
+    stop() {
+        this.running = false;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+        this.state.save();
+        this.emit('status', 'Daemon stopped');
+    }
+    /**
+     * Run a single poll cycle, then schedule the next one.
+     */
+    async poll() {
+        if (!this.running)
+            return;
+        try {
+            this.emit('poll_start');
+            // Check active runs for completion
+            await this.reconcileActiveRuns();
+            await this.drainLaunchQueue();
+            // Swarm mode: process proposals and dependencies
+            if (this.director) {
+                try {
+                    await this.director.autoApproveProposals();
+                    await this.director.processApprovedProposals();
+                    await this.director.reconcileDependencies();
+                    await this.director.updateDirectorContext(this.getActiveRuns());
+                    if (this.director.shouldRunEvolution()) {
+                        const started = await this.director.runEvolutionCycle();
+                        if (started > 0) {
+                            this.emit('status', `Swarm director started ${started} evolution cycle(s)`);
+                        }
+                    }
+                }
+                catch (err) {
+                    this.emit('error', new Error(`Swarm director error: ${err}`));
+                }
+            }
+            // Discover and process new candidates
+            let totalDiscovered = 0;
+            let totalLaunched = 0;
+            for (const repoConfig of this.settings.repos) {
+                const repo = repoConfig.repo;
+                try {
+                    const { discovered, launched } = await this.pollRepo(repo);
+                    totalDiscovered += discovered;
+                    totalLaunched += launched;
+                }
+                catch (err) {
+                    this.emit('error', new Error(`Error polling ${repo}: ${err}`));
+                }
+            }
+            this.state.save();
+            this.emit('poll_end', { discovered: totalDiscovered, launched: totalLaunched });
+        }
+        catch (err) {
+            this.emit('error', err instanceof Error ? err : new Error(String(err)));
+        }
+        // Schedule next poll
+        if (this.running) {
+            this.pollTimer = setTimeout(() => this.poll(), this.settings.poll_interval_sec * 1000);
+        }
+    }
+    /**
+     * Poll a single repository for new issues.
+     */
+    async pollRepo(repo) {
+        const trigger = getTriggerForRepo(this.settings, repo);
+        const mode = getModeForRepo(this.settings, repo);
+        let discovered = 0;
+        let launched = 0;
+        let duplicateReferencesPromise = null;
+        // Get updated issues
+        const issueCursor = this.state.getIssueCursor(repo);
+        if (!issueCursor && !trigger.include_existing_open_issues) {
+            const now = new Date().toISOString();
+            this.state.setIssueCursor(repo, now);
+            this.state.setCommentCursor(repo, now);
+            return { discovered: 0, launched: 0 };
+        }
+        const issues = await this.github.listUpdatedIssues(repo, issueCursor);
+        // Update cursor to the latest issue's updated_at
+        if (issues.length > 0) {
+            const latestUpdate = issues.reduce((latest, issue) => issue.updated_at > latest ? issue.updated_at : latest, issues[0].updated_at);
+            this.state.setIssueCursor(repo, latestUpdate);
+        }
+        // Get updated comments
+        const commentCursor = this.state.getCommentCursor(repo);
+        const recentComments = await this.github.listUpdatedComments(repo, commentCursor);
+        if (recentComments.length > 0) {
+            const latestCommentUpdate = recentComments.reduce((latest, c) => c.updated_at > latest ? c.updated_at : latest, recentComments[0].updated_at);
+            this.state.setCommentCursor(repo, latestCommentUpdate);
+        }
+        // Also fetch issues mentioned in new comments
+        const commentIssueNumbers = new Set();
+        for (const comment of recentComments) {
+            if (comment.issue_url) {
+                const match = comment.issue_url.match(/\/issues\/(\d+)$/);
+                if (match) {
+                    const issueNumber = parseInt(match[1], 10);
+                    commentIssueNumbers.add(issueNumber);
+                    if (!isSymphonyManagedComment(comment.body)) {
+                        this.state.clearSuppressedIssue(repo, issueNumber);
+                    }
+                }
+            }
+        }
+        const deferredIssueNumbers = new Set(this.state.getDeferredIssueNumbers(repo));
+        for (const deferredIssueNumber of deferredIssueNumbers) {
+            commentIssueNumbers.add(deferredIssueNumber);
+        }
+        // Merge issues from comments that aren't already in our list
+        const existingNumbers = new Set(issues.map(i => i.number));
+        for (const num of commentIssueNumbers) {
+            if (!existingNumbers.has(num)) {
+                try {
+                    const issue = await this.github.getIssue(repo, num);
+                    if (issue.state === 'open' && !issue.pull_request) {
+                        issues.push(issue);
+                    }
+                    else {
+                        this.state.clearDeferredIssue(repo, num);
+                    }
+                }
+                catch {
+                    this.state.clearDeferredIssue(repo, num);
+                    // Ignore - issue might be closed or deleted
+                }
+            }
+        }
+        discovered = issues.length;
+        const suppressedIssueNumbers = new Set(this.state.getSuppressedIssueNumbers(repo));
+        // Evaluate each issue
+        for (const issue of issues) {
+            // Get issue comments for trigger evaluation
+            let issueComments;
+            try {
+                issueComments = await this.github.listIssueComments(repo, issue.number);
+            }
+            catch {
+                issueComments = [];
+            }
+            // Build context for trigger evaluation
+            const processedIds = new Set(this.state.getProcessedCommentIds(repo));
+            const context = {
+                isHandled: this.state.isHandled(repo, issue.number),
+                hasActiveRun: this.state.hasActiveRun(repo, issue.number),
+                hasOpenPr: false, // Will check below
+                isClaimed: issue.labels.some(l => l.name === trigger.claim_label),
+                processedCommentIds: processedIds,
+            };
+            // Check for open PR
+            if (trigger.skip_if_open_pr) {
+                // Simple heuristic: check if any issue label suggests a PR exists
+                // For a more thorough check, we'd search PRs, but that's expensive
+                context.hasOpenPr = false; // TODO: implement PR check if needed
+            }
+            const decision = evaluateTrigger(issue, issueComments, trigger, context);
+            if (suppressedIssueNumbers.has(issue.number)) {
+                continue;
+            }
+            if (!decision.should_run) {
+                this.state.clearDeferredIssue(repo, issue.number);
+                continue;
+            }
+            const duplicateReferences = duplicateReferencesPromise ??= this.buildDuplicateReferences(repo, trigger.claim_label);
+            const duplicate = findDuplicateMatch(issue.title, (await duplicateReferences).filter(ref => ref.issueNumber !== issue.number));
+            if (duplicate) {
+                this.state.deferIssue(repo, issue.number);
+                this.emit('status', `Skipping ${repo}#${issue.number}: ${describeDuplicateMatch(duplicate)}`);
+                continue;
+            }
+            this.state.clearDeferredIssue(repo, issue.number);
+            const candidate = {
+                id: `${repo}#${issue.number}`,
+                repo,
+                issue,
+                comments: issueComments,
+                mode,
+                reason: decision.reason,
+                matched_by: decision.matched_by,
+                is_claimed: context.isClaimed,
+                agent_name: this.resolveAgentName(repo, issue, issueComments),
+            };
+            if (this.activeRuns.size >= this.settings.max_concurrent_runs) {
+                this.enqueueCandidate(candidate);
+                this.emit('status', `Queued ${repo}#${issue.number}: ${decision.reason}`);
+            }
+            else {
+                this.emit('status', `Triggering run for ${repo}#${issue.number}: ${decision.reason}`);
+                try {
+                    await this.startIssueRun(repo, issue, issueComments, mode, trigger.claim_label);
+                    if (duplicateReferencesPromise) {
+                        (await duplicateReferencesPromise).push({
+                            kind: 'active_run',
+                            title: issue.title,
+                            issueNumber: issue.number,
+                        });
+                    }
+                    this.state.clearDeferredIssue(repo, issue.number);
+                    launched++;
+                }
+                catch (err) {
+                    this.state.deferIssue(repo, issue.number);
+                    this.emit('error', new Error(`Failed to start run for ${repo}#${issue.number}: ${err}`));
+                }
+            }
+        }
+        return { discovered, launched };
+    }
+    async restoreTrackedRuns() {
+        const recovered = [];
+        for (const { repo, record } of this.state.getAllActiveRuns()) {
+            const manifest = this.runtime.getManifest(record.run_id);
+            if (!manifest) {
+                this.state.removeActiveRun(repo, record.run_id);
+                continue;
+            }
+            const paneId = record.tmux_pane_id || manifest.tmux_pane_id || this.runtime.getRecordedPaneId(record.run_id);
+            const paneExists = Boolean(paneId && await this.tmux.paneExists(paneId));
+            if (paneExists && (record.tmux_pane_id !== paneId
+                || record.tmux_session !== manifest.tmux_session)) {
+                this.state.addActiveRun(repo, {
+                    ...record,
+                    tmux_session: manifest.tmux_session || record.tmux_session || this.sessionName,
+                    tmux_pane_id: paneId,
+                });
+            }
+            const pane = this.manifestToPane(manifest, paneExists ? paneId : undefined);
+            try {
+                const check = await this.runner.checkRunStatus(pane);
+                if (check.result) {
+                    await this.completeRun(record.run_id, pane, check.result, check.detail);
+                }
+                else {
+                    this.activeRuns.set(record.run_id, pane);
+                    pane.status = check.status;
+                    pane.status_detail = check.detail;
+                }
+            }
+            catch (err) {
+                this.emit('error', new Error(`Failed to recover ${repo}#${record.issue_number}: ${err}`));
+            }
+            recovered.push({ ...pane });
+        }
+        return recovered;
+    }
+    manifestToPane(manifest, paneId) {
+        return {
+            id: manifest.run_id,
+            slug: manifest.branch,
+            type: 'issue',
+            repo: manifest.repo,
+            issue_number: manifest.issue_number,
+            issue_title: manifest.issue_title,
+            issue_url: manifest.issue_url,
+            agent_name: manifest.agent_name,
+            agent_provider: manifest.agent_provider,
+            run_id: manifest.run_id,
+            mode: manifest.mode,
+            status: manifest.status,
+            status_detail: manifest.status_detail,
+            tmux_pane_id: paneId,
+            worktree_path: manifest.worktree_path,
+            branch: manifest.branch,
+            base_sha: manifest.base_sha,
+            started_at: manifest.started_at,
+        };
+    }
+    resolveAgentName(repo, issue, comments) {
+        try {
+            return resolveAgent(issue, comments, repo, this.settings).name;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    candidateToPendingPane(candidate) {
+        return {
+            id: `queued:${candidate.id}`,
+            slug: candidate.id,
+            type: 'issue',
+            repo: candidate.repo,
+            issue_number: candidate.issue.number,
+            issue_title: candidate.issue.title,
+            issue_url: candidate.issue.html_url,
+            agent_name: candidate.agent_name,
+            run_id: undefined,
+            mode: candidate.mode,
+            status: 'pending',
+            status_detail: 'Queued: waiting for an open run slot',
+            started_at: undefined,
+        };
+    }
+    enqueueCandidate(candidate) {
+        const issueKey = `${candidate.repo}#${candidate.issue.number}`;
+        if (this.launchQueue.has(issueKey) || this.state.hasActiveRun(candidate.repo, candidate.issue.number)) {
+            return;
+        }
+        if (Array.from(this.activeRuns.values()).some(pane => pane.repo === candidate.repo && pane.issue_number === candidate.issue.number)) {
+            return;
+        }
+        this.launchQueue.set(issueKey, candidate);
+        this.emit('run_started', this.candidateToPendingPane(candidate));
+    }
+    async drainLaunchQueue() {
+        while (this.launchQueue.size > 0 && this.activeRuns.size < this.settings.max_concurrent_runs) {
+            const nextEntry = this.launchQueue.entries().next().value;
+            if (!nextEntry)
+                break;
+            const [issueKey, candidate] = nextEntry;
+            this.launchQueue.delete(issueKey);
+            try {
+                const trigger = getTriggerForRepo(this.settings, candidate.repo);
+                await this.startIssueRun(candidate.repo, candidate.issue, candidate.comments, candidate.mode, trigger.claim_label);
+            }
+            catch (err) {
+                this.emit('error', new Error(`Failed to start recovery run for ${candidate.id}: ${err}`));
+            }
+        }
+    }
+    async startIssueRun(repo, issue, issueComments, mode, claimLabel) {
+        const alreadyClaimed = Boolean(claimLabel && hasLabel(issue, claimLabel));
+        let claimApplied = false;
+        if (claimLabel && !alreadyClaimed) {
+            try {
+                await this.github.addLabels(repo, issue.number, [claimLabel]);
+                claimApplied = true;
+            }
+            catch {
+                // Ignore label failures; the run can still proceed.
+            }
+        }
+        try {
+            const { pane, runId } = await this.runner.startRun(repo, issue, issueComments, this.sessionName, mode);
+            this.activeRuns.set(runId, pane);
+            this.state.addActiveRun(repo, {
+                run_id: runId,
+                repo,
+                issue_number: issue.number,
+                started_at: new Date().toISOString(),
+                tmux_session: this.sessionName,
+                tmux_pane_id: pane.tmux_pane_id,
+            });
+            for (const comment of issueComments) {
+                this.state.markCommentProcessed(repo, comment.id);
+            }
+            this.emit('run_started', pane);
+            await this.reporter.publishRunStarted({ ...pane });
+        }
+        catch (err) {
+            if (claimApplied && claimLabel) {
+                try {
+                    await this.github.removeLabel(repo, issue.number, claimLabel);
+                }
+                catch {
+                    // Ignore rollback failures.
+                }
+            }
+            throw err;
+        }
+    }
+    async buildDuplicateReferences(repo, claimLabel) {
+        const references = [];
+        for (const pane of this.activeRuns.values()) {
+            if (pane.repo !== repo || !pane.issue_title)
+                continue;
+            references.push({
+                kind: 'active_run',
+                title: pane.issue_title,
+                issueNumber: pane.issue_number,
+            });
+        }
+        for (const candidate of this.launchQueue.values()) {
+            if (candidate.repo !== repo)
+                continue;
+            references.push({
+                kind: 'active_run',
+                title: candidate.issue.title,
+                issueNumber: candidate.issue.number,
+            });
+        }
+        if (claimLabel) {
+            try {
+                const claimedIssues = await this.github.listOpenIssues(repo, [claimLabel]);
+                for (const issue of claimedIssues) {
+                    references.push({
+                        kind: 'claimed_issue',
+                        title: issue.title,
+                        issueNumber: issue.number,
+                    });
+                }
+            }
+            catch {
+                // Ignore duplicate-check issue lookup failures
+            }
+        }
+        try {
+            const openPullRequests = await this.github.listOpenPullRequests(repo);
+            for (const pr of openPullRequests) {
+                references.push({
+                    kind: 'open_pr',
+                    title: pr.title,
+                    prNumber: pr.number,
+                });
+            }
+        }
+        catch {
+            // Ignore duplicate-check PR lookup failures
+        }
+        return references;
+    }
+    /**
+     * Check active runs for completion.
+     */
+    async reconcileActiveRuns() {
+        const now = Date.now();
+        for (const [runId, pane] of this.activeRuns) {
+            // Give recently started runs time for the agent to initialize
+            if (pane.started_at) {
+                const elapsed = now - new Date(pane.started_at).getTime();
+                if (elapsed < 10000)
+                    continue;
+            }
+            try {
+                const check = await this.runner.checkRunStatus(pane);
+                if (check.result) {
+                    await this.completeRun(runId, pane, check.result, check.detail);
+                    continue;
+                }
+                const suppressUntil = this.suppressIntermediateUpdatesUntil.get(runId) || 0;
+                const suppressIntermediateUpdate = suppressUntil > Date.now()
+                    && (check.status === 'awaiting_review' || check.status === 'needs_attention');
+                if (!suppressIntermediateUpdate) {
+                    this.suppressIntermediateUpdatesUntil.delete(runId);
+                }
+                if (!suppressIntermediateUpdate && (pane.status !== check.status || pane.status_detail !== check.detail)) {
+                    this.setPaneStatus(pane, check.status, check.detail);
+                }
+                else if (!suppressIntermediateUpdate && check.status === 'running') {
+                    void this.reporter.publishLiveTrace({ ...pane });
+                }
+            }
+            catch (err) {
+                this.emit('error', new Error(`Error checking run ${runId}: ${err}`));
+            }
+        }
+    }
+    setPaneStatus(pane, status, detail) {
+        pane.status = status;
+        pane.status_detail = detail;
+        if (pane.run_id) {
+            this.runtime.updateManifest(pane.run_id, {
+                status: status === 'pending' ? 'running' : status,
+                status_detail: detail,
+            });
+            this.runtime.appendEvent(pane.run_id, {
+                type: 'status_updated',
+                status,
+                detail,
+            });
+        }
+        const snapshot = { ...pane };
+        this.emit('run_updated', snapshot);
+        void this.reporter.publishRunUpdated(snapshot);
+    }
+    async completeRun(runId, pane, result, detail) {
+        const finalSnapshot = await this.capturePaneSnapshot(pane);
+        const effectiveMode = pane.mode || this.runtime.getManifest(runId)?.mode || this.settings.mode;
+        pane.status = result.success ? 'success' : 'failed';
+        pane.status_detail = detail || result.error_summary;
+        if (result.success) {
+            this.setPaneStatus(pane, 'running', allowsAutomaticMerge(effectiveMode)
+                ? 'Agent finished; finalizing merge automation'
+                : 'Agent finished; finalizing PR automation');
+        }
+        try {
+            await this.runner.handleRunCompletion(pane, result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.setPaneStatus(pane, 'needs_attention', `Run finished, but Symphony failed during finalization: ${message}`);
+            if (pane.run_id) {
+                this.runtime.updateManifest(pane.run_id, {
+                    finished_at: new Date().toISOString(),
+                    status: 'needs_attention',
+                    status_detail: pane.status_detail,
+                    exit_code: result.exit_code,
+                    error_summary: pane.status_detail,
+                    commits: result.commits,
+                    head_sha: result.head_sha,
+                    tmux_pane_id: pane.tmux_pane_id,
+                    worktree_path: pane.worktree_path,
+                    branch: pane.branch,
+                });
+                this.runtime.appendEvent(pane.run_id, {
+                    type: 'finished',
+                    status: 'needs_attention',
+                    commits: result.commits,
+                    detail: pane.status_detail,
+                });
+            }
+        }
+        const finalStatus = pane.status;
+        await this.reporter.publishRunCompleted({ ...pane }, { snapshot: finalSnapshot });
+        if (pane.repo) {
+            this.state.removeActiveRun(pane.repo, runId);
+            const shouldMarkHandled = finalStatus === 'success'
+                || (finalStatus === 'awaiting_review' && effectiveMode !== 'auto');
+            if (shouldMarkHandled) {
+                this.state.markHandled(pane.repo, pane.issue_number, runId);
+            }
+            else {
+                this.state.unmarkHandled(pane.repo, pane.issue_number);
+            }
+            const trigger = getTriggerForRepo(this.settings, pane.repo);
+            if (finalStatus === 'success') {
+                this.state.clearSuppressedIssue(pane.repo, pane.issue_number);
+            }
+            else if (effectiveMode === 'auto') {
+                this.state.suppressIssue(pane.repo, pane.issue_number);
+            }
+            if (trigger.claim_label) {
+                try {
+                    await this.github.removeLabel(pane.repo, pane.issue_number, trigger.claim_label);
+                }
+                catch {
+                    // Ignore label cleanup failures.
+                }
+            }
+            for (const obsoleteLabel of [trigger.done_label, trigger.failed_label]) {
+                if (!obsoleteLabel)
+                    continue;
+                try {
+                    await this.github.removeLabel(pane.repo, pane.issue_number, obsoleteLabel);
+                }
+                catch {
+                    // Ignore status-label cleanup failures.
+                }
+            }
+            const statusLabel = finalStatus === 'success'
+                ? trigger.done_label
+                : (finalStatus === 'failed' ? trigger.failed_label : '');
+            if (statusLabel) {
+                try {
+                    await this.github.addLabels(pane.repo, pane.issue_number, [statusLabel]);
+                }
+                catch {
+                    // Ignore final label failures.
+                }
+            }
+        }
+        this.suppressIntermediateUpdatesUntil.delete(runId);
+        this.activeRuns.delete(runId);
+        // Notify director of completion (for dependency resolution and backlog)
+        if (this.director) {
+            this.director.recordCompletion({ ...pane });
+        }
+        this.emit('run_completed', { ...pane });
+    }
+    async handleRunnerProgress(pane) {
+        const snapshot = { ...pane };
+        this.emit('run_updated', snapshot);
+        await this.reporter.publishRunUpdated(snapshot, { force: true });
+    }
+    async capturePaneSnapshot(pane) {
+        if (!pane.tmux_pane_id)
+            return undefined;
+        if (!(await this.tmux.paneExists(pane.tmux_pane_id)))
+            return undefined;
+        const content = await this.tmux.getPaneContent(pane.tmux_pane_id, 30);
+        return content.trim() || undefined;
+    }
+    /**
+     * Run a single poll cycle (for testing / manual use).
+     */
+    async runOnce() {
+        this.running = true;
+        await this.poll();
+        this.running = false;
+    }
+}
+function isSymphonyManagedComment(body) {
+    return typeof body === 'string' && body.includes('<!-- symphony-progress:');
+}
+function hasLabel(issue, label) {
+    return issue.labels.some(issueLabel => issueLabel.name === label);
+}
+//# sourceMappingURL=daemon.js.map