@prestyj/cli 4.3.207 → 4.3.210

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";
@@ -59,8 +59,9 @@ 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 { 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. */
@@ -189,9 +190,7 @@ function summarizeGoalCompletion(summary) {
     return statusLine ?? changedLine ?? verificationLine ?? lines[0];
 }
 function formatGoalWorkerFinishedTitle(taskTitle, status) {
-    return status === "done"
-        ? `Worker finished: ${taskTitle}. Reporting back.`
-        : `Worker failed: ${taskTitle}. Reporting back.`;
+    return status === "done" ? `Done: ${taskTitle}` : `Failed: ${taskTitle}`;
 }
 function countGoalTasksByStatus(tasks, status) {
     return tasks.filter((task) => task.status === status).length;
@@ -298,12 +297,11 @@ export function formatGoalTerminalProgress(run) {
             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 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");
@@ -321,8 +319,8 @@ export function getScrollStabilizationDecision({ isUserScrolled, hasNewOutput, h
 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}`;
+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). */
@@ -481,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("");
@@ -537,6 +553,11 @@ export function App(props) {
     // 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());
@@ -547,7 +568,6 @@ export function App(props) {
     const startPixelFixRef = useRef(() => { });
     const cwdRef = useRef(props.cwd);
     const [displayedCwd, setDisplayedCwd] = useState(props.cwd);
-    const [staticKey, setStaticKey] = useState(0);
     const [doneStatus, setDoneStatus] = useState(props.sessionStore?.doneStatus ?? null);
     // Suppress "done" status when a plan overlay is about to open
     const planOverlayPendingRef = useRef(false);
@@ -906,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
@@ -928,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)
@@ -1674,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",
@@ -1701,17 +1713,43 @@ 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);
+                        // startTaskRef.current() re-sets taskRunningRef = true before
+                        // the next agent run begins, so the brief clear-then-set is
+                        // safe — the agent isn't running in between.
                         startTaskRef.current(next.title, next.prompt, next.id);
                     }
                     else {
                         setRunAllTasks(false);
+                        if (props.taskRunningRef)
+                            props.taskRunningRef.current = false;
                         log("INFO", "tasks", "Run-all complete — no more pending tasks");
                     }
                 }, 500);
             }
+            else if (currentTaskIdRef.current) {
+                // Single manual task done — clear the task-running flag so a
+                // subsequent free-form prompt can use plan mode again.
+                if (props.taskRunningRef)
+                    props.taskRunningRef.current = false;
+                currentTaskIdRef.current = null;
+                if (props.sessionStore)
+                    props.sessionStore.currentTaskId = null;
+            }
             // 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]) {
@@ -1758,6 +1796,16 @@ export function App(props) {
             setRunAllTasks(false);
             setRunAllPixel(false);
             currentPixelFixRef.current = null;
+            // Clear the task-running flag so a subsequent free-form prompt can
+            // re-enable plan mode. Aborted runs never auto-advance.
+            if (props.taskRunningRef)
+                props.taskRunningRef.current = false;
+            // 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) => {
@@ -2045,14 +2093,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 () => {
@@ -2065,8 +2109,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([]);
@@ -2082,7 +2125,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;
         }
@@ -2190,8 +2232,6 @@ export function App(props) {
                 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;
@@ -2549,11 +2589,23 @@ export function App(props) {
                 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 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"
@@ -2643,14 +2695,30 @@ export function App(props) {
         const completionHint = `\n\n---\nWhen you have fully completed this task, call the tasks tool to mark it done:\n` +
             `tasks({ action: "done", id: "${shortId}" })`;
         const fullPrompt = prompt + completionHint;
+        // Task-pane runs are unattended — there is no human to approve a
+        // plan via the plan overlay. Force plan mode off and flag
+        // `taskRunningRef` so `enter_plan` refuses if the agent tries to call
+        // it. Both flags persist across the resetUI() unmount/remount below
+        // because they live in cli.ts-owned refs, not React state.
+        if (props.planModeRef)
+            props.planModeRef.current = false;
+        planModeStateRef.current = false;
+        approvedPlanPathRef.current = undefined;
+        setPlanMode(false);
+        if (props.taskRunningRef)
+            props.taskRunningRef.current = true;
         if (props.resetUI && props.sessionStore) {
-            // Preserve the current system prompt (may differ from the launch
-            // config — e.g. plan mode toggled or skills changed).
-            const sysMsg = messagesRef.current[0];
-            const newMessages = sysMsg && sysMsg.role === "system" ? [sysMsg] : messagesRef.current.slice(0, 1);
             const taskItem = { kind: "task", title, id: String(nextIdRef.current++) };
             const sm = sessionManagerRef.current;
             void (async () => {
+                // Rebuild the system prompt without plan mode / approved plan so the
+                // next mount doesn't inherit a stale plan-mode prefix from a prior
+                // user-toggled state. Skills, languages, and cwd are preserved.
+                const taskSysPrompt = await rebuildSystemPrompt({
+                    planMode: false,
+                    clearApprovedPlan: true,
+                });
+                const newMessages = [{ role: "system", content: taskSysPrompt }];
                 let newSessionPath;
                 if (sm) {
                     try {
@@ -2662,8 +2730,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,
@@ -2675,7 +2749,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);
@@ -2709,15 +2785,7 @@ export function App(props) {
                 setRunAllTasks(false);
             }
         })();
-    }, [
-        props.cwd,
-        props.resetUI,
-        props.sessionStore,
-        stdout,
-        agentLoop,
-        currentProvider,
-        currentModel,
-    ]);
+    }, [props.cwd, props.resetUI, props.sessionStore, agentLoop, currentProvider, currentModel]);
     const openOverlay = useCallback((kind) => {
         if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
             props.sessionStore.overlay = kind;
@@ -2738,7 +2806,7 @@ export function App(props) {
                 setPlanAutoExpand(false);
             setOverlay(kind);
         }
-    }, [agentLoop.isRunning, props, stdout]);
+    }, [agentLoop.isRunning, props]);
     const closeOverlay = useCallback(() => {
         if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
             props.sessionStore.overlay = null;
@@ -2750,7 +2818,7 @@ export function App(props) {
             }
             setOverlay(null);
         }
-    }, [agentLoop.isRunning, overlay, props, stdout]);
+    }, [agentLoop.isRunning, overlay, props]);
     const runGoalSyntheticEvent = useCallback((eventText) => {
         const eventInfo = parseGoalSyntheticEvent(eventText);
         const detail = eventInfo?.kind === "worker"
@@ -2841,8 +2909,8 @@ export function App(props) {
             appendGoalProgress({
                 kind: "goal_progress",
                 phase: "continuing",
-                title: `Continuing Goal: ${latestRun.title}`,
-                detail: "Starting the next worker task or verifier step automatically.",
+                title: `Choosing next Goal step: ${latestRun.title}`,
+                detail: "Latest result is recorded; starting the next worker task or verifier automatically.",
                 status: latestRun.status,
             });
             upsertGoalStatusEntry({
@@ -3138,143 +3206,89 @@ export function App(props) {
             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, {
+        void runGoalVerifierCommand({
             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);
+            runId: run.id,
+            command: run.verifier.command,
+            timeoutMs: verifierTimeoutMs,
+            now: () => startedAt,
+        })
+            .then(async ({ verification, failureClass, durationMs }) => {
             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 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 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")]);
+                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,
             });
-        };
-        child.on("close", (code) => finishVerifier(code));
-        child.on("error", (err) => finishVerifier(1, `Verifier process error: ${err.message}`));
+            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,
@@ -3308,8 +3322,12 @@ export function App(props) {
     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;
@@ -3364,14 +3382,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;
@@ -3403,7 +3417,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).
@@ -3431,12 +3445,13 @@ export function App(props) {
         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: () => {
+    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();
@@ -3586,10 +3601,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 }];
@@ -3630,8 +3643,6 @@ export function App(props) {
                         });
                         return;
                     }
-                    stdout?.write("\x1b[2J\x1b[3J\x1b[H");
-                    setStaticKey((k) => k + 1);
                     setPlanAutoExpand(false);
                     setOverlay(null);
                     setDoneStatus(null);
@@ -3646,8 +3657,6 @@ 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