@prestyj/cli 4.3.205 → 4.3.209

package/dist/ui/App.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import React, { useState, useRef, useCallback, useEffect, useMemo } from "react";
-import { Box, Text, Static, useStdout } from "ink";
+import { Box, Text, Static } from "ink";
 import { useTerminalSize } from "./hooks/useTerminalSize.js";
 import { useDoublePress } from "./hooks/useDoublePress.js";
 import { useTaskBarStore, useTaskBarPolling, focusTaskBar, exitTaskBar, expandTaskBar, collapseTaskBar, navigateTaskBar, killTask, } from "./stores/taskbar-store.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,11 @@ 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, summarizeGoalCounts, summarizeGoalCountsFromRuns, updateGoalTask, upsertGoalRun, } from "../core/goal-store.js";
+import { canCompleteGoalRun, decideGoalNextAction, shouldCreateVerifierFixTask, } from "../core/goal-controller.js";
+import { runGoalVerifierCommand } from "../core/goal-verifier.js";
+import { listGoalWorkers, startGoalWorker, stopGoalWorker, subscribeGoalWorkerCompletions, } from "../core/goal-worker.js";
+import { formatGoalVerifierCompletionEvent, formatGoalWorkerCompletionEvent, isGoalSyntheticEvent, parseGoalSyntheticEvent, } from "./goal-events.js";
 /** Where ezcoder bugs should be reported. Surfaced in the guidance line. */
 const GGCODER_BUG_REPORT_URL = "github.com/Gahroot/ezcoder/issues";
 /**
@@ -90,6 +97,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/ezcoder-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 +179,149 @@ 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" ? `Done: ${taskTitle}` : `Failed: ${taskTitle}`;
+}
+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) {
+    // Ink Static is append-only. Passing [] for overlay panes rewrites the Static
+    // accumulator and can destroy scrollback when the pane closes. Keep history
+    // mounted and let overlays render below it.
+    return false;
+}
+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 }) {
+    return `${resizeKey}`;
+}
 // flushOnTurnText, flushOnTurnEnd are imported from ./live-item-flush.ts
 /** Check whether an item is still active (running spinner, pending result). */
 function isActiveItem(item) {
@@ -271,11 +479,29 @@ function markTaskInProgress(cwd, taskId) {
         // ignore
     }
 }
+/**
+ * Mark a task as done in the on-disk tasks.json. Used by run-all auto-advance
+ * so the in-flight task is recorded as completed even when the agent forgets
+ * to call the `tasks` tool. Errors are swallowed — if the file is missing or
+ * the id is stale, the next auto-advance step still proceeds correctly.
+ */
+function markTaskDone(cwd, taskId) {
+    try {
+        const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+        const filePath = join(homedir(), ".ezcoder-tasks", "projects", hash, "tasks.json");
+        const data = readFileSync(filePath, "utf-8");
+        const tasks = JSON.parse(data);
+        const updated = tasks.map((t) => (t.id === taskId ? { ...t, status: "done" } : t));
+        writeFileSync(filePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+    }
+    catch {
+        // ignore
+    }
+}
 // ── App Component ──────────────────────────────────────────
 export function App(props) {
     const theme = useTheme();
     const switchTheme = useSetTheme();
-    const { stdout } = useStdout();
     const { columns, resizeKey } = useTerminalSize();
     // Hoisted before terminal title hook so it can reference them
     const [lastUserMessage, setLastUserMessage] = useState("");
@@ -311,26 +537,38 @@ 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()
     // remount that startTask() triggers between tasks.
     const [runAllTasks, setRunAllTasks] = useState(props.sessionStore?.runAllTasks ?? false);
     const runAllTasksRef = useRef(props.sessionStore?.runAllTasks ?? false);
+    // Task id of the run-all task currently driving the agent. Tracked so the
+    // run-all `onDone` auto-advance can mark the just-finished task as done
+    // even when the agent forgets to call the tasks tool. Mirrored through
+    // sessionStore so the value survives the resetUI() remount between tasks.
+    const currentTaskIdRef = useRef(props.sessionStore?.currentTaskId ?? null);
     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 +601,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 +642,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 +672,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 +701,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 +721,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 +740,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) => {
@@ -619,14 +926,6 @@ export function App(props) {
                 // premature "done" status that fires when the agent loop finishes
                 planOverlayPendingRef.current = true;
                 setTimeout(() => {
-                    // NOTE: this is the one open-overlay path that does NOT remount via
-                    // resetUI. It runs while the agent is still mid-turn (after the
-                    // exit_plan tool returned but before onDone fires), and unmounting
-                    // here would kill the in-flight agent stream. Keep the bare ANSI
-                    // clear; the drift bug is tolerable across just the agent's
-                    // wrap-up turn, and onApprove/onReject both remount cleanly via
-                    // resetUI when the user resolves the plan.
-                    stdout?.write("\x1b[2J\x1b[3J\x1b[H");
                     setPlanAutoExpand(true);
                     setOverlay("plan");
                     // Don't clear planOverlayPendingRef here — keep it true until
@@ -641,7 +940,7 @@ export function App(props) {
                     planPath);
             };
         }
-    }, [props.onExitPlanRef, replaceSystemPrompt, stdout]);
+    }, [props.onExitPlanRef, replaceSystemPrompt]);
     const appendMessagesToSession = useCallback(async (sessionPath, messages, startIndex) => {
         const sm = sessionManagerRef.current;
         if (!sm)
@@ -712,7 +1011,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 +1023,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 +1048,7 @@ export function App(props) {
                 projectId: compactProjectId,
                 baseUrl: compactBaseUrl,
                 contextWindow,
-                signal: undefined,
+                signal: compactionSignal,
                 approvedPlanPath: approvedPlanPathRef.current,
             });
             if (result.result.compacted) {
@@ -769,10 +1073,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,
@@ -1376,7 +1686,7 @@ export function App(props) {
                 return remaining;
             });
         }, []),
-        onDone: useCallback((durationMs, toolsUsed) => {
+        onDone: useCallback((durationMs, toolsUsed, errored) => {
             log("INFO", "agent", `Agent done`, {
                 duration: `${durationMs}ms`,
                 toolsUsed: toolsUsed.join(",") || "none",
@@ -1403,6 +1713,18 @@ export function App(props) {
             if (runAllTasksRef.current) {
                 setTimeout(() => {
                     const cwd = cwdRef.current;
+                    // Clean turn: mark the in-flight task done so the row flips to ✓.
+                    // Error path: leave it at `in-progress` so the failed task is
+                    // visibly distinct from completed ones. The chain still advances
+                    // either way — matching how errors were handled before this fix.
+                    const finishedId = currentTaskIdRef.current;
+                    if (finishedId) {
+                        if (!errored)
+                            markTaskDone(cwd, finishedId);
+                        currentTaskIdRef.current = null;
+                        if (props.sessionStore)
+                            props.sessionStore.currentTaskId = null;
+                    }
                     const next = getNextPendingTask(cwd);
                     if (next) {
                         markTaskInProgress(cwd, next.id);
@@ -1414,6 +1736,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;
@@ -1455,6 +1782,12 @@ export function App(props) {
             setRunAllTasks(false);
             setRunAllPixel(false);
             currentPixelFixRef.current = null;
+            // Clear the run-all task id so a subsequent run-all does not
+            // mistakenly mark this aborted task as done. The on-disk row stays
+            // at `in-progress`, which is the correct truth for an aborted task.
+            currentTaskIdRef.current = null;
+            if (props.sessionStore)
+                props.sessionStore.currentTaskId = null;
             setDoneStatus(null);
             setLiveItems((prev) => {
                 const next = prev.map((item) => {
@@ -1500,13 +1833,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 +1959,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 +2059,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
@@ -1710,14 +2075,10 @@ export function App(props) {
             process.exit(0);
         }
         // Handle /clear — tear down the entire Ink instance and rebuild fresh.
-        // Patching Ink's internal frame tracking in place (log-update reset,
-        // lastOutput cleared, fullStaticOutput dropped, staticKey bump) all
-        // looked correct for one frame but left the live area drifting on
-        // subsequent streaming responses — Ink's cursor math depends on
-        // terminal-state assumptions that ANSI clearing breaks. The reliable
-        // fix is unmount + render again. Runtime state (model, provider,
-        // thinking) survives via renderApp's closure-held `runtimeState`,
-        // mirrored from React state via the useEffects above.
+        // Avoid direct ANSI terminal clears here; they can erase scrollback.
+        // Runtime state (model, provider, thinking) survives via renderApp's
+        // closure-held `runtimeState`, mirrored from React state via the
+        // useEffects above.
         if (trimmed === "/clear") {
             if (props.resetUI) {
                 void (async () => {
@@ -1730,8 +2091,7 @@ export function App(props) {
                 return;
             }
             // Fallback path (resetUI not wired — e.g. tests). Best-effort: clear
-            // React state in place. The Ink-internal drift bug remains here.
-            stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+            // React state in place without touching terminal scrollback.
             pendingFlushRef.current = [];
             setHistory([{ kind: "banner", id: "banner" }]);
             setLiveItems([]);
@@ -1747,7 +2107,6 @@ export function App(props) {
             agentLoop.reset();
             setSessionTitle(undefined);
             sessionTitleGeneratedRef.current = false;
-            setStaticKey((k) => k + 1);
             setLiveItems([{ kind: "info", text: "Session cleared.", id: getId() }]);
             return;
         }
@@ -1847,6 +2206,25 @@ 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 {
+                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 +2245,49 @@ export function App(props) {
             return;
         }
         // Handle prompt-template commands (built-in + custom from .ezcoder/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 +2301,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/ezcoder-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 +2383,9 @@ export function App(props) {
             agentLoop.clearQueue();
             agentLoop.abort();
         }
+        else if (compactionAbortRef.current) {
+            compactionAbortRef.current.abort();
+        }
         else {
             handleDoubleExit();
         }
@@ -2175,6 +2516,7 @@ export function App(props) {
         };
         const promptOrder = [
             // Project audits / one-shot analysis
+            "goal",
             "init",
             "research",
             "scan",
@@ -2220,11 +2562,41 @@ 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 = isError
+                    ? theme.error
+                    : item.phase === "worker_finished"
+                        ? theme.success
+                        : item.phase === "verifier_finished"
+                            ? theme.accent
+                            : item.phase === "orchestrator_reviewing" || item.phase === "orchestrator_working"
+                                ? theme.secondary
+                                : item.phase === "continuing"
+                                    ? theme.warning
+                                    : item.phase === "verifier_started"
+                                        ? theme.accent
+                                        : item.phase === "worker_started"
+                                            ? theme.primary
+                                            : item.phase === "terminal"
+                                                ? theme.success
+                                                : 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";
@@ -2324,8 +2696,14 @@ export function App(props) {
                         // session creation is best-effort
                     }
                 }
-                if (props.sessionStore)
+                if (props.sessionStore) {
                     props.sessionStore.overlay = null;
+                    // Mirror through sessionStore so the post-resetUI remount can
+                    // re-seed the ref. markTaskDone() in the run-all onDone branch
+                    // reads currentTaskIdRef.current, which is seeded from this.
+                    props.sessionStore.currentTaskId = taskId;
+                }
+                currentTaskIdRef.current = taskId;
                 props.resetUI?.({
                     wipeSession: true,
                     messages: newMessages,
@@ -2337,7 +2715,9 @@ export function App(props) {
             return;
         }
         // Fallback path (resetUI not wired — tests).
-        stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+        currentTaskIdRef.current = taskId;
+        if (props.sessionStore)
+            props.sessionStore.currentTaskId = taskId;
         setHistory([{ kind: "banner", id: "banner" }]);
         setLiveItems([]);
         messagesRef.current = messagesRef.current.slice(0, 1);
@@ -2371,22 +2751,553 @@ export function App(props) {
                 setRunAllTasks(false);
             }
         })();
+    }, [props.cwd, props.resetUI, props.sessionStore, agentLoop, 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]);
+    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]);
+    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: `Choosing next Goal step: ${latestRun.title}`,
+                detail: "Latest result is recorded; starting the next worker task or verifier 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,
-        props.resetUI,
-        props.sessionStore,
-        stdout,
-        agentLoop,
         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),
+        });
+        void runGoalVerifierCommand({
+            cwd: props.cwd,
+            runId: run.id,
+            command: run.verifier.command,
+            timeoutMs: verifierTimeoutMs,
+            now: () => startedAt,
+        })
+            .then(async ({ verification, failureClass, durationMs }) => {
+            activeVerifierRunIdsRef.current.delete(run.id);
+            const status = verification.status;
+            const summary = verification.summary;
+            const outputPath = verification.outputPath;
+            const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
+            const runWithVerifier = {
+                ...latestRun,
+                verifier: {
+                    ...latestRun.verifier,
+                    description: latestRun.verifier?.description ?? "Goal verifier",
+                    command: run.verifier?.command,
+                    lastResult: verification,
+                },
+            };
+            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 ${verification.exitCode ?? 1}.`,
+                content: `outputPath=${outputPath ?? ""}; durationMs=${durationMs}`,
+            });
+            if (status === "fail" && shouldCreateVerifierFixTask(latestRun)) {
+                await updateGoalTask(props.cwd, run.id, `fix-${Date.now()}`, {
+                    title: "Fix verifier failure",
+                    prompt: `Goal verifier failed after ${durationMs}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 === "pass" ? "pass" : "fail", run.verifier?.command ?? "", verification.exitCode ?? 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) => {
+            activeVerifierRunIdsRef.current.delete(run.id);
+            clearGoalStatusEntry(run.id);
+            log("ERROR", "goal", err instanceof Error ? err.message : String(err));
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal verifier")]);
+        });
+    }, [
+        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)
+        if (props.sessionStore) {
             props.sessionStore.runAllTasks = runAllTasks;
+            // Keep currentTaskId in sync with the ref so a sessionStore-seeded
+            // remount picks up the same value the imperative sites wrote.
+            props.sessionStore.currentTaskId = currentTaskIdRef.current;
+        }
     }, [runAllTasks, props.sessionStore]);
+    useEffect(() => {
+        agentRunningRef.current = agentLoop.isRunning;
+    }, [agentLoop.isRunning]);
     const startPixelFix = useCallback((errorId) => {
         void (async () => {
             try {
@@ -2437,14 +3348,10 @@ export function App(props) {
                     activeLanguages: detectedForPixelFix,
                     tools: toolsForPixelFix,
                 });
-                // Now that the cwd swap is committed, reset chat. Doing this BEFORE
-                // the chdir would print a banner with the old cwd, then bumping
-                // staticKey would print a second banner with the new cwd — leaving
-                // two banners stacked in the scrollback.
-                stdout?.write("\x1b[2J\x1b[3J\x1b[H");
+                // Now that the cwd swap is committed, reset chat. Do not clear the
+                // terminal here; terminal clear sequences can erase saved scrollback.
                 setHistory([{ kind: "banner", id: "banner" }]);
                 setLiveItems([]);
-                setStaticKey((k) => k + 1);
                 messagesRef.current = messagesRef.current.slice(0, 1);
                 agentLoop.reset();
                 persistedIndexRef.current = messagesRef.current.length;
@@ -2476,7 +3383,7 @@ export function App(props) {
                 setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
             }
         })();
-    }, [props.cwd, stdout, agentLoop, currentProvider, currentModel]);
+    }, [props.cwd, agentLoop, currentProvider, currentModel]);
     startPixelFixRef.current = startPixelFix;
     // Seed from sessionStore so "Fix All" chaining survives a deferred
     // resetUI() if it fires between pixel fixes (e.g. user toggled a pane).
@@ -2487,12 +3394,30 @@ 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,
+    });
+    const staticItems = shouldHideStaticItemsForOverlayView({
+        shouldHideHistoryForOverlay,
+        stabilizeOverlayPaneRerender,
+    })
+        ? []
+        : history;
+    return (_jsxs(Box, { flexDirection: "column", width: columns, children: [_jsx(Static, { items: staticItems, style: { width: "100%" }, children: (item) => (_jsx(Box, { flexDirection: "column", paddingRight: 1, children: renderItem(item) }, item.id)) }, getStaticHistoryKey({ resizeKey })), 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 +3442,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;
@@ -2632,10 +3567,8 @@ export function App(props) {
                             approvedPlanPathRef.current = planPath;
                             planStepsRef.current = steps;
                             setPlanSteps(steps);
-                            stdout?.write("\x1b[2J\x1b[3J\x1b[H");
                             setHistory([{ kind: "banner", id: "banner" }]);
                             setLiveItems([]);
-                            setStaticKey((k) => k + 1);
                             setPlanAutoExpand(false);
                             setOverlay(null);
                             messagesRef.current = [{ role: "system", content: newPrompt }];
@@ -2676,8 +3609,6 @@ export function App(props) {
                         });
                         return;
                     }
-                    stdout?.write("\x1b[2J\x1b[3J\x1b[H");
-                    setStaticKey((k) => k + 1);
                     setPlanAutoExpand(false);
                     setOverlay(null);
                     setDoneStatus(null);
@@ -2692,50 +3623,17 @@ export function App(props) {
                     });
                 } })) : (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingRight: 1, children: [liveItems.map((item) => renderItem(item)), _jsx(StreamingArea, { isRunning: agentLoop.isRunning, streamingText: agentLoop.streamingText, streamingThinking: agentLoop.streamingThinking, thinkingMs: agentLoop.thinkingMs, planMode: planMode })] }), agentLoop.isRunning && agentLoop.activityPhase !== "idle" ? (_jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: agentLoop.activityPhase === "thinking" ? THINKING_BORDER_COLORS[0] : "transparent", paddingLeft: 1, paddingRight: 1, width: columns, children: _jsx(ActivityIndicator, { phase: agentLoop.activityPhase, elapsedMs: agentLoop.elapsedMs, runStartRef: agentLoop.runStartRef, thinkingMs: agentLoop.thinkingMs, isThinking: agentLoop.isThinking, thinkingEnabled: thinkingEnabled, tokenEstimate: agentLoop.streamedTokenEstimate, charCountRef: agentLoop.charCountRef, realTokensAccumRef: agentLoop.realTokensAccumRef, userMessage: lastUserMessage, activeToolNames: agentLoop.activeToolCalls.map((tc) => tc.name), planMode: planMode, retryInfo: agentLoop.retryInfo, planDone: planSteps.filter((s) => s.completed).length, planTotal: planSteps.length, staticDisplay: true }) })) : agentLoop.stallError ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.warning, children: "⚠ API provider stream interrupted — retries exhausted." }), _jsx(Text, { color: theme.textDim, children: "  Your conversation is preserved. Send a message to continue." })] })) : (doneStatus &&
                         !agentLoop.isRunning && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.success, children: ["✻ ", doneStatus.verb, " ", formatDuration(doneStatus.durationMs)] }) }))), agentLoop.queuedCount > 0 && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.accent, children: ["⏳ ", agentLoop.queuedCount, " message", agentLoop.queuedCount > 1 ? "s" : "", " queued"] }) })), _jsx(InputArea, { onSubmit: handleSubmit, onAbort: handleAbort, disabled: agentLoop.isRunning, isActive: !taskBarFocused && !overlay, onDownAtEnd: handleFocusTaskBar, onShiftTab: handleToggleThinking, onToggleTasks: () => {
-                            // While the agent is running, skip the screen-clear + staticKey
-                            // bump that would otherwise wipe the chat history from scrollback.
                             // Just flip the overlay state — Ink's log-update handles the
                             // 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 +3647,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 EZ 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 EZ 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";