@pentoshi/clai 3.8.20 → 3.8.22

package/dist/agent/runner.js

@@ -8,13 +8,16 @@ import { randomUUID } from "node:crypto";
 import { jobManager } from "../tools/jobs.js";
 import { agentModeDirective, planModeDirective, renderAgentSystemPrompt, renderCompactAgentSystemPrompt, scratchDirFor, toolNudge, } from "../prompts/index.js";
 import { getConfig } from "../store/config.js";
+import { beginSessionWorkspace, getActiveSessionWorkspace, } from "../store/session-workspace.js";
 import { groqInputTokenBudget } from "../llm/groq.js";
 import { classifyToolCall, isPentestToolCall, scopeHint, scopeTargetForToolCall, } from "../safety/classifier.js";
 import { availableToolNames, normalizeToolCall, runToolCall, BATCH_SAFE_TOOLS, } from "../tools/registry.js";
 import { getToolDefinitions, getCompactToolDefinitions, PLAN_TOOL_NAMES, } from "../tools/definitions.js";
-import { appendAssistantWithTools, appendToolResult, assertValidToolProtocol, fillMissingToolResults, } from "./tool-history.js";
+import { appendAssistantWithTools, appendToolResult, assertValidToolProtocol, fillMissingToolResults, repairToolProtocol, } from "./tool-history.js";
 import { formatViewportHint, registerViewport } from "../ui/output-pane.js";
-import { compactMessagesWithSummary, estimateMessagesTokens, AUTO_COMPACT_TOKEN_BUDGET, shouldApplyAutoCompact, COMPACTION_MEMORY_PREFIX, PLAN_IMPLEMENT_MEMORY_PREFIX, isCompactionMemoryMessage, } from "./context-manager.js";
+import { compactMessagesWithSummary, estimateMessagesTokens, shouldApplyAutoCompact, COMPACTION_MEMORY_PREFIX, PLAN_IMPLEMENT_MEMORY_PREFIX, isCompactionMemoryMessage, } from "./context-manager.js";
+import { buildContextBreakdown, contextBreakdownAuditPayload, } from "./context-breakdown.js";
+import { autoCompactTriggerTokens, dedupeToolContextOutput, freeTierGuardNotices, getReliabilityPolicy, resolveStepMaxTokens, } from "./reliability-policy.js";
 import { auditLog } from "../store/logs.js";
 import { loadProjectContext } from "../store/project.js";
 import { loadScope, isScopeActive } from "../store/scope.js";
@@ -34,6 +37,7 @@ import { fsWrite, isOutsideWorkingDirectory, resolveFsToolPath, } from "../tools
 import { stripSentinelTokens, parseToolCall, recognizeBareToolJson, looksLikeTruncatedToolCall, salvageTruncatedWrite, salvageTruncatedWriteFromNative, countToolFences, parseAllToolCalls, groupToolCallsForExecution, buildTurnHistory, collapseRepeatedText, textBeforeToolCall, formatToolArgs, looksLikePentestTask, looksLikeBuildTask, looksLikeInformationalQuery, looksLikeIdleOrSocialPrompt, looksLikeActionNarration, looksLikeWebActionNarration, looksLikePlanNarration, looksLikeErrorDiagnosisWithFixIntent, localHttpProbeIsFailure, localHttpProbeIsSuccess, requiresFreshWebSearch, freshnessGuardMessage, 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, handlePlanTool, resolvePlanTaskId, } from "./plan-tool.js";
 import { absorbLooseWorkIntoLedger, applyDestinationCwd, canMarkTaskDone, hasLocalRuntimeProof, hasRemoteWorkProof, isDevServerCall, isEvidenceWorkTool, isFeatureImplementationCall, isPackageInstallCommand, isPlanPreflightTool, isPortListeningOutput, isReadOnlyReconTool, isRemoteActiveTestCall, isRemoteObservationTask, isRemoteReconToolCall, isRuntimeObservationTask, isScaffoldCreateCommand, isServerReadyOutput, ledgerFromTaskEvidence, pickPendingTaskForToolCall, recordTaskWorkSuccess, resolveUserDestinationHint, taskEvidenceFromLedger, TOOL_ABORT_GRACE_MS, toolHardBudgetMs, toolStallBudgetMs, userAskedForFeatureApp, } from "./task-evidence.js";
 import { buildSessionStateBlock, inferNextHint, upsertSessionStateMessage, } from "./session-state.js";
@@ -85,9 +89,17 @@ export async function runAgentTurn(prompt, options = {}) {
         if (/\/output\b|open full output|Ctrl\+O or|\.clai\/outputs/i.test(cleaned)) {
             return;
         }
-        if (cleaned.length > 64) {
-            const short = cleaned.match(/^[\w./-]+/);
-            cleaned = short ? short[0] : cleaned.slice(0, 61) + "…";
+        // API key rotation / retry lines need more room than tool-name chips.
+        const keyLine = /^(using |switching |⏳ |all .+ API keys)/i.test(cleaned);
+        const maxLen = keyLine ? 96 : 64;
+        if (cleaned.length > maxLen) {
+            if (keyLine) {
+                cleaned = cleaned.slice(0, maxLen - 1) + "…";
+            }
+            else {
+                const short = cleaned.match(/^[\w./-]+/);
+                cleaned = short ? short[0] : cleaned.slice(0, maxLen - 3) + "…";
+            }
         }
         emit({ type: "status", text: cleaned || "working" });
         if (writesDirectly)
@@ -278,6 +290,11 @@ export async function runAgentTurn(prompt, options = {}) {
         };
         let lastAnswer = "";
         const session = options.session ?? createSessionPolicy();
+        // One-shot CLI / tests that never entered TUI/REPL still need an isolated
+        // scratch+output workspace. No-op when a session already bound one.
+        if (!getActiveSessionWorkspace()) {
+            beginSessionWorkspace();
+        }
         // Active plan context
         // If this session already has a plan, inject it so the model keeps it in
         // context. When the user has approved it (via /implement) we instruct the
@@ -323,11 +340,16 @@ export async function runAgentTurn(prompt, options = {}) {
             setActiveProjectRootIfValid(discoveredProjects[0]);
         }
         const buildSystemContent = (native) => {
+            const reliability = getReliabilityPolicy();
             const sections = [
                 (useCompactSystemPrompt
                     ? renderCompactAgentSystemPrompt
                     : renderAgentSystemPrompt)(toolNames.join(", "), {
                     nativeTools: native,
+                    // E6: slim native constitution when API tool schemas are attached.
+                    ...(native
+                        ? { slimNative: reliability.slimNativePrompt }
+                        : {}),
                 }),
             ];
             if (projectContext) {
@@ -772,6 +794,15 @@ 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({
@@ -1746,27 +1777,52 @@ export async function runAgentTurn(prompt, options = {}) {
                         ((call.name === "shell.exec" || call.name === "shell.start") &&
                             isPackageInstallCommand(String(call.args.command ?? "")));
             }
-            const governed = governProgress(governorState, "activity", {
-                evidenceDelta: newEvidence.length,
-                hypothesisDelta,
-                repetitionScore: loopGuard.getAttemptCount(call.name, call.args) > 1 ? 1 : 0,
-                policy: {
-                    resourceEnvelope: Math.max(12, maxSteps),
-                    emergencyCeiling: Math.max(70, maxSteps * 3),
-                    reflectionAfterNoDelta: 3,
-                    pauseAfterNoDelta: 6,
-                    repetitionThreshold: 0.8,
-                },
-            });
-            governorState = governed.state;
-            if (governed.recommendation === "reflect") {
-                deferredPostToolMessages.push({
-                    role: "system",
-                    content: `PROGRESS GOVERNOR: ${governed.reason}. Reassess the current premise and choose the next action that can produce criterion-linked evidence.`,
+            // Protocol-repair placeholders are not live work — never let them
+            // accumulate into a mid-turn pause (they used to look like failed tools).
+            if (!isProtocolPlaceholderOutput(result.output)) {
+                const governed = governProgress(governorState, "activity", {
+                    evidenceDelta: newEvidence.length,
+                    hypothesisDelta,
+                    repetitionScore: loopGuard.getAttemptCount(call.name, call.args) > 1 ? 1 : 0,
+                    policy: {
+                        resourceEnvelope: Math.max(12, maxSteps),
+                        // Coding builds get a much higher ceiling; never use the tight
+                        // default that stopped multi-file scaffolds after a handful of steps.
+                        emergencyCeiling: codingSession
+                            ? Math.max(200, maxSteps * 5)
+                            : Math.max(70, maxSteps * 3),
+                        reflectionAfterNoDelta: codingSession ? 5 : 3,
+                        pauseAfterNoDelta: codingSession ? 24 : 6,
+                        repetitionThreshold: 0.8,
+                    },
                 });
-            }
-            else if (governed.recommendation === "paused_budget") {
-                governorPauseReason = governed.reason;
+                governorState = governed.state;
+                if (governed.recommendation === "reflect") {
+                    deferredPostToolMessages.push({
+                        role: "system",
+                        content: `PROGRESS GOVERNOR: ${governed.reason}. Reassess the current premise and choose the next action that can produce criterion-linked evidence.` +
+                            (codingSession
+                                ? " Keep working — coding builds do not stop for a continue prompt."
+                                : ""),
+                    });
+                }
+                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);
@@ -1911,6 +1967,11 @@ export async function runAgentTurn(prompt, options = {}) {
         // Align with /compact default: small recency + dense memory (not keepRecent=6 fat tails).
         const AUTO_COMPACT_KEEP_RECENT = 2;
         let lastCompactionMsgCount = 0;
+        /** E5: identical tool bodies within this turn → pointer instead of re-append. */
+        const toolResultHashes = new Map();
+        /** E4: consecutive free-tier stream failures this turn. */
+        let freeTierConsecutiveFailures = 0;
+        let freeTierLargeContextWarned = false;
         const summarizeForCompaction = async (summaryPrompt) => {
             const response = await completeWithProvider({
                 provider,
@@ -1928,7 +1989,9 @@ export async function runAgentTurn(prompt, options = {}) {
         };
         async function maybeAutoCompact(reason, force = false) {
             const beforeTokens = estimateMessagesTokens(messages);
-            if (!force && beforeTokens < AUTO_COMPACT_TOKEN_BUDGET)
+            // E1: soft early compact (default 70k) while hard ceiling remains 100k.
+            const compactTrigger = autoCompactTriggerTokens();
+            if (!force && beforeTokens < compactTrigger)
                 return;
             if (messages.length <= AUTO_COMPACT_KEEP_RECENT + 2)
                 return;
@@ -2005,14 +2068,53 @@ export async function runAgentTurn(prompt, options = {}) {
             // advances when the previous iteration actually executed a tool.
             step = productiveSteps;
             if (governorPauseReason) {
-                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);
+                // 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;
@@ -2057,159 +2159,222 @@ export async function runAgentTurn(prompt, options = {}) {
                     ({ dialect: toolDialect, native: nativeToolsActive } =
                         resolveNativeTools(provider, model));
                     if (messages[0]?.role === "system") {
-                        messages[0] = {
-                            role: "system",
-                            content: composeCurrentSystemPrompt(nativeToolsActive),
-                        };
+                        // Recompose only when content actually changes (hour-stable env clock
+                        // keeps the constitution prefix identical across steps, which helps
+                        // provider prompt caching and avoids needless object churn).
+                        const nextSystem = composeCurrentSystemPrompt(nativeToolsActive);
+                        if (messages[0].content !== nextSystem) {
+                            messages[0] = {
+                                role: "system",
+                                content: nextSystem,
+                            };
+                        }
                     }
                     const turnTools = selectToolDefs(nativeToolsActive, useCompactSystemPrompt);
                     toolsAttached = Boolean(turnTools?.length);
+                    const contextBreakdown = buildContextBreakdown(messages, toolsAttached ? turnTools : undefined);
+                    // E4: advisory only — never blocks free-tier users.
+                    if (!freeTierLargeContextWarned) {
+                        const notices = freeTierGuardNotices({
+                            provider,
+                            estimatedInputTokens: contextBreakdown.estimatedTotalTokens,
+                            consecutiveFailures: freeTierConsecutiveFailures,
+                        });
+                        for (const notice of notices) {
+                            if (notice.includes("Large context")) {
+                                freeTierLargeContextWarned = true;
+                            }
+                            writeNotice("info", notice, chalk.dim(`  ℹ ${notice}\n`));
+                        }
+                    }
                     await auditLog("agent.turn", {
                         provider,
                         model,
                         tool_protocol: toolsAttached ? "native" : "text",
                         dialect: toolDialect,
                         step,
+                        // Metadata-only composition metrics (no prompt/tool text).
+                        ...contextBreakdownAuditPayload(contextBreakdown),
+                        compactTriggerTokens: autoCompactTriggerTokens(),
+                        maxTokensBudget: resolveStepMaxTokens({
+                            nativeToolsActive,
+                            toolsAttached,
+                            recoveryNudge: retryWithoutThinking,
+                        }),
                     });
+                    // Resume / mid-turn abort can leave orphan tool rows or a user
+                    // "continue" before tool results. Heal first so multi-key retry and
+                    // history reloads don't hard-fail on protocol asserts.
+                    // Heal once per step if needed; silent (no toast) — placeholders are
+                    // ok=true so the model doesn't thrash on fake exit=130 failures.
+                    repairToolProtocol(messages);
                     assertValidToolProtocol(messages);
-                    completion = await streamWithProvider({
-                        provider,
-                        model,
-                        allowModelFallback: false,
-                        messages,
-                        temperature: /minimax-m3/i.test(model) ? 1.0 : 0.2,
-                        maxTokens: 32_768,
-                        signal: options.signal,
-                        thinking: retryWithoutThinking
-                            ? { ...config.thinking, enabled: false, effort: "low" }
-                            : config.thinking,
-                        ...(toolsAttached
-                            ? {
-                                tools: turnTools,
-                                toolChoice: freshWebSearchRequired && !sawFreshWebSearch
-                                    ? { type: "function", name: "web.search" }
-                                    : "auto",
-                                parallelToolCalls: true,
-                                // P2-3: emit tool cards as soon as the function name arrives.
-                                onToolCallDelta: (delta) => {
-                                    if (!delta.name)
-                                        return;
-                                    const name = fromWireName(delta.name) ?? delta.name;
-                                    const existing = deferredToolCalls[delta.index];
-                                    if (existing) {
-                                        if (delta.argumentsBytes &&
-                                            delta.argumentsBytes >= 4096 &&
-                                            !writesDirectly) {
-                                            emit({
-                                                type: "status",
-                                                text: `${name} (${Math.round(delta.argumentsBytes / 1024)}KB args)`,
+                    // E3: adaptive completion budget (still large enough for writes).
+                    const stepMaxTokens = resolveStepMaxTokens({
+                        nativeToolsActive,
+                        toolsAttached,
+                        recoveryNudge: retryWithoutThinking,
+                    });
+                    try {
+                        completion = await streamWithProvider({
+                            provider,
+                            model,
+                            allowModelFallback: false,
+                            messages,
+                            temperature: /minimax-m3/i.test(model) ? 1.0 : 0.2,
+                            maxTokens: stepMaxTokens,
+                            signal: options.signal,
+                            thinking: retryWithoutThinking
+                                ? { ...config.thinking, enabled: false, effort: "low" }
+                                : config.thinking,
+                            ...(toolsAttached
+                                ? {
+                                    tools: turnTools,
+                                    toolChoice: freshWebSearchRequired && !sawFreshWebSearch
+                                        ? { type: "function", name: "web.search" }
+                                        : "auto",
+                                    parallelToolCalls: true,
+                                    // P2-3: emit tool cards as soon as the function name arrives.
+                                    onToolCallDelta: (delta) => {
+                                        if (!delta.name)
+                                            return;
+                                        const name = fromWireName(delta.name) ?? delta.name;
+                                        const existing = deferredToolCalls[delta.index];
+                                        if (existing) {
+                                            if (delta.argumentsBytes &&
+                                                delta.argumentsBytes >= 4096 &&
+                                                !writesDirectly) {
+                                                emit({
+                                                    type: "status",
+                                                    text: `${name} (${Math.round(delta.argumentsBytes / 1024)}KB args)`,
+                                                });
+                                            }
+                                            return;
+                                        }
+                                        // Ensure slots are dense so index maps to deferredToolCalls[i].
+                                        while (deferredToolCalls.length < delta.index) {
+                                            deferredToolCalls.push({
+                                                eventId: `tool-${++nextToolEventId}`,
+                                                call: { name: "…", args: {} },
+                                                rendered: "",
                                             });
                                         }
-                                        return;
+                                        const call = normalizeToolCall({
+                                            name,
+                                            args: {},
+                                        });
+                                        const eventId = `tool-${++nextToolEventId}`;
+                                        callIds.push(eventId);
+                                        alreadyPrintedIds.add(eventId);
+                                        const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
+                                            chalk.gray(` ${formatToolArgs(call)}`);
+                                        const entry = {
+                                            eventId,
+                                            call,
+                                            rendered: styleToolChatter(call, toolCallLine) + "\n",
+                                        };
+                                        if (deferredToolCalls.length === delta.index) {
+                                            deferredToolCalls.push(entry);
+                                        }
+                                        else {
+                                            deferredToolCalls[delta.index] = entry;
+                                        }
+                                        streamedCallsCount = Math.max(streamedCallsCount, deferredToolCalls.length);
+                                        if (!writesDirectly) {
+                                            emit({ type: "status", text: call.name });
+                                        }
+                                        else {
+                                            spinner.stop();
+                                            spinner = startThinkingSpinner(`tool ${call.name}…`, options.signal);
+                                        }
+                                    },
+                                }
+                                : {}),
+                        }, (token) => {
+                            deltaParser?.push(token);
+                            generatedTokens += 1;
+                            accumulatedText += token;
+                            // Early UI cards from text fences only when native tools are off
+                            // (native args stream as structured deltas, not prose).
+                            if (!toolsAttached) {
+                                const parsedCalls = parseAllToolCalls(accumulatedText);
+                                if (parsedCalls.length > streamedCallsCount) {
+                                    if (writesDirectly) {
+                                        spinner.stop();
                                     }
-                                    // Ensure slots are dense so index maps to deferredToolCalls[i].
-                                    while (deferredToolCalls.length < delta.index) {
+                                    while (streamedCallsCount < parsedCalls.length) {
+                                        const call = parsedCalls[streamedCallsCount];
+                                        const eventId = `tool-${++nextToolEventId}`;
+                                        callIds.push(eventId);
+                                        alreadyPrintedIds.add(eventId);
+                                        const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
+                                            chalk.gray(` ${formatToolArgs(call)}`);
                                         deferredToolCalls.push({
-                                            eventId: `tool-${++nextToolEventId}`,
-                                            call: { name: "…", args: {} },
-                                            rendered: "",
+                                            eventId,
+                                            call,
+                                            rendered: styleToolChatter(call, toolCallLine) + "\n",
                                         });
+                                        if (!writesDirectly) {
+                                            emit({ type: "status", text: call.name });
+                                        }
+                                        streamedCallsCount += 1;
                                     }
-                                    const call = normalizeToolCall({
-                                        name,
-                                        args: {},
-                                    });
-                                    const eventId = `tool-${++nextToolEventId}`;
-                                    callIds.push(eventId);
-                                    alreadyPrintedIds.add(eventId);
-                                    const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                                        chalk.gray(` ${formatToolArgs(call)}`);
-                                    const entry = {
-                                        eventId,
-                                        call,
-                                        rendered: styleToolChatter(call, toolCallLine) + "\n",
-                                    };
-                                    if (deferredToolCalls.length === delta.index) {
-                                        deferredToolCalls.push(entry);
-                                    }
-                                    else {
-                                        deferredToolCalls[delta.index] = entry;
-                                    }
-                                    streamedCallsCount = Math.max(streamedCallsCount, deferredToolCalls.length);
-                                    if (!writesDirectly) {
-                                        emit({ type: "status", text: call.name });
+                                    if (writesDirectly) {
+                                        spinner = startThinkingSpinner(`generating response (${generatedTokens} tokens)`, options.signal);
                                     }
-                                    else {
-                                        spinner.stop();
-                                        spinner = startThinkingSpinner(`tool ${call.name}…`, options.signal);
-                                    }
-                                },
-                            }
-                            : {}),
-                    }, (token) => {
-                        deltaParser?.push(token);
-                        generatedTokens += 1;
-                        accumulatedText += token;
-                        // Early UI cards from text fences only when native tools are off
-                        // (native args stream as structured deltas, not prose).
-                        if (!toolsAttached) {
-                            const parsedCalls = parseAllToolCalls(accumulatedText);
-                            if (parsedCalls.length > streamedCallsCount) {
-                                if (writesDirectly) {
-                                    spinner.stop();
-                                }
-                                while (streamedCallsCount < parsedCalls.length) {
-                                    const call = parsedCalls[streamedCallsCount];
-                                    const eventId = `tool-${++nextToolEventId}`;
-                                    callIds.push(eventId);
-                                    alreadyPrintedIds.add(eventId);
-                                    const toolCallLine = chalk.cyan(`  ▶ ${call.name}`) +
-                                        chalk.gray(` ${formatToolArgs(call)}`);
-                                    deferredToolCalls.push({
-                                        eventId,
-                                        call,
-                                        rendered: styleToolChatter(call, toolCallLine) + "\n",
-                                    });
-                                    if (!writesDirectly) {
-                                        emit({ type: "status", text: call.name });
-                                    }
-                                    streamedCallsCount += 1;
                                 }
-                                if (writesDirectly) {
-                                    spinner = startThinkingSpinner(`generating response (${generatedTokens} tokens)`, options.signal);
+                            }
+                            if (!sawReasoning && /<think/i.test(token)) {
+                                sawReasoning = true;
+                                inThinking = true;
+                                spinner.setLabel("thinking");
+                                if (!writesDirectly)
+                                    emit({ type: "status", text: "thinking" });
+                            }
+                            if (/<\/think>/i.test(token)) {
+                                inThinking = false;
+                                spinner.setLabel("generating response (0 tokens)");
+                                generatedTokens = 0;
+                            }
+                            if (inThinking) {
+                                const cleaned = token.replace(/<\/?think[^>]*>/gi, "");
+                                if (cleaned) {
+                                    spinner.pushPreview(cleaned);
+                                    const approx = cleaned.split(/\s+/).filter(Boolean).length;
+                                    if (approx > 0)
+                                        spinner.bumpReasoning(approx);
                                 }
                             }
-                        }
-                        if (!sawReasoning && /<think/i.test(token)) {
-                            sawReasoning = true;
-                            inThinking = true;
-                            spinner.setLabel("thinking");
-                            if (!writesDirectly)
-                                emit({ type: "status", text: "thinking" });
-                        }
-                        if (/<\/think>/i.test(token)) {
-                            inThinking = false;
-                            spinner.setLabel("generating response (0 tokens)");
-                            generatedTokens = 0;
-                        }
-                        if (inThinking) {
-                            const cleaned = token.replace(/<\/?think[^>]*>/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)`);
+                                }
                             }
-                        }
-                        else {
-                            if (generatedTokens % 10 === 0) {
-                                spinner.setLabel(`generating response (${generatedTokens} tokens)`);
+                        }, (status) => {
+                            spinner.stop();
+                            writeStatus(status, chalk.dim(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`));
                             }
+                        });
+                        freeTierConsecutiveFailures = 0;
+                    }
+                    catch (streamError) {
+                        // E4: track free-tier failures for advisory notices (never blocks).
+                        freeTierConsecutiveFailures += 1;
+                        for (const notice of freeTierGuardNotices({
+                            provider,
+                            estimatedInputTokens: contextBreakdown.estimatedTotalTokens,
+                            consecutiveFailures: freeTierConsecutiveFailures,
+                        })) {
+                            if (notice.includes("Large context"))
+                                continue; // already shown above
+                            writeNotice("warn", notice, chalk.yellow(`  ⚠ ${notice}\n`));
                         }
-                    }, (status) => {
-                        spinner.stop();
-                        writeStatus(status, chalk.dim(status));
-                    });
+                        throw streamError;
+                    }
                 }
                 finally {
                     // Always clear the spinner — abort, network error, or success.
@@ -2977,9 +3142,17 @@ export async function runAgentTurn(prompt, options = {}) {
                         planCreatedThisTurn = true;
                     }
                     productiveSteps += 1;
+                    // E5: collapse identical large tool bodies within this turn to a pointer.
+                    const deduped = dedupeToolContextOutput({
+                        content: res.contextOutput,
+                        toolName: res.call.name,
+                        artifactPath: res.result.outputPath,
+                        seenHashes: toolResultHashes,
+                    });
+                    const contextForHistory = deduped.content;
                     // Soft plan-mode note on tool payloads only (never a user message).
                     // Stop once a plan with tasks exists so we don't nag after plan.create.
-                    let toolContent = `Tool ${res.call.name} result (exit=${res.result.exitCode ?? 0}, ok=${res.result.ok}):\n${res.contextOutput}`;
+                    let toolContent = `Tool ${res.call.name} result (exit=${res.result.exitCode ?? 0}, ok=${res.result.ok}):\n${contextForHistory}`;
                     const reminded = maybeAppendPlanModeReminder(toolContent, {
                         isPlanMode,
                         planApproved: session.planApproved.value,
@@ -3117,6 +3290,19 @@ 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;
+                        codingSession = codingSessionFromContext({
+                            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.
@@ -3236,6 +3422,8 @@ export async function runAgentTurn(prompt, options = {}) {
                 }
             }
         }
+        // Hard iteration ceiling (hundreds of steps) — rare. Mid-turn governor
+        // pauses already confirm for non-coding; coding never hard-pauses there.
         const richSummary = await buildRichStopSummary(messages, session, productiveSteps);
         lastAnswer = richSummary;
         outcomeState.outcome.status = "paused_budget";