@pentoshi/clai 3.18.2 → 4.0.1

package/dist/agent/runner.js

@@ -6,12 +6,12 @@ import { streamAlreadyEmitted } from "../llm/stream-progress.js";
 import { classifyStreamFailure, planStreamRecovery, recordRecoveryAttempt, createStreamRecoveryState, resetStreamRecoveryState, } from "./stream-recovery.js";
 import { modelSupportsVision, resolveToolDialect } from "../llm/capabilities.js";
 import { syntheticToolCallId, isTextOnlyModel, markTextOnlyModel, fromWireName, } from "../llm/tool-protocol.js";
-import { sanitizeAssistantText } from "../ui/ansi-box.js";
+import { sanitizeDisplayText as sanitizeAssistantText } from "../ui-core/rendering/sanitize-display.js";
 import { createHash, randomUUID } from "node:crypto";
 import { jobManager, } from "../tools/jobs.js";
 import { isResponderResultLedgerMessage, responderContextMessage, upsertResponderContextMessage, upsertResponderResultLedger, } from "./responder-context.js";
 import { agentModeDirective, planModeDirective, renderAgentSystemPrompt, renderCompactAgentSystemPrompt, renderRequestEnvironmentContext, scratchDirFor, toolNudge, } from "../prompts/index.js";
-import { getConfig } from "../store/config.js";
+import { getConfig, getProviderModel } from "../store/config.js";
 import { beginSessionWorkspace, getActiveSessionWorkspace, } from "../store/session-workspace.js";
 import { groqInputTokenBudget } from "../llm/groq.js";
 import { classifyToolCall, isPentestToolCall, scopeTargetForToolCall, } from "../safety/classifier.js";
@@ -41,7 +41,6 @@ import { availableToolNames, normalizeToolCall, runToolCall, BATCH_SAFE_TOOLS, }
 import { getToolDefinitions, getCompactToolDefinitions, RUNNER_META_TOOL_NAMES, } from "../tools/definitions.js";
 import { elidedStubReuseMessage, findElidedStubArg, } from "./message-slim.js";
 import { appendAssistantWithTools, ensureUniqueToolCallIds, toolCallIdsInHistory, appendToolResult, assertValidToolProtocol, fillMissingToolResults, repairToolProtocol, } from "./tool-history.js";
-import { formatViewportHint, registerViewport } from "../ui/output-pane.js";
 import { compactMessagesWithSummary, shouldApplyAutoCompact, COMPACTION_MEMORY_PREFIX, PLAN_IMPLEMENT_MEMORY_PREFIX, isCompactionMemoryMessage, } from "./context-manager.js";
 import { buildContextBreakdown, contextBreakdownAuditPayload, describeDominantContextBlock, toolSchemaHash, } from "./context-breakdown.js";
 import { autoCompactTriggerTokens, dedupeToolContextOutput, freeTierGuardNotices, getReliabilityPolicy, resolveStepMaxTokens, } from "./reliability-policy.js";
@@ -49,10 +48,8 @@ import { auditLog } from "../store/logs.js";
 import { loadProjectContext } from "../store/project.js";
 import { loadScope, isScopeActive } from "../store/scope.js";
 import { ensureProviderConfigured } from "../commands/providers.js";
-import { createThinkingStreamParser, rememberThinkingFromText, renderThinkingSummary, stripThinking, } from "../ui/thinking.js";
-import { hasReasoningMarker, REASONING_CLOSE, REASONING_OPEN, stripReasoningMarkers, } from "../llm/reasoning-marker.js";
-import { renderMarkdown, indentAndWrapText } from "../ui/markdown.js";
-import { startThinkingSpinner } from "../ui/spinner.js";
+import { createThinkingStreamParser, rememberThinkingFromText, stripThinking, } from "../ui/thinking.js";
+import { hasReasoningMarker, REASONING_CLOSE, REASONING_OPEN, } from "../llm/reasoning-marker.js";
 import { safeCwd } from "../os/cwd.js";
 import { analyzeTask, formatTaskAnalysisHint, isNarrowExplicitNmapOperation, } from "./task-analyzer.js";
 import { computeMaxIterations, computeStepBudget } from "./step-budget.js";
@@ -68,9 +65,9 @@ import { stat } from "node:fs/promises";
 import { isOutsideWorkingDirectory, resolveFsToolPath, } from "../tools/fs.js";
 import { stripSentinelTokens, parseToolCall, recognizeBareToolJson, looksLikeTruncatedToolCall, salvageTruncatedWrite, salvageTruncatedWriteFromNative, countToolFences, parseAllToolCalls, groupToolCallsForExecution, buildTurnHistory, collapseRepeatedText, textBeforeToolCall, formatToolArgs, looksLikePentestTask, looksLikeBuildTask, looksLikeInformationalQuery, looksLikeIdleOrSocialPrompt, looksLikeActionNarration, looksLikeWebActionNarration, localHttpProbeIsFailure, localHttpProbeIsSuccess, buildWorkflowDirective, narrowNmapOperationDirective, pentestWorkflowDirective, pentestNoLocalServerDirective, shouldDimToolChatter, looksLikePromptLeak, } from "./tool-call-parser.js";
 import { createSessionPolicy, isPreApprovalAllowedTool, isPlanModeAllowedShellCommand, isPlanModeAllowedTool, isPlanApprovedByStatus, planHasOpenWork, isAbortError, shouldEnableImageOcr, } from "./session-policy.js";
-import { saveToolOutput, summarizeOutput, formatToolContext, } from "./tool-output-formatting.js";
-import { codingSessionFromContext, isProtocolPlaceholderOutput, progressPauseMode, } from "./progress-pause-policy.js";
-import { renderPlanForTerminal, planContextMessage, removePlanContextMessage, upsertPlanContextMessage, handlePlanTool, resolvePlanTaskId, } from "./plan-tool.js";
+import { saveToolOutput, formatToolContext, } from "./tool-output-formatting.js";
+import { codingSessionFromContext, isProtocolPlaceholderOutput, } from "./progress-pause-policy.js";
+import { planContextMessage, removePlanContextMessage, upsertPlanContextMessage, handlePlanTool, resolvePlanTaskId, } from "./plan-tool.js";
 import { readDeclaredParentTaskId, resolveResponderParent, isExplicitResponderDelegation, delegationTaskTitle, } from "./responder-parent.js";
 import { readTaskUpdateArgs, distinctAdvancingTaskIds, isSimultaneousTaskAdvance, batchUpdateSignature, buildMultiUpdateReminder, buildMultiOpenRejection, multiUpdateToast, multiOpenToast, openingTaskIds, } from "./task-sync.js";
 import { absorbLooseWorkIntoLedger, applyDestinationCwd, canMarkTaskDone, hasLocalRuntimeProof, hasRemoteWorkProof, isDevServerCall, isEvidenceWorkTool, isFeatureImplementationCall, isPackageInstallCommand, isPlanPreflightTool, isPortListeningOutput, isReadOnlyReconTool, isRemoteActiveTestCall, isRemoteReconToolCall, isScaffoldCreateCommand, isServerReadyOutput, ledgerFromTaskEvidence, pickPendingTaskForToolCall, recordTaskWorkSuccess, resolveUserDestinationHint, taskEvidenceFromLedger, TOOL_ABORT_GRACE_MS, toolHardBudgetMs, toolStallBudgetMs, userAskedForFeatureApp, } from "./task-evidence.js";
@@ -84,7 +81,7 @@ import { EngagementPolicyEngine, actionFromUrl, engagementActionsForToolCall, ev
 import { patchPlanMeta } from "../store/plan.js";
 import { extractProjectRootFromPlan, extractProjectRootFromScaffold, extractProjectRootFromText, getActiveProjectRoot, setActiveProjectRootIfValid, } from "./project-root.js";
 import { buildWorkspaceOrientation, discoverImmediateProjectRoots, guessProjectFolderName, isBareParentDirectory, isScaffoldCancelledOutput, scaffoldLooksMaterialized, scaffoldTargetConflictMessage, resolveScaffoldTargetPath, } from "./workspace-orient.js";
-import { inquirerConfirmPort, inquirerSecretRequester, restoreInteractiveStdin, ensurePentestAuthorization, confirmToolExecution, } from "./confirm-port.js";
+import { stdioConfirmPort, stdioSecretRequester, restoreInteractiveStdin, ensurePentestAuthorization, confirmToolExecution, } from "./confirm-port.js";
 import { buildRichStopSummary } from "./stop-summary.js";
 import { composeAgentSystemPrompt } from "./prompt-composer.js";
 import { createGovernorState, governProgress, } from "./evidence-governor.js";
@@ -205,14 +202,8 @@ export async function runAgentTurn(prompt, options = {}) {
         }
         return matched >= minLength ? current.slice(matched) : current;
     };
-    const noopSpinner = {
-        setLabel: () => { },
-        bumpReasoning: () => { },
-        pushPreview: () => { },
-        stop: () => { },
-    };
-    const writeStatus = (text, rendered = chalk.dim(text)) => {
-        // Footer activity is single-line; strip classic stdout newlines/indents.
+    const writeStatus = (text) => {
+        // Footer activity is single-line; collapse newlines and indents.
         // Never surface /output path hints as activity (garbles the status bar).
         let cleaned = text.replace(/\s+/g, " ").trim();
         if (/\/output\b|open full output|Ctrl\+O or|\.clai\/outputs/i.test(cleaned)) {
@@ -231,41 +222,29 @@ export async function runAgentTurn(prompt, options = {}) {
             }
         }
         emit({ type: "status", text: cleaned || "working" });
-        if (writesDirectly)
-            process.stdout.write(rendered);
     };
-    const writeNotice = (level, text, rendered) => {
+    const writeNotice = (level, text) => {
         emit({ type: "notice", level, text });
-        if (writesDirectly)
-            process.stdout.write(rendered);
     };
     const writeAssistantMessage = (text) => {
-        // Never surface an empty message: the reducer drops it and a direct
-        // stdout writer would print a stray blank line.
+        // Never surface an empty message: the reducer drops it and a consumer
+        // would paint a stray blank row.
         const clean = sanitizeAssistantText(text);
         if (!clean.trim())
             return;
         visibleCommitted = true;
         emit({ type: "assistant-message", text: clean });
-        const rendered = renderMarkdown(clean);
-        if (writesDirectly) {
-            process.stdout.write(clean.endsWith("\n") ? rendered : `${rendered}\n`);
-        }
     };
     const writeThinkingBlock = (content) => {
         emit({ type: "thinking-block", content });
-        if (writesDirectly)
-            process.stdout.write(`${renderThinkingSummary(content)}\n`);
     };
-    const writeToolOutput = (id, chunk, rendered, options) => {
+    const writeToolOutput = (id, chunk, options) => {
         emit({
             type: "tool-output",
             id,
             chunk,
             ...(options?.replace ? { replace: true } : {}),
         });
-        if (writesDirectly && rendered)
-            process.stdout.write(rendered);
     };
     const writeToolCall = (id, call, rendered) => {
         emit({
@@ -277,20 +256,14 @@ export async function runAgentTurn(prompt, options = {}) {
         if (writesDirectly)
             process.stdout.write(rendered);
     };
-    const writePlanUpdate = (plan, rendered) => {
+    const writePlanUpdate = (plan) => {
         emit({ type: "plan-update", plan });
-        if (writesDirectly)
-            process.stdout.write(rendered);
     };
-    const writeToolBlocked = (id, name, reason, rendered) => {
+    const writeToolBlocked = (id, name, reason) => {
         emit({ type: "tool-blocked", id, name, reason });
-        if (writesDirectly)
-            process.stdout.write(rendered);
     };
     const writeAbort = () => {
         emit({ type: "turn-aborted" });
-        if (writesDirectly)
-            process.stdout.write(chalk.yellow("  ⏹ Aborted.\n"));
     };
     const emitToolResult = (id, result, summary, artifactPath) => {
         const event = {
@@ -314,9 +287,6 @@ export async function runAgentTurn(prompt, options = {}) {
     const insertedText = (value, prefix) => value.startsWith(prefix) ? value.slice(prefix.length) : value;
     const writeCompactionStarted = (id, beforeTokens) => {
         emit({ type: "compaction-start", id, beforeTokens });
-        if (writesDirectly) {
-            process.stdout.write(chalk.dim("  ✦ Compacted Context · streaming Markdown\n\n"));
-        }
     };
     const writeCompactionDelta = (id, text, replace = false) => {
         if (!text && !replace)
@@ -327,12 +297,6 @@ export async function runAgentTurn(prompt, options = {}) {
             text,
             ...(replace ? { replace: true } : {}),
         });
-        if (writesDirectly) {
-            if (replace)
-                process.stdout.write(chalk.dim("\n  ↻ rewriting compacted context\n\n"));
-            if (text)
-                process.stdout.write(text);
-        }
     };
     const writeCompactionCompleted = (id, summary, beforeTokens, afterTokens) => {
         emit({
@@ -342,16 +306,9 @@ export async function runAgentTurn(prompt, options = {}) {
             beforeTokens,
             afterTokens,
         });
-        if (writesDirectly) {
-            const footer = chalk.dim(`\n  ~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens`);
-            process.stdout.write(`${footer}\n`);
-        }
     };
     const writeCompactionFailed = (id, message, retainedTokens) => {
         emit({ type: "compaction-failed", id, message, retainedTokens });
-        if (writesDirectly) {
-            process.stdout.write(chalk.yellow(`\n  Compaction failed: ${message} (~${retainedTokens.toLocaleString()} tokens retained)\n`));
-        }
     };
     // Points at the live message array so finishTurn can hand the full
     // conversation back to the caller. Assigned once `messages` is built below;
@@ -397,7 +354,7 @@ export async function runAgentTurn(prompt, options = {}) {
         if (displayRendered.trim()) {
             writeAssistantMessage(displayRendered);
         }
-        else if (!writesDirectly) {
+        else {
             emit({ type: "assistant-message", text: "" });
         }
         if (options.onMessages) {
@@ -422,12 +379,12 @@ export async function runAgentTurn(prompt, options = {}) {
         });
         const config = getConfig();
         const maxSteps = options.maxSteps ?? 70;
-        const confirmPort = options.confirm ?? inquirerConfirmPort;
+        const confirmPort = options.confirm ?? stdioConfirmPort;
         const projectContext = await loadProjectContext();
         const hasAttachedImages = Boolean(options.images?.length);
         const imageOcrEnabled = shouldEnableImageOcr(prompt, hasAttachedImages, options.visionProven !== false);
         const initialProvider = options.provider ?? config.defaultProvider;
-        const initialModel = options.model ?? config.defaultModel;
+        const initialModel = options.model ?? getProviderModel(initialProvider);
         // image.view is different from optimistic user-attachment handling: once
         // the tool succeeds, the model must actually receive and inspect its bytes.
         // Offer it only with affirmative capability evidence for the active route.
@@ -1122,15 +1079,10 @@ export async function runAgentTurn(prompt, options = {}) {
         const hasHistory = (options.history?.length ?? 0) > 0;
         const buildLike = buildLikeTurn;
         const pentestLike = looksLikePentestTask(prompt, options.history);
-        /** Coding/build sessions never hard-pause mid-turn for the progress governor. */
         let codingSession = codingSessionFromContext({
             buildLike,
             planKind: activePlan?.kind,
         });
-        let pauseMode = progressPauseMode({
-            codingSession,
-            autoConfirm: Boolean(options.autoConfirm),
-        });
         const continueExistingOutcome = /^(?:continue|resume|proceed|keep\s+going|finish|next)\b/i.test(prompt.trim()) ||
             Boolean(activePlan && !isPlanTerminal(activePlan));
         const outcomeState = await openOutcomeState({
@@ -1144,7 +1096,6 @@ export async function runAgentTurn(prompt, options = {}) {
         // Canonical mutation/artifact ledger feeding the durable compaction envelope.
         const workLedger = new WorkLedger();
         let governorState = createGovernorState();
-        let governorPauseReason;
         let turnState = createTurnState();
         const moveTurn = (to, reason) => {
             if (turnState.state === to)
@@ -1247,16 +1198,15 @@ export async function runAgentTurn(prompt, options = {}) {
             let call = normalizeToolCall(rawCall);
             const emitVisibleSyntheticReceipt = (result, summary) => {
                 if (!alreadyPrintedIds.has(toolEventId)) {
-                    const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                        chalk.gray(` ${formatToolArgs(call)}`);
-                    writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
+                    writeToolCall(toolEventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                        chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
                     alreadyPrintedIds.add(toolEventId);
                 }
                 emit({ type: "tool-start", id: toolEventId });
                 const output = result.output.endsWith("\n")
                     ? result.output
                     : `${result.output}\n`;
-                writeToolOutput(toolEventId, output, chalk.dim(`  ${output}`));
+                writeToolOutput(toolEventId, output);
                 emitToolResult(toolEventId, result, summary);
             };
             let dispatchedTaskId;
@@ -1281,7 +1231,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 return { ok: false, call, result, contextOutput: reason };
             }
             if (call.name === "image.ocr" && !imageOcrEnabled) {
-                writeNotice("info", "skipped OCR because the original image is attached to the vision model", chalk.dim("  ℹ skipped OCR — inspecting the attached image directly\n"));
+                writeNotice("info", "skipped OCR because the original image is attached to the vision model");
                 const recoveryText = "The original image is attached to this message and you can inspect it directly. " +
                     "Do not call image.ocr or infer text from OCR. Answer the user's question from the actual image pixels now.";
                 const result = { ok: true, output: recoveryText };
@@ -1317,14 +1267,13 @@ export async function runAgentTurn(prompt, options = {}) {
             // no execution, until the model re-issues the identical batch to confirm.
             if (call.name === "task.update" && batchRemindCalls.has(rawCall)) {
                 if (!alreadyPrintedIds.has(toolEventId)) {
-                    const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                        chalk.gray(` ${formatToolArgs(call)}`);
-                    writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
+                    writeToolCall(toolEventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                        chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
                     alreadyPrintedIds.add(toolEventId);
                 }
                 const result = { ok: false, output: batchReminderNote, exitCode: 1 };
                 emitToolResult(toolEventId, result, batchReminderNote);
-                writeToolOutput(toolEventId, "held\n", chalk.yellow("  ⚠") + "\n");
+                writeToolOutput(toolEventId, "held\n");
                 return { ok: false, call, result, contextOutput: batchReminderNote };
             }
             const retryReasonRaw = call.args._retryReason;
@@ -1361,7 +1310,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         suppressedRepeat: true,
                     };
                 }
-                writeNotice("warn", reason, chalk.yellow(`  ⚠ ${reason}\n`));
+                writeNotice("warn", reason);
                 const result = { ok: false, output: reason, exitCode: 1 };
                 emitToolResult(toolEventId, result, reason);
                 return {
@@ -1436,9 +1385,8 @@ export async function runAgentTurn(prompt, options = {}) {
                         unreadResponderNotificationIds.delete(responderWakeNotificationId);
                     }
                     if (!alreadyPrintedIds.has(toolEventId)) {
-                        const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                            chalk.gray(` ${formatToolArgs(call)}`);
-                        writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
+                        writeToolCall(toolEventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                            chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
                         alreadyPrintedIds.add(toolEventId);
                     }
                     const result = {
@@ -1448,7 +1396,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     };
                     loopGuard.recordAttempt(step, call.name, call.args, marked, 0);
                     emitToolResult(toolEventId, result, output);
-                    writeToolOutput(toolEventId, marked ? "read\n" : "failed\n", marked ? chalk.green("  ✓\n") : chalk.red("  ✗\n"));
+                    writeToolOutput(toolEventId, marked ? "read\n" : "failed\n");
                     return {
                         ok: marked,
                         call,
@@ -1496,11 +1444,10 @@ export async function runAgentTurn(prompt, options = {}) {
                                         reason: `Task ${resolved} must be in_progress before it can be marked done. Start or retry the task, perform fresh work, then complete it.`,
                                     };
                         if (!gate.ok) {
-                            writeNotice("warn", gate.reason, chalk.yellow(`  ⚠ ${gate.reason}\n`));
+                            writeNotice("warn", gate.reason);
                             if (!alreadyPrintedIds.has(toolEventId)) {
-                                const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                                    chalk.gray(` ${formatToolArgs(call)}`);
-                                writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
+                                writeToolCall(toolEventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                                    chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
                                 alreadyPrintedIds.add(toolEventId);
                             }
                             const result = {
@@ -1509,7 +1456,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 exitCode: 1,
                             };
                             emitToolResult(toolEventId, result, gate.reason);
-                            writeToolOutput(toolEventId, "failed\n", chalk.red("  ✗") + "\n");
+                            writeToolOutput(toolEventId, "failed\n");
                             return {
                                 ok: false,
                                 call,
@@ -1576,15 +1523,15 @@ export async function runAgentTurn(prompt, options = {}) {
                         pendingSessionStatePlan = planResult.plan;
                     }
                     if (!alreadyPrintedIds.has(toolEventId)) {
-                        const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) + chalk.gray(` ${formatToolArgs(call)}`);
-                        writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
+                        writeToolCall(toolEventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                            chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
                         alreadyPrintedIds.add(toolEventId);
                     }
                     if (planResult.reminder && planResult.toast) {
-                        writeNotice("warn", planResult.toast, chalk.yellow(`  ⚠ ${planResult.toast}\n`));
+                        writeNotice("warn", planResult.toast);
                     }
                     if (planResult.plan) {
-                        writePlanUpdate(planResult.plan, planResult.display);
+                        writePlanUpdate(planResult.plan);
                         // Refresh sticky root only if path already exists (not bare Desktop).
                         const root = extractProjectRootFromPlan(planResult.plan);
                         if (root)
@@ -1599,8 +1546,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                     const result = { ok: planResult.ok, output: planResult.modelNote };
                     emitToolResult(toolEventId, result, planResult.modelNote);
-                    const statusIcon = result.ok ? chalk.green("  ✓") : chalk.red("  ✗");
-                    writeToolOutput(toolEventId, result.ok ? "ok\n" : "failed\n", statusIcon + "\n");
+                    writeToolOutput(toolEventId, result.ok ? "ok\n" : "failed\n");
                     return {
                         ok: planResult.ok,
                         call,
@@ -1640,16 +1586,15 @@ export async function runAgentTurn(prompt, options = {}) {
                         `Use any recon/enum/scan/research tool; do not write project files or run active exploits. ` +
                         `Put exploit/implement steps in plan.create tasks for after accept. ` +
                         `Accept the plan (y/i or /implement) to switch to agent and execute.`;
-                    writeNotice("warn", reason, chalk.yellow(`  ⚠ ${reason}\n`));
+                    writeNotice("warn", reason);
                     if (!alreadyPrintedIds.has(toolEventId)) {
-                        const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                            chalk.gray(` ${formatToolArgs(call)}`);
-                        writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
+                        writeToolCall(toolEventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                            chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
                         alreadyPrintedIds.add(toolEventId);
                     }
                     const result = { ok: false, output: reason, exitCode: 1 };
                     emitToolResult(toolEventId, result, reason);
-                    writeToolOutput(toolEventId, "failed\n", chalk.red("  ✗") + "\n");
+                    writeToolOutput(toolEventId, "failed\n");
                     return {
                         ok: false,
                         call,
@@ -1666,7 +1611,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     (await loadPlan(session.sessionId).catch(() => undefined));
                 if (planNow && !session.planApproved.value) {
                     const reason = `plan awaiting approval — ${call.name} is blocked until the plan is accepted (/implement or Accept)`;
-                    writeNotice("warn", reason, chalk.yellow(`  ⚠ ${reason}\n`));
+                    writeNotice("warn", reason);
                     const result = { ok: false, output: reason, exitCode: 1 };
                     return {
                         ok: false,
@@ -1721,8 +1666,8 @@ export async function runAgentTurn(prompt, options = {}) {
                                     taskWorkLedger.taskId !== nextPending.id) {
                                     taskWorkLedger = ledgerFromTaskEvidence(nextPending.id, nextPending.evidence);
                                 }
-                                writePlanUpdate(livePlanForGate, renderPlanForTerminal(livePlanForGate) + "\n");
-                                writeNotice("info", `auto-started [${nextPending.id}] so work can continue`, chalk.dim(`  ℹ no task was in_progress — auto-started [${nextPending.id}] "${nextPending.title}" before ${call.name}\n`));
+                                writePlanUpdate(livePlanForGate);
+                                writeNotice("info", `auto-started [${nextPending.id}] so work can continue`);
                             }
                         }
                     }
@@ -1745,16 +1690,15 @@ export async function runAgentTurn(prompt, options = {}) {
                     const message = materialized
                         ? `Scaffold skipped: the target already contains a usable project${target ? ` at ${target}` : ""}. Continue that project directly; do not re-run the scaffolder.`
                         : `Scaffold was not run: the existing target${target ? ` at ${target}` : ""} is incomplete. Inspect and repair it before completing the scaffold task; do not retry the scaffolder into this non-empty directory.`;
-                    writeNotice("info", message, chalk.dim(`  ℹ ${message}\n`));
+                    writeNotice("info", message);
                     if (!alreadyPrintedIds.has(toolEventId)) {
-                        const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                            chalk.gray(` ${formatToolArgs(call)}`);
-                        writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
+                        writeToolCall(toolEventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                            chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
                         alreadyPrintedIds.add(toolEventId);
                     }
                     const result = { ok: true, output: message, exitCode: 0 };
                     emitToolResult(toolEventId, result, message);
-                    writeToolOutput(toolEventId, "ok\n", chalk.green("  ✓") + "\n");
+                    writeToolOutput(toolEventId, "ok\n");
                     return {
                         ok: true,
                         call,
@@ -1764,8 +1708,8 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
             }
             if (!alreadyPrintedIds.has(toolEventId)) {
-                const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) + chalk.gray(` ${formatToolArgs(call)}`);
-                writeToolCall(toolEventId, call, styleToolChatter(call, toolCallLine) + "\n");
+                writeToolCall(toolEventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                    chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
                 alreadyPrintedIds.add(toolEventId);
             }
             const scopeTarget = safeScopeTargetForToolCall(call);
@@ -1815,14 +1759,14 @@ export async function runAgentTurn(prompt, options = {}) {
                         reason: decisionForAction.reason,
                         allowed: scope?.authorizedTargets,
                     });
-                    writeToolBlocked(toolEventId, call.name, reason, chalk.red(`  ✗ ${reason}\n`));
+                    writeToolBlocked(toolEventId, call.name, reason);
                     const result = { ok: false, output: reason, exitCode: 1 };
                     emitToolResult(toolEventId, result, reason);
                     return { ok: false, call, result, contextOutput: reason };
                 }
             }
             if (decision.level === "block") {
-                writeToolBlocked(toolEventId, call.name, decision.reason, chalk.red(`  ✗ blocked: ${decision.reason}`) + "\n");
+                writeToolBlocked(toolEventId, call.name, decision.reason);
                 const message = `Blocked: ${call.name} — ${decision.reason}`;
                 const result = { ok: false, output: message, exitCode: 1 };
                 return {
@@ -1844,7 +1788,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 restoreInteractiveStdin();
                 if (!authorized) {
                     const lastAnswer = "Pentest authorization not confirmed.";
-                    writeToolBlocked(toolEventId, call.name, lastAnswer, chalk.red(`  ✗ ${lastAnswer}`) + "\n");
+                    writeToolBlocked(toolEventId, call.name, lastAnswer);
                     const result = { ok: false, output: lastAnswer, exitCode: 1 };
                     return {
                         ok: false,
@@ -1898,7 +1842,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     restoreInteractiveStdin();
                     if (!ok) {
                         const lastAnswer = "Cancelled.";
-                        writeToolBlocked(toolEventId, call.name, lastAnswer, chalk.red(`  ✗ cancelled`) + "\n");
+                        writeToolBlocked(toolEventId, call.name, lastAnswer);
                         const result = { ok: false, output: lastAnswer, exitCode: 1 };
                         return {
                             ok: false,
@@ -1961,11 +1905,11 @@ export async function runAgentTurn(prompt, options = {}) {
                 }).catch(() => undefined);
                 if (!created?.ok || !delegation.taskId) {
                     delegation = undefined;
-                    writeNotice("warn", "Responder delegation record could not be persisted — the job will be linked after launch", chalk.yellow("  ⚠ responder delegation record not persisted; linking after launch\n"));
+                    writeNotice("warn", "Responder delegation record could not be persisted — the job will be linked after launch");
                 }
                 else if (created.plan) {
                     pendingSessionStatePlan = created.plan;
-                    writePlanUpdate(created.plan, renderPlanForTerminal(created.plan) + "\n");
+                    writePlanUpdate(created.plan);
                 }
             }
             if (dispatchedTaskId &&
@@ -1993,7 +1937,7 @@ export async function runAgentTurn(prompt, options = {}) {
             options.onToolStart?.(call);
             // Card was "queued" since writeToolCall; flip to running only when work starts.
             emit({ type: "tool-start", id: toolEventId });
-            writeStatus(call.name, chalk.dim(`  → ${call.name}\n`));
+            writeStatus(call.name);
             // Elevation uses the secure secret modal (TUI) or is refused — never
             // a raw TTY "Password:" that freezes the UI. No misleading notice.
             const toolAc = new AbortController();
@@ -2013,7 +1957,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 liveBytes += chunk.length;
                 const indented = chunk.replace(/\r/g, "").replace(/\n(?!$)/g, "\n  ");
                 const body = indented.startsWith("\n") ? indented : `  ${indented}`;
-                writeToolOutput(toolEventId, chunk, chalk.dim(body));
+                writeToolOutput(toolEventId, chunk);
             };
             const jobId = randomUUID().slice(0, 8);
             const emptyJobArtifact = () => ({
@@ -2057,7 +2001,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 stallTimer = setTimeout(() => {
                     if (!toolAc.signal.aborted) {
                         stalledByWatchdog = true;
-                        writeNotice("warn", `${call.name} has been running for >${stallSecs}s without output — cancelling stalled tool`, chalk.yellow(`  ⏳ ${call.name} stalled for >${stallSecs}s without output — cancelling\n`));
+                        writeNotice("warn", `${call.name} has been running for >${stallSecs}s without output — cancelling stalled tool`);
                         toolAc.abort();
                     }
                 }, TOOL_STALL_ABORT_MS);
@@ -2073,7 +2017,7 @@ export async function runAgentTurn(prompt, options = {}) {
             const runToolWithForcedSettle = () => {
                 const work = runToolCall(call, {
                     signal: toolAc.signal,
-                    requestSecret: options.requestSecret ?? inquirerSecretRequester,
+                    requestSecret: options.requestSecret ?? stdioSecretRequester,
                     onOutput: (chunk) => {
                         if (toolAc.signal.aborted)
                             return;
@@ -2169,7 +2113,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         graceTimer = setTimeout(() => {
                             if (settled)
                                 return;
-                            writeNotice("warn", `${call.name} did not stop after cancel — force-settling`, chalk.yellow(`  ⏳ ${call.name} ignore cancel — force-settling hung tool\n`));
+                            writeNotice("warn", `${call.name} did not stop after cancel — force-settling`);
                             finishOk(forceCancelResult());
                         }, TOOL_ABORT_GRACE_MS);
                         graceTimer.unref?.();
@@ -2180,7 +2124,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         if (settled)
                             return;
                         hardTimedOut = true;
-                        writeNotice("warn", `${call.name} exceeded ${hardSecs}s hard budget — cancelling`, chalk.yellow(`  ⏳ ${call.name} hard-timeout (${hardSecs}s) — cancelling\n`));
+                        writeNotice("warn", `${call.name} exceeded ${hardSecs}s hard budget — cancelling`);
                         if (!toolAc.signal.aborted)
                             toolAc.abort();
                         armGraceForceSettle();
@@ -2215,7 +2159,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     };
                 }
                 if (liveBytes > 0) {
-                    writeToolOutput(toolEventId, "\n", "\n");
+                    writeToolOutput(toolEventId, "\n");
                 }
                 jobManager.updateJobStatus(jobId, result.ok ? "exited" : "failed", result.exitCode);
             }
@@ -2267,7 +2211,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 const output = result.output.endsWith("\n")
                     ? result.output
                     : `${result.output}\n`;
-                writeToolOutput(toolEventId, output, "", { replace: true });
+                writeToolOutput(toolEventId, output, { replace: true });
                 emitToolResult(toolEventId, result, contextOutput);
                 options.onToolResult?.(call, result);
                 // Record it as an observation-free success so the per-call guard can
@@ -2326,7 +2270,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             `(package/manifest present). Treat this as resumable: do NOT re-run the scaffolder. ` +
                             `Inspect the existing files, finish any missing install, implement the requested feature, then run/verify.`,
                     };
-                    writeNotice("info", `project root → ${fromScaffold} (existing materialized scaffold — continue)`, chalk.dim(`  ℹ existing scaffold at ${fromScaffold} — continue, do not re-create\n`));
+                    writeNotice("info", `project root → ${fromScaffold} (existing materialized scaffold — continue)`);
                 }
                 else if (result.ok && cancelled && !materialized) {
                     result = {
@@ -2357,13 +2301,13 @@ export async function runAgentTurn(prompt, options = {}) {
                     else if (fromScaffold) {
                         setActiveProjectRootIfValid(fromScaffold, { force: true });
                         await persistProjectRootOnPlan(fromScaffold);
-                        writeNotice("info", `project root → ${fromScaffold} (scaffold output claimed success — continue)`, chalk.dim(`  ℹ project root set to ${fromScaffold}\n`));
+                        writeNotice("info", `project root → ${fromScaffold} (scaffold output claimed success — continue)`);
                     }
                 }
                 else if (result.ok && fromScaffold && materialized) {
                     setActiveProjectRootIfValid(fromScaffold, { force: true });
                     await persistProjectRootOnPlan(fromScaffold);
-                    writeNotice("info", `project root → ${fromScaffold}`, chalk.dim(`  ℹ project root set to ${fromScaffold}\n`));
+                    writeNotice("info", `project root → ${fromScaffold}`);
                 }
             }
             if (delegation?.taskId && !result.backgroundJob) {
@@ -2383,7 +2327,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 }).catch(() => undefined);
                 if (settlement?.ok && settlement.plan) {
                     pendingSessionStatePlan = settlement.plan;
-                    writePlanUpdate(settlement.plan, renderPlanForTerminal(settlement.plan) + "\n");
+                    writePlanUpdate(settlement.plan);
                 }
                 delegation = undefined;
             }
@@ -2461,7 +2405,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             return true;
                         }).catch(() => undefined);
                         if (!upsert?.ok || !responderChildId) {
-                            writeNotice("warn", `Responder job ${durableJob.id} started, but its plan subtask could not be persisted`, chalk.yellow(`  ⚠ job ${durableJob.id} is running, but task linkage persistence failed\n`));
+                            writeNotice("warn", `Responder job ${durableJob.id} started, but its plan subtask could not be persisted`);
                         }
                         else {
                             linkedTaskId = responderChildId;
@@ -2469,7 +2413,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             responderTaskId = responderChildId;
                             pendingSessionStatePlan = upsert.plan ?? livePlan;
                             const rendered = upsert.plan ?? livePlan;
-                            writePlanUpdate(rendered, renderPlanForTerminal(rendered) + "\n");
+                            writePlanUpdate(rendered);
                         }
                     }
                     if (durableJob) {
@@ -2487,7 +2431,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             },
                         });
                         if (!linkedJob) {
-                            writeNotice("warn", `Responder job ${durableJob.id} started, but durable task linkage will be retried on completion`, chalk.yellow(`  ⚠ job ${durableJob.id} is running, but durable task linkage needs recovery\n`));
+                            writeNotice("warn", `Responder job ${durableJob.id} started, but durable task linkage will be retried on completion`);
                         }
                         else if (responderTaskId) {
                             result = {
@@ -2618,23 +2562,6 @@ export async function runAgentTurn(prompt, options = {}) {
                                 : ""),
                     });
                 }
-                else if (governed.recommendation === "paused_budget") {
-                    if (pauseMode === "never") {
-                        // Soft reset so we do not re-trip every subsequent tool.
-                        governorState = {
-                            ...governed.state,
-                            consecutiveNoDelta: 0,
-                        };
-                        deferredPostToolMessages.push({
-                            role: "system",
-                            content: `PROGRESS GOVERNOR (soft, coding build): ${governed.reason}. ` +
-                                "Change approach if stuck, but keep implementing — do not stop for user confirmation.",
-                        });
-                    }
-                    else {
-                        governorPauseReason = governed.reason;
-                    }
-                }
             }
             await saveOutcomeState(outcomeState);
             loopGuard.recordAttempt(step, call.name, call.args, result.ok, result.exitCode, result.output, completedProbeState ? { stateKey: completedProbeState } : undefined);
@@ -2735,51 +2662,14 @@ export async function runAgentTurn(prompt, options = {}) {
                 if (reflection) {
                     deferredPostToolMessages.push({ role: "system", content: reflection });
                     const failCount = loopGuard.consecutiveFailureCount();
-                    writeNotice("warn", `${failCount} consecutive failures — model evaluating approach`, chalk.yellow(`  ⚠ ${failCount} consecutive failures — evaluating approach\n`));
+                    writeNotice("warn", `${failCount} consecutive failures — model evaluating approach`);
                 }
             }
-            const statusIcon = result.ok ? chalk.green("  ✓") : chalk.red("  ✗");
-            // Classic stdout gets a short status glyph; the event stream / spool
-            // must NOT be polluted with "ok"/"failed" (the card already shows status).
-            if (writesDirectly) {
-                process.stdout.write(statusIcon + "\n");
-            }
             if (output) {
                 // Authoritative FULL body — replace any live stream so the pager
                 // never shows a truncated mid-run preview. Never cap for the UI.
                 const fullChunk = output.endsWith("\n") ? output : `${output}\n`;
-                if (!writesDirectly) {
-                    writeToolOutput(toolEventId, fullChunk, "", { replace: true });
-                }
-                else {
-                    // Classic stdout: short preview only; full text is on disk.
-                    const displayMax = 6_000;
-                    const displaySummary = summarizeOutput(output, displayMax);
-                    const displayText = displaySummary.truncated
-                        ? `${displaySummary.text}${savedOutputPath ? chalk.dim(`\n  ... full output saved to ${savedOutputPath}`) : ""}`
-                        : displaySummary.text;
-                    const renderedOutput = indentAndWrapText(displayText);
-                    process.stdout.write(styleToolChatter(call, renderedOutput) + "\n");
-                    if (savedOutputPath && displaySummary.truncated) {
-                        process.stdout.write(chalk.dim(`  full output saved to ${savedOutputPath}\n`));
-                    }
-                }
-            }
-            if (output) {
-                const viewport = registerViewport({
-                    toolName: call.name,
-                    argsDisplay: formatToolArgs(call),
-                    artifactPath: savedOutputPath,
-                    summary: contextOutput,
-                });
-                if (writesDirectly && savedOutputPath) {
-                    const short = chalk.dim(`  saved ${savedOutputPath}\n`);
-                    process.stdout.write(short);
-                }
-                else if (writesDirectly) {
-                    const viewportHint = `${formatViewportHint(viewport)}\n`;
-                    process.stdout.write(viewportHint);
-                }
+                writeToolOutput(toolEventId, fullChunk, { replace: true });
             }
             return { ok: result.ok, call, result, contextOutput };
         }
@@ -3023,7 +2913,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         trigger: compactTrigger,
                         dominant,
                     });
-                    writeNotice("warn", `context is still ~${candidateTokens.toLocaleString()} tokens after compaction (limit ~${compactTrigger.toLocaleString()}) — largest block: ${dominant}`, chalk.yellow(`  ⚠ context still ~${candidateTokens.toLocaleString()} tokens after compaction; largest block: ${dominant}\n`));
+                    writeNotice("warn", `context is still ~${candidateTokens.toLocaleString()} tokens after compaction (limit ~${compactTrigger.toLocaleString()}) — largest block: ${dominant}`);
                     writeCompactionFailed(compactionId, `Summary remained over the context limit; largest block: ${dominant}.`, beforeTokens);
                     return;
                 }
@@ -3060,7 +2950,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 // Report the final assembled request, including live plan and session
                 // state reinjection, so the card and the next provider request agree.
                 writeCompactionCompleted(compactionId, summaryText, beforeTokens, afterTokens);
-                writeNotice("info", `context auto-compacted to fit the window (~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens)`, chalk.dim(`  ℹ context auto-compacted (~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens)\n`));
+                writeNotice("info", `context auto-compacted to fit the window (~${beforeTokens.toLocaleString()} → ~${afterTokens.toLocaleString()} tokens)`);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
@@ -3082,55 +2972,6 @@ export async function runAgentTurn(prompt, options = {}) {
             // `step` is the productive-step index (used for display + audit). It only
             // advances when the previous iteration actually executed a tool.
             step = productiveSteps;
-            if (governorPauseReason) {
-                // Non-coding: always ask continue/stop. Coding never sets this reason
-                // (pauseMode === "never"), but guard anyway.
-                if (pauseMode === "never") {
-                    governorPauseReason = undefined;
-                    governorState = {
-                        ...governorState,
-                        consecutiveNoDelta: 0,
-                    };
-                }
-                else {
-                    const confirmPort = options.confirm;
-                    let keepGoing = false;
-                    if (confirmPort?.confirmContinue) {
-                        try {
-                            keepGoing = await confirmPort.confirmContinue(productiveSteps, governorPauseReason);
-                        }
-                        catch {
-                            keepGoing = false;
-                        }
-                        finally {
-                            restoreInteractiveStdin();
-                        }
-                    }
-                    if (keepGoing) {
-                        writeNotice("info", "continuing after progress pause", chalk.dim(`  ℹ continuing after pause (${governorPauseReason}) — change approach if stuck\n`));
-                        deferredPostToolMessages.push({
-                            role: "system",
-                            content: `User chose CONTINUE after progress pause (${governorPauseReason}). ` +
-                                "Do not repeat the same failing step; change approach and produce new evidence.",
-                        });
-                        governorPauseReason = undefined;
-                        governorState = {
-                            ...governorState,
-                            consecutiveNoDelta: 0,
-                        };
-                    }
-                    else {
-                        const richSummary = await buildRichStopSummary(messages, session, productiveSteps);
-                        outcomeState.outcome.status = "paused_budget";
-                        await saveOutcomeState(outcomeState);
-                        moveTurn("paused_budget", governorPauseReason);
-                        lastAnswer = richSummary;
-                        return finishTurn(lastAnswer, productiveSteps, "paused_budget", outcomeState.outcome.criteria
-                            .filter((criterion) => criterion.required && criterion.status !== "proven")
-                            .map((criterion) => criterion.statement), governorPauseReason);
-                    }
-                }
-            }
             options.signal?.throwIfAborted();
             let call;
             let assistantText;
@@ -3140,7 +2981,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 call = pendingCalls.shift();
                 assistantText = { visible: "", thinkContent: "", hasThinking: false };
                 const batchStatus = `  ↳ continuing batch (${pendingCalls.length} more queued)\n`;
-                writeStatus(batchStatus, chalk.dim(batchStatus));
+                writeStatus(batchStatus);
             }
             else {
                 await maybeAutoCompact("auto-token-budget");
@@ -3150,12 +2991,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 // tool protocol or forcing a separate busy-wait loop.
                 const responderDelivery = refreshResponderInbox();
                 const streamLabel = step === 0 ? "waiting for model" : `step ${step + 1}`;
-                let spinner = writesDirectly
-                    ? startThinkingSpinner(streamLabel, options.signal)
-                    : noopSpinner;
-                if (!writesDirectly) {
-                    emit({ type: "status", text: streamLabel });
-                }
+                emit({ type: "status", text: streamLabel });
                 let sawReasoning = false;
                 let inThinking = false;
                 let emittedThinkingStatus = false;
@@ -3175,24 +3011,18 @@ export async function runAgentTurn(prompt, options = {}) {
                     return "waiting for model";
                 };
                 const heartbeat = setInterval(() => {
-                    const text = streamPhase();
-                    if (writesDirectly)
-                        spinner.setLabel(text);
-                    else
-                        emit({ type: "status", text });
+                    emit({ type: "status", text: streamPhase() });
                 }, 10_000);
                 heartbeat.unref?.();
                 const deferredToolCalls = [];
                 const streamedNativeCallNames = new Map();
-                const deltaParser = writesDirectly
-                    ? undefined
-                    : createThinkingStreamParser((text) => emit({ type: "assistant-delta", text }), (text) => {
-                        if (!emittedThinkingStatus) {
-                            emittedThinkingStatus = true;
-                            emit({ type: "status", text: "thinking" });
-                        }
-                        emit({ type: "thinking-delta", text });
-                    });
+                const deltaParser = createThinkingStreamParser((text) => emit({ type: "assistant-delta", text }), (text) => {
+                    if (!emittedThinkingStatus) {
+                        emittedThinkingStatus = true;
+                        emit({ type: "status", text: "thinking" });
+                    }
+                    emit({ type: "thinking-delta", text });
+                });
                 let completion;
                 let toolsAttached = false;
                 try {
@@ -3230,7 +3060,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             if (notice.includes("Large context")) {
                                 freeTierLargeContextWarned = true;
                             }
-                            writeNotice("info", notice, chalk.dim(`  ℹ ${notice}\n`));
+                            writeNotice("info", notice);
                         }
                     }
                     const contextLimitTokens = currentContextLimitTokens();
@@ -3299,23 +3129,17 @@ export async function runAgentTurn(prompt, options = {}) {
                                             return;
                                         const name = fromWireName(delta.name) ?? delta.name;
                                         streamedNativeCallNames.set(delta.index, name);
-                                        if (!writesDirectly) {
-                                            emit({
-                                                type: "status",
-                                                text: delta.argumentsBytes && delta.argumentsBytes >= 4096
-                                                    ? `${name} (${Math.round(delta.argumentsBytes / 1024)}KB args)`
-                                                    : name,
-                                            });
-                                        }
-                                        else {
-                                            spinner.stop();
-                                            spinner = startThinkingSpinner(`tool ${name}…`, options.signal);
-                                        }
+                                        emit({
+                                            type: "status",
+                                            text: delta.argumentsBytes && delta.argumentsBytes >= 4096
+                                                ? `${name} (${Math.round(delta.argumentsBytes / 1024)}KB args)`
+                                                : name,
+                                        });
                                     },
                                 }
                                 : {}),
                         }, (token) => {
-                            deltaParser?.push(token);
+                            deltaParser.push(token);
                             generatedTokens += 1;
                             accumulatedText += token;
                             // Early UI cards from text fences only when native tools are off
@@ -3323,33 +3147,22 @@ export async function runAgentTurn(prompt, options = {}) {
                             if (!toolsAttached) {
                                 const parsedCalls = parseAllToolCalls(accumulatedText);
                                 if (parsedCalls.length > streamedCallsCount) {
-                                    if (writesDirectly) {
-                                        spinner.stop();
-                                    }
                                     while (streamedCallsCount < parsedCalls.length) {
                                         const call = normalizeToolCall(parsedCalls[streamedCallsCount]);
                                         const eventId = `tool-${++nextToolEventId}`;
                                         callIds[streamedCallsCount] = eventId;
                                         alreadyPrintedIds.add(eventId);
-                                        const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                                            chalk.gray(` ${formatToolArgs(call)}`);
-                                        const entry = {
+                                        deferredToolCalls.push({
                                             eventId,
                                             call,
-                                            rendered: styleToolChatter(call, toolCallLine) + "\n",
-                                            shown: false,
-                                        };
-                                        deferredToolCalls.push(entry);
-                                        if (!writesDirectly) {
-                                            writeToolCall(eventId, call, entry.rendered);
-                                            entry.shown = true;
-                                            emit({ type: "status", text: call.name });
-                                        }
+                                            rendered: "",
+                                            shown: true,
+                                        });
+                                        writeToolCall(eventId, call, styleToolChatter(call, chalk.cyan(`  ▶ ${call.name}`) +
+                                            chalk.gray(` ${formatToolArgs(call)}`)) + "\n");
+                                        emit({ type: "status", text: call.name });
                                         streamedCallsCount += 1;
                                     }
-                                    if (writesDirectly) {
-                                        spinner = startThinkingSpinner(`generating response (${generatedTokens} tokens)`, options.signal);
-                                    }
                                 }
                             }
                             if (!sawReasoning &&
@@ -3357,37 +3170,19 @@ export async function runAgentTurn(prompt, options = {}) {
                                     /^\s*<think(?:ing)?\b/i.test(accumulatedText))) {
                                 sawReasoning = true;
                                 inThinking = true;
-                                spinner.setLabel("thinking");
-                                if (!writesDirectly)
-                                    emit({ type: "status", text: "thinking" });
+                                emit({ type: "status", text: "thinking" });
                             }
                             if (token.includes(REASONING_CLOSE) ||
                                 (inThinking && /<\/think(?:ing)?>/i.test(token))) {
                                 inThinking = false;
-                                spinner.setLabel("generating response (0 tokens)");
                                 generatedTokens = 0;
                             }
-                            if (inThinking) {
-                                const cleaned = stripReasoningMarkers(token).replace(/<\/?think(?:ing)?[^>]*>/gi, "");
-                                if (cleaned) {
-                                    spinner.pushPreview(cleaned);
-                                    const approx = cleaned.split(/\s+/).filter(Boolean).length;
-                                    if (approx > 0)
-                                        spinner.bumpReasoning(approx);
-                                }
-                            }
-                            else {
-                                if (generatedTokens % 10 === 0) {
-                                    spinner.setLabel(`generating response (${generatedTokens} tokens)`);
-                                }
-                            }
                         }, (status) => {
-                            spinner.stop();
-                            writeStatus(status, chalk.dim(status));
+                            writeStatus(status);
                             // Toast only on key *switch* after a failure — never on sticky
                             // "using" or retry countdown ticks (those stay in composer status).
                             if (/^switching /i.test(status.trim())) {
-                                writeNotice("warn", status.trim(), chalk.yellow(`  ${status.trim()}\n`));
+                                writeNotice("warn", status.trim());
                             }
                         });
                         freeTierConsecutiveFailures = 0;
@@ -3413,7 +3208,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             })) {
                                 if (notice.includes("Large context"))
                                     continue; // already shown above
-                                writeNotice("warn", notice, chalk.yellow(`  ⚠ ${notice}\n`));
+                                writeNotice("warn", notice);
                                 freeTierAdvisoryShown = true;
                             }
                         }
@@ -3451,8 +3246,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         const terminalFailure = plan.action === "give-up";
                         let continuationNudge = "";
                         if (partialStream) {
-                            spinner.stop();
-                            deltaParser?.finish();
+                            deltaParser.finish();
                             const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
                             if (partialVisible) {
                                 // Finalizing here would close the streaming card and split one
@@ -3471,7 +3265,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 });
                                 interruptedVisible += normalizedPartialVisible;
                             }
-                            else if (terminalFailure && !writesDirectly) {
+                            else if (terminalFailure) {
                                 emit({ type: "assistant-message", text: "" });
                             }
                             if (partial.hasThinking && !hasShownToolCall) {
@@ -3483,7 +3277,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             for (const deferred of deferredToolCalls) {
                                 if (!deferred.shown || deferred.call.name === "…")
                                     continue;
-                                writeToolBlocked(deferred.eventId, deferred.call.name, "Incomplete tool call discarded after the provider stream was interrupted.", chalk.yellow("  ⚠ incomplete tool call discarded after stream interruption\n"));
+                                writeToolBlocked(deferred.eventId, deferred.call.name, "Incomplete tool call discarded after the provider stream was interrupted.");
                             }
                             continuationNudge = [
                                 partialVisible
@@ -3498,7 +3292,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 : lowYieldResumptions > 1
                                     ? `route is dropping after almost no output (${lowYieldResumptions} in a row) — switching model`
                                     : "partial response preserved — resuming from the interruption";
-                            writeNotice("warn", restartNotice, chalk.yellow(`  ⚠ ${restartNotice}\n`));
+                            writeNotice("warn", restartNotice);
                         }
                         if (terminalFailure) {
                             throw streamError;
@@ -3509,7 +3303,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             preferModelFallback = true;
                         }
                         if (plan.notice) {
-                            writeNotice("warn", plan.notice, chalk.yellow(`  ⚠ ${plan.notice}\n`));
+                            writeNotice("warn", plan.notice);
                         }
                         if (plan.disableThinking)
                             retryWithoutThinking = true;
@@ -3537,9 +3331,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                 }
                 finally {
-                    // Always clear the spinner — abort, network error, or success.
                     clearInterval(heartbeat);
-                    spinner.stop();
                 }
                 if (responderDelivery) {
                     // The result text is now part of this turn, so consumption is durable.
@@ -3577,7 +3369,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         });
                     }
                 }
-                deltaParser?.finish();
+                deltaParser.finish();
                 // Sticky text-only may have flipped dialect during stream retry.
                 ({ dialect: toolDialect, native: nativeToolsActive } =
                     resolveNativeTools(provider, model));
@@ -3599,10 +3391,10 @@ export async function runAgentTurn(prompt, options = {}) {
                         if (displayText) {
                             writeAssistantMessage(displayText);
                         }
-                        else if (deltaParser) {
+                        else {
                             emit({ type: "assistant-message", text: "" });
                         }
-                        if (assistantText.hasThinking && deltaParser) {
+                        if (assistantText.hasThinking) {
                             emit({
                                 type: "thinking-block",
                                 content: assistantText.thinkContent,
@@ -3614,18 +3406,6 @@ export async function runAgentTurn(prompt, options = {}) {
                     interruptedReasoning = "";
                     lowYieldResumptions = 0;
                 };
-                // Only emit a thinking-block event when the classic renderer is
-                // active (writesDirectly / no deltaParser).  In TUI v2 the
-                // deltaParser already streamed thinking-delta events that created
-                // the thinking item in the correct transcript position; emitting
-                // a redundant thinking-block after tool-call events have cleared
-                // pendingThinkingId causes the reducer to append a *duplicate*
-                // thinking item at the end of the transcript — the root cause of
-                // the "ghost thinking blocks below the response" bug seen with
-                // models that use reasoning_content (e.g. Kimi K2-thinking).
-                if (assistantText.hasThinking && !deltaParser) {
-                    writeThinkingBlock(assistantText.thinkContent);
-                }
                 // Native-first: prefer structured toolCalls from the provider.
                 let nativeToolCalls = completion.toolCalls ?? [];
                 // Early UI cards: refresh args if stream deltas already opened cards;
@@ -3641,12 +3421,10 @@ export async function runAgentTurn(prompt, options = {}) {
                             const eventId = `tool-${++nextToolEventId}`;
                             callIds[i] = eventId;
                             alreadyPrintedIds.add(eventId);
-                            const toolCallLine = chalk.cyan(`  ▶ ${normalized.name}`) +
-                                chalk.gray(` ${formatToolArgs(normalized)}`);
                             deferredToolCalls.push({
                                 eventId,
                                 call: normalized,
-                                rendered: styleToolChatter(normalized, toolCallLine) + "\n",
+                                rendered: "",
                                 shown: false,
                             });
                         }
@@ -3662,21 +3440,15 @@ export async function runAgentTurn(prompt, options = {}) {
                             if (existing && existing.call.name !== "…") {
                                 callIds[i] = existing.eventId;
                                 existing.call = normalized;
-                                const toolCallLine = chalk.cyan(`  ▶ ${normalized.name}`) +
-                                    chalk.gray(` ${formatToolArgs(normalized)}`);
-                                existing.rendered =
-                                    styleToolChatter(normalized, toolCallLine) + "\n";
                             }
                             else if (!existing || existing.call.name === "…") {
                                 const eventId = existing?.eventId ?? `tool-${++nextToolEventId}`;
                                 callIds[i] = eventId;
                                 alreadyPrintedIds.add(eventId);
-                                const toolCallLine = chalk.cyan(`  ▶ ${normalized.name}`) +
-                                    chalk.gray(` ${formatToolArgs(normalized)}`);
                                 const entry = {
                                     eventId,
                                     call: normalized,
-                                    rendered: styleToolChatter(normalized, toolCallLine) + "\n",
+                                    rendered: "",
                                     shown: existing?.shown ?? false,
                                 };
                                 if (existing)
@@ -3708,13 +3480,13 @@ export async function runAgentTurn(prompt, options = {}) {
                             strict: getConfig().parserStrict,
                         });
                         if (call) {
-                            writeNotice("info", "recovered tool call from thinking content", chalk.dim("  ℹ recovered tool call from thinking content\n"));
+                            writeNotice("info", "recovered tool call from thinking content");
                         }
                     }
                 }
                 if (looksLikePromptLeak(assistantText.visible)) {
                     if (call || nativeToolCalls.length) {
-                        writeNotice("warn", "suppressed tool call from apparent prompt leak", chalk.yellow("  ⚠ suppressed tool call — model appears to be repeating its system prompt\n"));
+                        writeNotice("warn", "suppressed tool call from apparent prompt leak");
                     }
                     call = undefined;
                     nativeToolCalls = [];
@@ -3742,7 +3514,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                     const writeResult = await applySalvagedWrite(salvaged);
                                     if (writeResult.ok) {
                                         const lineCount = salvaged.content.split("\n").length;
-                                        writeNotice("info", `native tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`, chalk.cyan(`  ℹ native tool call was truncated — salvaged ${lineCount} lines to ${salvaged.path}\n`));
+                                        writeNotice("info", `native tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`);
                                         // Pair assistant tool_calls with synthetic results so the
                                         // next turn is not orphaned, then nudge for append.
                                         const salvageHistoryCalls = ensureUniqueToolCallIds(nativeToolCalls, toolCallIdsInHistory(messages));
@@ -3800,10 +3572,10 @@ export async function runAgentTurn(prompt, options = {}) {
                             for (const entry of deferredToolCalls) {
                                 if (!entry.shown || entry.call.name === "…")
                                     continue;
-                                writeToolBlocked(entry.eventId, entry.call.name, "Native tool arguments were unusable again; nothing ran. Reissue as a fenced tool block.", chalk.yellow("  ⚠ native tool arguments were unusable again — nothing ran\n"));
+                                writeToolBlocked(entry.eventId, entry.call.name, "Native tool arguments were unusable again; nothing ran. Reissue as a fenced tool block.");
                             }
                             markTextOnlyModel(provider, model);
-                            writeNotice("warn", "native tool arguments keep arriving unusable — switching this model to the text tool protocol", chalk.yellow("  ⚠ native tool arguments keep arriving unusable — switching this model to the text tool protocol\n"));
+                            writeNotice("warn", "native tool arguments keep arriving unusable — switching this model to the text tool protocol");
                             commitAssistantRetry(assistantText.visible);
                             messages.push(recoveryUserMessage(`Your native ${names || "tool"} call arguments were not usable, so nothing ran. ` +
                                 "Do not repeat that call. Emit exactly one complete fenced ```tool block with valid JSON arguments now."));
@@ -3824,7 +3596,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     const truncatedRoundText = collapseRepeatedText(completion.text ?? "");
                     if (hitOutputLimit && truncatedRoundText.trim() && truncatedBudgetRounds < 2) {
                         truncatedBudgetRounds += 1;
-                        writeNotice("warn", "response hit the output token limit — continuing from where it stopped", chalk.yellow("  ⚠ response hit the output token limit — continuing from where it stopped\n"));
+                        writeNotice("warn", "response hit the output token limit — continuing from where it stopped");
                         messages.push({
                             role: "assistant",
                             content: sanitizeAssistantText(truncatedRoundText),
@@ -3841,18 +3613,18 @@ export async function runAgentTurn(prompt, options = {}) {
                         for (const deferred of deferredToolCalls) {
                             if (!deferred.shown || deferred.call.name === "…")
                                 continue;
-                            writeToolBlocked(deferred.eventId, deferred.call.name, reason, chalk.yellow(`  ⚠ ${reason}\n`));
+                            writeToolBlocked(deferred.eventId, deferred.call.name, reason);
                         }
                         markTextOnlyModel(provider, model);
-                        writeNotice("warn", "provider abandoned a native tool call — switching this model to the text tool protocol", chalk.yellow("  ⚠ provider abandoned a native tool call — switching this model to the text tool protocol\n"));
+                        writeNotice("warn", "provider abandoned a native tool call — switching this model to the text tool protocol");
                     }
                     emptyVisibleRetries += 1;
                     if (emptyVisibleRetries <= 3) {
                         if (assistantText.hasThinking) {
-                            writeNotice("warn", "model produced only thinking — nudging it to take action", chalk.yellow("  ⚠ model produced only thinking — nudging it to take action\n"));
+                            writeNotice("warn", "model produced only thinking — nudging it to take action");
                         }
                         else {
-                            writeNotice("warn", "model returned an empty response — nudging it to answer", chalk.yellow("  ⚠ model returned an empty response — nudging it to answer\n"));
+                            writeNotice("warn", "model returned an empty response — nudging it to answer");
                         }
                         if (assistantText.hasThinking)
                             retryWithoutThinking = true;
@@ -3872,7 +3644,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         messages.push(recoveryUserMessage(buildNudge));
                         continue;
                     }
-                    writeNotice("warn", "model returned an empty response after retries — no answer produced", chalk.yellow("  ⚠ model returned an empty response after retries — no answer produced\n"));
+                    writeNotice("warn", "model returned an empty response after retries — no answer produced");
                     return finishTurn("Model returned an empty response after retries.", step + 1);
                 }
                 else {
@@ -3888,7 +3660,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     if (bare?.call) {
                         call = bare.call;
                         recoveredFromBareJson = true;
-                        writeNotice("info", "recovered an unfenced tool call from bare JSON", chalk.dim("  ℹ recovered an unfenced tool call from bare JSON\n"));
+                        writeNotice("info", "recovered an unfenced tool call from bare JSON");
                     }
                     else if (bare?.argsOnly) {
                         bareArgsOnly = true;
@@ -3900,7 +3672,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     if (bareThink?.call) {
                         call = bareThink.call;
                         recoveredFromBareJson = true;
-                        writeNotice("info", "recovered an unfenced tool call from thinking content", chalk.dim("  ℹ recovered an unfenced tool call from thinking content\n"));
+                        writeNotice("info", "recovered an unfenced tool call from thinking content");
                     }
                     else if (bareThink?.argsOnly) {
                         bareArgsOnly = true;
@@ -3913,9 +3685,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         if (bareToolJsonRetries <= 3) {
                             writeNotice("warn", toolsAttached
                                 ? "tool call missing its name — asking the model to call a tool properly"
-                                : "tool call missing its name/fence — asking the model to re-emit a proper ```tool block", chalk.yellow(toolsAttached
-                                ? "  ⚠ tool call missing its name — asking the model to call a tool properly\n"
-                                : "  ⚠ tool call missing its name/fence — asking the model to re-emit a proper ```tool block\n"));
+                                : "tool call missing its name/fence — asking the model to re-emit a proper ```tool block");
                             commitAssistantRetry(assistantText.visible);
                             messages.push(recoveryUserMessage(isPlanMode && !activePlan
                                 ? toolsAttached
@@ -3938,7 +3708,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         // Exhausted retries — fall through to the normal answer path.
                     }
                     if (/<\|tool_call(?:s_section)?_begin\|>|<\|tool_call_argument_begin\|>|<[|｜]+DSML[|｜]+(?:tool_calls|invoke|parameter)\b|<[|｜]+tool[_▁](?:calls?[_▁]begin|sep)[|｜]+>/i.test(assistantText.visible)) {
-                        writeNotice("warn", "tool call was malformed or cut off — asking the model to retry in JSON form", chalk.yellow("  ⚠ tool call was malformed or cut off — asking the model to retry in JSON form\n"));
+                        writeNotice("warn", "tool call was malformed or cut off — asking the model to retry in JSON form");
                         commitAssistantRetry(assistantText.visible);
                         messages.push(recoveryUserMessage(toolsAttached
                             ? "Your previous tool call was malformed or truncated. " +
@@ -3960,7 +3730,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 const writeResult = await applySalvagedWrite(salvaged);
                                 if (writeResult.ok) {
                                     const lineCount = salvaged.content.split("\n").length;
-                                    writeNotice("info", `tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`, chalk.cyan(`  ℹ tool call was truncated — salvaged ${lineCount} lines to ${salvaged.path}\n`));
+                                    writeNotice("info", `tool call was truncated — salvaged ${lineCount} lines and wrote to ${salvaged.path}`);
                                     commitAssistantRetry(stripThinking(assistantText.visible).visible);
                                     const priorBytes = writeResult.bytesOnDisk;
                                     const salvagedToolName = salvaged.operation === "append" ? "fs.append" : "fs.write";
@@ -3989,7 +3759,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             }
                         }
                         if (truncatedToolRetries <= 3) {
-                            writeNotice("warn", "tool call was cut off (output too long) — asking the model to retry safely", chalk.yellow("  ⚠ tool call was cut off (output too long) — asking the model to retry safely\n"));
+                            writeNotice("warn", "tool call was cut off (output too long) — asking the model to retry safely");
                             commitAssistantRetry(stripThinking(assistantText.visible).visible);
                             messages.push({
                                 role: "user",
@@ -4022,7 +3792,7 @@ export async function runAgentTurn(prompt, options = {}) {
                                 const writeResult = await applySalvagedWrite(salvaged);
                                 if (writeResult.ok) {
                                     const lineCount = salvaged.content.split("\n").length;
-                                    writeNotice("info", `malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}`, chalk.cyan(`  ℹ malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}\n`));
+                                    writeNotice("info", `malformed tool call salvaged — wrote ${lineCount} lines to ${salvaged.path}`);
                                     commitAssistantRetry(stripThinking(assistantText.visible).visible);
                                     messages.push({
                                         role: "user",
@@ -4040,7 +3810,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         malformedFenceRetries += 1;
                         if (malformedFenceRetries <= 3) {
-                            writeNotice("warn", "tool block present but its JSON didn't parse — asking the model to re-emit valid JSON", chalk.yellow("  ⚠ tool block present but its JSON didn't parse — asking the model to re-emit valid JSON\n"));
+                            writeNotice("warn", "tool block present but its JSON didn't parse — asking the model to re-emit valid JSON");
                             commitAssistantRetry(stripThinking(assistantText.visible).visible);
                             messages.push({
                                 role: "user",
@@ -4085,7 +3855,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         consecutiveModelOnlyRounds === 2) {
                         markTextOnlyModel(provider, model);
                         commitAssistantRetry(assistantText.visible);
-                        writeNotice("warn", "model repeatedly returned prose instead of a native tool call — switching this model to the text tool protocol", chalk.yellow("  ⚠ switching this model to the text tool protocol after repeated non-actionable responses\n"));
+                        writeNotice("warn", "model repeatedly returned prose instead of a native tool call — switching this model to the text tool protocol");
                         messages.push(recoveryUserMessage("Native tool calling did not produce an executable call. Continue now with exactly one complete fenced ```tool block. Do not repeat the prior narration."));
                         continue;
                     }
@@ -4222,7 +3992,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 if (beforeTool) {
                     writeAssistantMessage(beforeTool);
                 }
-                else if (deltaParser) {
+                else {
                     emit({ type: "assistant-message", text: "" });
                 }
                 interruptedVisible = "";
@@ -4269,7 +4039,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     activeDeferredToolCalls = deferredToolCalls.slice(0, planCallIndex);
                     deferReason =
                         "Deferred — plan.create must wait until reconnaissance results exist.";
-                    writeNotice("info", "deferring plan.create until reconnaissance results are available", chalk.dim(`  ℹ running ${toRun.length} gathering call(s); ${deferredCount} plan/follow-on call(s) deferred for evidence-based planning\n`));
+                    writeNotice("info", "deferring plan.create until reconnaissance results are available");
                     messages.push({
                         role: "system",
                         content: `The prior response included plan.create before its reconnaissance results existed. ` +
@@ -4283,7 +4053,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     activeDeferredToolCalls = deferredToolCalls.slice(0, 1);
                     deferReason =
                         "Deferred — waiting for plan approval before follow-on tools.";
-                    writeNotice("info", "creating the plan now; deferring follow-on calls until it is approved", chalk.dim(`  ℹ running plan.create from prior reconnaissance; ${deferredCount} follow-on call(s) deferred until after approval\n`));
+                    writeNotice("info", "creating the plan now; deferring follow-on calls until it is approved");
                     messages.push({
                         role: "system",
                         content: `You emitted plan.create alongside ${deferredCount} follow-on call(s). Only plan.create was run; ` +
@@ -4333,7 +4103,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         : sequenceDecision.oscillation
                             ? "This exact action sequence already completed earlier this turn (the agent is oscillating back to finished work). No commands were run again; every one of these results is already in context — synthesize them and either advance to a genuinely new action or finish."
                             : "The same action sequence already ran in the previous model round. No commands were run again; reuse the existing results and choose a materially different next action or finish.";
-                    writeNotice("warn", reason, chalk.yellow(`  ⚠ ${reason}\n`));
+                    writeNotice("warn", reason);
                     const suppressedResults = bound.map((b) => {
                         const duplicate = runIds.has(b.id);
                         const priorObservation = duplicate
@@ -4359,15 +4129,14 @@ export async function runAgentTurn(prompt, options = {}) {
                     for (const { b, resultReason, result } of suppressedResults) {
                         const queued = deferredToolCalls[b.index];
                         const eventId = queued?.eventId ?? `tool-${++nextToolEventId}`;
-                        const toolCallLine = chalk.cyan(`  ▶ ${b.call.name}`) +
-                            chalk.gray(` ${formatToolArgs(b.call)}`);
-                        writeToolCall(eventId, b.call, styleToolChatter(b.call, toolCallLine) + "\n");
+                        writeToolCall(eventId, b.call, styleToolChatter(b.call, chalk.cyan(`  ▶ ${b.call.name}`) +
+                            chalk.gray(` ${formatToolArgs(b.call)}`)) + "\n");
                         alreadyPrintedIds.add(eventId);
                         emit({ type: "tool-start", id: eventId });
                         const output = resultReason.endsWith("\n")
                             ? resultReason
                             : `${resultReason}\n`;
-                        writeToolOutput(eventId, output, chalk.dim(`  ${output}`));
+                        writeToolOutput(eventId, output);
                         emitToolResult(eventId, result, resultReason);
                     }
                     const suppressedCallList = suppressedResults
@@ -4422,13 +4191,13 @@ export async function runAgentTurn(prompt, options = {}) {
                     continue;
                 }
                 if (sequenceDecision.warn && sequenceDecision.warnMessage) {
-                    writeNotice("warn", sequenceDecision.warnMessage, chalk.yellow(`  ⚠ ${sequenceDecision.warnMessage}\n`));
+                    writeNotice("warn", sequenceDecision.warnMessage);
                     messages.push(recoveryUserMessage(sequenceDecision.warnMessage));
                 }
                 // Notice BEFORE tool cards so the transcript reads:
                 // thinking → response → "N tool calls…" → tool cards (not tools then info).
                 if (allCalls.length > 1) {
-                    writeNotice("info", `${allCalls.length} tool calls in this message — read-only in parallel, writes in order (failures do not cancel siblings)`, chalk.dim(`  ℹ ${allCalls.length} tool calls — parallel reads, ordered writes; failures continue\n`));
+                    writeNotice("info", `${allCalls.length} tool calls in this message — read-only in parallel, writes in order (failures do not cancel siblings)`);
                 }
                 // Cards streamed from partial text can predate their arguments. The
                 // executed call is authoritative, so refresh a stale card in place
@@ -4565,7 +4334,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     if (reminded.reminded) {
                         planRemindedAt.add(productiveSteps);
                         // Chrome only — model already has the note on this tool result.
-                        writeNotice("info", PLAN_REMINDER_TOAST, chalk.dim(`  ℹ ${PLAN_REMINDER_TOAST}\n`));
+                        writeNotice("info", PLAN_REMINDER_TOAST);
                     }
                     if (historyNativeCalls.length) {
                         appendToolResult(messages, boundCall.id, toolContent, res.call.name, res.result.ok);
@@ -4701,8 +4470,6 @@ export async function runAgentTurn(prompt, options = {}) {
                         else {
                             session.planApproved.value = true;
                         }
-                        // Re-derive pause policy from the new plan kind (coding builds
-                        // must not hard-pause even if the free-text prompt was generic).
                         const kindArg = typeof res.call.args.kind === "string"
                             ? res.call.args.kind
                             : undefined;
@@ -4710,10 +4477,6 @@ export async function runAgentTurn(prompt, options = {}) {
                             buildLike,
                             planKind: kindArg,
                         });
-                        pauseMode = progressPauseMode({
-                            codingSession,
-                            autoConfirm: Boolean(options.autoConfirm),
-                        });
                     }
                     // User Esc/Ctrl+C only — never cancel siblings because a delete failed
                     // or a confirm was declined; the model must see every tool result.
@@ -4753,13 +4516,13 @@ export async function runAgentTurn(prompt, options = {}) {
                             if (intent.state === "in_progress")
                                 batchRemindCalls.add(intent.call);
                         }
-                        writeNotice("warn", multiOpenToast(openIds.length), chalk.yellow(`  ⚠ ${multiOpenToast(openIds.length)}\n`));
+                        writeNotice("warn", multiOpenToast(openIds.length));
                     }
                     else if (isSimultaneousTaskAdvance(intents)) {
                         const signature = batchUpdateSignature(intents);
                         if (session.pendingTaskBatch.value === signature) {
                             session.pendingTaskBatch.value = undefined;
-                            writeNotice("info", "confirmed batch task update — applying", chalk.dim("  ℹ confirmed batch task update — applying\n"));
+                            writeNotice("info", "confirmed batch task update — applying");
                         }
                         else {
                             session.pendingTaskBatch.value = signature;
@@ -4773,7 +4536,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             for (const intent of intents)
                                 batchRemindCalls.add(intent.call);
                             const advancing = distinctAdvancingTaskIds(intents).length;
-                            writeNotice("warn", multiUpdateToast(advancing), chalk.yellow(`  ⚠ ${multiUpdateToast(advancing)}\n`));
+                            writeNotice("warn", multiUpdateToast(advancing));
                         }
                     }
                     else {
@@ -4782,7 +4545,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
                 const groups = groupToolCallsForExecution(allCalls, isParallelSafe, PARALLEL_LIMIT);
                 for (const group of groups) {
-                    if (aborted || awaitingPlanApproval || governorPauseReason)
+                    if (aborted || awaitingPlanApproval)
                         break;
                     if (group.length === 1) {
                         const call = group[0];
@@ -4830,9 +4593,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         ? "Cancelled — turn aborted before this call ran."
                         : awaitingPlanApproval
                             ? "Deferred — waiting for plan approval."
-                            : governorPauseReason
-                                ? `Deferred — progress governor paused execution: ${governorPauseReason}`
-                                : "Cancelled — not executed.";
+                            : "Cancelled — not executed.";
                     const result = {
                         ok: false,
                         output: reason,
@@ -4870,8 +4631,7 @@ export async function runAgentTurn(prompt, options = {}) {
                     toRun.length === bound.length &&
                     actionSequenceExecuted === allCalls.length &&
                     !aborted &&
-                    !awaitingPlanApproval &&
-                    !governorPauseReason, actionSequenceOutcome);
+                    !awaitingPlanApproval, actionSequenceOutcome);
                 consecutiveSynthesizedRounds =
                     !aborted && actionSequenceExecuted > 0 && roundSuppressedCount === actionSequenceExecuted
                         ? consecutiveSynthesizedRounds + 1