@kenkaiiii/ggcoder 4.3.232 → 4.3.233

package/dist/ui/App.js

@@ -4,12 +4,10 @@ import { Box, useStdout } from "ink";
 import { useTerminalSize } from "./hooks/useTerminalSize.js";
 import { useChatLayoutMeasurements } from "./hooks/useChatLayoutMeasurements.js";
 import { useTaskPickerController } from "./hooks/useTaskPickerController.js";
-import { useGoalPickerController } from "./hooks/useGoalPickerController.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 { useGoalOrchestration } from "./hooks/useGoalOrchestration.js";
 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";
@@ -19,9 +17,9 @@ import { useAgentLoop } from "./hooks/useAgentLoop.js";
 import { useTranscriptHistory } from "./hooks/useTranscriptHistory.js";
 import { createWebSearchTool } from "../tools/web-search.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 { reconcileGoalStatusEntriesWithRuns, removeGoalStatusEntry, syncGoalStatusEntries, } from "./components/GoalStatusBar.js";
 import { useTheme, useSetTheme } from "./theme/theme.js";
 import { useTerminalTitle } from "./hooks/useTerminalTitle.js";
 import { getGitBranch } from "../utils/git.js";
@@ -41,17 +39,13 @@ import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, segmentDisp
 import { getMCPServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd, flushOverflow, } from "./live-item-flush.js";
 import { splitAssistantStreamingText } from "./utils/assistant-stream-split.js";
-import { goalHasBlockingPrerequisites, loadGoalRuns, reconcileActiveGoalRuns, upsertGoalRun, } from "../core/goal-store.js";
 import { getNextPendingTask, markTaskInProgress } from "../core/tasks-store.js";
-import { listGoalWorkers, stopGoalWorker } from "../core/goal-worker.js";
-import { isGoalSyntheticEvent, parseGoalSyntheticEvent } from "./goal-events.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 { getNextThinkingLevel, isThinkingLevelSupported } from "./thinking-level.js";
-import { appendGoalProgressDraft, completedItemsWithDurableGoalTerminalProgress, } from "./goal-progress.js";
-import { getDoneFlushDecision, nextGoalModeAfterAgentDone, shouldTopSpaceAfterPrintedAgentBoundary, shouldTopSpaceStreamingAssistant, } from "./layout-decisions.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";
@@ -62,13 +56,11 @@ import { pickDurationVerb } from "./duration-summary.js";
 import { toErrorItem } from "./error-item.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 } from "./app-items.js";
-export { buildGoalSetupPromptFromPlanner, buildUserContentWithAttachments, collectAssistantTextSince, isGoalPromptCommandName, routePromptCommandInput, runGoalPromptSetupSequence, } from "./prompt-routing.js";
+import { IDEAL_HOOK_NOTICE_TEXT, lastVisibleTranscriptItem } from "./app-items.js";
+export { buildUserContentWithAttachments, routePromptCommandInput } from "./prompt-routing.js";
 export { getNextThinkingLevel } from "./thinking-level.js";
-export { appendGoalProgressDraft, completedItemsWithDurableGoalTerminalProgress, formatGoalTerminalProgress, getGoalContinuationChoiceKey, routeGoalSyntheticEvent, truncateGoalProgressText, } from "./goal-progress.js";
-export { getChatControlsLayoutDecision, getDoneFlushDecision, getGoalActivationPaneTransition, getGoalSetupFinishedPaneTransition, getGoalSetupPaneTransitionAfterRun, getScrollStabilizationDecision, getStaticHistoryKey, hasParagraphBreakLiveUserMessage, isTallLiveUserMessage, nextGoalModeAfterAgentDone, shouldHideHistoryForOverlayView, shouldHideStaticItemsForOverlayView, shouldResetUIForGoalSetupPaneTransition, shouldStabilizeOverlayPaneRerender, shouldTopSpaceAfterPrintedAgentBoundary, shouldTopSpaceAssistantAfterToolBoundary, shouldTopSpaceStreamingAssistant, } from "./layout-decisions.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";
-export { buildGoalUserPauseRun, goalRunNeedsExplicitContinuationAfterWorker, shouldKeepGoalRunTrackedAfterDecision, shouldRunGoalTaskInMainCheckout, } from "./goal-run-helpers.js";
 /** Tools that get aggregated into a single compact group when possible. */
 const AGGREGATABLE_TOOLS = new Set([
     "read",
@@ -133,29 +125,26 @@ 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 finalized.
+    // 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 [goalStatusEntries, setGoalStatusEntries] = useState(props.sessionStore?.goalStatusEntries ?? []);
     const [updatePending, setUpdatePending] = useState(() => getPendingUpdate(props.version) !== null);
     // 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 runningGoalIdsRef = useRef(new Set());
-    const activeVerifierRunIdsRef = useRef(new Set());
-    const queuedGoalSyntheticEventsRef = useRef(0);
-    const goalContinuationFlightsRef = useRef(new Set());
-    const goalContinuationRecentChoicesRef = useRef(new Map());
-    const startGoalRunRef = useRef(() => { });
     const [runAllTasks, setRunAllTasks] = useState(props.sessionStore?.runAllTasks ?? false);
     const runAllTasksRef = useRef(props.sessionStore?.runAllTasks ?? false);
     const startTaskRef = useRef(() => { });
@@ -176,7 +165,6 @@ export function App(props) {
     const [doneStatus, setDoneStatus] = useState(props.sessionStore?.doneStatus ?? null);
     // Suppress "done" status when a plan overlay is about to open
     const planOverlayPendingRef = useRef(false);
-    const goalSetupPanePendingRef = useRef(false);
     const [gitBranch, setGitBranch] = useState(null);
     const [currentModel, setCurrentModel] = useState(props.model);
     const [currentProvider, setCurrentProvider] = useState(props.provider);
@@ -187,8 +175,6 @@ export function App(props) {
     const [renderMarkdown, setRenderMarkdown] = useState(true);
     const messagesRef = useRef(props.sessionStore?.messages ?? props.messages);
     const [planAutoExpand, setPlanAutoExpand] = useState(props.sessionStore?.planAutoExpand ?? false);
-    const [goalAutoExpand, setGoalAutoExpand] = useState(props.sessionStore?.goalAutoExpand ?? false);
-    const goalAutoExpandRef = useRef(props.sessionStore?.goalAutoExpand ?? false);
     const approvedPlanPathRef = useRef(props.sessionStore?.approvedPlanPath);
     const planStepsRef = useRef(props.sessionStore?.planSteps ?? []);
     const [planSteps, setPlanSteps] = useState(props.sessionStore?.planSteps ?? []);
@@ -199,7 +185,7 @@ 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, goal pane open, etc.) starts the counter at 0
+    // (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.
@@ -239,40 +225,15 @@ export function App(props) {
      */
     const triggerAutoSetupRef = useRef(async () => { });
     const getId = () => `ui-${nextIdRef.current++}`;
-    const appendGoalAgentTransition = useCallback((text) => {
-        setLiveItems((prev) => [...prev, { kind: "goal_agent_transition", text, id: getId() }]);
-    }, []);
-    const appendGoalProgress = useCallback((item) => {
-        setLiveItems((prev) => appendGoalProgressDraft(prev, item, getId));
-    }, []);
     useEffect(() => {
         idealReviewEnabledRef.current = idealReviewEnabled;
         if (props.sessionStore)
             props.sessionStore.idealReviewEnabled = idealReviewEnabled;
     }, [idealReviewEnabled, props.sessionStore]);
-    const goalNumberForRun = useCallback((runId) => Math.max(1, goalStatusEntries.findIndex((entry) => entry.runId === runId) + 1), [goalStatusEntries]);
-    const clearGoalStatusEntry = useCallback((runId) => {
-        setGoalStatusEntries((prev) => {
-            const next = removeGoalStatusEntry(prev, runId);
-            if (props.sessionStore)
-                props.sessionStore.goalStatusEntries = next;
-            return next;
-        });
-    }, [props.sessionStore]);
-    const upsertGoalStatusEntry = useCallback((entry) => {
-        setGoalStatusEntries((prev) => {
-            const next = syncGoalStatusEntries(prev, entry);
-            if (props.sessionStore)
-                props.sessionStore.goalStatusEntries = next;
-            return next;
-        });
-    }, [props.sessionStore]);
     const sessionStore = props.sessionStore;
-    const { goalMode, planMode, goalModeStateRef, rebuildSystemPrompt, replaceSystemPrompt, setGoalModeAndPrompt, setPlanModeAndPrompt, clearGoalModeIfIdle, } = useModeState({
-        initialGoalMode: props.sessionStore?.goalMode ?? props.goalModeRef?.current ?? "off",
+    const { planMode, rebuildSystemPrompt, replaceSystemPrompt, setPlanModeAndPrompt } = useModeState({
         initialPlanMode: props.sessionStore?.planMode ?? props.planModeRef?.current ?? false,
         skills: props.skills,
-        goalModeRef: props.goalModeRef,
         planModeRef: props.planModeRef,
         sessionStore: props.sessionStore,
         cwdRef,
@@ -281,9 +242,6 @@ export function App(props) {
         approvedPlanPathRef,
         injectedLanguagesRef,
         messagesRef,
-        runningGoalIdsRef,
-        activeVerifierRunIdsRef,
-        queuedGoalSyntheticEventsRef,
     });
     const { pendingHistoryFlushRef, streamedAssistantFlushRef, queueFlush, finalizeSubmittedUserItem, clearPendingHistory, } = useTranscriptHistory({
         // In fullscreen alt-screen mode the transcript renders inside Ink (the
@@ -359,19 +317,6 @@ 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.goalMode = goalMode;
-    }, [goalMode, sessionStore]);
     useEffect(() => {
         if (sessionStore)
             sessionStore.planMode = planMode;
@@ -395,35 +340,6 @@ export function App(props) {
     useEffect(() => {
         getGitBranch(displayedCwd).then(setGitBranch);
     }, [displayedCwd]);
-    useEffect(() => {
-        let cancelled = false;
-        const refreshGoalCount = () => {
-            void reconcileActiveGoalRuns(props.cwd, {
-                isWorkerActive: (workerId) => listGoalWorkers(props.cwd).some((worker) => worker.id === workerId && worker.status === "running"),
-            }).then(({ runs }) => {
-                if (cancelled)
-                    return;
-                setHistory((prev) => completedItemsWithDurableGoalTerminalProgress(prev, runs));
-                setGoalStatusEntries((prev) => {
-                    const next = reconcileGoalStatusEntriesWithRuns(prev, runs, {
-                        isWorkerActive: (workerId, run) => listGoalWorkers(props.cwd).some((worker) => worker.id === workerId &&
-                            worker.goalRunId === run.id &&
-                            worker.status === "running"),
-                        isVerifierActive: (run) => activeVerifierRunIdsRef.current.has(run.id),
-                    });
-                    if (props.sessionStore)
-                        props.sessionStore.goalStatusEntries = next;
-                    return next;
-                });
-            });
-        };
-        refreshGoalCount();
-        const interval = setInterval(refreshGoalCount, 1000);
-        return () => {
-            cancelled = true;
-            clearInterval(interval);
-        };
-    }, [props.cwd]);
     // Periodic update check during long sessions
     useEffect(() => {
         startPeriodicUpdateCheck(props.version, (msg) => {
@@ -443,10 +359,6 @@ export function App(props) {
     useEffect(() => {
         currentToolsRef.current = currentTools;
     }, [currentTools]);
-    const setActiveGoalReferences = useCallback((references) => {
-        if (props.goalReferencesRef)
-            props.goalReferencesRef.current = references;
-    }, [props.goalReferencesRef]);
     useEffect(() => {
         if (!props.connectInitialMcpTools)
             return;
@@ -735,9 +647,6 @@ export function App(props) {
             resolveCredentials,
         ]),
         onTurnText: useCallback((text, thinking, thinkingMs) => {
-            if (goalModeStateRef.current === "planner") {
-                return;
-            }
             const hadStreamedAssistantFlush = streamedAssistantFlushRef.current.flushedChars > 0;
             const unflushedAssistantText = text.slice(streamedAssistantFlushRef.current.flushedChars);
             // Track [DONE:n] markers for plan step progress
@@ -822,6 +731,9 @@ export function App(props) {
             log("INFO", "tool", `Tool call started: ${name}`, { id: toolCallId });
             const startedAt = Date.now();
             const animateUntil = startedAt + RUNNING_INDICATOR_ANIMATION_MS;
+            // 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,
@@ -945,6 +857,9 @@ 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, {
@@ -1180,10 +1095,8 @@ export function App(props) {
             });
             const doneDecision = getDoneFlushDecision({
                 planOverlayPending: planOverlayPendingRef.current,
-                goalMode: goalModeStateRef.current,
-                goalAutoExpand: goalAutoExpandRef.current,
             });
-            // Don't show "done" status when plan/goal review panes are about to open —
+            // 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.
@@ -1196,7 +1109,7 @@ export function App(props) {
             // 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/goal output
+            // Non-chat overlay transitions still flush so setup/plan output
             // does not vanish during remounts.
             if (doneDecision.flushLiveItems && !doneDecision.showDoneStatus) {
                 setLiveItems((prev) => {
@@ -1205,15 +1118,6 @@ export function App(props) {
                     return prev;
                 });
             }
-            const nextGoalMode = nextGoalModeAfterAgentDone({
-                currentMode: goalModeStateRef.current,
-                runningGoalIds: runningGoalIdsRef.current.size,
-                queuedSyntheticEvents: queuedGoalSyntheticEventsRef.current,
-                activeContinuationFlights: goalContinuationFlightsRef.current.size,
-            });
-            if (nextGoalMode !== goalModeStateRef.current) {
-                void setGoalModeAndPrompt(nextGoalMode);
-            }
             // Run-all: auto-start next pending task after a short delay.
             if (runAllTasksRef.current) {
                 setTimeout(() => {
@@ -1229,11 +1133,6 @@ export function App(props) {
                     }
                 }, 500);
             }
-            // Goal loop: after the orchestrator handles a worker/verifier event,
-            // continue the same Goal automatically until it reaches a terminal state.
-            for (const runId of [...runningGoalIdsRef.current]) {
-                setTimeout(() => continueGoalRun(runId), 500);
-            }
             // Pixel fix: observe branch + commits, patch status, optionally pick
             // up the next open error if run-all is active.
             const pendingFix = currentPixelFixRef.current;
@@ -1269,16 +1168,11 @@ export function App(props) {
                     }
                 })();
             }
-        }, [setGoalModeAndPrompt]),
+        }, []),
         onAborted: useCallback(() => {
             log("WARN", "agent", "Agent run aborted by user");
             setRunAllPixel(false);
             currentPixelFixRef.current = null;
-            queuedGoalSyntheticEventsRef.current = 0;
-            goalSetupPanePendingRef.current = false;
-            setActiveGoalReferences(undefined);
-            if (goalModeStateRef.current !== "off")
-                void setGoalModeAndPrompt("off");
             setDoneStatus(null);
             setLiveItems((prev) => {
                 const next = prev.map((item) => {
@@ -1321,42 +1215,16 @@ export function App(props) {
                 });
                 return [...next, { kind: "stopped", text: "Request was stopped.", id: getId() }];
             });
-        }, [setActiveGoalReferences, setGoalModeAndPrompt]),
+        }, []),
         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)) {
-                queuedGoalSyntheticEventsRef.current = Math.max(0, queuedGoalSyntheticEventsRef.current - 1);
-                void setGoalModeAndPrompt("coordinator");
-                const eventInfo = parseGoalSyntheticEvent(displayText);
-                // Write-then-clear: keep the rows mounted and let the flush drain
-                // print them to scrollback before removing them, so they don't blink
-                // out of the live area a frame before reappearing in scrollback.
-                setLiveItems((prev) => {
-                    if (prev.length > 0)
-                        queueFlush(prev);
-                    return prev;
-                });
-                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;
@@ -1369,7 +1237,7 @@ export function App(props) {
             setLastUserMessage(displayText);
             setDoneStatus(null);
             finalizeSubmittedUserItem(userItem);
-        }, [appendGoalProgress, finalizeSubmittedUserItem, setGoalModeAndPrompt]),
+        }, [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
@@ -1486,27 +1354,19 @@ export function App(props) {
     }, [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, Goal approval). The work survives the unmount because
+    // 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;
         const action = sessionStore?.pendingAction;
-        const pendingGoalRun = sessionStore?.pendingGoalRun;
-        if (!action && !pendingGoalRun)
+        if (!action)
             return;
         pendingActionConsumedRef.current = true;
         if (sessionStore) {
             sessionStore.pendingAction = undefined;
-            sessionStore.pendingGoalRun = undefined;
         }
         setDoneStatus(null);
-        if (pendingGoalRun) {
-            startGoalRunRef.current(pendingGoalRun);
-            return;
-        }
-        if (!action)
-            return;
         if (action.planEvent) {
             const ev = action.planEvent;
             setLiveItems((prev) => [
@@ -1649,36 +1509,20 @@ export function App(props) {
                 void replaceSystemPrompt({ clearApprovedPlan: true });
                 setLiveItems([{ kind: "plan_event", event: "dismissed", id: getId() }]);
             },
-            openGoalsPicker: () => {
-                taskPicker.close();
-                goalPicker.openPicker();
-            },
         })) {
             return;
         }
         if (await submitPromptCommand({
             trimmed,
             inputImages,
-            cwd: props.cwd,
             currentModel,
             customCommands,
-            messagesRef,
-            goalSetupPanePendingRef,
-            goalModeStateRef,
-            goalAutoExpandRef,
-            setActiveGoalReferences,
             setLastUserMessage,
             setDoneStatus,
             finalizeSubmittedUserItem,
-            setGoalModeAndPrompt,
             runAgent: (content) => agentLoop.run(content),
-            appendGoalAgentTransition,
             setLiveItems,
             getId,
-            setGoalAutoExpand,
-            setPlanAutoExpand,
-            closeTaskPicker: taskPicker.close,
-            openGoalPicker: goalPicker.openPicker,
             reloadCustomCommands,
         })) {
             return;
@@ -1776,7 +1620,6 @@ export function App(props) {
         }
     }, [
         agentLoop,
-        appendGoalAgentTransition,
         compactConversation,
         currentModel,
         finalizeSubmittedUserItem,
@@ -1789,8 +1632,6 @@ export function App(props) {
         showSessionSummaryAndExit,
         reloadCustomCommands,
         replaceSystemPrompt,
-        setActiveGoalReferences,
-        setGoalModeAndPrompt,
     ]);
     const handleDoubleExit = useDoublePress(setExitPending, showSessionSummaryAndExit);
     const handleAbort = useCallback(() => {
@@ -1947,7 +1788,6 @@ export function App(props) {
         };
         const promptOrder = [
             // Project audits / one-shot analysis
-            "goal",
             "init",
             "expand",
             "bullet-proof",
@@ -2006,8 +1846,8 @@ export function App(props) {
         item,
         index,
         items,
-        pendingHistoryFlushLastItem: index === 0 ? pendingHistoryFlushRef.current.at(-1) : undefined,
-        historyLastItem: index === 0 ? history.at(-1) : undefined,
+        pendingHistoryFlushLastItem: index === 0 ? lastVisibleTranscriptItem(pendingHistoryFlushRef.current) : undefined,
+        historyLastItem: index === 0 ? lastVisibleTranscriptItem(history) : undefined,
         version: props.version,
         currentModel,
         currentProvider,
@@ -2022,8 +1862,6 @@ export function App(props) {
             props.sessionStore.overlay = kind;
             if (kind !== "plan")
                 props.sessionStore.planAutoExpand = false;
-            if (kind !== "goal")
-                props.sessionStore.goalAutoExpand = false;
             props.resetUI();
         }
         else {
@@ -2031,53 +1869,15 @@ export function App(props) {
                 props.sessionStore.overlay = kind;
                 if (kind !== "plan")
                     props.sessionStore.planAutoExpand = false;
-                if (kind !== "goal")
-                    props.sessionStore.goalAutoExpand = false;
-                if (agentLoop.isRunning && kind !== "goal" && kind !== "plan") {
+                if (agentLoop.isRunning && kind !== "plan") {
                     props.sessionStore.pendingResetUI = true;
                 }
             }
             if (kind !== "plan")
                 setPlanAutoExpand(false);
-            if (kind !== "goal")
-                setGoalAutoExpand(false);
             setOverlay(kind);
         }
     }, [agentLoop.isRunning, props]);
-    const { continueGoalRun, startGoalRun, pauseGoalRun } = useGoalOrchestration({
-        cwd: props.cwd,
-        resetUI: props.resetUI,
-        sessionStore: props.sessionStore,
-        currentProvider,
-        currentModel,
-        thinkingLevel,
-        agentLoop,
-        appendGoalProgress,
-        goalNumberForRun,
-        clearGoalStatusEntry,
-        upsertGoalStatusEntry,
-        setGoalModeAndPrompt,
-        clearGoalModeIfIdle,
-        agentRunningRef,
-        runningGoalIdsRef,
-        activeVerifierRunIdsRef,
-        queuedGoalSyntheticEventsRef,
-        goalContinuationFlightsRef,
-        goalContinuationRecentChoicesRef,
-        startGoalRunRef,
-        startTaskRef,
-        messagesRef,
-        persistedIndexRef,
-        sessionManagerRef,
-        sessionPathRef,
-        cwdRef,
-        setLiveItems,
-        setHistory,
-        setLastUserMessage,
-        setDoneStatus,
-        getId,
-        clearPendingHistory,
-    });
     useEffect(() => {
         runAllTasksRef.current = runAllTasks;
         if (props.sessionStore)
@@ -2115,6 +1915,15 @@ export function App(props) {
         getId,
         initialRunAllPixel: props.sessionStore?.runAllPixel ?? false,
     });
+    // 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({
@@ -2132,14 +1941,26 @@ export function App(props) {
         displayedCwd,
         gitBranch,
         thinkingLevel,
-        goalMode,
         exitPending,
         taskBarExpanded,
-        goalStatusEntryCount: goalStatusEntries.length,
+        liveToolFeedCount: liveToolFeed.length,
     });
     const isPixelView = overlay === "pixel";
     const hasLiveAssistantItem = liveItems.some((item) => item.kind === "assistant");
-    const rawVisibleStreamingText = goalModeStateRef.current === "planner" || hasLiveAssistantItem ? "" : agentLoop.streamingText;
+    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: "" };
@@ -2170,10 +1991,20 @@ export function App(props) {
             text: rawVisibleStreamingText,
         };
     }, [rawVisibleStreamingText, queueFlush]);
-    const visibleStreamingText = stripDoneMarkers(rawVisibleStreamingText.slice(streamedAssistantFlushRef.current.flushedChars));
+    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 &&
@@ -2186,14 +2017,14 @@ export function App(props) {
             isAwaitingAssistantAfterUser);
     const shouldTopSpaceStreamingText = shouldTopSpaceStreamingAssistant({
         visibleStreamingText,
-        lastLiveItem,
-        lastPendingHistoryItem,
-        lastHistoryItem,
+        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 = streamedAssistantFlushRef.current.flushedChars > 0;
+    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
@@ -2466,70 +2297,9 @@ export function App(props) {
             setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
         });
     };
-    const handleRunGoalFromPicker = (run) => {
-        setDoneStatus(null);
-        appendGoalProgress({
-            kind: "goal_progress",
-            phase: "continuing",
-            title: `Goal run requested: ${run.title}`,
-            detail: "Enter pressed in Ctrl+G; starting the Goal orchestrator.",
-            status: run.status,
-        });
-        log("INFO", "goal", `Goal run requested from Ctrl+G: ${run.title}`, { id: run.id });
-        void (async () => {
-            const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
-            const requestedAt = new Date().toISOString();
-            const runWithContinuation = await upsertGoalRun(props.cwd, {
-                ...latestRun,
-                status: latestRun.status === "running" || latestRun.status === "verifying"
-                    ? latestRun.status
-                    : "ready",
-                continueRequestedAt: requestedAt,
-                blockers: goalHasBlockingPrerequisites(latestRun) ? latestRun.blockers : [],
-                evidence: [
-                    ...latestRun.evidence,
-                    {
-                        id: `goal-rerun-${requestedAt}`,
-                        kind: "summary",
-                        label: "Goal rerun requested",
-                        content: "Continuation requested from Ctrl+G; the orchestrator will choose the next eligible Goal action.",
-                        createdAt: requestedAt,
-                    },
-                ],
-            });
-            startGoalRun(runWithContinuation);
-        })().catch((err) => {
-            log("ERROR", "goal", err instanceof Error ? err.message : String(err));
-            setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal")]);
-        });
-    };
-    const handleDeleteGoalSideEffects = async (run) => {
-        runningGoalIdsRef.current.delete(run.id);
-        const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
-        if (latestRun.activeWorkerId)
-            await stopGoalWorker(latestRun.activeWorkerId);
-        clearGoalStatusEntry(run.id);
-        clearGoalModeIfIdle();
-    };
-    const handleGoalPickerError = (err) => {
-        log("ERROR", "goal", err instanceof Error ? err.message : String(err));
-        setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal")]);
-    };
-    const goalPicker = useGoalPickerController({
-        cwd: props.cwd,
-        onRunGoal: handleRunGoalFromPicker,
-        onDeleteGoalSideEffects: handleDeleteGoalSideEffects,
-        onPauseGoal: pauseGoalRun,
-        onError: handleGoalPickerError,
-    });
     const handleToggleTasks = () => {
-        goalPicker.close();
         taskPicker.toggle();
     };
-    const handleToggleGoalPicker = () => {
-        taskPicker.close();
-        goalPicker.toggle();
-    };
     const fullScreenOverlay = isPixelView
         ? "pixel"
         : isSkillsView
@@ -2540,7 +2310,7 @@ export function App(props) {
     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, 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: {
+    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,
@@ -2548,7 +2318,6 @@ export function App(props) {
                 onDownAtEnd: handleFocusTaskBar,
                 onShiftTab: handleToggleThinking,
                 onToggleTasks: handleToggleTasks,
-                onToggleGoal: handleToggleGoalPicker,
                 onToggleSkills: () => openOverlay("skills"),
                 onTogglePixel: () => openOverlay("pixel"),
                 onToggleMarkdown: () => setRenderMarkdown((prev) => !prev),
@@ -2563,13 +2332,6 @@ export function App(props) {
                 onStart: taskPicker.start,
                 onRunAll: taskPicker.runAll,
                 onDelete: taskPicker.deleteTask,
-            }, goalPicker: {
-                open: goalPicker.open,
-                goals: goalPicker.goals,
-                onClose: goalPicker.close,
-                onRun: goalPicker.run,
-                onDelete: goalPicker.deleteGoal,
-                onPause: goalPicker.pause,
-            }, 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, goalMode: goalMode, planMode: planMode, exitPending: exitPending, goalStatusEntries: goalStatusEntries, footerStatusLayout: footerStatusLayout, backgroundTasks: bgTasks, taskBarFocused: taskBarFocused, taskBarExpanded: taskBarExpanded, selectedTaskIndex: selectedTaskIndex, onTaskBarExpand: handleTaskBarExpand, onTaskBarCollapse: handleTaskBarCollapse, onTaskKill: handleTaskKill, onTaskBarExit: handleTaskBarExit, onTaskNavigate: handleTaskNavigate })) }));
+            }, 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