@pentoshi/clai 3.8.21 → 3.8.23

package/dist/agent/runner.js

@@ -13,7 +13,7 @@ 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, repairToolProtocol, } from "./tool-history.js";
+import { appendAssistantWithTools, ensureUniqueToolCallIds, appendToolResult, assertValidToolProtocol, fillMissingToolResults, repairToolProtocol, } from "./tool-history.js";
 import { formatViewportHint, registerViewport } from "../ui/output-pane.js";
 import { compactMessagesWithSummary, estimateMessagesTokens, shouldApplyAutoCompact, COMPACTION_MEMORY_PREFIX, PLAN_IMPLEMENT_MEMORY_PREFIX, isCompactionMemoryMessage, } from "./context-manager.js";
 import { buildContextBreakdown, contextBreakdownAuditPayload, } from "./context-breakdown.js";
@@ -37,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";
@@ -793,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({
@@ -911,13 +921,40 @@ export async function runAgentTurn(prompt, options = {}) {
                 environmentChanged: retryEnvironmentChanged,
                 ...(retryReason ? { retryReason } : {}),
             });
+            // Reuse prior SUCCESS instead of re-running or returning ok=false.
+            // Models often thrash "tools failed after resume" and re-call the same
+            // tool.check/fs.list; answering with a fake failure made the thrash worse.
+            const cachedSuccess = loopGuard.getCachedSuccessOutput(call.name, call.args);
+            if (cachedSuccess !== undefined && loopGuard.hasSucceeded(call.name, call.args)) {
+                const reuseNote = loopCheck.reason ??
+                    `${call.name} already succeeded with identical arguments earlier this turn — reusing that result. Do not re-call it; proceed to the next step.`;
+                writeNotice("info", reuseNote, chalk.dim(`  ℹ ${reuseNote}\n`));
+                const body = `Prior successful ${call.name} result (reused; identical args — tools are working):\n` +
+                    cachedSuccess;
+                const result = { ok: true, output: body, exitCode: 0 };
+                emitToolResult(toolEventId, result, reuseNote);
+                return {
+                    ok: true,
+                    call,
+                    result,
+                    contextOutput: body,
+                };
+            }
             if (loopCheck.block) {
                 const reason = loopCheck.reason ??
                     `${call.name} was already called with the same arguments. Use the prior result and choose a different next step.`;
                 writeNotice("warn", reason, chalk.yellow(`  ⚠ ${reason}\n`));
-                const result = { ok: false, output: reason, exitCode: 1 };
+                // Prefer ok=true when we previously succeeded but have no cache body,
+                // so the model does not treat loop-guard as a tool outage.
+                const softOk = loopGuard.hasSucceeded(call.name, call.args);
+                const result = {
+                    ok: softOk,
+                    output: reason,
+                    exitCode: softOk ? 0 : 1,
+                };
+                emitToolResult(toolEventId, result, reason);
                 return {
-                    ok: false,
+                    ok: softOk,
                     call,
                     result,
                     contextOutput: reason,
@@ -1767,30 +1804,55 @@ 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);
+            loopGuard.recordAttempt(step, call.name, call.args, result.ok, result.exitCode, result.output);
             // Evidence for verify-before-done: only successful real work counts.
             if (result.ok && isEvidenceWorkTool(call.name)) {
                 const liveAfter = await loadPlan(session.sessionId).catch(() => undefined);
@@ -2033,14 +2095,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;
@@ -3000,12 +3101,29 @@ export async function runAgentTurn(prompt, options = {}) {
                 // Preserve model/document order. In particular, never move a later
                 // in_progress transition ahead of the preceding work or done receipt;
                 // doing so inverts dependency order and desynchronizes the task pane.
+                // Re-id empty/duplicate native ids BEFORE building toRun/history so
+                // assistant toolCalls and role:tool results always share the same id.
+                // Mismatched ids make results look orphaned → repair injects placeholders
+                // → model thrash-retries tools that already succeeded in the UI.
+                const historyNativeCalls = ensureUniqueToolCallIds(bound.map((b) => b.native));
+                for (let i = 0; i < bound.length; i++) {
+                    const fixed = historyNativeCalls[i];
+                    bound[i] = {
+                        ...bound[i],
+                        id: fixed.id,
+                        native: fixed,
+                    };
+                }
+                // Re-bind toRun to the rewritten bound entries (by original call identity).
+                toRun = toRun.map((old) => {
+                    const match = bound.find((b) => b.call === old.call);
+                    return match ?? old;
+                });
                 // Re-index toRun positions for UI callIds[] (0..n-1 this turn).
                 toRun = toRun.map((b, index) => ({ ...b, index }));
                 const allCalls = toRun.map((b) => b.call);
                 /** Stable call→Bound map (object identity; no indexOf for result ids). */
                 const callToBound = new Map(toRun.map((b) => [b.call, b]));
-                const historyNativeCalls = bound.map((b) => b.native);
                 const runIds = new Set(toRun.map((b) => b.id));
                 // Notice BEFORE tool cards so the transcript reads:
                 // thinking → response → "N tool calls…" → tool cards (not tools then info).
@@ -3216,6 +3334,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.
@@ -3335,6 +3466,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";