minovative-mind-cli 2.13.3 → 2.13.4

package/dist/services/ai.d.ts

@@ -1,4 +1,5 @@
 import { type Content, type FunctionCall } from '@google/generative-ai';
+export declare function getMultiWorkspaceBlock(): string;
 export declare function setModelOverride(agent: 'context' | 'execution', overrideStr: string): void;
 export declare function clearModelOverrides(): void;
 export declare function setGlobalActiveModel(model: string): void;
@@ -9,11 +10,14 @@ export declare class ProxyChatSession {
     private modelName;
     private systemInstruction;
     private tools;
+    private toolConfig?;
     private generationConfig;
     private latestUsageMetadata;
-    constructor(modelName: string, systemInstruction: string, tools: any[], generationConfig: any);
+    constructor(modelName: string, systemInstruction: string, tools: any[], generationConfig: any, toolConfig?: any);
     getLatestUsageMetadata(): any;
-    setAgentConfig(systemInstruction: string, tools: any[]): void;
+    setAgentConfig(systemInstruction: string, tools: any[], toolConfig?: any): void;
+    setToolConfig(toolConfig?: any): void;
+    getToolConfig(): any;
     setModel(modelName: string): void;
     getModel(): string;
     clearHistory(): void;

package/dist/services/ai.js

@@ -9,7 +9,7 @@ import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUC
 import { workspaceRegistry } from './workspaceRegistry.js';
 import { loadCredentials } from '../utils/credentialStore.js';
 import { ProxyClient } from './proxyClient.js';
-function getMultiWorkspaceBlock() {
+export function getMultiWorkspaceBlock() {
     const summary = workspaceRegistry.buildPromptSummary();
     const primaryRoot = process.cwd();
     const primaryName = primaryRoot.split(/[/\\]/).pop() || 'Primary';
@@ -99,20 +99,29 @@ export class ProxyChatSession {
     modelName;
     systemInstruction;
     tools;
+    toolConfig;
     generationConfig;
     latestUsageMetadata = undefined;
-    constructor(modelName, systemInstruction, tools, generationConfig) {
+    constructor(modelName, systemInstruction, tools, generationConfig, toolConfig) {
         this.modelName = modelName;
         this.systemInstruction = systemInstruction;
         this.tools = tools;
         this.generationConfig = generationConfig;
+        this.toolConfig = toolConfig;
     }
     getLatestUsageMetadata() {
         return this.latestUsageMetadata;
     }
-    setAgentConfig(systemInstruction, tools) {
+    setAgentConfig(systemInstruction, tools, toolConfig) {
         this.systemInstruction = systemInstruction;
         this.tools = tools;
+        this.toolConfig = toolConfig;
+    }
+    setToolConfig(toolConfig) {
+        this.toolConfig = toolConfig;
+    }
+    getToolConfig() {
+        return this.toolConfig;
     }
     setModel(modelName) {
         this.modelName = modelName;
@@ -374,13 +383,11 @@ export class ProxyChatSession {
         let result;
         if (byokEnabled) {
             const creds = await loadCredentials();
-            result = await proxyClient.generateViaBYOK(creds.geminiApiKey, this.modelName, this.history, this.tools, undefined, // toolConfig
-            this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
+            result = await proxyClient.generateViaBYOK(creds.geminiApiKey, this.modelName, this.history, this.tools, this.toolConfig, this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
             actualAbortSignal);
         }
         else {
-            result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
-            this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, this.toolConfig, this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
             actualAbortSignal);
         }
         this.latestUsageMetadata = result.usageMetadata;
@@ -697,6 +704,10 @@ export function createContextAgentSession() {
         temperature: contextTempOverride !== null ? contextTempOverride : 1,
         topP: 0.95,
         topK: 40,
+    }, {
+        functionCallingConfig: {
+            mode: 'ANY',
+        },
     });
 }
 // ─── Intent Router Service ───────────────────────────────────────────

package/dist/services/contextAgent.js

@@ -2,9 +2,7 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import pc from 'picocolors';
 import { createContextAgentSession, createIntentRouterSession, createWebSearchAgentSession, createExecutionComplexitySession, } from './ai.js';
-import { evaluateInvestigationComplexity } from './investigationComplexity.js';
-import { InvestigationOrchestrator } from './orchestration/investigationOrchestrator.js';
-import { isSubAgentsEnabled, executeTool } from './agent-tools.js';
+import { executeTool } from './agent-tools.js';
 import { debugLog } from '../utils/logger.js';
 import { buildDependencyGraph } from '../utils/dependencyTracer.js';
 import { runEphemeralScript } from '../utils/analysisRunner.js';
@@ -418,23 +416,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
             chainedMessages: [],
         };
     }
-    // ─── Parallel Investigation Gate ─────────────────────────────
-    if (isSubAgentsEnabled()) {
-        // Determine complexity and domain breakdown
-        const approxFiles = projectTree.split('\n').length;
-        const complexity = await evaluateInvestigationComplexity(userRequest, projectType, approxFiles, chatHistory, abortSignal);
-        if (complexity.strategy === 'PARALLEL' && complexity.agentAssignments.length > 0) {
-            const orchestrator = new InvestigationOrchestrator();
-            const parallelResult = await orchestrator.runParallelInvestigation(userRequest, complexity.agentAssignments, workspaceRoot, projectTree, projectType, chatHistory, abortSignal, onProgress, onToolCall);
-            if (parallelResult !== null) {
-                // If parallel investigation succeeded, we are done. Return immediately.
-                parallelResult.isParallel = true;
-                return { contextResult: parallelResult, targetAgent, chainedMessages: [] };
-            }
-            // If it returned null, all agents crashed. Fall through to single agent fallback.
-        }
-    }
-    // ─── Single Agent Path (Fallback/Default) ────────────────────
+    // ─── Single Context Agent (Unified Reconnaissance) ───────────
     const session = createContextAgentSession();
     const relevantFiles = new Map();
     let summary = 'No relevant context found.';
@@ -450,6 +432,8 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     }
     currentMessage += `\n\nStart investigating to find relevant files.`;
     const MAX_TURNS = Infinity;
+    let textRetryCount = 0;
+    const MAX_TEXT_RETRIES = 2;
     for (let turn = 0; turn < MAX_TURNS; turn++) {
         if (abortSignal.aborted) {
             const err = new Error('Operation aborted');
@@ -489,8 +473,34 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
         }
         const functionCalls = result.response.functionCalls();
         if (!functionCalls || functionCalls.length === 0) {
-            // Model returned text instead of calling finish_investigation, just take the text as summary
-            summary = result.response.text();
+            const rawText = result.response.text() || '';
+            if (textRetryCount < MAX_TEXT_RETRIES) {
+                textRetryCount++;
+                debugLog(`[Context Agent] Model returned text with 0 tool calls. Rejecting and enforcing tool call (attempt ${textRetryCount}/${MAX_TEXT_RETRIES}).`);
+                currentMessage = `[SYSTEM DIRECTIVE (CRITICAL)]: You are a background investigation agent and must NEVER output conversational text directly. You MUST call tools (such as 'search_codebase', 'read_file', 'list_directory', 'find_dependencies', or 'finish_investigation'). You MUST conclude by calling the 'finish_investigation' tool with your findings and relevantFiles array.`;
+                continue;
+            }
+            // Fallback after retries: extract file paths from text
+            summary = rawText;
+            const fileRegex = /(?:[a-zA-Z0-9_-]+\/)+[a-zA-Z0-9_.-]+\.[a-zA-Z0-9]+/g;
+            const matches = rawText.match(fileRegex) || [];
+            const potentialFiles = Array.from(new Set(matches));
+            if (potentialFiles.length > 0) {
+                debugLog(`[Context Agent] Recovered ${potentialFiles.length} potential files from fallback text regex: ${potentialFiles.join(', ')}`);
+                const readResults = await Promise.all(potentialFiles.map(async (filePath) => {
+                    const readResult = await executeTool(workspaceRoot, 'read_file', { filePath });
+                    return { filePath, readResult };
+                }));
+                for (const { filePath, readResult } of readResults) {
+                    if (cumulativeFileTokens >= MAX_TOTAL_FILE_TOKENS)
+                        break;
+                    if (!readResult.error) {
+                        const boundedText = boundFileContent(filePath, readResult.output);
+                        relevantFiles.set(filePath, { text: boundedText, inlineData: readResult.inlineData });
+                        cumulativeFileTokens += estimateTokenCount(boundedText);
+                    }
+                }
+            }
             break;
         }
         let isFinished = false;

package/dist/services/orchestration/investigationAgent.js

@@ -11,13 +11,14 @@
  * components" + "Auth UI styling") and produces an `InvestigationResult` containing
  * the files it found and a summary of its findings.
  */
-import { ProxyChatSession, getContextToolDeclarations, getGlobalActiveModel } from '../ai.js';
+import { ProxyChatSession, getContextToolDeclarations, getGlobalActiveModel, getMultiWorkspaceBlock } from '../ai.js';
 import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { CONTEXT_SYSTEM_INSTRUCTION } from '../../utils/systemPrompts.js';
 import { debugLog } from '../../utils/logger.js';
 import { listDirectory, grepSearch, readFile, traceDependencies, findRecentChanges } from '../agent-tools.js';
 import { runEphemeralScript } from '../../utils/analysisRunner.js';
 import { formatToolCall } from '../agent/toolLoop.js';
+import { pruneTextToTokenBudget } from '../../utils/historyPrompt.js';
 // ─── Investigation Agent Runner ──────────────────────────────────────
 /**
  * Executes a read-only investigation within a scoped set of domains.
@@ -52,12 +53,16 @@ export class InvestigationAgentRunner {
         this.projectType = projectType;
         let model = getGlobalActiveModel();
         if (model === GEMINI_MODELS.AUTO || model.includes('claude'))
-            model = GEMINI_MODELS.FLASH_LITE;
+            model = GEMINI_MODELS.FLASH;
         this.chat = new ProxyChatSession(model, this.buildSystemInstruction(), getContextToolDeclarations(), {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 1,
             topP: 0.95,
             topK: 40,
+        }, {
+            functionCallingConfig: {
+                mode: 'ANY',
+            },
         });
     }
     /**
@@ -66,7 +71,7 @@ export class InvestigationAgentRunner {
      */
     buildSystemInstruction() {
         const domainList = this.domains.map((d) => `  - ${d}`).join('\n');
-        return (CONTEXT_SYSTEM_INSTRUCTION +
+        return (CONTEXT_SYSTEM_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()) +
             `\n\n<investigation_scope>` +
             `\nYou are investigation agent "${this.agentLabel}", part of a parallel investigation team.` +
             `\nYour assigned investigation domains:\n${domainList}` +
@@ -111,10 +116,13 @@ export class InvestigationAgentRunner {
             // Build the initial investigation prompt
             let currentMessage = `User Request: "${userRequest}"\n\nProject Type: ${this.projectType}\n\nProject Structure:\n${this.projectTree}`;
             if (chatHistory) {
-                currentMessage = `Previous Conversation Context:\n${chatHistory}\n\n` + currentMessage;
+                const prunedHistory = pruneTextToTokenBudget(chatHistory, 4500, { fromStart: true });
+                currentMessage = `Previous Conversation Context:\n${prunedHistory}\n\n` + currentMessage;
             }
             currentMessage += `\n\nStart investigating to find relevant files within your assigned domains.`;
             let isFinished = false;
+            let textRetryCount = 0;
+            const MAX_TEXT_RETRIES = 2;
             // Tool loop — mirrors the existing context agent loop in contextAgent.ts
             while (!crashed && !abortSignal.aborted && !isFinished) {
                 this.pingHeartbeat();
@@ -130,8 +138,34 @@ export class InvestigationAgentRunner {
                 this.updateUsage(result);
                 const functionCalls = result.response.functionCalls();
                 if (!functionCalls || functionCalls.length === 0) {
-                    // Model returned text — take as summary
-                    summary = result.response.text();
+                    const rawText = result.response.text() || '';
+                    if (textRetryCount < MAX_TEXT_RETRIES) {
+                        textRetryCount++;
+                        debugLog(`InvestigationAgent [${this.agentLabel}]: Model returned text with 0 tool calls. Rejecting and enforcing tool call (attempt ${textRetryCount}/${MAX_TEXT_RETRIES}).`);
+                        currentMessage = `[SYSTEM DIRECTIVE (CRITICAL)]: You are a background investigation agent and must NEVER output conversational text directly. You MUST call tools (such as 'search_codebase', 'read_file', 'list_directory', 'find_dependencies', or 'finish_investigation'). You MUST conclude by calling the 'finish_investigation' tool with your findings and relevantFiles array.`;
+                        continue;
+                    }
+                    // Fallback after retries: attempt to extract file paths mentioned in the text using regex
+                    summary = rawText;
+                    const fileRegex = /(?:[a-zA-Z0-9_-]+\/)+[a-zA-Z0-9_.-]+\.[a-zA-Z0-9]+/g;
+                    const matches = rawText.match(fileRegex) || [];
+                    const potentialFiles = Array.from(new Set(matches));
+                    if (potentialFiles.length > 0) {
+                        debugLog(`InvestigationAgent [${this.agentLabel}]: Recovered ${potentialFiles.length} potential files from fallback text regex: ${potentialFiles.join(', ')}`);
+                        await Promise.all(potentialFiles.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);
+                                }
+                            }
+                        }));
+                    }
                     success = true;
                     break;
                 }

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

@@ -17,15 +17,26 @@
  *   to prevent OOM on very large monorepos.
  */
 /**
- * In-memory file content cache shared across parallel investigation agents.
+ * Computes a standardized cache key for full-file or ranged/targeted read requests.
+ *
+ * @param filePath - Target relative or aliased file path.
+ * @param startLine - Optional 1-indexed starting line.
+ * @param endLine - Optional 1-indexed ending line.
+ * @param targetElements - Optional array of AST symbol names.
+ * @returns Serialized cache key string.
+ */
+export declare function computeReadCacheKey(filePath: string, startLine?: number, endLine?: number, targetElements?: string[]): string;
+/**
+ * In-memory file content cache shared across parallel investigation agents
+ * or scoped to individual execution sub-agents.
  *
  * Usage:
  * ```ts
  * const cache = new ReadCache()
- * // In tool wrapper:
- * if (cache.has(filePath)) return cache.get(filePath)!
- * const content = await fs.readFile(absPath, 'utf-8')
- * cache.set(filePath, content)
+ * const key = computeReadCacheKey(filePath, startLine, endLine)
+ * if (cache.has(key)) return cache.get(key)!
+ * const content = await readFile(root, filePath, startLine, endLine)
+ * cache.set(key, content)
  * ```
  */
 export declare class ReadCache {
@@ -36,15 +47,15 @@ export declare class ReadCache {
     private missCount;
     /**
      * Checks whether a file's content is already cached.
-     * @param filePath - Relative file path from workspace root.
+     * @param keyOrPath - Relative file path or computed cache key.
      */
-    has(filePath: string): boolean;
+    has(keyOrPath: string): boolean;
     /**
-     * Retrieves cached content for a file.
-     * @param filePath - Relative file path from workspace root.
+     * Retrieves cached content for a file or key.
+     * @param keyOrPath - Relative file path or computed cache key.
      * @returns The file content, or undefined if not cached.
      */
-    get(filePath: string): {
+    get(keyOrPath: string): {
         text: string;
         inlineData?: any;
     } | undefined;
@@ -52,13 +63,24 @@ export declare class ReadCache {
      * Stores file content in the cache. If adding this entry would exceed
      * the memory cap, older entries are evicted in insertion order (LRU).
      *
-     * @param filePath - Relative file path from workspace root.
+     * @param keyOrPath - Relative file path or computed cache key.
      * @param content - The file's text content.
      */
-    set(filePath: string, content: {
+    set(keyOrPath: string, content: {
         text: string;
         inlineData?: any;
     }): void;
+    /**
+     * Invalidates and evicts all cache entries associated with a file path,
+     * including full-file reads and any ranged or targeted sub-reads.
+     *
+     * @param filePath - The file path that was modified or deleted.
+     */
+    invalidate(filePath: string): void;
+    /**
+     * Clears all cached file entries and resets byte counts.
+     */
+    clear(): void;
     /**
      * Returns all cached file entries. Used by the Reducer to assemble
      * the merged file set without re-reading from disk.

package/dist/services/orchestration/readCache.js

@@ -21,17 +21,38 @@ import { getMetricCollector } from '../metrics.js';
 // ─── Constants ───────────────────────────────────────────────────────
 /** Maximum total bytes of cached file content before LRU eviction kicks in. */
 const MAX_CACHE_BYTES = 5 * 1024 * 1024; // 5 MB
+// ─── Key Computation Helper ──────────────────────────────────────────
+/**
+ * Computes a standardized cache key for full-file or ranged/targeted read requests.
+ *
+ * @param filePath - Target relative or aliased file path.
+ * @param startLine - Optional 1-indexed starting line.
+ * @param endLine - Optional 1-indexed ending line.
+ * @param targetElements - Optional array of AST symbol names.
+ * @returns Serialized cache key string.
+ */
+export function computeReadCacheKey(filePath, startLine, endLine, targetElements) {
+    const hasLines = startLine !== undefined || endLine !== undefined;
+    const hasElems = Array.isArray(targetElements) && targetElements.length > 0;
+    if (!hasLines && !hasElems) {
+        return filePath;
+    }
+    const linePart = hasLines ? `::lines=${startLine || 1}-${endLine || 'end'}` : '';
+    const elemPart = hasElems ? `::elems=${[...targetElements].sort().join(',')}` : '';
+    return `${filePath}${linePart}${elemPart}`;
+}
 // ─── Read Cache Implementation ───────────────────────────────────────
 /**
- * In-memory file content cache shared across parallel investigation agents.
+ * In-memory file content cache shared across parallel investigation agents
+ * or scoped to individual execution sub-agents.
  *
  * Usage:
  * ```ts
  * const cache = new ReadCache()
- * // In tool wrapper:
- * if (cache.has(filePath)) return cache.get(filePath)!
- * const content = await fs.readFile(absPath, 'utf-8')
- * cache.set(filePath, content)
+ * const key = computeReadCacheKey(filePath, startLine, endLine)
+ * if (cache.has(key)) return cache.get(key)!
+ * const content = await readFile(root, filePath, startLine, endLine)
+ * cache.set(key, content)
  * ```
  */
 export class ReadCache {
@@ -42,10 +63,10 @@ export class ReadCache {
     missCount = 0;
     /**
      * Checks whether a file's content is already cached.
-     * @param filePath - Relative file path from workspace root.
+     * @param keyOrPath - Relative file path or computed cache key.
      */
-    has(filePath) {
-        const found = this.cache.has(filePath);
+    has(keyOrPath) {
+        const found = this.cache.has(keyOrPath);
         const collector = getMetricCollector();
         if (found) {
             this.hitCount++;
@@ -58,23 +79,23 @@ export class ReadCache {
         return found;
     }
     /**
-     * Retrieves cached content for a file.
-     * @param filePath - Relative file path from workspace root.
+     * Retrieves cached content for a file or key.
+     * @param keyOrPath - Relative file path or computed cache key.
      * @returns The file content, or undefined if not cached.
      */
-    get(filePath) {
-        return this.cache.get(filePath);
+    get(keyOrPath) {
+        return this.cache.get(keyOrPath);
     }
     /**
      * Stores file content in the cache. If adding this entry would exceed
      * the memory cap, older entries are evicted in insertion order (LRU).
      *
-     * @param filePath - Relative file path from workspace root.
+     * @param keyOrPath - Relative file path or computed cache key.
      * @param content - The file's text content.
      */
-    set(filePath, content) {
+    set(keyOrPath, content) {
         // Don't re-insert if already cached
-        if (this.cache.has(filePath))
+        if (this.cache.has(keyOrPath))
             return;
         const entryBytes = Buffer.byteLength(content.text, 'utf-8');
         // Evict oldest entries until there is room
@@ -87,10 +108,47 @@ export class ReadCache {
                 debugLog(`ReadCache: Evicted "${oldest}" to stay under ${MAX_CACHE_BYTES} byte cap.`);
             }
         }
-        this.cache.set(filePath, content);
-        this.insertionOrder.push(filePath);
+        this.cache.set(keyOrPath, content);
+        this.insertionOrder.push(keyOrPath);
         this.totalBytes += entryBytes;
     }
+    /**
+     * Invalidates and evicts all cache entries associated with a file path,
+     * including full-file reads and any ranged or targeted sub-reads.
+     *
+     * @param filePath - The file path that was modified or deleted.
+     */
+    invalidate(filePath) {
+        if (!filePath)
+            return;
+        const prefix = `${filePath}::`;
+        const keysToRemove = [];
+        for (const key of this.cache.keys()) {
+            if (key === filePath || key.startsWith(prefix)) {
+                keysToRemove.push(key);
+            }
+        }
+        for (const key of keysToRemove) {
+            const evicted = this.cache.get(key);
+            if (evicted !== undefined) {
+                this.totalBytes -= Buffer.byteLength(evicted.text, 'utf-8');
+                this.cache.delete(key);
+                debugLog(`ReadCache: Invalidated "${key}"`);
+            }
+            const idx = this.insertionOrder.indexOf(key);
+            if (idx !== -1) {
+                this.insertionOrder.splice(idx, 1);
+            }
+        }
+    }
+    /**
+     * Clears all cached file entries and resets byte counts.
+     */
+    clear() {
+        this.cache.clear();
+        this.insertionOrder = [];
+        this.totalBytes = 0;
+    }
     /**
      * Returns all cached file entries. Used by the Reducer to assemble
      * the merged file set without re-reading from disk.

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

@@ -1,5 +1,6 @@
 import { MessageBus } from './messageBus.js';
 import { FileLockRegistry } from './fileLockRegistry.js';
+import { ReadCache } from './readCache.js';
 import { type PathResolutionOptions } from '../../utils/pathSecurity.js';
 /**
  * Resolves a file path to its canonical absolute path for lock registry keying,
@@ -25,7 +26,7 @@ export declare function getScopedToolDeclarations(): any[];
 /**
  * Executes a tool within the sub-agent execution boundary.
  * Handles concurrency locking for file-mutating operations, sends progress
- * notifications to the orchestrator, and logs activity to the message bus.
+ * notifications to the orchestrator, checks per-agent read caches, and logs activity to the message bus.
  *
  * @param name - Tool function name
  * @param args - Tool arguments object
@@ -36,5 +37,6 @@ export declare function getScopedToolDeclarations(): any[];
  * @param onProgress - Callback to notify parent of sub-agent progress
  * @param options - Optional sub-path auto-focus and override configuration
  * @param taskScope - Optional task scope metadata (targetFiles, dependsOn)
+ * @param readCache - Optional per-agent in-memory file read cache
  */
-export declare function executeScopedTool(name: string, args: Record<string, any>, workspaceRoot: string, agentId: string, bus: MessageBus, locks: FileLockRegistry, onProgress: (msg?: string) => void, options?: PathResolutionOptions, taskScope?: TaskScope): Promise<any>;
+export declare function executeScopedTool(name: string, args: Record<string, any>, workspaceRoot: string, agentId: string, bus: MessageBus, locks: FileLockRegistry, onProgress: (msg?: string) => void, options?: PathResolutionOptions, taskScope?: TaskScope, readCache?: ReadCache): Promise<any>;