@prestyj/cli 4.4.0 → 4.5.0

package/dist/ui/App.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;
@@ -1373,6 +1406,11 @@ export function App(props) {
                 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,
             });
@@ -1935,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;
@@ -1993,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;
@@ -2450,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: [],
@@ -2471,7 +2543,7 @@ export function App(props) {
                 sectionTitle: "built-in",
             },
         ];
-    }, [customCommands, idealReviewEnabled]);
+    }, [customCommands, idealReviewEnabled, autoApprovePlansEnabled]);
     const renderItem = (item, index, items) => renderTranscriptItem({
         item,
         index,
@@ -2557,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}" })`;
@@ -2868,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);
@@ -2884,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;
@@ -3186,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,