minovative-mind-cli 2.10.0 → 2.11.0

package/dist/services/orchestration/investigationAgent.js

@@ -135,56 +135,63 @@ export class InvestigationAgentRunner {
                     success = true;
                     break;
                 }
-                const functionResponses = [];
-                for (const call of functionCalls) {
-                    if (crashed || abortSignal.aborted)
-                        break;
+                let isFinished = false;
+                if (onTool) {
+                    for (const call of functionCalls) {
+                        onTool(formatToolCall(call.name, (call.args || {})));
+                    }
+                }
+                // Execute tool calls concurrently while preserving 1:1 Gemini response positional ordering
+                const functionResponses = await Promise.all(functionCalls.map(async (call) => {
+                    if (crashed || abortSignal.aborted) {
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { error: 'Operation aborted or agent stopped.' },
+                            },
+                        };
+                    }
                     this.pingHeartbeat();
-                    const args = call.args;
+                    const args = (call.args || {});
                     const logPrefix = `[${this.agentLabel}]`;
-                    if (onTool) {
-                        onTool(formatToolCall(call.name, args));
-                    }
                     if (call.name === 'finish_investigation') {
                         summary = args.summary || '';
                         const filesToRead = args.relevantFiles || [];
                         if (onProgress)
                             onProgress(`${logPrefix} Finished investigation (${filesToRead.length} files)`);
                         debugLog(`InvestigationAgent ${logPrefix}: Finished. Selected files: ${JSON.stringify(filesToRead)}`);
-                        for (const filePath of filesToRead) {
-                            if (!relevantFiles.has(filePath)) {
-                                // Check shared cache first
-                                if (this.readCache.has(filePath)) {
-                                    relevantFiles.set(filePath, this.readCache.get(filePath));
-                                }
-                                else {
-                                    const readResult = await readFile(this.workspaceRoot, filePath);
-                                    if (!readResult.error) {
-                                        const contentObj = { text: readResult.output, inlineData: readResult.inlineData };
-                                        relevantFiles.set(filePath, contentObj);
-                                        this.readCache.set(filePath, contentObj);
-                                    }
+                        await Promise.all(filesToRead.map(async (filePath) => {
+                            if (this.readCache.has(filePath)) {
+                                relevantFiles.set(filePath, this.readCache.get(filePath));
+                            }
+                            else {
+                                const readResult = await readFile(this.workspaceRoot, filePath);
+                                if (!readResult.error) {
+                                    const contentObj = { text: readResult.output, inlineData: readResult.inlineData };
+                                    relevantFiles.set(filePath, contentObj);
+                                    this.readCache.set(filePath, contentObj);
                                 }
                             }
-                        }
+                        }));
                         isFinished = true;
                         success = true;
-                        functionResponses.push({
-                            functionResponse: { name: call.name, response: { output: 'Investigation finished.' } },
-                        });
-                        break;
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: 'Investigation finished.' },
+                            },
+                        };
                     }
                     else if (call.name === 'select_files') {
                         const filesToRead = args.files || [];
                         if (onProgress)
                             onProgress(`${logPrefix} Selected ${filesToRead.length} files`);
-                        let output = '';
-                        for (const filePath of filesToRead) {
+                        const fileOutputs = await Promise.all(filesToRead.map(async (filePath) => {
                             // Check cache first
                             if (this.readCache.has(filePath)) {
                                 const cached = this.readCache.get(filePath);
                                 relevantFiles.set(filePath, cached);
-                                output += `\n--- File: ${filePath} ---\n${cached.text}\n`;
+                                return `\n--- File: ${filePath} ---\n${cached.text}\n`;
                             }
                             else {
                                 const readResult = await readFile(this.workspaceRoot, filePath);
@@ -192,99 +199,98 @@ export class InvestigationAgentRunner {
                                     const contentObj = { text: readResult.output, inlineData: readResult.inlineData };
                                     relevantFiles.set(filePath, contentObj);
                                     this.readCache.set(filePath, contentObj);
-                                    output += `\n--- File: ${filePath} ---\n${readResult.output}\n`;
+                                    return `\n--- File: ${filePath} ---\n${readResult.output}\n`;
                                 }
                                 else {
-                                    output += `\n--- File: ${filePath} ---\nError: ${readResult.error}\n`;
+                                    return `\n--- File: ${filePath} (Error: ${readResult.error}) ---\n`;
                                 }
                             }
-                        }
-                        functionResponses.push({
-                            functionResponse: { name: call.name, response: { output: output || 'No files read.' } },
-                        });
+                        }));
+                        const output = fileOutputs.join('');
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: output || 'No files selected.' },
+                            },
+                        };
                     }
                     else if (call.name === 'list_directory') {
                         if (onProgress)
-                            onProgress(`${logPrefix} Listing: ${args.dirPath}`);
-                        const listRes = await listDirectory(this.workspaceRoot, args.dirPath, args.maxDepth || 1);
-                        functionResponses.push({
+                            onProgress(`${logPrefix} Listing directory: ${args.dirPath || '.'}`);
+                        const listRes = await listDirectory(this.workspaceRoot, args.dirPath || '.', args.maxDepth);
+                        return {
                             functionResponse: {
                                 name: call.name,
-                                response: { output: listRes.output, ...(listRes.error ? { error: listRes.error } : {}) },
+                                response: {
+                                    output: listRes.output,
+                                    ...(listRes.error ? { error: listRes.error } : {}),
+                                },
                             },
-                        });
+                        };
                     }
                     else if (call.name === 'search_codebase') {
                         if (onProgress)
                             onProgress(`${logPrefix} Searching: "${args.pattern}"`);
-                        const grepRes = await grepSearch(this.workspaceRoot, args.pattern, args.fileGlob);
-                        functionResponses.push({
-                            functionResponse: { name: call.name, response: { output: grepRes.error ? grepRes.error : grepRes.output } },
-                        });
+                        const grepRes = await grepSearch(this.workspaceRoot, args.pattern || '', args.fileGlob, args.fixedStrings, args.dirPath);
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: grepRes.error ? grepRes.error : grepRes.output },
+                            },
+                        };
                     }
                     else if (call.name === 'read_file') {
-                        const filePath = args.filePath;
+                        const filePath = args.filePath || '';
+                        const startLine = args.startLine;
+                        const endLine = args.endLine;
+                        const targetElements = args.targetElements;
                         if (onProgress)
                             onProgress(`${logPrefix} Reading: ${filePath}`);
-                        // Check cache for full-file reads (no line range or target elements)
-                        if (!args.startLine && !args.endLine && !args.targetElements && this.readCache.has(filePath)) {
+                        // Check read cache only for full-file reads
+                        if (this.readCache.has(filePath) && !startLine && !endLine && (!targetElements || targetElements.length === 0)) {
                             const cached = this.readCache.get(filePath);
                             relevantFiles.set(filePath, cached);
-                            functionResponses.push({ functionResponse: { name: call.name, response: { output: cached.text } } });
+                            return {
+                                functionResponse: {
+                                    name: call.name,
+                                    response: { output: cached.text },
+                                },
+                            };
                         }
-                        else {
-                            const readRes = await readFile(this.workspaceRoot, filePath, args.startLine, args.endLine, args.targetElements);
-                            if (!readRes.error) {
-                                const contentObj = { text: readRes.output, inlineData: readRes.inlineData };
-                                relevantFiles.set(filePath, contentObj);
-                                // Only cache full-file reads (partial reads shouldn't overwrite full content)
-                                if (!args.startLine && !args.endLine && !args.targetElements) {
-                                    this.readCache.set(filePath, contentObj);
-                                }
-                            }
-                            functionResponses.push({
-                                functionResponse: { name: call.name, response: { output: readRes.error ? readRes.error : readRes.output } },
-                            });
-                        }
-                    }
-                    else if (call.name === 'perform_web_search') {
-                        if (onProgress)
-                            onProgress(`${logPrefix} Web search: "${args.query}"`);
-                        try {
-                            const { createWebSearchAgentSession } = await import('../ai.js');
-                            const webSession = createWebSearchAgentSession();
-                            const webResult = await webSession.sendMessage(`Please search the web for the following query and summarize your findings:\n"${args.query}"`, undefined, abortSignal, () => this.pingHeartbeat());
-                            const searchSummary = webResult.response.text()?.trim() || 'No relevant information found.';
-                            webSearchSummary += `\nQuery: ${args.query}\nFindings:\n${searchSummary}\n`;
-                            functionResponses.push({ functionResponse: { name: call.name, response: { output: searchSummary } } });
-                        }
-                        catch (e) {
-                            functionResponses.push({
-                                functionResponse: { name: call.name, response: { error: e.message || 'Failed to search the web' } },
-                            });
+                        const readRes = await readFile(this.workspaceRoot, filePath, startLine, endLine, targetElements);
+                        if (!readRes.error && !startLine && !endLine && (!targetElements || targetElements.length === 0)) {
+                            const contentObj = { text: readRes.output, inlineData: readRes.inlineData };
+                            relevantFiles.set(filePath, contentObj);
+                            this.readCache.set(filePath, contentObj);
                         }
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: readRes.error ? readRes.error : readRes.output },
+                            },
+                        };
                     }
                     else if (call.name === 'find_dependencies') {
                         if (onProgress)
                             onProgress(`${logPrefix} Tracing dependencies: ${args.filePath}`);
                         const depResult = await traceDependencies(this.workspaceRoot, args.filePath, args.direction, args.maxDepth);
-                        functionResponses.push({
+                        return {
                             functionResponse: {
                                 name: call.name,
                                 response: { output: depResult.error ? depResult.error : depResult.output },
                             },
-                        });
+                        };
                     }
                     else if (call.name === 'find_recent_changes') {
                         if (onProgress)
                             onProgress(`${logPrefix} Finding recent changes`);
                         const recentRes = await findRecentChanges(this.workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
-                        functionResponses.push({
+                        return {
                             functionResponse: {
                                 name: call.name,
                                 response: { output: recentRes.error ? recentRes.error : recentRes.output },
                             },
-                        });
+                        };
                     }
                     else if (call.name === 'run_analysis_script') {
                         if (onProgress)
@@ -295,9 +301,20 @@ export class InvestigationAgentRunner {
                         const output = analysisResult.exitCode === 0
                             ? analysisResult.stdout || '(script produced no output)'
                             : `Script failed (exit ${analysisResult.exitCode}):\n${analysisResult.stderr}`;
-                        functionResponses.push({ functionResponse: { name: call.name, response: { output } } });
+                        return {
+                            functionResponse: {
+                                name: call.name,
+                                response: { output },
+                            },
+                        };
                     }
-                }
+                    return {
+                        functionResponse: {
+                            name: call.name,
+                            response: { output: `Unknown tool: ${call.name}` },
+                        },
+                    };
+                }));
                 if (crashed || abortSignal.aborted || isFinished)
                     break;
                 // Feed tool results back to the model

package/dist/services/orchestration/investigationOrchestrator.js

@@ -64,6 +64,8 @@ export class InvestigationOrchestrator {
         const MAX_CONCURRENT = 2;
         const results = [];
         for (let i = 0; i < agents.length; i += MAX_CONCURRENT) {
+            if (abortSignal.aborted)
+                break;
             const chunk = agents.slice(i, i + MAX_CONCURRENT);
             const chunkAssignments = agentAssignments.slice(i, i + MAX_CONCURRENT);
             const chunkPromises = chunk.map((agent, chunkIndex) => {
@@ -107,8 +109,10 @@ export class InvestigationOrchestrator {
         // 5. Reduce: Merge results
         const mergedResult = this.reduceResults(successfulResults, projectTree, projectType);
         // 6. Auto-trace reverse dependencies (same logic as contextAgent.ts)
-        const allSelectedFiles = Array.from(mergedResult.relevantFiles.keys());
-        await this.autoTraceReverseDeps(workspaceRoot, allSelectedFiles, mergedResult.relevantFiles, onProgress);
+        if (!abortSignal.aborted) {
+            const allSelectedFiles = Array.from(mergedResult.relevantFiles.keys());
+            await this.autoTraceReverseDeps(workspaceRoot, allSelectedFiles, mergedResult.relevantFiles, onProgress);
+        }
         // 7. Log summary
         const cacheStats = readCache.getStats();
         const totalTokens = results.reduce((sum, r) => sum + r.creditsUsed, 0);

package/dist/services/orchestration/orchestrator.js

@@ -27,12 +27,13 @@ You must output ONLY raw JSON representing the TaskGraph object. Do not wrap in
 </identity>
 
 <requirements>
-- Break the work down logically based on file isolation and dependency chains.
-- Tasks that don't depend on each other will run in parallel.
+- Break the work down logically based on file isolation, domain boundaries, and dependency chains.
+- Tasks that don't depend on each other will run in parallel (up to 2 concurrent agents per wave).
 - If a task depends on another, it must list its ID in "dependsOn".
 - Do NOT create cyclic dependencies (A -> B -> A).
 - If the entire objective is very simple and only requires modifying 1-2 files sequentially, output a graph with exactly 1 task.
-- Ensure 'targetFiles' lists all files the task will modify.
+- Ensure 'targetFiles' lists all files the task will modify. Isolate targetFiles across parallel tasks in the same wave to avoid file lock contention.
+- Use 'readOnlyFiles' for files the task needs to inspect without modifying.
 </requirements>
 
 <json_schema>
@@ -123,6 +124,8 @@ export class Orchestrator {
             const MAX_CONCURRENT = 2;
             const toolLogs = [];
             for (let i = 0; i < wave.taskIds.length; i += MAX_CONCURRENT) {
+                if (signal.aborted)
+                    break;
                 const chunk = wave.taskIds.slice(i, i + MAX_CONCURRENT);
                 const wavePromises = chunk.map((taskId) => {
                     const taskDef = graph.tasks.find((t) => t.id === taskId);

package/dist/services/orchestration/scopedTools.js

@@ -160,6 +160,11 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
             targetDesc = String(args.filePath);
             actionDesc = 'Deleted';
         }
+        else if (name === 'run_debug_script') {
+            targetDesc = String(args.language ?? 'node');
+            actionDesc = 'Ran debug script';
+            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed debug script';
+        }
         else if (name === 'run_fuzz_probe') {
             targetDesc = String(args.language ?? 'node');
             actionDesc = 'Ran fuzz probe';

package/dist/services/orchestration/subAgent.d.ts

@@ -6,6 +6,25 @@
  */
 import { MessageBus } from './messageBus.js';
 import { FileLockRegistry } from './fileLockRegistry.js';
+/**
+ * Scopes workspace file blocks within a context string by replacing full implementation
+ * bodies with compact AST declaration outlines (types, classes, function signatures),
+ * drastically conserving token overhead for parallel sub-agents.
+ *
+ * @param contextStr The raw context string containing workspace_file blocks.
+ * @returns Context string with scoped workspace_file blocks.
+ */
+export declare function scopeContext(contextStr: string): string;
+/**
+ * Generates a concise reference string for completed historical tool executions
+ * to eliminate token bloat while keeping execution history coherent for the model.
+ *
+ * @param toolName Name of the executed tool.
+ * @param output Output text or object from the tool execution.
+ * @param args Arguments passed to the tool call.
+ * @returns Compacted tool execution reference string.
+ */
+export declare function createCompactToolReference(toolName: string, output: any, args?: Record<string, any>): string;
 /**
  * Result returned when a sub-agent completes its execution.
  */
@@ -43,7 +62,9 @@ export declare class SubAgentRunner {
     static readonly STALL_TIMEOUT_MS = 300000;
     constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string, onProgress?: ((msg: string) => void) | undefined, onTool?: ((msg: string) => void) | undefined);
     /**
-     * Constructs the base system instruction for this specific agent.
+     * Constructs the base system instruction for this specific agent,
+     * injecting scoped AST outlines for referenced workspace files to eliminate
+     * multi-megabyte context bloat during parallel sub-agent execution.
      */
     private buildSystemInstruction;
     /**
@@ -57,6 +78,15 @@ export declare class SubAgentRunner {
      * an error occurs, or the stall timeout is hit.
      */
     execute(signal: AbortSignal): Promise<SubAgentResult>;
+    /**
+     * Compacts older tool responses in the chat session history into concise references
+     * (e.g. `[Read X lines from file.ts - tool execution completed]`), drastically reducing
+     * context window bloat across multi-turn sub-agent executions while preserving
+     * Gemini's functionCall <-> functionResponse protocol.
+     *
+     * @param turnsToKeep Number of recent turns to preserve in full (default: 1).
+     */
+    compactOlderToolResponses(turnsToKeep?: number): void;
     /**
      * Accumulates token usage from the chat session.
      */

package/dist/services/orchestration/subAgent.js

@@ -11,6 +11,108 @@ import { debugLog } from '../../utils/logger.js';
 import { runWithAgentId } from '../../utils/asyncContext.js';
 import { clearReadHistory } from '../../utils/fileReadGuard.js';
 import { formatToolCall } from '../agent/toolLoop.js';
+import { extractDeclarationsOutline } from '../../utils/symbolExtractor.js';
+import { sanitizeForCDATA } from '../../utils/contextPrompts.js';
+/**
+ * Scopes workspace file blocks within a context string by replacing full implementation
+ * bodies with compact AST declaration outlines (types, classes, function signatures),
+ * drastically conserving token overhead for parallel sub-agents.
+ *
+ * @param contextStr The raw context string containing workspace_file blocks.
+ * @returns Context string with scoped workspace_file blocks.
+ */
+export function scopeContext(contextStr) {
+    if (!contextStr)
+        return '';
+    return contextStr.replace(/<workspace_file path="([^"]+)"([^>]*)>[\s\r\n]*<content_data><!\[CDATA\[([\s\S]*?)\]\](?:\\u200B)?>[\s\r\n]*<\/content_data>[\s\r\n]*<\/workspace_file>/g, (match, filePath, attrs, rawContent) => {
+        if (attrs.includes('scoped="outline"'))
+            return match;
+        const unescaped = rawContent.replace(/\]\]\\u200B>/g, ']]>');
+        const outline = extractDeclarationsOutline(unescaped, filePath) || unescaped;
+        const sanitized = sanitizeForCDATA(outline);
+        return `<workspace_file path="${filePath}"${attrs} scoped="outline">\n<content_data><![CDATA[\n${sanitized}\n]]\\u200B></content_data>\n</workspace_file>`;
+    });
+}
+/**
+ * Locates the matching functionCall in the preceding model response entry.
+ *
+ * @param modelEntry The preceding Content entry from the model.
+ * @param toolName The name of the function call.
+ * @param partIndex Index of the function response part.
+ * @returns The matching functionCall object with args if found.
+ */
+function findMatchingFunctionCall(modelEntry, toolName, partIndex) {
+    if (!modelEntry || modelEntry.role !== 'model' || !Array.isArray(modelEntry.parts))
+        return null;
+    const callParts = modelEntry.parts.filter((p) => p && typeof p === 'object' && 'functionCall' in p && p.functionCall);
+    if (partIndex < callParts.length) {
+        const call = callParts[partIndex].functionCall;
+        if (call && call.name === toolName)
+            return call;
+    }
+    // Fallback: search by toolName
+    const match = callParts.find((p) => p.functionCall?.name === toolName);
+    return match ? match.functionCall : null;
+}
+/**
+ * Generates a concise reference string for completed historical tool executions
+ * to eliminate token bloat while keeping execution history coherent for the model.
+ *
+ * @param toolName Name of the executed tool.
+ * @param output Output text or object from the tool execution.
+ * @param args Arguments passed to the tool call.
+ * @returns Compacted tool execution reference string.
+ */
+export function createCompactToolReference(toolName, output, args) {
+    if (typeof output !== 'string') {
+        return `[${toolName} tool execution completed]`;
+    }
+    // If already compacted, return as-is
+    if (output.startsWith('[') && output.endsWith('completed]')) {
+        return output;
+    }
+    const lineCount = output.split('\n').length;
+    if (toolName === 'read_file') {
+        const file = args?.filePath ? `from ${args.filePath}` : 'from file';
+        return `[Read ${lineCount} lines ${file} - tool execution completed]`;
+    }
+    if (toolName === 'grep_search' || toolName === 'search_codebase') {
+        const pattern = args?.pattern ? `for "${args.pattern}"` : '';
+        return `[Grep search ${pattern} completed - ${lineCount} lines returned]`.replace(/\s+/g, ' ');
+    }
+    if (toolName === 'list_directory') {
+        const dir = args?.dirPath ? `for "${args.dirPath}"` : '';
+        return `[Directory listing ${dir} completed - ${lineCount} entries]`.replace(/\s+/g, ' ');
+    }
+    if (toolName === 'modify_file') {
+        const file = args?.filePath ? `${args.filePath}` : 'file';
+        return `[Modified ${file} - tool execution completed]`;
+    }
+    if (toolName === 'write_file') {
+        const file = args?.filePath ? `${args.filePath}` : 'file';
+        return `[Wrote ${file} - tool execution completed]`;
+    }
+    if (toolName === 'find_dependencies') {
+        const file = args?.filePath ? `for ${args.filePath}` : '';
+        return `[Dependency trace ${file} completed]`.replace(/\s+/g, ' ');
+    }
+    if (toolName === 'find_recent_changes') {
+        return `[Recent changes lookup completed]`;
+    }
+    if (toolName === 'run_command' ||
+        toolName === 'run_debug_script' ||
+        toolName === 'run_analysis_script' ||
+        toolName === 'run_fuzz_probe' ||
+        toolName === 'check_heap_delta' ||
+        toolName === 'check_behavioral_drift') {
+        const cmd = args?.command ? ` "${args.command.slice(0, 50)}"` : '';
+        return `[Command/Script${cmd} execution completed (${lineCount} lines output)]`;
+    }
+    if (output.length > 300) {
+        return `[${toolName} tool execution completed (${lineCount} lines)]`;
+    }
+    return output;
+}
 /**
  * Executes a sub-agent task with full health monitoring, tool wrapping,
  * and orchestration integration.
@@ -52,9 +154,12 @@ export class SubAgentRunner {
         });
     }
     /**
-     * Constructs the base system instruction for this specific agent.
+     * Constructs the base system instruction for this specific agent,
+     * injecting scoped AST outlines for referenced workspace files to eliminate
+     * multi-megabyte context bloat during parallel sub-agent execution.
      */
     buildSystemInstruction() {
+        const scopedContext = scopeContext(this.globalContext);
         return (`<identity>\n` +
             `You are an autonomous Senior software developer sub-agent executing a specific portion of a larger task.\n` +
             `</identity>\n\n` +
@@ -64,7 +169,7 @@ export class SubAgentRunner {
             `</task_info>\n\n` +
             `<reference_context>\n` +
             `DO NOT IMPLEMENT THIS FULL REQUEST. THIS IS JUST FOR CONTEXT.\n\n` +
-            `${this.globalContext}\n` +
+            `${scopedContext}\n` +
             `</reference_context>\n\n` +
             `<critical_guidelines>\n` +
             `1. You are ONE worker in a team. Focus EXCLUSIVELY on your specific objective: "${this.intent}".\n` +
@@ -162,6 +267,10 @@ export class SubAgentRunner {
                     }
                     if (crashed || signal.aborted)
                         break;
+                    // Compact older tool responses in chat history before sending new turn
+                    if (turns > 0) {
+                        this.compactOlderToolResponses(1);
+                    }
                     this.pingHeartbeat();
                     // Feed tool results back to the model
                     turnResult = await this.chat.sendMessage(toolResponses, undefined, signal);
@@ -199,6 +308,48 @@ export class SubAgentRunner {
             };
         });
     }
+    /**
+     * Compacts older tool responses in the chat session history into concise references
+     * (e.g. `[Read X lines from file.ts - tool execution completed]`), drastically reducing
+     * context window bloat across multi-turn sub-agent executions while preserving
+     * Gemini's functionCall <-> functionResponse protocol.
+     *
+     * @param turnsToKeep Number of recent turns to preserve in full (default: 1).
+     */
+    compactOlderToolResponses(turnsToKeep = 1) {
+        const rawHistory = this.chat.getRawHistory();
+        // 1 turn = 1 user Content + 1 model Content pair (2 entries)
+        const cutoffIndex = Math.max(0, rawHistory.length - turnsToKeep * 2);
+        if (cutoffIndex <= 0)
+            return;
+        for (let i = 0; i < cutoffIndex; i++) {
+            const entry = rawHistory[i];
+            if (entry && entry.role === 'user' && Array.isArray(entry.parts)) {
+                const prevModelEntry = i > 0 ? rawHistory[i - 1] : undefined;
+                let funcRespIdx = 0;
+                for (const part of entry.parts) {
+                    if (part && typeof part === 'object' && 'functionResponse' in part && part.functionResponse) {
+                        const funcResp = part.functionResponse;
+                        const toolName = funcResp.name || 'tool';
+                        const matchingCall = findMatchingFunctionCall(prevModelEntry, toolName, funcRespIdx);
+                        const args = matchingCall?.args;
+                        if (funcResp.response && typeof funcResp.response === 'object') {
+                            const respObj = funcResp.response;
+                            if (typeof respObj.output === 'string') {
+                                respObj.output = createCompactToolReference(toolName, respObj.output, args);
+                            }
+                            if (typeof respObj.result === 'string') {
+                                respObj.result = createCompactToolReference(toolName, respObj.result, args);
+                            }
+                        }
+                        funcRespIdx++;
+                    }
+                }
+            }
+        }
+        // Also trigger proxy chat session pruning to collapse any remaining long fields
+        this.chat.pruneToolOutputHistory();
+    }
     /**
      * Accumulates token usage from the chat session.
      */

package/dist/utils/analysisRunner.d.ts

@@ -10,6 +10,8 @@ export interface EphemeralScriptOptions {
     maxOutputChars?: number;
     /** AbortSignal to cancel execution. */
     abortSignal?: AbortSignal;
+    /** Optional custom environment variables to merge into execution environment. */
+    env?: Record<string, string>;
 }
 export interface PropertyTestConfig {
     numRuns?: number;
@@ -23,10 +25,37 @@ export interface PropertyTestResult extends EphemeralScriptResult {
     seed?: number;
     numRunsCompleted?: number;
 }
+/** Supported canonical language names list. */
+export declare const SUPPORTED_LANGUAGES: readonly ["node", "ts-node", "python", "bash", "go", "rust", "c", "cpp", "ruby", "php", "java"];
+export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
 /**
  * Normalizes user/AI provided language string to a standard runtime identifier.
  */
 export declare function normalizeLanguage(lang: string): string;
+/**
+ * Detects programming language heuristic markers directly from script source code syntax.
+ * Useful when language is omitted or set to 'auto'.
+ *
+ * @param code - The source code to analyze.
+ * @returns Detected runtime identifier (e.g., 'python', 'rust', 'go', 'cpp', 'c', 'bash', 'ruby', 'php', 'java', 'ts-node', 'node').
+ */
+export declare function detectLanguageFromCode(code: string): string;
+/**
+ * Detects the dominant programming language / runtime for a workspace based on project manifest files.
+ *
+ * @param workspaceRoot - Path to the workspace root directory.
+ * @returns Detected runtime identifier (e.g., 'rust', 'go', 'python', 'cpp', 'ts-node', 'node').
+ */
+export declare function detectProjectRuntime(workspaceRoot: string): Promise<string>;
+/**
+ * Resolves the effective runtime language by combining explicit language input,
+ * source code syntax heuristics, and workspace project manifests.
+ *
+ * @param workspaceRoot - Path to workspace root directory.
+ * @param language - Optional language parameter passed by user/agent.
+ * @param code - Optional source code string to inspect.
+ */
+export declare function resolveEffectiveRuntime(workspaceRoot: string, language?: string, code?: string): Promise<string>;
 /**
  * Detects whether the workspace package.json specifies `"type": "module"`.
  * Returns `'module'` or `'commonjs'`.