minovative-mind-cli 2.4.0 → 2.5.1

package/dist/services/ai.js

@@ -1,12 +1,14 @@
-import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS } from '../utils/config.js';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { GEMINI_MODELS, DEFAULT_MODEL, MAX_OUTPUT_TOKENS, isByokEnabled } from '../utils/config.js';
 import { getToolDeclarations } from './agent-tools.js';
-import { ProxyClient } from './proxyClient.js';
+import { getMetricCollector } from './metrics.js';
 import { getAuthorizedIdToken } from './auth.js';
 import { debugLog } from '../utils/logger.js';
 import { readCache, writeCache } from '../utils/projectStorage.js';
 import { GENERAL_CHAT_INSTRUCTION, PLAN_EXECUTION_INSTRUCTION, PLAN_MODE_INSTRUCTION, CONTEXT_SYSTEM_INSTRUCTION, INTENT_ROUTER_SYSTEM_INSTRUCTION, WEB_SEARCH_SYSTEM_INSTRUCTION, EXECUTION_COMPLEXITY_SYSTEM_INSTRUCTION, INVESTIGATION_COMPLEXITY_SYSTEM_INSTRUCTION, } from '../utils/systemPrompts.js';
-import { getMetricCollector } from './metrics.js';
 import { workspaceRegistry } from './workspaceRegistry.js';
+import { loadCredentials } from '../utils/credentialStore.js';
+import { ProxyClient, accumulateTurnUsage } from './proxyClient.js';
 function getMultiWorkspaceBlock() {
     const summary = workspaceRegistry.buildPromptSummary();
     if (!summary)
@@ -206,15 +208,57 @@ export class ProxyChatSession {
         // Prune old history before sending to keep payload bounded
         await this.pruneHistory();
         const effectiveGenerationConfig = { ...this.generationConfig };
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
-        this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
-        abortSignal);
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            const creds = await loadCredentials();
+            const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+            const model = genAI.getGenerativeModel({
+                model: this.modelName,
+                systemInstruction: this.systemInstruction,
+                tools: this.tools,
+            });
+            const chat = model.startChat({
+                history: this.history.slice(0, -1),
+                generationConfig: effectiveGenerationConfig,
+            });
+            const lastMessage = this.history[this.history.length - 1];
+            try {
+                const response = await chat.sendMessage(lastMessage.parts);
+                const responseObj = await response.response;
+                result = {
+                    functionCalls: responseObj.functionCalls(),
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    const collector = getMetricCollector();
+                    collector?.accumulateUsage(responseObj.usageMetadata);
+                }
+            }
+            catch (error) {
+                debugLog(`Failed to send message via BYOK: ${error}`);
+                const errorMessage = error?.message || '';
+                if (error?.status === 401 ||
+                    error?.status === 403 ||
+                    errorMessage.includes('API_KEY_INVALID') ||
+                    errorMessage.includes('quota') ||
+                    errorMessage.includes('PERMISSION_DENIED')) {
+                    throw new Error('AI_BYOK_ERROR: Your API key or quota is invalid. Please run /config-key to update your settings.');
+                }
+                throw error;
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, this.modelName, this.history, this.tools, undefined, // toolConfig
+            this.systemInstruction, effectiveGenerationConfig, onChunk ? { onChunk } : undefined, // streamCallbacks
+            abortSignal);
+        }
         this.latestUsageMetadata = result.usageMetadata;
         // Track token usage metrics
         if (result.usageMetadata) {
-            const { accumulateUsage } = await import('./metrics.js');
-            accumulateUsage(result.usageMetadata);
             const collector = getMetricCollector();
+            collector?.accumulateUsage(result.usageMetadata);
             if (collector) {
                 collector.recordTokenUsage(result.usageMetadata.promptTokens || 0, result.usageMetadata.candidatesTokens || 0, result.usageMetadata.cachedTokens || 0);
             }
@@ -323,8 +367,38 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
             parts.push({ inlineData });
         }
         const contents = [{ role: 'user', parts }];
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
-        undefined, instruction, { temperature: 0.2 });
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            try {
+                const creds = await loadCredentials();
+                const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+                const modelObj = genAI.getGenerativeModel({
+                    model,
+                    systemInstruction: instruction,
+                });
+                const response = await modelObj.generateContent({
+                    contents: [{ role: 'user', parts }],
+                    generationConfig: { temperature: 0.2 },
+                });
+                const responseObj = await response.response;
+                result = {
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    accumulateTurnUsage(responseObj.usageMetadata, model);
+                }
+            }
+            catch (error) {
+                console.error('BYOK Error:', error.message);
+                throw new Error(`BYOK AI Error: ${error.message}`);
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
+            undefined, instruction, { temperature: 0.2 });
+        }
         let textPart = '';
         if (result.parts) {
             // Use highly optimized local loop instead of array search to avoid callback allocation and naive database regex flags
@@ -340,6 +414,9 @@ export async function compressTextUsingFlashLite(text, instruction = "<directive
     }
     catch (error) {
         debugLog(`Failed to compress text using flash-lite: ${error}`);
+        if (error?.status === 401 || error?.status === 403 || error?.message?.includes('API_KEY_INVALID') || error?.message?.includes('quota')) {
+            throw new Error('AI_AUTH_ERROR: Your API key or quota is invalid. Please run /config-key or re-login.');
+        }
         return text; // fallback to raw text if compression fails
     }
 }
@@ -583,8 +660,38 @@ export async function generateChatTitle(firstMessage) {
         let model = getGlobalActiveModel();
         if (model === 'auto')
             model = GEMINI_MODELS.FLASH_LITE;
-        const result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
-        undefined, instruction, { temperature: 0.2 });
+        const byokEnabled = await isByokEnabled();
+        let result;
+        if (byokEnabled) {
+            try {
+                const creds = await loadCredentials();
+                const genAI = new GoogleGenerativeAI(creds.geminiApiKey);
+                const modelObj = genAI.getGenerativeModel({
+                    model,
+                    systemInstruction: instruction,
+                });
+                const response = await modelObj.generateContent({
+                    contents,
+                    generationConfig: { temperature: 0.2 },
+                });
+                const responseObj = await response.response;
+                result = {
+                    parts: responseObj.candidates?.[0]?.content?.parts,
+                    usageMetadata: responseObj.usageMetadata,
+                };
+                if (responseObj.usageMetadata) {
+                    accumulateTurnUsage(responseObj.usageMetadata, model);
+                }
+            }
+            catch (error) {
+                console.error('BYOK Error:', error.message);
+                throw new Error(`BYOK AI Error: ${error.message}`);
+            }
+        }
+        else {
+            result = await proxyClient.generateFunctionCallViaProxy(idToken, model, contents, [], // no tools
+            undefined, instruction, { temperature: 0.2 });
+        }
         let title = '';
         if (result.parts) {
             for (const p of result.parts) {
@@ -599,7 +706,15 @@ export async function generateChatTitle(firstMessage) {
         return title ? title : firstMessage.substring(0, maxLength);
     }
     catch (error) {
-        debugLog(`Failed to generate chat title: ${error}`);
+        debugLog(`Failed to generate chat title via BYOK: ${error}`);
+        const errorMessage = error?.message || '';
+        if (error?.status === 401 ||
+            error?.status === 403 ||
+            errorMessage.includes('API_KEY_INVALID') ||
+            errorMessage.includes('quota') ||
+            errorMessage.includes('PERMISSION_DENIED')) {
+            throw new Error('AI_BYOK_ERROR: Your API key or quota is invalid. Please run /config-key to update your settings.');
+        }
         return firstMessage.substring(0, maxLength);
     }
 }

package/dist/services/changeLogger.js

@@ -21,7 +21,7 @@ class ChangeLogger {
      * Maximum number of historical changesets retained in memory and on disk.
      * Older changesets are discarded on save once this limit is exceeded.
      */
-    MAX_HISTORY = 10;
+    MAX_HISTORY = 20;
     /**
      * Whether the change logger is currently enabled.
      */
@@ -66,7 +66,7 @@ class ChangeLogger {
         }
         writeCache(this.workspaceRoot, 'revert_state.json', {
             history: this.changeStack,
-            isEnabled: this.isEnabled
+            isEnabled: this.isEnabled,
         });
     }
     /**

package/dist/services/contextAgent.js

@@ -222,7 +222,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 cachedFiles.set(filePath, { text: readResult.output, inlineData: readResult.inlineData });
             }
         }
-        const MAX_TOTAL_FILES = 15;
+        const MAX_TOTAL_FILES = 30;
         try {
             const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
             const autoDiscovered = new Set();
@@ -255,10 +255,10 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 projectType,
                 summary: cacheHit.entry.summary,
                 relevantFiles: cachedFiles,
-                fromMemoryBank: true
+                fromMemoryBank: true,
             },
             targetAgent,
-            chainedMessages: []
+            chainedMessages: [],
         };
     }
     // ─── Parallel Investigation Gate ─────────────────────────────
@@ -282,9 +282,6 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     const relevantFiles = new Map();
     let summary = 'No relevant context found.';
     let isInvestigationFinished = false;
-    const visitedToolCalls = new Set();
-    let consecutiveDuplicates = 0;
-    const MAX_CONSECUTIVE_DUPLICATES = 3;
     let chainedMessages = [];
     let webSearchSummary = '';
     // Initial prompt
@@ -336,33 +333,6 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
             if (abortSignal.aborted)
                 break;
             const args = call.args;
-            // Deduplicate identical tool calls
-            const callSignature = `${call.name}:${JSON.stringify(args)}`;
-            if (call.name !== 'finish_investigation' && visitedToolCalls.has(callSignature)) {
-                consecutiveDuplicates++;
-                if (consecutiveDuplicates >= MAX_CONSECUTIVE_DUPLICATES) {
-                    // Force-finish: the model is stuck in a loop, finalize with whatever context we have
-                    const forceMsg = `Investigation auto-completed: the model repeated the same tool call ${MAX_CONSECUTIVE_DUPLICATES} times consecutively.`;
-                    debugLog(`[Context Agent] ${forceMsg}`);
-                    if (onProgress)
-                        onProgress(forceMsg);
-                    if (!summary || summary === 'No relevant context found.') {
-                        summary = 'Investigation was auto-completed due to repeated duplicate tool calls. Review the gathered files for context.';
-                    }
-                    isFinished = true;
-                    isInvestigationFinished = relevantFiles.size > 0;
-                    break;
-                }
-                functionResponses.push({
-                    functionResponse: {
-                        name: call.name,
-                        response: { error: `DUPLICATE CALL BLOCKED (attempt ${consecutiveDuplicates}/${MAX_CONSECUTIVE_DUPLICATES}): You already executed this exact tool call. Do NOT retry it. Use the results you already have and call finish_investigation now, or try a DIFFERENT tool call with different parameters.` }
-                    }
-                });
-                continue;
-            }
-            consecutiveDuplicates = 0;
-            visitedToolCalls.add(callSignature);
             let logMsg = `  [Context Agent] Executing ${call.name}`;
             if (call.name === 'finish_investigation') {
                 const filesToRead = args.relevantFiles || [];
@@ -420,7 +390,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
                 // When the Context Agent finalizes its investigation, we automatically
                 // discover files that DEPEND ON the selected files. This ensures the
                 // Execution Agent won't break imports when modifying/deleting/renaming.
-                const MAX_TOTAL_FILES = 15;
+                const MAX_TOTAL_FILES = 30;
                 try {
                     const { resolveAndValidateMultiWorkspacePath } = await import('../utils/pathSecurity.js');
                     const autoDiscovered = new Set();
@@ -599,7 +569,7 @@ export async function gatherContext(workspaceRoot, userRequest, chatHistory = ''
     if (collector) {
         collector.recordContextSelectedFiles(Array.from(relevantFiles.keys()));
         if (!isInvestigationFinished || relevantFiles.size === 0) {
-            collector.recordInvestigationFailure();
+            collector?.recordInvestigationFailure?.();
         }
     }
     if (isInvestigationFinished && relevantFiles.size > 0) {

package/dist/services/metrics.d.ts

@@ -16,15 +16,13 @@ export interface MetricCollector {
     recordSelfCorrection(): void;
     recordVerificationResult(passed: boolean): void;
     recordMatchTier(tier: 'exact' | 'normalized' | 'levenshtein' | 'none'): void;
-    recordCacheHit(): void;
-    recordCacheMiss(): void;
-    recordInvestigationFailure(): void;
-    recordToolFailure(toolName: string): void;
-    recordModifyFailure(): void;
-    recordWriteFailure(): void;
-    recordCacheHit(cacheType: 'investigation' | 'read'): void;
-    recordCacheMiss(cacheType: 'investigation' | 'read'): void;
+    recordCacheHit(cacheType?: 'investigation' | 'read'): void;
+    recordCacheMiss(cacheType?: 'investigation' | 'read'): void;
     recordCachePerformance(cacheType: 'investigation' | 'read', durationMs: number): void;
+    recordWriteFailure?(): void;
+    recordModifyFailure?(): void;
+    recordToolFailure?(toolName?: string): void;
+    recordInvestigationFailure?(): void;
 }
 export declare function setMetricCollector(collector: MetricCollector | null): void;
 export declare function getMetricCollector(): MetricCollector | null;

package/dist/services/orchestration/investigationAgent.js

@@ -113,9 +113,6 @@ export class InvestigationAgentRunner {
             }
             currentMessage += `\n\nStart investigating to find relevant files within your assigned domains.`;
             let isFinished = false;
-            const visitedToolCalls = new Set();
-            let consecutiveDuplicates = 0;
-            const MAX_CONSECUTIVE_DUPLICATES = 3;
             // Tool loop — mirrors the existing context agent loop in contextAgent.ts
             while (!crashed && !abortSignal.aborted && !isFinished) {
                 this.pingHeartbeat();
@@ -143,35 +140,6 @@ export class InvestigationAgentRunner {
                     this.pingHeartbeat();
                     const args = call.args;
                     const logPrefix = `[${this.agentLabel}]`;
-                    // Deduplicate identical tool calls
-                    const callSignature = `${call.name}:${JSON.stringify(args)}`;
-                    if (call.name !== 'finish_investigation' && visitedToolCalls.has(callSignature)) {
-                        consecutiveDuplicates++;
-                        if (consecutiveDuplicates >= MAX_CONSECUTIVE_DUPLICATES) {
-                            // Force-finish: the model is stuck in a loop
-                            const forceMsg = `Investigation auto-completed: the model repeated the same tool call ${MAX_CONSECUTIVE_DUPLICATES} times consecutively.`;
-                            debugLog(`InvestigationAgent [${this.agentLabel}]: ${forceMsg}`);
-                            if (onProgress)
-                                onProgress(`[${this.agentLabel}] ${forceMsg}`);
-                            if (!summary || summary === 'No relevant context found.') {
-                                summary = 'Investigation was auto-completed due to repeated duplicate tool calls. Review the gathered files for context.';
-                            }
-                            isFinished = true;
-                            success = relevantFiles.size > 0;
-                            break;
-                        }
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: {
-                                    error: `DUPLICATE CALL BLOCKED (attempt ${consecutiveDuplicates}/${MAX_CONSECUTIVE_DUPLICATES}): You already executed this exact tool call. Do NOT retry it. Use the results you already have and call finish_investigation now, or try a DIFFERENT tool call with different parameters.`,
-                                },
-                            },
-                        });
-                        continue;
-                    }
-                    consecutiveDuplicates = 0;
-                    visitedToolCalls.add(callSignature);
                     if (call.name === 'finish_investigation') {
                         summary = args.summary || '';
                         const filesToRead = args.relevantFiles || [];

package/dist/services/orchestration/investigationOrchestrator.js

@@ -27,7 +27,7 @@ import { buildDependencyGraph } from '../../utils/dependencyTracer.js';
 import { debugLog } from '../../utils/logger.js';
 // ─── Constants ───────────────────────────────────────────────────────
 /** Maximum total relevant files across all agents after merge. */
-const MAX_TOTAL_FILES = 15;
+const MAX_TOTAL_FILES = 30;
 // ─── Investigation Orchestrator ──────────────────────────────────────
 export class InvestigationOrchestrator {
     /**

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

@@ -86,7 +86,7 @@ export declare class MessageBus {
     private readonly persistPath;
     private readonly workspaceRoot;
     /** Maximum semantic signals any single agent can post */
-    static readonly MAX_SIGNALS_PER_AGENT = 20;
+    static readonly MAX_SIGNALS_PER_AGENT = 50;
     constructor(workspaceRoot: string, conversationId: string);
     /**
      * Records a tool execution into the activity log. Called by the scoped tool

package/dist/services/orchestration/messageBus.js

@@ -38,7 +38,7 @@ export class MessageBus {
     persistPath;
     workspaceRoot;
     /** Maximum semantic signals any single agent can post */
-    static MAX_SIGNALS_PER_AGENT = 20;
+    static MAX_SIGNALS_PER_AGENT = 50;
     constructor(workspaceRoot, conversationId) {
         this.workspaceRoot = workspaceRoot;
         const orchestrationDir = path.join(workspaceRoot, '.minovativemind', 'orchestration');
@@ -64,7 +64,7 @@ export class MessageBus {
      * @returns `true` if the signal was accepted, `false` if the agent hit the cap.
      */
     postSignal(signal) {
-        const agentSignalCount = this.signals.filter(s => s.fromAgent === signal.fromAgent).length;
+        const agentSignalCount = this.signals.filter((s) => s.fromAgent === signal.fromAgent).length;
         if (agentSignalCount >= MessageBus.MAX_SIGNALS_PER_AGENT) {
             debugLog(`MessageBus: Agent ${signal.fromAgent} hit signal cap (${MessageBus.MAX_SIGNALS_PER_AGENT}). ` +
                 `Dropping signal of type "${signal.type}".`);
@@ -85,12 +85,8 @@ export class MessageBus {
     getUnread(agentId) {
         const actCursor = this.activityCursors.get(agentId) ?? 0;
         const sigCursor = this.signalCursors.get(agentId) ?? 0;
-        const activities = this.activityLog
-            .slice(actCursor)
-            .filter(e => e.agentId !== agentId);
-        const signals = this.signals
-            .slice(sigCursor)
-            .filter(s => s.fromAgent !== agentId);
+        const activities = this.activityLog.slice(actCursor).filter((e) => e.agentId !== agentId);
+        const signals = this.signals.slice(sigCursor).filter((s) => s.fromAgent !== agentId);
         // Advance cursors to current end
         this.activityCursors.set(agentId, this.activityLog.length);
         this.signalCursors.set(agentId, this.signals.length);
@@ -111,7 +107,7 @@ export class MessageBus {
      * recovery — collecting partial progress before re-dispatch).
      */
     getAgentActivity(agentId) {
-        return this.activityLog.filter(e => e.agentId === agentId);
+        return this.activityLog.filter((e) => e.agentId === agentId);
     }
     /**
      * Returns the total number of activity entries and signals in the bus.
@@ -131,11 +127,13 @@ export class MessageBus {
     static formatActivityEntries(entries) {
         if (entries.length === 0)
             return '';
-        return entries.map(e => {
+        return entries
+            .map((e) => {
             const statusIcon = e.status === 'success' ? '✓' : '✗';
             const summary = e.resultSummary ? ` | ${e.resultSummary}` : '';
             return `  ${e.agentId} | ${e.tool.padEnd(14)} → ${e.target.padEnd(40)} | ${statusIcon} ${e.action}${summary}`;
-        }).join('\n');
+        })
+            .join('\n');
     }
     /**
      * Formats semantic signals into a readable string for agent context injection.
@@ -143,7 +141,8 @@ export class MessageBus {
     static formatSignals(signals) {
         if (signals.length === 0)
             return '';
-        return signals.map(s => {
+        return signals
+            .map((s) => {
             const tag = s.type.toUpperCase();
             switch (s.type) {
                 case 'discovery':
@@ -157,7 +156,8 @@ export class MessageBus {
                 default:
                     return `  [SIGNAL from ${s.fromAgent}]: ${JSON.stringify(s)}`;
             }
-        }).join('\n');
+        })
+            .join('\n');
     }
     // ─── Persistence ─────────────────────────────────────────────────
     /**
@@ -173,7 +173,7 @@ export class MessageBus {
             signalCursors: Object.fromEntries(this.signalCursors),
         };
         // Fire-and-forget — don't block the calling agent's tool loop
-        atomicWriteFile(this.persistPath, JSON.stringify(snapshot)).catch(err => {
+        atomicWriteFile(this.persistPath, JSON.stringify(snapshot)).catch((err) => {
             debugLog(`MessageBus: Failed to persist to disk: ${err}`);
         });
     }

package/dist/services/orchestration/readCache.js

@@ -17,6 +17,7 @@
  *   to prevent OOM on very large monorepos.
  */
 import { debugLog } from '../../utils/logger.js';
+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
@@ -45,7 +46,6 @@ export class ReadCache {
      */
     has(filePath) {
         const found = this.cache.has(filePath);
-        const { getMetricCollector } = require('./metrics.js');
         const collector = getMetricCollector();
         if (found) {
             this.hitCount++;

package/dist/services/orchestration/scopedTools.js

@@ -145,7 +145,8 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
         else if (name === 'grep_search') {
             targetDesc = args.pattern;
             actionDesc = 'Searched';
-            const matchCount = Array.isArray(result) ? result.length : 0;
+            const outputText = typeof result === 'object' && result?.output ? result.output : String(result || '');
+            const matchCount = (outputText.match(/\.\/[^:]+:\d+:/g) || []).length;
             resultSummary = `${matchCount} matches`;
         }
         return result;

package/dist/services/orchestration/subAgent.js

@@ -63,11 +63,14 @@ export class SubAgentRunner {
             `${this.globalContext}\n` +
             `</reference_context>\n\n` +
             `<critical_guidelines>\n` +
-            `1. You are ONE worker in a team. You MUST ONLY focus on your specific objective: "${this.intent}".\n` +
-            `2. DO NOT attempt to fulfill the entire original user request in the reference context. Other agents are handling the other parts.\n` +
-            `3. You are part of a parallelized system. Use 'post_message' to coordinate if you discover breaking changes.\n` +
-            `4. When you have completed your objective, stop using tools and provide a final summary of your work.\n` +
-            `5. If you encounter an insurmountable error, provide a summary of what went wrong so the orchestrator can re-assign or fix it.\n` +
+            `1. You are ONE worker in a team. Focus EXCLUSIVELY on your specific objective: "${this.intent}".\n` +
+            `2. DO NOT attempt to fulfill the entire original user request in the reference context. Other agents handle other tasks.\n` +
+            `3. EXECUTION WORKFLOW:\n` +
+            `   - Step 1 (Locate): Call 'grep_search' or 'read_file' ONCE to inspect the file you need to edit.\n` +
+            `   - Step 2 (Modify): Call 'modify_file' or 'write_file' to implement the required changes.\n` +
+            `   - Step 3 (Conclude): Immediately STOP using tools and return a text summary of your changes.\n` +
+            `4. Do NOT call 'grep_search' or 'run_command' repeatedly in a loop. Once you have file context or command results, proceed directly to modifying code or responding with your text summary.\n` +
+            `5. Use 'post_message' only if you discover breaking changes affecting other agents.\n` +
             `</critical_guidelines>`);
     }
     /**
@@ -87,12 +90,10 @@ export class SubAgentRunner {
      */
     async execute(signal) {
         return runWithAgentId(this.taskId, async () => {
-            debugLog(`SubAgent [${this.taskId}]: Starting execution.`);
-            this.lastHeartbeat = Date.now();
             let success = false;
             let finalSummary = '';
             let crashed = false;
-            // Health Monitor Timer
+            // Health monitor interval: checks every 5s if the last tool execution/heartbeat stalled
             const healthMonitor = setInterval(() => {
                 if (Date.now() - this.lastHeartbeat > SubAgentRunner.STALL_TIMEOUT_MS) {
                     debugLog(`SubAgent [${this.taskId}]: STALL DETECTED. No heartbeat for ${SubAgentRunner.STALL_TIMEOUT_MS}ms.`);
@@ -103,14 +104,12 @@ export class SubAgentRunner {
             }, 5000);
             try {
                 // Send initial prompt
-                const prompt = `Begin execution for task: ${this.taskId}\nObjective: ${this.intent}\n\nYou must use tools to achieve this objective. Do not stop until the objective is fully complete.`;
+                const prompt = `Begin execution for task: ${this.taskId}\nObjective: ${this.intent}\n\nFollow the 3-step workflow: 1) inspect file -> 2) modify code -> 3) respond with text summary. Do not repeat search tools once results are returned.`;
                 let turnResult = await this.chat.sendMessage(prompt, undefined, signal);
                 this.updateUsage(turnResult);
                 // Tool Loop
                 const MAX_TURNS = Infinity;
                 let turns = 0;
-                // Anti-loop tracking
-                const visitedToolCalls = new Set();
                 while (turns < MAX_TURNS && !crashed && !signal.aborted) {
                     this.pingHeartbeat();
                     const calls = turnResult.response.functionCalls();
@@ -125,21 +124,6 @@ export class SubAgentRunner {
                     for (const call of calls) {
                         if (crashed || signal.aborted)
                             break;
-                        // Anti-loop check: Hash the call to detect exact repetitions
-                        const callSignature = `${call.name}:${JSON.stringify(call.args)}`;
-                        if (visitedToolCalls.has(callSignature)) {
-                            debugLog(`SubAgent [${this.taskId}]: Detected identical tool call ${call.name}. Blocking to prevent loop.`);
-                            toolResponses.push({
-                                functionResponse: {
-                                    name: call.name,
-                                    response: {
-                                        error: 'You have already made this exact tool call previously. Please review your context history or try a different action.',
-                                    },
-                                },
-                            });
-                            continue;
-                        }
-                        visitedToolCalls.add(callSignature);
                         this.pingHeartbeat();
                         if (this.onProgress) {
                             this.onProgress(`executing ${call.name}...`);
@@ -152,6 +136,9 @@ export class SubAgentRunner {
                         catch (err) {
                             responseData = { error: err.message || String(err) };
                         }
+                        // Log tool output to help diagnose issues (truncated to avoid giant logs)
+                        const outputStr = JSON.stringify(responseData);
+                        debugLog(`SubAgent [${this.taskId}]: Tool ${call.name} returned -> ${outputStr.length > 500 ? outputStr.substring(0, 1000) + '... (truncated)' : outputStr}`);
                         toolResponses.push({
                             functionResponse: {
                                 name: call.name,

package/dist/services/proxyClient.d.ts

@@ -32,6 +32,14 @@ export declare function peekTurnUsage(): {
     remainingBalance: number | undefined;
     modelsUsed: Record<string, number>;
 };
+export declare function accumulateTurnUsage(usage: {
+    promptTokens?: number;
+    candidatesTokens?: number;
+    cachedTokens?: number;
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    cachedContentTokenCount?: number;
+}, modelName: string): void;
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.

package/dist/services/proxyClient.js

@@ -1,4 +1,5 @@
 import { debugLog } from '../utils/logger.js';
+import { getMetricCollector } from './metrics.js';
 /**
  * ============================================================================
  *                               PROXY CLIENT SERVICE
@@ -58,6 +59,16 @@ export function getAndResetTurnUsage() {
 export function peekTurnUsage() {
     return { ...globalSessionAccumulatedUsage };
 }
+export function accumulateTurnUsage(usage, modelName) {
+    const pTokens = usage.promptTokens ?? usage.promptTokenCount ?? 0;
+    const cTokens = usage.candidatesTokens ?? usage.candidatesTokenCount ?? 0;
+    const cachedTokens = usage.cachedTokens ?? usage.cachedContentTokenCount ?? 0;
+    globalSessionAccumulatedUsage.promptTokens += pTokens;
+    globalSessionAccumulatedUsage.candidatesTokens += cTokens;
+    globalSessionAccumulatedUsage.cachedTokens += cachedTokens;
+    globalSessionAccumulatedUsage.totalTokenCount += pTokens + cachedTokens + cTokens;
+    globalSessionAccumulatedUsage.modelsUsed[modelName] = (globalSessionAccumulatedUsage.modelsUsed[modelName] || 0) + 1;
+}
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.
@@ -183,6 +194,12 @@ export class ProxyClient {
                             else if (data.type === 'done') {
                                 if (data.usage) {
                                     usageMetadata = data.usage;
+                                    const collector = getMetricCollector();
+                                    collector?.accumulateUsage({
+                                        promptTokens: data.usage.promptTokens || 0,
+                                        candidatesTokens: data.usage.candidatesTokens || 0,
+                                        cachedTokens: data.usage.cachedTokens || 0
+                                    });
                                     globalSessionAccumulatedUsage.promptTokens += data.usage.promptTokens || 0;
                                     globalSessionAccumulatedUsage.candidatesTokens += data.usage.candidatesTokens || 0;
                                     globalSessionAccumulatedUsage.cachedTokens += data.usage.cachedTokens || 0;