@kenkaiiii/ggcoder 4.3.208 → 4.3.210

package/dist/ui/App.js

@@ -59,8 +59,9 @@ import { getLatestUserText, injectRepoMapContextMessages, stripRepoMapContextMes
 import { extractPlanSteps, findCompletedMarkers, markStepsCompleted, segmentDisplayText, stripDoneMarkers, } from "../utils/plan-steps.js";
 import { getMCPServers } from "../core/mcp/index.js";
 import { trimFlushedItems, flushOnTurnText, flushOnTurnEnd, flushOverflow, } from "./live-item-flush.js";
-import { appendGoalDecision, appendGoalEvidence, formatGoalBlockingPrerequisites, goalHasBlockingPrerequisites, loadGoalRuns, reconcileActiveGoalRuns, projectDir, summarizeGoalCounts, summarizeGoalCountsFromRuns, updateGoalTask, upsertGoalRun, } from "../core/goal-store.js";
-import { canCompleteGoalRun, decideGoalNextAction, shouldCreateVerifierFixTask, } from "../core/goal-controller.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 { runGoalVerifierCommand } from "../core/goal-verifier.js";
 import { listGoalWorkers, startGoalWorker, stopGoalWorker, subscribeGoalWorkerCompletions, } from "../core/goal-worker.js";
 import { formatGoalVerifierCompletionEvent, formatGoalWorkerCompletionEvent, isGoalSyntheticEvent, parseGoalSyntheticEvent, } from "./goal-events.js";
 /** Where ggcoder bugs should be reported. Surfaced in the guidance line. */
@@ -189,9 +190,7 @@ function summarizeGoalCompletion(summary) {
     return statusLine ?? changedLine ?? verificationLine ?? lines[0];
 }
 function formatGoalWorkerFinishedTitle(taskTitle, status) {
-    return status === "done"
-        ? `Worker finished: ${taskTitle}. Reporting back.`
-        : `Worker failed: ${taskTitle}. Reporting back.`;
+    return status === "done" ? `Done: ${taskTitle}` : `Failed: ${taskTitle}`;
 }
 function countGoalTasksByStatus(tasks, status) {
     return tasks.filter((task) => task.status === status).length;
@@ -251,6 +250,53 @@ export function buildGoalSummaryRows(run) {
     }
     return rows.slice(0, 4);
 }
+function goalTerminalProgressId(run) {
+    return `goal-terminal-${run.id}`;
+}
+function goalTerminalRunIdFromItem(item) {
+    if (item.kind !== "goal_progress" || item.phase !== "terminal")
+        return undefined;
+    if (!item.id.startsWith("goal-terminal-"))
+        return undefined;
+    return item.id.slice("goal-terminal-".length);
+}
+function goalProgressMatchesDraft(item, draft) {
+    return (item.title === draft.title &&
+        item.detail === draft.detail &&
+        item.status === draft.status &&
+        JSON.stringify(item.summaryRows ?? []) === JSON.stringify(draft.summaryRows ?? []));
+}
+export function completedItemsWithDurableGoalTerminalProgress(items, runs) {
+    const runIds = new Set(runs.map((run) => run.id));
+    const terminalByRun = new Map(runs
+        .map((run) => [run.id, formatGoalTerminalProgress(run)])
+        .filter((entry) => entry[1] !== null));
+    if (runIds.size === 0)
+        return items;
+    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);
+            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];
+}
 export function formatGoalTerminalProgress(run) {
     switch (run.status) {
         case "passed":
@@ -325,10 +371,11 @@ export function getStaticHistoryKey({ resizeKey }) {
 }
 // flushOnTurnText, flushOnTurnEnd are imported from ./live-item-flush.ts
 /** Check whether an item is still active (running spinner, pending result). */
-function isActiveItem(item) {
+export function isActiveItem(item) {
     switch (item.kind) {
         case "tool_start":
         case "server_tool_start":
+        case "queued":
         case "compacting":
             return true;
         case "tool_group":
@@ -727,6 +774,7 @@ export function App(props) {
                 if (cancelled)
                     return;
                 setGoalCount(counts.active);
+                setHistory((prev) => completedItemsWithDurableGoalTerminalProgress(prev, runs));
                 setGoalStatusEntries((prev) => {
                     const next = reconcileGoalStatusEntriesWithRuns(prev, runs, {
                         isWorkerActive: (workerId, run) => listGoalWorkers(props.cwd).some((worker) => worker.id === workerId &&
@@ -2530,11 +2578,23 @@ export function App(props) {
                 return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.success, bold: true, children: "▶ " }), _jsx(Text, { color: theme.textDim, children: "Goal: " }), _jsx(Text, { color: theme.success, children: item.title }), item.workerId ? _jsxs(Text, { color: theme.textDim, children: [" \u00B7 worker ", item.workerId] }) : null] }) }, item.id));
             case "goal_progress": {
                 const isError = item.status === "failed" || item.status === "fail" || item.status === "blocked";
-                const color = item.phase === "terminal" && !isError
-                    ? theme.success
-                    : isError
-                        ? theme.warning
-                        : theme.primary;
+                const color = isError
+                    ? theme.error
+                    : item.phase === "worker_finished"
+                        ? theme.success
+                        : item.phase === "verifier_finished"
+                            ? theme.accent
+                            : item.phase === "orchestrator_reviewing" || item.phase === "orchestrator_working"
+                                ? theme.secondary
+                                : item.phase === "continuing"
+                                    ? theme.warning
+                                    : item.phase === "verifier_started"
+                                        ? theme.accent
+                                        : item.phase === "worker_started"
+                                            ? theme.primary
+                                            : item.phase === "terminal"
+                                                ? theme.success
+                                                : theme.primary;
                 const glyph = item.phase === "worker_finished" || item.phase === "verifier_finished"
                     ? "✓ "
                     : item.phase === "terminal"
@@ -2604,7 +2664,7 @@ export function App(props) {
             case "step_done":
                 return (_jsx(Box, { marginTop: 1, flexShrink: 1, children: _jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { color: theme.success, bold: true, children: "✓ " }), _jsx(Text, { color: theme.success, bold: true, children: `Step ${item.stepNum} done` }), item.description ? (_jsx(Text, { color: theme.textDim, children: ` — ${item.description}` })) : null] }) }, item.id));
             case "queued":
-                return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: "⏳ Queued: " }), _jsxs(Text, { color: theme.text, wrap: "wrap", children: [item.text, item.imageCount
+                return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.warning, bold: true, children: "• " }), _jsx(Text, { color: theme.textDim, children: "Queued: " }), _jsxs(Text, { color: theme.text, wrap: "wrap", children: [item.text, item.imageCount
                                     ? ` (+${item.imageCount} image${item.imageCount > 1 ? "s" : ""})`
                                     : ""] })] }, item.id));
             case "compacting":
@@ -2791,8 +2851,10 @@ export function App(props) {
                     content: `terminal=${status}`,
                 });
                 const terminalProgress = formatGoalTerminalProgress(nextRun);
-                if (terminalProgress)
-                    appendGoalProgress(terminalProgress);
+                if (terminalProgress) {
+                    const item = { ...terminalProgress, id: goalTerminalProgressId(nextRun) };
+                    setLiveItems((prev) => completedItemsWithDurableGoalTerminalProgress([...prev, item], [nextRun]));
+                }
                 runningGoalIdsRef.current.delete(runId);
                 clearGoalStatusEntry(runId);
                 return;
@@ -2813,8 +2875,8 @@ export function App(props) {
             appendGoalProgress({
                 kind: "goal_progress",
                 phase: "continuing",
-                title: `Continuing Goal: ${latestRun.title}`,
-                detail: "Starting the next worker task or verifier step automatically.",
+                title: `Choosing next Goal step: ${latestRun.title}`,
+                detail: "Latest result is recorded; starting the next worker task or verifier automatically.",
                 status: latestRun.status,
             });
             upsertGoalStatusEntry({
@@ -2915,8 +2977,10 @@ export function App(props) {
             await appendGoalDecision(props.cwd, run.id, decision);
             if (decision.kind === "terminal") {
                 const terminalProgress = formatGoalTerminalProgress(run);
-                if (terminalProgress)
-                    appendGoalProgress(terminalProgress);
+                if (terminalProgress) {
+                    const item = { ...terminalProgress, id: goalTerminalProgressId(run) };
+                    setLiveItems((prev) => completedItemsWithDurableGoalTerminalProgress([...prev, item], [run]));
+                }
                 runningGoalIdsRef.current.delete(run.id);
                 clearGoalStatusEntry(run.id);
                 return;
@@ -2988,20 +3052,21 @@ export function App(props) {
                 return;
             }
             if (decision.kind === "pause") {
-                await updateGoalTask(props.cwd, run.id, decision.task.id, {
+                const runWithBlockedTask = (await updateGoalTask(props.cwd, run.id, decision.task.id, {
                     status: "blocked",
                     attempts: decision.attempts,
                     lastSummary: "Paused after worker attempt limit.",
-                });
-                await upsertGoalRun(props.cwd, {
-                    ...run,
-                    status: "paused",
-                    blockers: [...run.blockers, decision.reason],
-                });
-                await appendGoalEvidence(props.cwd, run.id, {
+                })) ?? run;
+                const runWithPauseEvidence = (await appendGoalEvidence(props.cwd, run.id, {
                     kind: "summary",
                     label: "Goal paused",
                     content: decision.reason,
+                })) ?? runWithBlockedTask;
+                await upsertGoalRun(props.cwd, {
+                    ...runWithPauseEvidence,
+                    status: "paused",
+                    continueRequestedAt: undefined,
+                    blockers: Array.from(new Set([...runWithPauseEvidence.blockers, decision.reason])),
                 });
                 setGoalCount((await summarizeGoalCounts(props.cwd)).active);
                 appendGoalProgress({
@@ -3015,7 +3080,9 @@ export function App(props) {
                 clearGoalStatusEntry(run.id);
                 return;
             }
-            await updateGoalTask(props.cwd, run.id, decision.task.id, { attempts: decision.attempts });
+            const runWithAttempt = (await updateGoalTask(props.cwd, run.id, decision.task.id, {
+                attempts: decision.attempts,
+            })) ?? run;
             const worker = await startGoalWorker({
                 cwd: props.cwd,
                 provider: currentProvider,
@@ -3025,11 +3092,15 @@ export function App(props) {
                 taskTitle: decision.task.title,
                 prompt: decision.task.prompt,
             });
+            const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? runWithAttempt;
             await upsertGoalRun(props.cwd, {
-                ...run,
+                ...latestRun,
                 status: "running",
                 activeWorkerId: worker.id,
                 continueRequestedAt: undefined,
+                tasks: latestRun.tasks.map((item) => item.id === decision.task.id
+                    ? { ...item, status: "running", workerId: worker.id, attempts: decision.attempts }
+                    : item),
             });
             setOverlay(null);
             setGoalCount((await summarizeGoalCounts(props.cwd)).active);
@@ -3110,143 +3181,74 @@ export function App(props) {
             detail: run.verifier.command,
             goalNumber: goalNumberForRun(run.id),
         });
-        const { spawn } = await import("node:child_process");
-        const { mkdir, writeFile } = await import("node:fs/promises");
-        const { join } = await import("node:path");
-        const logDir = join(projectDir(props.cwd), "verifiers");
-        await mkdir(logDir, { recursive: true });
-        const outputPath = join(logDir, `${run.id}-${startedAt}.log`);
-        const child = spawn(run.verifier.command, {
+        void runGoalVerifierCommand({
             cwd: props.cwd,
-            shell: true,
-            stdio: ["ignore", "pipe", "pipe"],
-            env: { ...process.env },
-        });
-        let output = "";
-        child.stdout?.on("data", (chunk) => {
-            output += chunk.toString("utf-8");
-            if (output.length > 20_000)
-                output = output.slice(output.length - 20_000);
-        });
-        child.stderr?.on("data", (chunk) => {
-            output += chunk.toString("utf-8");
-            if (output.length > 20_000)
-                output = output.slice(output.length - 20_000);
-        });
-        let verifierSettled = false;
-        let timedOut = false;
-        const timeout = verifierTimeoutMs > 0
-            ? setTimeout(() => {
-                timedOut = true;
-                if (child.pid)
-                    child.kill("SIGTERM");
-                const killTimer = setTimeout(() => {
-                    if (!verifierSettled && child.pid)
-                        child.kill("SIGKILL");
-                }, 5000);
-                killTimer.unref?.();
-                finishVerifier(124, `Verifier timed out after ${verifierTimeoutMs}ms and was terminated.\n${output}`);
-            }, verifierTimeoutMs)
-            : undefined;
-        timeout?.unref?.();
-        const finishVerifier = (code, forcedOutput) => {
-            if (verifierSettled)
-                return;
-            verifierSettled = true;
-            if (timeout)
-                clearTimeout(timeout);
+            runId: run.id,
+            command: run.verifier.command,
+            timeoutMs: verifierTimeoutMs,
+            now: () => startedAt,
+        })
+            .then(async ({ verification, failureClass, durationMs }) => {
             activeVerifierRunIdsRef.current.delete(run.id);
-            void (async () => {
-                const status = code === 0 ? "pass" : "fail";
-                const failureClass = timedOut
-                    ? "verifier_timeout"
-                    : forcedOutput?.startsWith("Verifier process error:")
-                        ? "verifier_spawn_error"
-                        : status === "fail"
-                            ? "verifier_failure"
-                            : "verifier_pass";
-                const summary = (forcedOutput ?? output).trim() ||
-                    (code === 0 ? "Verifier passed." : "Verifier failed.");
-                const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
-                await writeFile(outputPath, summary + "\n", "utf-8");
-                const runWithVerifier = {
-                    ...latestRun,
-                    verifier: {
-                        ...latestRun.verifier,
-                        description: latestRun.verifier?.description ?? "Goal verifier",
-                        command: run.verifier?.command,
-                        lastResult: {
-                            status,
-                            summary,
-                            command: run.verifier?.command,
-                            exitCode: code ?? 1,
-                            outputPath,
-                            checkedAt: new Date().toISOString(),
-                        },
-                    },
-                };
-                const completionCheck = canCompleteGoalRun(runWithVerifier);
-                const verifiedRun = await upsertGoalRun(props.cwd, {
-                    ...runWithVerifier,
-                    continueRequestedAt: undefined,
-                    status: status === "pass" && completionCheck.ok
-                        ? "passed"
-                        : status === "pass"
-                            ? "ready"
-                            : "failed",
-                });
-                await appendGoalEvidence(props.cwd, run.id, {
-                    kind: "command",
-                    label: `Verifier ${status}`,
-                    content: `${failureClass}: ${summary}`.slice(0, 4000),
-                    path: outputPath,
-                });
-                await appendGoalDecision(props.cwd, run.id, {
-                    kind: `verifier_${status}`,
-                    reason: `${failureClass}: verifier exited with code ${code ?? 1}.`,
-                    content: `outputPath=${outputPath}; durationMs=${Date.now() - startedAt}`,
-                });
-                if (status === "fail" && shouldCreateVerifierFixTask(latestRun)) {
-                    await updateGoalTask(props.cwd, run.id, `fix-${Date.now()}`, {
-                        title: "Fix verifier failure",
-                        prompt: `Goal verifier failed after ${Date.now() - startedAt}ms. Original goal: ${run.goal}\n\n` +
-                            `Verifier command: ${run.verifier?.command}\n\n` +
-                            `Failure output:\n${summary.slice(-6000)}\n\nFix the cause, record evidence with the goals tool, and rerun relevant verification.`,
-                        status: "pending",
-                    });
-                    const runWithPendingFix = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? latestRun;
-                    await upsertGoalRun(props.cwd, { ...runWithPendingFix, status: "ready" });
-                }
-                setGoalCount((await summarizeGoalCounts(props.cwd)).active);
-                appendGoalProgress({
-                    kind: "goal_progress",
-                    phase: "verifier_finished",
-                    title: `Verifier ${status}: ${run.title}`,
-                    detail: summarizeGoalCompletion(summary),
-                    status,
-                });
-                upsertGoalStatusEntry({
-                    runId: run.id,
-                    label: run.title,
-                    phase: status === "pass" ? "reviewing" : "failed",
-                    startedAt: Date.now(),
-                    detail: status === "pass" ? "reviewing verifier evidence" : "verifier failed",
-                    goalNumber: goalNumberForRun(run.id),
-                });
-                const eventText = formatGoalVerifierCompletionEvent(verifiedRun, status, run.verifier?.command ?? "", code ?? 1, summary);
-                runGoalSyntheticEvent(eventText);
-                const continuationRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id);
-                if (continuationRun?.continueRequestedAt && status === "pass") {
-                    setTimeout(() => continueGoalRun(run.id), 500);
-                }
-            })().catch((err) => {
-                clearGoalStatusEntry(run.id);
-                log("ERROR", "goal", err instanceof Error ? err.message : String(err));
-                setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal verifier")]);
+            const status = verification.status;
+            const summary = verification.summary;
+            const outputPath = verification.outputPath;
+            const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
+            const runWithVerifier = {
+                ...latestRun,
+                verifier: {
+                    ...latestRun.verifier,
+                    description: latestRun.verifier?.description ?? "Goal verifier",
+                    command: run.verifier?.command,
+                    lastResult: verification,
+                },
+            };
+            const completionCheck = canCompleteGoalRun(runWithVerifier);
+            const verifiedRun = await upsertGoalRun(props.cwd, {
+                ...runWithVerifier,
+                continueRequestedAt: status === "pass" && completionCheck.ok ? undefined : latestRun.continueRequestedAt,
+                status: status === "pass" && completionCheck.ok ? "passed" : "ready",
             });
-        };
-        child.on("close", (code) => finishVerifier(code));
-        child.on("error", (err) => finishVerifier(1, `Verifier process error: ${err.message}`));
+            await appendGoalEvidence(props.cwd, run.id, {
+                kind: "command",
+                label: `Verifier ${status}`,
+                content: `${failureClass}: ${summary}`.slice(0, 4000),
+                path: outputPath,
+            });
+            await appendGoalDecision(props.cwd, run.id, {
+                kind: `verifier_${status}`,
+                reason: `${failureClass}: verifier exited with code ${verification.exitCode ?? 1}.`,
+                content: `outputPath=${outputPath ?? ""}; durationMs=${durationMs}`,
+            });
+            setGoalCount((await summarizeGoalCounts(props.cwd)).active);
+            appendGoalProgress({
+                kind: "goal_progress",
+                phase: "verifier_finished",
+                title: `Verifier ${status}: ${run.title}`,
+                detail: summarizeGoalCompletion(summary),
+                status,
+            });
+            upsertGoalStatusEntry({
+                runId: run.id,
+                label: run.title,
+                phase: status === "pass" ? "reviewing" : "failed",
+                startedAt: Date.now(),
+                detail: status === "pass" ? "reviewing verifier evidence" : "verifier failed",
+                goalNumber: goalNumberForRun(run.id),
+            });
+            const eventText = formatGoalVerifierCompletionEvent(verifiedRun, status === "pass" ? "pass" : "fail", run.verifier?.command ?? "", verification.exitCode ?? 1, summary);
+            runGoalSyntheticEvent(eventText);
+            const continuationRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id);
+            if (continuationRun?.continueRequestedAt || status === "fail") {
+                setTimeout(() => continueGoalRun(run.id), 500);
+            }
+        })
+            .catch((err) => {
+            activeVerifierRunIdsRef.current.delete(run.id);
+            clearGoalStatusEntry(run.id);
+            log("ERROR", "goal", err instanceof Error ? err.message : String(err));
+            setLiveItems((prev) => [...prev, toErrorItem(err, getId(), "Goal verifier")]);
+        });
     }, [
         props.cwd,
         appendGoalProgress,
@@ -3260,7 +3262,12 @@ export function App(props) {
             runningGoalIdsRef.current.delete(run.id);
             if (run.activeWorkerId)
                 await stopGoalWorker(run.activeWorkerId);
-            await upsertGoalRun(props.cwd, { ...run, status: "paused", activeWorkerId: undefined });
+            const latestRun = (await loadGoalRuns(props.cwd)).find((item) => item.id === run.id) ?? run;
+            await upsertGoalRun(props.cwd, {
+                ...latestRun,
+                status: "paused",
+                activeWorkerId: undefined,
+            });
             setGoalCount((await summarizeGoalCounts(props.cwd)).active);
             appendGoalProgress({
                 kind: "goal_progress",
@@ -3610,7 +3617,7 @@ export function App(props) {
                         setLiveItems((prev) => [...prev, toErrorItem(err, getId())]);
                     });
                 } })) : (_jsxs(_Fragment, { children: [_jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingRight: 1, children: [liveItems.map((item) => renderItem(item)), _jsx(StreamingArea, { isRunning: agentLoop.isRunning, streamingText: agentLoop.streamingText, streamingThinking: agentLoop.streamingThinking, thinkingMs: agentLoop.thinkingMs, planMode: planMode })] }), agentLoop.isRunning && agentLoop.activityPhase !== "idle" ? (_jsx(Box, { marginTop: 1, borderStyle: "round", borderColor: agentLoop.activityPhase === "thinking" ? THINKING_BORDER_COLORS[0] : "transparent", paddingLeft: 1, paddingRight: 1, width: columns, children: _jsx(ActivityIndicator, { phase: agentLoop.activityPhase, elapsedMs: agentLoop.elapsedMs, runStartRef: agentLoop.runStartRef, thinkingMs: agentLoop.thinkingMs, isThinking: agentLoop.isThinking, thinkingEnabled: thinkingEnabled, tokenEstimate: agentLoop.streamedTokenEstimate, charCountRef: agentLoop.charCountRef, realTokensAccumRef: agentLoop.realTokensAccumRef, userMessage: lastUserMessage, activeToolNames: agentLoop.activeToolCalls.map((tc) => tc.name), planMode: planMode, retryInfo: agentLoop.retryInfo, planDone: planSteps.filter((s) => s.completed).length, planTotal: planSteps.length, staticDisplay: true }) })) : agentLoop.stallError ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: theme.warning, children: "⚠ API provider stream interrupted — retries exhausted." }), _jsx(Text, { color: theme.textDim, children: "  Your conversation is preserved. Send a message to continue." })] })) : (doneStatus &&
-                        !agentLoop.isRunning && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.success, children: ["✻ ", doneStatus.verb, " ", formatDuration(doneStatus.durationMs)] }) }))), agentLoop.queuedCount > 0 && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.accent, children: ["⏳ ", agentLoop.queuedCount, " message", agentLoop.queuedCount > 1 ? "s" : "", " queued"] }) })), _jsx(InputArea, { onSubmit: handleSubmit, onAbort: handleAbort, disabled: agentLoop.isRunning, isActive: !taskBarFocused && !overlay, onDownAtEnd: handleFocusTaskBar, onShiftTab: handleToggleThinking, onToggleTasks: () => {
+                        !agentLoop.isRunning && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.success, children: ["✻ ", doneStatus.verb, " ", formatDuration(doneStatus.durationMs)] }) }))), agentLoop.queuedCount > 0 && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.warning, bold: true, children: "• " }), _jsxs(Text, { color: theme.textDim, children: [agentLoop.queuedCount, " message", agentLoop.queuedCount > 1 ? "s" : "", " queued"] })] })), _jsx(InputArea, { onSubmit: handleSubmit, onAbort: handleAbort, disabled: agentLoop.isRunning, isActive: !taskBarFocused && !overlay, onDownAtEnd: handleFocusTaskBar, onShiftTab: handleToggleThinking, onToggleTasks: () => {
                             // Just flip the overlay state — Ink's log-update handles the
                             // live-area transition (chat input → TaskOverlay) natively, and
                             // the chat history above stays in scrollback. When the overlay