@visorcraft/idlehands 2.3.2 → 2.3.4

package/dist/agent.js

@@ -2,13 +2,13 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { DEFAULT_SUB_AGENT_RESULT_TOKEN_CAP, DEFAULT_SUB_AGENT_SYSTEM_PROMPT, MCP_TOOLS_REQUEST_TOKEN, } from './agent/constants.js';
 import { AgentLoopBreak } from './agent/errors.js';
-import { execRcShouldSignalFailure, looksLikeReadOnlyExecCommand, detectSedAsRead, extractGrepPattern, detectCatHeadTailAsRead, extractTestFilter, extractGrepTargetFile, extractLogFilePath, readOnlyExecCacheable, withCachedExecObservationHint, withReplayedExecHint, } from './agent/exec-helpers.js';
+import { execRcShouldSignalFailure, looksLikeReadOnlyExecCommand, detectSedAsRead, extractGrepPattern, detectCatHeadTailAsRead, extractFilePathFromReadCommand, extractTestFilter, extractGrepTargetFile, extractLogFilePath, readOnlyExecCacheable, withCachedExecObservationHint, withReplayedExecHint, } from './agent/exec-helpers.js';
 import { generateMinimalDiff, toolResultSummary, execCommandFromSig, formatDurationMs, looksLikePlanningNarration, capTextByApproxTokens, sanitizePathsInMessage, digestToolResult, } from './agent/formatting.js';
 import { autoPickModel } from './agent/model-pick.js';
 import { reviewArtifactKeys, looksLikeCodeReviewRequest, looksLikeReviewRetrievalRequest, retrievalAllowsStaleArtifact, parseReviewArtifactStalePolicy, parseReviewArtifact, reviewArtifactStaleReason, gitHead, normalizeModelsResponse, } from './agent/review-artifact.js';
 import { capApprovalMode, ensureInformativeAssistantText, isContextWindowExceededError, makeAbortController, userContentToText, userDisallowsDelegation, } from './agent/session-utils.js';
 import { buildSubAgentContextBlock, extractLensBody } from './agent/subagent-context.js';
-import { parseToolCallsFromContent, getMissingRequiredParams, getArgValidationIssues, stripMarkdownFences, parseJsonArgs, } from './agent/tool-calls.js';
+import { parseToolCallsFromContent, getMissingRequiredParams, getArgValidationIssues, stripUnknownArgs, stripMarkdownFences, parseJsonArgs, } from './agent/tool-calls.js';
 import { resolveToolAlias } from './agent/tool-name-alias.js';
 import { buildDefaultSystemPrompt } from './agent/prompt-builder.js';
 import { LeakDetector } from './security/leak-detector.js';
@@ -25,7 +25,7 @@ import { OpenAIClient } from './client.js';
 import { loadProjectContext } from './context.js';
 import { loadGitContext, isGitDirty, stashWorkingTree } from './git.js';
 import { selectHarness } from './harnesses.js';
-import { enforceContextBudget, stripThinking, estimateTokensFromMessages, estimateToolSchemaTokens, } from './history.js';
+import { enforceContextBudget, stripThinking, estimateTokensFromMessages, estimateToolSchemaTokens, rollingCompressToolResults, } from './history.js';
 import { truncateToolResultContent } from './agent/context-budget.js';
 import { HookManager, loadHookPlugins } from './hooks/index.js';
 import { projectIndexKeys, parseIndexMeta, isFreshIndex, indexSummaryLine } from './indexer.js';
@@ -2034,6 +2034,13 @@ export async function createSession(opts) {
         let repromptUsed = false;
         let readBudgetWarned = false;
         let noToolNudgeUsed = false;
+        // ── Edited paths tracking (#4) ──
+        // Track files that have been successfully edited, for compression of prior reads.
+        const editedPaths = new Set();
+        // ── Stagnation detection (#3) ──
+        // Track turns where no novel action (new signature) occurs.
+        let stagnantTurns = 0;
+        let stagnationWarned = false;
         // ── Per-file mutation spiral detection ──
         // Track how many times the same file is mutated within a single ask().
         // When a file is edited too many times it usually means the model is in a
@@ -2081,7 +2088,8 @@ export async function createSession(opts) {
         });
         const toolLoopWarningKeys = new Set();
         let forceToollessRecoveryTurn = false;
-        let toollessRecoveryUsed = false;
+        let toollessRecoveryCount = 0;
+        const MAX_TOOLLESS_RECOVERIES = 3;
         const streamedToolCallPreviews = new Set();
         const streamedToolCallPreviewScores = new Map();
         // ── Security: credential leak detection + prompt injection guard ──
@@ -2222,7 +2230,22 @@ export async function createSession(opts) {
                 await maybeAutoDetectModelChange();
                 const compactionStartMs = Date.now();
                 await runCompactionWithLock('auto context-budget compaction', async () => {
-                    const beforeMsgs = messages;
+                    let beforeMsgs = messages;
+                    // Rolling compression: shrink old read_file/read_files/exec results
+                    const rolling = rollingCompressToolResults({
+                        messages: beforeMsgs,
+                        freshCount: cfg.rolling_compress_fresh_count ?? cfg.compact_min_tail ?? 12,
+                        maxChars: cfg.rolling_compress_max_chars ?? 1500,
+                        toolNameByCallId,
+                        toolArgsByCallId,
+                        editedPaths,
+                    });
+                    if (rolling.compressedCount > 0) {
+                        beforeMsgs = rolling.messages;
+                        if (cfg.verbose) {
+                            console.error(`[rolling-compress] ${rolling.compressedCount} results, ~${Math.ceil(rolling.charsSaved / 4)} tokens freed`);
+                        }
+                    }
                     const beforeTokens = estimateTokensCached(beforeMsgs);
                     const compacted = enforceContextBudget({
                         messages: beforeMsgs,
@@ -2960,6 +2983,26 @@ export async function createSession(opts) {
                             criticalLoopSigs.add(detected.signature);
                         }
                     }
+                    // ── Stagnation detection (#3): check for novel actions ──
+                    {
+                        const hasNovelAction = [...turnSigs].some(sig => !sigCounts.has(sig));
+                        if (hasNovelAction) {
+                            stagnantTurns = 0;
+                            stagnationWarned = false;
+                        }
+                        else {
+                            stagnantTurns++;
+                        }
+                        if (stagnantTurns >= 3 && totalToolCallsThisAsk >= 10 && !stagnationWarned) {
+                            stagnationWarned = true;
+                            messages.push({
+                                role: 'system',
+                                content: '[stagnation detected] You have repeated the same actions for 3 turns with no new progress. ' +
+                                    'STOP and reassess your approach. Try a different strategy, or if you are stuck, ' +
+                                    'summarize what you have tried and ask for guidance.',
+                            });
+                        }
+                    }
                     // Track whether a mutation happened since a given signature was last seen.
                     // (Tool-loop is single-threaded across turns; this is safe to keep in-memory.)
                     for (const sig of turnSigs) {
@@ -3082,13 +3125,11 @@ export async function createSession(opts) {
                                     content: `[tool-loop critical] ${toolName} repeated ${consec}x unchanged. Tools disabled next turn; use existing results.`,
                                 });
                             }
-                            // At consec >= 3: poison the result (don't execute, return error).
-                            // At consec >= 4: also suppress the tool from the schema entirely.
+                            // At consec >= 3: poison this specific signature (don't execute, return error).
+                            // The tool itself stays in the schema so the model can call it with
+                            // different arguments (e.g. read a different file or different offset).
                             if (consec >= 3) {
                                 poisonedToolSigs.add(sig);
-                                if (consec >= 4) {
-                                    suppressedTools.add(toolName);
-                                }
                                 continue;
                             }
                             continue;
@@ -3132,13 +3173,45 @@ export async function createSession(opts) {
                     // Update consecutive tracking: save this turn's signatures for next turn comparison.
                     lastTurnSigs = turnSigs;
                     if (shouldForceToollessRecovery) {
-                        if (!toollessRecoveryUsed) {
-                            console.error(`[tool-loop] Disabling tools for one recovery turn (turn=${turns})`);
+                        if (toollessRecoveryCount < MAX_TOOLLESS_RECOVERIES) {
+                            toollessRecoveryCount++;
+                            console.error(`[tool-loop] Recovery turn ${toollessRecoveryCount}/${MAX_TOOLLESS_RECOVERIES}` +
+                                ` \u2014 disabling tools (turn=${turns})`);
                             forceToollessRecoveryTurn = true;
-                            toollessRecoveryUsed = true;
+                            // Reset loop state so the model gets a genuine fresh start after reflection.
+                            // Without this, it immediately re-hits the same thresholds on the next turn.
+                            consecutiveCounts.clear();
+                            suppressedTools.clear();
+                            // Escalating recovery messages — more urgent with each attempt
+                            let recoveryContent;
+                            if (toollessRecoveryCount === 1) {
+                                recoveryContent =
+                                    `[system] \u{1F6D1} Tool loop detected (recovery ${toollessRecoveryCount}/${MAX_TOOLLESS_RECOVERIES}). ` +
+                                        `Tools are disabled for this turn. Before your next tool call, explain:\n` +
+                                        `1. What you were trying to accomplish\n` +
+                                        `2. Why your previous approach was not working\n` +
+                                        `3. What different approach you will take next`;
+                            }
+                            else if (toollessRecoveryCount === 2) {
+                                recoveryContent =
+                                    `[system] \u{1F6D1} Tool loop detected again (recovery ${toollessRecoveryCount}/${MAX_TOOLLESS_RECOVERIES}). ` +
+                                        `You have already failed to break out of a loop once. ` +
+                                        `You MUST take a fundamentally different approach:\n` +
+                                        `- If you were editing a file repeatedly, try a completely different fix\n` +
+                                        `- If you were reading the same file, use the content you already have\n` +
+                                        `- If you were searching for something and not finding it, it may not exist\n` +
+                                        `- Consider whether the task can be completed with what you already know`;
+                            }
+                            else {
+                                recoveryContent =
+                                    `[system] \u{1F6D1} FINAL recovery attempt (${toollessRecoveryCount}/${MAX_TOOLLESS_RECOVERIES}). ` +
+                                        `If you loop again, the session will be terminated.\n` +
+                                        `Summarize what you know and either complete the task with what you have, ` +
+                                        `or explain clearly what is blocking you so the user can intervene.`;
+                            }
                             messages.push({
                                 role: 'user',
-                                content: '[system] 🛑 Tool loop detected. Tools disabled for this turn. Analyze the situation using existing results and explain what went wrong before continuing.',
+                                content: recoveryContent,
                             });
                             await emitTurnEnd({
                                 turn: turns,
@@ -3154,8 +3227,10 @@ export async function createSession(opts) {
                             });
                             continue;
                         }
-                        console.error(`[tool-loop] Recovery failed — model resumed looping after tools-disabled turn (turn=${turns})`);
-                        throw new AgentLoopBreak('critical tool-loop persisted after one tools-disabled recovery turn. Stopping to avoid infinite loop.');
+                        console.error(`[tool-loop] Recovery failed \u2014 model resumed looping after ` +
+                            `${MAX_TOOLLESS_RECOVERIES} recovery turns (turn=${turns})`);
+                        throw new AgentLoopBreak(`critical tool-loop persisted after ${MAX_TOOLLESS_RECOVERIES} recovery turns. ` +
+                            `Stopping to avoid infinite loop.`);
                     }
                     const runOne = async (tc) => {
                         // Resolve tool name aliases (bash→exec, file_read→read_file, etc.)
@@ -3214,10 +3289,23 @@ export async function createSession(opts) {
                         toolLoopGuard.registerCall(name, parsedArgs, callId);
                         toolArgsByCallId.set(callId, parsedArgs);
                         recordToolUsageForHints(name, parsedArgs);
+                        // Auto-strip unknown parameters before validation (#1).
+                        // This prevents hard errors from unknown keys while still
+                        // reporting them as notes in the tool result.
+                        let strippedArgKeys = [];
+                        if (builtInFn || isSpawnTask) {
+                            const strip = stripUnknownArgs(name, args);
+                            if (strip.stripped.length > 0) {
+                                strippedArgKeys = strip.stripped;
+                                // Mutate args in-place so downstream code sees cleaned args
+                                for (const k of strip.stripped) {
+                                    delete args[k];
+                                }
+                            }
+                        }
                         // Pre-dispatch argument validation.
                         // - Required params
                         // - Type/range/enums
-                        // - Unknown properties
                         if (builtInFn || isSpawnTask) {
                             const missing = getMissingRequiredParams(name, args);
                             if (missing.length) {
@@ -3277,6 +3365,30 @@ export async function createSession(opts) {
                             // Detect cat/head/tail used as a substitute for read_file
                             const catRedirect = detectCatHeadTailAsRead(args.command);
                             if (catRedirect) {
+                                // Before returning a bare STOP, check if we have cached content
+                                // for the target file. When read_file is poisoned for this path
+                                // (deadlock scenario), serve the cached content so the model can
+                                // make progress instead of looping on STOP messages.
+                                const catReadPath = extractFilePathFromReadCommand(args.command);
+                                if (catReadPath) {
+                                    const cachedContent = await toolLoopGuard.getFileContentCache('read_file', { path: catReadPath }, ctx.cwd);
+                                    if (cachedContent) {
+                                        await emitToolCall(callId, name, args);
+                                        await emitToolResult({
+                                            id: callId,
+                                            name,
+                                            success: true,
+                                            summary: 'served cached file content (read_file redirect)',
+                                            result: '',
+                                        });
+                                        return {
+                                            id: callId,
+                                            content: '[system] Use read_file instead of shell commands for reading files. ' +
+                                                'Here is the cached content you already have:\n\n' +
+                                                cachedContent,
+                                        };
+                                    }
+                                }
                                 await emitToolCall(callId, name, args);
                                 await emitToolResult({
                                     id: callId,
@@ -3777,6 +3889,10 @@ export async function createSession(opts) {
                         if (!toolSuccess && name === 'exec' && typeof resultEvent.execRc === 'number') {
                             resultEvent.summary = `rc=${resultEvent.execRc} (command failed)`;
                         }
+                        // Append note about stripped unknown parameters (#1)
+                        if (strippedArgKeys.length > 0) {
+                            content += `\n[note: unknown parameters ${strippedArgKeys.join(", ")} were ignored]`;
+                        }
                         await emitToolResult(resultEvent);
                         // Proactive LSP diagnostics after file mutations
                         if (lspManager?.hasServers() && lspCfg?.proactive_diagnostics !== false) {
@@ -3818,6 +3934,13 @@ export async function createSession(opts) {
                         totalToolCallsThisAsk++;
                         if (isMutationTool(name) && toolSuccess) {
                             totalEditsThisAsk++;
+                            // Track edited paths for acted-on read compression (#4)
+                            if (typeof args.path === 'string') {
+                                const absEditedPath = args.path.startsWith('/')
+                                    ? args.path
+                                    : path.resolve(projectDir, args.path);
+                                editedPaths.add(absEditedPath);
+                            }
                         }
                         // ── Per-file mutation spiral detection ──
                         // Track edits to the same file. If the model keeps editing the same file
@@ -3987,12 +4110,30 @@ export async function createSession(opts) {
                         }
                     }
                     if (harness.toolCalls.parallelCalls) {
-                        // Models that support parallel calls: read-only in parallel, mutations sequential
+                        // Models that support parallel calls: read-only in parallel, mutations by file (#7)
                         const readonly = toolCallsArr.filter((tc) => isReadOnlyToolDynamic(tc.function.name));
                         const others = toolCallsArr.filter((tc) => !isReadOnlyToolDynamic(tc.function.name));
                         const ro = await Promise.all(readonly.map((tc) => runOne(tc).catch((e) => catchToolError(e, tc))));
                         results.push(...ro);
+                        // Group mutations by target file path for parallel execution (#7).
+                        // Mutations targeting the same file run sequentially within their group.
+                        // Mutations targeting different files run in parallel.
+                        // Non-file-targeting tools (exec, apply_patch) run sequentially first.
+                        const sequential = [];
+                        const byFile = new Map();
                         for (const tc of others) {
+                            const target = getMutationTargetPath(tc, projectDir);
+                            if (!target) {
+                                sequential.push(tc);
+                            }
+                            else {
+                                const group = byFile.get(target) ?? [];
+                                group.push(tc);
+                                byFile.set(target, group);
+                            }
+                        }
+                        // Run sequential group first (exec, apply_patch, etc.)
+                        for (const tc of sequential) {
                             if (ac.signal.aborted)
                                 break;
                             try {
@@ -4000,12 +4141,31 @@ export async function createSession(opts) {
                             }
                             catch (e) {
                                 results.push(await catchToolError(e, tc));
-                                if (isMutationTool(tc.function.name)) {
-                                    // Fail-fast: after mutating tool failure, stop the remaining batch.
+                                if (isMutationTool(tc.function.name))
                                     break;
-                                }
                             }
                         }
+                        // Run file-mutation groups in parallel
+                        if (byFile.size > 0 && !ac.signal.aborted) {
+                            const groupResults = await Promise.all([...byFile.values()].map(async (group) => {
+                                const groupRes = [];
+                                for (const tc of group) {
+                                    if (ac.signal.aborted)
+                                        break;
+                                    try {
+                                        groupRes.push(await runOne(tc));
+                                    }
+                                    catch (e) {
+                                        groupRes.push(await catchToolError(e, tc));
+                                        // Fail-fast within this file's group
+                                        break;
+                                    }
+                                }
+                                return groupRes;
+                            }));
+                            for (const gr of groupResults)
+                                results.push(...gr);
+                        }
                     }
                     else {
                         // Models with parallelCalls=false: run ALL calls sequentially (§4i).
@@ -4408,6 +4568,27 @@ export async function createSession(opts) {
         compactHistory,
     };
 }
+/**
+ * Extract the absolute file path targeted by a mutation tool call (#7).
+ * Returns null for apply_patch (multi-file), exec, and non-file tools.
+ */
+function getMutationTargetPath(tc, projectDir) {
+    const name = tc.function?.name ?? '';
+    // apply_patch can target multiple files — treat as sequential
+    if (name === 'apply_patch' || name === 'exec')
+        return null;
+    let raw;
+    try {
+        const args = JSON.parse(tc.function?.arguments ?? '{}');
+        raw = typeof args.path === 'string' ? args.path.trim() : undefined;
+    }
+    catch {
+        return null;
+    }
+    if (!raw)
+        return null;
+    return raw.startsWith('/') ? raw : path.resolve(projectDir, raw);
+}
 export async function runAgent(opts) {
     const session = await createSession({
         config: opts.config,