minovative-mind-cli 2.2.4 → 2.3.0

package/dist/services/orchestration/investigationAgent.js

@@ -38,8 +38,10 @@ export class InvestigationAgentRunner {
     chat;
     lastHeartbeat = Date.now();
     creditsUsed = 0;
-    /** Shorter stall timeout for investigation agents (120s to allow for heavy vision/web tasks) */
-    static STALL_TIMEOUT_MS = 120_000;
+    inputTokens = 0;
+    outputTokens = 0;
+    /** 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;
@@ -49,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,
@@ -112,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();
@@ -142,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 || '';
@@ -322,7 +343,7 @@ export class InvestigationAgentRunner {
             crashed = true;
             summary = 'Investigation aborted by user.';
         }
-        debugLog(`InvestigationAgent [${this.agentLabel}]: Finished. Success=${success && !crashed}, Files=${relevantFiles.size}, Tokens=${this.creditsUsed}`);
+        debugLog(`InvestigationAgent [${this.agentLabel}]: Finished. Success=${success && !crashed}, Files=${relevantFiles.size}, Tokens=${this.creditsUsed} (In: ${this.inputTokens}, Out: ${this.outputTokens})`);
         return {
             domains: this.domains,
             agentLabel: this.agentLabel,
@@ -330,6 +351,8 @@ export class InvestigationAgentRunner {
             summary,
             webSearchSummary,
             creditsUsed: this.creditsUsed,
+            inputTokens: this.inputTokens,
+            outputTokens: this.outputTokens,
             success: success && !crashed,
         };
     }
@@ -339,10 +362,12 @@ export class InvestigationAgentRunner {
     updateUsage(result) {
         const usage = result.response.usageMetadata?.();
         if (usage) {
-            const tokens = usage.totalTokenCount || ((usage.promptTokens || 0) + (usage.candidatesTokens || 0) + (usage.cachedTokens || 0));
-            if (tokens) {
-                this.creditsUsed += tokens;
-            }
+            const input = (usage.promptTokens || 0) + (usage.cachedTokens || 0);
+            const output = usage.candidatesTokens || 0;
+            const tokens = usage.totalTokenCount || input + output;
+            this.inputTokens += input;
+            this.outputTokens += output;
+            this.creditsUsed += tokens;
         }
     }
 }

package/dist/services/orchestration/investigationOrchestrator.js

@@ -98,12 +98,14 @@ export class InvestigationOrchestrator {
         // 7. Log summary
         const cacheStats = readCache.getStats();
         const totalTokens = results.reduce((sum, r) => sum + r.creditsUsed, 0);
+        const totalInputTokens = results.reduce((sum, r) => sum + (r.inputTokens || 0), 0);
+        const totalOutputTokens = results.reduce((sum, r) => sum + (r.outputTokens || 0), 0);
         const totalFilesBeforeDedup = results.reduce((sum, r) => sum + r.relevantFiles.size, 0);
         p.log.info(`${pc.green('✓')} Parallel Investigation complete.\n` +
             `  Agents: ${agentCount} (${failedResults.length} failed) | ` +
             `Files: ${mergedResult.relevantFiles.size} (deduped from ${totalFilesBeforeDedup}) | ` +
             `Cache hits: ${cacheStats.hitCount}\n` +
-            `  Duration: ${duration}s | Tokens: ${totalTokens.toLocaleString()}`);
+            `  Duration: ${duration}s | Tokens: ${totalTokens.toLocaleString()} ${pc.dim(`(Input: ${totalInputTokens.toLocaleString()}, Output: ${totalOutputTokens.toLocaleString()})`)}`);
         return mergedResult;
     }
     /**

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
@@ -226,30 +232,47 @@ export class Orchestrator {
         p.log.step(pc.cyan('Orchestrator: Reconciling results...'));
         const stats = this.bus.getStats();
         let totalTokens = 0;
+        let inputTokens = 0;
+        let outputTokens = 0;
         let failedTasks = 0;
         let rawSummaryData = '';
         for (const [taskId, res] of this.agentResults.entries()) {
             totalTokens += res.creditsUsed;
+            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()}`);
+            `  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

@@ -16,6 +16,8 @@ export interface SubAgentResult {
     summary: string;
     /** Total credits (tokens) consumed by this agent */
     creditsUsed: number;
+    inputTokens?: number;
+    outputTokens?: number;
     /** Did the agent hit a stall timeout or crash? */
     crashed: boolean;
 }
@@ -34,8 +36,10 @@ export declare class SubAgentRunner {
     private chat;
     private lastHeartbeat;
     private creditsUsed;
+    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

@@ -24,8 +24,10 @@ export class SubAgentRunner {
     chat;
     lastHeartbeat = Date.now();
     creditsUsed = 0;
+    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;
@@ -36,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
@@ -49,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
@@ -124,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;
                         }
@@ -149,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 }
+                                        : {}),
                                 },
                             },
                         });
@@ -180,11 +192,13 @@ export class SubAgentRunner {
                 crashed = true;
                 finalSummary = 'Aborted by orchestrator.';
             }
-            debugLog(`SubAgent [${this.taskId}]: Finished. Success=${success}, Crashed=${crashed}, Tokens=${this.creditsUsed}`);
+            debugLog(`SubAgent [${this.taskId}]: Finished. Success=${success}, Crashed=${crashed}, Tokens=${this.creditsUsed} (In: ${this.inputTokens}, Out: ${this.outputTokens})`);
             return {
                 success: success && !crashed,
                 summary: finalSummary,
                 creditsUsed: this.creditsUsed,
+                inputTokens: this.inputTokens,
+                outputTokens: this.outputTokens,
                 crashed,
             };
         });
@@ -195,10 +209,12 @@ export class SubAgentRunner {
     updateUsage(result) {
         const usage = result.response.usageMetadata?.();
         if (usage) {
-            const tokens = usage.totalTokenCount || ((usage.promptTokens || 0) + (usage.candidatesTokens || 0) + (usage.cachedTokens || 0));
-            if (tokens) {
-                this.creditsUsed += tokens;
-            }
+            const input = (usage.promptTokens || 0) + (usage.cachedTokens || 0);
+            const output = usage.candidatesTokens || 0;
+            const tokens = usage.totalTokenCount || input + output;
+            this.inputTokens += input;
+            this.outputTokens += output;
+            this.creditsUsed += tokens;
         }
     }
 }

package/dist/services/proxyClient.d.ts

@@ -28,6 +28,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.

package/dist/services/proxyClient.js

@@ -1,4 +1,27 @@
 import { debugLog } from '../utils/logger.js';
+let globalSessionAccumulatedUsage = {
+    promptTokens: 0,
+    candidatesTokens: 0,
+    cachedTokens: 0,
+    totalTokenCount: 0,
+    creditsUsed: 0,
+    remainingBalance: undefined
+};
+export function getAndResetTurnUsage() {
+    const current = { ...globalSessionAccumulatedUsage };
+    globalSessionAccumulatedUsage = {
+        promptTokens: 0,
+        candidatesTokens: 0,
+        cachedTokens: 0,
+        totalTokenCount: 0,
+        creditsUsed: 0,
+        remainingBalance: undefined
+    };
+    return current;
+}
+export function peekTurnUsage() {
+    return { ...globalSessionAccumulatedUsage };
+}
 /**
  * Client service interacting directly with the serverless Gemini proxy endpoint.
  * Ensures authorization via Firebase token passing and parses streamed content.
@@ -111,6 +134,15 @@ export class ProxyClient {
                         else if (data.type === 'done') {
                             if (data.usage) {
                                 usageMetadata = data.usage;
+                                globalSessionAccumulatedUsage.promptTokens += data.usage.promptTokens || 0;
+                                globalSessionAccumulatedUsage.candidatesTokens += data.usage.candidatesTokens || 0;
+                                globalSessionAccumulatedUsage.cachedTokens += data.usage.cachedTokens || 0;
+                                globalSessionAccumulatedUsage.creditsUsed += data.usage.creditsUsed || 0;
+                                globalSessionAccumulatedUsage.totalTokenCount +=
+                                    (data.usage.promptTokens || 0) + (data.usage.cachedTokens || 0) + (data.usage.candidatesTokens || 0);
+                                if (data.usage.remainingBalance !== undefined) {
+                                    globalSessionAccumulatedUsage.remainingBalance = data.usage.remainingBalance;
+                                }
                             }
                             if (data.groundingMetadata) {
                                 groundingMetadata = data.groundingMetadata;

package/dist/utils/analysisRunner.js

@@ -70,8 +70,8 @@ function truncateOutput(text, max) {
  * @returns Captured stdout, stderr, and exit code.
  */
 export async function runEphemeralScript(workspaceRoot, language, code, options) {
-    const timeoutMs = options?.timeoutMs ?? 10_000;
-    const maxOutputChars = options?.maxOutputChars ?? 30_000;
+    const timeoutMs = options?.timeoutMs ?? 60_000;
+    const maxOutputChars = options?.maxOutputChars ?? 100_000;
     const ext = LANGUAGE_EXTENSIONS[language.toLowerCase()];
     if (!ext) {
         return {

package/dist/utils/config.d.ts

@@ -14,10 +14,9 @@ export declare const GITHUB_CLIENT_ID = "Ov23linFYFfjO3JILG7r";
  * Supported Gemini AI models.
  */
 export declare const GEMINI_MODELS: {
-    readonly PRO_3_1: "gemini-3.1-pro-preview";
-    readonly FLASH_3_5: "gemini-3.5-flash";
-    readonly FLASH_2_5: "gemini-2.5-flash";
-    readonly FLASH_LITE_3_1: "gemini-3.1-flash-lite";
+    readonly PRO: "gemini-3.1-pro-preview";
+    readonly FLASH: "gemini-3.6-flash";
+    readonly FLASH_LITE: "gemini-3.5-flash-lite";
     readonly AUTO: "auto";
 };
 /** Default Gemini model for the coding agent. */

package/dist/utils/config.js

@@ -14,10 +14,9 @@ export const GITHUB_CLIENT_ID = 'Ov23linFYFfjO3JILG7r';
  * Supported Gemini AI models.
  */
 export const GEMINI_MODELS = {
-    PRO_3_1: 'gemini-3.1-pro-preview',
-    FLASH_3_5: 'gemini-3.5-flash',
-    FLASH_2_5: 'gemini-2.5-flash',
-    FLASH_LITE_3_1: 'gemini-3.1-flash-lite',
+    PRO: 'gemini-3.1-pro-preview',
+    FLASH: 'gemini-3.6-flash',
+    FLASH_LITE: 'gemini-3.5-flash-lite',
     AUTO: 'auto',
 };
 /** Default Gemini model for the coding agent. */

package/dist/utils/credentialStore.d.ts

@@ -0,0 +1,30 @@
+/** Legacy plaintext file path (for migration). */
+export declare const LEGACY_CONFIG_FILE: string;
+export interface StoredCredentials {
+    idToken?: string;
+    refreshToken?: string;
+    idTokenExpiry?: number;
+}
+/**
+ * Persists authentication credentials to the most secure available store.
+ *
+ * Strategy (tried in order):
+ * 1. macOS Keychain (`security` CLI)
+ * 2. Linux libsecret (`secret-tool` CLI)
+ * 3. Windows DPAPI (PowerShell)
+ * 4. AES-256-GCM encrypted file with 0600 permissions
+ */
+export declare function saveCredentials(data: StoredCredentials): Promise<void>;
+/**
+ * Loads authentication credentials from the secure store.
+ * Returns an empty object if no credentials are found.
+ *
+ * On first run after upgrade, silently migrates any legacy plaintext
+ * `~/.minovative-mind-cli.json` into the secure store and deletes the old file.
+ */
+export declare function loadCredentials(): Promise<StoredCredentials>;
+/**
+ * Removes all stored credentials from the secure store.
+ * Also cleans up any legacy plaintext file if it still exists.
+ */
+export declare function clearCredentials(): Promise<void>;