minovative-mind-cli 2.7.0 → 2.8.1

package/dist/utils/analysisRunner.d.ts

@@ -70,3 +70,68 @@ export declare function generatePBTScriptTemplate(language: string, targetFuncti
  * Runs an ephemeral Property-Based Test script and extracts failure counterexamples and shrink results.
  */
 export declare function runPropertyBasedTest(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: PropertyTestConfig & EphemeralScriptOptions): Promise<PropertyTestResult>;
+export interface FuzzProbeConfig {
+    iterations?: number;
+    maxInputLength?: number;
+    seed?: number;
+    timeoutMs?: number;
+}
+export interface FuzzProbeResult extends EphemeralScriptResult {
+    passed: boolean;
+    totalFuzzRuns: number;
+    failingInputs?: string[];
+    errorSummary?: string;
+    seed?: number;
+}
+export interface HeapDeltaConfig {
+    warmupIterations?: number;
+    testIterations?: number;
+    samplingIntervalMs?: number;
+}
+export interface HeapDeltaResult extends EphemeralScriptResult {
+    initialHeapBytes: number;
+    finalHeapBytes: number;
+    deltaBytes: number;
+    leakDetected: boolean;
+    growthRateBytesPerIter?: number;
+    samples?: Array<{
+        iteration: number;
+        heapBytes: number;
+    }>;
+}
+export interface BehavioralDriftConfig {
+    tolerance?: number;
+    compareKeys?: string[];
+}
+export interface BehavioralDriftResult extends EphemeralScriptResult {
+    hasDrift: boolean;
+    baselineOutput?: string;
+    candidateOutput?: string;
+    diffSummary?: string;
+    driftDetails?: Array<{
+        field?: string;
+        baseline: any;
+        candidate: any;
+        diff?: string;
+    }>;
+}
+/**
+ * Generates an ephemeral Fuzz Probe script template tailored to the target language.
+ */
+export declare function generateFuzzScriptTemplate(language: string, targetFeature: string, config?: FuzzProbeConfig): string;
+/**
+ * Runs a fuzz probing analysis script and parses failure counterexamples and crash statistics.
+ */
+export declare function runFuzzProbe(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: FuzzProbeConfig & EphemeralScriptOptions): Promise<FuzzProbeResult>;
+/**
+ * Generates an ephemeral memory heap analysis script template tailored to the target language.
+ */
+export declare function generateHeapCheckScriptTemplate(language: string, targetCode: string, config?: HeapDeltaConfig): string;
+/**
+ * Runs a memory heap inspection script and extracts heap growth, leak indicators, and memory delta statistics.
+ */
+export declare function checkHeapDelta(workspaceRoot: string, code: string, language?: string | EphemeralScriptOptions, config?: HeapDeltaConfig & EphemeralScriptOptions): Promise<HeapDeltaResult>;
+/**
+ * Executes baseline and candidate scripts, comparing outputs and return values to detect behavioral drift.
+ */
+export declare function checkBehavioralDrift(workspaceRoot: string, baselineCode: string, candidateCode: string, language?: string | EphemeralScriptOptions, config?: BehavioralDriftConfig & EphemeralScriptOptions): Promise<BehavioralDriftResult>;

package/dist/utils/analysisRunner.js

@@ -324,3 +324,561 @@ export async function runPropertyBasedTest(workspaceRoot, code, language = 'node
         numRunsCompleted,
     };
 }
+/**
+ * Generates an ephemeral Fuzz Probe script template tailored to the target language.
+ */
+export function generateFuzzScriptTemplate(language, targetFeature, config) {
+    const normLang = normalizeLanguage(language);
+    const iterations = config?.iterations ?? 500;
+    const maxLen = config?.maxInputLength ?? 256;
+    if (normLang === 'python') {
+        return `import sys, random, traceback
+
+# Fuzz Probe Target: ${targetFeature}
+def fuzz_target(data: bytes):
+    if len(data) > 0 and data[0] == 0xff:
+        raise ValueError("Simulated fuzz anomaly detected")
+
+def run_fuzz():
+    runs = ${iterations}
+    failed_inputs = []
+    
+    for i in range(runs):
+        input_len = random.randint(0, ${maxLen})
+        fuzz_data = random.randbytes(input_len) if hasattr(random, 'randbytes') else bytes([random.randint(0, 255) for _ in range(input_len)])
+        
+        try:
+            fuzz_target(fuzz_data)
+        except Exception as e:
+            failed_inputs.append(fuzz_data.hex())
+            print(f"[FUZZ FAILED] Iteration: {i}, Error: {e}")
+            if len(failed_inputs) >= 5:
+                break
+                
+    if failed_inputs:
+        print(f"[FUZZ SUMMARY] Total Runs: {runs}, Failures: {len(failed_inputs)}")
+        sys.exit(1)
+    else:
+        print(f"[FUZZ PASSED] Completed {runs} fuzz runs without crashes.")
+
+if __name__ == "__main__":
+    run_fuzz()
+`;
+    }
+    if (normLang === 'go') {
+        return `package main
+
+import (
+	"fmt"
+	"math/rand"
+	"os"
+)
+
+func fuzzTarget(data []byte) {
+	if len(data) > 0 && data[0] == 0xff {
+		panic("Simulated fuzz anomaly detected")
+	}
+}
+
+func main() {
+	runs := ${iterations}
+	failures := 0
+
+	for i := 0; i < runs; i++ {
+		length := rand.Intn(${maxLen} + 1)
+		data := make([]byte, length)
+		rand.Read(data)
+
+		func() {
+			defer func() {
+				if r := recover(); r != nil {
+					failures++
+					fmt.Printf("[FUZZ FAILED] Iteration %d: %v\\n", i, r)
+				}
+			}()
+			fuzzTarget(data)
+		}()
+
+		if failures >= 5 {
+			break
+		}
+	}
+
+	if failures > 0 {
+		fmt.Printf("[FUZZ SUMMARY] Total Runs: %d, Failures: %d\\n", runs, failures)
+		os.Exit(1)
+	} else {
+		fmt.Printf("[FUZZ PASSED] Completed %d fuzz runs without crashes.\\n", runs)
+	}
+}
+`;
+    }
+    if (normLang === 'rust') {
+        return `use std::panic;
+
+fn fuzz_target(data: &[u8]) {
+    if !data.is_empty() && data[0] == 0xff {
+        panic!("Simulated fuzz anomaly detected");
+    }
+}
+
+fn main() {
+    let runs = ${iterations};
+    let mut failures = 0;
+
+    for i in 0..runs {
+        let len = (i * 37) % ${maxLen};
+        let data: Vec<u8> = (0..len).map(|j| ((i + j) % 256) as u8).collect();
+
+        let result = panic::catch_unwind(|| {
+            fuzz_target(&data);
+        });
+
+        if result.is_err() {
+            failures += 1;
+            println!("[FUZZ FAILED] Iteration {}", i);
+            if failures >= 5 {
+                break;
+            }
+        }
+    }
+
+    if failures > 0 {
+        println!("[FUZZ SUMMARY] Total Runs: {}, Failures: {}", runs, failures);
+        std::process::exit(1);
+    } else {
+        println!("[FUZZ PASSED] Completed {} fuzz runs without crashes.", runs);
+    }
+}
+`;
+    }
+    // Default Node / TypeScript template
+    return `// Fuzz Probe Target: ${targetFeature}
+function fuzzTarget(buffer) {
+  if (buffer.length > 0 && buffer[0] === 0xff) {
+    throw new Error('Simulated fuzz anomaly detected');
+  }
+}
+
+function runFuzz() {
+  const runs = ${iterations};
+  const maxLen = ${maxLen};
+  const failingInputs = [];
+
+  for (let i = 0; i < runs; i++) {
+    const len = Math.floor(Math.random() * maxLen);
+    const buf = Buffer.alloc(len);
+    for (let j = 0; j < len; j++) buf[j] = Math.floor(Math.random() * 256);
+
+    try {
+      fuzzTarget(buf);
+    } catch (err) {
+      failingInputs.push(buf.toString('hex'));
+      console.log(\`[FUZZ FAILED] Iteration: \${i}, Error: \${err.message}\`);
+      if (failingInputs.length >= 5) break;
+    }
+  }
+
+  if (failingInputs.length > 0) {
+    console.log(\`[FUZZ SUMMARY] Total Runs: \${runs}, Failures: \${failingInputs.length}\`);
+    process.exit(1);
+  } else {
+    console.log(\`[FUZZ PASSED] Completed \${runs} fuzz runs without crashes.\`);
+  }
+}
+
+runFuzz();
+`;
+}
+/**
+ * Runs a fuzz probing analysis script and parses failure counterexamples and crash statistics.
+ */
+export async function runFuzzProbe(workspaceRoot, code, language = 'node', config) {
+    let lang = 'node';
+    let opts;
+    if (typeof language === 'string') {
+        lang = language;
+        opts = config;
+    }
+    else if (typeof language === 'object' && language !== null) {
+        opts = language;
+    }
+    const scriptResult = await runEphemeralScript(workspaceRoot, lang, code, opts);
+    const combinedOutput = `${scriptResult.stdout}\n${scriptResult.stderr}`;
+    const isPassed = scriptResult.exitCode === 0 &&
+        (combinedOutput.includes('[FUZZ PASSED]') || !combinedOutput.includes('[FUZZ FAILED]'));
+    const failingInputs = [];
+    const failRegex = /(?:\[FUZZ FAILED\]|Failing Input|Counterexample)[:\s]\s*([^\n]+)/gi;
+    let match;
+    while ((match = failRegex.exec(combinedOutput)) !== null) {
+        failingInputs.push(match[1].trim());
+    }
+    let totalFuzzRuns = 0;
+    const runsMatch = combinedOutput.match(/(?:Total Runs|Runs):\s*(\d+)/i) || combinedOutput.match(/Completed\s+(\d+)\s+(?:fuzz\s+)?runs/i);
+    if (runsMatch) {
+        totalFuzzRuns = parseInt(runsMatch[1], 10);
+    }
+    let seed;
+    const seedMatch = combinedOutput.match(/Seed:\s*(\d+)/i);
+    if (seedMatch) {
+        seed = parseInt(seedMatch[1], 10);
+    }
+    let errorSummary;
+    if (!isPassed) {
+        const errLine = scriptResult.stderr.split('\n').find((l) => l.trim().length > 0) ||
+            combinedOutput.split('\n').find((l) => l.toLowerCase().includes('error') || l.includes('[FUZZ FAILED]'));
+        errorSummary = errLine?.trim() || 'Fuzzing probe encountered unexpected failure or crash.';
+    }
+    return {
+        ...scriptResult,
+        passed: isPassed,
+        totalFuzzRuns,
+        failingInputs: failingInputs.length > 0 ? failingInputs : undefined,
+        errorSummary,
+        seed,
+    };
+}
+/**
+ * Generates an ephemeral memory heap analysis script template tailored to the target language.
+ */
+export function generateHeapCheckScriptTemplate(language, targetCode, config) {
+    const normLang = normalizeLanguage(language);
+    const warmup = config?.warmupIterations ?? 10;
+    const testIters = config?.testIterations ?? 100;
+    if (normLang === 'python') {
+        return `import sys, gc
+
+# Target Logic:
+# ${targetCode.replace(/\n/g, '\n# ')}
+
+def main():
+    gc.collect()
+    start_bytes = 0
+    try:
+        import os, psutil
+        process = psutil.Process(os.getpid())
+        start_bytes = process.memory_info().rss
+    except Exception:
+        import resource
+        start_bytes = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * 1024
+
+    print(f"[HEAP_START] {start_bytes}")
+
+    for _ in range(${warmup}):
+        pass
+
+    test_iters = ${testIters}
+    for i in range(test_iters):
+        if i % max(1, test_iters // 5) == 0:
+            gc.collect()
+            try:
+                import os, psutil
+                curr = psutil.Process(os.getpid()).memory_info().rss
+            except Exception:
+                import resource
+                curr = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * 1024
+            print(f"[HEAP_SAMPLE] {i}, {curr}")
+
+    gc.collect()
+    final_bytes = start_bytes
+    try:
+        import os, psutil
+        final_bytes = psutil.Process(os.getpid()).memory_info().rss
+    except Exception:
+        import resource
+        final_bytes = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * 1024
+
+    delta = final_bytes - start_bytes
+    print(f"[HEAP_FINAL] {final_bytes}")
+    print(f"[HEAP_DELTA] {delta}")
+
+if __name__ == "__main__":
+    main()
+`;
+    }
+    if (normLang === 'go') {
+        return `package main
+
+import (
+	"fmt"
+	"runtime"
+)
+
+func main() {
+	var m runtime.MemStats
+	runtime.GC()
+	runtime.ReadMemStats(&m)
+	initial := m.Alloc
+	fmt.Printf("[HEAP_START] %d\\n", initial)
+
+	testIters := ${testIters}
+	for i := 0; i < testIters; i++ {
+		if i%(testIters/5+1) == 0 {
+			runtime.ReadMemStats(&m)
+			fmt.Printf("[HEAP_SAMPLE] %d, %d\\n", i, m.Alloc)
+		}
+	}
+
+	runtime.GC()
+	runtime.ReadMemStats(&m)
+	finalHeap := m.Alloc
+	delta := int64(finalHeap) - int64(initial)
+	fmt.Printf("[HEAP_FINAL] %d\\n", finalHeap)
+	fmt.Printf("[HEAP_DELTA] %d\\n", delta)
+}
+`;
+    }
+    // Default Node / TypeScript template
+    return `if (global.gc) global.gc();
+const initial = process.memoryUsage().heapUsed;
+console.log(\`[HEAP_START] \${initial}\`);
+
+for (let i = 0; i < ${warmup}; i++) {
+  // Warmup iteration
+}
+
+const testIters = ${testIters};
+for (let i = 0; i < testIters; i++) {
+  if (i % Math.max(1, Math.floor(testIters / 5)) === 0) {
+    if (global.gc) global.gc();
+    console.log(\`[HEAP_SAMPLE] \${i}, \${process.memoryUsage().heapUsed}\`);
+  }
+}
+
+if (global.gc) global.gc();
+const finalHeap = process.memoryUsage().heapUsed;
+const delta = finalHeap - initial;
+console.log(\`[HEAP_FINAL] \${finalHeap}\`);
+console.log(\`[HEAP_DELTA] \${delta}\`);
+`;
+}
+/**
+ * Runs a memory heap inspection script and extracts heap growth, leak indicators, and memory delta statistics.
+ */
+export async function checkHeapDelta(workspaceRoot, code, language = 'node', config) {
+    let lang = 'node';
+    let opts;
+    if (typeof language === 'string') {
+        lang = language;
+        opts = config;
+    }
+    else if (typeof language === 'object' && language !== null) {
+        opts = language;
+    }
+    const scriptResult = await runEphemeralScript(workspaceRoot, lang, code, opts);
+    const combinedOutput = `${scriptResult.stdout}\n${scriptResult.stderr}`;
+    let initialHeapBytes = 0;
+    const startMatch = combinedOutput.match(/(?:\[HEAP_START\]|Heap start:)\s*(-?\d+)/i);
+    if (startMatch) {
+        initialHeapBytes = parseInt(startMatch[1], 10);
+    }
+    let finalHeapBytes = 0;
+    const finalMatch = combinedOutput.match(/(?:\[HEAP_FINAL\]|Heap final:)\s*(-?\d+)/i);
+    if (finalMatch) {
+        finalHeapBytes = parseInt(finalMatch[1], 10);
+    }
+    let deltaBytes = finalHeapBytes - initialHeapBytes;
+    const deltaMatch = combinedOutput.match(/(?:\[HEAP_DELTA\]|Heap delta:)\s*(-?\d+)/i);
+    if (deltaMatch) {
+        deltaBytes = parseInt(deltaMatch[1], 10);
+    }
+    const samples = [];
+    const sampleRegex = /(?:\[HEAP_SAMPLE\]|Sample\s+(\d+):?)\s*(\d+)(?:,\s*(\d+))?/gi;
+    let sMatch;
+    while ((sMatch = sampleRegex.exec(combinedOutput)) !== null) {
+        const iter = parseInt(sMatch[1], 10);
+        const bytes = sMatch[3] ? parseInt(sMatch[3], 10) : parseInt(sMatch[2], 10);
+        if (!isNaN(iter) && !isNaN(bytes)) {
+            samples.push({ iteration: iter, heapBytes: bytes });
+        }
+    }
+    let growthRateBytesPerIter;
+    if (samples.length >= 2) {
+        const first = samples[0];
+        const last = samples[samples.length - 1];
+        const iterDiff = last.iteration - first.iteration;
+        if (iterDiff > 0) {
+            growthRateBytesPerIter = (last.heapBytes - first.heapBytes) / iterDiff;
+        }
+    }
+    else if (config?.testIterations && config.testIterations > 0) {
+        growthRateBytesPerIter = deltaBytes / config.testIterations;
+    }
+    const leakDetected = combinedOutput.includes('[LEAK_DETECTED]') ||
+        deltaBytes > (config?.warmupIterations ? 1_048_576 : 5_242_880) ||
+        (growthRateBytesPerIter !== undefined && growthRateBytesPerIter > 10_000);
+    return {
+        ...scriptResult,
+        initialHeapBytes,
+        finalHeapBytes,
+        deltaBytes,
+        leakDetected,
+        growthRateBytesPerIter,
+        samples: samples.length > 0 ? samples : undefined,
+    };
+}
+/**
+ * Helper to deep-compare JSON values with optional numerical tolerance.
+ */
+function compareJsonValues(val1, val2, pathStr, tolerance, details) {
+    if (val1 === val2)
+        return;
+    if (typeof val1 === 'number' && typeof val2 === 'number') {
+        if (Math.abs(val1 - val2) > tolerance) {
+            details.push({
+                field: pathStr,
+                baseline: val1,
+                candidate: val2,
+                diff: `Numeric difference exceeds tolerance (${tolerance}): |${val1} - ${val2}| = ${Math.abs(val1 - val2)}`,
+            });
+        }
+        return;
+    }
+    if (typeof val1 !== typeof val2 || val1 === null || val2 === null) {
+        details.push({
+            field: pathStr,
+            baseline: val1,
+            candidate: val2,
+            diff: `Type mismatch: baseline is ${typeof val1}, candidate is ${typeof val2}`,
+        });
+        return;
+    }
+    if (Array.isArray(val1) && Array.isArray(val2)) {
+        if (val1.length !== val2.length) {
+            details.push({
+                field: `${pathStr}.length`,
+                baseline: val1.length,
+                candidate: val2.length,
+                diff: `Array length mismatch: baseline length ${val1.length}, candidate length ${val2.length}`,
+            });
+        }
+        const minLen = Math.min(val1.length, val2.length);
+        for (let i = 0; i < minLen; i++) {
+            compareJsonValues(val1[i], val2[i], `${pathStr}[${i}]`, tolerance, details);
+        }
+        return;
+    }
+    if (typeof val1 === 'object' && typeof val2 === 'object') {
+        const keys1 = Object.keys(val1);
+        const keys2 = Object.keys(val2);
+        const allKeys = new Set([...keys1, ...keys2]);
+        for (const key of allKeys) {
+            const subPath = pathStr ? `${pathStr}.${key}` : key;
+            if (!(key in val1)) {
+                details.push({
+                    field: subPath,
+                    baseline: undefined,
+                    candidate: val2[key],
+                    diff: `Key "${key}" missing in baseline`,
+                });
+            }
+            else if (!(key in val2)) {
+                details.push({
+                    field: subPath,
+                    baseline: val1[key],
+                    candidate: undefined,
+                    diff: `Key "${key}" missing in candidate`,
+                });
+            }
+            else {
+                compareJsonValues(val1[key], val2[key], subPath, tolerance, details);
+            }
+        }
+        return;
+    }
+    details.push({
+        field: pathStr,
+        baseline: val1,
+        candidate: val2,
+        diff: `Value mismatch: baseline="${val1}", candidate="${val2}"`,
+    });
+}
+/**
+ * Computes a line-by-line diff string between baseline and candidate output strings.
+ */
+function computeTextDiff(text1, text2) {
+    const lines1 = text1.split('\n');
+    const lines2 = text2.split('\n');
+    const diffs = [];
+    const maxLines = Math.max(lines1.length, lines2.length);
+    for (let i = 0; i < maxLines; i++) {
+        const l1 = lines1[i];
+        const l2 = lines2[i];
+        if (l1 !== l2) {
+            if (l1 === undefined) {
+                diffs.push(`+ Line ${i + 1}: ${l2}`);
+            }
+            else if (l2 === undefined) {
+                diffs.push(`- Line ${i + 1}: ${l1}`);
+            }
+            else {
+                diffs.push(`- Line ${i + 1}: ${l1}`);
+                diffs.push(`+ Line ${i + 1}: ${l2}`);
+            }
+        }
+    }
+    return diffs.join('\n');
+}
+/**
+ * Executes baseline and candidate scripts, comparing outputs and return values to detect behavioral drift.
+ */
+export async function checkBehavioralDrift(workspaceRoot, baselineCode, candidateCode, language = 'node', config) {
+    let lang = 'node';
+    let opts;
+    if (typeof language === 'string') {
+        lang = language;
+        opts = config;
+    }
+    else if (typeof language === 'object' && language !== null) {
+        opts = language;
+    }
+    const [baselineResult, candidateResult] = await Promise.all([
+        runEphemeralScript(workspaceRoot, lang, baselineCode, opts),
+        runEphemeralScript(workspaceRoot, lang, candidateCode, opts),
+    ]);
+    const baselineOut = baselineResult.stdout.trim();
+    const candidateOut = candidateResult.stdout.trim();
+    const driftDetails = [];
+    const tolerance = config?.tolerance ?? 1e-6;
+    let isJsonComparison = false;
+    try {
+        const jsonBaseline = JSON.parse(baselineOut);
+        const jsonCandidate = JSON.parse(candidateOut);
+        isJsonComparison = true;
+        compareJsonValues(jsonBaseline, jsonCandidate, '', tolerance, driftDetails);
+    }
+    catch {
+        // Non-JSON comparison fallback
+    }
+    if (!isJsonComparison) {
+        if (baselineOut !== candidateOut) {
+            driftDetails.push({
+                baseline: baselineOut,
+                candidate: candidateOut,
+                diff: 'Plain text output mismatch',
+            });
+        }
+    }
+    if (baselineResult.exitCode !== candidateResult.exitCode) {
+        driftDetails.push({
+            field: 'exitCode',
+            baseline: baselineResult.exitCode,
+            candidate: candidateResult.exitCode,
+            diff: `Exit code mismatch: baseline exited with ${baselineResult.exitCode}, candidate with ${candidateResult.exitCode}`,
+        });
+    }
+    const hasDrift = driftDetails.length > 0;
+    const diffSummary = hasDrift ? computeTextDiff(baselineOut, candidateOut) : undefined;
+    const combinedStdout = `--- Baseline Stdout ---\n${baselineResult.stdout}\n--- Candidate Stdout ---\n${candidateResult.stdout}`;
+    const combinedStderr = `--- Baseline Stderr ---\n${baselineResult.stderr}\n--- Candidate Stderr ---\n${candidateResult.stderr}`;
+    return {
+        stdout: combinedStdout,
+        stderr: combinedStderr,
+        exitCode: hasDrift ? 1 : 0,
+        hasDrift,
+        baselineOutput: baselineOut,
+        candidateOutput: candidateOut,
+        diffSummary,
+        driftDetails: driftDetails.length > 0 ? driftDetails : undefined,
+    };
+}

package/dist/utils/config.d.ts

@@ -25,6 +25,19 @@ export declare const GEMINI_MODELS: {
 export declare const DEFAULT_MODEL: "auto";
 /** Maximum tokens the model can output per response. */
 export declare const MAX_OUTPUT_TOKENS = 60000;
+/**
+ * Rate limit & Tokens-Per-Minute (TPM) cooling-off delays (in milliseconds).
+ * Prevents transient 429 / 503 rate-limit errors by giving the API 60-second
+ * rolling token window time to settle during key agent transitions.
+ */
+export declare const TPM_COOLING_DELAYS: {
+    /** Pause before running initial intent routing between turns */
+    readonly INTER_TURN_MS: 1000;
+    /** Pause before dispatching parallel sub-agent investigations simultaneously */
+    readonly PARALLEL_DISPATCH_MS: 1000;
+    /** Pause after context gathering completes before starting the execution stream */
+    readonly POST_INVESTIGATION_MS: 3000;
+};
 /**
  * Checks if BYOK is currently enabled for the user.
  */

package/dist/utils/config.js

@@ -25,6 +25,19 @@ export const GEMINI_MODELS = {
 export const DEFAULT_MODEL = GEMINI_MODELS.AUTO;
 /** Maximum tokens the model can output per response. */
 export const MAX_OUTPUT_TOKENS = 60_000;
+/**
+ * Rate limit & Tokens-Per-Minute (TPM) cooling-off delays (in milliseconds).
+ * Prevents transient 429 / 503 rate-limit errors by giving the API 60-second
+ * rolling token window time to settle during key agent transitions.
+ */
+export const TPM_COOLING_DELAYS = {
+    /** Pause before running initial intent routing between turns */
+    INTER_TURN_MS: 1000,
+    /** Pause before dispatching parallel sub-agent investigations simultaneously */
+    PARALLEL_DISPATCH_MS: 1000,
+    /** Pause after context gathering completes before starting the execution stream */
+    POST_INVESTIGATION_MS: 3000,
+};
 /**
  * Checks if BYOK is currently enabled for the user.
  */