@kenkaiiii/ggcoder 4.3.210 → 4.3.212

package/dist/ui/App.js

@@ -61,6 +61,7 @@ import { getMCPServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd, flushOverflow, } from "./live-item-flush.js";
 import { appendGoalDecision, appendGoalEvidence, formatGoalBlockingPrerequisites, goalHasBlockingPrerequisites, loadGoalRuns, reconcileActiveGoalRuns, summarizeGoalCounts, summarizeGoalCountsFromRuns, updateGoalTask, upsertGoalRun, } from "../core/goal-store.js";
 import { canCompleteGoalRun, decideGoalNextAction } from "../core/goal-controller.js";
+import { runGoalPrerequisiteChecks } from "../core/goal-prerequisites.js";
 import { runGoalVerifierCommand } from "../core/goal-verifier.js";
 import { listGoalWorkers, startGoalWorker, stopGoalWorker, subscribeGoalWorkerCompletions, } from "../core/goal-worker.js";
 import { formatGoalVerifierCompletionEvent, formatGoalWorkerCompletionEvent, isGoalSyntheticEvent, parseGoalSyntheticEvent, } from "./goal-events.js";
@@ -266,6 +267,16 @@ function goalProgressMatchesDraft(item, draft) {
         item.status === draft.status &&
         JSON.stringify(item.summaryRows ?? []) === JSON.stringify(draft.summaryRows ?? []));
 }
+/**
+ * Reconcile terminal Goal cards that are already visible in this UI session.
+ *
+ * This intentionally does not synthesize missing cards from durable GoalRun
+ * state. Goal terminal cards are event notifications: they should appear when
+ * the terminal event happens in the current UI, not whenever a fresh session
+ * polls old Goal runs from the Goal pane. Callers that just observed a terminal
+ * event append that card first, then use this helper to tombstone stale older
+ * cards for the same run.
+ */
 export function completedItemsWithDurableGoalTerminalProgress(items, runs) {
     const runIds = new Set(runs.map((run) => run.id));
     const terminalByRun = new Map(runs
@@ -273,29 +284,18 @@ export function completedItemsWithDurableGoalTerminalProgress(items, runs) {
         .filter((entry) => entry[1] !== null));
     if (runIds.size === 0)
         return items;
-    const upToDateRunIds = new Set();
     let changed = false;
     const reconciled = items.map((item, index) => {
         const runId = goalTerminalRunIdFromItem(item);
         if (!runId || !runIds.has(runId))
             return item;
         const draft = terminalByRun.get(runId);
-        if (draft && goalProgressMatchesDraft(item, draft)) {
-            upToDateRunIds.add(runId);
+        if (draft && goalProgressMatchesDraft(item, draft))
             return item;
-        }
         changed = true;
         return { kind: "tombstone", id: `tombstone-${item.id}-${index}` };
     });
-    const additions = [];
-    for (const [runId, progress] of terminalByRun) {
-        if (upToDateRunIds.has(runId))
-            continue;
-        additions.push({ ...progress, id: goalTerminalProgressId({ id: runId }) });
-    }
-    if (!changed && additions.length === 0)
-        return items;
-    return [...reconciled, ...additions];
+    return changed ? reconciled : items;
 }
 export function formatGoalTerminalProgress(run) {
     switch (run.status) {
@@ -344,17 +344,16 @@ export function formatGoalTerminalProgress(run) {
             return null;
     }
 }
-export function shouldHideHistoryForOverlayView(_isOverlayView, _isAgentRunning) {
-    // Ink Static is append-only. Passing [] for overlay panes rewrites the Static
-    // accumulator and can destroy scrollback when the pane closes. Keep history
-    // mounted and let overlays render below it.
-    return false;
+export function shouldHideHistoryForOverlayView(isOverlayView, _isAgentRunning) {
+    // Overlay panes are standalone full-screen states. Do not render chat Static
+    // history behind them, otherwise panes appear below the previous transcript.
+    return isOverlayView;
 }
 export function shouldStabilizeOverlayPaneRerender({ overlayPane, isAgentRunning, }) {
     return isAgentRunning && (overlayPane === "goal" || overlayPane === "plan");
 }
-export function shouldHideStaticItemsForOverlayView({ shouldHideHistoryForOverlay, stabilizeOverlayPaneRerender, }) {
-    return shouldHideHistoryForOverlay && !stabilizeOverlayPaneRerender;
+export function shouldHideStaticItemsForOverlayView({ shouldHideHistoryForOverlay, stabilizeOverlayPaneRerender: _stabilizeOverlayPaneRerender, }) {
+    return shouldHideHistoryForOverlay;
 }
 export function getScrollStabilizationDecision({ isUserScrolled, hasNewOutput, hasTallLiveUserMessage = false, }) {
     const shouldStabilize = isUserScrolled || hasTallLiveUserMessage;
@@ -2953,111 +2952,121 @@ export function App(props) {
     const startGoalRun = useCallback((run) => {
         runningGoalIdsRef.current.add(run.id);
         void (async () => {
-            if (goalHasBlockingPrerequisites(run)) {
+            const currentRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
+            const prereqCheck = await runGoalPrerequisiteChecks(props.cwd, currentRun);
+            const checkedRun = prereqCheck.checkedCount > 0
+                ? await upsertGoalRun(props.cwd, {
+                    ...prereqCheck.run,
+                    status: goalHasBlockingPrerequisites(prereqCheck.run) ? "blocked" : "ready",
+                })
+                : currentRun;
+            if (goalHasBlockingPrerequisites(checkedRun)) {
                 setOverlay(null);
-                const detail = formatGoalBlockingPrerequisites(run);
+                const detail = formatGoalBlockingPrerequisites(checkedRun);
                 await upsertGoalRun(props.cwd, {
-                    ...run,
+                    ...checkedRun,
                     status: "blocked",
-                    blockers: Array.from(new Set([...run.blockers, detail])),
+                    blockers: Array.from(new Set([...checkedRun.blockers, detail])),
                 });
                 setGoalCount((await summarizeGoalCounts(props.cwd)).active);
                 appendGoalProgress({
                     kind: "goal_progress",
                     phase: "terminal",
-                    title: `Goal blocked: ${run.title}`,
+                    title: `Goal blocked: ${checkedRun.title}`,
                     detail,
                     status: "blocked",
                 });
-                runningGoalIdsRef.current.delete(run.id);
-                clearGoalStatusEntry(run.id);
+                runningGoalIdsRef.current.delete(checkedRun.id);
+                clearGoalStatusEntry(checkedRun.id);
                 return;
             }
-            const decision = decideGoalNextAction(run);
-            await appendGoalDecision(props.cwd, run.id, decision);
+            const decision = decideGoalNextAction(checkedRun);
+            await appendGoalDecision(props.cwd, checkedRun.id, decision);
             if (decision.kind === "terminal") {
-                const terminalProgress = formatGoalTerminalProgress(run);
+                const terminalProgress = formatGoalTerminalProgress(checkedRun);
                 if (terminalProgress) {
-                    const item = { ...terminalProgress, id: goalTerminalProgressId(run) };
-                    setLiveItems((prev) => completedItemsWithDurableGoalTerminalProgress([...prev, item], [run]));
+                    const item = { ...terminalProgress, id: goalTerminalProgressId(checkedRun) };
+                    setLiveItems((prev) => completedItemsWithDurableGoalTerminalProgress([...prev, item], [checkedRun]));
                 }
-                runningGoalIdsRef.current.delete(run.id);
-                clearGoalStatusEntry(run.id);
+                runningGoalIdsRef.current.delete(checkedRun.id);
+                clearGoalStatusEntry(checkedRun.id);
                 return;
             }
             if (decision.kind === "wait") {
                 appendGoalProgress({
                     kind: "goal_progress",
                     phase: "worker_started",
-                    title: decision.workerId ? `Goal working: ${run.title}` : `Goal active: ${run.title}`,
+                    title: decision.workerId
+                        ? `Goal working: ${checkedRun.title}`
+                        : `Goal active: ${checkedRun.title}`,
                     detail: decision.reason,
                     workerId: decision.workerId,
                 });
                 upsertGoalStatusEntry({
-                    runId: run.id,
-                    label: run.title,
+                    runId: checkedRun.id,
+                    label: checkedRun.title,
                     phase: decision.workerId ? "worker" : "orchestrating",
                     startedAt: Date.now(),
                     detail: decision.reason,
                     workerId: decision.workerId,
-                    goalNumber: goalNumberForRun(run.id),
+                    goalNumber: goalNumberForRun(checkedRun.id),
                 });
                 return;
             }
             if (decision.kind === "complete") {
-                await upsertGoalRun(props.cwd, { ...run, status: "passed" });
+                await upsertGoalRun(props.cwd, { ...checkedRun, status: "passed" });
                 setGoalCount((await summarizeGoalCounts(props.cwd)).active);
                 appendGoalProgress({
                     kind: "goal_progress",
                     phase: "terminal",
-                    title: `Goal passed: ${run.title}`,
+                    title: `Goal passed: ${checkedRun.title}`,
                     detail: decision.reason,
                     status: "passed",
                 });
-                runningGoalIdsRef.current.delete(run.id);
-                clearGoalStatusEntry(run.id);
+                runningGoalIdsRef.current.delete(checkedRun.id);
+                clearGoalStatusEntry(checkedRun.id);
                 return;
             }
             if (decision.kind === "run_verifier") {
-                await verifyGoalRun(run);
+                await verifyGoalRun(checkedRun);
                 return;
             }
             if (decision.kind === "create_task") {
-                await updateGoalTask(props.cwd, run.id, `auto-${Date.now()}`, {
+                await updateGoalTask(props.cwd, checkedRun.id, `auto-${Date.now()}`, {
                     title: decision.title,
                     prompt: decision.prompt,
                     status: "pending",
                 });
-                const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
+                const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === checkedRun.id) ?? checkedRun;
                 await upsertGoalRun(props.cwd, { ...latestRun, status: "ready" });
-                setTimeout(() => continueGoalRun(run.id), 250);
+                setTimeout(() => continueGoalRun(checkedRun.id), 250);
                 return;
             }
             if (decision.kind === "blocked") {
                 await upsertGoalRun(props.cwd, {
-                    ...run,
+                    ...checkedRun,
                     status: "blocked",
-                    blockers: [...run.blockers, decision.reason],
+                    blockers: [...checkedRun.blockers, decision.reason],
                 });
                 setGoalCount((await summarizeGoalCounts(props.cwd)).active);
                 appendGoalProgress({
                     kind: "goal_progress",
                     phase: "terminal",
-                    title: `Goal blocked: ${run.title}`,
+                    title: `Goal blocked: ${checkedRun.title}`,
                     detail: decision.reason,
                     status: "blocked",
                 });
-                runningGoalIdsRef.current.delete(run.id);
-                clearGoalStatusEntry(run.id);
+                runningGoalIdsRef.current.delete(checkedRun.id);
+                clearGoalStatusEntry(checkedRun.id);
                 return;
             }
             if (decision.kind === "pause") {
-                const runWithBlockedTask = (await updateGoalTask(props.cwd, run.id, decision.task.id, {
+                const runWithBlockedTask = (await updateGoalTask(props.cwd, checkedRun.id, decision.task.id, {
                     status: "blocked",
                     attempts: decision.attempts,
                     lastSummary: "Paused after worker attempt limit.",
-                })) ?? run;
-                const runWithPauseEvidence = (await appendGoalEvidence(props.cwd, run.id, {
+                })) ?? checkedRun;
+                const runWithPauseEvidence = (await appendGoalEvidence(props.cwd, checkedRun.id, {
                     kind: "summary",
                     label: "Goal paused",
                     content: decision.reason,
@@ -3072,27 +3081,28 @@ export function App(props) {
                 appendGoalProgress({
                     kind: "goal_progress",
                     phase: "terminal",
-                    title: `Goal paused: ${run.title}`,
+                    title: `Goal paused: ${checkedRun.title}`,
                     detail: decision.reason,
                     status: "paused",
                 });
-                runningGoalIdsRef.current.delete(run.id);
-                clearGoalStatusEntry(run.id);
+                runningGoalIdsRef.current.delete(checkedRun.id);
+                clearGoalStatusEntry(checkedRun.id);
                 return;
             }
-            const runWithAttempt = (await updateGoalTask(props.cwd, run.id, decision.task.id, {
+            const runWithAttempt = (await updateGoalTask(props.cwd, checkedRun.id, decision.task.id, {
                 attempts: decision.attempts,
-            })) ?? run;
+            })) ?? checkedRun;
             const worker = await startGoalWorker({
                 cwd: props.cwd,
                 provider: currentProvider,
                 model: currentModel,
-                goalRunId: run.id,
+                goalRunId: checkedRun.id,
                 goalTaskId: decision.task.id,
                 taskTitle: decision.task.title,
                 prompt: decision.task.prompt,
             });
-            const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? runWithAttempt;
+            const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === checkedRun.id) ??
+                runWithAttempt;
             await upsertGoalRun(props.cwd, {
                 ...latestRun,
                 status: "running",
@@ -3113,13 +3123,13 @@ export function App(props) {
                 status: worker.status,
             });
             upsertGoalStatusEntry({
-                runId: run.id,
+                runId: checkedRun.id,
                 label: decision.task.title,
                 phase: "worker",
                 startedAt: Date.now(),
                 detail: "background worker running",
                 workerId: worker.id,
-                goalNumber: goalNumberForRun(run.id),
+                goalNumber: goalNumberForRun(checkedRun.id),
             });
         })().catch((err) => {
             clearGoalStatusEntry(run.id);