@pentoshi/clai 3.8.20 → 3.8.21

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";
@@ -85,9 +88,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 +289,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 +339,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) {
@@ -1911,6 +1932,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 +1954,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;
@@ -2057,159 +2085,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 });
-                                    }
-                                    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 });
+                                    if (writesDirectly) {
+                                        spinner = startThinkingSpinner(`generating response (${generatedTokens} tokens)`, options.signal);
                                     }
-                                    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 +3068,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,