@prestyj/cli 4.3.210 → 4.3.237

package/dist/ui/App.js

@@ -1,254 +1,149 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import React, { useState, useRef, useCallback, useEffect, useMemo } from "react";
-import { Box, Text, Static } from "ink";
+import { Box, useStdout } from "ink";
 import { useTerminalSize } from "./hooks/useTerminalSize.js";
+import { useChatLayoutMeasurements } from "./hooks/useChatLayoutMeasurements.js";
+import { useTaskPickerController } from "./hooks/useTaskPickerController.js";
+import { useModeState } from "./hooks/useModeState.js";
+import { useSessionPersistence } from "./hooks/useSessionPersistence.js";
+import { useContextCompaction } from "./hooks/useContextCompaction.js";
+import { usePixelFixFlow } from "./hooks/usePixelFixFlow.js";
 import { useDoublePress } from "./hooks/useDoublePress.js";
 import { useTaskBarStore, useTaskBarPolling, focusTaskBar, exitTaskBar, expandTaskBar, collapseTaskBar, navigateTaskBar, killTask, } from "./stores/taskbar-store.js";
-import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { playNotificationSound } from "../utils/sound.js";
-import { formatError, } from "@prestyj/ai";
-import { extractImagePaths } from "../utils/image.js";
+import {} from "@prestyj/ai";
+import { downscaleForPreview, extractImagePaths } from "../utils/image.js";
 import { useAgentLoop } from "./hooks/useAgentLoop.js";
-import { isEyesActive, journalCount } from "@prestyj/eyes";
-import { UserMessage } from "./components/UserMessage.js";
-import { AssistantMessage } from "./components/AssistantMessage.js";
-import { ToolExecution } from "./components/ToolExecution.js";
-import { ToolGroupExecution } from "./components/ToolGroupExecution.js";
-import { ServerToolExecution } from "./components/ServerToolExecution.js";
-import { SubAgentPanel } from "./components/SubAgentPanel.js";
-import { CompactionSpinner, CompactionDone } from "./components/CompactionNotice.js";
+import { useTranscriptHistory } from "./hooks/useTranscriptHistory.js";
 import { createWebSearchTool } from "../tools/web-search.js";
-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, getFooterStatusLayoutDecision, } from "./components/BackgroundTasksBar.js";
+import { ChatScreen } from "./components/ChatScreen.js";
+import { LIVE_TOOL_PANEL_ROWS } from "./components/LiveToolPanel.js";
+import { FullScreenOverlayRouter } from "./components/FullScreenOverlayRouter.js";
+import { SessionSummaryDisplay } from "./components/SessionSummary.js";
 import { useTheme, useSetTheme } from "./theme/theme.js";
 import { useTerminalTitle } from "./hooks/useTerminalTitle.js";
 import { getGitBranch } from "../utils/git.js";
-import { getModel, getContextWindow, getMaxThinkingLevel } from "../core/model-registry.js";
+import { getModel } from "../core/model-registry.js";
 import { SessionManager } from "../core/session-manager.js";
-import { appendMessagesToSession as appendSessionMessages, createCompactedSessionCheckpoint, } from "../core/session-compaction.js";
 import { log } from "../core/logger.js";
 import { getPendingUpdate, startPeriodicUpdateCheck, stopPeriodicUpdateCheck, } from "../core/auto-update.js";
 import { generateSessionTitle } from "../utils/session-title.js";
 import { SettingsManager } from "../core/settings-manager.js";
-import { shouldCompact, compact, getCompactionReserveTokens, } from "../core/compaction/compactor.js";
-import { estimateConversationTokens } from "../core/compaction/token-estimator.js";
 import { PROMPT_COMMANDS, getPromptCommand } from "../core/prompt-commands.js";
 import { isFirstTimeSetup, markSetupAudited, getAnnouncedLanguages, markLanguagesAnnounced, } from "../core/setup-history.js";
 import { loadCustomCommands } from "../core/custom-commands.js";
-import { buildSystemPrompt } from "../system-prompt.js";
-import { detectLanguages, LANGUAGE_DISPLAY_NAMES, } from "../core/language-detector.js";
+import { detectLanguages } from "../core/language-detector.js";
 import { detectVerifyCommands } from "../core/verify-commands.js";
-import { FOCUSED_REPO_MAP_MAX_CHARS, FIRST_TURN_REPO_MAP_MAX_CHARS, buildRepoMap, createRepoMapCache, } from "../core/repomap.js";
-import { getLatestUserText, injectRepoMapContextMessages, stripRepoMapContextMessages, } from "../core/repomap-context.js";
+import { RewindOverlay } from "./components/RewindOverlay.js";
+import { reconcileGoalStatusEntriesWithRuns, removeGoalStatusEntry, syncGoalStatusEntries, } from "./components/GoalStatusBar.js";
 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 { splitAssistantStreamingText } from "./utils/assistant-stream-split.js";
+import { getNextPendingTask, markTaskInProgress } from "../core/tasks-store.js";
+import { buildUserContentWithAttachments } from "./prompt-routing.js";
+import { submitPromptCommand } from "./submit-prompt-command.js";
+import { handleUiSlashCommand } from "./submit-slash-commands.js";
+import { buildIdealReviewMessage, evaluateIdealReview } from "../core/ideal-review.js";
+import { buildLoopBreakMessage, evaluateLoopBreak } from "../core/loop-breaker.js";
+import { buildRegroundingMessage } from "../core/regrounding.js";
+import { getNextThinkingLevel, isThinkingLevelSupported } from "./thinking-level.js";
+import { getDoneFlushDecision, shouldTopSpaceAfterPrintedAgentBoundary, shouldTopSpaceStreamingAssistant, } from "./layout-decisions.js";
+import { isTranscriptSpacingItem } from "./transcript/spacing.js";
+import { buildTranscriptLines } from "./transcript/transcript-lines.js";
+import { useTranscriptScroll } from "./hooks/useTranscriptScroll.js";
+import { scrollTranscriptByLines } from "./stores/transcript-scroll-store.js";
+import { renderTranscriptItem } from "./transcript/TranscriptRenderer.js";
+import { formatDuration } from "./duration-format.js";
+import { pickDurationVerb } from "./duration-summary.js";
+import { toErrorItem } from "./error-item.js";
+import { appendGoalDecision, appendGoalEvidence, createGoalTask, formatGoalBlockingPrerequisites, goalHasBlockingPrerequisites, loadGoalRuns, reconcileActiveGoalRuns, updateGoalTask, upsertGoalRun, } from "../core/goal-store.js";
+import { canCompleteGoalRun, decideGoalNextAction, } from "../core/goal-controller.js";
+import { runGoalPrerequisiteChecks } from "../core/goal-prerequisites.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";
-/**
- * Build an ErrorItem from any thrown value. Centralises headline / message /
- * guidance extraction so every error answers the same question for the user:
- *   "Should I retry, or is this a ezcoder bug to report?"
- */
-function toErrorItem(err, id, contextPrefix) {
-    const f = formatError(err);
-    const headline = contextPrefix ? `${contextPrefix} — ${f.headline}` : f.headline;
-    // For ezcoder bugs, swap the generic "see /help" guidance for an actual URL
-    // so users have a clear place to send the report.
-    const guidance = f.source === "ezcoder"
-        ? `This looks like a ezcoder bug — please send it to the dev at ${GGCODER_BUG_REPORT_URL}.`
-        : f.guidance;
-    // Mirror every user-visible error into ~/.ezcoder/debug.log so reports can be
-    // diagnosed even after the terminal scrollback is gone.
-    log("ERROR", "ui-error", headline, {
-        source: f.source,
-        message: f.message,
-        ...(f.provider ? { provider: f.provider } : {}),
-        ...(f.statusCode != null ? { statusCode: String(f.statusCode) } : {}),
-        ...(f.requestId ? { requestId: f.requestId } : {}),
-        ...(err instanceof Error && err.stack ? { stack: err.stack } : {}),
-    });
-    return {
-        kind: "error",
-        headline,
-        message: f.message,
-        guidance,
-        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"]);
+import { formatGoalVerifierCompletionEvent, formatGoalWorkerCompletionEvent, } from "./goal-events.js";
+import { buildGoalFinalSummarySections, buildGoalSummaryRows, goalPassedDetail, } from "./goal-summary.js";
+import { addLinesChanged, buildSessionSummary, createSessionStats, recordServerToolCall, recordToolEnd, recordTurnEnd, } from "./session-summary.js";
+import { compactHistory, getNextGeneratedItemId, isActiveItem, isSameAssistantText, normalizeAssistantText, partitionCompleted, pinStreamingTextBeforeToolBoundary, removeItemsWithIds, uniqueItemsById, } from "./item-helpers.js";
+import { IDEAL_HOOK_NOTICE_TEXT, LOOP_BREAK_NOTICE_TEXT, REGROUNDING_NOTICE_TEXT, lastVisibleTranscriptItem, } from "./app-items.js";
+export { buildUserContentWithAttachments, routePromptCommandInput } from "./prompt-routing.js";
+export { getNextThinkingLevel } from "./thinking-level.js";
+export { getChatControlsLayoutDecision, getDoneFlushDecision, getScrollStabilizationDecision, getStaticHistoryKey, hasParagraphBreakLiveUserMessage, isTallLiveUserMessage, shouldHideHistoryForOverlayView, shouldHideStaticItemsForOverlayView, shouldStabilizeOverlayPaneRerender, shouldTopSpaceAfterPrintedAgentBoundary, shouldTopSpaceAssistantAfterToolBoundary, shouldTopSpaceStreamingAssistant, } from "./layout-decisions.js";
+export { getNextGeneratedItemId, isActiveItem, partitionCompleted, pinStreamingTextBeforeToolBoundary, } from "./item-helpers.js";
+/** Tools that get aggregated into a single compact group when possible. */
+const AGGREGATABLE_TOOLS = new Set([
+    "read",
+    "grep",
+    "find",
+    "ls",
+    "mcp__kencode-search__searchCode",
+    "mcp__kencode-search__referenceSources",
+    "mcp__kencode-search__discoverRepos",
+]);
 const RUNNING_INDICATOR_ANIMATION_MS = 1_200;
-/**
- * Cap memory by replacing old items with tiny tombstones. Ink's <Static>
- * tracks rendered items by array length — the array must never shrink, but
- * we can swap out heavy objects for lightweight `{ kind: "tombstone", id }`
- * entries so GC can reclaim the original data.
- */
-const MAX_LIVE_HISTORY = 200;
-function compactHistory(items) {
-    if (items.length <= MAX_LIVE_HISTORY)
-        return items;
-    const cutoff = items.length - MAX_LIVE_HISTORY;
-    const compacted = new Array(items.length);
-    for (let i = 0; i < cutoff; i++) {
-        const it = items[i];
-        compacted[i] = it.kind === "tombstone" ? it : { kind: "tombstone", id: it.id };
-    }
-    for (let i = cutoff; i < items.length; i++) {
-        compacted[i] = items[i];
-    }
-    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];
+    const trimmed = summary.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.length > 400 ? `${trimmed.slice(0, 397)}...` : trimmed;
 }
 function formatGoalWorkerFinishedTitle(taskTitle, status) {
-    return status === "done" ? `Done: ${taskTitle}` : `Failed: ${taskTitle}`;
+    return status === "done" ? `Worker finished: ${taskTitle}` : `Worker failed: ${taskTitle}`;
 }
-function countGoalTasksByStatus(tasks, status) {
-    return tasks.filter((task) => task.status === status).length;
+function goalCompletionReason(check) {
+    return check.reason;
+}
+function getGoalContinuationChoiceKey({ runId, decision, }) {
+    switch (decision.kind) {
+        case "create_task":
+            return `${runId}:create_task:${decision.title}`;
+        case "start_worker":
+        case "pause":
+            return `${runId}:${decision.kind}:${decision.task.id}:${decision.attempts}`;
+        case "run_verifier":
+            return `${runId}:run_verifier:${decision.command}`;
+        case "terminal":
+            return `${runId}:terminal:${decision.status}`;
+        case "blocked":
+        case "wait":
+        case "complete":
+            return `${runId}:${decision.kind}:${decision.reason}`;
+    }
 }
-function firstText(values) {
-    return values.find((value) => value !== undefined && value.trim().length > 0)?.trim();
+function goalTerminalRunIdFromItem(item) {
+    if (item.kind !== "goal_progress" || item.phase !== "terminal")
+        return undefined;
+    if (!item.id.startsWith("goal-terminal-"))
+        return undefined;
+    return item.id.slice("goal-terminal-".length);
 }
-function truncateGoalSummary(value, maxLength = 90) {
-    const normalized = value.replace(/\s+/g, " ").trim();
-    if (normalized.length <= maxLength)
-        return normalized;
-    return `${normalized.slice(0, maxLength - 1)}…`;
+function goalProgressMatchesDraft(item, draft) {
+    return (item.title === draft.title &&
+        item.detail === draft.detail &&
+        item.status === draft.status &&
+        JSON.stringify(item.summaryRows ?? []) === JSON.stringify(draft.summaryRows ?? []) &&
+        JSON.stringify(item.summarySections ?? []) === JSON.stringify(draft.summarySections ?? []));
 }
-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) }
-            : {}),
+export function completedItemsWithDurableGoalTerminalProgress(items, runs) {
+    const runIds = new Set(runs.map((run) => run.id));
+    const terminalByRun = new Map(runs
+        .map((run) => [run.id, formatGoalTerminalProgress(run)])
+        .filter((entry) => entry[1] !== null));
+    if (runIds.size === 0)
+        return items;
+    let changed = false;
+    const reconciled = items.map((item, index) => {
+        const runId = goalTerminalRunIdFromItem(item);
+        if (!runId || !runIds.has(runId))
+            return item;
+        const draft = terminalByRun.get(runId);
+        if (item.kind === "goal_progress" && draft && goalProgressMatchesDraft(item, draft))
+            return item;
+        changed = true;
+        return { kind: "tombstone", id: `tombstone-${item.id}-${index}` };
     });
-    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);
+    return changed ? reconciled : items;
 }
 export function formatGoalTerminalProgress(run) {
     switch (run.status) {
@@ -257,8 +152,9 @@ export function formatGoalTerminalProgress(run) {
                 kind: "goal_progress",
                 phase: "terminal",
                 title: `Goal passed: ${run.title}`,
-                detail: "Verifier evidence is recorded; auto-continuation stopped.",
+                detail: goalPassedDetail(run),
                 summaryRows: buildGoalSummaryRows(run),
+                summarySections: buildGoalFinalSummarySections(run),
                 status: run.status,
             };
         case "failed":
@@ -297,221 +193,49 @@ export function formatGoalTerminalProgress(run) {
             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) {
-    switch (item.kind) {
-        case "tool_start":
-        case "server_tool_start":
-        case "compacting":
-            return true;
-        case "tool_group":
-            return item.tools.some((t) => t.status === "running");
-        case "subagent_group":
-            return item.agents.some((a) => a.status === "running");
-        default:
-            return false;
-    }
-}
-/**
- * Partition live items into completed (flushable to Static) and still-active.
- * Completed items precede active ones — we flush the longest contiguous prefix
- * of completed items to keep ordering stable.
- */
-function partitionCompleted(items) {
-    // Find the first active item — everything before it is safe to flush
-    const firstActiveIdx = items.findIndex(isActiveItem);
-    if (firstActiveIdx === -1) {
-        // All items are completed
-        return { flushed: items, remaining: [] };
-    }
-    if (firstActiveIdx === 0) {
-        return { flushed: [], remaining: items };
-    }
-    return {
-        flushed: items.slice(0, firstActiveIdx),
-        remaining: items.slice(firstActiveIdx),
-    };
-}
-// ── Duration summary ─────────────────────────────────────
-function formatDuration(ms) {
-    const totalSec = Math.round(ms / 1000);
-    if (totalSec < 60)
-        return `${totalSec}s`;
-    const min = Math.floor(totalSec / 60);
-    const sec = totalSec % 60;
-    return sec > 0 ? `${min}m ${sec}s` : `${min}m`;
-}
-function pickDurationVerb(toolsUsed) {
-    const has = (name) => toolsUsed.includes(name);
-    const hasAny = (...names) => names.some(has);
-    const writing = has("edit") || has("write");
-    const reading = has("read") || has("grep") || has("find") || has("ls");
-    // Multi-tool combos (most specific first)
-    if (has("subagent") && writing)
-        return "Orchestrated changes for";
-    if (has("subagent"))
-        return "Delegated work for";
-    if (has("web-fetch") && writing)
-        return "Researched & coded for";
-    if (has("web-fetch") && reading)
-        return "Researched for";
-    if (has("web-fetch"))
-        return "Fetched the web for";
-    if (has("bash") && writing)
-        return "Built & ran for";
-    if (has("edit") && has("write"))
-        return "Crafted code for";
-    if (has("edit") && has("bash"))
-        return "Refactored & tested for";
-    if (has("edit") && reading)
-        return "Refactored for";
-    if (has("edit"))
-        return "Refactored for";
-    if (has("write") && has("bash"))
-        return "Wrote & ran for";
-    if (has("write") && reading)
-        return "Wrote code for";
-    if (has("write"))
-        return "Wrote code for";
-    if (has("bash") && has("grep"))
-        return "Hacked away for";
-    if (has("bash") && reading)
-        return "Ran & investigated for";
-    if (has("bash"))
-        return "Executed commands for";
-    if (hasAny("tasks", "task-output", "task-stop"))
-        return "Managed tasks for";
-    if (has("grep") && has("read"))
-        return "Investigated for";
-    if (has("grep") && has("find"))
-        return "Scoured the codebase for";
-    if (has("grep"))
-        return "Searched for";
-    if (has("read") && has("find"))
-        return "Explored for";
-    if (has("read"))
-        return "Studied the code for";
-    if (has("find") || has("ls"))
-        return "Browsed files for";
-    // No tools used — pure text response
-    const phrases = [
-        "Pondered for",
-        "Thought for",
-        "Reasoned for",
-        "Mulled it over for",
-        "Noodled on it for",
-        "Brewed up a response in",
-        "Cooked up an answer in",
-        "Worked out a reply in",
-        "Channeled wisdom for",
-        "Conjured a response in",
-    ];
-    return phrases[Math.floor(Math.random() * phrases.length)];
-}
-// ── Animated thinking border ────────────────────────────────
-const THINKING_BORDER_COLORS = ["#60a5fa", "#818cf8", "#a78bfa", "#818cf8", "#60a5fa"];
-// ── Task count helper ───────────────────────────────────────
-function getTaskCount(cwd) {
-    try {
-        const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 16);
-        const data = readFileSync(join(homedir(), ".ezcoder-tasks", "projects", hash, "tasks.json"), "utf-8");
-        const tasks = JSON.parse(data);
-        return tasks.filter((t) => t.status !== "done").length;
-    }
-    catch {
-        return 0;
-    }
-}
-function getNextPendingTask(cwd) {
-    try {
-        const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 16);
-        const data = readFileSync(join(homedir(), ".ezcoder-tasks", "projects", hash, "tasks.json"), "utf-8");
-        const tasks = JSON.parse(data);
-        const pending = tasks.find((t) => t.status === "pending");
-        if (!pending)
-            return null;
-        return {
-            id: pending.id,
-            title: pending.title,
-            prompt: pending.prompt || pending.text || pending.title,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function markTaskInProgress(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: "in-progress" } : t));
-        writeFileSync(filePath, JSON.stringify(updated, null, 2) + "\n", "utf-8");
-    }
-    catch {
-        // ignore
-    }
+export function nextGoalModeAfterAgentDone({ currentMode, runningGoalIds, queuedSyntheticEvents, activeContinuationFlights = 0, wasGoalSetupTurn, }) {
+    if (wasGoalSetupTurn)
+        return "off";
+    if (currentMode === "planner" || currentMode === "setup")
+        return currentMode;
+    if (queuedSyntheticEvents > 0)
+        return "coordinator";
+    if (activeContinuationFlights > 0)
+        return "coordinator";
+    if (currentMode === "coordinator" && runningGoalIds > 0)
+        return "coordinator";
+    return "off";
 }
+// ── App Component ──────────────────────────────────────────
 /**
- * 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.
+ * Extract inline image previews carried on a tool result's `details` payload.
+ * Image-producing tools (e.g. screenshot) attach `{ imagePreviews: [...] }` so
+ * the terminal-history printer can render the captured pixels inline.
  */
-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
-    }
+function extractToolImagePreviews(details) {
+    if (!details || typeof details !== "object")
+        return undefined;
+    const previews = details.imagePreviews;
+    if (!Array.isArray(previews))
+        return undefined;
+    const valid = previews.filter((p) => typeof p === "object" &&
+        p !== null &&
+        typeof p.base64 === "string" &&
+        typeof p.mediaType === "string");
+    return valid.length > 0 ? valid : undefined;
 }
-// ── App Component ──────────────────────────────────────────
 export function App(props) {
     const theme = useTheme();
     const switchTheme = useSetTheme();
-    const { columns, resizeKey } = useTerminalSize();
+    const { write: writeStdout } = useStdout();
+    const { columns, rows } = useTerminalSize();
     // Hoisted before terminal title hook so it can reference them
     const [lastUserMessage, setLastUserMessage] = useState("");
+    // Bumped on every prompt submit; the fullscreen transcript scroll controller
+    // watches this to snap back to the bottom so the newest output is visible.
+    const [scrollResetToken, setScrollResetToken] = useState(0);
     const [exitPending, setExitPending] = useState(false);
-    // Initialize from planModeRef (lives outside React in cli.ts) so plan
-    // mode survives /clear's unmount/remount, matching the prior behavior
-    // where /clear didn't toggle plan mode off.
-    const [planMode, setPlanMode] = useState(props.planModeRef?.current ?? false);
-    const planModeLocalRef = useRef(false);
-    planModeLocalRef.current = planMode;
+    const [quittingSummary, setQuittingSummary] = useState(null);
     // Terminal title — updated later after agentLoop is created
     // (hoisted here so the hook is always called in the same order)
     const [titleRunning, setTitleRunning] = useState(false);
@@ -521,14 +245,11 @@ export function App(props) {
         isRunning: titleRunning,
         sessionTitle,
     });
-    // Items scrolled into Static (history). For restored sessions, seed the
-    // initial array directly — matches how every other Ink chat agent passes
-    // messages to <Static> (cat-code, harness, p90-cli, openai-chatgpt, lms,
-    // gatsby). Ink's Static (build/components/Static.js) starts with index=0
-    // so slice(0) returns the full array regardless of length.
+    // Completed transcript rows are kept as durable session data but are no longer
+    // rendered through Ink history. They are serialized once into real terminal
+    // scrollback via terminalHistoryPrinter, while Ink owns only live rows and
+    // controls. This avoids Static/log-update replay drift on resize/remount.
     const [history, setHistory] = useState(() => {
-        // sessionStore wins (lives across remount). Falls back to initialHistory
-        // (loaded from a session file at startup), then a fresh banner-only list.
         const stored = props.sessionStore?.history;
         if (stored && stored.length > 0)
             return stored;
@@ -538,57 +259,68 @@ export function App(props) {
         return [{ kind: "banner", id: "banner" }];
     });
     // 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 ?? []);
+    // Seed from sessionStore so live output
+    // survives pane/overlay/resize remounts before it is finalized.
+    const [liveItems, setLiveItems] = useState(() => {
+        const restoredLiveItems = uniqueItemsById(props.sessionStore?.liveItems ?? []);
+        const restoredHistoryIds = new Set(history.map((item) => item.id));
+        return removeItemsWithIds(restoredLiveItems, restoredHistoryIds);
+    });
+    // Rolling feed of recent tool actions for the pinned LiveToolPanel. Kept
+    // separate from `liveItems` (the scrollback record) so tool calls mutate in
+    // place above the activity bar instead of spamming the transcript.
+    const [liveToolFeed, setLiveToolFeed] = useState([]);
     // 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.
+    // Signal that pushes text into the InputArea composer (e.g. restoring queued
+    // messages after an interrupt). Bumping `nonce` triggers the injection even
+    // when the text is identical to a prior restore.
+    const [composerInject, setComposerInject] = useState(null);
+    const agentRunningRef = useRef(false);
     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);
+    // /rewind overlay: holds the checkpoint list while the picker is open.
+    const [rewindCheckpoints, setRewindCheckpoints] = useState(null);
+    // Monotonic user-turn counter keying per-turn checkpoints.
+    const rewindTurnRef = useRef(0);
+    const taskPicker = useTaskPickerController({
+        displayedCwd,
+        onStartTask: (title, prompt, taskId) => startTaskRef.current(title, prompt, taskId),
+        onRunAllTasksChange: setRunAllTasks,
+    });
     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);
     const [currentModel, setCurrentModel] = useState(props.model);
+    const currentModelRef = useRef(props.model);
     const [currentProvider, setCurrentProvider] = useState(props.provider);
+    const currentProviderRef = useRef(props.provider);
     const [currentTools, setCurrentTools] = useState(props.tools);
     const currentToolsRef = useRef(props.tools);
-    const [thinkingEnabled, setThinkingEnabled] = useState(!!props.thinking);
+    const [thinkingLevel, setThinkingLevel] = useState(props.thinking);
+    const [renderMarkdown, setRenderMarkdown] = useState(true);
     const messagesRef = useRef(props.sessionStore?.messages ?? props.messages);
-    const repoMapInjectionEnabledRef = useRef(true);
-    const repoMapDirtyRef = useRef(true);
-    const repoMapMarkdownRef = useRef("");
-    const repoMapSnapshotRef = useRef(undefined);
-    const repoMapChangedCountRef = useRef(0);
-    const repoMapCacheRef = useRef(createRepoMapCache());
     const [planAutoExpand, setPlanAutoExpand] = useState(props.sessionStore?.planAutoExpand ?? false);
+    const [goalAutoExpand, setGoalAutoExpand] = useState(props.sessionStore?.goalAutoExpand ?? false);
+    const goalAutoExpandRef = useRef(props.sessionStore?.goalAutoExpand ?? false);
+    const [goalStatusEntries, setGoalStatusEntries] = useState(props.sessionStore?.goalStatusEntries ?? []);
+    const runningGoalIdsRef = useRef(new Set());
+    const activeVerifierRunIdsRef = useRef(new Set());
+    const goalContinuationFlightsRef = useRef(new Set());
+    const goalContinuationRecentChoicesRef = useRef(new Map());
+    const startGoalRunRef = useRef(() => { });
     const approvedPlanPathRef = useRef(props.sessionStore?.approvedPlanPath);
     const planStepsRef = useRef(props.sessionStore?.planSteps ?? []);
     const [planSteps, setPlanSteps] = useState(props.sessionStore?.planSteps ?? []);
-    const planModeStateRef = useRef(planMode);
     // Stuck-guard for the plan-continuation follow-up nudge. Tracks how many
     // times we've nudged the agent to continue the same step. Reset whenever a
     // new [DONE:n] marker advances progress (see onTurnText). Caps at 2 nudges
@@ -596,32 +328,25 @@ export function App(props) {
     const followUpNudgesRef = useRef({ step: 0, count: 0 });
     // Seed the per-item ID counter so it doesn't collide with IDs already in
     // sessionStore.history (which survives remount). Without this, a remount
-    // (resize, overlay toggle, etc.) starts the counter at 0 and new items
-    // generate ids "0", "1", "2"… that collide with the same ids from the
-    // previous mount, triggering React's duplicate-key warning and causing
-    // duplicate/omitted renders.
-    const nextIdRef = useRef((() => {
-        const items = [
-            ...(props.sessionStore?.history ?? props.initialHistory ?? []),
-            ...(props.sessionStore?.liveItems ?? []),
-        ];
-        let max = -1;
-        for (const item of items) {
-            const n = Number(item.id);
-            if (Number.isFinite(n) && n > max)
-                max = n;
-        }
-        return max + 1;
-    })());
+    // (resize, overlay toggle, task pane open, etc.) starts the counter at 0
+    // and new items generate ids "ui-0", "ui-1", "ui-2"… that collide with
+    // the same ids from the previous mount, triggering React's duplicate-key
+    // warning and causing duplicate/omitted renders.
+    const nextIdRef = useRef(getNextGeneratedItemId([
+        ...(props.sessionStore?.history ?? props.initialHistory ?? []),
+        ...(props.sessionStore?.liveItems ?? []),
+    ]));
     const sessionManagerRef = useRef(props.sessionsDir ? new SessionManager(props.sessionsDir) : null);
     const sessionPathRef = useRef(props.sessionStore?.sessionPath ?? props.sessionPath);
     const persistedIndexRef = useRef(messagesRef.current.length);
+    const sessionStatsRef = useRef(props.sessionStore?.sessionStats ??
+        createSessionStats({ sessionId: props.sessionStore?.sessionId ?? props.sessionId }));
+    const [idealReviewEnabled, setIdealReviewEnabled] = useState(props.sessionStore?.idealReviewEnabled ?? props.idealReviewEnabled ?? true);
+    const idealReviewEnabledRef = useRef(idealReviewEnabled);
     /** Last actual API-reported input token count (from turn_end). */
     const lastActualTokensRef = useRef(0);
     /** Timestamp (ms) when lastActualTokensRef was last updated by turn_end. */
     const lastActualTokensTimestampRef = useRef(0);
-    /** Timestamp of last compaction — used for time-based cooldown and staleness detection. */
-    const lastCompactionTimeRef = useRef(0);
     /**
      * Languages whose style packs are currently injected into the system prompt.
      * Grown by `maybeInjectLanguagePacks` after `write`/`bash` tool results when
@@ -643,6 +368,29 @@ export function App(props) {
      */
     const triggerAutoSetupRef = useRef(async () => { });
     const getId = () => `ui-${nextIdRef.current++}`;
+    useEffect(() => {
+        idealReviewEnabledRef.current = idealReviewEnabled;
+        if (props.sessionStore)
+            props.sessionStore.idealReviewEnabled = idealReviewEnabled;
+    }, [idealReviewEnabled, props.sessionStore]);
+    const sessionStore = props.sessionStore;
+    const { planMode, goalMode, rebuildSystemPrompt, replaceSystemPrompt, setPlanModeAndPrompt, setGoalModeAndPrompt, } = useModeState({
+        initialPlanMode: props.sessionStore?.planMode ?? props.planModeRef?.current ?? false,
+        initialGoalMode: props.sessionStore?.goalMode ?? props.goalModeRef?.current ?? "off",
+        skills: props.skills,
+        planModeRef: props.planModeRef,
+        goalModeRef: props.goalModeRef,
+        sessionStore: props.sessionStore,
+        cwdRef,
+        currentToolsRef,
+        providerRef: currentProviderRef,
+        approvedPlanPathRef,
+        injectedLanguagesRef,
+        messagesRef,
+    });
+    const appendGoalAgentTransition = useCallback((text) => {
+        setLiveItems((prev) => [...prev, { kind: "goal_agent_transition", text, id: getId() }]);
+    }, []);
     const appendGoalProgress = useCallback((item) => {
         setLiveItems((prev) => [...prev, { ...item, id: getId() }]);
     }, []);
@@ -663,47 +411,64 @@ export function App(props) {
             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([]);
-    const [flushGeneration, setFlushGeneration] = useState(0);
-    /** Queue items for two-phase flush and signal the drain effect. */
-    const queueFlush = useCallback((items) => {
-        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]);
+    const { pendingHistoryFlushRef, streamedAssistantFlushRef, queueFlush, finalizeSubmittedUserItem, clearPendingHistory, } = useTranscriptHistory({
+        // In fullscreen alt-screen mode the transcript renders inside Ink (the
+        // viewport), so we must NOT write completed rows to native scrollback —
+        // doing so would scroll the live frame. Dropping the printer keeps history
+        // accumulating in React state (still flushed + persisted) without any
+        // stdout writes. The legacy scrollback path keeps the printer.
+        terminalHistoryPrinter: props.fullscreen ? undefined : props.terminalHistoryPrinter,
+        terminalHistoryContext: {
+            theme,
+            columns,
+            version: props.version,
+            model: currentModel,
+            provider: currentProvider,
+            cwd: displayedCwd,
+        },
+        writeStdout,
+        sessionPathRef,
+        sessionManagerRef,
+        sessionStore,
+        history,
+        setHistory,
+        setLiveItems,
+    });
     // Mirror runtime state choices (model/provider/thinking) into renderApp's
     // closure so unmount/remount preserves them.
     const onRuntimeStateChange = props.onRuntimeStateChange;
     useEffect(() => {
+        currentModelRef.current = currentModel;
         onRuntimeStateChange?.({ model: currentModel });
     }, [currentModel, onRuntimeStateChange]);
     useEffect(() => {
         onRuntimeStateChange?.({ provider: currentProvider });
     }, [currentProvider, onRuntimeStateChange]);
+    useEffect(() => {
+        if (thinkingLevel && !isThinkingLevelSupported(currentProvider, currentModel, thinkingLevel)) {
+            setThinkingLevel(getNextThinkingLevel(currentProvider, currentModel, undefined));
+        }
+    }, [currentProvider, currentModel, thinkingLevel]);
     useEffect(() => {
         onRuntimeStateChange?.({
-            thinking: thinkingEnabled ? getMaxThinkingLevel(currentModel) : undefined,
+            thinking: thinkingLevel,
         });
-    }, [thinkingEnabled, currentModel, onRuntimeStateChange]);
+    }, [thinkingLevel, onRuntimeStateChange]);
     // Mirror session state into renderApp's closure so resetUI() can re-seed
     // the conversation on remount. Each panel that previously did a bare ANSI
-    // screen clear (overlay open/close, plan accept/reject, /clear, startTask)
+    // screen clear (overlay open/close, plan accept/reject, /clear)
     // now goes through resetUI; without these mirrors, the chat would vanish.
-    const sessionStore = props.sessionStore;
+    const historyRef = useRef(history);
     useEffect(() => {
+        historyRef.current = history;
         if (sessionStore)
             sessionStore.history = history;
     }, [history, sessionStore]);
     useEffect(() => {
-        if (sessionStore)
-            sessionStore.liveItems = liveItems;
+        if (!sessionStore)
+            return;
+        const historyIds = new Set(historyRef.current.map((item) => item.id));
+        sessionStore.liveItems = removeItemsWithIds(uniqueItemsById(liveItems), historyIds);
     }, [liveItems, sessionStore]);
     useEffect(() => {
         if (sessionStore)
@@ -721,10 +486,27 @@ export function App(props) {
         if (sessionStore)
             sessionStore.overlay = overlay;
     }, [overlay, sessionStore]);
+    useEffect(() => {
+        goalAutoExpandRef.current = goalAutoExpand;
+        if (sessionStore)
+            sessionStore.goalAutoExpand = goalAutoExpand;
+    }, [goalAutoExpand, sessionStore]);
     useEffect(() => {
         if (sessionStore)
             sessionStore.goalStatusEntries = goalStatusEntries;
     }, [goalStatusEntries, sessionStore]);
+    useEffect(() => {
+        if (sessionStore)
+            sessionStore.planMode = planMode;
+    }, [planMode, sessionStore]);
+    useEffect(() => {
+        if (sessionStore)
+            sessionStore.goalMode = goalMode;
+    }, [goalMode, sessionStore]);
+    useEffect(() => {
+        if (sessionStore)
+            sessionStore.sessionStats = sessionStatsRef.current;
+    }, [sessionStore]);
     // pendingAction is consumed via a useEffect AFTER agentLoop is created
     // — see below where useAgentLoop is set up.
     const pendingActionConsumedRef = useRef(false);
@@ -742,14 +524,13 @@ export function App(props) {
     }, [displayedCwd]);
     useEffect(() => {
         let cancelled = false;
-        const refreshGoalCount = () => {
+        const refreshGoalState = () => {
             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);
+                setHistory((prev) => completedItemsWithDurableGoalTerminalProgress(prev, runs));
                 setGoalStatusEntries((prev) => {
                     const next = reconcileGoalStatusEntriesWithRuns(prev, runs, {
                         isWorkerActive: (workerId, run) => listGoalWorkers(props.cwd).some((worker) => worker.id === workerId &&
@@ -763,13 +544,13 @@ export function App(props) {
                 });
             });
         };
-        refreshGoalCount();
-        const interval = setInterval(refreshGoalCount, 1000);
+        refreshGoalState();
+        const interval = setInterval(refreshGoalState, 1_000);
         return () => {
             cancelled = true;
             clearInterval(interval);
         };
-    }, [props.cwd]);
+    }, [props.cwd, props.sessionStore]);
     // Periodic update check during long sessions
     useEffect(() => {
         startPeriodicUpdateCheck(props.version, (msg) => {
@@ -789,27 +570,29 @@ export function App(props) {
     useEffect(() => {
         currentToolsRef.current = currentTools;
     }, [currentTools]);
-    // ── Plan mode wiring ─────────────────────────────────────
-    // Sync planModeRef with React state
     useEffect(() => {
-        planModeStateRef.current = planMode;
-        if (props.planModeRef) {
-            props.planModeRef.current = planMode;
-        }
-    }, [planMode, props.planModeRef]);
-    const rebuildSystemPrompt = useCallback(async (options) => {
-        const approvedPlanPath = options?.clearApprovedPlan
-            ? undefined
-            : (options?.approvedPlanPath ?? approvedPlanPathRef.current);
-        return buildSystemPrompt(options?.cwd ?? cwdRef.current, props.skills, options?.planMode ?? planModeStateRef.current, approvedPlanPath, (options?.tools ?? currentToolsRef.current).map((tool) => tool.name), options?.activeLanguages ?? injectedLanguagesRef.current);
-    }, [props.skills]);
-    const replaceSystemPrompt = useCallback(async (options) => {
-        const newPrompt = await rebuildSystemPrompt(options);
-        if (messagesRef.current[0]?.role === "system") {
-            messagesRef.current[0] = { role: "system", content: newPrompt };
-        }
-        return newPrompt;
-    }, [rebuildSystemPrompt]);
+        if (!props.connectInitialMcpTools)
+            return;
+        let cancelled = false;
+        void props
+            .connectInitialMcpTools()
+            .then((mcpTools) => {
+            if (cancelled || mcpTools.length === 0)
+                return;
+            setCurrentTools((prev) => {
+                const next = [...prev.filter((tool) => !tool.name.startsWith("mcp__")), ...mcpTools];
+                currentToolsRef.current = next;
+                void replaceSystemPrompt({ tools: next });
+                return next;
+            });
+        })
+            .catch((err) => {
+            log("WARN", "mcp", `MCP initialization failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [props.connectInitialMcpTools, replaceSystemPrompt]);
     /**
      * Unified "apply detection result" pipeline. Called from three sites:
      *   1. Initial mount (existing project at startup).
@@ -894,89 +677,17 @@ export function App(props) {
     useEffect(() => {
         void applyLanguageDetectionRef.current("initial");
     }, []);
-    // Rebuild system prompt when plan mode changes
-    useEffect(() => {
-        void replaceSystemPrompt({ planMode });
-    }, [planMode, replaceSystemPrompt]);
-    // Wire onEnterPlan callback ref
-    useEffect(() => {
-        if (props.onEnterPlanRef) {
-            props.onEnterPlanRef.current = (reason) => {
-                setPlanMode(true);
-                const msg = reason ? `Plan Mode Activated — ${reason}` : "Plan Mode Activated";
-                setLiveItems((prev) => [
-                    ...prev,
-                    { kind: "plan_transition", text: msg, active: true, id: getId() },
-                ]);
-            };
-        }
-    }, [props.onEnterPlanRef]);
-    // Wire onExitPlan callback ref
-    useEffect(() => {
-        if (props.onExitPlanRef) {
-            props.onExitPlanRef.current = async (planPath) => {
-                // Deactivate plan mode, store approved plan path, open pane
-                planModeStateRef.current = false;
-                setPlanMode(false);
-                approvedPlanPathRef.current = planPath;
-                await replaceSystemPrompt({ planMode: false, approvedPlanPath: planPath });
-                // Use setTimeout to open pane after the current tool execution completes,
-                // so the turn can finish and the UI transitions cleanly
-                // Flag that the plan overlay is about to open — suppresses the
-                // premature "done" status that fires when the agent loop finishes
-                planOverlayPendingRef.current = true;
-                setTimeout(() => {
-                    setPlanAutoExpand(true);
-                    setOverlay("plan");
-                    // Don't clear planOverlayPendingRef here — keep it true until
-                    // the user actually approves/rejects the plan. Clearing it on a
-                    // timer causes a race where agent_done fires after the 300ms
-                    // timeout but before the user interacts, triggering a premature
-                    // completion sound.
-                }, 300);
-                return ("Plan submitted. Exiting plan mode.\n" +
-                    "The plan pane is opening for user review.\n" +
-                    "Plan saved at: " +
-                    planPath);
-            };
-        }
-    }, [props.onExitPlanRef, replaceSystemPrompt]);
-    const appendMessagesToSession = useCallback(async (sessionPath, messages, startIndex) => {
-        const sm = sessionManagerRef.current;
-        if (!sm)
-            return;
-        await appendSessionMessages(sm, sessionPath, messages, startIndex);
-    }, []);
-    const persistCompactedSession = useCallback(async (compactedMessages) => {
-        const sm = sessionManagerRef.current;
-        if (!sm)
-            return;
-        const session = await createCompactedSessionCheckpoint(sm, {
-            cwd: cwdRef.current,
-            provider: currentProvider,
-            model: currentModel,
-            messages: compactedMessages,
-        });
-        sessionPathRef.current = session.path;
-        persistedIndexRef.current = compactedMessages.length;
-        if (sessionStore) {
-            sessionStore.sessionPath = session.path;
-            sessionStore.messages = [...compactedMessages];
-        }
-        log("INFO", "compaction", "Persisted compacted session checkpoint", { path: session.path });
-    }, [currentModel, currentProvider, sessionStore]);
-    const persistNewMessages = useCallback(async () => {
-        const sp = sessionPathRef.current;
-        if (!sp)
-            return;
-        const allMsgs = messagesRef.current;
-        await appendMessagesToSession(sp, allMsgs, persistedIndexRef.current);
-        persistedIndexRef.current = allMsgs.length;
-        if (sessionStore) {
-            sessionStore.messages = [...allMsgs];
-            sessionStore.sessionPath = sp;
-        }
-    }, [appendMessagesToSession, sessionStore]);
+    const { persistCompactedSession, persistNewMessages } = useSessionPersistence({
+        sessionManagerRef,
+        sessionPathRef,
+        sessionStatsRef,
+        persistedIndexRef,
+        messagesRef,
+        cwdRef,
+        currentProvider,
+        currentModel,
+        sessionStore,
+    });
     /**
      * Run the language detector against the current cwd. If the detected set is a
      * strict superset of what's already injected, rebuild the system prompt with
@@ -987,7 +698,7 @@ export function App(props) {
      * Other tool kinds skip detection entirely to avoid wasted filesystem stats.
      *
      * No restart required: the system prompt is mutated in place, same mechanism
-     * already used for plan mode + pixel-fix chdir.
+     * used for pixel-fix chdir.
      *
      * Stored in a ref so `onToolEnd` (whose useCallback dep array is intentionally
      * empty to keep agent-loop options stable) can call the freshest version.
@@ -1011,189 +722,25 @@ export function App(props) {
             });
         }
     }, [props.settingsFile]);
-    const compactionAbortRef = useRef(null);
-    const compactConversation = useCallback(async (messages, signal) => {
-        const contextWindow = getContextWindow(currentModel, contextWindowOptions);
-        const tokensBefore = estimateConversationTokens(messages);
-        const spinId = getId();
-        log("INFO", "compaction", `Running compaction`, {
-            messages: String(messages.length),
-            estimatedTokens: String(tokensBefore),
-            contextWindow: String(contextWindow),
-        });
-        // 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;
-            let compactAccountId = activeAccountId;
-            let compactProjectId = activeProjectId;
-            let compactBaseUrl = activeBaseUrl;
-            if (props.authStorage) {
-                const creds = await props.authStorage.resolveCredentials(currentProvider);
-                compactApiKey = creds.accessToken;
-                compactAccountId = creds.accountId;
-                compactProjectId = creds.projectId;
-                compactBaseUrl = creds.baseUrl ?? compactBaseUrl;
-            }
-            const result = await compact(messages, {
-                provider: currentProvider,
-                model: currentModel,
-                apiKey: compactApiKey,
-                accountId: compactAccountId,
-                projectId: compactProjectId,
-                baseUrl: compactBaseUrl,
-                contextWindow,
-                signal: compactionSignal,
-                approvedPlanPath: approvedPlanPathRef.current,
-            });
-            if (result.result.compacted) {
-                // Replace spinner with completed notice
-                setLiveItems((prev) => prev.map((item) => item.id === spinId
-                    ? {
-                        kind: "compacted",
-                        originalCount: result.result.originalCount,
-                        newCount: result.result.newCount,
-                        tokensBefore: result.result.tokensBeforeEstimate,
-                        tokensAfter: result.result.tokensAfterEstimate,
-                        id: spinId,
-                    }
-                    : item));
-            }
-            else {
-                // Nothing was actually compacted — remove spinner silently
-                log("INFO", "compaction", `Compaction skipped: ${result.result.reason ?? "unknown"}`);
-                setLiveItems((prev) => prev.filter((item) => item.id !== spinId));
-            }
-            return result.messages;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            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;
-        }
-    }, [
+    const { compactionAbortRef, compactConversation, transformContext } = useContextCompaction({
         currentModel,
         currentProvider,
+        maxTokens: props.maxTokens,
+        authStorage: props.authStorage,
+        contextWindowOptions,
         activeApiKey,
         activeAccountId,
         activeProjectId,
         activeBaseUrl,
-        contextWindowOptions,
-        props.authStorage,
-    ]);
-    const getRepoMapSignalCount = useCallback(() => {
-        return ((props.repoMapChangedFilesRef?.current.size ?? 0) +
-            (props.repoMapReadFilesRef?.current.size ?? 0));
-    }, [props.repoMapChangedFilesRef, props.repoMapReadFilesRef]);
-    const getRepoMapBudget = useCallback(() => {
-        const userTurns = messagesRef.current.filter((message) => message.role === "user").length;
-        const readCount = props.repoMapReadFilesRef?.current.size ?? 0;
-        if (userTurns <= 1 && readCount === 0)
-            return FIRST_TURN_REPO_MAP_MAX_CHARS;
-        if (readCount > 0)
-            return FOCUSED_REPO_MAP_MAX_CHARS;
-        return FOCUSED_REPO_MAP_MAX_CHARS + 1000;
-    }, [props.repoMapReadFilesRef]);
-    const refreshRepoMap = useCallback(async (latestUserPrompt) => {
-        const rendered = await buildRepoMap({
-            cwd: cwdRef.current,
-            maxChars: getRepoMapBudget(),
-            changedFiles: [...(props.repoMapChangedFilesRef?.current ?? new Set())],
-            readFiles: [...(props.repoMapReadFilesRef?.current ?? new Set())],
-            focusTerms: latestUserPrompt ? [latestUserPrompt] : [],
-            cache: repoMapCacheRef.current,
-        });
-        repoMapMarkdownRef.current = rendered.markdown;
-        repoMapSnapshotRef.current = rendered.snapshot;
-        repoMapChangedCountRef.current = getRepoMapSignalCount();
-        repoMapDirtyRef.current = false;
-        return rendered.markdown;
-    }, [
-        getRepoMapBudget,
-        getRepoMapSignalCount,
-        props.repoMapChangedFilesRef,
-        props.repoMapReadFilesRef,
-    ]);
-    const stripRepoMapMessages = useCallback((messages) => {
-        return stripRepoMapContextMessages(messages);
-    }, []);
-    const injectRepoMapContext = useCallback(async (messages) => {
-        if (!repoMapInjectionEnabledRef.current)
-            return stripRepoMapMessages(messages);
-        const stripped = stripRepoMapMessages(messages);
-        const latestUserPrompt = getLatestUserText(stripped);
-        const signalCount = getRepoMapSignalCount();
-        if (signalCount !== repoMapChangedCountRef.current)
-            repoMapDirtyRef.current = true;
-        if (repoMapDirtyRef.current || !repoMapMarkdownRef.current) {
-            await refreshRepoMap(latestUserPrompt);
-        }
-        if (!repoMapMarkdownRef.current)
-            return stripped;
-        return injectRepoMapContextMessages(stripped, repoMapMarkdownRef.current);
-    }, [props.repoMapChangedFilesRef, props.repoMapReadFilesRef, refreshRepoMap, stripRepoMapMessages]);
-    /**
-     * transformContext callback for the agent loop.
-     * Called before each LLM call and on context overflow.
-     * Compacts persistent chat only, then injects the dynamic repo map transiently.
-     */
-    const transformContext = useCallback(async (messages, options) => {
-        const stripped = stripRepoMapMessages(messages);
-        const settings = settingsRef.current;
-        const autoCompact = settings?.get("autoCompact") ?? true;
-        const threshold = settings?.get("compactThreshold") ?? 0.8;
-        // Force-compact on context overflow regardless of settings
-        if (options?.force) {
-            const result = await compactConversation(stripped);
-            if (result !== stripped) {
-                messagesRef.current = result;
-                await persistCompactedSession(result);
-            }
-            lastCompactionTimeRef.current = Date.now();
-            return injectRepoMapContext(result);
-        }
-        if (!autoCompact)
-            return injectRepoMapContext(stripped);
-        // Time-based cooldown: skip if compaction ran within the last 30 seconds
-        if (Date.now() - lastCompactionTimeRef.current < 30_000) {
-            log("INFO", "compaction", `Skipping compaction — cooldown active`);
-            return injectRepoMapContext(stripped);
-        }
-        const contextWindow = getContextWindow(currentModel, contextWindowOptions);
-        const reserveTokens = getCompactionReserveTokens(props.maxTokens);
-        const tokensFresh = lastActualTokensTimestampRef.current > lastCompactionTimeRef.current;
-        const actualTokens = lastActualTokensRef.current > 0 && tokensFresh ? lastActualTokensRef.current : undefined;
-        if (shouldCompact(stripped, contextWindow, threshold, actualTokens, reserveTokens)) {
-            const result = await compactConversation(stripped);
-            if (result !== stripped) {
-                messagesRef.current = result;
-                await persistCompactedSession(result);
-            }
-            lastCompactionTimeRef.current = Date.now();
-            return injectRepoMapContext(result);
-        }
-        return injectRepoMapContext(stripped);
-    }, [
-        currentModel,
-        compactConversation,
-        contextWindowOptions,
-        injectRepoMapContext,
+        setLiveItems,
+        getId,
+        approvedPlanPathRef,
+        settingsRef,
+        messagesRef,
+        lastActualTokensRef,
+        lastActualTokensTimestampRef,
         persistCompactedSession,
-        stripRepoMapMessages,
-    ]);
+    });
     // ── Background task bar state (external store) ──────────
     const { bgTasks, focused: taskBarFocused, expanded: taskBarExpanded, selectedIndex: selectedTaskIndex, } = useTaskBarStore();
     useTaskBarPolling(props.processManager);
@@ -1225,16 +772,56 @@ export function App(props) {
         tools: currentTools,
         webSearch: props.webSearch,
         maxTokens: props.maxTokens,
-        thinking: thinkingEnabled ? getMaxThinkingLevel(currentModel) : undefined,
+        thinking: thinkingLevel,
         apiKey: activeApiKey,
         baseUrl: activeBaseUrl,
         accountId: activeAccountId,
         projectId: activeProjectId,
         resolveCredentials,
         transformContext,
+        getIdealReviewMessage: (stats) => {
+            if (!idealReviewEnabledRef.current)
+                return null;
+            const decision = evaluateIdealReview(stats);
+            if (!decision.shouldReview)
+                return null;
+            log("INFO", "ideal", "Injecting ideal review before final response", {
+                score: String(decision.score),
+                reasons: decision.reasons.join(", "),
+            });
+            setLiveItems((prev) => [
+                ...prev,
+                { kind: "ideal_hook", text: IDEAL_HOOK_NOTICE_TEXT, tone: "review", id: getId() },
+            ]);
+            return buildIdealReviewMessage(decision.reasons);
+        },
+        getLoopBreakMessage: (stats) => {
+            if (!idealReviewEnabledRef.current)
+                return null;
+            const decision = evaluateLoopBreak(stats);
+            if (!decision.shouldBreak)
+                return null;
+            log("INFO", "loop-break", "Injecting loop-break nudge", {
+                reasons: decision.reasons.join(", "),
+            });
+            setLiveItems((prev) => [
+                ...prev,
+                { kind: "ideal_hook", text: LOOP_BREAK_NOTICE_TEXT, tone: "warning", id: getId() },
+            ]);
+            return buildLoopBreakMessage(decision.reasons);
+        },
+        getRegroundingMessage: (originalRequest) => {
+            if (!idealReviewEnabledRef.current)
+                return null;
+            log("INFO", "reground", "Injecting re-grounding after compaction", {});
+            setLiveItems((prev) => [
+                ...prev,
+                { kind: "ideal_hook", text: REGROUNDING_NOTICE_TEXT, tone: "info", id: getId() },
+            ]);
+            return buildRegroundingMessage(originalRequest);
+        },
     }, {
         onComplete: useCallback(() => {
-            messagesRef.current = stripRepoMapMessages(messagesRef.current);
             persistNewMessages();
             // Auto-clear plan progress and approved plan when all steps are completed
             const steps = planStepsRef.current;
@@ -1287,8 +874,6 @@ export function App(props) {
             }
         }, [
             persistNewMessages,
-            stripRepoMapMessages,
-            planMode,
             props.cwd,
             props.skills,
             currentProvider,
@@ -1298,6 +883,8 @@ export function App(props) {
             resolveCredentials,
         ]),
         onTurnText: useCallback((text, thinking, thinkingMs) => {
+            const hadStreamedAssistantFlush = streamedAssistantFlushRef.current.flushedChars > 0;
+            const unflushedAssistantText = text.slice(streamedAssistantFlushRef.current.flushedChars);
             // Track [DONE:n] markers for plan step progress
             if (planStepsRef.current.length > 0) {
                 const completed = findCompletedMarkers(text);
@@ -1312,15 +899,9 @@ export function App(props) {
                     followUpNudgesRef.current = { step: 0, count: 0 };
                 }
             }
-            // Flush all completed items from the previous turn to Static history.
-            // This keeps liveItems bounded per-turn, preventing Ink's live area from
-            // growing unbounded, which makes Ink's live-area re-renders expensive.
-            //
-            // Items are queued in pendingFlushRef (not sent to setHistory directly)
-            // so the Static write happens in a SEPARATE render cycle from the
-            // live-area change — avoiding both Ink cursor-math clipping and the
-            // brief duplicate that occurred when setHistory was nested inside the
-            // setLiveItems updater.
+            // Flush completed rows from the previous turn to finalized terminal
+            // history. Ink keeps only the active turn, preventing live-area growth
+            // and avoiding Static/log-update replay during resize/remount churn.
             setLiveItems((prev) => {
                 const flushed = flushOnTurnText(prev);
                 if (flushed.length > 0) {
@@ -1329,10 +910,7 @@ export function App(props) {
                 // Split text on [DONE:N] markers so each marker renders inline as
                 // a styled "✓ Step N: <description>" item at the position the
                 // agent emitted it, instead of vanishing into stripped whitespace.
-                // Falls back to a single assistant item containing the
-                // marker-stripped text when there are no markers (keeps the
-                // common case zero-cost).
-                const segments = segmentDisplayText(text, planStepsRef.current);
+                const segments = segmentDisplayText(unflushedAssistantText, planStepsRef.current);
                 const items = [];
                 let thinkingAttached = false;
                 for (const seg of segments) {
@@ -1345,7 +923,7 @@ export function App(props) {
                             // contains multiple text chunks split by markers.
                             thinking: thinkingAttached ? undefined : thinking,
                             thinkingMs: thinkingAttached ? undefined : thinkingMs,
-                            planMode: planModeLocalRef.current,
+                            continuation: hadStreamedAssistantFlush,
                             id: getId(),
                         });
                         thinkingAttached = true;
@@ -1360,36 +938,54 @@ export function App(props) {
                     }
                 }
                 // No segments at all (text was empty/whitespace, no markers).
-                // Still emit an assistant item so a thinking block renders if
-                // there was thinking content for this turn.
+                // Still persist an assistant item so a thinking block renders in
+                // terminal history if there was thinking content for this turn.
                 if (items.length === 0) {
                     items.push({
                         kind: "assistant",
                         text: "",
                         thinking,
                         thinkingMs,
-                        planMode: planModeLocalRef.current,
                         id: getId(),
                     });
                 }
-                return items;
+                const assistantItems = prev.filter((item) => item.kind === "assistant");
+                const newAssistantText = normalizeAssistantText(unflushedAssistantText);
+                const duplicatePinnedText = newAssistantText.length > 0 &&
+                    [...assistantItems, ...pendingHistoryFlushRef.current, ...historyRef.current].some((item) => isSameAssistantText(item, newAssistantText));
+                const nextItems = duplicatePinnedText
+                    ? items.filter((item) => !isSameAssistantText(item, newAssistantText))
+                    : items;
+                const flushablePrev = prev.filter((item) => item.kind !== "assistant");
+                if (flushablePrev.length > 0)
+                    queueFlush(flushablePrev);
+                streamedAssistantFlushRef.current = { flushedChars: 0, text: "" };
+                return [...assistantItems, ...nextItems];
             });
-        }, []),
-        onToolStart: useCallback((toolCallId, name, args) => {
+        }, [queueFlush]),
+        onToolStart: useCallback((toolCallId, name, args, stream) => {
             log("INFO", "tool", `Tool call started: ${name}`, { id: toolCallId });
             const startedAt = Date.now();
             const animateUntil = startedAt + RUNNING_INDICATOR_ANIMATION_MS;
-            // Flush completed items (assistant text, finished tools) to Static
-            // before adding tool UI. Keeping both in the live area makes it tall
-            // and causes Ink's cursor math to clip the top.
-            setLiveItems((prev) => {
-                const { flushed, remaining } = partitionCompleted(prev);
+            // Feed the pinned LiveToolPanel. Keep a small tail (panel shows the
+            // last few rows) so memory stays bounded across long sessions.
+            setLiveToolFeed((prev) => [...prev, { id: toolCallId, name, args, status: "running" }].slice(-(LIVE_TOOL_PANEL_ROWS * 2)));
+            const appendToolStart = (prev) => {
+                const visible = pinStreamingTextBeforeToolBoundary({
+                    items: prev,
+                    visibleStreamingText: stream.text,
+                    thinking: stream.thinking,
+                    thinkingMs: stream.thinkingMs,
+                    makeId: getId,
+                });
+                const { flushed, remaining } = partitionCompleted(visible);
                 if (flushed.length > 0) {
                     queueFlush(flushed);
                 }
                 return remaining;
-            });
+            };
             if (name === "subagent") {
+                setLiveItems(appendToolStart);
                 // Create or update the sub-agent group item
                 const newAgent = {
                     toolCallId,
@@ -1414,25 +1010,32 @@ export function App(props) {
                 });
             }
             else if (AGGREGATABLE_TOOLS.has(name)) {
-                // Group concurrent read-only tools into a single compact item
                 setLiveItems((prev) => {
-                    // Find an active tool group (has at least one running tool)
-                    const groupIdx = prev.findIndex((item) => item.kind === "tool_group" &&
-                        item.tools.some((t) => t.status === "running"));
-                    if (groupIdx !== -1) {
-                        const group = prev[groupIdx];
-                        const next = [...prev];
-                        next[groupIdx] = {
-                            ...group,
-                            tools: [
-                                ...group.tools,
-                                { toolCallId, name, args, status: "running", animateUntil },
-                            ],
-                        };
-                        return next;
+                    const reusableGroupIdx = prev.findIndex((item) => item.kind === "tool_group" &&
+                        item.tools.every((tool) => tool.name === name && !tool.isError));
+                    const prior = reusableGroupIdx === -1 ? [] : prev.slice(0, reusableGroupIdx);
+                    if (reusableGroupIdx !== -1 && prior.every((item) => !isActiveItem(item))) {
+                        const flushablePrior = prior.filter((item) => item.kind !== "assistant");
+                        if (flushablePrior.length > 0)
+                            queueFlush(flushablePrior);
+                        const pinnedPrior = prior.filter((item) => item.kind === "assistant");
+                        const candidates = prev.slice(reusableGroupIdx);
+                        const group = candidates[0];
+                        return [
+                            ...pinnedPrior,
+                            {
+                                ...group,
+                                tools: [
+                                    ...group.tools,
+                                    { toolCallId, name, args, status: "running", animateUntil },
+                                ],
+                            },
+                            ...candidates.slice(1),
+                        ];
                     }
+                    const remaining = appendToolStart(prev);
                     return [
-                        ...prev,
+                        ...remaining,
                         {
                             kind: "tool_group",
                             tools: [{ toolCallId, name, args, status: "running", animateUntil }],
@@ -1443,11 +1046,11 @@ export function App(props) {
             }
             else {
                 setLiveItems((prev) => [
-                    ...prev,
+                    ...appendToolStart(prev),
                     { kind: "tool_start", toolCallId, name, args, id: getId(), startedAt, animateUntil },
                 ]);
             }
-        }, []),
+        }, [queueFlush]),
         onToolUpdate: useCallback((toolCallId, update) => {
             const u = update;
             // Bash progress streaming — append output to tool_start item
@@ -1489,6 +1092,17 @@ export function App(props) {
             });
         }, []),
         onToolEnd: useCallback((toolCallId, name, result, isError, durationMs, details) => {
+            recordToolEnd(sessionStatsRef.current, name, isError, durationMs);
+            setLiveToolFeed((prev) => prev.map((entry) => entry.id === toolCallId
+                ? { ...entry, status: "done", isError, result, details }
+                : entry));
+            if (name === "edit" && !isError) {
+                const diff = details?.diff ?? result;
+                addLinesChanged(sessionStatsRef.current, {
+                    added: (diff.match(/^\+[^+]/gm) ?? []).length,
+                    removed: (diff.match(/^-[^-]/gm) ?? []).length,
+                });
+            }
             // Language-pack detection — gated on `write`/`bash` inside the
             // helper; cheap to call unconditionally. Fire-and-forget; the next
             // LLM turn picks up the swapped system prompt automatically.
@@ -1520,7 +1134,7 @@ export function App(props) {
                     };
                     const next = [...prev];
                     next[groupIdx] = { ...group, agents: updatedAgents };
-                    // Flush completed items to Static to keep the live area small
+                    // Flush completed items to finalized history to keep the live area small
                     const { flushed, remaining } = partitionCompleted(next);
                     if (flushed.length > 0) {
                         queueFlush(flushed);
@@ -1530,6 +1144,19 @@ export function App(props) {
             }
             else {
                 setLiveItems((prev) => {
+                    if (name === "enter_plan") {
+                        const updated = prev
+                            .filter((item) => !(item.kind === "tool_start" && item.toolCallId === toolCallId))
+                            .map((item) => item.kind === "plan_transition" && item.active
+                            ? { ...item, active: false }
+                            : item);
+                        const { flushed, remaining } = partitionCompleted(updated);
+                        if (flushed.length > 0) {
+                            queueFlush(flushed);
+                            return remaining;
+                        }
+                        return updated;
+                    }
                     // Check if this tool is in a tool_group
                     const groupIdx = prev.findIndex((item) => item.kind === "tool_group" &&
                         item.tools.some((t) => t.toolCallId === toolCallId));
@@ -1557,6 +1184,7 @@ export function App(props) {
                                 isError,
                                 durationMs,
                                 details,
+                                imagePreviews: extractToolImagePreviews(details),
                                 id: startItem.id,
                             };
                             updated = [...prev];
@@ -1574,12 +1202,13 @@ export function App(props) {
                                     isError,
                                     durationMs,
                                     details,
+                                    imagePreviews: extractToolImagePreviews(details),
                                     id: getId(),
                                 },
                             ];
                         }
                     }
-                    // Flush completed items to Static to keep the live area small
+                    // Flush completed items to finalized history to keep the live area small
                     const { flushed, remaining } = partitionCompleted(updated);
                     if (flushed.length > 0) {
                         queueFlush(flushed);
@@ -1595,14 +1224,22 @@ export function App(props) {
                 });
             }
         }, []),
-        onServerToolCall: useCallback((id, name, input) => {
+        onServerToolCall: useCallback((id, name, input, stream) => {
+            recordServerToolCall(sessionStatsRef.current);
             log("INFO", "server_tool", `Server tool call: ${name}`, { id });
             const startedAt = Date.now();
             const animateUntil = startedAt + RUNNING_INDICATOR_ANIMATION_MS;
-            // Flush completed items (including assistant text) to Static before
-            // adding server tool UI — same rationale as onToolStart.
+            // Flush completed items (including assistant text) before adding server
+            // tool UI — same rationale as onToolStart.
             setLiveItems((prev) => {
-                const { flushed, remaining } = partitionCompleted(prev);
+                const visible = pinStreamingTextBeforeToolBoundary({
+                    items: prev,
+                    visibleStreamingText: stream.text,
+                    thinking: stream.thinking,
+                    thinkingMs: stream.thinkingMs,
+                    makeId: getId,
+                });
+                const { flushed, remaining } = partitionCompleted(visible);
                 if (flushed.length > 0) {
                     queueFlush(flushed);
                 }
@@ -1619,7 +1256,7 @@ export function App(props) {
                     },
                 ];
             });
-        }, []),
+        }, [queueFlush]),
         onServerToolResult: useCallback((toolUseId, resultType, data) => {
             log("INFO", "server_tool", `Server tool result`, { toolUseId, resultType });
             setLiveItems((prev) => {
@@ -1653,15 +1290,16 @@ export function App(props) {
                         },
                     ];
                 }
-                // Flush completed items to Static
+                // Flush completed items to finalized history
                 const { flushed, remaining } = partitionCompleted(updated);
                 if (flushed.length > 0) {
                     queueFlush(flushed);
                 }
                 return remaining;
             });
-        }, []),
+        }, [queueFlush]),
         onTurnEnd: useCallback((turn, stopReason, usage) => {
+            recordTurnEnd(sessionStatsRef.current, usage);
             log("INFO", "turn", `Turn ${turn} ended`, {
                 stopReason,
                 inputTokens: String(usage.inputTokens),
@@ -1676,8 +1314,8 @@ export function App(props) {
             lastActualTokensRef.current =
                 currentProvider === "anthropic" ? inputContext : inputContext + usage.outputTokens;
             lastActualTokensTimestampRef.current = Date.now();
-            // For tool-only turns (no text), flush completed items to Static so
-            // liveItems doesn't grow unbounded across consecutive tool-only turns.
+            // For tool-only turns (no text), flush completed items to finalized
+            // history so liveItems doesn't grow unbounded across consecutive turns.
             setLiveItems((prev) => {
                 const { flushed, remaining } = flushOnTurnEnd(prev, stopReason);
                 if (flushed.length > 0) {
@@ -1685,76 +1323,52 @@ export function App(props) {
                 }
                 return remaining;
             });
-        }, []),
-        onDone: useCallback((durationMs, toolsUsed, errored) => {
+        }, [queueFlush]),
+        onDone: useCallback((durationMs, toolsUsed) => {
             log("INFO", "agent", `Agent done`, {
                 duration: `${durationMs}ms`,
                 toolsUsed: toolsUsed.join(",") || "none",
             });
-            // Don't show "done" status when plan overlay is about to open —
-            // the agent loop finished but we're waiting for user plan review
-            if (planOverlayPendingRef.current)
-                return;
-            setDoneStatus({ durationMs, toolsUsed, verb: pickDurationVerb(toolsUsed) });
-            playNotificationSound();
-            // Two-phase flush to avoid Ink text clipping.
-            // Phase 1 (here): clear the live area so Ink commits a render with
-            // the smaller output and updates its internal line counter.
-            // Phase 2 (useEffect below): push items to Static history in a
-            // separate render cycle so the Static write never coincides with
-            // a live-area height change in the same frame.
-            setLiveItems((prev) => {
-                if (prev.length > 0)
-                    queueFlush(prev);
-                return [];
+            const doneDecision = getDoneFlushDecision({
+                planOverlayPending: planOverlayPendingRef.current,
             });
-            // Run-all: auto-start next pending task after a short delay
-            // (allow the two-phase flush to complete first)
+            // Don't show "done" status when the plan review pane is about to open —
+            // the agent loop finished but we're waiting for user approval/review.
+            // Still flush live transcript rows before the pane remounts; otherwise
+            // setup output remains in ephemeral liveItems and appears to vanish.
+            if (doneDecision.showDoneStatus) {
+                setDoneStatus({ durationMs, toolsUsed, verb: pickDurationVerb(toolsUsed) });
+                playNotificationSound();
+            }
+            // Keep the final assistant response mounted in the live frame after a
+            // normal chat turn finishes. Moving a large final response to terminal
+            // history at this moment writes many scrollback rows while the footer is
+            // still mounted, which visibly pushes the input/footer upward. The final
+            // response is flushed on the next submit before the new prompt is shown.
+            // Non-chat overlay transitions still flush so setup/plan output
+            // does not vanish during remounts.
+            if (doneDecision.flushLiveItems && !doneDecision.showDoneStatus) {
+                setLiveItems((prev) => {
+                    if (prev.length > 0)
+                        queueFlush(prev);
+                    return prev;
+                });
+            }
+            // Run-all: auto-start next pending task after a short delay.
             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]) {
-                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;
@@ -1796,16 +1410,6 @@ 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) => {
@@ -1851,42 +1455,16 @@ export function App(props) {
         }, []),
         onQueuedStart: useCallback((content) => {
             // When a queued message starts processing, show it as a UserItem
-            // and flush prior items to history. Synthetic system events are hidden
-            // from the transcript but still routed through the main agent context.
+            // and flush prior items to history.
             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;
-            setLiveItems((prev) => {
-                if (prev.length > 0)
-                    queueFlush(prev);
-                return [];
-            });
             const userItem = {
                 kind: "user",
                 text: displayText,
@@ -1895,8 +1473,8 @@ export function App(props) {
             };
             setLastUserMessage(displayText);
             setDoneStatus(null);
-            setLiveItems([userItem]);
-        }, []),
+            finalizeSubmittedUserItem(userItem);
+        }, [finalizeSubmittedUserItem]),
         // Inject a "continue with the next step" follow-up when the agent
         // would otherwise stop mid-plan. The prompt-only instruction wasn't
         // enough — some models (notably Opus) treat each [DONE:n] as a
@@ -1928,9 +1506,280 @@ export function App(props) {
             ];
         }, []),
     });
-    // First-time-per-project auto-run of /setup. Bound after `agentLoop` is in
-    // scope so the ref closure can dispatch to it. Called from the initial
-    // language-detection path when `isFirstTimeSetup(cwd)` is true. Pushes a
+    const continueGoalRun = useCallback((run) => {
+        const cwd = cwdRef.current;
+        const decision = decideGoalNextAction(run);
+        const choiceKey = getGoalContinuationChoiceKey({ runId: run.id, decision });
+        const now = Date.now();
+        for (const [key, timestamp] of goalContinuationRecentChoicesRef.current.entries()) {
+            if (now - timestamp > 5_000)
+                goalContinuationRecentChoicesRef.current.delete(key);
+        }
+        if (goalContinuationFlightsRef.current.has(choiceKey))
+            return;
+        const lastChosenAt = goalContinuationRecentChoicesRef.current.get(choiceKey);
+        if (lastChosenAt && now - lastChosenAt < 1_500)
+            return;
+        goalContinuationFlightsRef.current.add(choiceKey);
+        goalContinuationRecentChoicesRef.current.set(choiceKey, now);
+        const releaseChoice = () => {
+            setTimeout(() => goalContinuationFlightsRef.current.delete(choiceKey), 250);
+        };
+        void (async () => {
+            try {
+                if (decision.kind === "create_task") {
+                    const nextTask = createGoalTask({ title: decision.title, prompt: decision.prompt });
+                    const updated = await upsertGoalRun(cwd, {
+                        ...run,
+                        status: "ready",
+                        tasks: [...run.tasks, nextTask],
+                    });
+                    await appendGoalDecision(cwd, run.id, decision);
+                    appendGoalProgress({
+                        kind: "goal_progress",
+                        phase: "orchestrator_working",
+                        title: `Goal ${goalNumberForRun(run.id)} task queued`,
+                        detail: decision.reason,
+                        status: updated.status,
+                    });
+                    continueGoalRun(updated);
+                    return;
+                }
+                if (decision.kind === "start_worker") {
+                    const updatedRun = await updateGoalTask(cwd, run.id, decision.task.id, {
+                        status: "running",
+                        attempts: decision.attempts,
+                        lastSummary: `Worker attempt ${decision.attempts} running.`,
+                    });
+                    const taskForPrompt = updatedRun?.tasks.find((task) => task.id === decision.task.id) ?? {
+                        ...decision.task,
+                        attempts: decision.attempts,
+                    };
+                    const worker = await startGoalWorker({
+                        cwd,
+                        goalRunId: run.id,
+                        goalTaskId: taskForPrompt.id,
+                        taskTitle: taskForPrompt.title,
+                        provider: currentProviderRef.current,
+                        model: currentModelRef.current,
+                        prompt: taskForPrompt.prompt,
+                    });
+                    upsertGoalStatusEntry({
+                        runId: run.id,
+                        label: run.title,
+                        phase: "worker",
+                        detail: `Worker: ${decision.task.title}`,
+                        workerId: worker.id,
+                        startedAt: Date.now(),
+                    });
+                    appendGoalProgress({
+                        kind: "goal_progress",
+                        phase: "worker_started",
+                        title: `Goal ${goalNumberForRun(run.id)} worker started`,
+                        detail: decision.task.title,
+                        workerId: worker.id,
+                        status: "running",
+                    });
+                    return;
+                }
+                if (decision.kind === "run_verifier") {
+                    if (activeVerifierRunIdsRef.current.has(run.id))
+                        return;
+                    activeVerifierRunIdsRef.current.add(run.id);
+                    upsertGoalStatusEntry({
+                        runId: run.id,
+                        label: run.title,
+                        phase: "verifier",
+                        detail: "Verifier running",
+                        startedAt: Date.now(),
+                    });
+                    appendGoalProgress({
+                        kind: "goal_progress",
+                        phase: "verifier_started",
+                        title: `Goal ${goalNumberForRun(run.id)} verifier started`,
+                        detail: decision.command,
+                        status: "running",
+                    });
+                    try {
+                        const completed = await runGoalVerifierCommand({
+                            cwd,
+                            runId: run.id,
+                            command: decision.command,
+                        });
+                        const verification = completed.verification;
+                        const verificationStatus = verification.status === "pass" ? "pass" : "fail";
+                        const latestBeforeVerifier = (await loadGoalRuns(cwd)).find((candidate) => candidate.id === run.id) ?? run;
+                        const latest = await upsertGoalRun(cwd, {
+                            ...latestBeforeVerifier,
+                            status: verificationStatus === "pass" ? "passed" : "ready",
+                            verifier: {
+                                ...(latestBeforeVerifier.verifier ?? { description: "Goal verifier" }),
+                                command: verification.command ?? decision.command,
+                                lastResult: verification,
+                            },
+                        });
+                        await appendGoalEvidence(cwd, run.id, {
+                            kind: "log",
+                            label: "Verifier result",
+                            content: formatGoalVerifierCompletionEvent(latest, verificationStatus, verification.command ?? decision.command, verification.exitCode ?? (verificationStatus === "pass" ? 0 : 1), verification.summary),
+                            ...(verification.outputPath ? { path: verification.outputPath } : {}),
+                        });
+                        appendGoalProgress({
+                            kind: "goal_progress",
+                            phase: "verifier_finished",
+                            title: `Goal ${goalNumberForRun(run.id)} verifier ${verificationStatus}`,
+                            detail: verification.summary,
+                            status: verificationStatus,
+                        });
+                        upsertGoalStatusEntry({
+                            runId: run.id,
+                            label: latest.title,
+                            phase: verificationStatus === "pass" ? "reviewing" : "failed",
+                            detail: verificationStatus === "pass" ? "Verifier passed" : "Verifier failed",
+                            startedAt: Date.now(),
+                        });
+                        continueGoalRun(latest);
+                    }
+                    catch (error) {
+                        appendGoalProgress({
+                            kind: "goal_progress",
+                            phase: "verifier_finished",
+                            title: `Goal ${goalNumberForRun(run.id)} verifier failed`,
+                            detail: error instanceof Error ? error.message : String(error),
+                            status: "failed",
+                        });
+                    }
+                    finally {
+                        activeVerifierRunIdsRef.current.delete(run.id);
+                    }
+                    return;
+                }
+                if (decision.kind === "complete") {
+                    const completion = canCompleteGoalRun(run);
+                    const updated = await upsertGoalRun(cwd, { ...run, status: "passed" });
+                    const summary = completion.ok
+                        ? "Verifier evidence proves the Goal success criteria."
+                        : goalCompletionReason(completion);
+                    await appendGoalDecision(cwd, run.id, {
+                        kind: "summary",
+                        content: summary,
+                    });
+                    appendGoalProgress({
+                        kind: "goal_progress",
+                        phase: "terminal",
+                        title: `Goal passed: ${updated.title}`,
+                        detail: summary,
+                        status: updated.status,
+                    });
+                    clearGoalStatusEntry(run.id);
+                    return;
+                }
+                if (decision.kind === "pause") {
+                    const updated = await upsertGoalRun(cwd, {
+                        ...run,
+                        status: "paused",
+                        blockers: [...run.blockers, decision.reason],
+                    });
+                    await appendGoalDecision(cwd, run.id, decision);
+                    upsertGoalStatusEntry({
+                        runId: updated.id,
+                        label: updated.title,
+                        phase: "failed",
+                        detail: decision.reason,
+                        startedAt: Date.now(),
+                    });
+                    appendGoalProgress({
+                        kind: "goal_progress",
+                        phase: "terminal",
+                        title: `Goal paused: ${updated.title}`,
+                        detail: decision.reason,
+                        summaryRows: buildGoalSummaryRows(updated),
+                        status: "paused",
+                    });
+                    return;
+                }
+                if (decision.kind === "terminal") {
+                    const updated = await upsertGoalRun(cwd, { ...run, status: decision.status });
+                    if (decision.status === "passed")
+                        clearGoalStatusEntry(run.id);
+                    appendGoalProgress({
+                        kind: "goal_progress",
+                        phase: "terminal",
+                        title: `Goal ${decision.status}: ${updated.title}`,
+                        detail: decision.reason,
+                        summaryRows: buildGoalSummaryRows(updated),
+                        status: decision.status,
+                    });
+                    return;
+                }
+                if (decision.kind === "blocked") {
+                    const updated = await upsertGoalRun(cwd, {
+                        ...run,
+                        status: "blocked",
+                        blockers: [...run.blockers, decision.reason],
+                    });
+                    upsertGoalStatusEntry({
+                        runId: updated.id,
+                        label: updated.title,
+                        phase: "failed",
+                        detail: decision.reason,
+                        startedAt: Date.now(),
+                    });
+                    appendGoalProgress({
+                        kind: "goal_progress",
+                        phase: "terminal",
+                        title: `Goal ${goalNumberForRun(run.id)} blocked`,
+                        detail: decision.reason,
+                        status: "blocked",
+                    });
+                }
+            }
+            finally {
+                releaseChoice();
+            }
+        })();
+    }, [appendGoalProgress, clearGoalStatusEntry, goalNumberForRun, upsertGoalStatusEntry]);
+    const handleGoalWorkerCompletion = useCallback((completion) => {
+        const cwd = cwdRef.current;
+        runningGoalIdsRef.current.delete(completion.worker.goalRunId);
+        void (async () => {
+            const run = (await loadGoalRuns(cwd)).find((candidate) => candidate.id === completion.worker.goalRunId);
+            const taskTitle = run?.tasks.find((task) => task.id === completion.worker.goalTaskId)?.title ??
+                completion.worker.goalTaskId;
+            await appendGoalEvidence(cwd, completion.worker.goalRunId, {
+                kind: "log",
+                label: formatGoalWorkerFinishedTitle(taskTitle, completion.status),
+                content: run
+                    ? formatGoalWorkerCompletionEvent(run, taskTitle, completion)
+                    : completion.summary,
+                path: completion.worker.logFile,
+            });
+            appendGoalProgress({
+                kind: "goal_progress",
+                phase: "worker_finished",
+                status: completion.status === "done" ? "done" : "failed",
+                title: formatGoalWorkerFinishedTitle(taskTitle, completion.status),
+                detail: summarizeGoalCompletion(completion.summary),
+                workerId: completion.worker.id,
+            });
+            if (!run) {
+                clearGoalStatusEntry(completion.worker.goalRunId);
+                return;
+            }
+            upsertGoalStatusEntry({
+                runId: run.id,
+                label: run.title,
+                phase: completion.status === "done" ? "orchestrating" : "failed",
+                detail: completion.status === "done" ? "Worker finished" : "Worker failed",
+                startedAt: Date.now(),
+            });
+            continueGoalRun(run);
+        })();
+    }, [appendGoalProgress, clearGoalStatusEntry, continueGoalRun, upsertGoalStatusEntry]);
+    useEffect(() => subscribeGoalWorkerCompletions(handleGoalWorkerCompletion), [handleGoalWorkerCompletion]);
+    // First-time-per-project auto-run of /setup. Bound after `agentLoop` is in
+    // scope so the ref closure can dispatch to it. Called from the initial
+    // language-detection path when `isFirstTimeSetup(cwd)` is true. Pushes a
     // notice item explaining what's happening, then runs the audit prompt.
     triggerAutoSetupRef.current = async () => {
         const setupCmd = getPromptCommand("setup");
@@ -1966,27 +1815,6 @@ export function App(props) {
             ]);
         }
     };
-    // Phase 2 of the two-phase flush: after onDone clears liveItems (phase 1)
-    // and Ink renders the smaller live area (updating its internal line
-    // counter), this effect pushes the stashed items into Static history.
-    // Because the Static write happens in a SEPARATE render cycle from the
-    // live-area shrink, Ink's log-update never needs to erase the old tall
-    // live area AND write Static content in the same frame — avoiding the
-    // cursor-math mismatch that caused text clipping.
-    useEffect(() => {
-        if (pendingFlushRef.current.length > 0) {
-            const items = pendingFlushRef.current;
-            pendingFlushRef.current = [];
-            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
     useEffect(() => {
         setTitleRunning(agentLoop.isRunning);
@@ -2014,10 +1842,28 @@ export function App(props) {
             return () => clearTimeout(timer);
         }
     }, [agentLoop.isRunning, sessionStore, props.resetUI]);
-    // Consume sessionStore.pendingAction once on mount. Set by resetUI options
-    // for paths that remount AND immediately drive the agent (plan accept,
-    // plan reject, startTask, pixel fix). The action survives the unmount
-    // because it lives in renderApp's closure (sessionStore), not React state.
+    const showSessionSummaryAndExit = useCallback(() => {
+        const summary = buildSessionSummary({
+            stats: sessionStatsRef.current,
+            provider: currentProvider,
+            model: currentModel,
+            cwd: displayedCwd,
+            footer: sessionStatsRef.current.sessionId
+                ? `To resume this session: ezcoder --resume ${sessionStatsRef.current.sessionId}`
+                : undefined,
+        });
+        setDoneStatus(null);
+        setExitPending(false);
+        setOverlay(null);
+        setLiveItems([]);
+        setQuittingSummary(summary);
+        writeStdout("\x1b[2J\x1b[3J\x1b[H");
+        setTimeout(() => process.exit(0), 150);
+    }, [currentModel, currentProvider, displayedCwd, writeStdout]);
+    // Consume pending post-remount work once on mount. Set by resetUI options
+    // for paths that remount AND immediately drive work (plan accept/reject,
+    // pixel fix, plan accept/reject). The work survives the unmount because
+    // it lives in renderApp's closure (sessionStore), not React state.
     useEffect(() => {
         if (pendingActionConsumedRef.current)
             return;
@@ -2025,8 +1871,10 @@ export function App(props) {
         if (!action)
             return;
         pendingActionConsumedRef.current = true;
-        if (sessionStore)
+        if (sessionStore) {
             sessionStore.pendingAction = undefined;
+        }
+        setDoneStatus(null);
         if (action.planEvent) {
             const ev = action.planEvent;
             setLiveItems((prev) => [
@@ -2040,7 +1888,6 @@ export function App(props) {
                 { kind: "info", text: action.infoText, id: getId() },
             ]);
         }
-        setDoneStatus(null);
         void agentLoop.run(action.prompt).catch((err) => {
             const errMsg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", errMsg);
@@ -2048,14 +1895,6 @@ export function App(props) {
         });
         // Intentional one-shot: run once on mount, never re-fire on re-render.
     }, []);
-    // Refresh eyes badge count when the agent settles (end of a turn) — a turn
-    // may have logged new rough/wish/blocked signals. Also covers the case where
-    // /eyes was run for the first time (manifest now exists).
-    useEffect(() => {
-        if (!agentLoop.isRunning) {
-            setEyesCount(isEyesActive(props.cwd) ? journalCount({ status: "open" }, props.cwd) : undefined);
-        }
-    }, [agentLoop.isRunning, props.cwd]);
     const handleSubmit = useCallback(async (input, inputImages = [], pasteInfo) => {
         const trimmed = input.trim();
         if (trimmed.startsWith("/")) {
@@ -2070,241 +1909,141 @@ export function App(props) {
             // has not grown.
             await applyLanguageDetectionRef.current("input");
         }
-        // Handle /model directly — open inline selector
-        if (trimmed === "/model" || trimmed === "/m" || trimmed === "/models") {
-            setOverlay("model");
-            return;
-        }
-        // Handle /compact — compact conversation
-        if (trimmed === "/compact" || trimmed === "/c") {
-            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
-        if (trimmed === "/quit" || trimmed === "/q" || trimmed === "/exit") {
-            process.exit(0);
-        }
-        // Handle /clear — tear down the entire Ink instance and rebuild fresh.
-        // 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 () => {
-                    const newPrompt = await rebuildSystemPrompt({ clearApprovedPlan: true });
-                    props.resetUI?.({
-                        wipeSession: true,
-                        messages: [{ role: "system", content: newPrompt }],
-                    });
-                })();
-                return;
-            }
-            // Fallback path (resetUI not wired — e.g. tests). Best-effort: clear
-            // React state in place without touching terminal scrollback.
-            pendingFlushRef.current = [];
-            setHistory([{ kind: "banner", id: "banner" }]);
-            setLiveItems([]);
-            setDoneStatus(null);
-            approvedPlanPathRef.current = undefined;
-            planStepsRef.current = [];
-            setPlanSteps([]);
-            void (async () => {
-                const newPrompt = await rebuildSystemPrompt({ clearApprovedPlan: true });
-                messagesRef.current = [{ role: "system", content: newPrompt }];
-                persistedIndexRef.current = messagesRef.current.length;
-            })();
-            agentLoop.reset();
-            setSessionTitle(undefined);
-            sessionTitleGeneratedRef.current = false;
-            setLiveItems([{ kind: "info", text: "Session cleared.", id: getId() }]);
-            return;
-        }
-        // Handle /theme — open theme selector overlay
-        if (trimmed === "/theme" || trimmed === "/t") {
-            setOverlay("theme");
-            return;
-        }
-        // Open the Eyes pane — read-only review of installed probes + open signals.
-        // Gated by the ezcoder-eyes manifest: in projects without /eyes set up,
-        // there's nothing useful to show.
-        if (trimmed === "/eyes-view" || trimmed === "/ev") {
-            if (!isEyesActive(props.cwd)) {
-                setLiveItems((prev) => [
-                    ...prev,
-                    {
-                        kind: "info",
-                        text: "Eyes not set up in this project. Run /setup-eyes to get started.",
-                        id: getId(),
-                    },
-                ]);
-                return;
+        if (trimmed === "/ideal-on" || trimmed === "/ideal-off") {
+            const next = trimmed === "/ideal-on";
+            setIdealReviewEnabled(next);
+            if (props.settingsFile) {
+                const sm = new SettingsManager(props.settingsFile);
+                await sm.load();
+                await sm.set("idealReviewEnabled", next);
             }
-            setOverlay("eyes");
-            return;
-        }
-        // Handle /plan — toggle plan mode
-        if (trimmed === "/plan" || trimmed === "/plan on") {
-            setPlanMode(true);
-            setLiveItems((prev) => [
-                ...prev,
-                { kind: "plan_transition", text: "Plan Mode Activated", active: true, id: getId() },
-            ]);
-            return;
-        }
-        if (trimmed === "/plan off") {
-            setPlanMode(false);
             setLiveItems((prev) => [
                 ...prev,
                 {
-                    kind: "plan_transition",
-                    text: "Plan Mode Deactivated",
-                    active: false,
+                    kind: "info",
+                    text: next
+                        ? "Ideal review enabled. Use /ideal-off to disable it."
+                        : "Ideal review disabled. Use /ideal-on to enable it.",
                     id: getId(),
                 },
             ]);
             return;
         }
-        // Handle /clearplan — dismiss the approved plan
-        if (trimmed === "/clearplan") {
-            approvedPlanPathRef.current = undefined;
-            planStepsRef.current = [];
-            setPlanSteps([]);
-            // Rebuild system prompt without the plan
-            void replaceSystemPrompt({ clearApprovedPlan: true });
-            setLiveItems([{ kind: "plan_event", event: "dismissed", id: getId() }]);
-            return;
-        }
-        // Handle /map — show, refresh, or toggle dynamic repo map injection
-        if (trimmed === "/map" ||
-            trimmed === "/map refresh" ||
-            trimmed === "/map on" ||
-            trimmed === "/map off") {
-            const action = trimmed.slice("/map".length).trim();
-            if (action === "on") {
-                repoMapInjectionEnabledRef.current = true;
-                repoMapDirtyRef.current = true;
+        // /rewind — open the checkpoint picker (needs React state + the store).
+        if (trimmed === "/rewind") {
+            const store = props.checkpointStore;
+            if (!store) {
                 setLiveItems((prev) => [
                     ...prev,
-                    { kind: "info", text: "Dynamic repo map injection is on.", id: getId() },
+                    { kind: "info", text: "Checkpoints are not available in this session.", id: getId() },
                 ]);
                 return;
             }
-            if (action === "off") {
-                repoMapInjectionEnabledRef.current = false;
-                messagesRef.current = stripRepoMapMessages(messagesRef.current);
+            const cps = await store.listCheckpoints();
+            if (cps.length === 0) {
                 setLiveItems((prev) => [
                     ...prev,
                     {
                         kind: "info",
-                        text: "Dynamic repo map injection is off for this session.",
+                        text: "No checkpoints yet \u2014 edit a file through ezcoder first.",
                         id: getId(),
                     },
                 ]);
                 return;
             }
-            if (action === "refresh")
-                repoMapDirtyRef.current = true;
-            const markdown = await refreshRepoMap(getLatestUserText(messagesRef.current));
-            setLiveItems((prev) => [
-                ...prev,
-                {
-                    kind: "info",
-                    text: formatRepoMapCommandOutput(repoMapInjectionEnabledRef.current, markdown, action === "refresh"),
-                    id: getId(),
-                },
-            ]);
+            setRewindCheckpoints(cps);
             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;
+        if (await handleUiSlashCommand(trimmed, {
+            openModelSelector: () => setOverlay("model"),
+            compactConversation: async () => {
+                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);
                 }
-                setPlanAutoExpand(false);
-                setOverlay("goal");
-            }
-            return;
-        }
-        // Handle /plans — open plan pane
-        if (trimmed === "/plans") {
-            if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
-                props.sessionStore.overlay = "plan";
-                props.sessionStore.planAutoExpand = false;
-                props.resetUI();
-            }
-            else {
-                if (props.sessionStore) {
-                    props.sessionStore.overlay = "plan";
-                    props.sessionStore.planAutoExpand = false;
-                    if (agentLoop.isRunning)
-                        props.sessionStore.pendingResetUI = true;
+                if (compactionAbortRef.current === ac)
+                    compactionAbortRef.current = null;
+            },
+            quit: showSessionSummaryAndExit,
+            clearSession: () => {
+                if (props.resetUI) {
+                    void (async () => {
+                        const newPrompt = await rebuildSystemPrompt({ clearApprovedPlan: true });
+                        props.resetUI?.({
+                            wipeSession: true,
+                            messages: [{ role: "system", content: newPrompt }],
+                        });
+                    })();
+                    return;
                 }
-                setPlanAutoExpand(false);
-                setOverlay("plan");
-            }
+                clearPendingHistory();
+                setHistory([{ kind: "banner", id: "banner" }]);
+                setLiveItems([]);
+                setDoneStatus(null);
+                approvedPlanPathRef.current = undefined;
+                planStepsRef.current = [];
+                setPlanSteps([]);
+                void (async () => {
+                    const newPrompt = await rebuildSystemPrompt({ clearApprovedPlan: true });
+                    messagesRef.current = [{ role: "system", content: newPrompt }];
+                    persistedIndexRef.current = messagesRef.current.length;
+                })();
+                agentLoop.reset();
+                setSessionTitle(undefined);
+                sessionTitleGeneratedRef.current = false;
+                setLiveItems([{ kind: "info", text: "Session cleared.", id: getId() }]);
+            },
+            openThemeSelector: () => setOverlay("theme"),
+            toggleMarkdown: () => {
+                setRenderMarkdown((prev) => {
+                    const next = !prev;
+                    setLiveItems([
+                        {
+                            kind: "info",
+                            text: next ? "Rendered markdown mode." : "Raw markdown mode.",
+                            id: getId(),
+                        },
+                    ]);
+                    return next;
+                });
+            },
+            clearApprovedPlan: () => {
+                approvedPlanPathRef.current = undefined;
+                planStepsRef.current = [];
+                setPlanSteps([]);
+                void replaceSystemPrompt({ clearApprovedPlan: true });
+                setLiveItems([{ kind: "plan_event", event: "dismissed", id: getId() }]);
+            },
+        })) {
             return;
         }
-        // Handle prompt-template commands (built-in + custom from .ezcoder/commands/)
-        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];
+        if (await submitPromptCommand({
+            trimmed,
+            inputImages,
+            currentModel,
+            customCommands,
+            setLastUserMessage,
+            setDoneStatus,
+            finalizeSubmittedUserItem,
+            runAgent: (content) => agentLoop.run(content),
+            setLiveItems,
+            getId,
+            reloadCustomCommands,
+            messagesRef,
+            setGoalModeAndPrompt,
+            onGoalStage: appendGoalAgentTransition,
+            onGoalSetupComplete: () => {
+                setGoalAutoExpand(true);
+                if (props.sessionStore) {
+                    props.sessionStore.overlay = "goal";
+                    props.sessionStore.goalAutoExpand = true;
                 }
-                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();
+                setOverlay("goal");
+            },
+        })) {
             return;
         }
         // Check slash commands
@@ -2323,7 +2062,7 @@ export function App(props) {
         // ── Queue message if agent is already running ──
         if (agentLoop.isRunning) {
             log("INFO", "queue", `Queued message: ${trimmed.length > 80 ? trimmed.slice(0, 80) + "..." : trimmed}`);
-            agentLoop.queueMessage(userContent);
+            agentLoop.queueMessage(userContent, input);
             let displayText = input;
             if (hasImages) {
                 const { cleanText } = await extractImagePaths(input, props.cwd);
@@ -2338,31 +2077,32 @@ export function App(props) {
             setLiveItems((prev) => [...prev, queuedItem]);
             return;
         }
-        // Move any remaining live items into history (Static) before starting a
-        // new turn. Must go through queueFlush so flushGeneration bumps and the
-        // drain effect actually runs — mutating pendingFlushRef directly here
-        // stashed items that nothing was signalled to pick up, so they sat in
-        // limbo until some unrelated later code path happened to call queueFlush.
-        setLiveItems((prev) => {
-            if (prev.length > 0) {
-                queueFlush(prev);
-            }
-            return [];
-        });
         // Build display text — strip image paths, show badges instead
         let displayText = input;
         if (hasImages) {
             const { cleanText } = await extractImagePaths(input, props.cwd);
             displayText = cleanText;
         }
+        let imagePreviews;
+        if (hasImages) {
+            const built = await Promise.all(inputImages
+                .filter((img) => img.kind === "image")
+                .map(async (img) => {
+                const downscaled = await downscaleForPreview(Buffer.from(img.data, "base64"));
+                return { base64: downscaled.toString("base64"), mediaType: img.mediaType };
+            }));
+            imagePreviews = built.length > 0 ? built : undefined;
+        }
         const userItem = {
             kind: "user",
             text: displayText,
             imageCount: hasImages ? inputImages.length : undefined,
+            imagePreviews,
             pasteInfo,
             id: getId(),
         };
         setLastUserMessage(input);
+        setScrollResetToken((token) => token + 1);
         setDoneStatus(null);
         // Clear stale plan progress if there's no active approved plan
         // (avoids lingering progress from a completed or abandoned plan run)
@@ -2370,7 +2110,18 @@ export function App(props) {
             planStepsRef.current = [];
             setPlanSteps([]);
         }
-        setLiveItems([userItem]);
+        finalizeSubmittedUserItem(userItem, liveItems);
+        // Open a per-turn checkpoint capturing the conversation position right
+        // before this exchange, so /rewind can restore pre-turn code/chat state.
+        if (props.checkpointStore) {
+            rewindTurnRef.current += 1;
+            await props.checkpointStore
+                .openCheckpoint({
+                turnIndex: rewindTurnRef.current,
+                messageIndex: messagesRef.current.length,
+            })
+                .catch(() => { });
+        }
         // Run agent
         try {
             await agentLoop.run(userContent);
@@ -2388,17 +2139,29 @@ export function App(props) {
         }
     }, [
         agentLoop,
-        props.onSlashCommand,
         compactConversation,
+        currentModel,
+        finalizeSubmittedUserItem,
+        liveItems,
+        props.cwd,
+        props.onSlashCommand,
+        props.resetUI,
+        props.sessionStore,
         rebuildSystemPrompt,
+        showSessionSummaryAndExit,
+        reloadCustomCommands,
         replaceSystemPrompt,
-        refreshRepoMap,
-        stripRepoMapMessages,
     ]);
-    const handleDoubleExit = useDoublePress(setExitPending, () => process.exit(0));
+    const handleDoubleExit = useDoublePress(setExitPending, showSessionSummaryAndExit);
     const handleAbort = useCallback(() => {
         if (agentLoop.isRunning) {
-            agentLoop.clearQueue();
+            // Restore any unsent queued messages to the composer instead of dropping
+            // them, so an interrupt never silently discards what the user typed.
+            const queuedText = agentLoop.drainQueuedText();
+            if (queuedText) {
+                setLiveItems((prev) => prev.filter((item) => item.kind !== "queued"));
+                setComposerInject({ text: queuedText, nonce: nextIdRef.current++ });
+            }
             agentLoop.abort();
         }
         else if (compactionAbortRef.current) {
@@ -2407,22 +2170,22 @@ export function App(props) {
         else {
             handleDoubleExit();
         }
-    }, [agentLoop, handleDoubleExit]);
+    }, [agentLoop, handleDoubleExit, setLiveItems]);
     const handleToggleThinking = useCallback(() => {
-        setThinkingEnabled((prev) => {
-            const next = !prev;
-            log("INFO", "thinking", `Thinking ${next ? "enabled" : "disabled"}`);
-            setLiveItems((items) => [
-                ...items,
-                { kind: "thinking_transition", active: next, id: getId() },
-            ]);
+        setThinkingLevel((prev) => {
+            const next = getNextThinkingLevel(currentProvider, currentModel, prev);
+            log("INFO", "thinking", next ? `Thinking ${next}` : "Thinking disabled");
             if (props.settingsFile) {
                 const sm = new SettingsManager(props.settingsFile);
-                sm.load().then(() => sm.set("thinkingEnabled", next));
+                void sm.load().then(async () => {
+                    await sm.set("thinkingEnabled", !!next);
+                    if (next)
+                        await sm.set("thinkingLevel", next);
+                });
             }
             return next;
         });
-    }, [props.settingsFile]);
+    }, [currentProvider, currentModel, props.settingsFile]);
     const handleModelSelect = useCallback((value) => {
         setOverlay(null);
         const colonIdx = value.indexOf(":");
@@ -2431,6 +2194,9 @@ export function App(props) {
         const newProvider = value.slice(0, colonIdx);
         const newModelId = value.slice(colonIdx + 1);
         log("INFO", "model", `Model changed`, { provider: newProvider, model: newModelId });
+        // Keep the ref in sync before any prompt rebuild so the identity (Claude
+        // Code vs EZ Coder) reflects the newly selected provider immediately.
+        currentProviderRef.current = newProvider;
         const rebuildPromptWithTools = (tools) => {
             currentToolsRef.current = tools;
             void replaceSystemPrompt({ tools });
@@ -2530,214 +2296,179 @@ export function App(props) {
         const promptByName = new Map(PROMPT_COMMANDS.map((c) => [c.name, c]));
         const fromPrompt = (name) => {
             const c = promptByName.get(name);
-            return c ? { name: c.name, aliases: c.aliases, description: c.description } : null;
+            return c
+                ? {
+                    name: c.name,
+                    aliases: c.aliases,
+                    description: c.description,
+                    sectionTitle: "workflows",
+                }
+                : null;
         };
         const promptOrder = [
             // Project audits / one-shot analysis
-            "goal",
             "init",
-            "research",
-            "scan",
-            "verify",
             "expand",
             "bullet-proof",
-            "simplify",
             "compare",
-            "batch",
             // Setup / installers
-            "setup-lint",
-            "setup-tests",
             "setup-commit",
-            "setup-update",
-            "setup-eyes",
-            "eyes-improve",
             "setup-skills",
         ];
         const orderedPromptCommands = promptOrder
             .map(fromPrompt)
             .filter((c) => c !== null);
         const knownPromptNames = new Set(promptOrder);
-        const remainingPromptCommands = PROMPT_COMMANDS.filter((c) => !knownPromptNames.has(c.name)).map((c) => ({ name: c.name, aliases: c.aliases, description: c.description }));
+        const remainingPromptCommands = PROMPT_COMMANDS.filter((c) => !knownPromptNames.has(c.name)).map((c) => ({
+            name: c.name,
+            aliases: c.aliases,
+            description: c.description,
+            sectionTitle: "workflows",
+        }));
         return [
             // Session actions (most frequent)
-            { name: "model", aliases: ["m"], description: "Switch model" },
-            { name: "compact", aliases: ["c"], description: "Compact conversation" },
-            { name: "clear", aliases: [], description: "Clear session and terminal" },
-            { name: "theme", aliases: ["t"], description: "Switch theme" },
-            { name: "plans", aliases: [], description: "Open plans pane" },
+            { name: "model", aliases: ["m"], description: "Switch model", sectionTitle: "built-in" },
+            { name: "compact", aliases: ["c"], description: "Compact context", sectionTitle: "built-in" },
+            { name: "clear", aliases: [], description: "Clear session", sectionTitle: "built-in" },
+            { name: "theme", aliases: ["t"], description: "Switch theme", sectionTitle: "built-in" },
+            {
+                name: idealReviewEnabled ? "ideal-off" : "ideal-on",
+                aliases: [],
+                description: idealReviewEnabled
+                    ? "Disable pre-final ideal review"
+                    : "Enable pre-final ideal review",
+                sectionTitle: "built-in",
+            },
+            {
+                name: "rewind",
+                aliases: [],
+                description: "Restore files/conversation to a checkpoint",
+                sectionTitle: "built-in",
+            },
             ...orderedPromptCommands,
             ...remainingPromptCommands,
             ...customCommands.map((cmd) => ({
                 name: cmd.name,
                 aliases: [],
                 description: cmd.description,
+                sectionTitle: "custom",
             })),
-            { name: "quit", aliases: ["q", "exit"], description: "Exit the agent" },
+            {
+                name: "quit",
+                aliases: ["q", "exit"],
+                description: "Exit ezcoder",
+                sectionTitle: "built-in",
+            },
         ];
-    }, [customCommands]);
-    const renderItem = (item) => {
-        switch (item.kind) {
-            case "tombstone":
-                return null;
-            case "banner":
-                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";
-                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, flexDirection: "column", borderStyle: "round", borderColor: theme.language, paddingX: 1, children: [_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.language, bold: true, children: "◆ " }), _jsx(Text, { color: theme.language, bold: true, children: headerLabel })] }), _jsx(Text, { color: theme.text, bold: true, wrap: "wrap", children: names.join(", ") }), item.showSetupHint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.textMuted, children: "Tip: run " }), _jsx(Text, { color: theme.language, bold: true, children: "/setup" }), _jsx(Text, { color: theme.textMuted, children: " to audit this project against the active pack(s)" })] }) }))] }, item.id));
-            }
-            case "setup_hint":
-                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, flexDirection: "column", borderStyle: "round", borderColor: theme.language, paddingX: 1, children: [_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.language, bold: true, children: "◆ " }), _jsx(Text, { color: theme.language, bold: true, children: "NO STYLE PACKS DETECTED" })] }), _jsx(Text, { color: theme.textMuted, wrap: "wrap", children: "This directory has no recognized language manifest at its root." }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.textMuted, children: "Tip: run " }), _jsx(Text, { color: theme.language, bold: true, children: "/setup" }), _jsx(Text, { color: theme.textMuted, children: " to audit project hygiene or bootstrap a new project from scratch" })] }) })] }, item.id));
-            case "assistant":
-                return (_jsx(AssistantMessage, { text: item.text, thinking: item.thinking, thinkingMs: item.thinkingMs, planMode: item.planMode }, item.id));
-            case "tool_start":
-                return (_jsx(ToolExecution, { status: "running", name: item.name, args: item.args, progressOutput: item.progressOutput, animateUntil: item.animateUntil }, item.id));
-            case "tool_done":
-                return (_jsx(ToolExecution, { status: "done", name: item.name, args: item.args, result: item.result, isError: item.isError, details: item.details }, item.id));
-            case "tool_group":
-                return _jsx(ToolGroupExecution, { tools: item.tools }, item.id);
-            case "server_tool_start":
-                return (_jsx(ServerToolExecution, { status: "running", name: item.name, input: item.input, startedAt: item.startedAt, animateUntil: item.animateUntil }, item.id));
-            case "server_tool_done":
-                return (_jsx(ServerToolExecution, { status: "done", name: item.name, input: item.input, durationMs: item.durationMs, resultType: item.resultType }, item.id));
-            case "error": {
-                const showMessage = item.message && item.message !== item.headline;
-                return (_jsxs(Box, { marginTop: 1, flexDirection: "column", flexShrink: 1, children: [_jsxs(Text, { color: theme.error, wrap: "wrap", children: ["✗ ", item.headline] }), showMessage && (_jsx(Text, { color: theme.textDim, wrap: "wrap", children: `  ${item.message}` })), _jsx(Text, { color: theme.textDim, wrap: "wrap", children: `  → ${item.guidance}` })] }, item.id));
-            }
-            case "info":
-                return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsx(Text, { color: theme.textDim, wrap: "wrap", children: item.text }) }, item.id));
-            case "update_notice":
-                return (_jsx(Box, { marginTop: 1, flexShrink: 1, borderStyle: "round", borderColor: theme.success, paddingX: 1, children: _jsxs(Text, { color: theme.success, bold: true, wrap: "wrap", children: ["✨ ", item.text] }) }, item.id));
-            case "plan_transition":
-                return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsxs(Text, { color: theme.planPrimary, bold: true, wrap: "wrap", children: [item.active ? "● " : "● ", item.text] }) }, item.id));
-            case "thinking_transition": {
-                const glyphColor = item.active ? THINKING_BORDER_COLORS[0] : theme.textDim;
-                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, children: [_jsx(Text, { color: glyphColor, bold: true, children: "✻ " }), _jsx(Text, { color: item.active ? theme.accent : theme.textDim, bold: true, children: item.active ? "Thinking ON" : "Thinking OFF" })] }, item.id));
-            }
-            case "model_transition": {
-                const glyphColor = THINKING_BORDER_COLORS[0];
-                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, children: [_jsx(Text, { color: glyphColor, bold: true, children: "▸ " }), _jsx(Text, { color: theme.textDim, children: "Switched to " }), _jsx(Text, { color: theme.primary, bold: true, children: item.modelName })] }, item.id));
-            }
-            case "theme_transition": {
-                const glyphColor = THINKING_BORDER_COLORS[0];
-                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, children: [_jsx(Text, { color: glyphColor, bold: true, children: "◐ " }), _jsx(Text, { color: theme.textDim, children: "Theme switched to " }), _jsx(Text, { color: theme.primary, bold: true, children: item.themeName })] }, item.id));
-            }
-            case "plan_event": {
-                // Plan-domain status changes (approve / reject / dismiss). Uses
-                // theme.planPrimary to match the existing plan_transition family,
-                // distinct from the model/thinking gradient.
-                const label = item.event === "approved"
-                    ? "Plan approved"
-                    : item.event === "rejected"
-                        ? "Plan rejected"
-                        : "Plan dismissed";
-                return (_jsxs(Box, { marginTop: 1, flexShrink: 1, children: [_jsxs(Text, { color: theme.planPrimary, bold: true, children: ["○ ", label] }), item.detail ? _jsx(Text, { color: theme.textDim, children: ` — "${item.detail}"` }) : null] }, item.id));
-            }
-            case "stopped":
-                // Cancellation / abort acknowledgement (ESC, auto-setup cancel, etc.).
-                // Muted dim treatment — this is an ack, not a state change worth a
-                // gradient. Glyph `⊘` reads as "stop" without being alarming.
-                return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsxs(Text, { color: theme.textDim, bold: true, children: ["⊘ ", item.text] }) }, item.id));
-            case "step_done":
-                return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.success, bold: true, children: "✓ " }), _jsx(Text, { color: theme.success, bold: true, children: `Step ${item.stepNum} done` }), item.description ? (_jsx(Text, { color: theme.textDim, children: ` — ${item.description}` })) : null] }) }, item.id));
-            case "queued":
-                return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: "⏳ Queued: " }), _jsxs(Text, { color: theme.text, wrap: "wrap", children: [item.text, item.imageCount
-                                    ? ` (+${item.imageCount} image${item.imageCount > 1 ? "s" : ""})`
-                                    : ""] })] }, item.id));
-            case "compacting":
-                return _jsx(CompactionSpinner, { staticDisplay: true }, item.id);
-            case "compacted":
-                return (_jsx(CompactionDone, { originalCount: item.originalCount, newCount: item.newCount, tokensBefore: item.tokensBefore, tokensAfter: item.tokensAfter }, item.id));
-            case "duration":
-                return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.textDim, children: ["✻ ", item.verb, " ", formatDuration(item.durationMs)] }) }, item.id));
-            case "subagent_group":
-                return _jsx(SubAgentPanel, { agents: item.agents, aborted: item.aborted }, item.id);
+    }, [customCommands, idealReviewEnabled]);
+    const renderItem = (item, index, items) => renderTranscriptItem({
+        item,
+        index,
+        items,
+        pendingHistoryFlushLastItem: index === 0 ? lastVisibleTranscriptItem(pendingHistoryFlushRef.current) : undefined,
+        historyLastItem: index === 0 ? lastVisibleTranscriptItem(history) : undefined,
+        version: props.version,
+        currentModel,
+        currentProvider,
+        displayedCwd,
+        columns,
+        theme,
+        renderMarkdown,
+        measuredLiveAreaRows,
+    });
+    const openOverlay = useCallback((kind) => {
+        if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
+            props.sessionStore.overlay = kind;
+            if (kind !== "plan")
+                props.sessionStore.planAutoExpand = false;
+            if (kind !== "goal")
+                props.sessionStore.goalAutoExpand = false;
+            props.resetUI();
         }
-    };
-    // ── Start a task (shared by manual "work on it" and run-all) ──
-    const startTask = useCallback((title, prompt, taskId) => {
-        setTaskCount(getTaskCount(props.cwd));
-        const shortId = taskId.slice(0, 8);
-        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) {
-            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 }];
+        else {
+            if (props.sessionStore) {
+                props.sessionStore.overlay = kind;
+                if (kind !== "plan")
+                    props.sessionStore.planAutoExpand = false;
+                if (kind !== "goal")
+                    props.sessionStore.goalAutoExpand = false;
+                if (agentLoop.isRunning && kind !== "plan") {
+                    props.sessionStore.pendingResetUI = true;
+                }
+            }
+            if (kind !== "plan")
+                setPlanAutoExpand(false);
+            if (kind !== "goal")
+                setGoalAutoExpand(false);
+            setOverlay(kind);
+        }
+    }, [agentLoop.isRunning, props]);
+    useEffect(() => {
+        runAllTasksRef.current = runAllTasks;
+        if (props.sessionStore)
+            props.sessionStore.runAllTasks = runAllTasks;
+    }, [runAllTasks, props.sessionStore]);
+    useEffect(() => {
+        agentRunningRef.current = agentLoop.isRunning;
+    }, [agentLoop.isRunning]);
+    const { startPixelFix, setRunAllPixel } = usePixelFixFlow({
+        agentLoop,
+        cwd: props.cwd,
+        currentProvider,
+        currentModel,
+        rebuildToolsForCwd: props.rebuildToolsForCwd,
+        sessionStore: props.sessionStore,
+        currentPixelFixRef,
+        runAllPixelRef,
+        startPixelFixRef,
+        cwdRef,
+        currentToolsRef,
+        injectedLanguagesRef,
+        setupHintShownRef,
+        messagesRef,
+        persistedIndexRef,
+        sessionManagerRef,
+        sessionPathRef,
+        setDisplayedCwd,
+        setCurrentTools,
+        setHistory,
+        setLiveItems,
+        setLastUserMessage,
+        setDoneStatus,
+        rebuildSystemPrompt,
+        clearPendingHistory,
+        getId,
+        initialRunAllPixel: props.sessionStore?.runAllPixel ?? false,
+    });
+    // Starts a single task: opens a fresh session + chat and runs the task
+    // prompt through the agent loop. Wired into startTaskRef so both the task
+    // picker (Enter = start one, r = run all) and the run-all auto-advance in
+    // onDone can invoke it from stale closures.
+    const startTask = useCallback((title, prompt, taskId) => {
+        const taskCwd = cwdRef.current;
+        const shortId = taskId.slice(0, 8);
+        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;
+        if (props.resetUI && props.sessionStore) {
+            const sysMsg = messagesRef.current[0];
+            const newMessages = sysMsg && sysMsg.role === "system" ? [sysMsg] : messagesRef.current.slice(0, 1);
+            const taskItem = { kind: "task", title, id: getId() };
+            const sm = sessionManagerRef.current;
+            void (async () => {
                 let newSessionPath;
                 if (sm) {
                     try {
-                        const s = await sm.create(props.cwd, currentProvider, currentModel);
-                        newSessionPath = s.path;
-                        log("INFO", "tasks", "New session for task", { path: s.path });
+                        const session = await sm.create(taskCwd, currentProvider, currentModel);
+                        newSessionPath = session.path;
+                        log("INFO", "tasks", "New session for task", { path: session.path });
                     }
                     catch {
-                        // session creation is best-effort
+                        // 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,
@@ -2748,10 +2479,7 @@ export function App(props) {
             })();
             return;
         }
-        // Fallback path (resetUI not wired — tests).
-        currentTaskIdRef.current = taskId;
-        if (props.sessionStore)
-            props.sessionStore.currentTaskId = taskId;
+        clearPendingHistory();
         setHistory([{ kind: "banner", id: "banner" }]);
         setLiveItems([]);
         messagesRef.current = messagesRef.current.slice(0, 1);
@@ -2759,940 +2487,585 @@ export function App(props) {
         persistedIndexRef.current = messagesRef.current.length;
         const sm = sessionManagerRef.current;
         if (sm) {
-            void sm.create(props.cwd, currentProvider, currentModel).then((s) => {
-                sessionPathRef.current = s.path;
-                log("INFO", "tasks", "New session for task", { path: s.path });
+            void sm.create(taskCwd, currentProvider, currentModel).then((session) => {
+                sessionPathRef.current = session.path;
+                log("INFO", "tasks", "New session for task", { path: session.path });
             });
         }
         const taskItem = { kind: "task", title, id: getId() };
         setLastUserMessage(title);
         setDoneStatus(null);
         setLiveItems([taskItem]);
+        void agentLoop.run(fullPrompt).catch((err) => {
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
+        });
+    }, [agentLoop, currentModel, currentProvider, props]);
+    // Keep the ref in sync so stale closures (task picker, onDone run-all) can
+    // start a task without being recreated each render.
+    startTaskRef.current = startTask;
+    // Reset the live tool feed at the start of each run so the pinned panel only
+    // ever reflects the current turn's activity, not the previous one's.
+    const wasRunningRef = useRef(false);
+    useEffect(() => {
+        if (agentLoop.isRunning && !wasRunningRef.current) {
+            setLiveToolFeed([]);
+        }
+        wasRunningRef.current = agentLoop.isRunning;
+    }, [agentLoop.isRunning]);
+    const isSkillsView = overlay === "skills";
+    const isPlanView = overlay === "plan";
+    const { footerStatusLayout, activityVisible, stallStatusVisible, statusSlotVisible, mainControlsRef, measuredLiveAreaRows, viewportRows, } = useChatLayoutMeasurements({
+        rows,
+        columns,
+        backgroundTaskCount: bgTasks.length,
+        updatePending,
+        agentRunning: agentLoop.isRunning,
+        activityPhase: agentLoop.activityPhase,
+        stallError: agentLoop.stallError,
+        doneStatus,
+        currentModel,
+        contextUsed: agentLoop.contextUsed,
+        contextWindowOptions,
+        displayedCwd,
+        gitBranch,
+        thinkingLevel,
+        exitPending,
+        taskBarExpanded,
+        liveToolFeedCount: liveToolFeed.length,
+    });
+    const isPixelView = overlay === "pixel";
+    const hasLiveAssistantItem = liveItems.some((item) => item.kind === "assistant");
+    const rawVisibleStreamingText = hasLiveAssistantItem ? "" : agentLoop.streamingText;
+    // Compute the prospective paragraph flush DURING render so the live frame
+    // immediately drops the prefix that is about to be written to scrollback.
+    // The queueFlush below runs in an effect (after paint), so if the live text
+    // were sliced only by the already-committed `flushedChars`, the just-flushed
+    // paragraph would render BOTH in scrollback and live for one frame — that
+    // transient extra height is what shoves the footer up and then back down on
+    // every chunk boundary. Slicing by the prospective flush here keeps the live
+    // frame height monotonic, so the footer never bounces.
+    const alreadyFlushedChars = streamedAssistantFlushRef.current.flushedChars;
+    const pendingFlushChars = rawVisibleStreamingText
+        ? splitAssistantStreamingText(rawVisibleStreamingText.slice(alreadyFlushedChars)).flushedText
+            .length
+        : 0;
+    useEffect(() => {
+        if (!rawVisibleStreamingText) {
+            streamedAssistantFlushRef.current = { flushedChars: 0, text: "" };
+            return;
+        }
+        if (rawVisibleStreamingText === streamedAssistantFlushRef.current.text)
+            return;
+        const alreadyFlushed = streamedAssistantFlushRef.current.flushedChars;
+        const unflushedText = rawVisibleStreamingText.slice(alreadyFlushed);
+        const split = splitAssistantStreamingText(unflushedText);
+        if (split.flushedText.length > 0) {
+            queueFlush([
+                {
+                    kind: "assistant",
+                    text: stripDoneMarkers(split.flushedText),
+                    continuation: streamedAssistantFlushRef.current.flushedChars > 0,
+                    id: getId(),
+                },
+            ]);
+            streamedAssistantFlushRef.current = {
+                flushedChars: alreadyFlushed + split.flushedText.length,
+                text: rawVisibleStreamingText,
+            };
+            return;
+        }
+        streamedAssistantFlushRef.current = {
+            ...streamedAssistantFlushRef.current,
+            text: rawVisibleStreamingText,
+        };
+    }, [rawVisibleStreamingText, queueFlush]);
+    const visibleStreamingText = stripDoneMarkers(rawVisibleStreamingText.slice(alreadyFlushedChars + pendingFlushChars));
+    const lastLiveItem = liveItems.at(-1);
+    // For spacing decisions, the previous row is the last item that actually
+    // RENDERS. Panel-replaced tool items (now shown only in the LiveToolPanel)
+    // render null, so counting them as the boundary inserts a blank separator
+    // above the streamed response with nothing visible above it.
+    const lastVisibleLiveItem = lastVisibleTranscriptItem(liveItems);
+    const lastPendingHistoryItem = pendingHistoryFlushRef.current.at(-1);
+    const lastHistoryItem = history.at(-1);
+    // Spacing variants: flushed tool rows render null (LiveToolPanel owns them), so
+    // the streamed/first-live boundary must look past them to the last row that
+    // actually printed — otherwise a tool→assistant separator leaves a phantom gap.
+    const lastVisiblePendingHistoryItem = lastVisibleTranscriptItem(pendingHistoryFlushRef.current);
+    const lastVisibleHistoryItem = lastVisibleTranscriptItem(history);
+    const previousTranscriptItem = lastPendingHistoryItem ?? lastHistoryItem;
+    const isAwaitingAssistantAfterUser = agentLoop.isRunning &&
+        !hasLiveAssistantItem &&
+        visibleStreamingText.trim().length === 0 &&
+        (lastLiveItem?.kind === "user" || (!lastLiveItem && previousTranscriptItem?.kind === "user"));
+    const shouldReserveStreamingSpacing = agentLoop.isRunning &&
+        !hasLiveAssistantItem &&
+        (visibleStreamingText.trim().length > 0 ||
+            liveItems.some(isTranscriptSpacingItem) ||
+            isAwaitingAssistantAfterUser);
+    const shouldTopSpaceStreamingText = shouldTopSpaceStreamingAssistant({
+        visibleStreamingText,
+        lastLiveItem: lastVisibleLiveItem,
+        lastPendingHistoryItem: lastVisiblePendingHistoryItem,
+        lastHistoryItem: lastVisibleHistoryItem,
+    });
+    // When earlier paragraphs of THIS response were already flushed to scrollback
+    // mid-stream, the live remainder is the next paragraph — re-insert the blank
+    // line that separated them so the live tail lines up with the flushed history.
+    const streamingContinuesFlushed = alreadyFlushedChars + pendingFlushChars > 0;
+    // ── Fullscreen alt-screen transcript ───────────────────
+    // Flatten history + live items + in-flight streaming into the flat ANSI line
+    // buffer the viewport renders. Reuses the same serializer the legacy
+    // scrollback printer used, so the transcript looks identical. Only computed
+    // when fullscreen is active (the legacy path renders items through Ink).
+    const transcriptContext = useMemo(() => ({
+        theme,
+        columns,
+        version: props.version,
+        model: currentModel,
+        provider: currentProvider,
+        cwd: displayedCwd,
+    }), [theme, columns, props.version, currentModel, currentProvider, displayedCwd]);
+    const transcriptLines = useMemo(() => {
+        if (!props.fullscreen)
+            return [];
+        const items = [...history, ...uniqueItemsById(liveItems)];
+        const hasStreaming = visibleStreamingText.length > 0 || agentLoop.streamingThinking.length > 0;
+        if (hasStreaming) {
+            items.push({
+                kind: "assistant",
+                text: visibleStreamingText,
+                thinking: agentLoop.streamingThinking,
+                thinkingMs: agentLoop.thinkingMs,
+                continuation: streamingContinuesFlushed,
+                id: "__streaming__",
+            });
+        }
+        return buildTranscriptLines(items, transcriptContext);
+    }, [
+        props.fullscreen,
+        history,
+        liveItems,
+        visibleStreamingText,
+        agentLoop.streamingThinking,
+        agentLoop.thinkingMs,
+        streamingContinuesFlushed,
+        transcriptContext,
+    ]);
+    // Keyboard + bounds controller. The offset itself lives in the external
+    // transcript-scroll store; the viewport subscribes to it directly so scroll
+    // re-renders only the viewport, not this whole component.
+    useTranscriptScroll({
+        totalLines: transcriptLines.length,
+        viewportRows,
+        active: !!props.fullscreen && !overlay && !taskBarFocused,
+        resetToken: scrollResetToken,
+    });
+    const visibleQueuedCount = liveItems.filter((item) => item.kind === "queued").length;
+    const hiddenQueuedCount = Math.max(0, agentLoop.queuedCount - visibleQueuedCount);
+    const shouldTopSpaceQueueIndicator = hiddenQueuedCount > 0 &&
+        shouldTopSpaceAfterPrintedAgentBoundary({
+            currentKind: "queued",
+            previousLiveItem: lastLiveItem,
+            lastPendingHistoryItem,
+            lastHistoryItem,
+        });
+    const handleRewindCancel = useCallback(() => setRewindCheckpoints(null), []);
+    const handleRewindRestore = useCallback((id, mode) => {
+        const store = props.checkpointStore;
+        setRewindCheckpoints(null);
+        if (!store)
+            return;
         void (async () => {
             try {
-                await agentLoop.run(fullPrompt);
+                const result = await store.restore(id, mode);
+                const turnNum = id.replace(/^cp-0*/, "") || id;
+                const detailParts = [];
+                if (mode === "code" || mode === "both") {
+                    detailParts.push(`${result.filesRestored} file${result.filesRestored === 1 ? "" : "s"} restored`);
+                }
+                if (mode === "conversation" || mode === "both")
+                    detailParts.push("conversation rewound");
+                const infoText = `Rewound to checkpoint #${turnNum} (${detailParts.join(", ")}).`;
+                if (mode === "conversation" || mode === "both") {
+                    const truncated = messagesRef.current.slice(0, Math.max(1, result.messageIndex));
+                    messagesRef.current = truncated;
+                    persistedIndexRef.current = truncated.length;
+                    agentLoop.reset();
+                    // Remount in lockstep so the banner + confirmation re-render cleanly
+                    // after the conversation context is truncated (CLAUDE.md pattern).
+                    if (props.resetUI) {
+                        props.resetUI({
+                            wipeSession: true,
+                            messages: truncated,
+                            history: [
+                                { kind: "banner", id: "banner" },
+                                { kind: "info", text: infoText, id: getId() },
+                            ],
+                        });
+                        return;
+                    }
+                }
+                setLiveItems((prev) => [...prev, { kind: "info", text: infoText, id: getId() }]);
             }
             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()),
+                    { kind: "info", text: `Rewind failed: ${msg}`, id: getId() },
                 ]);
-                setRunAllTasks(false);
             }
         })();
-    }, [props.cwd, props.resetUI, props.sessionStore, agentLoop, currentProvider, currentModel]);
-    const openOverlay = useCallback((kind) => {
+    }, [props.checkpointStore, props.resetUI, agentLoop, messagesRef, persistedIndexRef]);
+    const handleCloseRemountableOverlay = () => {
         if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
-            props.sessionStore.overlay = kind;
-            if (kind !== "plan")
-                props.sessionStore.planAutoExpand = false;
+            props.sessionStore.overlay = null;
             props.resetUI();
+            return;
         }
-        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);
+        if (props.sessionStore) {
+            props.sessionStore.overlay = null;
+            if (agentLoop.isRunning)
+                props.sessionStore.pendingResetUI = true;
         }
-    }, [agentLoop.isRunning, props]);
-    const closeOverlay = useCallback(() => {
+        setOverlay(null);
+    };
+    const handleEnterPlanMode = useCallback(async (reason) => {
+        await setPlanModeAndPrompt(true);
+        setLiveItems((prev) => [
+            ...prev,
+            { kind: "plan_transition", text: reason ?? "", id: getId(), active: true },
+        ]);
+    }, [setPlanModeAndPrompt]);
+    const handleExitPlanMode = useCallback(async (_planPath) => {
+        await setPlanModeAndPrompt(false);
+        planOverlayPendingRef.current = true;
+        setPlanAutoExpand(true);
+        if (props.sessionStore) {
+            props.sessionStore.overlay = "plan";
+            props.sessionStore.planAutoExpand = true;
+        }
+        setOverlay("plan");
+        return "Plan submitted for user review. Wait for the user to approve, reject, or dismiss it before implementing.";
+    }, [props.sessionStore, setPlanModeAndPrompt]);
+    useEffect(() => {
+        if (!props.planCallbacks)
+            return;
+        props.planCallbacks.onEnterPlan = handleEnterPlanMode;
+        props.planCallbacks.onExitPlan = handleExitPlanMode;
+    }, [handleEnterPlanMode, handleExitPlanMode, props.planCallbacks]);
+    const handleCloseGoalOverlay = () => {
         if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
             props.sessionStore.overlay = null;
+            props.sessionStore.goalAutoExpand = false;
             props.resetUI();
+            return;
         }
-        else {
-            if (props.sessionStore) {
-                props.sessionStore.overlay = null;
-            }
-            setOverlay(null);
+        if (props.sessionStore) {
+            props.sessionStore.overlay = null;
+            props.sessionStore.goalAutoExpand = false;
+            if (agentLoop.isRunning)
+                props.sessionStore.pendingResetUI = true;
         }
-    }, [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) {
+        setGoalAutoExpand(false);
+        setOverlay(null);
+    };
+    const handleRunGoal = (run) => {
+        if (goalHasBlockingPrerequisites(run)) {
+            upsertGoalStatusEntry({
+                runId: run.id,
+                label: run.title,
+                phase: "failed",
+                detail: formatGoalBlockingPrerequisites(run),
+                startedAt: Date.now(),
+            });
             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,
+                phase: "terminal",
+                title: `Goal blocked: ${run.title}`,
+                detail: formatGoalBlockingPrerequisites(run),
+                summaryRows: buildGoalSummaryRows(run),
+                status: "blocked",
             });
-            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,
-                });
+            const checked = await runGoalPrerequisiteChecks(props.cwd, run);
+            const current = await upsertGoalRun(props.cwd, checked.run);
+            if (goalHasBlockingPrerequisites(current)) {
                 upsertGoalStatusEntry({
-                    runId: run.id,
-                    label: run.title,
-                    phase: decision.workerId ? "worker" : "orchestrating",
+                    runId: current.id,
+                    label: current.title,
+                    phase: "failed",
+                    detail: formatGoalBlockingPrerequisites(current),
                     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, {
+                    title: `Goal blocked: ${current.title}`,
+                    detail: formatGoalBlockingPrerequisites(current),
+                    summaryRows: buildGoalSummaryRows(current),
                     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,
+            const resumed = await upsertGoalRun(props.cwd, {
+                ...current,
+                status: current.status === "draft" ? "ready" : current.status,
+                continueRequestedAt: new Date().toISOString(),
             });
-            await upsertGoalRun(props.cwd, {
-                ...run,
-                status: "running",
-                activeWorkerId: worker.id,
-                continueRequestedAt: undefined,
+            setGoalAutoExpand(true);
+            upsertGoalStatusEntry({
+                runId: resumed.id,
+                label: resumed.title,
+                phase: "orchestrating",
+                detail: "Choosing next Goal action",
+                startedAt: Date.now(),
             });
-            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),
+                phase: "orchestrator_reviewing",
+                title: `Goal ${goalNumberForRun(resumed.id)} continuing`,
+                detail: resumed.title,
+                status: resumed.status,
             });
-        })().catch((err) => {
-            clearGoalStatusEntry(run.id);
-            log("ERROR", "goal", err instanceof Error ? err.message : String(err));
-            setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal")]);
-        });
-    }, [
-        props.cwd,
-        currentProvider,
-        currentModel,
-        appendGoalProgress,
-        clearGoalStatusEntry,
-        goalNumberForRun,
-        upsertGoalStatusEntry,
-    ]);
-    const verifyGoalRun = useCallback(async (run) => {
+            continueGoalRun(resumed);
+        })();
+    };
+    startGoalRunRef.current = handleRunGoal;
+    const handleVerifyGoal = (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.",
+                title: `Goal verifier missing: ${run.title}`,
+                detail: "Define a verifier command before running verification.",
                 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,
+        void (async () => {
+            const verifying = await upsertGoalRun(props.cwd, {
+                ...run,
+                status: "ready",
+                tasks: run.tasks.map((task) => task.status === "pending" || task.status === "failed"
+                    ? { ...task, status: "done" }
+                    : task),
                 verifier: {
-                    ...latestRun.verifier,
-                    description: latestRun.verifier?.description ?? "Goal verifier",
-                    command: run.verifier?.command,
-                    lastResult: verification,
+                    ...run.verifier,
+                    lastResult: undefined,
                 },
-            };
-            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" });
+            continueGoalRun(verifying);
+        })();
+    };
+    const handlePauseGoal = (run) => {
+        void (async () => {
+            for (const worker of listGoalWorkers(props.cwd).filter((item) => item.goalRunId === run.id)) {
+                await stopGoalWorker(worker.id);
             }
-            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 paused = await upsertGoalRun(props.cwd, {
+                ...run,
+                status: "paused",
+                blockers: [...run.blockers, "Paused by user from Goal pane."],
             });
-            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.",
+                title: `Goal paused: ${paused.title}`,
+                detail: "Paused by user from Goal pane.",
+                summaryRows: buildGoalSummaryRows(paused),
                 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;
+        })();
+    };
+    const handleRefineGoal = (run, feedback) => {
+        setOverlay(null);
+        setGoalAutoExpand(false);
+        setDoneStatus(null);
+        appendGoalAgentTransition(`Goal refinement requested for ${run.title}`);
+        void agentLoop
+            .run(`Refine Goal run ${run.id} (${run.title}) using this user feedback:\n\n${feedback}\n\nUpdate the durable Goal plan with the goals tool. Do not start workers until the user approves/runs the Goal.`)
+            .catch((err) => setLiveItems((prev) => [...prev, toErrorItem(err, getId())]));
+    };
+    const handleClosePlanOverlay = () => {
+        planOverlayPendingRef.current = false;
+        if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
+            props.sessionStore.overlay = null;
+            props.sessionStore.planAutoExpand = false;
+            props.resetUI();
+            return;
+        }
         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;
+            props.sessionStore.overlay = null;
+            props.sessionStore.planAutoExpand = false;
+            if (agentLoop.isRunning)
+                props.sessionStore.pendingResetUI = true;
         }
-    }, [runAllTasks, props.sessionStore]);
-    useEffect(() => {
-        agentRunningRef.current = agentLoop.isRunning;
-    }, [agentLoop.isRunning]);
-    const startPixelFix = useCallback((errorId) => {
+        setPlanAutoExpand(false);
+        setOverlay(null);
+    };
+    const handlePixelFixOne = (entry) => {
+        setOverlay(null);
+        startPixelFix(entry.errorId);
+    };
+    const handlePixelFixAll = (entries) => {
+        const first = entries.find((entry) => entry.status === "open") ?? entries[0];
+        if (!first)
+            return;
+        setOverlay(null);
+        setRunAllPixel(true);
+        startPixelFix(first.errorId);
+    };
+    const handleApprovePlan = (planPath) => {
+        log("INFO", "plan", "Plan approved — transitioning to implementation", {
+            planPath,
+        });
+        planOverlayPendingRef.current = false;
         void (async () => {
             try {
-                const { preparePixelFix } = await import("../core/pixel-fix.js");
-                const prep = await preparePixelFix(errorId);
-                currentPixelFixRef.current = prep;
-                // Move the agent into the error's project root. Four things must
-                // change in lockstep, otherwise the agent (or the chrome around
-                // it) shows the wrong project:
-                //   1. process.cwd  — for any code reading it directly
-                //   2. cwd-bound tools (read/write/bash/grep/…) — baked at creation
-                //   3. the system prompt's "Working directory: …" line — the only
-                //      place the model itself learns where it is
-                //   4. displayedCwd state — Banner + Footer read this for display
-                try {
-                    process.chdir(prep.projectPath);
-                }
-                catch (err) {
-                    log("WARN", "pixel", `chdir failed: ${err.message}`);
+                // Read plan steps for progress tracking — handed to the new
+                // mount via sessionStore.planSteps below.
+                const planContent = await import("node:fs/promises").then(({ readFile }) => readFile(planPath, "utf-8"));
+                const steps = extractPlanSteps(planContent);
+                // Build the new system prompt with the approved plan baked in.
+                const newPrompt = await rebuildSystemPrompt({
+                    approvedPlanPath: planPath,
+                });
+                // Create a new session file BEFORE remount so the new tree
+                // picks it up via sessionStore.sessionPath.
+                let newSessionPath;
+                const sm = sessionManagerRef.current;
+                if (sm) {
+                    const s = await sm.create(props.cwd, currentProvider, currentModel);
+                    newSessionPath = s.path;
                 }
-                cwdRef.current = prep.projectPath;
-                repoMapDirtyRef.current = true;
-                repoMapMarkdownRef.current = "";
-                repoMapSnapshotRef.current = undefined;
-                repoMapChangedCountRef.current = 0;
-                repoMapCacheRef.current = createRepoMapCache();
-                props.repoMapChangedFilesRef?.current.clear();
-                props.repoMapReadFilesRef?.current.clear();
-                setDisplayedCwd(prep.projectPath);
-                let toolsForPixelFix = currentToolsRef.current;
-                if (props.rebuildToolsForCwd) {
-                    toolsForPixelFix = props.rebuildToolsForCwd(prep.projectPath);
-                    currentToolsRef.current = toolsForPixelFix;
-                    setCurrentTools(toolsForPixelFix);
+                if (props.resetUI && props.sessionStore) {
+                    // Clear the overlay so the new mount lands on the chat,
+                    // not back inside the plan pane.
+                    props.sessionStore.overlay = null;
+                    props.sessionStore.planAutoExpand = false;
+                    props.resetUI({
+                        wipeSession: true,
+                        messages: [{ role: "system", content: newPrompt }],
+                        approvedPlanPath: planPath,
+                        planSteps: steps,
+                        sessionPath: newSessionPath,
+                        pendingAction: {
+                            prompt: "The plan has been approved. Implement it now, following each step in order.",
+                            planEvent: { event: "approved" },
+                        },
+                    });
+                    return;
                 }
-                // Pixel-fix swaps the project root — reset injected packs so the
-                // new project re-detects from scratch on the next tool call. Also
-                // reset the setup-hint flag so the new project's first badge re-
-                // surfaces the tip (different project, may need the reminder).
-                injectedLanguagesRef.current = new Set();
-                setupHintShownRef.current = false;
-                const detectedForPixelFix = detectLanguages(prep.projectPath);
-                injectedLanguagesRef.current = detectedForPixelFix;
-                const newSystemPrompt = await rebuildSystemPrompt({
-                    cwd: prep.projectPath,
-                    planMode: false,
-                    clearApprovedPlan: true,
-                    activeLanguages: detectedForPixelFix,
-                    tools: toolsForPixelFix,
-                });
-                // Now that the cwd swap is committed, reset chat. Do not clear the
-                // terminal here; terminal clear sequences can erase saved scrollback.
+                // Fallback path (resetUI not wired — tests). Mutate in place.
+                approvedPlanPathRef.current = planPath;
+                planStepsRef.current = steps;
+                setPlanSteps(steps);
+                clearPendingHistory();
                 setHistory([{ kind: "banner", id: "banner" }]);
                 setLiveItems([]);
-                messagesRef.current = messagesRef.current.slice(0, 1);
+                setPlanAutoExpand(false);
+                setOverlay(null);
+                messagesRef.current = [{ role: "system", content: newPrompt }];
                 agentLoop.reset();
                 persistedIndexRef.current = messagesRef.current.length;
-                const sm = sessionManagerRef.current;
-                if (sm) {
-                    void sm.create(prep.projectPath, currentProvider, currentModel).then((s) => {
-                        sessionPathRef.current = s.path;
-                        log("INFO", "pixel", "New session for pixel fix", { path: s.path });
-                    });
-                }
-                if (messagesRef.current[0]?.role === "system") {
-                    messagesRef.current[0] = { role: "system", content: newSystemPrompt };
-                }
-                else {
-                    messagesRef.current.unshift({ role: "system", content: newSystemPrompt });
-                }
-                const title = `Fix ${errorId.slice(0, 12)}… in ${prep.projectName}`;
-                const taskItem = { kind: "task", title, id: getId() };
-                setLastUserMessage(title);
+                if (newSessionPath)
+                    sessionPathRef.current = newSessionPath;
+                setLiveItems([
+                    {
+                        kind: "info",
+                        text: "Plan approved — starting fresh session for implementation",
+                        id: getId(),
+                    },
+                ]);
                 setDoneStatus(null);
-                setLiveItems([taskItem]);
-                await agentLoop.run(prep.prompt);
+                await agentLoop.run("The plan has been approved. Implement it now, following each step in order.");
             }
             catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                log("ERROR", "pixel", msg);
-                currentPixelFixRef.current = null;
-                setRunAllPixel(false);
+                const errMsg = err instanceof Error ? err.message : String(err);
+                log("ERROR", "error", errMsg);
                 setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
             }
         })();
-    }, [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).
-    const [runAllPixel, setRunAllPixel] = useState(props.sessionStore?.runAllPixel ?? false);
-    useEffect(() => {
-        runAllPixelRef.current = runAllPixel;
-        if (props.sessionStore)
-            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 || 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();
-                    }
-                    else {
-                        if (props.sessionStore) {
-                            props.sessionStore.overlay = null;
-                            if (agentLoop.isRunning)
-                                props.sessionStore.pendingResetUI = true;
-                        }
-                        setTaskCount(getTaskCount(props.cwd));
-                        setOverlay(null);
-                    }
-                }, onWorkOnTask: (title, prompt, taskId) => {
-                    setOverlay(null);
-                    startTask(title, prompt, taskId);
-                }, onRunAllTasks: () => {
-                    setOverlay(null);
-                    setRunAllTasks(true);
-                    const next = getNextPendingTask(props.cwd);
-                    if (next) {
-                        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;
-                        props.resetUI();
-                    }
-                    else {
-                        if (props.sessionStore) {
-                            props.sessionStore.overlay = null;
-                            if (agentLoop.isRunning)
-                                props.sessionStore.pendingResetUI = true;
-                        }
-                        setOverlay(null);
-                    }
-                }, onFixOne: (entry) => {
-                    setOverlay(null);
-                    startPixelFix(entry.errorId);
-                }, onFixAll: (entries) => {
-                    const first = entries.find((e) => e.status === "open") ?? entries[0];
-                    if (!first)
-                        return;
-                    setOverlay(null);
-                    setRunAllPixel(true);
-                    startPixelFix(first.errorId);
-                } })) : isSkillsView ? (_jsx(SkillsOverlay, { cwd: props.cwd, onClose: () => {
-                    if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
-                        props.sessionStore.overlay = null;
-                        props.resetUI();
-                    }
-                    else {
-                        if (props.sessionStore) {
-                            props.sessionStore.overlay = null;
-                            if (agentLoop.isRunning)
-                                props.sessionStore.pendingResetUI = true;
-                        }
-                        setOverlay(null);
-                    }
-                } })) : isEyesView ? (_jsx(EyesOverlay, { cwd: props.cwd, onClose: () => {
-                    if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
-                        props.sessionStore.overlay = null;
-                        props.resetUI();
-                    }
-                    else {
-                        if (props.sessionStore) {
-                            props.sessionStore.overlay = null;
-                            if (agentLoop.isRunning)
-                                props.sessionStore.pendingResetUI = true;
-                        }
-                        setEyesCount(isEyesActive(props.cwd) ? journalCount({ status: "open" }, props.cwd) : undefined);
-                        setOverlay(null);
-                    }
-                }, onQueueMessage: (msg) => {
-                    agentLoop.queueMessage(msg);
-                } })) : isPlanView ? (_jsx(PlanOverlay, { cwd: props.cwd, autoExpandNewest: planAutoExpand, onClose: () => {
-                    planOverlayPendingRef.current = false;
-                    if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
-                        props.sessionStore.overlay = null;
-                        props.sessionStore.planAutoExpand = false;
-                        props.resetUI();
-                    }
-                    else {
-                        if (props.sessionStore) {
-                            props.sessionStore.overlay = null;
-                            props.sessionStore.planAutoExpand = false;
-                            if (agentLoop.isRunning)
-                                props.sessionStore.pendingResetUI = true;
-                        }
-                        setPlanAutoExpand(false);
-                        setOverlay(null);
-                    }
-                }, onApprove: (planPath) => {
-                    log("INFO", "plan", "Plan approved — transitioning to implementation", {
-                        planPath,
-                    });
-                    planOverlayPendingRef.current = false;
-                    void (async () => {
-                        try {
-                            // Read plan steps for progress tracking — handed to the new
-                            // mount via sessionStore.planSteps below.
-                            const planContent = await import("node:fs/promises").then(({ readFile }) => readFile(planPath, "utf-8"));
-                            const steps = extractPlanSteps(planContent);
-                            // Build the new system prompt with the approved plan baked in.
-                            const newPrompt = await rebuildSystemPrompt({
-                                planMode: false,
-                                approvedPlanPath: planPath,
-                            });
-                            // Create a new session file BEFORE remount so the new tree
-                            // picks it up via sessionStore.sessionPath.
-                            let newSessionPath;
-                            const sm = sessionManagerRef.current;
-                            if (sm) {
-                                const s = await sm.create(props.cwd, currentProvider, currentModel);
-                                newSessionPath = s.path;
-                            }
-                            if (props.resetUI && props.sessionStore) {
-                                // Clear the overlay so the new mount lands on the chat,
-                                // not back inside the plan pane.
-                                props.sessionStore.overlay = null;
-                                props.sessionStore.planAutoExpand = false;
-                                props.resetUI({
-                                    wipeSession: true,
-                                    messages: [{ role: "system", content: newPrompt }],
-                                    approvedPlanPath: planPath,
-                                    planSteps: steps,
-                                    sessionPath: newSessionPath,
-                                    pendingAction: {
-                                        prompt: "The plan has been approved. Implement it now, following each step in order.",
-                                        planEvent: { event: "approved" },
-                                    },
-                                });
-                                return;
-                            }
-                            // Fallback path (resetUI not wired — tests). Mutate in place.
-                            approvedPlanPathRef.current = planPath;
-                            planStepsRef.current = steps;
-                            setPlanSteps(steps);
-                            setHistory([{ kind: "banner", id: "banner" }]);
-                            setLiveItems([]);
-                            setPlanAutoExpand(false);
-                            setOverlay(null);
-                            messagesRef.current = [{ role: "system", content: newPrompt }];
-                            agentLoop.reset();
-                            persistedIndexRef.current = messagesRef.current.length;
-                            if (newSessionPath)
-                                sessionPathRef.current = newSessionPath;
-                            setLiveItems([
-                                {
-                                    kind: "info",
-                                    text: "Plan approved — starting fresh session for implementation",
-                                    id: getId(),
-                                },
-                            ]);
-                            setDoneStatus(null);
-                            await agentLoop.run("The plan has been approved. Implement it now, following each step in order.");
-                        }
-                        catch (err) {
-                            const errMsg = err instanceof Error ? err.message : String(err);
-                            log("ERROR", "error", errMsg);
-                            setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
-                        }
-                    })();
-                }, onReject: (planPath, feedback) => {
-                    planOverlayPendingRef.current = false;
-                    const rejectionMsg = `The plan at ${planPath} was rejected.\n\nFeedback: ${feedback}\n\n` +
-                        `Please revise the plan based on this feedback.`;
-                    if (props.resetUI && props.sessionStore) {
-                        props.sessionStore.overlay = null;
-                        props.sessionStore.planAutoExpand = false;
-                        // No wipeSession — keep history, messages, plan mode etc. The
-                        // agent picks up the rejection mid-conversation.
-                        props.resetUI({
-                            pendingAction: {
-                                prompt: rejectionMsg,
-                                planEvent: { event: "rejected", detail: feedback },
-                            },
-                        });
-                        return;
-                    }
-                    setPlanAutoExpand(false);
-                    setOverlay(null);
-                    setDoneStatus(null);
-                    setLiveItems((prev) => [
-                        ...prev,
-                        { kind: "info", text: `Plan rejected — "${feedback}"`, id: getId() },
-                    ]);
-                    void agentLoop.run(rejectionMsg).catch((err) => {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        log("ERROR", "error", errMsg);
-                        setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
-                    });
-                } })) : (_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: () => {
-                            // 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).
-                            openOverlay("tasks");
-                        }, onToggleGoal: () => {
-                            openOverlay("goal");
-                        }, onToggleSkills: () => {
-                            openOverlay("skills");
-                        }, onTogglePixel: () => {
-                            openOverlay("pixel");
-                        }, onTogglePlanMode: () => {
-                            const next = !planMode;
-                            setPlanMode(next);
-                            log("INFO", "plan", `Plan mode ${next ? "enabled" : "disabled"}`);
-                            setLiveItems((items) => [
-                                ...items,
-                                {
-                                    kind: "plan_transition",
-                                    text: next ? "Plan Mode Activated" : "Plan Mode Deactivated",
-                                    active: next,
-                                    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 })) : (_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";
-    const prefix = refreshed
-        ? `Dynamic repo map refreshed · injection: ${status}`
-        : `Dynamic repo map · injection: ${status}`;
-    return `${prefix}\n\n${markdown}`;
+    };
+    const handleRejectPlan = (planPath, feedback) => {
+        planOverlayPendingRef.current = false;
+        const rejectionMsg = `The plan at ${planPath} was rejected.\n\nFeedback: ${feedback}\n\n` +
+            `Please revise the plan based on this feedback.`;
+        if (props.resetUI && props.sessionStore) {
+            props.sessionStore.overlay = null;
+            props.sessionStore.planAutoExpand = false;
+            // No wipeSession — keep history and messages so the agent picks
+            // up the rejection mid-conversation.
+            props.resetUI({
+                pendingAction: {
+                    prompt: rejectionMsg,
+                    planEvent: { event: "rejected", detail: feedback },
+                },
+            });
+            return;
+        }
+        setPlanAutoExpand(false);
+        setOverlay(null);
+        setDoneStatus(null);
+        setLiveItems((prev) => [
+            ...prev,
+            { kind: "info", text: `Plan rejected — "${feedback}"`, id: getId() },
+        ]);
+        void agentLoop.run(rejectionMsg).catch((err) => {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log("ERROR", "error", errMsg);
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
+        });
+    };
+    const handleToggleTasks = () => {
+        taskPicker.toggle();
+    };
+    const fullScreenOverlay = isPixelView
+        ? "pixel"
+        : isSkillsView
+            ? "skills"
+            : isPlanView
+                ? "plan"
+                : null;
+    if (quittingSummary) {
+        return (_jsx(Box, { flexDirection: "column", width: columns, flexShrink: 0, flexGrow: 0, children: _jsx(SessionSummaryDisplay, { summary: quittingSummary }) }));
+    }
+    return (_jsx(Box, { flexDirection: "column", width: columns, flexShrink: 0, flexGrow: 0, children: rewindCheckpoints ? (_jsx(RewindOverlay, { checkpoints: rewindCheckpoints, onRestore: handleRewindRestore, onCancel: handleRewindCancel })) : fullScreenOverlay ? (_jsx(FullScreenOverlayRouter, { overlay: fullScreenOverlay, version: props.version, cwd: props.cwd, agentRunning: agentLoop.isRunning, planAutoExpand: planAutoExpand, onClosePixel: handleCloseRemountableOverlay, onPixelFixOne: handlePixelFixOne, onPixelFixAll: handlePixelFixAll, onCloseSkills: handleCloseRemountableOverlay, onClosePlan: handleClosePlanOverlay, onApprovePlan: handleApprovePlan, onRejectPlan: handleRejectPlan })) : (_jsx(ChatScreen, { columns: columns, liveItems: uniqueItemsById(liveItems), renderItem: renderItem, isRunning: agentLoop.isRunning, visibleStreamingText: visibleStreamingText, streamingThinking: agentLoop.streamingThinking, thinkingMs: agentLoop.thinkingMs, reserveStreamingSpacing: shouldReserveStreamingSpacing, renderMarkdown: renderMarkdown, measuredLiveAreaRows: measuredLiveAreaRows, fullscreen: props.fullscreen, rows: rows, transcriptLines: transcriptLines, viewportRows: viewportRows, assistantMarginTop: shouldTopSpaceStreamingText || streamingContinuesFlushed ? 1 : 0, streamingContinuation: streamingContinuesFlushed, controlsRef: mainControlsRef, hiddenQueuedCount: hiddenQueuedCount, queueIndicatorMarginTop: shouldTopSpaceQueueIndicator ? 2 : 1, theme: theme, statusSlotVisible: statusSlotVisible, activityVisible: activityVisible, stallStatusVisible: stallStatusVisible, liveToolFeed: liveToolFeed, doneStatus: doneStatus, activityPhase: agentLoop.activityPhase, elapsedMs: agentLoop.elapsedMs, runStartRef: agentLoop.runStartRef, isThinking: agentLoop.isThinking, thinkingLevel: thinkingLevel, tokenEstimate: agentLoop.streamedTokenEstimate, charCountRef: agentLoop.charCountRef, realTokensAccumRef: agentLoop.realTokensAccumRef, lastUserMessage: lastUserMessage, activeToolNames: agentLoop.activeToolCalls.map((tc) => tc.name), retryInfo: agentLoop.retryInfo, planDone: planSteps.filter((s) => s.completed).length, planTotal: planSteps.length, formatDuration: formatDuration, inputControls: {
+                onSubmit: handleSubmit,
+                onAbort: handleAbort,
+                injectText: composerInject,
+                inputActive: !taskBarFocused && !overlay,
+                onDownAtEnd: handleFocusTaskBar,
+                onShiftTab: handleToggleThinking,
+                onToggleTasks: handleToggleTasks,
+                onToggleSkills: () => openOverlay("skills"),
+                onTogglePixel: () => openOverlay("pixel"),
+                onToggleGoal: () => openOverlay("goal"),
+                onToggleMarkdown: () => setRenderMarkdown((prev) => !prev),
+                cwd: props.cwd,
+                commands: allCommands,
+                mouseScroll: props.fullscreen,
+                onScroll: scrollTranscriptByLines,
+            }, taskPicker: {
+                open: taskPicker.open,
+                tasks: taskPicker.tasks,
+                onClose: taskPicker.close,
+                onStart: taskPicker.start,
+                onRunAll: taskPicker.runAll,
+                onDelete: taskPicker.deleteTask,
+            }, goalPane: {
+                cwd: props.cwd,
+                autoExpandNewest: goalAutoExpand,
+                statusEntries: goalStatusEntries,
+                onClose: handleCloseGoalOverlay,
+                onRunGoal: handleRunGoal,
+                onVerifyGoal: handleVerifyGoal,
+                onPauseGoal: handlePauseGoal,
+                onRefineGoal: handleRefineGoal,
+            }, overlay: overlay, onModelSelect: handleModelSelect, onModelCancel: () => setOverlay(null), loggedInProviders: props.loggedInProviders ?? [currentProvider], currentModel: currentModel, currentProvider: currentProvider, onThemeSelect: handleThemeSelect, onThemeCancel: () => setOverlay(null), currentTheme: theme.name, contextUsed: agentLoop.contextUsed, contextWindowOptions: contextWindowOptions, displayedCwd: displayedCwd, gitBranch: gitBranch, planMode: planMode, exitPending: exitPending, footerStatusLayout: footerStatusLayout, backgroundTasks: bgTasks, taskBarFocused: taskBarFocused, taskBarExpanded: taskBarExpanded, selectedTaskIndex: selectedTaskIndex, onTaskBarExpand: handleTaskBarExpand, onTaskBarCollapse: handleTaskBarCollapse, onTaskKill: handleTaskKill, onTaskBarExit: handleTaskBarExit, onTaskNavigate: handleTaskNavigate })) }));
 }
 //# sourceMappingURL=App.js.map