minovative-mind-cli 2.7.0 → 2.8.1

package/README.md

@@ -165,7 +165,7 @@ _⚠️\*Support is limited or requires custom local system tooling/environment
 
 1. **Dependency Tracing:** Fully supported across language families. It uses lightning-fast static regex pattern matching to resolve local import structures and determine the "blast radius" of code changes without requiring local compilations.
 2. **Performance Auditing:** Executed natively across 9 major language families (JavaScript/TypeScript, Python, Go, Rust, PHP, C#, Java, C/C++, and Ruby). It uses zero-dependency, ultra-fast (<50ms) language-aware regex heuristics with comment/string stripping and line-preserving offset tracking to detect severe runtime anti-patterns (such as unbounded loops, synchronous I/O, chained array allocations, unnecessary allocations, and unclosed resources).
-3. **Ephemeral Analysis & Property-Based Probing:** Runs temporary files in sandbox directories to parse and extract local symbols, execute ephemeral Property-Based Testing (PBT) probes to discover and shrink counterexamples, perform infrastructure probing (detecting available runtimes, checking ports, identifying project type), post-change validation (importing modified modules and asserting expected behavior), and lightweight ML-powered analysis (e.g., TF-IDF file ranking, anomaly detection, Big-O estimation). Defaults to Node.js as a safe baseline, but natively leverages host-installed runtimes (Python, Rust, Go compilers) and standard libraries whenever available in the workspace.
+3. **Ephemeral Analysis & Property-Based Probing:** Defaults to Node.js as a safe baseline, but natively leverages host-installed runtimes (Python, Rust, Go compilers) and standard libraries whenever available in the workspace.
 
 ---
 

package/dist/services/agent/slashCommands.js

@@ -223,20 +223,27 @@ export async function handleSlashCommand(command, context) {
         try {
             const { getInvestigationCacheStats } = await import('../orchestration/investigationCache.js');
             const invStats = getInvestigationCacheStats(workspaceRoot);
-            const memBankSizeKB = (invStats.sizeBytes / 1024).toFixed(1);
-            console.log(`${pc.bold('Memory Bank:')}      ${pc.cyan(`${invStats.entries} cached investigations (${memBankSizeKB} KB / 5 MB)`)}`);
+            const formatBytesToSize = (bytes) => {
+                if (bytes >= 1024 * 1024) {
+                    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+                }
+                return `${(bytes / 1024).toFixed(1)} KB`;
+            };
+            const memBankSizeStr = formatBytesToSize(invStats.sizeBytes);
+            console.log(`${pc.bold('Memory Bank:')}      ${pc.cyan(`${invStats.entries} cached investigations (${memBankSizeStr} / 5 MB)`)}`);
             const { readCache } = await import('../../utils/projectStorage.js');
             const contextCache = readCache(workspaceRoot, 'context_cache.json');
             const contextEntries = contextCache ? Object.keys(contextCache).length : 0;
-            let contextSizeKB = '0.0';
+            let contextSizeBytes = 0;
             try {
                 const fs = await import('node:fs');
                 const path = await import('node:path');
                 const stat = await fs.promises.stat(path.join(workspaceRoot, '.minovativemind', 'context_cache.json'));
-                contextSizeKB = (stat.size / 1024).toFixed(1);
+                contextSizeBytes = stat.size;
             }
             catch (e) { }
-            console.log(`${pc.bold('Context Cache:')}    ${pc.cyan(`${contextEntries} file summaries (${contextSizeKB} KB / 5 MB)`)}`);
+            const contextSizeStr = formatBytesToSize(contextSizeBytes);
+            console.log(`${pc.bold('Context Cache:')}    ${pc.cyan(`${contextEntries} file summaries (${contextSizeStr} / 5 MB)`)}`);
         }
         catch (e) {
             // Ignored if cache stats fail

package/dist/services/agent/toolLoop.js

@@ -1,3 +1,4 @@
+import path from 'path';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { debugLog } from '../../utils/logger.js';
@@ -24,6 +25,9 @@ const TOOL_ICONS = {
     find_dependencies: '🔗',
     run_analysis_script: '🔬',
     run_debug_script: '🧪',
+    run_fuzz_probe: '🎯',
+    check_heap_delta: '📊',
+    check_behavioral_drift: '🔀',
 };
 /**
  * Human-readable translations for tool actions.
@@ -41,6 +45,9 @@ const TOOL_LABELS = {
     find_dependencies: 'Tracing dependencies',
     run_analysis_script: 'Analyzing workspace',
     run_debug_script: 'Executing debug/validation script',
+    run_fuzz_probe: 'Executing fuzz testing probe',
+    check_heap_delta: 'Inspecting memory heap delta',
+    check_behavioral_drift: 'Comparing behavioral drift',
 };
 // ─── Helpers ─────────────────────────────────────────────────────────
 /**
@@ -52,8 +59,20 @@ const TOOL_LABELS = {
  * @returns A fully colorized and formatted ANSI console string.
  */
 export function formatToolCall(name, args) {
-    const icon = TOOL_ICONS[name] ?? '🔧';
-    const label = TOOL_LABELS[name] ?? name;
+    let icon = TOOL_ICONS[name] ?? '🔧';
+    let label = TOOL_LABELS[name] ?? name;
+    if (name === 'rename_file') {
+        const src = String(args.sourcePath ?? '');
+        const tgt = String(args.targetPath ?? '');
+        if (src && tgt && path.dirname(src) === path.dirname(tgt)) {
+            label = 'Renaming file';
+            icon = '🏷️';
+        }
+        else {
+            label = 'Moving file';
+            icon = '🚚';
+        }
+    }
     const formatPath = (path) => pc.cyan(path);
     const argsMap = {
         read_file: () => {
@@ -86,6 +105,37 @@ export function formatToolCall(name, args) {
         find_dependencies: () => `: ${formatPath(String(args.filePath))}${args.direction ? ` (${args.direction})` : ''}`,
         run_analysis_script: () => `: ${formatPath(String(args.targetFile ?? 'workspace'))}`,
         run_debug_script: () => `: ${pc.dim(`(${String(args.language ?? 'script')})`)}`,
+        run_fuzz_probe: () => {
+            const lang = String(args.language ?? 'node');
+            const extras = [];
+            if (args.iterations !== undefined)
+                extras.push(`${args.iterations} iterations`);
+            if (args.seed !== undefined)
+                extras.push(`seed: ${args.seed}`);
+            const meta = extras.length > 0 ? `, ${extras.join(', ')}` : '';
+            return `: ${pc.dim(`(${lang}${meta})`)}`;
+        },
+        check_heap_delta: () => {
+            const lang = String(args.language ?? 'node');
+            const extras = [];
+            if (args.testIterations !== undefined)
+                extras.push(`${args.testIterations} iterations`);
+            if (args.samplingIntervalMs !== undefined)
+                extras.push(`${args.samplingIntervalMs}ms interval`);
+            const meta = extras.length > 0 ? `, ${extras.join(', ')}` : '';
+            return `: ${pc.dim(`(${lang}${meta})`)}`;
+        },
+        check_behavioral_drift: () => {
+            const lang = String(args.language ?? 'node');
+            const extras = [];
+            if (args.tolerance !== undefined)
+                extras.push(`tol: ${args.tolerance}`);
+            if (Array.isArray(args.compareKeys) && args.compareKeys.length > 0) {
+                extras.push(`keys: ${args.compareKeys.join(', ')}`);
+            }
+            const meta = extras.length > 0 ? `, ${extras.join(', ')}` : '';
+            return `: ${pc.dim(`(${lang}${meta})`)}`;
+        },
     };
     const formatter = argsMap[name];
     const details = formatter ? formatter() : '';

package/dist/services/agent-tools.d.ts

@@ -183,6 +183,32 @@ export declare function findRecentChanges(workspaceRoot: string, dirPath?: strin
  * @returns A promise resolving to a {@link ToolResult} containing execution output.
  */
 export declare function runDebugScript(workspaceRoot: string, language: string, code: string, abortSignal?: AbortSignal): Promise<ToolResult>;
+/**
+ * Executes a fuzz probing analysis script and formats the resulting pass/fail and crash statistics.
+ */
+export declare function executeFuzzProbe(workspaceRoot: string, code: string, language?: string, config?: {
+    iterations?: number;
+    maxInputLength?: number;
+    seed?: number;
+    timeoutMs?: number;
+}, abortSignal?: AbortSignal): Promise<ToolResult>;
+/**
+ * Executes a heap memory inspection script and formats memory consumption and growth delta metrics.
+ */
+export declare function executeHeapDelta(workspaceRoot: string, code: string, language?: string, config?: {
+    warmupIterations?: number;
+    testIterations?: number;
+    samplingIntervalMs?: number;
+    timeoutMs?: number;
+}, abortSignal?: AbortSignal): Promise<ToolResult>;
+/**
+ * Executes baseline and candidate scripts, returning output diffs and behavioral drift findings.
+ */
+export declare function executeBehavioralDrift(workspaceRoot: string, baselineCode: string, candidateCode: string, language?: string, config?: {
+    tolerance?: number;
+    compareKeys?: string[];
+    timeoutMs?: number;
+}, abortSignal?: AbortSignal): Promise<ToolResult>;
 /**
  * Central tool dispatcher that resolves multi-workspace paths, executes the requested tool
  * with the provided arguments, records metrics, and returns the standardized {@link ToolResult}.

package/dist/services/agent-tools.js

@@ -24,6 +24,7 @@ import { extractSymbols } from '../utils/symbolExtractor.js';
 import { getMetricCollector } from './metrics.js';
 import { getCurrentAgentId } from '../utils/asyncContext.js';
 import { recordFileRead, hasAgentReadFile } from '../utils/fileReadGuard.js';
+import { runFuzzProbe, checkHeapDelta as runCheckHeapDelta, checkBehavioralDrift as runCheckBehavioralDrift, } from '../utils/analysisRunner.js';
 import ignore from 'ignore';
 const execAsync = promisify(exec);
 // ─── Tool Declarations for Gemini Function Calling ───────────────────
@@ -341,6 +342,109 @@ export const toolDeclarations = [
             required: ['summary'],
         },
     },
+    {
+        name: 'run_fuzz_probe',
+        description: 'Execute a fuzz testing probe script to detect edge-case failures, unhandled exceptions, or unexpected crashes under randomized or boundary inputs.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                code: {
+                    type: SchemaType.STRING,
+                    description: 'The fuzz test script or probe code to execute.',
+                },
+                language: {
+                    type: SchemaType.STRING,
+                    description: 'Runtime environment: "node", "ts-node", "python", "bash", "go", or "rust". Defaults to "node".',
+                },
+                iterations: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Number of fuzz test iterations to run.',
+                },
+                maxInputLength: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Maximum length/size for generated fuzz input vectors.',
+                },
+                seed: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Random seed for deterministic fuzz generation.',
+                },
+                timeoutMs: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Execution timeout in milliseconds.',
+                },
+            },
+            required: ['code'],
+        },
+    },
+    {
+        name: 'check_heap_delta',
+        description: 'Execute a heap memory inspection script to measure memory consumption, detect heap growth/leaks, and evaluate memory delta statistics.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                code: {
+                    type: SchemaType.STRING,
+                    description: 'The script or code snippet to execute for heap memory analysis.',
+                },
+                language: {
+                    type: SchemaType.STRING,
+                    description: 'Runtime environment: "node", "ts-node", "python", "bash", "go", or "rust". Defaults to "node".',
+                },
+                warmupIterations: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Number of warmup iterations prior to initial heap snapshot.',
+                },
+                testIterations: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Number of test iterations executed between snapshots.',
+                },
+                samplingIntervalMs: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Memory sampling interval in milliseconds.',
+                },
+                timeoutMs: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Execution timeout in milliseconds.',
+                },
+            },
+            required: ['code'],
+        },
+    },
+    {
+        name: 'check_behavioral_drift',
+        description: 'Execute baseline and candidate scripts in parallel or sequence to detect output differences, return value mismatches, or behavioral drift.',
+        parameters: {
+            type: SchemaType.OBJECT,
+            properties: {
+                baselineCode: {
+                    type: SchemaType.STRING,
+                    description: 'The baseline implementation script source code.',
+                },
+                candidateCode: {
+                    type: SchemaType.STRING,
+                    description: 'The candidate implementation script source code to compare against baseline.',
+                },
+                language: {
+                    type: SchemaType.STRING,
+                    description: 'Runtime environment: "node", "ts-node", "python", "bash", "go", or "rust". Defaults to "node".',
+                },
+                tolerance: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Numerical tolerance threshold for floating point comparison.',
+                },
+                compareKeys: {
+                    type: SchemaType.ARRAY,
+                    items: { type: SchemaType.STRING },
+                    description: 'Optional. Specific JSON object keys/fields to compare for drift.',
+                },
+                timeoutMs: {
+                    type: SchemaType.NUMBER,
+                    description: 'Optional. Execution timeout in milliseconds.',
+                },
+            },
+            required: ['baselineCode', 'candidateCode'],
+        },
+    },
 ];
 let currentApprovalMode = 'ask';
 /**
@@ -1312,6 +1416,112 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
         }
     }
 }
+/**
+ * Executes a fuzz probing analysis script and formats the resulting pass/fail and crash statistics.
+ */
+export async function executeFuzzProbe(workspaceRoot, code, language = 'node', config, abortSignal) {
+    try {
+        const res = await runFuzzProbe(workspaceRoot, code, language, {
+            ...config,
+            abortSignal,
+        });
+        let output = `Fuzz Probe Result: ${res.passed ? 'PASSED' : 'FAILED'}\n`;
+        if (res.totalFuzzRuns > 0)
+            output += `Total Fuzz Runs: ${res.totalFuzzRuns}\n`;
+        if (res.seed !== undefined)
+            output += `Seed: ${res.seed}\n`;
+        if (res.failingInputs && res.failingInputs.length > 0) {
+            output += `Failing Inputs / Counterexamples:\n${res.failingInputs.map((inp) => `  - ${inp}`).join('\n')}\n`;
+        }
+        if (res.errorSummary) {
+            output += `Error Summary:\n${res.errorSummary}\n`;
+        }
+        if (res.stdout)
+            output += `\n[STDOUT]\n${res.stdout}\n`;
+        if (res.stderr)
+            output += `\n[STDERR]\n${res.stderr}\n`;
+        return {
+            output: output.trim(),
+            ...(res.exitCode !== 0 && !res.passed ? { error: `Fuzz probe failed with exit code ${res.exitCode}` } : {}),
+        };
+    }
+    catch (err) {
+        return { output: '', error: `Fuzz probe error: ${err.message || String(err)}` };
+    }
+}
+/**
+ * Executes a heap memory inspection script and formats memory consumption and growth delta metrics.
+ */
+export async function executeHeapDelta(workspaceRoot, code, language = 'node', config, abortSignal) {
+    try {
+        const res = await runCheckHeapDelta(workspaceRoot, code, language, {
+            ...config,
+            abortSignal,
+        });
+        let output = `Heap Delta Analysis Result:\n`;
+        output += `Initial Heap: ${res.initialHeapBytes} bytes\n`;
+        output += `Final Heap: ${res.finalHeapBytes} bytes\n`;
+        output += `Delta: ${res.deltaBytes} bytes\n`;
+        output += `Leak Detected: ${res.leakDetected ? 'YES' : 'NO'}\n`;
+        if (res.growthRateBytesPerIter !== undefined) {
+            output += `Growth Rate: ${res.growthRateBytesPerIter} bytes/iter\n`;
+        }
+        if (res.samples && res.samples.length > 0) {
+            output += `Samples (${res.samples.length}):\n`;
+            for (const s of res.samples) {
+                output += `  Iter ${s.iteration}: ${s.heapBytes} bytes\n`;
+            }
+        }
+        if (res.stdout)
+            output += `\n[STDOUT]\n${res.stdout}\n`;
+        if (res.stderr)
+            output += `\n[STDERR]\n${res.stderr}\n`;
+        return {
+            output: output.trim(),
+            ...(res.exitCode !== 0 ? { error: `Heap delta failed with exit code ${res.exitCode}` } : {}),
+        };
+    }
+    catch (err) {
+        return { output: '', error: `Heap delta error: ${err.message || String(err)}` };
+    }
+}
+/**
+ * Executes baseline and candidate scripts, returning output diffs and behavioral drift findings.
+ */
+export async function executeBehavioralDrift(workspaceRoot, baselineCode, candidateCode, language = 'node', config, abortSignal) {
+    try {
+        const res = await runCheckBehavioralDrift(workspaceRoot, baselineCode, candidateCode, language, {
+            ...config,
+            abortSignal,
+        });
+        let output = `Behavioral Drift Analysis Result:\n`;
+        output += `Has Drift: ${res.hasDrift ? 'YES' : 'NO'}\n`;
+        if (res.diffSummary) {
+            output += `Diff Summary:\n${res.diffSummary}\n`;
+        }
+        if (res.driftDetails && res.driftDetails.length > 0) {
+            output += `Drift Details:\n`;
+            for (const detail of res.driftDetails) {
+                output += `  - ${detail.field ? `[${detail.field}] ` : ''}Baseline: ${JSON.stringify(detail.baseline)} vs Candidate: ${JSON.stringify(detail.candidate)}${detail.diff ? ` (${detail.diff})` : ''}\n`;
+            }
+        }
+        if (res.baselineOutput)
+            output += `\n[BASELINE OUTPUT]\n${res.baselineOutput}\n`;
+        if (res.candidateOutput)
+            output += `\n[CANDIDATE OUTPUT]\n${res.candidateOutput}\n`;
+        if (res.stdout)
+            output += `\n[STDOUT]\n${res.stdout}\n`;
+        if (res.stderr)
+            output += `\n[STDERR]\n${res.stderr}\n`;
+        return {
+            output: output.trim(),
+            ...(res.exitCode !== 0 ? { error: `Behavioral drift check failed with exit code ${res.exitCode}` } : {}),
+        };
+    }
+    catch (err) {
+        return { output: '', error: `Behavioral drift error: ${err.message || String(err)}` };
+    }
+}
 /**
  * Resolves `@alias/` prefixed paths in tool arguments to the correct workspace root
  * and relative path. Returns the effective workspaceRoot and the cleaned arguments.
@@ -1424,6 +1634,15 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
     else if (normalizedToolName === 'finish_investigation') {
         normalizedToolName = 'finish_task';
     }
+    else if (normalizedToolName === 'fuzz_probe' || normalizedToolName === 'run_fuzz') {
+        normalizedToolName = 'run_fuzz_probe';
+    }
+    else if (normalizedToolName === 'heap_delta' || normalizedToolName === 'check_heap') {
+        normalizedToolName = 'check_heap_delta';
+    }
+    else if (normalizedToolName === 'behavioral_drift' || normalizedToolName === 'check_drift') {
+        normalizedToolName = 'check_behavioral_drift';
+    }
     // ─── Multi-Workspace Path Resolution ─────────────────────────────
     // Intercept @alias/ prefixed paths and swap workspaceRoot + relative path
     // before dispatching to the underlying tool functions (which remain unchanged).
@@ -1620,6 +1839,42 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
         case 'find_recent_changes':
             result = await findRecentChanges(effectiveRoot, resolvedArgs.dirPath, resolvedArgs.minutes, resolvedArgs.maxDepth);
             break;
+        case 'run_fuzz_probe': {
+            const code = resolvedArgs.code;
+            const language = resolvedArgs.language || 'node';
+            const config = {
+                iterations: resolvedArgs.iterations,
+                maxInputLength: resolvedArgs.maxInputLength,
+                seed: resolvedArgs.seed,
+                timeoutMs: resolvedArgs.timeoutMs,
+            };
+            result = await executeFuzzProbe(effectiveRoot, code, language, config, abortSignal);
+            break;
+        }
+        case 'check_heap_delta': {
+            const code = resolvedArgs.code;
+            const language = resolvedArgs.language || 'node';
+            const config = {
+                warmupIterations: resolvedArgs.warmupIterations,
+                testIterations: resolvedArgs.testIterations,
+                samplingIntervalMs: resolvedArgs.samplingIntervalMs,
+                timeoutMs: resolvedArgs.timeoutMs,
+            };
+            result = await executeHeapDelta(effectiveRoot, code, language, config, abortSignal);
+            break;
+        }
+        case 'check_behavioral_drift': {
+            const baselineCode = resolvedArgs.baselineCode;
+            const candidateCode = resolvedArgs.candidateCode;
+            const language = resolvedArgs.language || 'node';
+            const config = {
+                tolerance: resolvedArgs.tolerance,
+                compareKeys: resolvedArgs.compareKeys,
+                timeoutMs: resolvedArgs.timeoutMs,
+            };
+            result = await executeBehavioralDrift(effectiveRoot, baselineCode, candidateCode, language, config, abortSignal);
+            break;
+        }
         default:
             result = { output: '', error: `Unknown tool: "${toolName}"` };
             break;

package/dist/services/agent.js

@@ -26,7 +26,7 @@ import { markedTerminal } from 'marked-terminal';
 const execAsync = promisify(exec);
 import { debugLog, isDebugOn } from '../utils/logger.js';
 import { ensureProjectStorage, ensureIgnored, readCache, writeCache, invalidateCacheForDependents, } from '../utils/projectStorage.js';
-import { GEMINI_MODELS, isByokEnabled } from '../utils/config.js';
+import { GEMINI_MODELS, isByokEnabled, TPM_COOLING_DELAYS } from '../utils/config.js';
 import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, generateChatTitle, getGlobalActiveModel, setGlobalActiveModel, summarizeChatHistory, } from './ai.js';
 import { getAndResetTurnUsage } from './proxyClient.js';
 import { changeLogger } from './changeLogger.js';
@@ -317,6 +317,8 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             inputHandler.start(spinner);
             changeLogger.startChangeSet(userInput);
             let finalInput = userInput;
+            // Inter-turn cooling-off delay to allow API token buckets to settle before running intent routing
+            await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.INTER_TURN_MS));
             // Stage 0: Summarize chat history if length threshold is met
             if (!cachedContextResult) {
                 const isDebug = isDebugOn();
@@ -359,6 +361,8 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     toolLogs.forEach((log) => p.log.step(log));
                     spinner.start(`🔍 Context gathered successfully.`);
                 }
+                // Post-investigation cooling-off delay to allow API Tokens-Per-Minute (TPM) sliding window to settle
+                await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.POST_INVESTIGATION_MS));
             }
             let latestUsage = undefined;
             // Collect any inputs that were queued while the Context Agent was investigating
@@ -481,7 +485,8 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                             modifiedFiles.forEach((file) => p.log.message(`  ${pc.dim('•')} ${file}`));
                         }
                         else {
-                            summaryMsg = 'Generation was stopped by the user before completion. No code files were modified before stopping.';
+                            summaryMsg =
+                                'Generation was stopped by the user before completion. No code files were modified before stopping.';
                             p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion (no files were modified).'));
                         }
                         chat.addTurn({
@@ -657,8 +662,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             const turnDuration = ((turnEndTime - turnStartTime) / 1000).toFixed(1);
             p.log.info(`${pc.dim('Generated in')} ${pc.cyan(turnDuration + 's')}`);
             // Check if generation was stopped by user
-            const isStopped = finalText.includes('Generation stopped') ||
-                finalText.includes('[Generation stopped');
+            const isStopped = finalText.includes('Generation stopped') || finalText.includes('[Generation stopped');
             if (isStopped) {
                 const currentChanges = changeLogger.getCurrentChangeSet()?.changes || [];
                 const modifiedFiles = currentChanges
@@ -672,7 +676,8 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                     modifiedFiles.forEach((file) => p.log.message(`  ${pc.dim('•')} ${file}`));
                 }
                 else {
-                    summaryMsg = 'Generation was stopped by the user before completion. No code files were modified before stopping.';
+                    summaryMsg =
+                        'Generation was stopped by the user before completion. No code files were modified before stopping.';
                     p.log.warn(pc.yellow('\n⚠️  Generation stopped by user before completion (no files were modified).'));
                 }
                 chat.addTurn({

package/dist/services/orchestration/investigationOrchestrator.js

@@ -25,6 +25,7 @@ import { InvestigationAgentRunner } from './investigationAgent.js';
 import { readFile } from '../agent-tools.js';
 import { buildDependencyGraph } from '../../utils/dependencyTracer.js';
 import { debugLog } from '../../utils/logger.js';
+import { TPM_COOLING_DELAYS } from '../../utils/config.js';
 // ─── Constants ───────────────────────────────────────────────────────
 /** Maximum total relevant files across all agents after merge. */
 const MAX_TOTAL_FILES = 30;
@@ -57,6 +58,8 @@ export class InvestigationOrchestrator {
         const agents = agentAssignments.map((assignment) => new InvestigationAgentRunner(assignment.agentLabel, assignment.domains, workspaceRoot, readCache, projectTree, projectType));
         // 3. Run all agents in parallel
         const startTime = Date.now();
+        // Cooling-off pause to prevent burst 429 errors when initiating parallel agent dispatch
+        await new Promise((resolve) => setTimeout(resolve, TPM_COOLING_DELAYS.PARALLEL_DISPATCH_MS));
         // Limit parallel investigation agents to 2 to avoid Vertex AI RESOURCE_EXHAUSTED errors
         const MAX_CONCURRENT = 2;
         const results = [];

package/dist/services/orchestration/scopedTools.js

@@ -1,3 +1,4 @@
+import path from 'path';
 import { executeTool, getToolDeclarations as getBaseToolDeclarations } from '../agent-tools.js';
 import { MessageBus } from './messageBus.js';
 import { debugLog } from '../../utils/logger.js';
@@ -149,6 +150,31 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
             const matchCount = (outputText.match(/\.\/[^:]+:\d+:/g) || []).length;
             resultSummary = `${matchCount} matches`;
         }
+        else if (name === 'rename_file') {
+            const src = String(args.sourcePath ?? '');
+            const tgt = String(args.targetPath ?? '');
+            targetDesc = `${src} -> ${tgt}`;
+            actionDesc = (src && tgt && path.dirname(src) === path.dirname(tgt)) ? 'Renamed' : 'Moved';
+        }
+        else if (name === 'delete_file') {
+            targetDesc = String(args.filePath);
+            actionDesc = 'Deleted';
+        }
+        else if (name === 'run_fuzz_probe') {
+            targetDesc = String(args.language ?? 'node');
+            actionDesc = 'Ran fuzz probe';
+            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed fuzz probe';
+        }
+        else if (name === 'check_heap_delta') {
+            targetDesc = String(args.language ?? 'node');
+            actionDesc = 'Inspected heap delta';
+            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed heap analysis';
+        }
+        else if (name === 'check_behavioral_drift') {
+            targetDesc = String(args.language ?? 'node');
+            actionDesc = 'Checked behavioral drift';
+            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed drift comparison';
+        }
         return result;
     }
     catch (error) {

package/dist/services/orchestration/subAgent.js

@@ -72,7 +72,7 @@ export class SubAgentRunner {
             `3. EXECUTION WORKFLOW:\n` +
             `   - Step 1 (Investigate): Use 'grep_search', 'read_file', or 'list_directory' to inspect the codebase as needed.\n` +
             `   - Step 2 (Execute): Use 'modify_file' or 'write_file' to implement the required changes.\n` +
-            `   - Step 3 (Verify): Use 'run_debug_script' or 'run_command' to test your changes if necessary.\n` +
+            `   - Step 3 (Verify): Use 'run_debug_script', 'run_fuzz_probe', 'check_heap_delta', 'check_behavioral_drift', or 'run_command' to test your changes if necessary.\n` +
             `   - Step 4 (Conclude): Once your specific objective is fully met, stop calling tools and return a text summary of your changes.\n` +
             `4. Coordinate: Use 'read_messages' to check for updates from other agents. Use 'post_message' if you discover breaking changes affecting others.\n` +
             `</critical_guidelines>`);

package/dist/services/proxyClient.js

@@ -41,7 +41,7 @@ let globalSessionAccumulatedUsage = {
     totalTokenCount: 0,
     creditsUsed: 0,
     remainingBalance: undefined,
-    modelsUsed: {}
+    modelsUsed: {},
 };
 export function getAndResetTurnUsage() {
     const current = { ...globalSessionAccumulatedUsage };
@@ -52,7 +52,7 @@ export function getAndResetTurnUsage() {
         totalTokenCount: 0,
         creditsUsed: 0,
         remainingBalance: undefined,
-        modelsUsed: {}
+        modelsUsed: {},
     };
     return current;
 }
@@ -117,6 +117,7 @@ export class ProxyClient {
             if ((response.status === 429 || response.status === 503) && attempt < MAX_RETRIES) {
                 const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
                 const delayTime = Math.round(exponentialDelay * (0.5 + Math.random() * 0.5));
+                process.stdout.write('\n');
                 console.warn(`Rate limit or service unavailable hit (${response.status}). Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
                 await delay(delayTime, abortSignal);
                 attempt++;
@@ -198,7 +199,7 @@ export class ProxyClient {
                                     collector?.accumulateUsage({
                                         promptTokens: data.usage.promptTokens || 0,
                                         candidatesTokens: data.usage.candidatesTokens || 0,
-                                        cachedTokens: data.usage.cachedTokens || 0
+                                        cachedTokens: data.usage.cachedTokens || 0,
                                     });
                                     globalSessionAccumulatedUsage.promptTokens += data.usage.promptTokens || 0;
                                     globalSessionAccumulatedUsage.candidatesTokens += data.usage.candidatesTokens || 0;
@@ -209,7 +210,8 @@ export class ProxyClient {
                                     if (data.usage.remainingBalance !== undefined) {
                                         globalSessionAccumulatedUsage.remainingBalance = data.usage.remainingBalance;
                                     }
-                                    globalSessionAccumulatedUsage.modelsUsed[modelName] = (globalSessionAccumulatedUsage.modelsUsed[modelName] || 0) + 1;
+                                    globalSessionAccumulatedUsage.modelsUsed[modelName] =
+                                        (globalSessionAccumulatedUsage.modelsUsed[modelName] || 0) + 1;
                                 }
                                 if (data.groundingMetadata) {
                                     groundingMetadata = data.groundingMetadata;
@@ -236,6 +238,7 @@ export class ProxyClient {
                     if (attempt < MAX_RETRIES) {
                         const exponentialDelay = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * Math.pow(2, attempt));
                         const delayTime = Math.round(exponentialDelay * (0.5 + Math.random() * 0.5));
+                        process.stdout.write('\n');
                         console.warn(`Rate limit or service unavailable hit during stream. Retrying in ${(delayTime / 1000).toFixed(1)}s... (Attempt ${attempt + 1}/${MAX_RETRIES})`);
                         await delay(delayTime, abortSignal);
                         attempt++;