@prestyj/cli 4.3.239 → 4.5.0

package/dist/ui/App.js

@@ -12,7 +12,7 @@ import { useDoublePress } from "./hooks/useDoublePress.js";
 import { useTaskBarStore, useTaskBarPolling, focusTaskBar, exitTaskBar, expandTaskBar, collapseTaskBar, navigateTaskBar, killTask, } from "./stores/taskbar-store.js";
 import { playNotificationSound } from "../utils/sound.js";
 import {} from "@prestyj/ai";
-import { downscaleForPreview, extractImagePaths } from "../utils/image.js";
+import { downscaleForPreview, extractMediaPaths } from "../utils/image.js";
 import { useAgentLoop } from "./hooks/useAgentLoop.js";
 import { useTranscriptHistory } from "./hooks/useTranscriptHistory.js";
 import { createWebSearchTool } from "../tools/web-search.js";
@@ -23,7 +23,7 @@ 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 } from "../core/model-registry.js";
+import { getModel, getVideoByteLimit } from "../core/model-registry.js";
 import { SessionManager } from "../core/session-manager.js";
 import { log } from "../core/logger.js";
 import { getPendingUpdate, startPeriodicUpdateCheck, stopPeriodicUpdateCheck, } from "../core/auto-update.js";
@@ -36,10 +36,10 @@ import { detectLanguages } from "../core/language-detector.js";
 import { detectVerifyCommands } from "../core/verify-commands.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 { extractPlanSteps, findCompletedMarkers, markStepsCompleted, rebasePlanSteps, segmentDisplayText, stripDoneMarkers, } from "../utils/plan-steps.js";
+import { getAllMcpServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd, flushOverflow, } from "./live-item-flush.js";
-import { splitAssistantStreamingText } from "./utils/assistant-stream-split.js";
+import { splitAssistantStreamingText, estimateRenderedRows, } from "./utils/assistant-stream-split.js";
 import { getNextPendingTask, markTaskInProgress } from "../core/task-store.js";
 import { buildUserContentWithAttachments } from "./prompt-routing.js";
 import { submitPromptCommand } from "./submit-prompt-command.js";
@@ -282,6 +282,10 @@ export function App(props) {
     const [runAllTasks, setRunAllTasks] = useState(props.sessionStore?.runAllTasks ?? false);
     const runAllTasksRef = useRef(props.sessionStore?.runAllTasks ?? false);
     const startTaskRef = useRef(() => { });
+    // True while a task-pane task (single or run-all) is executing. Used to
+    // suppress the interactive plan-mode approval pane, which would otherwise
+    // stall an unattended task run waiting for the user to approve a plan.
+    const taskRunningRef = useRef(props.sessionStore?.taskRunning ?? false);
     const runAllPixelRef = useRef(props.sessionStore?.runAllPixel ?? false);
     const currentPixelFixRef = useRef(null);
     const startPixelFixRef = useRef(() => { });
@@ -343,6 +347,8 @@ export function App(props) {
         createSessionStats({ sessionId: props.sessionStore?.sessionId ?? props.sessionId }));
     const [idealReviewEnabled, setIdealReviewEnabled] = useState(props.sessionStore?.idealReviewEnabled ?? props.idealReviewEnabled ?? true);
     const idealReviewEnabledRef = useRef(idealReviewEnabled);
+    const [autoApprovePlansEnabled, setAutoApprovePlansEnabled] = useState(props.sessionStore?.autoApprovePlans ?? props.autoApprovePlans ?? true);
+    const autoApprovePlansEnabledRef = useRef(autoApprovePlansEnabled);
     /** Last actual API-reported input token count (from turn_end). */
     const lastActualTokensRef = useRef(0);
     /** Timestamp (ms) when lastActualTokensRef was last updated by turn_end. */
@@ -368,11 +374,21 @@ export function App(props) {
      */
     const triggerAutoSetupRef = useRef(async () => { });
     const getId = () => `ui-${nextIdRef.current++}`;
+    // Single predicate for "no human is present to approve a plan": task-list
+    // runs (single + run-all, via taskRunningRef) and pixel-fix runs (single +
+    // run-all-pixel, via currentPixelFixRef). Every autonomous context routes
+    // through here so future ones only update one place.
+    const isUnattendedRun = () => taskRunningRef.current || currentPixelFixRef.current !== null;
     useEffect(() => {
         idealReviewEnabledRef.current = idealReviewEnabled;
         if (props.sessionStore)
             props.sessionStore.idealReviewEnabled = idealReviewEnabled;
     }, [idealReviewEnabled, props.sessionStore]);
+    useEffect(() => {
+        autoApprovePlansEnabledRef.current = autoApprovePlansEnabled;
+        if (props.sessionStore)
+            props.sessionStore.autoApprovePlans = autoApprovePlansEnabled;
+    }, [autoApprovePlansEnabled, props.sessionStore]);
     const sessionStore = props.sessionStore;
     const { planMode, goalMode, rebuildSystemPrompt, replaceSystemPrompt, setPlanModeAndPrompt, setGoalModeAndPrompt, } = useModeState({
         initialPlanMode: props.sessionStore?.planMode ?? props.planModeRef?.current ?? false,
@@ -577,8 +593,25 @@ export function App(props) {
         void props
             .connectInitialMcpTools()
             .then((mcpTools) => {
-            if (cancelled || mcpTools.length === 0)
+            if (cancelled)
                 return;
+            if (mcpTools.length === 0) {
+                // No MCP tools connected (e.g. kencode-search failed to boot). The
+                // system prompt was built without them, so the model is never told
+                // to call tools it doesn't have — but flag it so the user knows
+                // public-code research is degraded this session.
+                log("WARN", "mcp", "No MCP tools connected at startup");
+                setLiveItems((prev) => [
+                    ...prev,
+                    {
+                        kind: "info",
+                        text: "Research tools (kencode-search) didn't connect — public-code search is unavailable this session.",
+                        id: getId(),
+                    },
+                ]);
+                return;
+            }
+            log("INFO", "mcp", `MCP tools ready: ${mcpTools.length} tool(s)`);
             setCurrentTools((prev) => {
                 const next = [...prev.filter((tool) => !tool.name.startsWith("mcp__")), ...mcpTools];
                 currentToolsRef.current = next;
@@ -772,6 +805,8 @@ export function App(props) {
         tools: currentTools,
         webSearch: props.webSearch,
         maxTokens: props.maxTokens,
+        supportsImages: getModel(currentModel)?.supportsImages ?? true,
+        supportsVideo: getModel(currentModel)?.supportsVideo ?? false,
         thinking: thinkingLevel,
         apiKey: activeApiKey,
         baseUrl: activeBaseUrl,
@@ -889,10 +924,32 @@ export function App(props) {
             if (planStepsRef.current.length > 0) {
                 const completed = findCompletedMarkers(text);
                 if (completed.size > 0) {
-                    const updated = markStepsCompleted(planStepsRef.current, completed);
-                    if (updated !== planStepsRef.current) {
-                        planStepsRef.current = updated;
-                        setPlanSteps(updated);
+                    const planPath = approvedPlanPathRef.current;
+                    // The agent can rewrite/expand the approved plan mid-run, so the
+                    // snapshot captured at approval goes stale (wrong total, and new
+                    // [DONE:n] markers match nothing). Re-extract from the live plan
+                    // file and re-base onto it before applying markers. The file read
+                    // is async; apply markers inside the same async step to avoid a
+                    // race with the snapshot. Fall back to the in-memory snapshot if
+                    // there is no plan path or the read fails.
+                    const applyMarkers = (base) => {
+                        const updated = markStepsCompleted(base, completed);
+                        if (updated !== planStepsRef.current) {
+                            planStepsRef.current = updated;
+                            setPlanSteps(updated);
+                        }
+                    };
+                    if (planPath) {
+                        void import("node:fs/promises")
+                            .then(({ readFile }) => readFile(planPath, "utf-8"))
+                            .then((planContent) => {
+                            const fresh = extractPlanSteps(planContent);
+                            applyMarkers(rebasePlanSteps(planStepsRef.current, fresh));
+                        })
+                            .catch(() => applyMarkers(planStepsRef.current));
+                    }
+                    else {
+                        applyMarkers(planStepsRef.current);
                     }
                     // Real progress happened — reset the stuck-guard so the next
                     // step gets its own fresh nudge budget.
@@ -1229,6 +1286,18 @@ export function App(props) {
             log("INFO", "server_tool", `Server tool call: ${name}`, { id });
             const startedAt = Date.now();
             const animateUntil = startedAt + RUNNING_INDICATOR_ANIMATION_MS;
+            // Feed the pinned LiveToolPanel so provider-side tools (Anthropic's
+            // native web_search) appear in the same rolling window as client
+            // tools. `input` carries the tool args (e.g. { query }) the row reads.
+            setLiveToolFeed((prev) => [
+                ...prev,
+                {
+                    id,
+                    name,
+                    args: (input ?? {}),
+                    status: "running",
+                },
+            ].slice(-(LIVE_TOOL_PANEL_ROWS * 2)));
             // Flush completed items (including assistant text) before adding server
             // tool UI — same rationale as onToolStart.
             setLiveItems((prev) => {
@@ -1243,6 +1312,11 @@ export function App(props) {
                 if (flushed.length > 0) {
                     queueFlush(flushed);
                 }
+                // The pre-tool text was just pinned; the hook resets its streaming
+                // buffer at this same boundary. Reset the progressive-flush offset
+                // so post-tool text is measured from zero (stale flushedChars would
+                // otherwise slice into the fresh, shorter buffer).
+                streamedAssistantFlushRef.current = { flushedChars: 0, text: "" };
                 return [
                     ...remaining,
                     {
@@ -1259,6 +1333,9 @@ export function App(props) {
         }, [queueFlush]),
         onServerToolResult: useCallback((toolUseId, resultType, data) => {
             log("INFO", "server_tool", `Server tool result`, { toolUseId, resultType });
+            // Mark the panel entry done. Aborts never reach here (handled in
+            // onAborted), so a result that arrives is always a normal completion.
+            setLiveToolFeed((prev) => prev.map((entry) => entry.id === toolUseId ? { ...entry, status: "done" } : entry));
             setLiveItems((prev) => {
                 let updated;
                 const startIdx = prev.findIndex((item) => item.kind === "server_tool_start" && item.serverToolCallId === toolUseId);
@@ -1324,11 +1401,16 @@ export function App(props) {
                 return remaining;
             });
         }, [queueFlush]),
-        onDone: useCallback((durationMs, toolsUsed) => {
+        onDone: useCallback((durationMs, toolsUsed, runStats) => {
             log("INFO", "agent", `Agent done`, {
                 duration: `${durationMs}ms`,
                 toolsUsed: toolsUsed.join(",") || "none",
             });
+            // The task run (if any) is finished. Run-all re-arms this below when it
+            // auto-starts the next task.
+            taskRunningRef.current = false;
+            if (props.sessionStore)
+                props.sessionStore.taskRunning = false;
             const doneDecision = getDoneFlushDecision({
                 planOverlayPending: planOverlayPendingRef.current,
             });
@@ -1337,7 +1419,13 @@ export function App(props) {
             // 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) });
+                setDoneStatus({
+                    durationMs,
+                    toolsUsed,
+                    verb: pickDurationVerb(toolsUsed),
+                    counts: runStats?.counts,
+                    tokens: runStats?.tokens,
+                });
                 playNotificationSound();
             }
             // Keep the final assistant response mounted in the live frame after a
@@ -1465,10 +1553,14 @@ export function App(props) {
             const imageCount = typeof content === "string"
                 ? undefined
                 : content.filter((c) => c.type === "image").length || undefined;
+            const videoCount = typeof content === "string"
+                ? undefined
+                : content.filter((c) => c.type === "video").length || undefined;
             const userItem = {
                 kind: "user",
                 text: displayText,
                 imageCount,
+                videoCount,
                 id: getId(),
             };
             setLastUserMessage(displayText);
@@ -1505,6 +1597,13 @@ export function App(props) {
                 },
             ];
         }, []),
+        onRetry: useCallback(() => {
+            // Roll back any pending progressive flushes from the aborted attempt.
+            // Without this, a stall retry regenerates the preamble and the old
+            // flushed paragraph + the new one both end up in terminal history.
+            pendingHistoryFlushRef.current = pendingHistoryFlushRef.current.filter((item) => item.kind !== "assistant");
+            streamedAssistantFlushRef.current = { flushedChars: 0, text: "" };
+        }, []),
     });
     const continueGoalRun = useCallback((run) => {
         const cwd = cwdRef.current;
@@ -1874,6 +1973,12 @@ export function App(props) {
         if (sessionStore) {
             sessionStore.pendingAction = undefined;
         }
+        // Re-arm the task-running flag after the remount: startTask sets it but the
+        // resetUI() remount drops the plain ref, so without this an unattended task
+        // run would look interactive (and stall on plan-mode approval).
+        if (sessionStore?.taskRunning) {
+            taskRunningRef.current = true;
+        }
         setDoneStatus(null);
         if (action.planEvent) {
             const ev = action.planEvent;
@@ -1891,6 +1996,9 @@ export function App(props) {
         void agentLoop.run(action.prompt).catch((err) => {
             const errMsg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", errMsg);
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
         // Intentional one-shot: run once on mount, never re-fire on re-render.
@@ -1929,6 +2037,26 @@ export function App(props) {
             ]);
             return;
         }
+        if (trimmed === "/autoplan-on" || trimmed === "/autoplan-off") {
+            const next = trimmed === "/autoplan-on";
+            setAutoApprovePlansEnabled(next);
+            if (props.settingsFile) {
+                const sm = new SettingsManager(props.settingsFile);
+                await sm.load();
+                await sm.set("autoApprovePlans", next);
+            }
+            setLiveItems((prev) => [
+                ...prev,
+                {
+                    kind: "info",
+                    text: next
+                        ? "Auto-approve plans enabled — unattended runs approve plans and keep going. Use /autoplan-off to disable."
+                        : "Auto-approve plans disabled — unattended runs decline plan mode instead. Use /autoplan-on to enable.",
+                    id: getId(),
+                },
+            ]);
+            return;
+        }
         // /rewind — open the checkpoint picker (needs React state + the store).
         if (trimmed === "/rewind") {
             const store = props.checkpointStore;
@@ -2056,31 +2184,35 @@ export function App(props) {
         }
         // ── Build user content (shared by normal + queued paths) ──
         const hasImages = inputImages.length > 0;
+        const imageCount = inputImages.filter((img) => img.kind === "image").length;
+        const videoCount = inputImages.filter((img) => img.kind === "video").length;
         const modelInfo = getModel(currentModel);
         const modelSupportsImages = modelInfo?.supportsImages ?? true;
-        const userContent = buildUserContentWithAttachments(input, inputImages, modelSupportsImages);
+        const modelSupportsVideo = modelInfo?.supportsVideo ?? false;
+        const userContent = buildUserContentWithAttachments(input, inputImages, modelSupportsImages, modelSupportsVideo);
         // ── 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, input);
             let displayText = input;
             if (hasImages) {
-                const { cleanText } = await extractImagePaths(input, props.cwd);
+                const { cleanText } = await extractMediaPaths(input, props.cwd);
                 displayText = cleanText;
             }
             const queuedItem = {
                 kind: "queued",
                 text: displayText,
-                imageCount: hasImages ? inputImages.length : undefined,
+                imageCount: imageCount > 0 ? imageCount : undefined,
+                videoCount: videoCount > 0 ? videoCount : undefined,
                 id: getId(),
             };
             setLiveItems((prev) => [...prev, queuedItem]);
             return;
         }
-        // Build display text — strip image paths, show badges instead
+        // Build display text — strip image/video paths, show badges instead
         let displayText = input;
         if (hasImages) {
-            const { cleanText } = await extractImagePaths(input, props.cwd);
+            const { cleanText } = await extractMediaPaths(input, props.cwd);
             displayText = cleanText;
         }
         let imagePreviews;
@@ -2096,7 +2228,8 @@ export function App(props) {
         const userItem = {
             kind: "user",
             text: displayText,
-            imageCount: hasImages ? inputImages.length : undefined,
+            imageCount: imageCount > 0 ? imageCount : undefined,
+            videoCount: videoCount > 0 ? videoCount : undefined,
             imagePreviews,
             pasteInfo,
             id: getId(),
@@ -2130,6 +2263,12 @@ export function App(props) {
             const msg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", msg);
             const isAbort = msg.includes("aborted") || msg.includes("abort");
+            // If the agent loop threw but left isRunning in a stale true state
+            // (can happen when the finally block hasn't been processed by React
+            // yet), reset it so the user isn't deadlocked with a non-working UI.
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [
                 ...prev,
                 isAbort
@@ -2220,8 +2359,14 @@ export function App(props) {
                     rebuildPromptWithTools(next);
                     return next;
                 });
-                // Reconnect MCP servers
-                if (props.mcpManager) {
+                // Reconnect MCP servers ONLY when the resolved server set actually
+                // changes. GLM is the only provider with a different set (Z.AI
+                // servers), so a switch that doesn't involve GLM on either side
+                // keeps the identical set — tearing down a live stdio child (e.g.
+                // kencode-search) and re-spawning `npx` there only risks a failed
+                // re-spawn that would silently drop the tools.
+                const glmInvolved = newProvider === "glm" || prevProvider === "glm";
+                if (props.mcpManager && glmInvolved) {
                     void (async () => {
                         // Disconnect old MCP servers
                         await props.mcpManager.dispose();
@@ -2240,7 +2385,11 @@ export function App(props) {
                             apiKey = props.credentialsByProvider?.["glm"]?.accessToken;
                         }
                         try {
-                            const mcpTools = await props.mcpManager.connectAll(getMCPServers(newProvider, apiKey));
+                            // Use getAllMcpServers so user-configured servers (from
+                            // ~/.ezcoder/mcp.json and ./.gg/mcp.json) survive the reconnect —
+                            // getMCPServers returns provider defaults only.
+                            const servers = await getAllMcpServers(newProvider, apiKey, props.cwd);
+                            const mcpTools = await props.mcpManager.connectAll(servers);
                             setCurrentTools((prev) => {
                                 const next = [...prev.filter((t) => !t.name.startsWith("mcp__")), ...mcpTools];
                                 rebuildPromptWithTools(next);
@@ -2262,7 +2411,26 @@ export function App(props) {
             }
             return newProvider;
         });
-        setCurrentModel(newModelId);
+        // The `read` tool's video capability (its description + native-video
+        // execute path) is baked in at creation from the model's `maxVideoBytes`.
+        // Switching to/from a video-capable model (e.g. text-only MiMo-V2.5-Pro →
+        // omnimodal MiMo-V2.5) must rebuild it, or the tool keeps telling the model
+        // it can't watch video. Rebuild reuses the read tracker, so read-before-edit
+        // history survives. Provider-change rebuilds the prompt above; this covers
+        // same-provider model switches too.
+        setCurrentModel((prevModel) => {
+            if (props.rebuildReadTool &&
+                getVideoByteLimit(prevModel) !== getVideoByteLimit(newModelId)) {
+                const newReadTool = props.rebuildReadTool(newModelId);
+                setCurrentTools((prev) => {
+                    const next = prev.map((tool) => (tool.name === "read" ? newReadTool : tool));
+                    currentToolsRef.current = next;
+                    void replaceSystemPrompt({ tools: next });
+                    return next;
+                });
+            }
+            return newModelId;
+        });
         const modelInfo = getModel(newModelId);
         const displayName = modelInfo?.name ?? newModelId;
         setLiveItems((prev) => [
@@ -2277,7 +2445,14 @@ export function App(props) {
                 await sm.set("defaultModel", newModelId);
             });
         }
-    }, [props.settingsFile, props.mcpManager, props.credentialsByProvider, props.authStorage]);
+    }, [
+        props.settingsFile,
+        props.mcpManager,
+        props.credentialsByProvider,
+        props.authStorage,
+        props.rebuildReadTool,
+        replaceSystemPrompt,
+    ]);
     const handleThemeSelect = useCallback((name) => {
         setOverlay(null);
         if (switchTheme) {
@@ -2339,6 +2514,14 @@ export function App(props) {
                     : "Enable pre-final ideal review",
                 sectionTitle: "built-in",
             },
+            {
+                name: autoApprovePlansEnabled ? "autoplan-off" : "autoplan-on",
+                aliases: [],
+                description: autoApprovePlansEnabled
+                    ? "Disable auto-approving plans in unattended runs"
+                    : "Enable auto-approving plans in unattended runs",
+                sectionTitle: "built-in",
+            },
             {
                 name: "rewind",
                 aliases: [],
@@ -2360,7 +2543,7 @@ export function App(props) {
                 sectionTitle: "built-in",
             },
         ];
-    }, [customCommands, idealReviewEnabled]);
+    }, [customCommands, idealReviewEnabled, autoApprovePlansEnabled]);
     const renderItem = (item, index, items) => renderTranscriptItem({
         item,
         index,
@@ -2446,6 +2629,9 @@ export function App(props) {
     // onDone can invoke it from stale closures.
     const startTask = useCallback((title, prompt, taskId) => {
         const taskCwd = cwdRef.current;
+        taskRunningRef.current = true;
+        if (props.sessionStore)
+            props.sessionStore.taskRunning = true;
         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}" })`;
@@ -2497,6 +2683,9 @@ export function App(props) {
         setDoneStatus(null);
         setLiveItems([taskItem]);
         void agentLoop.run(fullPrompt).catch((err) => {
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
     }, [agentLoop, currentModel, currentProvider, props]);
@@ -2545,7 +2734,23 @@ export function App(props) {
     // 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
+    // Retry-safety gate: don't commit streamed paragraphs to permanent scrollback
+    // while the text is still small enough to live entirely in the live region.
+    // A silent stall-retry (agent-loop.ts) restarts the LLM call from scratch and
+    // regenerates the opening text — reworded, so the byte-identical dedup can't
+    // catch it. Anything already printed to scrollback can't be un-written, so the
+    // regen appends as a second ⏺ bullet that paraphrases the first. Keeping short
+    // streamed text live (it clears via setStreamingText("") on retry) closes that
+    // hole. We only start flushing once the unflushed text would overflow the live
+    // area — the original anti-jump purpose, which only matters for long responses
+    // that are far less likely to be a stalled preamble. Once flushing has begun
+    // for this turn (alreadyFlushedChars > 0) we keep flushing every boundary so
+    // committed continuation paragraphs stay consistent with the live tail.
+    const unflushedStreamingRows = rawVisibleStreamingText
+        ? estimateRenderedRows(rawVisibleStreamingText.slice(alreadyFlushedChars), columns)
+        : 0;
+    const shouldFlushStreamedText = alreadyFlushedChars > 0 || unflushedStreamingRows > measuredLiveAreaRows;
+    const pendingFlushChars = rawVisibleStreamingText && shouldFlushStreamedText
         ? splitAssistantStreamingText(rawVisibleStreamingText.slice(alreadyFlushedChars)).flushedText
             .length
         : 0;
@@ -2556,6 +2761,13 @@ export function App(props) {
         }
         if (rawVisibleStreamingText === streamedAssistantFlushRef.current.text)
             return;
+        if (!shouldFlushStreamedText) {
+            streamedAssistantFlushRef.current = {
+                ...streamedAssistantFlushRef.current,
+                text: rawVisibleStreamingText,
+            };
+            return;
+        }
         const alreadyFlushed = streamedAssistantFlushRef.current.flushedChars;
         const unflushedText = rawVisibleStreamingText.slice(alreadyFlushed);
         const split = splitAssistantStreamingText(unflushedText);
@@ -2578,7 +2790,7 @@ export function App(props) {
             ...streamedAssistantFlushRef.current,
             text: rawVisibleStreamingText,
         };
-    }, [rawVisibleStreamingText, queueFlush]);
+    }, [rawVisibleStreamingText, shouldFlushStreamedText, 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
@@ -2731,13 +2943,48 @@ export function App(props) {
         setOverlay(null);
     };
     const handleEnterPlanMode = useCallback(async (reason) => {
+        // During an unattended run with auto-approve disabled, plan mode would open
+        // an approval pane and stall the loop waiting on a human. Decline plan mode
+        // so the agent implements directly. When auto-approve is enabled we DO allow
+        // plan mode — handleExitPlanMode auto-approves the plan in place and the run
+        // keeps going, preserving the explore→plan→implement process.
+        if (isUnattendedRun() && !autoApprovePlansEnabledRef.current)
+            return false;
         await setPlanModeAndPrompt(true);
         setLiveItems((prev) => [
             ...prev,
             { kind: "plan_transition", text: reason ?? "", id: getId(), active: true },
         ]);
+        return true;
     }, [setPlanModeAndPrompt]);
-    const handleExitPlanMode = useCallback(async (_planPath) => {
+    const handleExitPlanMode = useCallback(async (planPath) => {
+        // Unattended run + auto-approve enabled: approve the plan IN PLACE (no
+        // remount, no message wipe) so the appended task-completion hint survives
+        // and run-all can advance. Swap the system prompt from "Plan Mode (ACTIVE)"
+        // to the "Approved Plan" + step-tracking section, surface an auditable
+        // transcript row, and tell the model to implement now.
+        if (isUnattendedRun() && autoApprovePlansEnabledRef.current) {
+            log("INFO", "plan", "Plan auto-approved during unattended run", { planPath });
+            let steps = [];
+            try {
+                const planContent = await import("node:fs/promises").then(({ readFile }) => readFile(planPath, "utf-8"));
+                steps = extractPlanSteps(planContent);
+            }
+            catch {
+                // Plan with no readable steps still proceeds (just no step widget).
+            }
+            approvedPlanPathRef.current = planPath;
+            planStepsRef.current = steps;
+            setPlanSteps(steps);
+            await setPlanModeAndPrompt(false);
+            await replaceSystemPrompt({ approvedPlanPath: planPath, planMode: false });
+            setLiveItems((prev) => [
+                ...prev,
+                { kind: "plan_event", event: "auto-approved", detail: planPath, id: getId() },
+            ]);
+            return (`Plan auto-approved (unattended run). The approved plan is at ${planPath}. ` +
+                `Implement it now, following each step in order.`);
+        }
         await setPlanModeAndPrompt(false);
         planOverlayPendingRef.current = true;
         setPlanAutoExpand(true);
@@ -2747,13 +2994,38 @@ export function App(props) {
         }
         setOverlay("plan");
         return "Plan submitted for user review. Wait for the user to approve, reject, or dismiss it before implementing.";
-    }, [props.sessionStore, setPlanModeAndPrompt]);
+    }, [props.sessionStore, setPlanModeAndPrompt, replaceSystemPrompt]);
     useEffect(() => {
         if (!props.planCallbacks)
             return;
         props.planCallbacks.onEnterPlan = handleEnterPlanMode;
         props.planCallbacks.onExitPlan = handleExitPlanMode;
     }, [handleEnterPlanMode, handleExitPlanMode, props.planCallbacks]);
+    // Toggle auto-approve-plans (Ctrl+O / /autoplan-on|off). Persists the setting
+    // so it survives restarts and pushes a transient info row for feedback.
+    const handleToggleAutoApprove = useCallback(() => {
+        const next = !autoApprovePlansEnabledRef.current;
+        setAutoApprovePlansEnabled(next);
+        if (props.settingsFile) {
+            const sm = new SettingsManager(props.settingsFile);
+            void sm
+                .load()
+                .then(() => sm.set("autoApprovePlans", next))
+                .catch(() => {
+                /* persistence is best-effort */
+            });
+        }
+        setLiveItems((prev) => [
+            ...prev,
+            {
+                kind: "info",
+                text: next
+                    ? "Auto-approve plans enabled — unattended runs approve plans and keep going. Use /autoplan-off to disable."
+                    : "Auto-approve plans disabled — unattended runs decline plan mode instead. Use /autoplan-on to enable.",
+                id: getId(),
+            },
+        ]);
+    }, [props.settingsFile]);
     const handleCloseGoalOverlay = () => {
         if (props.resetUI && props.sessionStore && !agentLoop.isRunning) {
             props.sessionStore.overlay = null;
@@ -3018,6 +3290,9 @@ export function App(props) {
         void agentLoop.run(rejectionMsg).catch((err) => {
             const errMsg = err instanceof Error ? err.message : String(err);
             log("ERROR", "error", errMsg);
+            if (agentLoop.isRunning) {
+                agentLoop.reset();
+            }
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
     };
@@ -3046,6 +3321,7 @@ export function App(props) {
                 onTogglePixel: () => openOverlay("pixel"),
                 onToggleGoal: () => openOverlay("goal"),
                 onToggleMarkdown: () => setRenderMarkdown((prev) => !prev),
+                onToggleAutoApprove: handleToggleAutoApprove,
                 cwd: props.cwd,
                 commands: allCommands,
                 mouseScroll: props.fullscreen,