minovative-mind-cli 2.2.5 → 2.3.1

package/dist/services/orchestration/investigationAgent.js

@@ -40,8 +40,8 @@ export class InvestigationAgentRunner {
     creditsUsed = 0;
     inputTokens = 0;
     outputTokens = 0;
-    /** Shorter stall timeout for investigation agents (120s to allow for heavy vision/web tasks) */
-    static STALL_TIMEOUT_MS = 120_000;
+    /** Stall timeout for investigation agents (300s to allow for heavy vision/web tasks) */
+    static STALL_TIMEOUT_MS = 300_000;
     constructor(agentLabel, domains, workspaceRoot, readCache, projectTree, projectType) {
         this.agentLabel = agentLabel;
         this.domains = domains;
@@ -51,7 +51,7 @@ export class InvestigationAgentRunner {
         this.projectType = projectType;
         let model = getGlobalActiveModel();
         if (model === GEMINI_MODELS.AUTO)
-            model = GEMINI_MODELS.FLASH_3_5;
+            model = GEMINI_MODELS.FLASH;
         this.chat = new ProxyChatSession(model, this.buildSystemInstruction(), getContextToolDeclarations(), {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 1,
@@ -114,6 +114,8 @@ 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();
@@ -144,14 +146,31 @@ export class InvestigationAgentRunner {
                     // 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: 'You have already made this exact tool call previously. Please review your context history or try a different action.' }
-                            }
+                                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 || '';
@@ -345,7 +364,7 @@ export class InvestigationAgentRunner {
         if (usage) {
             const input = (usage.promptTokens || 0) + (usage.cachedTokens || 0);
             const output = usage.candidatesTokens || 0;
-            const tokens = usage.totalTokenCount || (input + output);
+            const tokens = usage.totalTokenCount || input + output;
             this.inputTokens += input;
             this.outputTokens += output;
             this.creditsUsed += tokens;

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

@@ -2,7 +2,7 @@
  * @fileoverview Main Orchestrator for Sub-Agent Dispatch and Coordination.
  *
  * The orchestrator acts as the "PM Kernel", responsible for:
- * 1. Task Decomposition (using gemini-3.5-flash)
+ * 1. Task Decomposition (using gemini-3.6-flash)
  * 2. Graph Validation (Cycle detection via Kahn's algorithm)
  * 3. Lock Ordering (Conflict resolution across parallel waves)
  * 4. Parallel Dispatch (Executing waves sequentially, agents in parallel)

package/dist/services/orchestration/orchestrator.js

@@ -2,7 +2,7 @@
  * @fileoverview Main Orchestrator for Sub-Agent Dispatch and Coordination.
  *
  * The orchestrator acts as the "PM Kernel", responsible for:
- * 1. Task Decomposition (using gemini-3.5-flash)
+ * 1. Task Decomposition (using gemini-3.6-flash)
  * 2. Graph Validation (Cycle detection via Kahn's algorithm)
  * 3. Lock Ordering (Conflict resolution across parallel waves)
  * 4. Parallel Dispatch (Executing waves sequentially, agents in parallel)
@@ -11,6 +11,7 @@
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { ProxyChatSession, getGlobalActiveModel, compressTextUsingFlashLite } from '../ai.js';
+import { peekTurnUsage } from '../proxyClient.js';
 import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { debugLog } from '../../utils/logger.js';
 import { MessageBus } from './messageBus.js';
@@ -19,19 +20,22 @@ import { SubAgentRunner } from './subAgent.js';
 import { validateTaskGraph, computeExecutionWaves, detectFileConflicts, resolveFileConflicts, buildCycleCorrectionPrompt, CyclicDependencyError, } from './taskGraph.js';
 import { trackTask } from '../../utils/taskVisualizer.js';
 // ─── Constants ───────────────────────────────────────────────────────
-const PM_SYSTEM_INSTRUCTION = `You are the PM Agent (Project Manager).
+const PM_SYSTEM_INSTRUCTION = `<identity>
+You are the PM Agent (Project Manager).
 Your job is to decompose the user's objective into a parallelizable Task Graph for sub-agents.
 You must output ONLY raw JSON representing the TaskGraph object. Do not wrap in markdown code blocks.
+</identity>
 
-Requirements:
+<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.
 - 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.
+</requirements>
 
-JSON Schema:
+<json_schema>
 {
   "objective": "string",
   "tasks": [
@@ -46,7 +50,7 @@ JSON Schema:
   ],
   "constraints": ["string"]
 }
-`;
+</json_schema>`;
 // ─── Orchestrator Implementation ─────────────────────────────────────
 export class Orchestrator {
     workspaceRoot;
@@ -64,7 +68,7 @@ export class Orchestrator {
         this.locks = new FileLockRegistry();
         let model = getGlobalActiveModel();
         if (model === GEMINI_MODELS.AUTO)
-            model = GEMINI_MODELS.FLASH_3_5;
+            model = GEMINI_MODELS.FLASH;
         this.pmChat = new ProxyChatSession(model, PM_SYSTEM_INSTRUCTION, [], {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 0.1,
@@ -97,10 +101,12 @@ export class Orchestrator {
         for (const wave of waves) {
             if (signal.aborted)
                 break;
-            const taskDescriptions = wave.taskIds.map(taskId => {
-                const taskDef = graph.tasks.find(t => t.id === taskId);
+            const taskDescriptions = wave.taskIds
+                .map((taskId) => {
+                const taskDef = graph.tasks.find((t) => t.id === taskId);
                 return `  - ${pc.cyan(taskDef.id)}: ${pc.dim(taskDef.intent)}`;
-            }).join('\n');
+            })
+                .join('\n');
             p.log.step(pc.magenta(`Starting Wave ${wave.depth + 1} (${wave.taskIds.length} tasks):\n${taskDescriptions}`));
             const s = p.spinner();
             s.start(`Executing Wave ${wave.depth + 1}...`);
@@ -116,8 +122,8 @@ export class Orchestrator {
             const MAX_CONCURRENT = 2;
             for (let i = 0; i < wave.taskIds.length; i += MAX_CONCURRENT) {
                 const chunk = wave.taskIds.slice(i, i + MAX_CONCURRENT);
-                const wavePromises = chunk.map(taskId => {
-                    const taskDef = graph.tasks.find(t => t.id === taskId);
+                const wavePromises = chunk.map((taskId) => {
+                    const taskDef = graph.tasks.find((t) => t.id === taskId);
                     const globalContext = `Objective:\n${objective}\n\nContext:\n${contextInjection}`;
                     agentStatuses.set(taskDef.id, 'Starting...');
                     updateSpinner();
@@ -131,7 +137,7 @@ export class Orchestrator {
             }
             s.stop(`Wave ${wave.depth + 1} execution finished.`);
             // Post-wave evaluation
-            const failedCount = results.filter(r => !r.success).length;
+            const failedCount = results.filter((r) => !r.success).length;
             if (failedCount > 0) {
                 p.log.warn(pc.yellow(`Wave ${wave.depth + 1} finished with ${failedCount} failure(s).`));
                 // Phase 3 implementation note: Right now, we continue and let downstream
@@ -232,28 +238,41 @@ export class Orchestrator {
         let rawSummaryData = '';
         for (const [taskId, res] of this.agentResults.entries()) {
             totalTokens += res.creditsUsed;
-            inputTokens += (res.inputTokens || 0);
-            outputTokens += (res.outputTokens || 0);
+            inputTokens += res.inputTokens || 0;
+            outputTokens += res.outputTokens || 0;
             if (!res.success)
                 failedTasks++;
             debugLog(`Task ${taskId} summary: ${res.summary.substring(0, 100)}...`);
             rawSummaryData += `Task: ${taskId} | Status: ${res.success ? 'Success' : 'Failed'}\nChanges:\n${res.summary}\n\n`;
         }
         p.log.step(pc.cyan('Orchestrator: Synthesizing final changes overview...'));
-        let finalSummary = '[Sub-Agent Orchestration Completed]\n\n';
+        let finalSummary = '';
         try {
-            const instruction = 'You are an expert technical orchestrator. The user has delegated a complex task to multiple sub-agents. Below are their individual task completion summaries. Synthesize these summaries into ONE cohesive, unified overview of all changes made. DO NOT list them by task name or separate them by agent. Just provide a single seamless summary of what was accomplished overall. Use clear bullet points and markdown. Be concise but complete.';
-            const synthesized = await compressTextUsingFlashLite(rawSummaryData, instruction);
+            const payloadWithContext = `<original_request>\n${graph.objective}\n</original_request>\n\n<task_summaries>\n${rawSummaryData}\n</task_summaries>`;
+            const instruction = '<identity>\n' +
+                "You are Mino, a Senior software developer. You just delegated the user's complex request to multiple parallel sub-agents, and they have finished. " +
+                "Below is the user's original request, followed by the raw task completion summaries from the sub-agents.\n" +
+                '</identity>\n\n' +
+                '<directives>\n' +
+                'Synthesize these summaries into a natural, conversational response back to the user. ' +
+                'Address their original request directly (e.g., "I have completed your request to..."). ' +
+                'Provide ONE cohesive, unified overview of all changes made, using clear bullet points. ' +
+                'DO NOT list changes by task name or separate them by agent. ' +
+                'Be concise, helpful, and conclude by asking if they need any further adjustments.\n' +
+                '</directives>';
+            const synthesized = await compressTextUsingFlashLite(payloadWithContext, instruction);
             finalSummary += synthesized + '\n\n';
         }
         catch (e) {
             debugLog(`Synthesis failed, falling back to raw output: ${e}`);
             finalSummary += rawSummaryData;
         }
+        const currentUsage = peekTurnUsage();
+        const totalInputTokens = (currentUsage.promptTokens || 0) + (currentUsage.cachedTokens || 0);
         p.log.info(`${pc.green('✓')} Sub-agent execution complete.\n` +
             `  Total tasks: ${graph.tasks.length} (${failedTasks} failed)\n` +
             `  Bus Activity: ${stats.activityCount} actions, ${stats.signalCount} signals\n` +
-            `  Total Tokens: ${totalTokens.toLocaleString()} ${pc.dim(`(Input: ${inputTokens.toLocaleString()}, Output: ${outputTokens.toLocaleString()})`)}`);
+            `  Total Tokens: ${currentUsage.totalTokenCount.toLocaleString()} ${pc.dim(`(Input: ${totalInputTokens.toLocaleString()}, Output: ${currentUsage.candidatesTokens.toLocaleString()})`)}`);
         // Clear the bus persistence now that orchestration is done
         await this.bus.cleanup();
         this.locks.shutdown();

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

@@ -39,7 +39,7 @@ export declare class SubAgentRunner {
     private inputTokens;
     private outputTokens;
     /** Max time without a tool call or response before the agent is considered stalled */
-    static readonly STALL_TIMEOUT_MS = 60000;
+    static readonly STALL_TIMEOUT_MS = 300000;
     constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string, onProgress?: ((msg: string) => void) | undefined);
     /**
      * Constructs the base system instruction for this specific agent.

package/dist/services/orchestration/subAgent.js

@@ -27,7 +27,7 @@ export class SubAgentRunner {
     inputTokens = 0;
     outputTokens = 0;
     /** Max time without a tool call or response before the agent is considered stalled */
-    static STALL_TIMEOUT_MS = 60_000;
+    static STALL_TIMEOUT_MS = 300_000;
     constructor(taskId, intent, workspaceRoot, bus, locks, globalContext, onProgress) {
         this.taskId = taskId;
         this.intent = intent;
@@ -38,8 +38,8 @@ export class SubAgentRunner {
         this.onProgress = onProgress;
         let model = getGlobalActiveModel();
         if (model === GEMINI_MODELS.AUTO)
-            model = GEMINI_MODELS.FLASH_3_5;
-        // Sub-agents default to flash-3.5 for better reasoning capabilities
+            model = GEMINI_MODELS.FLASH;
+        // Sub-agents default to flash-3.6 for better reasoning capabilities
         this.chat = new ProxyChatSession(model, this.buildSystemInstruction(), [{ functionDeclarations: getScopedToolDeclarations() }], {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 0.3, // Lower temperature for more focused execution
@@ -51,18 +51,24 @@ export class SubAgentRunner {
      * Constructs the base system instruction for this specific agent.
      */
     buildSystemInstruction() {
-        return (`You are an autonomous sub-agent executing a specific portion of a larger task.\n` +
+        return (`<identity>\n` +
+            `You are an autonomous Senior software developer sub-agent executing a specific portion of a larger task.\n` +
+            `</identity>\n\n` +
+            `<task_info>\n` +
             `Your task ID is: ${this.taskId}\n` +
-            `Your objective: ${this.intent}\n\n` +
-            `=== REFERENCE CONTEXT (DO NOT IMPLEMENT THIS FULL REQUEST) ===\n` +
+            `Your objective: ${this.intent}\n` +
+            `</task_info>\n\n` +
+            `<reference_context>\n` +
+            `DO NOT IMPLEMENT THIS FULL REQUEST. THIS IS JUST FOR CONTEXT.\n\n` +
             `${this.globalContext}\n` +
-            `==============================================================\n\n` +
-            `CRITICAL GUIDELINES:\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.`);
+            `5. If you encounter an insurmountable error, provide a summary of what went wrong so the orchestrator can re-assign or fix it.\n` +
+            `</critical_guidelines>`);
     }
     /**
      * Updates the heartbeat. Passed to `executeScopedTool` to ensure the agent
@@ -126,8 +132,10 @@ export class SubAgentRunner {
                             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.' }
-                                }
+                                    response: {
+                                        error: 'You have already made this exact tool call previously. Please review your context history or try a different action.',
+                                    },
+                                },
                             });
                             continue;
                         }
@@ -151,7 +159,9 @@ export class SubAgentRunner {
                                     output: responseData.output !== undefined ? responseData.output : responseData,
                                     ...(responseData.error ? { error: responseData.error } : {}),
                                     ...(responseData.inlineData ? { inlineData: responseData.inlineData } : {}),
-                                    ...(responseData._orchestrationWarning ? { _orchestrationWarning: responseData._orchestrationWarning } : {}),
+                                    ...(responseData._orchestrationWarning
+                                        ? { _orchestrationWarning: responseData._orchestrationWarning }
+                                        : {}),
                                 },
                             },
                         });
@@ -201,7 +211,7 @@ export class SubAgentRunner {
         if (usage) {
             const input = (usage.promptTokens || 0) + (usage.cachedTokens || 0);
             const output = usage.candidatesTokens || 0;
-            const tokens = usage.totalTokenCount || (input + output);
+            const tokens = usage.totalTokenCount || input + output;
             this.inputTokens += input;
             this.outputTokens += output;
             this.creditsUsed += tokens;

package/dist/services/proxyClient.d.ts

@@ -1,18 +1,4 @@
 import type { Content, Tool, ToolConfig, FunctionCall } from '@google/generative-ai';
-/**
- * ============================================================================
- *                               PROXY CLIENT SERVICE
- * ============================================================================
- * Facilitates stream-based communication with the secure, Firebase-authenticated
- * serverless Gemini content generation proxy.
- *
- * Core Capabilities:
- * - Server-Sent Events (SSE) parsing for thoughts, text, and function calls.
- * - Secure Authentication handling (Firebase ID Tokens).
- * - Real-time stream-callback piping for instant responses.
- * - Accurate token usage, credit consumption, and grounding metadata parsing.
- * ============================================================================
- */
 /**
  * Metadata containing real-time proxy token and credit usage diagnostics.
  */
@@ -28,6 +14,22 @@ export interface ProxyUsageMetadata {
     /** The remaining balance left in the user's account. */
     remainingBalance: number;
 }
+export declare function getAndResetTurnUsage(): {
+    promptTokens: number;
+    candidatesTokens: number;
+    cachedTokens: number;
+    totalTokenCount: number;
+    creditsUsed: number;
+    remainingBalance: number | undefined;
+};
+export declare function peekTurnUsage(): {
+    promptTokens: number;
+    candidatesTokens: number;
+    cachedTokens: number;
+    totalTokenCount: number;
+    creditsUsed: number;
+    remainingBalance: number | undefined;
+};
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.