@kenkaiiii/ggcoder 4.3.204 → 4.3.206

package/dist/ui/App.js

@@ -25,15 +25,17 @@ import { StreamingArea } from "./components/StreamingArea.js";
 import { ActivityIndicator } from "./components/ActivityIndicator.js";
 import { InputArea } from "./components/InputArea.js";
 import { Footer } from "./components/Footer.js";
+import { GoalStatusBar, reconcileGoalStatusEntriesWithRuns, removeGoalStatusEntry, syncGoalStatusEntries, } from "./components/GoalStatusBar.js";
 import { Banner } from "./components/Banner.js";
 import { PlanOverlay } from "./components/PlanOverlay.js";
 import { ModelSelector } from "./components/ModelSelector.js";
 import { TaskOverlay } from "./components/TaskOverlay.js";
+import { GoalOverlay } from "./components/GoalOverlay.js";
 import { PixelOverlay } from "./components/PixelOverlay.js";
 import { SkillsOverlay } from "./components/SkillsOverlay.js";
 import { EyesOverlay } from "./components/EyesOverlay.js";
 import { ThemeSelector } from "./components/ThemeSelector.js";
-import { BackgroundTasksBar } from "./components/BackgroundTasksBar.js";
+import { BackgroundTasksBar, getFooterStatusLayoutDecision, } from "./components/BackgroundTasksBar.js";
 import { useTheme, useSetTheme } from "./theme/theme.js";
 import { useTerminalTitle } from "./hooks/useTerminalTitle.js";
 import { getGitBranch } from "../utils/git.js";
@@ -57,6 +59,10 @@ import { getLatestUserText, injectRepoMapContextMessages, stripRepoMapContextMes
 import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, segmentDisplayText, stripDoneMarkers, } from "../utils/plan-steps.js";
 import { getMCPServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd, flushOverflow, } from "./live-item-flush.js";
+import { appendGoalDecision, appendGoalEvidence, formatGoalBlockingPrerequisites, goalHasBlockingPrerequisites, loadGoalRuns, reconcileActiveGoalRuns, projectDir, summarizeGoalCounts, summarizeGoalCountsFromRuns, updateGoalTask, upsertGoalRun, } from "../core/goal-store.js";
+import { canCompleteGoalRun, decideGoalNextAction, shouldCreateVerifierFixTask, } from "../core/goal-controller.js";
+import { listGoalWorkers, startGoalWorker, stopGoalWorker, subscribeGoalWorkerCompletions, } from "../core/goal-worker.js";
+import { formatGoalVerifierCompletionEvent, formatGoalWorkerCompletionEvent, isGoalSyntheticEvent, parseGoalSyntheticEvent, } from "./goal-events.js";
 /** Where ggcoder bugs should be reported. Surfaced in the guidance line. */
 const GGCODER_BUG_REPORT_URL = "github.com/kenkaiiii/gg-framework/issues";
 /**
@@ -114,6 +120,77 @@ function compactHistory(items) {
     }
     return compacted;
 }
+function summarizeGoalCompletion(summary) {
+    const lines = summary
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && line !== "[agent_done]");
+    const statusLine = lines.find((line) => /^Status:/i.test(line));
+    const changedLine = lines.find((line) => /^(Changed|Implemented|Fixed|Added|Key findings|Full verifier)/i.test(line));
+    const verificationLine = lines.find((line) => /^(Verification|Verified|Result):/i.test(line));
+    return statusLine ?? changedLine ?? verificationLine ?? lines[0];
+}
+function formatGoalWorkerFinishedTitle(taskTitle, status) {
+    return status === "done"
+        ? `Worker finished: ${taskTitle}. Reporting back.`
+        : `Worker failed: ${taskTitle}. Reporting back.`;
+}
+export function formatGoalTerminalProgress(run) {
+    switch (run.status) {
+        case "passed":
+            return {
+                kind: "goal_progress",
+                phase: "terminal",
+                title: `Goal passed: ${run.title}`,
+                detail: "Verifier evidence is recorded; auto-continuation stopped.",
+                status: run.status,
+            };
+        case "failed":
+            return {
+                kind: "goal_progress",
+                phase: "terminal",
+                title: `Goal failed: ${run.title}`,
+                detail: "Auto-continuation stopped. Check Goal tasks for the failing step.",
+                status: run.status,
+            };
+        case "blocked":
+            return {
+                kind: "goal_progress",
+                phase: "terminal",
+                title: `Goal blocked: ${run.title}`,
+                detail: goalHasBlockingPrerequisites(run)
+                    ? formatGoalBlockingPrerequisites(run)
+                    : (run.blockers[0] ?? "A prerequisite or missing verifier blocked progress."),
+                status: run.status,
+            };
+        case "paused":
+            return {
+                kind: "goal_progress",
+                phase: "terminal",
+                title: `Goal paused: ${run.title}`,
+                detail: run.blockers[0] ?? "Auto-continuation paused.",
+                status: run.status,
+            };
+        case "draft":
+        case "ready":
+        case "running":
+        case "verifying":
+            return null;
+    }
+}
+export function shouldHideHistoryForOverlayView(isOverlayView, isAgentRunning) {
+    // Overlay panes should be clean, full-screen views like Tasks/Plans/Skills.
+    // When the agent is idle, pane open/close goes through resetUI(), so history
+    // remains in sessionStore and is reprinted after the pane closes. While the
+    // agent is running we keep Static mounted because resetUI would abort the run.
+    return isOverlayView && !isAgentRunning;
+}
+export function getScrollStabilizationDecision({ isUserScrolled, hasNewOutput, }) {
+    return {
+        preserveStatic: isUserScrolled && hasNewOutput,
+        autoFollow: !isUserScrolled,
+    };
+}
 // flushOnTurnText, flushOnTurnEnd are imported from ./live-item-flush.ts
 /** Check whether an item is still active (running spinner, pending result). */
 function isActiveItem(item) {
@@ -311,12 +388,16 @@ export function App(props) {
         }
         return [{ kind: "banner", id: "banner" }];
     });
-    // Items from the current/last turn — rendered in the live area so they stay visible
-    const [liveItems, setLiveItems] = useState([]);
+    // Items from the current/last turn — rendered in the live area so they stay visible.
+    // Seed from sessionStore so Goal progress/completion rows and other live output
+    // survive pane/overlay/resize remounts before they are flushed to <Static>.
+    const [liveItems, setLiveItems] = useState(() => props.sessionStore?.liveItems ?? []);
     // overlay seeded from sessionStore (lives across remount). Falls back to
     // props.initialOverlay (CLI launched with one), then null.
     const [overlay, setOverlay] = useState(props.sessionStore?.overlay ?? props.initialOverlay ?? null);
     const [taskCount, setTaskCount] = useState(() => getTaskCount(props.cwd));
+    const [goalCount, setGoalCount] = useState(0);
+    const [goalStatusEntries, setGoalStatusEntries] = useState(props.sessionStore?.goalStatusEntries ?? []);
     const [eyesCount, setEyesCount] = useState(() => isEyesActive(props.cwd) ? journalCount({ status: "open" }, props.cwd) : undefined);
     const [updatePending, setUpdatePending] = useState(() => getPendingUpdate(props.version) !== null);
     // Seed from sessionStore so "Run All" chaining survives the resetUI()
@@ -324,6 +405,10 @@ export function App(props) {
     const [runAllTasks, setRunAllTasks] = useState(props.sessionStore?.runAllTasks ?? false);
     const runAllTasksRef = useRef(props.sessionStore?.runAllTasks ?? false);
     const startTaskRef = useRef(() => { });
+    const agentRunningRef = useRef(false);
+    const runningGoalIdsRef = useRef(new Set());
+    const activeVerifierRunIdsRef = useRef(new Set());
+    const startGoalRunRef = useRef(() => { });
     const runAllPixelRef = useRef(props.sessionStore?.runAllPixel ?? false);
     const currentPixelFixRef = useRef(null);
     const startPixelFixRef = useRef(() => { });
@@ -363,9 +448,12 @@ export function App(props) {
     // previous mount, triggering React's duplicate-key warning and causing
     // duplicate/omitted renders.
     const nextIdRef = useRef((() => {
-        const hist = props.sessionStore?.history ?? props.initialHistory ?? [];
+        const items = [
+            ...(props.sessionStore?.history ?? props.initialHistory ?? []),
+            ...(props.sessionStore?.liveItems ?? []),
+        ];
         let max = -1;
-        for (const item of hist) {
+        for (const item of items) {
             const n = Number(item.id);
             if (Number.isFinite(n) && n > max)
                 max = n;
@@ -401,7 +489,27 @@ export function App(props) {
      * language-detection path when this cwd has never been audited before.
      */
     const triggerAutoSetupRef = useRef(async () => { });
-    const getId = () => String(nextIdRef.current++);
+    const getId = () => `ui-${nextIdRef.current++}`;
+    const appendGoalProgress = useCallback((item) => {
+        setLiveItems((prev) => [...prev, { ...item, id: getId() }]);
+    }, []);
+    const goalNumberForRun = useCallback((runId) => Math.max(1, goalStatusEntries.findIndex((entry) => entry.runId === runId) + 1), [goalStatusEntries]);
+    const clearGoalStatusEntry = useCallback((runId) => {
+        setGoalStatusEntries((prev) => {
+            const next = removeGoalStatusEntry(prev, runId);
+            if (props.sessionStore)
+                props.sessionStore.goalStatusEntries = next;
+            return next;
+        });
+    }, [props.sessionStore]);
+    const upsertGoalStatusEntry = useCallback((entry) => {
+        setGoalStatusEntries((prev) => {
+            const next = syncGoalStatusEntries(prev, entry);
+            if (props.sessionStore)
+                props.sessionStore.goalStatusEntries = next;
+            return next;
+        });
+    }, [props.sessionStore]);
     // Two-phase flush: items waiting to be moved to Static history after the
     // live area has been cleared and Ink has committed the smaller output.
     const pendingFlushRef = useRef([]);
@@ -411,8 +519,12 @@ export function App(props) {
         if (items.length === 0)
             return;
         pendingFlushRef.current = [...pendingFlushRef.current, ...items];
+        if (props.sessionStore) {
+            const queuedIds = new Set(items.map((item) => item.id));
+            props.sessionStore.liveItems = (props.sessionStore.liveItems ?? []).filter((item) => !queuedIds.has(item.id));
+        }
         setFlushGeneration((g) => g + 1);
-    }, []);
+    }, [props.sessionStore]);
     // Mirror runtime state choices (model/provider/thinking) into renderApp's
     // closure so unmount/remount preserves them.
     const onRuntimeStateChange = props.onRuntimeStateChange;
@@ -436,6 +548,10 @@ export function App(props) {
         if (sessionStore)
             sessionStore.history = history;
     }, [history, sessionStore]);
+    useEffect(() => {
+        if (sessionStore)
+            sessionStore.liveItems = liveItems;
+    }, [liveItems, sessionStore]);
     useEffect(() => {
         if (sessionStore)
             sessionStore.planSteps = planSteps;
@@ -448,6 +564,10 @@ export function App(props) {
         if (sessionStore)
             sessionStore.overlay = overlay;
     }, [overlay, sessionStore]);
+    useEffect(() => {
+        if (sessionStore)
+            sessionStore.goalStatusEntries = goalStatusEntries;
+    }, [goalStatusEntries, sessionStore]);
     // pendingAction is consumed via a useEffect AFTER agentLoop is created
     // — see below where useAgentLoop is set up.
     const pendingActionConsumedRef = useRef(false);
@@ -463,6 +583,36 @@ export function App(props) {
     useEffect(() => {
         getGitBranch(displayedCwd).then(setGitBranch);
     }, [displayedCwd]);
+    useEffect(() => {
+        let cancelled = false;
+        const refreshGoalCount = () => {
+            void reconcileActiveGoalRuns(props.cwd, {
+                isWorkerActive: (workerId) => listGoalWorkers(props.cwd).some((worker) => worker.id === workerId && worker.status === "running"),
+            }).then(({ runs }) => {
+                const counts = summarizeGoalCountsFromRuns(runs);
+                if (cancelled)
+                    return;
+                setGoalCount(counts.active);
+                setGoalStatusEntries((prev) => {
+                    const next = reconcileGoalStatusEntriesWithRuns(prev, runs, {
+                        isWorkerActive: (workerId, run) => listGoalWorkers(props.cwd).some((worker) => worker.id === workerId &&
+                            worker.goalRunId === run.id &&
+                            worker.status === "running"),
+                        isVerifierActive: (run) => activeVerifierRunIdsRef.current.has(run.id),
+                    });
+                    if (props.sessionStore)
+                        props.sessionStore.goalStatusEntries = next;
+                    return next;
+                });
+            });
+        };
+        refreshGoalCount();
+        const interval = setInterval(refreshGoalCount, 1000);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+        };
+    }, [props.cwd]);
     // Periodic update check during long sessions
     useEffect(() => {
         startPeriodicUpdateCheck(props.version, (msg) => {
@@ -712,7 +862,8 @@ export function App(props) {
             });
         }
     }, [props.settingsFile]);
-    const compactConversation = useCallback(async (messages) => {
+    const compactionAbortRef = useRef(null);
+    const compactConversation = useCallback(async (messages, signal) => {
         const contextWindow = getContextWindow(currentModel, contextWindowOptions);
         const tokensBefore = estimateConversationTokens(messages);
         const spinId = getId();
@@ -723,6 +874,10 @@ export function App(props) {
         });
         // Show animated spinner
         setLiveItems((prev) => [...prev, { kind: "compacting", id: spinId }]);
+        const ownedAbort = signal ? null : new AbortController();
+        const compactionSignal = signal ?? ownedAbort?.signal;
+        if (ownedAbort)
+            compactionAbortRef.current = ownedAbort;
         try {
             // Resolve fresh credentials for compaction too
             let compactApiKey = activeApiKey;
@@ -744,7 +899,7 @@ export function App(props) {
                 projectId: compactProjectId,
                 baseUrl: compactBaseUrl,
                 contextWindow,
-                signal: undefined,
+                signal: compactionSignal,
                 approvedPlanPath: approvedPlanPathRef.current,
             });
             if (result.result.compacted) {
@@ -769,10 +924,16 @@ export function App(props) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            log("ERROR", "compaction", `Compaction failed: ${msg}`);
-            // Replace spinner with error
-            setLiveItems((prev) => prev.map((item) => item.id === spinId ? toErrorItem(err, spinId, "Compaction failed") : item));
-            return messages; // Return unchanged on failure
+            const isAbort = compactionSignal?.aborted || msg.includes("aborted") || msg.includes("abort");
+            log(isAbort ? "WARN" : "ERROR", "compaction", isAbort ? "Compaction aborted" : `Compaction failed: ${msg}`);
+            setLiveItems((prev) => isAbort
+                ? prev.filter((item) => item.id !== spinId)
+                : prev.map((item) => item.id === spinId ? toErrorItem(err, spinId, "Compaction failed") : item));
+            return messages; // Return unchanged on failure/abort
+        }
+        finally {
+            if (ownedAbort && compactionAbortRef.current === ownedAbort)
+                compactionAbortRef.current = null;
         }
     }, [
         currentModel,
@@ -1414,6 +1575,11 @@ export function App(props) {
                     }
                 }, 500);
             }
+            // Goal loop: after the orchestrator handles a worker/verifier event,
+            // continue the same Goal automatically until it reaches a terminal state.
+            for (const runId of [...runningGoalIdsRef.current]) {
+                setTimeout(() => continueGoalRun(runId), 500);
+            }
             // Pixel fix: observe branch + commits, patch status, optionally pick
             // up the next open error if run-all is active.
             const pendingFix = currentPixelFixRef.current;
@@ -1500,13 +1666,34 @@ export function App(props) {
         }, []),
         onQueuedStart: useCallback((content) => {
             // When a queued message starts processing, show it as a UserItem
-            // and flush prior items to history
+            // and flush prior items to history. Synthetic system events are hidden
+            // from the transcript but still routed through the main agent context.
             const displayText = typeof content === "string"
                 ? content
                 : content
                     .filter((c) => c.type === "text")
                     .map((c) => c.text)
                     .join("\n");
+            if (isGoalSyntheticEvent(displayText)) {
+                const eventInfo = parseGoalSyntheticEvent(displayText);
+                setLiveItems((prev) => {
+                    if (prev.length > 0)
+                        queueFlush(prev);
+                    return [];
+                });
+                setDoneStatus(null);
+                appendGoalProgress({
+                    kind: "goal_progress",
+                    phase: "orchestrator_reviewing",
+                    title: "Orchestrator reviewing Goal update",
+                    detail: eventInfo?.kind === "worker"
+                        ? `Worker ${eventInfo.worker ?? "finished"} reported back${eventInfo.task ? ` on ${eventInfo.task}` : ""}. Inspecting Goal state.`
+                        : `Verifier reported ${eventInfo?.status ?? "status"}. Inspecting evidence and next action.`,
+                    workerId: eventInfo?.worker,
+                    status: eventInfo?.status,
+                });
+                return;
+            }
             const imageCount = typeof content === "string"
                 ? undefined
                 : content.filter((c) => c.type === "image").length || undefined;
@@ -1605,7 +1792,14 @@ export function App(props) {
         if (pendingFlushRef.current.length > 0) {
             const items = pendingFlushRef.current;
             pendingFlushRef.current = [];
-            setHistory((h) => compactHistory([...h, ...trimFlushedItems(items)]));
+            setHistory((h) => {
+                const next = compactHistory([...h, ...trimFlushedItems(items)]);
+                if (sessionStore)
+                    sessionStore.history = next;
+                return next;
+            });
+            if (sessionStore)
+                sessionStore.liveItems = liveItems;
         }
     }, [flushGeneration]);
     // Sync terminal title with agent loop state
@@ -1698,11 +1892,15 @@ export function App(props) {
         }
         // Handle /compact — compact conversation
         if (trimmed === "/compact" || trimmed === "/c") {
-            const compacted = await compactConversation(messagesRef.current);
-            if (compacted !== messagesRef.current) {
+            const ac = new AbortController();
+            compactionAbortRef.current = ac;
+            const compacted = await compactConversation(messagesRef.current, ac.signal);
+            if (!ac.signal.aborted && compacted !== messagesRef.current) {
                 messagesRef.current = compacted;
                 await persistCompactedSession(compacted);
             }
+            if (compactionAbortRef.current === ac)
+                compactionAbortRef.current = null;
             return;
         }
         // Handle /quit — exit the agent
@@ -1847,6 +2045,27 @@ export function App(props) {
             ]);
             return;
         }
+        // Handle /goals — open goal pane
+        if (trimmed === "/goals") {
+            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
+                props.sessionStore.overlay = "goal";
+                props.sessionStore.planAutoExpand = false;
+                props.resetUI();
+            }
+            else {
+                stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+                setStaticKey((key) => key + 1);
+                if (props.sessionStore) {
+                    props.sessionStore.overlay = "goal";
+                    props.sessionStore.planAutoExpand = false;
+                    if (agentLoop.isRunning)
+                        props.sessionStore.pendingResetUI = true;
+                }
+                setPlanAutoExpand(false);
+                setOverlay("goal");
+            }
+            return;
+        }
         // Handle /plans — open plan pane
         if (trimmed === "/plans") {
             if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
@@ -2045,6 +2264,9 @@ export function App(props) {
             agentLoop.clearQueue();
             agentLoop.abort();
         }
+        else if (compactionAbortRef.current) {
+            compactionAbortRef.current.abort();
+        }
         else {
             handleDoubleExit();
         }
@@ -2175,6 +2397,7 @@ export function App(props) {
         };
         const promptOrder = [
             // Project audits / one-shot analysis
+            "goal",
             "init",
             "research",
             "scan",
@@ -2220,11 +2443,29 @@ export function App(props) {
             case "tombstone":
                 return null;
             case "banner":
-                return (_jsx(Banner, { version: props.version, model: currentModel, provider: currentProvider, cwd: displayedCwd, taskCount: taskCount }, item.id));
+                return (_jsx(Banner, { version: props.version, model: currentModel, provider: currentProvider, cwd: displayedCwd, taskCount: taskCount, goalCount: goalCount }, item.id));
             case "user":
                 return (_jsx(UserMessage, { text: item.text, imageCount: item.imageCount, pasteInfo: item.pasteInfo }, item.id));
             case "task":
                 return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.success, bold: true, children: "▶ " }), _jsx(Text, { color: theme.textDim, children: "Task: " }), _jsx(Text, { color: theme.success, children: item.title })] }) }, item.id));
+            case "goal":
+                return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.success, bold: true, children: "▶ " }), _jsx(Text, { color: theme.textDim, children: "Goal: " }), _jsx(Text, { color: theme.success, children: item.title }), item.workerId ? _jsxs(Text, { color: theme.textDim, children: [" \u00B7 worker ", item.workerId] }) : null] }) }, item.id));
+            case "goal_progress": {
+                const isError = item.status === "failed" || item.status === "fail" || item.status === "blocked";
+                const color = item.phase === "terminal" && !isError
+                    ? theme.success
+                    : isError
+                        ? theme.warning
+                        : theme.primary;
+                const glyph = item.phase === "worker_finished" || item.phase === "verifier_finished"
+                    ? "✓ "
+                    : item.phase === "terminal"
+                        ? item.status === "passed"
+                            ? "◆ "
+                            : "! "
+                        : "↻ ";
+                return (_jsxs(Box, { marginTop: 1, flexDirection: "column", flexShrink: 1, children: [_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: color, bold: true, children: glyph }), _jsx(Text, { color: color, bold: true, children: item.title }), item.workerId ? _jsxs(Text, { color: theme.textDim, children: [" \u00B7 worker ", item.workerId] }) : null] }), item.detail ? (_jsx(Text, { color: theme.textDim, wrap: "wrap", children: `  ${item.detail}` })) : null] }, item.id));
+            }
             case "style_pack": {
                 const names = item.added.map((id) => LANGUAGE_DISPLAY_NAMES[id]);
                 const headerLabel = item.added.length > 1 ? "STYLE PACKS ACTIVE" : "STYLE PACK ACTIVE";
@@ -2380,13 +2621,602 @@ export function App(props) {
         currentProvider,
         currentModel,
     ]);
+    const openOverlay = useCallback((kind) => {
+        if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
+            props.sessionStore.overlay = kind;
+            if (kind !== "plan")
+                props.sessionStore.planAutoExpand = false;
+            props.resetUI();
+        }
+        else {
+            if (props.sessionStore) {
+                props.sessionStore.overlay = kind;
+                if (kind !== "plan")
+                    props.sessionStore.planAutoExpand = false;
+                if (agentLoop.isRunning)
+                    props.sessionStore.pendingResetUI = true;
+            }
+            if (kind !== "plan")
+                setPlanAutoExpand(false);
+            setOverlay(kind);
+        }
+    }, [agentLoop.isRunning, props, stdout]);
+    const closeOverlay = useCallback(() => {
+        if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
+            props.sessionStore.overlay = null;
+            props.resetUI();
+        }
+        else {
+            if (props.sessionStore) {
+                props.sessionStore.overlay = null;
+                if (agentLoop.isRunning)
+                    props.sessionStore.pendingResetUI = true;
+            }
+            setOverlay(null);
+        }
+    }, [agentLoop.isRunning, overlay, props, stdout]);
+    const runGoalSyntheticEvent = useCallback((eventText) => {
+        const eventInfo = parseGoalSyntheticEvent(eventText);
+        const detail = eventInfo?.kind === "worker"
+            ? `Inspecting worker result${eventInfo.task ? ` for ${eventInfo.task}` : ""}.`
+            : `Inspecting verifier result${eventInfo?.status ? ` (${eventInfo.status})` : ""}.`;
+        if (agentRunningRef.current) {
+            appendGoalProgress({
+                kind: "goal_progress",
+                phase: "orchestrator_reviewing",
+                title: "Goal update queued for orchestrator",
+                detail: `${detail} It will report back after the current turn.`,
+                workerId: eventInfo?.worker,
+                status: eventInfo?.status,
+            });
+            agentLoop.queueMessage(eventText);
+            return;
+        }
+        appendGoalProgress({
+            kind: "goal_progress",
+            phase: "orchestrator_reviewing",
+            title: "Orchestrator reviewing Goal update",
+            detail,
+            workerId: eventInfo?.worker,
+            status: eventInfo?.status,
+        });
+        setLastUserMessage("");
+        setDoneStatus(null);
+        void agentLoop.run(eventText).catch((err) => {
+            log("ERROR", "goal", err instanceof Error ? err.message : String(err));
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal")]);
+        });
+    }, [agentLoop, appendGoalProgress]);
+    const continueGoalRun = useCallback((runId) => {
+        void (async () => {
+            const latestRun = await reconcileActiveGoalRuns(props.cwd, {
+                isWorkerActive: (workerId) => listGoalWorkers(props.cwd).some((worker) => worker.id === workerId && worker.status === "running"),
+            }).then(({ runs }) => runs.find((item) => item.id === runId) ?? null);
+            if (!latestRun) {
+                runningGoalIdsRef.current.delete(runId);
+                clearGoalStatusEntry(runId);
+                return;
+            }
+            const decision = decideGoalNextAction(latestRun);
+            if (decision.kind === "wait")
+                return;
+            if (decision.kind === "terminal" ||
+                decision.kind === "blocked" ||
+                decision.kind === "pause") {
+                const status = decision.kind === "terminal"
+                    ? decision.status
+                    : decision.kind === "blocked"
+                        ? "blocked"
+                        : "paused";
+                const nextRun = {
+                    ...latestRun,
+                    status,
+                    continueRequestedAt: undefined,
+                    blockers: decision.kind === "blocked" || decision.kind === "pause"
+                        ? Array.from(new Set([...latestRun.blockers, decision.reason]))
+                        : latestRun.blockers,
+                };
+                await upsertGoalRun(props.cwd, nextRun);
+                await appendGoalDecision(props.cwd, latestRun.id, {
+                    kind: "continuation_stopped",
+                    reason: decision.reason,
+                    content: `terminal=${status}`,
+                });
+                const terminalProgress = formatGoalTerminalProgress(nextRun);
+                if (terminalProgress)
+                    appendGoalProgress(terminalProgress);
+                runningGoalIdsRef.current.delete(runId);
+                clearGoalStatusEntry(runId);
+                return;
+            }
+            let runForNextAction = latestRun;
+            if (latestRun.continueRequestedAt &&
+                !listGoalWorkers(props.cwd).some((worker) => worker.status === "running") &&
+                activeVerifierRunIdsRef.current.size === 0) {
+                await appendGoalDecision(props.cwd, latestRun.id, {
+                    kind: "continuation_consumed",
+                    reason: `Continuation request consumed by ${decision.kind}.`,
+                });
+                runForNextAction = await upsertGoalRun(props.cwd, {
+                    ...latestRun,
+                    continueRequestedAt: undefined,
+                });
+            }
+            appendGoalProgress({
+                kind: "goal_progress",
+                phase: "continuing",
+                title: `Continuing Goal: ${latestRun.title}`,
+                detail: "Starting the next worker task or verifier step automatically.",
+                status: latestRun.status,
+            });
+            upsertGoalStatusEntry({
+                runId: latestRun.id,
+                label: latestRun.title,
+                phase: "orchestrating",
+                startedAt: Date.now(),
+                detail: "choosing next step",
+            });
+            startGoalRunRef.current(runForNextAction);
+        })().catch((err) => {
+            runningGoalIdsRef.current.delete(runId);
+            clearGoalStatusEntry(runId);
+            log("ERROR", "goal", err instanceof Error ? err.message : String(err));
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal")]);
+        });
+    }, [appendGoalProgress, clearGoalStatusEntry, props.cwd, upsertGoalStatusEntry]);
+    const handleGoalWorkerComplete = useCallback((run, completion) => {
+        const taskTitle = run.tasks.find((task) => task.id === completion.worker.goalTaskId)?.title ??
+            completion.worker.goalTaskId;
+        const eventText = formatGoalWorkerCompletionEvent(run, taskTitle, completion);
+        void summarizeGoalCounts(completion.worker.cwd).then((counts) => setGoalCount(counts.active));
+        appendGoalProgress({
+            kind: "goal_progress",
+            phase: "worker_finished",
+            title: formatGoalWorkerFinishedTitle(taskTitle, completion.status),
+            detail: summarizeGoalCompletion(completion.summary),
+            workerId: completion.worker.id,
+            status: completion.status,
+        });
+        upsertGoalStatusEntry({
+            runId: run.id,
+            label: taskTitle,
+            phase: completion.status === "done" ? "reviewing" : "failed",
+            startedAt: Date.now(),
+            detail: completion.status === "done" ? "reviewing result" : "task failed",
+            workerId: completion.worker.id,
+            goalNumber: goalNumberForRun(run.id),
+        });
+        runGoalSyntheticEvent(eventText);
+        void (async () => {
+            if (listGoalWorkers(completion.worker.cwd).some((worker) => worker.status === "running"))
+                return;
+            if (activeVerifierRunIdsRef.current.size > 0)
+                return;
+            const runs = await loadGoalRuns(completion.worker.cwd);
+            const queued = runs.find((item) => item.continueRequestedAt && !goalHasBlockingPrerequisites(item));
+            if (queued)
+                setTimeout(() => continueGoalRun(queued.id), 750);
+        })().catch((err) => log("ERROR", "goal", err instanceof Error ? err.message : String(err)));
+    }, [
+        appendGoalProgress,
+        continueGoalRun,
+        goalNumberForRun,
+        runGoalSyntheticEvent,
+        upsertGoalStatusEntry,
+    ]);
+    useEffect(() => {
+        return subscribeGoalWorkerCompletions((completion) => {
+            void (async () => {
+                const latestRun = (await loadGoalRuns(completion.worker.cwd)).find((item) => item.id === completion.worker.goalRunId) ?? null;
+                if (!latestRun) {
+                    log("WARN", "goal", `Worker completion for unknown Goal ${completion.worker.goalRunId}`);
+                    return;
+                }
+                runningGoalIdsRef.current.add(latestRun.id);
+                handleGoalWorkerComplete(latestRun, completion);
+            })().catch((err) => {
+                log("ERROR", "goal", err instanceof Error ? err.message : String(err));
+                setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal")]);
+            });
+        }, props.cwd);
+    }, [handleGoalWorkerComplete, props.cwd]);
+    const startGoalRun = useCallback((run) => {
+        runningGoalIdsRef.current.add(run.id);
+        void (async () => {
+            if (goalHasBlockingPrerequisites(run)) {
+                setOverlay(null);
+                const detail = formatGoalBlockingPrerequisites(run);
+                await upsertGoalRun(props.cwd, {
+                    ...run,
+                    status: "blocked",
+                    blockers: Array.from(new Set([...run.blockers, detail])),
+                });
+                setGoalCount((await summarizeGoalCounts(props.cwd)).active);
+                appendGoalProgress({
+                    kind: "goal_progress",
+                    phase: "terminal",
+                    title: `Goal blocked: ${run.title}`,
+                    detail,
+                    status: "blocked",
+                });
+                runningGoalIdsRef.current.delete(run.id);
+                clearGoalStatusEntry(run.id);
+                return;
+            }
+            const decision = decideGoalNextAction(run);
+            await appendGoalDecision(props.cwd, run.id, decision);
+            if (decision.kind === "terminal") {
+                const terminalProgress = formatGoalTerminalProgress(run);
+                if (terminalProgress)
+                    appendGoalProgress(terminalProgress);
+                runningGoalIdsRef.current.delete(run.id);
+                clearGoalStatusEntry(run.id);
+                return;
+            }
+            if (decision.kind === "wait") {
+                appendGoalProgress({
+                    kind: "goal_progress",
+                    phase: "worker_started",
+                    title: decision.workerId ? `Goal working: ${run.title}` : `Goal active: ${run.title}`,
+                    detail: decision.reason,
+                    workerId: decision.workerId,
+                });
+                upsertGoalStatusEntry({
+                    runId: run.id,
+                    label: run.title,
+                    phase: decision.workerId ? "worker" : "orchestrating",
+                    startedAt: Date.now(),
+                    detail: decision.reason,
+                    workerId: decision.workerId,
+                    goalNumber: goalNumberForRun(run.id),
+                });
+                return;
+            }
+            if (decision.kind === "complete") {
+                await upsertGoalRun(props.cwd, { ...run, status: "passed" });
+                setGoalCount((await summarizeGoalCounts(props.cwd)).active);
+                appendGoalProgress({
+                    kind: "goal_progress",
+                    phase: "terminal",
+                    title: `Goal passed: ${run.title}`,
+                    detail: decision.reason,
+                    status: "passed",
+                });
+                runningGoalIdsRef.current.delete(run.id);
+                clearGoalStatusEntry(run.id);
+                return;
+            }
+            if (decision.kind === "run_verifier") {
+                await verifyGoalRun(run);
+                return;
+            }
+            if (decision.kind === "create_task") {
+                await updateGoalTask(props.cwd, run.id, `auto-${Date.now()}`, {
+                    title: decision.title,
+                    prompt: decision.prompt,
+                    status: "pending",
+                });
+                const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
+                await upsertGoalRun(props.cwd, { ...latestRun, status: "ready" });
+                setTimeout(() => continueGoalRun(run.id), 250);
+                return;
+            }
+            if (decision.kind === "blocked") {
+                await upsertGoalRun(props.cwd, {
+                    ...run,
+                    status: "blocked",
+                    blockers: [...run.blockers, decision.reason],
+                });
+                setGoalCount((await summarizeGoalCounts(props.cwd)).active);
+                appendGoalProgress({
+                    kind: "goal_progress",
+                    phase: "terminal",
+                    title: `Goal blocked: ${run.title}`,
+                    detail: decision.reason,
+                    status: "blocked",
+                });
+                runningGoalIdsRef.current.delete(run.id);
+                clearGoalStatusEntry(run.id);
+                return;
+            }
+            if (decision.kind === "pause") {
+                await updateGoalTask(props.cwd, run.id, decision.task.id, {
+                    status: "blocked",
+                    attempts: decision.attempts,
+                    lastSummary: "Paused after worker attempt limit.",
+                });
+                await upsertGoalRun(props.cwd, {
+                    ...run,
+                    status: "paused",
+                    blockers: [...run.blockers, decision.reason],
+                });
+                await appendGoalEvidence(props.cwd, run.id, {
+                    kind: "summary",
+                    label: "Goal paused",
+                    content: decision.reason,
+                });
+                setGoalCount((await summarizeGoalCounts(props.cwd)).active);
+                appendGoalProgress({
+                    kind: "goal_progress",
+                    phase: "terminal",
+                    title: `Goal paused: ${run.title}`,
+                    detail: decision.reason,
+                    status: "paused",
+                });
+                runningGoalIdsRef.current.delete(run.id);
+                clearGoalStatusEntry(run.id);
+                return;
+            }
+            await updateGoalTask(props.cwd, run.id, decision.task.id, { attempts: decision.attempts });
+            const worker = await startGoalWorker({
+                cwd: props.cwd,
+                provider: currentProvider,
+                model: currentModel,
+                goalRunId: run.id,
+                goalTaskId: decision.task.id,
+                prompt: decision.task.prompt,
+            });
+            await upsertGoalRun(props.cwd, {
+                ...run,
+                status: "running",
+                activeWorkerId: worker.id,
+                continueRequestedAt: undefined,
+            });
+            setOverlay(null);
+            setGoalCount((await summarizeGoalCounts(props.cwd)).active);
+            appendGoalProgress({
+                kind: "goal_progress",
+                phase: "worker_started",
+                title: `Worker started: ${decision.task.title}`,
+                detail: "Task is running in the background.",
+                workerId: worker.id,
+                status: worker.status,
+            });
+            upsertGoalStatusEntry({
+                runId: run.id,
+                label: decision.task.title,
+                phase: "worker",
+                startedAt: Date.now(),
+                detail: "background worker running",
+                workerId: worker.id,
+                goalNumber: goalNumberForRun(run.id),
+            });
+        })().catch((err) => {
+            clearGoalStatusEntry(run.id);
+            log("ERROR", "goal", err instanceof Error ? err.message : String(err));
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal")]);
+        });
+    }, [
+        props.cwd,
+        currentProvider,
+        currentModel,
+        appendGoalProgress,
+        clearGoalStatusEntry,
+        goalNumberForRun,
+        upsertGoalStatusEntry,
+    ]);
+    const verifyGoalRun = useCallback(async (run) => {
+        if (!run.verifier?.command) {
+            await appendGoalEvidence(props.cwd, run.id, {
+                kind: "summary",
+                label: "Missing verifier",
+                content: "No verifier command is configured.",
+            });
+            await upsertGoalRun(props.cwd, {
+                ...run,
+                status: "blocked",
+                blockers: [...run.blockers, "No verifier command configured."],
+            });
+            appendGoalProgress({
+                kind: "goal_progress",
+                phase: "terminal",
+                title: `Goal blocked: ${run.title}`,
+                detail: "No verifier command is configured.",
+                status: "blocked",
+            });
+            runningGoalIdsRef.current.delete(run.id);
+            clearGoalStatusEntry(run.id);
+            return;
+        }
+        activeVerifierRunIdsRef.current.add(run.id);
+        await upsertGoalRun(props.cwd, {
+            ...run,
+            status: "verifying",
+            continueRequestedAt: undefined,
+        });
+        appendGoalProgress({
+            kind: "goal_progress",
+            phase: "verifier_started",
+            title: `Verifier started: ${run.title}`,
+            detail: run.verifier.command,
+            status: "verifying",
+        });
+        const startedAt = Date.now();
+        const verifierTimeoutMs = Number(process.env.GG_GOAL_VERIFIER_TIMEOUT_MS ?? 10 * 60 * 1000);
+        upsertGoalStatusEntry({
+            runId: run.id,
+            label: run.title,
+            phase: "verifier",
+            startedAt,
+            detail: run.verifier.command,
+            goalNumber: goalNumberForRun(run.id),
+        });
+        const { spawn } = await import("node:child_process");
+        const { mkdir, writeFile } = await import("node:fs/promises");
+        const { join } = await import("node:path");
+        const logDir = join(projectDir(props.cwd), "verifiers");
+        await mkdir(logDir, { recursive: true });
+        const outputPath = join(logDir, `${run.id}-${startedAt}.log`);
+        const child = spawn(run.verifier.command, {
+            cwd: props.cwd,
+            shell: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env },
+        });
+        let output = "";
+        child.stdout?.on("data", (chunk) => {
+            output += chunk.toString("utf-8");
+            if (output.length > 20_000)
+                output = output.slice(output.length - 20_000);
+        });
+        child.stderr?.on("data", (chunk) => {
+            output += chunk.toString("utf-8");
+            if (output.length > 20_000)
+                output = output.slice(output.length - 20_000);
+        });
+        let verifierSettled = false;
+        let timedOut = false;
+        const timeout = verifierTimeoutMs > 0
+            ? setTimeout(() => {
+                timedOut = true;
+                if (child.pid)
+                    child.kill("SIGTERM");
+                const killTimer = setTimeout(() => {
+                    if (!verifierSettled && child.pid)
+                        child.kill("SIGKILL");
+                }, 5000);
+                killTimer.unref?.();
+                finishVerifier(124, `Verifier timed out after ${verifierTimeoutMs}ms and was terminated.\n${output}`);
+            }, verifierTimeoutMs)
+            : undefined;
+        timeout?.unref?.();
+        const finishVerifier = (code, forcedOutput) => {
+            if (verifierSettled)
+                return;
+            verifierSettled = true;
+            if (timeout)
+                clearTimeout(timeout);
+            activeVerifierRunIdsRef.current.delete(run.id);
+            void (async () => {
+                const status = code === 0 ? "pass" : "fail";
+                const failureClass = timedOut
+                    ? "verifier_timeout"
+                    : forcedOutput?.startsWith("Verifier process error:")
+                        ? "verifier_spawn_error"
+                        : status === "fail"
+                            ? "verifier_failure"
+                            : "verifier_pass";
+                const summary = (forcedOutput ?? output).trim() ||
+                    (code === 0 ? "Verifier passed." : "Verifier failed.");
+                const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
+                await writeFile(outputPath, summary + "\n", "utf-8");
+                const runWithVerifier = {
+                    ...latestRun,
+                    verifier: {
+                        ...latestRun.verifier,
+                        description: latestRun.verifier?.description ?? "Goal verifier",
+                        command: run.verifier?.command,
+                        lastResult: {
+                            status,
+                            summary,
+                            command: run.verifier?.command,
+                            exitCode: code ?? 1,
+                            outputPath,
+                            checkedAt: new Date().toISOString(),
+                        },
+                    },
+                };
+                const completionCheck = canCompleteGoalRun(runWithVerifier);
+                const verifiedRun = await upsertGoalRun(props.cwd, {
+                    ...runWithVerifier,
+                    continueRequestedAt: undefined,
+                    status: status === "pass" && completionCheck.ok
+                        ? "passed"
+                        : status === "pass"
+                            ? "ready"
+                            : "failed",
+                });
+                await appendGoalEvidence(props.cwd, run.id, {
+                    kind: "command",
+                    label: `Verifier ${status}`,
+                    content: `${failureClass}: ${summary}`.slice(0, 4000),
+                    path: outputPath,
+                });
+                await appendGoalDecision(props.cwd, run.id, {
+                    kind: `verifier_${status}`,
+                    reason: `${failureClass}: verifier exited with code ${code ?? 1}.`,
+                    content: `outputPath=${outputPath}; durationMs=${Date.now() - startedAt}`,
+                });
+                if (status === "fail" && shouldCreateVerifierFixTask(latestRun)) {
+                    await updateGoalTask(props.cwd, run.id, `fix-${Date.now()}`, {
+                        title: "Fix verifier failure",
+                        prompt: `Goal verifier failed after ${Date.now() - startedAt}ms. Original goal: ${run.goal}\n\n` +
+                            `Verifier command: ${run.verifier?.command}\n\n` +
+                            `Failure output:\n${summary.slice(-6000)}\n\nFix the cause, record evidence with the goals tool, and rerun relevant verification.`,
+                        status: "pending",
+                    });
+                    const runWithPendingFix = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? latestRun;
+                    await upsertGoalRun(props.cwd, { ...runWithPendingFix, status: "ready" });
+                }
+                setGoalCount((await summarizeGoalCounts(props.cwd)).active);
+                appendGoalProgress({
+                    kind: "goal_progress",
+                    phase: "verifier_finished",
+                    title: `Verifier ${status}: ${run.title}`,
+                    detail: summarizeGoalCompletion(summary),
+                    status,
+                });
+                upsertGoalStatusEntry({
+                    runId: run.id,
+                    label: run.title,
+                    phase: status === "pass" ? "reviewing" : "failed",
+                    startedAt: Date.now(),
+                    detail: status === "pass" ? "reviewing verifier evidence" : "verifier failed",
+                    goalNumber: goalNumberForRun(run.id),
+                });
+                const eventText = formatGoalVerifierCompletionEvent(verifiedRun, status, run.verifier?.command ?? "", code ?? 1, summary);
+                runGoalSyntheticEvent(eventText);
+                const continuationRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id);
+                if (continuationRun?.continueRequestedAt && status === "pass") {
+                    setTimeout(() => continueGoalRun(run.id), 500);
+                }
+            })().catch((err) => {
+                clearGoalStatusEntry(run.id);
+                log("ERROR", "goal", err instanceof Error ? err.message : String(err));
+                setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal verifier")]);
+            });
+        };
+        child.on("close", (code) => finishVerifier(code));
+        child.on("error", (err) => finishVerifier(1, `Verifier process error: ${err.message}`));
+    }, [
+        props.cwd,
+        appendGoalProgress,
+        clearGoalStatusEntry,
+        goalNumberForRun,
+        runGoalSyntheticEvent,
+        upsertGoalStatusEntry,
+    ]);
+    const pauseGoalRun = useCallback((run) => {
+        void (async () => {
+            runningGoalIdsRef.current.delete(run.id);
+            if (run.activeWorkerId)
+                await stopGoalWorker(run.activeWorkerId);
+            await upsertGoalRun(props.cwd, { ...run, status: "paused", activeWorkerId: undefined });
+            setGoalCount((await summarizeGoalCounts(props.cwd)).active);
+            appendGoalProgress({
+                kind: "goal_progress",
+                phase: "terminal",
+                title: `Goal paused: ${run.title}`,
+                detail: "Auto-continuation stopped until resumed.",
+                status: "paused",
+            });
+            clearGoalStatusEntry(run.id);
+        })().catch((err) => {
+            log("ERROR", "goal", err instanceof Error ? err.message : String(err));
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal")]);
+        });
+    }, [appendGoalProgress, clearGoalStatusEntry, props.cwd]);
     // Keep refs in sync for access from stale closures (onDone)
     startTaskRef.current = startTask;
+    startGoalRunRef.current = startGoalRun;
     useEffect(() => {
         runAllTasksRef.current = runAllTasks;
         if (props.sessionStore)
             props.sessionStore.runAllTasks = runAllTasks;
     }, [runAllTasks, props.sessionStore]);
+    useEffect(() => {
+        agentRunningRef.current = agentLoop.isRunning;
+    }, [agentLoop.isRunning]);
     const startPixelFix = useCallback((errorId) => {
         void (async () => {
             try {
@@ -2487,12 +3317,20 @@ export function App(props) {
             props.sessionStore.runAllPixel = runAllPixel;
     }, [runAllPixel, props.sessionStore]);
     const isTaskView = overlay === "tasks";
+    const isGoalView = overlay === "goal";
     const isSkillsView = overlay === "skills";
     const isPlanView = overlay === "plan";
     const isEyesView = overlay === "eyes";
+    const footerStatusLayout = getFooterStatusLayoutDecision({
+        columns,
+        backgroundTaskCount: bgTasks.length,
+        eyesCount,
+        updatePending,
+    });
     const isPixelView = overlay === "pixel";
-    const isOverlayView = isTaskView || isSkillsView || isPlanView || isEyesView || isPixelView;
-    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(Static, { items: isOverlayView && !agentLoop.isRunning ? [] : history, style: { width: "100%" }, children: (item) => (_jsx(Box, { flexDirection: "column", paddingRight: 1, children: renderItem(item) }, item.id)) }, `${resizeKey}-${staticKey}`), isTaskView ? (_jsx(TaskOverlay, { cwd: props.cwd, agentRunning: agentLoop.isRunning, onClose: () => {
+    const isOverlayView = isTaskView || isGoalView || isSkillsView || isPlanView || isEyesView || isPixelView;
+    const shouldHideHistoryForOverlay = shouldHideHistoryForOverlayView(isOverlayView, agentLoop.isRunning);
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(Static, { items: shouldHideHistoryForOverlay ? [] : history, style: { width: "100%" }, children: (item) => (_jsx(Box, { flexDirection: "column", paddingRight: 1, children: renderItem(item) }, item.id)) }, `${resizeKey}-${staticKey}`), isTaskView ? (_jsx(TaskOverlay, { cwd: props.cwd, agentRunning: agentLoop.isRunning, onClose: () => {
                     if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                         props.sessionStore.overlay = null;
                         props.resetUI();
@@ -2517,6 +3355,16 @@ export function App(props) {
                         markTaskInProgress(props.cwd, next.id);
                         startTask(next.title, next.prompt, next.id);
                     }
+                } })) : isGoalView ? (_jsx(GoalOverlay, { cwd: props.cwd, agentRunning: agentLoop.isRunning, onClose: () => {
+                    void summarizeGoalCounts(props.cwd).then((counts) => setGoalCount(counts.active));
+                    closeOverlay();
+                }, onRunGoal: (run) => {
+                    setOverlay(null);
+                    startGoalRun(run);
+                }, onVerifyGoal: (run) => {
+                    void verifyGoalRun(run);
+                }, onPauseGoal: (run) => {
+                    pauseGoalRun(run);
                 } })) : isPixelView ? (_jsx(PixelOverlay, { version: props.version, agentRunning: agentLoop.isRunning, onClose: () => {
                     if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
                         props.sessionStore.overlay = null;
@@ -2698,44 +3546,13 @@ export function App(props) {
                             // live-area transition (chat input → TaskOverlay) natively, and
                             // the chat history above stays in scrollback. When the overlay
                             // closes, the history is still there (banner included).
-                            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
-                                props.sessionStore.overlay = "tasks";
-                                props.resetUI();
-                            }
-                            else {
-                                if (props.sessionStore) {
-                                    props.sessionStore.overlay = "tasks";
-                                    if (agentLoop.isRunning)
-                                        props.sessionStore.pendingResetUI = true;
-                                }
-                                setOverlay("tasks");
-                            }
+                            openOverlay("tasks");
+                        }, onToggleGoal: () => {
+                            openOverlay("goal");
                         }, onToggleSkills: () => {
-                            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
-                                props.sessionStore.overlay = "skills";
-                                props.resetUI();
-                            }
-                            else {
-                                if (props.sessionStore) {
-                                    props.sessionStore.overlay = "skills";
-                                    if (agentLoop.isRunning)
-                                        props.sessionStore.pendingResetUI = true;
-                                }
-                                setOverlay("skills");
-                            }
+                            openOverlay("skills");
                         }, onTogglePixel: () => {
-                            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
-                                props.sessionStore.overlay = "pixel";
-                                props.resetUI();
-                            }
-                            else {
-                                if (props.sessionStore) {
-                                    props.sessionStore.overlay = "pixel";
-                                    if (agentLoop.isRunning)
-                                        props.sessionStore.pendingResetUI = true;
-                                }
-                                setOverlay("pixel");
-                            }
+                            openOverlay("pixel");
                         }, onTogglePlanMode: () => {
                             const next = !planMode;
                             setPlanMode(next);
@@ -2749,7 +3566,12 @@ export function App(props) {
                                     id: getId(),
                                 },
                             ]);
-                        }, cwd: props.cwd, commands: allCommands, eyesCount: eyesCount }), overlay === "model" ? (_jsx(ModelSelector, { onSelect: handleModelSelect, onCancel: () => setOverlay(null), loggedInProviders: props.loggedInProviders ?? [currentProvider], currentModel: currentModel, currentProvider: currentProvider })) : overlay === "theme" ? (_jsx(ThemeSelector, { onSelect: handleThemeSelect, onCancel: () => setOverlay(null), currentTheme: theme.name })) : (_jsx(Footer, { model: currentModel, tokensIn: agentLoop.contextUsed, contextWindowOptions: contextWindowOptions, cwd: displayedCwd, gitBranch: gitBranch, thinkingLevel: thinkingEnabled ? getMaxThinkingLevel(currentModel) : undefined, planMode: planMode, exitPending: exitPending })), (bgTasks.length > 0 || (eyesCount !== undefined && eyesCount > 0) || updatePending) && (_jsxs(Box, { children: [bgTasks.length > 0 && (_jsx(BackgroundTasksBar, { tasks: bgTasks, focused: taskBarFocused, expanded: taskBarExpanded, selectedIndex: selectedTaskIndex, onExpand: handleTaskBarExpand, onCollapse: handleTaskBarCollapse, onKill: handleTaskKill, onExit: handleTaskBarExit, onNavigate: handleTaskNavigate })), eyesCount !== undefined && eyesCount > 0 && (_jsx(Box, { paddingLeft: bgTasks.length > 0 ? 2 : 1, paddingRight: 1, children: _jsx(Text, { color: theme.accent, bold: true, children: `${eyesCount} eyes signal${eyesCount === 1 ? "" : "s"} · Run /eyes-improve to enhance GG Coder` }) })), updatePending && (_jsx(Box, { paddingLeft: bgTasks.length > 0 || (eyesCount !== undefined && eyesCount > 0) ? 2 : 1, paddingRight: 1, children: _jsx(Text, { color: theme.success, bold: true, children: "\u2728 Update ready \u00B7 restart to apply" }) }))] }))] }))] }));
+                        }, cwd: props.cwd, commands: allCommands, eyesCount: eyesCount }), overlay === "model" ? (_jsx(ModelSelector, { onSelect: handleModelSelect, onCancel: () => setOverlay(null), loggedInProviders: props.loggedInProviders ?? [currentProvider], currentModel: currentModel, currentProvider: currentProvider })) : overlay === "theme" ? (_jsx(ThemeSelector, { onSelect: handleThemeSelect, onCancel: () => setOverlay(null), currentTheme: theme.name })) : (_jsxs(_Fragment, { children: [_jsx(Footer, { model: currentModel, tokensIn: agentLoop.contextUsed, contextWindowOptions: contextWindowOptions, cwd: displayedCwd, gitBranch: gitBranch, thinkingLevel: thinkingEnabled ? getMaxThinkingLevel(currentModel) : undefined, planMode: planMode, exitPending: exitPending }), !exitPending && _jsx(GoalStatusBar, { entries: goalStatusEntries })] })), (footerStatusLayout.hasBackgroundTasks ||
+                        footerStatusLayout.hasEyesSignals ||
+                        footerStatusLayout.hasUpdateNotice) && (_jsxs(Box, { flexDirection: footerStatusLayout.stack ? "column" : "row", width: columns, children: [footerStatusLayout.hasBackgroundTasks && (_jsx(BackgroundTasksBar, { tasks: bgTasks, focused: taskBarFocused, expanded: taskBarExpanded, selectedIndex: selectedTaskIndex, onExpand: handleTaskBarExpand, onCollapse: handleTaskBarCollapse, onKill: handleTaskKill, onExit: handleTaskBarExit, onNavigate: handleTaskNavigate, compact: footerStatusLayout.compactBackgroundTasks })), footerStatusLayout.hasEyesSignals && (_jsx(Box, { paddingLeft: footerStatusLayout.stack || bgTasks.length === 0 ? 1 : 2, paddingRight: 1, children: _jsx(Text, { color: theme.accent, bold: true, wrap: "truncate", children: `${eyesCount} eyes signal${eyesCount === 1 ? "" : "s"} · Run /eyes-improve to enhance GG Coder` }) })), footerStatusLayout.hasUpdateNotice && (_jsx(Box, { paddingLeft: footerStatusLayout.stack ||
+                                    (!footerStatusLayout.hasBackgroundTasks && !footerStatusLayout.hasEyesSignals)
+                                    ? 1
+                                    : 2, paddingRight: 1, children: _jsx(Text, { color: theme.success, bold: true, wrap: "truncate", children: "\u2728 Update ready \u00B7 restart to apply" }) }))] }))] }))] }));
 }
 function formatRepoMapCommandOutput(enabled, markdown, refreshed) {
     const status = enabled ? "on" : "off";