@kenkaiiii/ggcoder 4.3.205 → 4.3.207

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";
 /**
@@ -90,6 +96,64 @@ function toErrorItem(err, id, contextPrefix) {
         id,
     };
 }
+export function routePromptCommandInput(input, promptCommands = PROMPT_COMMANDS, customCommands = []) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const parts = trimmed.slice(1).split(" ");
+    const cmdName = parts[0];
+    const cmdArgs = parts.slice(1).join(" ").trim();
+    const builtinCmd = promptCommands.find((c) => c.name === cmdName || c.aliases.includes(cmdName));
+    const customCmd = !builtinCmd ? customCommands.find((c) => c.name === cmdName) : undefined;
+    const promptText = builtinCmd?.prompt ?? customCmd?.prompt;
+    if (!promptText)
+        return null;
+    return {
+        cmdName,
+        cmdArgs,
+        promptText,
+        fullPrompt: cmdArgs ? `${promptText}\n\n## User Instructions\n\n${cmdArgs}` : promptText,
+    };
+}
+export function buildUserContentWithAttachments(text, inputImages, modelSupportsImages) {
+    if (inputImages.length === 0)
+        return text;
+    const parts = [];
+    if (text) {
+        parts.push({ type: "text", text });
+    }
+    for (const img of inputImages) {
+        if (img.kind === "text") {
+            parts.push({
+                type: "text",
+                text: `<file name="${img.fileName}">\n${img.data}\n</file>`,
+            });
+        }
+        else if (modelSupportsImages) {
+            parts.push({ type: "image", mediaType: img.mediaType, data: img.data });
+        }
+        else {
+            // GLM models: save image to temp file and instruct model to use vision MCP tool
+            const ext = img.mediaType.split("/")[1] ?? "png";
+            const tmpPath = `/tmp/ggcoder-img-${Date.now()}.${ext}`;
+            try {
+                writeFileSync(tmpPath, Buffer.from(img.data, "base64"));
+                parts.push({
+                    type: "text",
+                    text: `[User attached an image saved at: ${tmpPath} — use the image_analysis tool to view and analyze it]`,
+                });
+            }
+            catch {
+                parts.push({
+                    type: "text",
+                    text: `[User attached an image but it could not be saved for analysis]`,
+                });
+            }
+        }
+    }
+    // If only text parts remain after stripping images, simplify to plain string
+    return parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts;
+}
 /** Tools that get aggregated into a single compact group when concurrent. */
 const AGGREGATABLE_TOOLS = new Set(["read", "grep", "find", "ls"]);
 const RUNNING_INDICATOR_ANIMATION_MS = 1_200;
@@ -114,6 +178,152 @@ 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.`;
+}
+function countGoalTasksByStatus(tasks, status) {
+    return tasks.filter((task) => task.status === status).length;
+}
+function firstText(values) {
+    return values.find((value) => value !== undefined && value.trim().length > 0)?.trim();
+}
+function truncateGoalSummary(value, maxLength = 90) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 1)}…`;
+}
+export function buildGoalSummaryRows(run) {
+    const rows = [];
+    const doneTasks = countGoalTasksByStatus(run.tasks, "done");
+    const failedTasks = countGoalTasksByStatus(run.tasks, "failed");
+    const blockedTasks = countGoalTasksByStatus(run.tasks, "blocked");
+    const taskSuffix = [
+        failedTasks > 0 ? `${failedTasks} failed` : undefined,
+        blockedTasks > 0 ? `${blockedTasks} blocked` : undefined,
+    ].filter((item) => item !== undefined);
+    rows.push({
+        label: "Tasks",
+        value: run.tasks.length > 0 ? `${doneTasks}/${run.tasks.length} done` : "none",
+        ...(taskSuffix.length > 0 ? { detail: taskSuffix.join(", ") } : {}),
+    });
+    const verifierResult = run.verifier?.lastResult;
+    const verifierDetail = firstText([verifierResult?.outputPath, run.verifier?.command]);
+    rows.push({
+        label: "Verifier",
+        value: verifierResult?.status ?? (run.verifier?.command ? "ready" : "missing"),
+        ...(verifierDetail ? { detail: truncateGoalSummary(verifierDetail) } : {}),
+    });
+    const latestEvidence = run.evidence.at(-1);
+    rows.push({
+        label: "Evidence",
+        value: `${run.evidence.length} recorded`,
+        ...(latestEvidence
+            ? { detail: truncateGoalSummary(latestEvidence.path ?? latestEvidence.label) }
+            : {}),
+    });
+    if (run.status === "blocked" || run.status === "paused" || run.blockers.length > 0) {
+        rows.push({
+            label: run.status === "paused" ? "Paused on" : "Blocked on",
+            value: truncateGoalSummary(goalHasBlockingPrerequisites(run)
+                ? formatGoalBlockingPrerequisites(run)
+                : (run.blockers[0] ?? "manual review"), 110),
+        });
+    }
+    else if (run.successCriteria.length > 0) {
+        rows.push({
+            label: "Criteria",
+            value: `${run.successCriteria.length} checked`,
+            detail: truncateGoalSummary(run.successCriteria[0] ?? "", 80),
+        });
+    }
+    return rows.slice(0, 4);
+}
+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.",
+                summaryRows: buildGoalSummaryRows(run),
+                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.",
+                summaryRows: buildGoalSummaryRows(run),
+                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."),
+                summaryRows: buildGoalSummaryRows(run),
+                status: run.status,
+            };
+        case "paused":
+            return {
+                kind: "goal_progress",
+                phase: "terminal",
+                title: `Goal paused: ${run.title}`,
+                detail: run.blockers[0] ?? "Auto-continuation paused.",
+                summaryRows: buildGoalSummaryRows(run),
+                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 shouldStabilizeOverlayPaneRerender({ overlayPane, isAgentRunning, }) {
+    return isAgentRunning && (overlayPane === "goal" || overlayPane === "plan");
+}
+export function shouldHideStaticItemsForOverlayView({ shouldHideHistoryForOverlay, stabilizeOverlayPaneRerender, }) {
+    return shouldHideHistoryForOverlay && !stabilizeOverlayPaneRerender;
+}
+export function getScrollStabilizationDecision({ isUserScrolled, hasNewOutput, hasTallLiveUserMessage = false, }) {
+    const shouldStabilize = isUserScrolled || hasTallLiveUserMessage;
+    return {
+        preserveStatic: shouldStabilize && hasNewOutput,
+        autoFollow: !shouldStabilize,
+    };
+}
+export function isTallLiveUserMessage(text, rows) {
+    return text.split("\n").length > Math.max(8, Math.floor(rows * 0.6));
+}
+export function getStaticHistoryKey({ resizeKey, staticKey, }) {
+    return `${resizeKey}-${staticKey}`;
+}
 // 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 +521,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,13 +538,17 @@ 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(() => { });
     const cwdRef = useRef(props.cwd);
     const [displayedCwd, setDisplayedCwd] = useState(props.cwd);
     const [staticKey, setStaticKey] = useState(0);
-    const [doneStatus, setDoneStatus] = useState(null);
+    const [doneStatus, setDoneStatus] = useState(props.sessionStore?.doneStatus ?? null);
     // Suppress "done" status when a plan overlay is about to open
     const planOverlayPendingRef = useRef(false);
     const [gitBranch, setGitBranch] = useState(null);
@@ -363,9 +581,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 +622,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 +652,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 +681,14 @@ export function App(props) {
         if (sessionStore)
             sessionStore.history = history;
     }, [history, sessionStore]);
+    useEffect(() => {
+        if (sessionStore)
+            sessionStore.liveItems = liveItems;
+    }, [liveItems, sessionStore]);
+    useEffect(() => {
+        if (sessionStore)
+            sessionStore.doneStatus = doneStatus;
+    }, [doneStatus, sessionStore]);
     useEffect(() => {
         if (sessionStore)
             sessionStore.planSteps = planSteps;
@@ -448,6 +701,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 +720,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 +999,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 +1011,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 +1036,7 @@ export function App(props) {
                 projectId: compactProjectId,
                 baseUrl: compactBaseUrl,
                 contextWindow,
-                signal: undefined,
+                signal: compactionSignal,
                 approvedPlanPath: approvedPlanPathRef.current,
             });
             if (result.result.compacted) {
@@ -769,10 +1061,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 +1712,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 +1803,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 +1929,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 +2029,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 +2182,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) {
@@ -1867,49 +2223,49 @@ export function App(props) {
             return;
         }
         // Handle prompt-template commands (built-in + custom from .gg/commands/)
-        if (trimmed.startsWith("/")) {
-            const parts = trimmed.slice(1).split(" ");
-            const cmdName = parts[0];
-            const cmdArgs = parts.slice(1).join(" ").trim();
-            const builtinCmd = getPromptCommand(cmdName);
-            const customCmd = !builtinCmd ? customCommands.find((c) => c.name === cmdName) : undefined;
-            const promptText = builtinCmd?.prompt ?? customCmd?.prompt;
-            if (promptText) {
-                log("INFO", "command", `Prompt command: /${cmdName}${cmdArgs ? ` (args: ${cmdArgs})` : ""}`);
-                // Move live items into history before starting
-                setLiveItems((prev) => {
-                    if (prev.length > 0) {
-                        pendingFlushRef.current = [...pendingFlushRef.current, ...prev];
-                    }
-                    return [];
-                });
-                // Show the command name as the user message
-                const userItem = { kind: "user", text: trimmed, id: getId() };
-                setLastUserMessage(trimmed);
-                setDoneStatus(null);
-                setLiveItems([userItem]);
-                // Send the full prompt to the agent, with user args appended if provided
-                const fullPrompt = cmdArgs
-                    ? `${promptText}\n\n## User Instructions\n\n${cmdArgs}`
-                    : promptText;
-                try {
-                    await agentLoop.run(fullPrompt);
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    log("ERROR", "error", msg);
-                    const isAbort = msg.includes("aborted") || msg.includes("abort");
-                    setLiveItems((prev) => [
-                        ...prev,
-                        isAbort
-                            ? { kind: "stopped", text: "Request was stopped.", id: getId() }
-                            : toErrorItem(err, getId()),
-                    ]);
+        const promptCommandRoute = routePromptCommandInput(trimmed, PROMPT_COMMANDS, customCommands);
+        if (promptCommandRoute) {
+            const { cmdName, cmdArgs, fullPrompt } = promptCommandRoute;
+            log("INFO", "command", `Prompt command: /${cmdName}${cmdArgs ? ` (args: ${cmdArgs})` : ""}`);
+            // Move live items into history before starting
+            setLiveItems((prev) => {
+                if (prev.length > 0) {
+                    pendingFlushRef.current = [...pendingFlushRef.current, ...prev];
                 }
-                // Reload custom commands in case a setup command created new ones
-                reloadCustomCommands();
-                return;
+                return [];
+            });
+            const hasImages = inputImages.length > 0;
+            const modelInfo = getModel(currentModel);
+            const modelSupportsImages = modelInfo?.supportsImages ?? true;
+            const userContent = buildUserContentWithAttachments(fullPrompt, inputImages, modelSupportsImages);
+            // Show the typed command as the user message
+            const userItem = {
+                kind: "user",
+                text: trimmed,
+                imageCount: hasImages ? inputImages.length : undefined,
+                id: getId(),
+            };
+            setLastUserMessage(trimmed);
+            setDoneStatus(null);
+            setLiveItems([userItem]);
+            // Send the full prompt to the agent, with user args appended if provided
+            try {
+                await agentLoop.run(userContent);
             }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                log("ERROR", "error", msg);
+                const isAbort = msg.includes("aborted") || msg.includes("abort");
+                setLiveItems((prev) => [
+                    ...prev,
+                    isAbort
+                        ? { kind: "stopped", text: "Request was stopped.", id: getId() }
+                        : toErrorItem(err, getId()),
+                ]);
+            }
+            // Reload custom commands in case a setup command created new ones
+            reloadCustomCommands();
+            return;
         }
         // Check slash commands
         if (props.onSlashCommand && input.startsWith("/")) {
@@ -1923,47 +2279,7 @@ export function App(props) {
         const hasImages = inputImages.length > 0;
         const modelInfo = getModel(currentModel);
         const modelSupportsImages = modelInfo?.supportsImages ?? true;
-        let userContent;
-        if (hasImages) {
-            const parts = [];
-            if (trimmed) {
-                parts.push({ type: "text", text: trimmed });
-            }
-            for (const img of inputImages) {
-                if (img.kind === "text") {
-                    parts.push({
-                        type: "text",
-                        text: `<file name="${img.fileName}">\n${img.data}\n</file>`,
-                    });
-                }
-                else if (modelSupportsImages) {
-                    parts.push({ type: "image", mediaType: img.mediaType, data: img.data });
-                }
-                else {
-                    // GLM models: save image to temp file and instruct model to use vision MCP tool
-                    const ext = img.mediaType.split("/")[1] ?? "png";
-                    const tmpPath = `/tmp/ggcoder-img-${Date.now()}.${ext}`;
-                    try {
-                        writeFileSync(tmpPath, Buffer.from(img.data, "base64"));
-                        parts.push({
-                            type: "text",
-                            text: `[User attached an image saved at: ${tmpPath} — use the image_analysis tool to view and analyze it]`,
-                        });
-                    }
-                    catch {
-                        parts.push({
-                            type: "text",
-                            text: `[User attached an image but it could not be saved for analysis]`,
-                        });
-                    }
-                }
-            }
-            // If only text parts remain after stripping images, simplify to plain string
-            userContent = parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts;
-        }
-        else {
-            userContent = input;
-        }
+        const userContent = buildUserContentWithAttachments(input, inputImages, modelSupportsImages);
         // ── Queue message if agent is already running ──
         if (agentLoop.isRunning) {
             log("INFO", "queue", `Queued message: ${trimmed.length > 80 ? trimmed.slice(0, 80) + "..." : trimmed}`);
@@ -2045,6 +2361,9 @@ export function App(props) {
             agentLoop.clearQueue();
             agentLoop.abort();
         }
+        else if (compactionAbortRef.current) {
+            compactionAbortRef.current.abort();
+        }
         else {
             handleDoubleExit();
         }
@@ -2175,6 +2494,7 @@ export function App(props) {
         };
         const promptOrder = [
             // Project audits / one-shot analysis
+            "goal",
             "init",
             "research",
             "scan",
@@ -2220,11 +2540,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.summaryRows && item.summaryRows.length > 0 ? (_jsx(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, flexShrink: 1, children: item.summaryRows.map((row) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Text, { color: theme.textDim, children: row.label.padEnd(10) }), _jsx(Text, { color: theme.text, children: row.value }), row.detail ? _jsxs(Text, { color: theme.textDim, children: [" \u00B7 ", row.detail] }) : null] }, row.label))) })) : 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 +2718,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 && kind !== "goal" && kind !== "plan") {
+                    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;
+            }
+            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,
+                taskTitle: decision.task.title,
+                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 +3414,29 @@ 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);
+    const stabilizeOverlayPaneRerender = shouldStabilizeOverlayPaneRerender({
+        overlayPane: overlay,
+        isAgentRunning: agentLoop.isRunning,
+    });
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(Static, { items: shouldHideStaticItemsForOverlayView({
+                    shouldHideHistoryForOverlay,
+                    stabilizeOverlayPaneRerender,
+                })
+                    ? []
+                    : history, style: { width: "100%" }, children: (item) => (_jsx(Box, { flexDirection: "column", paddingRight: 1, children: renderItem(item) }, item.id)) }, getStaticHistoryKey({ 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 +3461,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 +3652,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 +3672,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";