verbolab 0.1.0-alpha.1

package/dist/src/tui/app.js

@@ -0,0 +1,676 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect, useRef } from 'react';
+import { execFile } from 'child_process';
+import { Box, Text, useInput } from 'ink';
+import { useStore } from './hooks/use-store.js';
+import { useBell } from './hooks/use-bell.js';
+import { useKeyboard } from './hooks/use-keyboard.js';
+import { useSpinner } from './hooks/use-spinner.js';
+import { RichHeader } from './components/rich-header.js';
+import { StatusBar } from './components/status-bar.js';
+import { AgentList } from './components/agent-list.js';
+import { ApprovalTerminal } from './components/approval-terminal.js';
+import { TaskQueue } from './components/task-queue.js';
+import { Footer } from './components/footer.js';
+import { NewTaskInput } from './components/new-task-input.js';
+import { ReviewQueue, getReviewTasks } from './components/review-queue.js';
+import { ActivityFeed } from './components/activity-feed.js';
+import { HumanActions } from './components/human-actions.js';
+import { DecompositionReview } from './components/decomposition-review.js';
+import { DiffViewer } from './components/diff-viewer.js';
+import { useDiffView } from './hooks/use-diff-view.js';
+import { MemoryViewer } from './components/memory-viewer.js';
+import { AuditViewer } from './components/audit-viewer.js';
+import { CommandPalette } from './components/command-palette.js';
+import { DependencyGraph } from './components/dependency-graph.js';
+import { buildPaletteCommands } from './lib/palette-commands.js';
+import { LogPanel } from './components/log-panel.js';
+import { hasFileOverlap } from '../core/parallelizer.js';
+import { countPrsToday } from '../core/orchestrator-store.js';
+export function App({ getState, teamName, onCreateTask, onLaunchAgent, onLaunchBatch, onKillAgent, onDismiss, onApproveRequest, onDenyRequest, onToggleYolo, onToggleFactory, onResolveHumanAction, onDeleteTask, onDecomposeTask, onConfirmDecompose, onForcePush, getLogLines, getLearnings, getAuditEntries, getTaskTitleById, flashMessage, getDependencyGraph, }) {
+    const state = useStore(getState);
+    useBell(state);
+    const spinnerFrame = useSpinner();
+    const [rows, setRows] = useState(process.stdout.rows ?? 24);
+    const [cols, setCols] = useState(process.stdout.columns ?? 80);
+    const [showNewTask, setShowNewTask] = useState(false);
+    const [activeArea, setActiveArea] = useState('tasks');
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [taskIndex, setTaskIndex] = useState(0);
+    const [approvalIndex, setApprovalIndex] = useState(0);
+    const [showReview, setShowReview] = useState(false);
+    const [reviewIndex, setReviewIndex] = useState(0);
+    const [showFeed, setShowFeed] = useState(true);
+    const [feedOffset, setFeedOffset] = useState(0);
+    const [actionIndex, setActionIndex] = useState(0);
+    const [trustLevel, setTrustLevel] = useState('medium');
+    const [skipFeedback, setSkipFeedback] = useState(null);
+    const skipTimerRef = useRef(null);
+    const [decomposeState, setDecomposeState] = useState('idle');
+    const [decomposeSubtasks, setDecomposeSubtasks] = useState([]);
+    const [decomposeTaskId, setDecomposeTaskId] = useState(null);
+    const [showLog, setShowLog] = useState(false);
+    const [showHelp, setShowHelp] = useState(false);
+    const [showMemory, setShowMemory] = useState(false);
+    const [showDiff, setShowDiff] = useState(false);
+    const [diffWorktreePath, setDiffWorktreePath] = useState(null);
+    const [diffBranch, setDiffBranch] = useState(null);
+    const [showPalette, setShowPalette] = useState(false);
+    const [showAudit, setShowAudit] = useState(false);
+    const [auditFilter, setAuditFilter] = useState('');
+    const [auditScroll, setAuditScroll] = useState(0);
+    const [auditFilterMode, setAuditFilterMode] = useState(false);
+    const [showGraph, setShowGraph] = useState(false);
+    const [graphFocusedId, setGraphFocusedId] = useState(null);
+    // Fetch diff for selected agent (only when diff panel is open)
+    const diffView = useDiffView(showDiff ? diffWorktreePath : null, showDiff ? diffBranch : null);
+    // Track terminal resize to keep layout within viewport
+    useEffect(() => {
+        const onResize = () => {
+            setRows(process.stdout.rows ?? 24);
+            setCols(process.stdout.columns ?? 80);
+        };
+        process.stdout.on('resize', onResize);
+        return () => { process.stdout.off('resize', onResize); };
+    }, []);
+    const showSkipFeedback = useCallback((message) => {
+        if (skipTimerRef.current)
+            clearTimeout(skipTimerRef.current);
+        setSkipFeedback(message);
+        skipTimerRef.current = setTimeout(() => setSkipFeedback(null), 4000);
+    }, []);
+    // Cleanup timer on unmount
+    useEffect(() => {
+        return () => {
+            if (skipTimerRef.current)
+                clearTimeout(skipTimerRef.current);
+        };
+    }, []);
+    const cycleTrustLevel = () => {
+        setTrustLevel((prev) => {
+            if (prev === 'low')
+                return 'medium';
+            if (prev === 'medium')
+                return 'high';
+            return 'low';
+        });
+    };
+    useKeyboard((action) => {
+        // When graph is open, component handles its own navigation
+        if (showGraph) {
+            if (action === 'dismiss')
+                setShowGraph(false);
+            return;
+        }
+        // When palette is open, block all other actions (component handles its own navigation)
+        if (showPalette) {
+            if (action === 'dismiss')
+                setShowPalette(false);
+            return;
+        }
+        // When audit viewer is open, handle its own navigation
+        if (showAudit && !auditFilterMode) {
+            if (action === 'dismiss') {
+                setShowAudit(false);
+                setAuditFilter('');
+                setAuditScroll(0);
+            }
+            else if (action === 'nav-down') {
+                setAuditScroll((prev) => prev + 1);
+            }
+            else if (action === 'nav-up') {
+                setAuditScroll((prev) => Math.max(0, prev - 1));
+            }
+            // '/' to enter filter mode is handled by the separate useInput below
+            return;
+        }
+        // When decompose review is visible, only handle dismiss
+        if (decomposeState === 'review' || decomposeState === 'loading') {
+            return;
+        }
+        // When log panel is open, only handle dismiss (LogPanel has its own useInput for j/k/o/space)
+        if (showLog) {
+            if (action === 'dismiss') {
+                setShowLog(false);
+            }
+            return;
+        }
+        // When diff viewer is open, route navigation to it
+        if (showDiff) {
+            if (action === 'dismiss' || action === 'diff') {
+                setShowDiff(false);
+            }
+            else if (action === 'feed-scroll-down') {
+                diffView.nextFile();
+            }
+            else if (action === 'feed-scroll-up') {
+                diffView.prevFile();
+            }
+            else if (action === 'new-task') {
+                diffView.nextHunk();
+            }
+            else if (action === 'hunk-prev') {
+                diffView.prevHunk();
+            }
+            return;
+        }
+        // When new-task input is visible, only handle dismiss
+        if (showNewTask) {
+            if (action === 'dismiss') {
+                setShowNewTask(false);
+            }
+            return;
+        }
+        switch (action) {
+            case 'approve-once': {
+                const req = state.pendingApprovals[approvalIndex];
+                if (req) {
+                    onApproveRequest(req.id);
+                    // Advance to next request or reset
+                    if (approvalIndex >= state.pendingApprovals.length - 1) {
+                        setApprovalIndex(0);
+                    }
+                }
+                break;
+            }
+            case 'approve-session': {
+                // For now, same as approve-once (session-level approval is future work)
+                const req = state.pendingApprovals[approvalIndex];
+                if (req) {
+                    onApproveRequest(req.id);
+                    if (approvalIndex >= state.pendingApprovals.length - 1) {
+                        setApprovalIndex(0);
+                    }
+                }
+                break;
+            }
+            case 'deny': {
+                const req = state.pendingApprovals[approvalIndex];
+                if (req) {
+                    onDenyRequest(req.id);
+                    if (approvalIndex >= state.pendingApprovals.length - 1) {
+                        setApprovalIndex(0);
+                    }
+                }
+                break;
+            }
+            case 'yolo-toggle':
+                onToggleYolo();
+                break;
+            case 'factory-toggle':
+                onToggleFactory();
+                break;
+            case 'new-task':
+                setShowNewTask(true);
+                break;
+            case 'toggle-review':
+                setShowReview((prev) => !prev);
+                break;
+            case 'open-pr': {
+                const reviewTasks = getReviewTasks(state.tasks);
+                const target = reviewTasks[reviewIndex];
+                if (target?.prUrl) {
+                    const cmd = process.platform === 'win32' ? 'cmd' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+                    const args = process.platform === 'win32' ? ['/c', 'start', '', target.prUrl] : [target.prUrl];
+                    execFile(cmd, args, { timeout: 5_000 }, () => { });
+                }
+                break;
+            }
+            case 'review-up': {
+                setReviewIndex((i) => Math.max(i - 1, 0));
+                break;
+            }
+            case 'review-down': {
+                const reviewTasks = getReviewTasks(state.tasks);
+                setReviewIndex((i) => Math.min(i + 1, Math.max(0, reviewTasks.length - 1)));
+                break;
+            }
+            case 'toggle-feed':
+                setShowFeed((prev) => !prev);
+                break;
+            case 'feed-scroll-down':
+                setFeedOffset((prev) => prev + 1);
+                break;
+            case 'feed-scroll-up':
+                setFeedOffset((prev) => Math.max(0, prev - 1));
+                break;
+            case 'focus-agents':
+                setActiveArea('agents');
+                break;
+            case 'focus-tasks':
+                setActiveArea('tasks');
+                break;
+            case 'focus-your-turn':
+                setActiveArea('your-turn');
+                break;
+            case 'focus-activity':
+                setActiveArea('activity');
+                break;
+            case 'nav-up': {
+                switch (activeArea) {
+                    case 'agents':
+                        setSelectedIndex((i) => Math.max(i - 1, 0));
+                        break;
+                    case 'tasks':
+                        setTaskIndex((i) => Math.max(i - 1, 0));
+                        break;
+                    case 'your-turn':
+                        setActionIndex((i) => Math.max(i - 1, 0));
+                        break;
+                    case 'activity':
+                        setFeedOffset((prev) => Math.max(0, prev - 1));
+                        break;
+                }
+                break;
+            }
+            case 'nav-down': {
+                switch (activeArea) {
+                    case 'agents':
+                        setSelectedIndex((i) => Math.min(i + 1, Math.max(0, state.activeSessions.length - 1)));
+                        break;
+                    case 'tasks': {
+                        const todoTasks = state.tasks.filter((t) => (t.status === 'todo' || t.status === 'blocked') && !t.title.startsWith('HUMANO:'));
+                        setTaskIndex((i) => Math.min(i + 1, Math.max(0, todoTasks.length - 1)));
+                        break;
+                    }
+                    case 'your-turn':
+                        setActionIndex((i) => Math.min(i + 1, Math.max(0, state.humanActions.length - 1)));
+                        break;
+                    case 'activity':
+                        setFeedOffset((prev) => prev + 1);
+                        break;
+                }
+                break;
+            }
+            case 'cycle-trust':
+                cycleTrustLevel();
+                break;
+            case 'parallelize':
+                if (state.parallelBatch.length > 0) {
+                    onLaunchBatch(state.parallelBatch.map((t) => t.id), trustLevel);
+                }
+                break;
+            case 'launch': {
+                const todoTasks = state.tasks.filter((t) => t.status === 'todo' && !t.title.startsWith('HUMANO:'));
+                if (todoTasks.length === 0)
+                    break;
+                const activeTasks = state.tasks.filter((t) => t.status === 'in_progress');
+                const activeFiles = activeTasks.flatMap((t) => t.filePaths);
+                const startIdx = Math.min(taskIndex, todoTasks.length - 1);
+                // Find the first non-conflicting task starting from selected index
+                const skippedMessages = [];
+                let launched = false;
+                for (let offset = 0; offset < todoTasks.length; offset++) {
+                    const idx = (startIdx + offset) % todoTasks.length;
+                    const candidate = todoTasks[idx];
+                    // Check for file conflict with active tasks
+                    if (activeFiles.length > 0 && candidate.filePaths.length > 0) {
+                        let conflictFile = null;
+                        let conflictTask = null;
+                        for (const active of activeTasks) {
+                            if (hasFileOverlap(candidate.filePaths, active.filePaths)) {
+                                // Find the specific conflicting file for the message
+                                for (const cf of candidate.filePaths) {
+                                    for (const af of active.filePaths) {
+                                        if (cf === af || hasFileOverlap([cf], [af])) {
+                                            conflictFile = cf;
+                                            conflictTask = active;
+                                            break;
+                                        }
+                                    }
+                                    if (conflictFile)
+                                        break;
+                                }
+                                break;
+                            }
+                        }
+                        if (conflictFile && conflictTask) {
+                            skippedMessages.push(`Skipped "${candidate.title}" — conflicts with "${conflictTask.title}" on ${conflictFile}`);
+                            continue;
+                        }
+                    }
+                    // No conflict — launch this task
+                    onLaunchAgent(candidate.id, trustLevel);
+                    setTaskIndex(0);
+                    launched = true;
+                    if (skippedMessages.length > 0) {
+                        showSkipFeedback(skippedMessages.join('\n'));
+                    }
+                    break;
+                }
+                if (!launched) {
+                    showSkipFeedback(`All ${todoTasks.length} todo tasks conflict with running agents`);
+                }
+                break;
+            }
+            case 'resolve-action': {
+                const action = state.humanActions[actionIndex];
+                if (action) {
+                    onResolveHumanAction(action.id);
+                    if (actionIndex >= state.humanActions.length - 1) {
+                        setActionIndex(Math.max(0, state.humanActions.length - 2));
+                    }
+                }
+                break;
+            }
+            case 'open-action-pr': {
+                const action = state.humanActions[actionIndex];
+                if (action?.actionType === 'merge-review' && action.prUrl) {
+                    const cmd = process.platform === 'win32' ? 'cmd' : process.platform === 'darwin' ? 'open' : 'xdg-open';
+                    const args = process.platform === 'win32' ? ['/c', 'start', '', action.prUrl] : [action.prUrl];
+                    execFile(cmd, args, { timeout: 5_000 }, () => { });
+                }
+                break;
+            }
+            case 'action-up':
+                setActionIndex((i) => Math.max(i - 1, 0));
+                break;
+            case 'action-down':
+                setActionIndex((i) => Math.min(i + 1, Math.max(0, state.humanActions.length - 1)));
+                break;
+            case 'diff': {
+                if (state.activeSessions.length > 0) {
+                    // Open diff for the selected active agent
+                    const clampedIdx = Math.min(selectedIndex, state.activeSessions.length - 1);
+                    const session = state.activeSessions[clampedIdx];
+                    if (session?.worktreePath && session.worktreeBranch) {
+                        setDiffWorktreePath(session.worktreePath);
+                        setDiffBranch(session.worktreeBranch);
+                        setShowDiff(true);
+                    }
+                    else {
+                        showSkipFeedback('Agent has no worktree yet — wait for it to start');
+                    }
+                }
+                else {
+                    // No agents running: fall back to decompose
+                    const todoTasks = state.tasks.filter((t) => (t.status === 'todo' || t.status === 'blocked') && !t.title.startsWith('HUMANO:'));
+                    const target = todoTasks[taskIndex] ?? todoTasks[0];
+                    if (!target)
+                        break;
+                    setDecomposeTaskId(target.id);
+                    setDecomposeState('loading');
+                    onDecomposeTask(target.id).then((subtasks) => {
+                        if (subtasks && subtasks.length > 0) {
+                            setDecomposeSubtasks(subtasks);
+                            setDecomposeState('review');
+                        }
+                        else {
+                            setDecomposeState('idle');
+                            showSkipFeedback('No decomposition available (need ANTHROPIC_API_KEY and ≥50-word description)');
+                        }
+                    }).catch(() => {
+                        setDecomposeState('idle');
+                        showSkipFeedback('Decomposition failed');
+                    });
+                }
+                break;
+            }
+            case 'hunk-prev':
+                // Only active inside the diff modal (handled above); ignore outside
+                break;
+            case 'kill': {
+                switch (activeArea) {
+                    case 'agents': {
+                        const session = state.activeSessions[selectedIndex];
+                        if (session)
+                            onKillAgent(session.id);
+                        break;
+                    }
+                    case 'tasks': {
+                        const todoTasks = state.tasks.filter((t) => (t.status === 'todo' || t.status === 'blocked') && !t.title.startsWith('HUMANO:'));
+                        const target = todoTasks[taskIndex];
+                        if (target) {
+                            if (target.status === 'todo' || target.status === 'blocked') {
+                                onDeleteTask(target.id);
+                                setTaskIndex((i) => Math.max(0, i - 1));
+                            }
+                            else if (target.status === 'in_progress' && target.agentSessionId) {
+                                onKillAgent(target.agentSessionId);
+                            }
+                        }
+                        break;
+                    }
+                    case 'your-turn': {
+                        const action = state.humanActions[actionIndex];
+                        if (action) {
+                            onResolveHumanAction(action.id);
+                            if (actionIndex >= state.humanActions.length - 1) {
+                                setActionIndex(Math.max(0, state.humanActions.length - 2));
+                            }
+                        }
+                        break;
+                    }
+                    case 'activity':
+                        // no-op
+                        break;
+                }
+                break;
+            }
+            case 'delete-task': {
+                switch (activeArea) {
+                    case 'agents': {
+                        const session = state.activeSessions[selectedIndex];
+                        if (session)
+                            onKillAgent(session.id);
+                        break;
+                    }
+                    case 'tasks': {
+                        const todoTasks = state.tasks.filter((t) => (t.status === 'todo' || t.status === 'blocked') && !t.title.startsWith('HUMANO:'));
+                        const target = todoTasks[taskIndex];
+                        if (target) {
+                            onDeleteTask(target.id);
+                            setTaskIndex((i) => Math.max(0, i - 1));
+                        }
+                        break;
+                    }
+                    case 'your-turn': {
+                        const action = state.humanActions[actionIndex];
+                        if (action) {
+                            onResolveHumanAction(action.id);
+                            if (actionIndex >= state.humanActions.length - 1) {
+                                setActionIndex(Math.max(0, state.humanActions.length - 2));
+                            }
+                        }
+                        break;
+                    }
+                    case 'activity':
+                        // no-op
+                        break;
+                }
+                break;
+            }
+            case 'open-log':
+                setShowLog((prev) => !prev);
+                break;
+            case 'help':
+                setShowHelp((prev) => !prev);
+                break;
+            case 'memory':
+                if (getLearnings)
+                    setShowMemory((prev) => !prev);
+                break;
+            case 'audit':
+                if (getAuditEntries) {
+                    setShowAudit((prev) => {
+                        if (prev) {
+                            setAuditFilter('');
+                            setAuditScroll(0);
+                        }
+                        return !prev;
+                    });
+                }
+                break;
+            case 'graph':
+                if (getDependencyGraph) {
+                    setShowGraph((prev) => {
+                        if (!prev) {
+                            // When opening, focus the first task
+                            const g = getDependencyGraph();
+                            setGraphFocusedId(g.roots[0] ?? null);
+                        }
+                        return !prev;
+                    });
+                }
+                break;
+            case 'palette':
+                setShowPalette(true);
+                break;
+            case 'dismiss':
+                // Palette, log, diff, new-task and decompose are handled by early returns above.
+                // This branch handles: help > memory > fallback dismiss.
+                if (showHelp) {
+                    setShowHelp(false);
+                }
+                else if (showMemory) {
+                    setShowMemory(false);
+                }
+                else {
+                    onDismiss();
+                }
+                break;
+            default:
+                break;
+        }
+    });
+    // Audit viewer: '/' to enter filter mode, type to filter, escape/return to exit filter mode
+    useInput((input, key) => {
+        if (!showAudit)
+            return;
+        if (auditFilterMode) {
+            if (key.escape || key.return) {
+                setAuditFilterMode(false);
+            }
+            else if (key.backspace || key.delete) {
+                setAuditFilter((prev) => prev.slice(0, -1));
+                setAuditScroll(0);
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                setAuditFilter((prev) => prev + input);
+                setAuditScroll(0);
+            }
+        }
+        else if (input === '/') {
+            setAuditFilterMode(true);
+        }
+    }, { isActive: showAudit });
+    const paletteCommands = buildPaletteCommands({
+        hasLogLines: !!getLogLines,
+        hasLearnings: !!getLearnings,
+    });
+    const onPaletteExecute = (action) => {
+        switch (action) {
+            case 'new-task':
+                setShowNewTask(true);
+                break;
+            case 'launch': {
+                const todoTasks = state.tasks.filter((t) => t.status === 'todo' && !t.title.startsWith('HUMANO:'));
+                if (todoTasks.length === 0)
+                    break;
+                const target = todoTasks[Math.min(taskIndex, todoTasks.length - 1)];
+                if (target)
+                    onLaunchAgent(target.id, trustLevel);
+                break;
+            }
+            case 'kill': {
+                const session = state.activeSessions[selectedIndex];
+                if (session)
+                    onKillAgent(session.id);
+                break;
+            }
+            case 'parallelize':
+                if (state.parallelBatch.length > 0) {
+                    onLaunchBatch(state.parallelBatch.map((t) => t.id), trustLevel);
+                }
+                break;
+            case 'toggle-review':
+                setShowReview((p) => !p);
+                break;
+            case 'toggle-feed':
+                setShowFeed((p) => !p);
+                break;
+            case 'yolo-toggle':
+                onToggleYolo();
+                break;
+            case 'factory-toggle':
+                onToggleFactory();
+                break;
+            case 'cycle-trust':
+                cycleTrustLevel();
+                break;
+            case 'diff': {
+                if (state.activeSessions.length > 0) {
+                    const clampedIdx = Math.min(selectedIndex, state.activeSessions.length - 1);
+                    const session = state.activeSessions[clampedIdx];
+                    if (session?.worktreePath && session.worktreeBranch) {
+                        setDiffWorktreePath(session.worktreePath);
+                        setDiffBranch(session.worktreeBranch);
+                        setShowDiff(true);
+                    }
+                    else {
+                        showSkipFeedback('Agent has no worktree yet — wait for it to start');
+                    }
+                }
+                break;
+            }
+            case 'help':
+                setShowHelp((p) => !p);
+                break;
+            case 'open-log':
+                setShowLog((p) => !p);
+                break;
+            case 'memory':
+                if (getLearnings)
+                    setShowMemory((p) => !p);
+                break;
+            case 'graph': {
+                if (getDependencyGraph) {
+                    const g = getDependencyGraph();
+                    setGraphFocusedId(g.roots[0] ?? null);
+                    setShowGraph((p) => !p);
+                }
+                break;
+            }
+            default: break;
+        }
+    };
+    const agentsRunning = state.activeSessions.length;
+    const warnings = state.conflicts.length;
+    const taskCount = state.tasks.length;
+    const blocked = state.tasks.filter((t) => t.status === 'blocked').length;
+    const orchestratorReviewing = state.orchestratorStates.filter((s) => s.pushStatus === 'pending').length;
+    const orchestratorBlocked = state.orchestratorStates.filter((s) => s.pushStatus === 'blocked').length;
+    const prsToday = countPrsToday(state.orchestratorStates);
+    return (_jsxs(Box, { flexDirection: "column", height: rows, overflow: "hidden", borderStyle: "round", borderColor: "gray", children: [_jsx(RichHeader, { teamName: teamName, syncStatus: state.syncStatus, cols: cols, spinnerFrame: spinnerFrame }), _jsx(Box, { borderStyle: "single", borderColor: "gray", borderTop: false, borderLeft: false, borderRight: false }), _jsx(StatusBar, { agentsRunning: agentsRunning, warnings: warnings, tasks: taskCount, blocked: blocked, humanActions: state.humanActions.length, factoryMode: state.factoryMode, yoloMode: state.yoloMode, orchestratorReviewing: orchestratorReviewing, orchestratorBlocked: orchestratorBlocked, prsToday: prsToday, cols: cols, flashMessage: flashMessage, isCompliance: state.isCompliance, mergeQueuePending: state.mergeQueueItems?.filter((i) => i.status === 'queued' || i.status === 'processing').length ?? 0, mergeQueueProcessing: state.mergeQueueProcessing ?? false }), _jsx(Box, { borderStyle: "single", borderColor: "gray", borderTop: false, borderLeft: false, borderRight: false }), _jsxs(Box, { flexDirection: "row", flexGrow: 1, overflow: "hidden", children: [_jsx(Box, { flexDirection: "column", width: "50%", overflow: "hidden", children: showReview ? (_jsx(Box, { flexGrow: 1, overflow: "hidden", children: _jsx(ReviewQueue, { tasks: state.tasks, selectedIndex: reviewIndex, orchestratorStates: state.orchestratorStates, onForcePush: onForcePush }) })) : (_jsxs(_Fragment, { children: [_jsx(Box, { flexGrow: 1, flexShrink: 1, flexBasis: 0, overflow: "hidden", children: _jsx(TaskQueue, { tasks: state.tasks, cols: cols, isActive: activeArea === 'tasks', selectedIndex: taskIndex }) }), _jsx(Box, { flexGrow: 1, flexShrink: 1, flexBasis: 0, overflow: "hidden", borderStyle: "single", borderColor: "magenta", borderLeft: false, borderRight: false, borderBottom: false, children: _jsx(HumanActions, { actions: state.humanActions, humanTasks: state.tasks.filter((t) => t.title.startsWith('HUMANO:') && t.status !== 'done'), selectedIndex: actionIndex, isActive: activeArea === 'your-turn' }) })] })) }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", borderStyle: "single", borderTop: false, borderRight: false, borderBottom: false, borderColor: "gray", children: [_jsx(Box, { flexGrow: 1, overflow: "hidden", flexDirection: "column", children: _jsx(AgentList, { sessions: state.activeSessions, tasks: state.tasks, conflicts: state.conflicts, selectedIndex: selectedIndex, activeArea: activeArea }) }), state.teamMembers.length > 0 && (_jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(Text, { color: "gray", dimColor: true, children: 'team: ' + state.teamMembers.map((m) => {
+                                        const count = m.sessions.length;
+                                        return count > 0 ? `${m.humanId}(${count})` : m.humanId;
+                                    }).join(' · ') }) }))] })] }), showLog && getLogLines && (_jsx(LogPanel, { getLines: getLogLines, onClose: () => setShowLog(false) })), showNewTask && (_jsx(Box, { borderStyle: "single", borderColor: "green", borderLeft: false, borderRight: false, borderBottom: false, children: _jsx(NewTaskInput, { visible: showNewTask, onSubmit: (title) => {
+                        onCreateTask(title);
+                        setShowNewTask(false);
+                    }, onDismiss: () => setShowNewTask(false) }) })), decomposeState === 'loading' && (_jsx(Box, { borderStyle: "single", borderColor: "cyan", borderLeft: false, borderRight: false, borderBottom: false, paddingX: 1, children: _jsxs(Text, { color: "cyan", children: [spinnerFrame, " Decomposing task with Claude\u2026"] }) })), decomposeState === 'review' && decomposeSubtasks.length > 0 && (_jsx(Box, { borderStyle: "single", borderColor: "cyan", borderLeft: false, borderRight: false, borderBottom: false, children: _jsx(DecompositionReview, { subtasks: decomposeSubtasks, onConfirm: () => {
+                        if (decomposeTaskId) {
+                            onConfirmDecompose(decomposeSubtasks, decomposeTaskId);
+                        }
+                        setDecomposeState('idle');
+                        setDecomposeSubtasks([]);
+                        setDecomposeTaskId(null);
+                    }, onCancel: () => {
+                        setDecomposeState('idle');
+                        setDecomposeSubtasks([]);
+                        setDecomposeTaskId(null);
+                    } }) })), showDiff && (_jsx(Box, { borderStyle: "single", borderColor: "blue", borderLeft: false, borderRight: false, borderBottom: false, flexShrink: 0, children: _jsx(DiffViewer, { diffView: diffView, cols: cols, maxLines: 18 }) })), showMemory && getLearnings && (_jsx(MemoryViewer, { learnings: getLearnings(), taskTitleById: getTaskTitleById, onClose: () => setShowMemory(false) })), showAudit && getAuditEntries && (_jsx(AuditViewer, { entries: getAuditEntries(), filterText: auditFilter, scrollOffset: auditScroll, onClose: () => {
+                    setShowAudit(false);
+                    setAuditFilter('');
+                    setAuditScroll(0);
+                } })), showGraph && getDependencyGraph && (_jsx(Box, { borderStyle: "single", borderColor: "blue", borderLeft: false, borderRight: false, borderBottom: false, flexShrink: 0, children: _jsx(DependencyGraph, { tasks: state.tasks, graph: getDependencyGraph(), focusedId: graphFocusedId, onFocus: setGraphFocusedId, onSelect: (taskId) => {
+                        setShowGraph(false);
+                        // Focus the task in the task queue
+                        const todoTasks = state.tasks.filter((t) => (t.status === 'todo' || t.status === 'blocked') && !t.title.startsWith('HUMANO:'));
+                        const idx = todoTasks.findIndex((t) => t.id === taskId);
+                        if (idx >= 0) {
+                            setTaskIndex(idx);
+                            setActiveArea('tasks');
+                        }
+                    }, onExit: () => setShowGraph(false) }) })), _jsx(CommandPalette, { visible: showPalette, commands: paletteCommands, onExecute: onPaletteExecute, onDismiss: () => setShowPalette(false) }), _jsx(Box, { flexShrink: 0, children: _jsx(ApprovalTerminal, { requests: state.pendingApprovals, selectedIndex: approvalIndex, yoloMode: state.yoloMode, cols: cols }) }), showFeed && (_jsx(Box, { flexShrink: 1, overflow: "hidden", borderStyle: "single", borderColor: "gray", borderLeft: false, borderRight: false, borderBottom: false, children: _jsx(ActivityFeed, { tasks: state.tasks, resolvedApprovals: state.resolvedApprovals, scrollOffset: feedOffset, isActive: activeArea === 'activity' }) })), skipFeedback && (_jsx(Box, { flexShrink: 0, paddingX: 1, children: _jsxs(Text, { color: "yellow", children: ["\u26A0 ", skipFeedback] }) })), _jsx(Box, { flexShrink: 0, children: _jsx(Footer, { trustLevel: trustLevel, factoryMode: state.factoryMode, yoloMode: state.yoloMode, showHelp: showHelp, sandboxEnabled: state.sandboxEnabled }) })] }));
+}
+//# sourceMappingURL=app.js.map