symphony-github 0.1.0

package/dist/app.js

@@ -0,0 +1,829 @@
+import React, { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { Box, Text, useInput, useApp, useStdout } from 'ink';
+import { Header } from './components/Header.js';
+import { Onboarding } from './components/Onboarding.js';
+import { StartupRecoveryView } from './components/StartupRecoveryView.js';
+import { StatusBar } from './components/StatusBar.js';
+import { loadConfigDocument, writeConfigAndLoad } from './config/index.js';
+import { Daemon } from './services/daemon.js';
+import { TmuxService } from './services/tmux.js';
+import { colors, gradient, statusColor, statusIcon, sparkline } from './theme.js';
+import { getDiffStats } from './git/utils.js';
+// Table column widths (fixed columns; title gets remaining space)
+const COL = { num: 7, status: 18, agent: 8, changes: 14, time: 8, activity: 16 };
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max - 1) + '\u2026';
+}
+// Strip ANSI/cursor artifacts so activity tracking ignores tmux UI noise
+function normalizeContent(raw) {
+    return raw
+        .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '') // CSI sequences
+        .replace(/\x1b\][^\x07]*\x07/g, '') // OSC sequences
+        .replace(/\x1b[()][0-9A-B]/g, '') // charset sequences
+        .split('\n')
+        .map(line => line.trimEnd())
+        .join('\n')
+        .replace(/\n+$/, '');
+}
+// Patterns that indicate the agent is actively working (reused from runner.ts)
+const ACTIVITY_PATTERNS = [
+    /thinking/i, /planning/i, /analyzing/i, /building/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, /staging/i, /committing/i, /finalizing/i,
+    /esc to interrupt/i, /\(\d+[smh].*interrupt/i,
+    /considering/i, /inspecting/i, /implementing/i, /verifying/i,
+];
+// OSC 8 terminal hyperlink (clickable in modern terminals/tmux 3.1+)
+function hyperlink(url, text) {
+    return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+const DELETE_MENU_OPTIONS = [
+    { action: 'pause', label: 'Pause agent', desc: 'Send interrupt (Ctrl-C) to the agent' },
+    { action: 'kill', label: 'Kill agent', desc: 'Kill the tmux pane and remove from list' },
+    { action: 'label_kill', label: 'Label no-agents & kill', desc: 'Add ignore label, remove claim label, kill' },
+];
+function timeAgo(ms) {
+    const sec = Math.floor((Date.now() - ms) / 1000);
+    if (sec < 5)
+        return 'now';
+    if (sec < 60)
+        return `${sec}s ago`;
+    if (sec < 3600)
+        return `${Math.floor(sec / 60)}m ago`;
+    return `${Math.floor(sec / 3600)}h ago`;
+}
+export const App = ({ settings, sessionName, controlPaneId, configPath }) => {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const termHeight = stdout?.rows || 40;
+    const termWidth = stdout?.columns || 80;
+    const [activeSettings, setActiveSettings] = useState(settings);
+    const [isConfiguring, setIsConfiguring] = useState(false);
+    const [configBase, setConfigBase] = useState();
+    const [panes, setPanes] = useState([]);
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [statusMessage, setStatusMessage] = useState();
+    const [lastPoll, setLastPoll] = useState();
+    const [preview, setPreview] = useState('');
+    const [daemon, setDaemon] = useState(null);
+    const [paneActivitySnapshot, setPaneActivitySnapshot] = useState(new Map());
+    const [startupRecovery, setStartupRecovery] = useState({
+        loading: true,
+        pending: [],
+        selectedIds: new Set(),
+        cursor: 0,
+        recoveredCount: 0,
+        applying: false,
+    });
+    const contentHashesRef = useRef(new Map());
+    const paneActivityRef = useRef(new Map());
+    const lastActivityTsRef = useRef(new Map());
+    const previewCacheRef = useRef(new Map());
+    const [lastActivitySnapshot, setLastActivitySnapshot] = useState(new Map());
+    const [diffStatsSnapshot, setDiffStatsSnapshot] = useState(new Map());
+    const diffStatsRef = useRef(new Map());
+    const [deleteMenu, setDeleteMenu] = useState(null);
+    const tmux = TmuxService.getInstance();
+    const orderedPanes = useMemo(() => [
+        ...panes.filter(p => p.status === 'running'),
+        ...panes.filter(p => p.status === 'awaiting_review'),
+        ...panes.filter(p => p.status === 'needs_attention'),
+        ...panes.filter(p => p.status === 'pending'),
+        ...panes.filter(p => p.status === 'success' || p.status === 'failed' || p.status === 'timeout'),
+    ], [panes]);
+    const isStartupRecoveryActive = startupRecovery.loading || startupRecovery.pending.length > 0 || startupRecovery.applying;
+    // ── Business logic ────────────────────────────────────────────────
+    const upsertPane = useCallback((incoming) => {
+        setPanes(prev => {
+            const index = prev.findIndex(p => p.id === incoming.id);
+            if (index === -1) {
+                const pendingMatchIndex = prev.findIndex(p => p.status === 'pending'
+                    && incoming.status !== 'pending'
+                    && p.repo
+                    && incoming.repo
+                    && p.repo === incoming.repo
+                    && p.issue_number
+                    && incoming.issue_number
+                    && p.issue_number === incoming.issue_number);
+                if (pendingMatchIndex !== -1) {
+                    const next = [...prev];
+                    next[pendingMatchIndex] = incoming;
+                    return next;
+                }
+                return [...prev, incoming];
+            }
+            const next = [...prev];
+            next[index] = { ...next[index], ...incoming };
+            return next;
+        });
+    }, []);
+    const applyStartupRecoverySelection = useCallback(async (selectedIds) => {
+        if (!daemon)
+            return;
+        setStartupRecovery(prev => ({ ...prev, applying: true }));
+        try {
+            await daemon.launchStartupIssues(selectedIds);
+        }
+        finally {
+            daemon.completeStartupRecovery();
+            daemon.start();
+            setStartupRecovery(prev => ({
+                ...prev,
+                applying: false,
+                loading: false,
+                pending: [],
+            }));
+        }
+    }, [daemon]);
+    useEffect(() => {
+        setActiveSettings(settings);
+    }, [settings]);
+    const enterConfigureMode = useCallback(() => {
+        try {
+            setConfigBase(loadConfigDocument(configPath));
+            setIsConfiguring(true);
+            setStatusMessage('Reconfigure Symphony');
+            setTimeout(() => setStatusMessage(undefined), 3000);
+        }
+        catch (err) {
+            setStatusMessage(`Failed to load config: ${err}`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+    }, [configPath]);
+    const handleConfigureComplete = useCallback((result) => {
+        try {
+            const nextSettings = writeConfigAndLoad(configPath, result.yaml);
+            setStartupRecovery({
+                loading: true,
+                pending: [],
+                selectedIds: new Set(),
+                cursor: 0,
+                recoveredCount: 0,
+                applying: false,
+            });
+            setConfigBase(loadConfigDocument(configPath));
+            setActiveSettings(nextSettings);
+            setIsConfiguring(false);
+            setStatusMessage('Configuration updated');
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+        catch (err) {
+            setStatusMessage(`Failed to write config: ${err}`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+    }, [configPath]);
+    // ── Daemon initialization ─────────────────────────────────────────
+    useEffect(() => {
+        const d = new Daemon(activeSettings, sessionName);
+        let cancelled = false;
+        d.on('poll_start', () => { });
+        d.on('poll_end', (result) => {
+            setLastPoll(new Date().toISOString());
+            if (result.launched > 0) {
+                setStatusMessage(`Launched ${result.launched} run(s)`);
+                setTimeout(() => setStatusMessage(undefined), 5000);
+            }
+        });
+        d.on('run_started', (pane) => {
+            upsertPane(pane);
+            setStatusMessage(`Started: #${pane.issue_number} ${pane.issue_title || ''}`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        });
+        d.on('run_updated', (pane) => {
+            upsertPane(pane);
+            if (pane.status === 'awaiting_review') {
+                setStatusMessage(`Awaiting review: #${pane.issue_number}`);
+            }
+            else if (pane.status === 'needs_attention') {
+                setStatusMessage(`Needs attention: #${pane.issue_number}`);
+            }
+            else if (pane.status_detail) {
+                setStatusMessage(pane.status_detail);
+            }
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        });
+        d.on('run_completed', (pane) => {
+            upsertPane(pane);
+            setStatusMessage(`Completed: #${pane.issue_number} (${pane.status})`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        });
+        d.on('error', (err) => {
+            setStatusMessage(`Error: ${err.message}`);
+            setTimeout(() => setStatusMessage(undefined), 8000);
+        });
+        d.on('status', (msg) => {
+            setStatusMessage(msg);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        });
+        setDaemon(d);
+        void (async () => {
+            try {
+                const recovery = await d.prepareStartupRecovery();
+                if (cancelled)
+                    return;
+                for (const pane of recovery.recovered) {
+                    upsertPane(pane);
+                }
+                if (recovery.pending.length > 0) {
+                    setStartupRecovery({
+                        loading: true,
+                        pending: recovery.pending,
+                        selectedIds: new Set(recovery.pending.map(item => item.id)),
+                        cursor: 0,
+                        recoveredCount: recovery.recovered.length,
+                        applying: true,
+                    });
+                    await d.launchStartupIssues(recovery.pending.map(item => item.id));
+                    d.completeStartupRecovery();
+                    setStartupRecovery({
+                        loading: false,
+                        pending: [],
+                        selectedIds: new Set(),
+                        cursor: 0,
+                        recoveredCount: recovery.recovered.length,
+                        applying: false,
+                    });
+                    setStatusMessage(recovery.recovered.length > 0
+                        ? `Recovered ${recovery.recovered.length} run(s); started startup issue processing`
+                        : `Started startup issue processing`);
+                    d.start();
+                    return;
+                }
+                d.completeStartupRecovery();
+                setStartupRecovery({
+                    loading: false,
+                    pending: [],
+                    selectedIds: new Set(),
+                    cursor: 0,
+                    recoveredCount: recovery.recovered.length,
+                    applying: false,
+                });
+                d.start();
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                setStartupRecovery(prev => ({ ...prev, loading: false, applying: false }));
+                setStatusMessage(`Startup recovery failed: ${err}`);
+                d.start();
+            }
+        })();
+        return () => {
+            cancelled = true;
+            d.stop();
+        };
+    }, [activeSettings, sessionName, upsertPane]);
+    // ── Periodic pane sync from daemon ────────────────────────────────
+    useEffect(() => {
+        if (!daemon)
+            return;
+        const interval = setInterval(() => {
+            const activeRuns = daemon.getActiveRuns();
+            setPanes(prev => {
+                let changed = false;
+                const updated = [...prev];
+                for (const run of activeRuns) {
+                    const idx = updated.findIndex(p => p.id === run.id);
+                    if (idx === -1) {
+                        updated.push(run);
+                        changed = true;
+                    }
+                    else {
+                        const existing = updated[idx];
+                        if (existing.status !== run.status
+                            || existing.status_detail !== run.status_detail
+                            || existing.tmux_pane_id !== run.tmux_pane_id
+                            || existing.branch !== run.branch) {
+                            updated[idx] = { ...updated[idx], ...run };
+                            changed = true;
+                        }
+                    }
+                }
+                return changed ? updated : prev;
+            });
+        }, 3000);
+        return () => clearInterval(interval);
+    }, [daemon]);
+    // Clamp selectedIndex when panes change
+    useEffect(() => {
+        setSelectedIndex(prev => {
+            if (orderedPanes.length === 0)
+                return 0;
+            return Math.min(prev, orderedPanes.length - 1);
+        });
+    }, [orderedPanes.length]);
+    // ── Preview fetch ─────────────────────────────────────────────────
+    const selectedPaneTmuxId = orderedPanes[selectedIndex]?.tmux_pane_id;
+    const selectedPaneId = orderedPanes[selectedIndex]?.id;
+    useEffect(() => {
+        if (isStartupRecoveryActive) {
+            setPreview('');
+            return;
+        }
+        if (!selectedPaneTmuxId) {
+            // No live tmux pane — show cached preview (for completed/killed panes)
+            const cached = selectedPaneId ? previewCacheRef.current.get(selectedPaneId) : '';
+            setPreview(cached || '');
+            return;
+        }
+        let cancelled = false;
+        const fetchPreview = async () => {
+            try {
+                const content = await tmux.getPaneContent(selectedPaneTmuxId, 200);
+                if (!cancelled) {
+                    const trimmed = content.trimEnd();
+                    // Cache every non-empty preview so completed panes retain content
+                    if (trimmed && selectedPaneId) {
+                        previewCacheRef.current.set(selectedPaneId, trimmed);
+                    }
+                    setPreview(prev => prev === trimmed ? prev : trimmed);
+                }
+            }
+            catch {
+                if (!cancelled)
+                    setPreview('');
+            }
+        };
+        fetchPreview();
+        const interval = setInterval(fetchPreview, 3000);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, [isStartupRecoveryActive, selectedPaneTmuxId, selectedPaneId, tmux]);
+    // ── Per-pane activity tracking for sparkline column ────────────────
+    useEffect(() => {
+        const interval = setInterval(async () => {
+            let changed = false;
+            for (const pane of orderedPanes) {
+                if (!pane.tmux_pane_id)
+                    continue;
+                try {
+                    const raw = await tmux.getPaneContent(pane.tmux_pane_id, 15);
+                    const normalized = normalizeContent(raw);
+                    const prevNormalized = contentHashesRef.current.get(pane.id);
+                    contentHashesRef.current.set(pane.id, normalized);
+                    if (prevNormalized !== undefined) {
+                        const contentChanged = normalized !== prevNormalized;
+                        // Also check for working-pattern keywords as a secondary signal
+                        const lines = normalized.split('\n').filter(Boolean);
+                        const recentText = lines.slice(-8).join('\n');
+                        const matchesWork = ACTIVITY_PATTERNS.some(p => p.test(recentText));
+                        const active = (contentChanged || matchesWork) ? 1 : 0;
+                        const prev = paneActivityRef.current.get(pane.id) || new Array(14).fill(0);
+                        paneActivityRef.current.set(pane.id, [...prev.slice(-13), active]);
+                        if (active) {
+                            lastActivityTsRef.current.set(pane.id, Date.now());
+                        }
+                        changed = true;
+                    }
+                    else {
+                        if (!paneActivityRef.current.has(pane.id)) {
+                            paneActivityRef.current.set(pane.id, new Array(14).fill(0));
+                        }
+                        lastActivityTsRef.current.set(pane.id, Date.now());
+                    }
+                }
+                catch { /* ignore */ }
+            }
+            if (changed) {
+                setPaneActivitySnapshot(new Map(paneActivityRef.current));
+                setLastActivitySnapshot(new Map(lastActivityTsRef.current));
+            }
+        }, 5000);
+        return () => clearInterval(interval);
+    }, [orderedPanes, tmux]);
+    // ── Diff stats polling ────────────────────────────────────────────
+    useEffect(() => {
+        const interval = setInterval(async () => {
+            let changed = false;
+            for (const pane of orderedPanes) {
+                if (!pane.worktree_path || !pane.base_sha)
+                    continue;
+                const hasStats = diffStatsRef.current.has(pane.id);
+                const isActive = pane.status === 'running' || pane.status === 'awaiting_review' || pane.status === 'needs_attention';
+                if (!isActive && hasStats)
+                    continue; // already have final stats
+                try {
+                    const stats = await getDiffStats(pane.base_sha, pane.worktree_path);
+                    const prev = diffStatsRef.current.get(pane.id);
+                    if (!prev || prev.added !== stats.added || prev.removed !== stats.removed) {
+                        diffStatsRef.current.set(pane.id, stats);
+                        changed = true;
+                    }
+                }
+                catch { /* ignore */ }
+            }
+            if (changed) {
+                setDiffStatsSnapshot(new Map(diffStatsRef.current));
+            }
+        }, 15000);
+        return () => clearInterval(interval);
+    }, [orderedPanes]);
+    // ── Keyboard input ────────────────────────────────────────────────
+    useInput(useCallback((input, key) => {
+        if (isConfiguring)
+            return;
+        // ── Delete action menu ──
+        if (deleteMenu) {
+            if (key.upArrow) {
+                setDeleteMenu(prev => prev ? { ...prev, cursor: Math.max(0, prev.cursor - 1) } : null);
+                return;
+            }
+            if (key.downArrow) {
+                setDeleteMenu(prev => prev ? { ...prev, cursor: Math.min(DELETE_MENU_OPTIONS.length - 1, prev.cursor + 1) } : null);
+                return;
+            }
+            if (key.escape) {
+                setDeleteMenu(null);
+                return;
+            }
+            if (key.return) {
+                const action = DELETE_MENU_OPTIONS[deleteMenu.cursor];
+                const pane = deleteMenu.pane;
+                setDeleteMenu(null);
+                if (action)
+                    void executeDeleteAction(action.action, pane);
+                return;
+            }
+            return;
+        }
+        // ── Startup recovery ──
+        if (isStartupRecoveryActive) {
+            if (startupRecovery.loading || startupRecovery.applying) {
+                if (input === 'q') {
+                    daemon?.stop();
+                    exit();
+                }
+                return;
+            }
+            const item = startupRecovery.pending[startupRecovery.cursor];
+            if (key.upArrow && startupRecovery.pending.length > 0) {
+                setStartupRecovery(prev => ({ ...prev, cursor: Math.max(0, prev.cursor - 1) }));
+                return;
+            }
+            if (key.downArrow && startupRecovery.pending.length > 0) {
+                setStartupRecovery(prev => ({ ...prev, cursor: Math.min(prev.pending.length - 1, prev.cursor + 1) }));
+                return;
+            }
+            if (input === ' ' && item) {
+                setStartupRecovery(prev => {
+                    const next = new Set(prev.selectedIds);
+                    if (next.has(item.id))
+                        next.delete(item.id);
+                    else
+                        next.add(item.id);
+                    return { ...prev, selectedIds: next };
+                });
+                return;
+            }
+            if (input === 'a') {
+                setStartupRecovery(prev => ({ ...prev, selectedIds: new Set(prev.pending.map(e => e.id)) }));
+                return;
+            }
+            if (input === 'n') {
+                setStartupRecovery(prev => ({ ...prev, selectedIds: new Set() }));
+                return;
+            }
+            if (key.return) {
+                void applyStartupRecoverySelection(Array.from(startupRecovery.selectedIds));
+                return;
+            }
+            if (input === 's') {
+                void applyStartupRecoverySelection([]);
+                return;
+            }
+            if (input === 'q') {
+                daemon?.stop();
+                exit();
+            }
+            return;
+        }
+        // ── Normal mode ──
+        const paneCount = orderedPanes.length;
+        if (key.upArrow && paneCount > 0) {
+            setSelectedIndex(prev => Math.max(0, prev - 1));
+            return;
+        }
+        if (key.downArrow && paneCount > 0) {
+            setSelectedIndex(prev => Math.min(paneCount - 1, prev + 1));
+            return;
+        }
+        if (key.return) {
+            const pane = orderedPanes[selectedIndex];
+            if (pane?.tmux_pane_id)
+                void jumpToPane(pane);
+            return;
+        }
+        // Delete / d → action menu
+        if (key.delete || input === 'd') {
+            const pane = orderedPanes[selectedIndex];
+            if (pane)
+                setDeleteMenu({ pane, cursor: 0 });
+            return;
+        }
+        if (input === 'q') {
+            daemon?.stop();
+            exit();
+            return;
+        }
+        if (input === 'c') {
+            enterConfigureMode();
+            return;
+        }
+        if (input === 'm') {
+            const pane = orderedPanes[selectedIndex];
+            if (pane && pane.status === 'success')
+                handleMerge(pane);
+            else {
+                setStatusMessage('Select a completed (success) pane to merge');
+                setTimeout(() => setStatusMessage(undefined), 3000);
+            }
+            return;
+        }
+        if (input === 'f') {
+            const pane = orderedPanes[selectedIndex];
+            if (pane?.status === 'awaiting_review')
+                void handleFinalize(pane);
+            else {
+                setStatusMessage('Select an awaiting-review pane to finalize');
+                setTimeout(() => setStatusMessage(undefined), 3000);
+            }
+            return;
+        }
+        if (input === 'r') {
+            const pane = orderedPanes[selectedIndex];
+            if (pane && (pane.status === 'awaiting_review' || pane.status === 'needs_attention'))
+                void handleResume(pane);
+            else {
+                setStatusMessage('Select a review/attention pane to resume');
+                setTimeout(() => setStatusMessage(undefined), 3000);
+            }
+            return;
+        }
+        if (input === 'x') {
+            const pane = orderedPanes[selectedIndex];
+            if (pane)
+                handleClose(pane);
+            return;
+        }
+        if (input === 'a') {
+            const pane = orderedPanes[selectedIndex];
+            if (pane?.tmux_pane_id)
+                void jumpToPane(pane);
+            return;
+        }
+    }, [
+        applyStartupRecoverySelection,
+        daemon,
+        deleteMenu,
+        enterConfigureMode,
+        exit,
+        isConfiguring,
+        isStartupRecoveryActive,
+        orderedPanes,
+        selectedIndex,
+        startupRecovery,
+    ]));
+    // ── Action handlers ───────────────────────────────────────────────
+    const jumpToPane = async (pane) => {
+        if (!pane.tmux_pane_id)
+            return;
+        try {
+            const exists = await tmux.paneExists(pane.tmux_pane_id);
+            if (!exists) {
+                setPanes(prev => prev.map(p => p.id === pane.id
+                    ? { ...p, status: p.status === 'success' ? 'success' : 'failed',
+                        status_detail: 'tmux pane no longer available', tmux_pane_id: undefined }
+                    : p));
+                setStatusMessage(`Pane for #${pane.issue_number || pane.slug} is no longer available`);
+                setTimeout(() => setStatusMessage(undefined), 5000);
+                return;
+            }
+            // Switch to the agent's tmux window
+            await tmux.selectWindowByPane(pane.tmux_pane_id);
+            await tmux.selectPane(pane.tmux_pane_id);
+            setStatusMessage(`Opened #${pane.issue_number || pane.slug} \u2014 Ctrl-b 0 to return`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+        catch (err) {
+            setStatusMessage(`Failed to open: ${err}`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+    };
+    const handleMerge = async (pane) => {
+        setStatusMessage(`Merging ${pane.branch}... (merge logic pending)`);
+        setTimeout(() => setStatusMessage(undefined), 5000);
+    };
+    const handleFinalize = async (pane) => {
+        try {
+            const ok = pane.run_id ? await daemon?.finalizeRun(pane.run_id) : false;
+            if (!ok) {
+                setStatusMessage(`Failed to finalize #${pane.issue_number || pane.slug}`);
+                setTimeout(() => setStatusMessage(undefined), 5000);
+                return;
+            }
+            setStatusMessage(`Finalizing #${pane.issue_number || pane.slug}`);
+            setTimeout(() => setStatusMessage(undefined), 3000);
+        }
+        catch (err) {
+            setStatusMessage(`Finalize failed: ${err}`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+    };
+    const handleResume = async (pane) => {
+        try {
+            const ok = pane.run_id ? await daemon?.resumeRun(pane.run_id) : false;
+            if (!ok) {
+                setStatusMessage(`Failed to resume #${pane.issue_number || pane.slug}`);
+                setTimeout(() => setStatusMessage(undefined), 5000);
+                return;
+            }
+            await jumpToPane(pane);
+        }
+        catch (err) {
+            setStatusMessage(`Resume failed: ${err}`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+    };
+    const handleClose = async (pane) => {
+        if (pane.tmux_pane_id) {
+            try {
+                await tmux.killPane(pane.tmux_pane_id);
+            }
+            catch { /* ignore */ }
+        }
+        setPanes(prev => prev.filter(p => p.id !== pane.id));
+        setSelectedIndex(prev => Math.max(0, Math.min(prev, panes.length - 2)));
+        setStatusMessage(`Closed: #${pane.issue_number || pane.slug}`);
+        setTimeout(() => setStatusMessage(undefined), 3000);
+    };
+    const executeDeleteAction = async (action, pane) => {
+        try {
+            switch (action) {
+                case 'pause':
+                    if (pane.run_id) {
+                        await daemon?.pauseRun(pane.run_id);
+                        setStatusMessage(`Paused #${pane.issue_number || pane.slug}`);
+                    }
+                    else if (pane.tmux_pane_id) {
+                        await tmux.sendKeys(pane.tmux_pane_id, 'C-c');
+                        setStatusMessage(`Sent interrupt to #${pane.issue_number || pane.slug}`);
+                    }
+                    break;
+                case 'kill':
+                    await handleClose(pane);
+                    return; // handleClose sets its own status message
+                case 'label_kill':
+                    if (pane.run_id && await daemon?.stopAndLabelRun(pane.run_id)) {
+                        setPanes(prev => prev.filter(p => p.id !== pane.id));
+                        setSelectedIndex(prev => Math.max(0, Math.min(prev, panes.length - 2)));
+                        setStatusMessage(`Labeled & removed #${pane.issue_number || pane.slug}`);
+                    }
+                    else {
+                        // Fallback: just close if no run_id
+                        await handleClose(pane);
+                        return;
+                    }
+                    break;
+            }
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+        catch (err) {
+            setStatusMessage(`Action failed: ${err}`);
+            setTimeout(() => setStatusMessage(undefined), 5000);
+        }
+    };
+    // ── Computed values for render ────────────────────────────────────
+    const selectedPane = orderedPanes[selectedIndex] || null;
+    const runningCount = panes.filter(p => p.status === 'running' || p.status === 'needs_attention').length;
+    const reviewCount = panes.filter(p => p.status === 'awaiting_review').length;
+    const completedCount = panes.filter(p => p.status === 'success' || p.status === 'failed' || p.status === 'timeout').length;
+    // Table layout
+    const titleWidth = Math.max(10, termWidth - COL.num - COL.status - COL.agent - COL.changes - COL.time - COL.activity - 6);
+    const maxTableRows = Math.min(orderedPanes.length, Math.max(3, Math.floor(termHeight * 0.35)));
+    let tableScrollOffset = 0;
+    if (selectedIndex >= maxTableRows) {
+        tableScrollOffset = selectedIndex - maxTableRows + 1;
+    }
+    const visibleRows = orderedPanes.slice(tableScrollOffset, tableScrollOffset + maxTableRows);
+    const hasScrollIndicator = orderedPanes.length > maxTableRows;
+    // Preview: fill remaining vertical space with explicit height
+    const tableHeight = orderedPanes.length === 0
+        ? 5 // border(2) + paddingY(2) + text(1)
+        : 4 + maxTableRows + (hasScrollIndicator ? 1 : 0); // border(2) + header(1) + sep(1) + rows + scroll
+    const previewBoxHeight = Math.max(5, termHeight - 3 - tableHeight - 3);
+    // 3=header box, 3=statusbar box
+    const previewContentLines = previewBoxHeight - 3; // minus border(2) + header line(1)
+    // ── Render ────────────────────────────────────────────────────────
+    if (isConfiguring) {
+        return (React.createElement(Onboarding, { configPath: configPath, flow: "reconfigure", initialSettings: activeSettings, baseConfig: configBase, onComplete: handleConfigureComplete, onExit: () => setIsConfiguring(false) }));
+    }
+    return (React.createElement(Box, { flexDirection: "column", height: termHeight },
+        React.createElement(Header, { repos: activeSettings.repos.map(r => r.repo), mode: activeSettings.mode, runningCount: runningCount, reviewCount: reviewCount, completedCount: completedCount, lastPoll: lastPoll }),
+        isStartupRecoveryActive ? (React.createElement(Box, { flexGrow: 1, borderStyle: "round", borderColor: colors.border, flexDirection: "column" },
+            React.createElement(StartupRecoveryView, { loading: startupRecovery.loading || startupRecovery.applying, applying: startupRecovery.applying, recoveredCount: startupRecovery.recoveredCount, pending: startupRecovery.pending, selectedIds: startupRecovery.selectedIds, cursor: startupRecovery.cursor }))) : (React.createElement(React.Fragment, null,
+            React.createElement(Box, { borderStyle: "round", borderColor: gradient.blue3, flexDirection: "column", paddingX: 1 }, orderedPanes.length === 0 ? (React.createElement(Box, { paddingY: 1 },
+                React.createElement(Text, { color: colors.muted }, "No issues yet. Waiting for GitHub issues..."))) : (React.createElement(React.Fragment, null,
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: gradient.blue5, bold: true },
+                        '  ',
+                        '#'.padEnd(COL.num - 2),
+                        'Title'.padEnd(titleWidth),
+                        'Status'.padEnd(COL.status),
+                        'Agent'.padEnd(COL.agent),
+                        'Changes'.padEnd(COL.changes),
+                        'Update'.padEnd(COL.time),
+                        'Activity')),
+                React.createElement(Text, { color: colors.border }, '\u2500'.repeat(Math.max(0, termWidth - 4))),
+                visibleRows.map((pane, i) => {
+                    const globalIdx = tableScrollOffset + i;
+                    const isSelected = globalIdx === selectedIndex;
+                    const num = pane.issue_number ? `#${pane.issue_number}` : truncate(pane.slug, COL.num - 2);
+                    const title = truncate(pane.issue_title || pane.slug || '', titleWidth - 1);
+                    const status = `${statusIcon(pane.status)} ${pane.status}`;
+                    const agent = pane.agent_name || '-';
+                    const lastTs = lastActivitySnapshot.get(pane.id);
+                    const time = lastTs ? timeAgo(lastTs) : (pane.started_at ? timeAgo(new Date(pane.started_at).getTime()) : '-');
+                    const activity = paneActivitySnapshot.get(pane.id) || new Array(14).fill(0);
+                    const act = sparkline(activity);
+                    const bg = isSelected ? colors.selected : undefined;
+                    return (React.createElement(Box, { key: pane.id },
+                        React.createElement(Text, { backgroundColor: bg, color: isSelected ? colors.selectedText : colors.primaryLight },
+                            isSelected ? '\u25b8 ' : '  ',
+                            pane.issue_url ? hyperlink(pane.issue_url, num) : num,
+                            ' '.repeat(Math.max(0, COL.num - 2 - num.length))),
+                        React.createElement(Text, { backgroundColor: bg, color: isSelected ? colors.selectedText : colors.text }, title.padEnd(titleWidth)),
+                        React.createElement(Text, { backgroundColor: bg, color: isSelected ? colors.selectedText : statusColor(pane.status) }, truncate(status, COL.status - 1).padEnd(COL.status)),
+                        React.createElement(Text, { backgroundColor: bg, color: isSelected ? colors.selectedText : colors.accent }, truncate(agent, COL.agent - 1).padEnd(COL.agent)),
+                        (() => {
+                            const stats = diffStatsSnapshot.get(pane.id);
+                            if (!stats) {
+                                return (React.createElement(Text, { backgroundColor: bg, color: isSelected ? colors.selectedText : colors.muted }, (pane.status === 'pending' ? '-' : '\u2026').padEnd(COL.changes)));
+                            }
+                            const addStr = `+${stats.added}`;
+                            const remStr = `-${stats.removed}`;
+                            const pad = Math.max(0, COL.changes - addStr.length - 1 - remStr.length);
+                            return (React.createElement(Box, { width: COL.changes },
+                                React.createElement(Text, { backgroundColor: bg, color: isSelected ? colors.selectedText : colors.success }, addStr),
+                                React.createElement(Text, { backgroundColor: bg }, ' '),
+                                React.createElement(Text, { backgroundColor: bg, color: isSelected ? colors.selectedText : colors.error }, remStr),
+                                React.createElement(Text, { backgroundColor: bg }, ' '.repeat(pad))));
+                        })(),
+                        React.createElement(Text, { backgroundColor: bg, color: isSelected ? colors.selectedText : colors.textDim }, time.padEnd(COL.time)),
+                        React.createElement(Text, { backgroundColor: bg, color: isSelected ? gradient.blue6 : colors.running }, act.padEnd(COL.activity))));
+                }),
+                hasScrollIndicator && (React.createElement(Box, { justifyContent: "space-between" },
+                    React.createElement(Text, { color: colors.muted }, tableScrollOffset > 0 ? '  \u2191 more' : '        '),
+                    React.createElement(Text, { color: colors.muted }, tableScrollOffset + maxTableRows < orderedPanes.length ? '\u2193 more  ' : '        ')))))),
+            React.createElement(Box, { borderStyle: "round", borderColor: deleteMenu ? colors.warning : colors.border, flexDirection: "column", height: previewBoxHeight, paddingX: 1 }, deleteMenu ? (React.createElement(Box, { flexDirection: "column", paddingY: 1 },
+                React.createElement(Text, { bold: true, color: colors.warning },
+                    ' ',
+                    "Action: #",
+                    deleteMenu.pane.issue_number || deleteMenu.pane.slug,
+                    ' ',
+                    truncate(deleteMenu.pane.issue_title || '', 40)),
+                React.createElement(Text, { color: colors.muted }, ' '),
+                DELETE_MENU_OPTIONS.map((opt, i) => {
+                    const isSel = i === deleteMenu.cursor;
+                    return (React.createElement(Box, { key: opt.action },
+                        React.createElement(Text, { color: isSel ? colors.selectedText : colors.text, backgroundColor: isSel ? colors.selected : undefined, bold: isSel },
+                            isSel ? ' \u25b8 ' : '   ',
+                            opt.label),
+                        React.createElement(Text, { color: colors.muted },
+                            '  ',
+                            opt.desc)));
+                }),
+                React.createElement(Text, { color: colors.muted }, ' '),
+                React.createElement(Text, { color: colors.muted },
+                    '  ',
+                    React.createElement(Text, { color: colors.key }, "\u2191\u2193"),
+                    " choose",
+                    '  ',
+                    React.createElement(Text, { color: colors.key }, "Enter"),
+                    " confirm",
+                    '  ',
+                    React.createElement(Text, { color: colors.key }, "Esc"),
+                    " cancel"))) : selectedPane ? (React.createElement(React.Fragment, null,
+                React.createElement(Box, null,
+                    React.createElement(Text, { bold: true, color: colors.primaryLight },
+                        'Preview: ',
+                        selectedPane.issue_url
+                            ? hyperlink(selectedPane.issue_url, `#${selectedPane.issue_number || ''} ${truncate(selectedPane.issue_title || selectedPane.slug || '', Math.max(10, termWidth - 40))}`)
+                            : `${selectedPane.issue_number ? `#${selectedPane.issue_number} ` : ''}${truncate(selectedPane.issue_title || selectedPane.slug || '', Math.max(10, termWidth - 40))}`),
+                    selectedPane.agent_name && (React.createElement(Text, { color: colors.accent },
+                        " [",
+                        selectedPane.agent_name,
+                        "]")),
+                    React.createElement(Text, { color: statusColor(selectedPane.status) },
+                        ' ',
+                        statusIcon(selectedPane.status),
+                        " ",
+                        selectedPane.status)),
+                preview ? (React.createElement(Text, { color: colors.text, wrap: "truncate-end" }, preview.split('\n').slice(-Math.max(3, previewContentLines)).join('\n'))) : (React.createElement(Text, { color: colors.muted }, selectedPane.tmux_pane_id ? 'Loading preview...' : 'No pane available (pending)')))) : (React.createElement(Text, { color: colors.muted }, "No issue selected"))))),
+        React.createElement(StatusBar, { message: statusMessage, recoveryMode: isStartupRecoveryActive, deleteMenuActive: deleteMenu !== null })));
+};
+//# sourceMappingURL=app.js.map