minovative-mind-cli 2.13.4 → 2.14.0

package/dist/services/orchestration/investigationAgent.js

@@ -59,6 +59,9 @@ export class InvestigationAgentRunner {
             temperature: 1,
             topP: 0.95,
             topK: 40,
+            thinkingConfig: {
+                thinkingLevel: 'MEDIUM',
+            },
         }, {
             functionCallingConfig: {
                 mode: 'ANY',
@@ -98,7 +101,7 @@ export class InvestigationAgentRunner {
      * @returns The investigation result with discovered files and summary.
      */
     async execute(userRequest, chatHistory, abortSignal, onProgress, onTool) {
-        debugLog(`InvestigationAgent [${this.agentLabel}]: Starting execution for domains: ${this.domains.join(', ')}`);
+        debugLog(`InvestigationAgent [${this.agentLabel}]: Starting execution [Model: ${this.chat.getModel()}, Thinking: ${this.chat.getThinkingLevel() || 'MEDIUM'}] for domains: ${this.domains.join(', ')}`);
         this.lastHeartbeat = Date.now();
         const relevantFiles = new Map();
         let summary = 'No relevant context found.';

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

@@ -76,9 +76,15 @@ export interface BusQueryOptions {
     type?: 'discovery' | 'warning' | 'request' | 'completion';
     onlyMutations?: boolean;
     targetFiles?: string[];
+    readOnlyFiles?: string[];
     dependsOn?: string[];
     advanceCursor?: boolean;
 }
+/**
+ * Checks if a target path matches any file in a scoped file list,
+ * handling relative paths, normalizations, and partial segment matches.
+ */
+export declare function isPathMatchingScope(target: string, scopedFiles: string[]): boolean;
 interface CoalescedEntry {
     agentId: string;
     tool: string;
@@ -101,9 +107,10 @@ export declare function coalesceActivityEntries(entries: ActivityEntry[]): Coale
  */
 export declare class MessageBus {
     /** Maximum semantic signals any single agent can post */
-    static readonly MAX_SIGNALS_PER_AGENT = 50;
+    static readonly MAX_SIGNALS_PER_AGENT = 1000;
     private activityCursors;
     private activityLog;
+    private inBandNoticeCursors;
     private readonly persistPath;
     private persistQueue;
     private signalCursors;
@@ -117,6 +124,7 @@ export declare class MessageBus {
     static formatActivityEntries(entries: ActivityEntry[]): string;
     /**
      * Formats semantic signals into a readable string for agent context injection.
+     * Deduplicates identical signal renderings to eliminate payload bloat.
      */
     static formatSignals(signals: BusSignal[]): string;
     /**
@@ -159,22 +167,36 @@ export declare class MessageBus {
     /**
      * Records a tool execution into the activity log. Called by the scoped tool
      * wrapper in `scopedTools.ts` — zero cost to the agent.
+     * Sanitizes and caps result summaries and target paths to eliminate payload bloat.
      */
     logActivity(entry: ActivityEntry): void;
+    /**
+     * Retrieves newly arrived urgent signals relevant to an agent's task scope
+     * that have NOT yet been delivered in-band to this agent, and advances the in-band cursor.
+     * This ensures an urgent notice is delivered ONCE on the next tool execution
+     * rather than being repetitively injected on every single subsequent tool turn.
+     */
+    getNewUrgentSignals(agentId: string, scope?: {
+        targetFiles?: string[];
+        readOnlyFiles?: string[];
+        dependsOn?: string[];
+    }): BusSignal[];
     /**
      * Peeks urgent signals (breaking warnings or direct requests) that are relevant
      * to a sub-agent's task scope without advancing its cursor. Used for in-band notice
-     * delivery in scopedTools.
+     * delivery or diagnostics.
      */
     peekUrgentSignals(agentId: string, scope?: {
         targetFiles?: string[];
+        readOnlyFiles?: string[];
         dependsOn?: string[];
     }): BusSignal[];
     /**
      * Posts a semantic signal from an agent. These cost tokens (the agent calls
      * `post_message`) but carry intent that raw tool logs cannot express.
      *
-     * Enforces per-agent signal cap to prevent runaway agents from flooding the bus.
+     * Enforces signal deduplication, content sanitization, and per-agent caps
+     * to eliminate redundant message propagation and bus flooding.
      *
      * @returns `true` if the signal was accepted, `false` if the agent hit the cap.
      */
@@ -182,7 +204,8 @@ export declare class MessageBus {
     /**
      * Performs an intelligent, scoped query against unread bus activity and signals.
      * Filters out read-only noise for peer sub-agents, enforces unicast delivery for targeted
-     * requests, and supports selective querying by file, agent, or signal type.
+     * requests, applies task-scope and dependency filtering to eliminate payload bloat,
+     * and supports selective querying by file, agent, or signal type.
      */
     queryBus(options: BusQueryOptions): {
         activities: ActivityEntry[];

package/dist/services/orchestration/messageBus.js

@@ -19,13 +19,24 @@ import { promises as fs, readFileSync, existsSync, mkdirSync } from 'node:fs';
 import path from 'node:path';
 import { atomicWriteFile } from '../../utils/atomicWrite.js';
 import { debugLog } from '../../utils/logger.js';
-export const MUTATING_TOOLS = new Set([
-    'write_file',
-    'modify_file',
-    'delete_file',
-    'rename_file',
-    'run_command',
-]);
+export const MUTATING_TOOLS = new Set(['write_file', 'modify_file', 'delete_file', 'rename_file', 'run_command']);
+/**
+ * Checks if a target path matches any file in a scoped file list,
+ * handling relative paths, normalizations, and partial segment matches.
+ */
+export function isPathMatchingScope(target, scopedFiles) {
+    if (!target || !scopedFiles || scopedFiles.length === 0)
+        return false;
+    const normTarget = target.replace(/\\/g, '/').toLowerCase().replace(/^\.\//, '');
+    return scopedFiles.some((f) => {
+        const normScope = f.replace(/\\/g, '/').toLowerCase().replace(/^\.\//, '');
+        return (normTarget === normScope ||
+            normTarget.endsWith(`/${normScope}`) ||
+            normScope.endsWith(`/${normTarget}`) ||
+            normTarget.includes(normScope) ||
+            normScope.includes(normTarget));
+    });
+}
 export function coalesceActivityEntries(entries) {
     const result = [];
     for (const entry of entries) {
@@ -64,9 +75,10 @@ export function coalesceActivityEntries(entries) {
  */
 export class MessageBus {
     /** Maximum semantic signals any single agent can post */
-    static MAX_SIGNALS_PER_AGENT = 50;
+    static MAX_SIGNALS_PER_AGENT = 1000;
     activityCursors = new Map();
     activityLog = [];
+    inBandNoticeCursors = new Map();
     persistPath;
     persistQueue = Promise.resolve();
     signalCursors = new Map();
@@ -99,27 +111,39 @@ export class MessageBus {
     // ─── Layer 2: Semantic Signals ───────────────────────────────────
     /**
      * Formats semantic signals into a readable string for agent context injection.
+     * Deduplicates identical signal renderings to eliminate payload bloat.
      */
     static formatSignals(signals) {
         if (signals.length === 0)
             return '';
-        return signals
-            .map((s) => {
+        const seen = new Set();
+        const lines = [];
+        for (const s of signals) {
             const tag = s.type.toUpperCase();
+            let line = '';
             switch (s.type) {
                 case 'discovery':
-                    return `  [${tag} from ${s.fromAgent}]: "${s.content}" (affects: ${s.affectedFiles.join(', ')})`;
+                    line = `  [${tag} from ${s.fromAgent}]: "${s.content}" (affects: ${s.affectedFiles.join(', ')})`;
+                    break;
                 case 'warning':
-                    return `  [${tag} from ${s.fromAgent}]: "${s.content}"${s.changedSignature ? ` (signature: ${s.changedSignature})` : ''}`;
+                    line = `  [${tag} from ${s.fromAgent}]: "${s.content}"${s.changedSignature ? ` (signature: ${s.changedSignature})` : ''}`;
+                    break;
                 case 'request':
-                    return `  [${tag} from ${s.fromAgent} → ${s.toAgent}]: "${s.content}"`;
+                    line = `  [${tag} from ${s.fromAgent} → ${s.toAgent}]: "${s.content}"`;
+                    break;
                 case 'completion':
-                    return `  [${tag} from ${s.fromAgent}]: "${s.summary}"`;
+                    line = `  [${tag} from ${s.fromAgent}]: "${s.summary}"`;
+                    break;
                 default:
-                    return `  [SIGNAL from ${s.fromAgent}]: ${JSON.stringify(s)}`;
+                    line = `  [SIGNAL from ${s.fromAgent}]: ${JSON.stringify(s)}`;
+                    break;
             }
-        })
-            .join('\n');
+            if (!seen.has(line)) {
+                seen.add(line);
+                lines.push(line);
+            }
+        }
+        return lines.join('\n');
     }
     // ─── Reading ─────────────────────────────────────────────────────
     /**
@@ -131,6 +155,7 @@ export class MessageBus {
         this.signals = [];
         this.activityCursors = new Map();
         this.signalCursors = new Map();
+        this.inBandNoticeCursors = new Map();
         try {
             await fs.unlink(this.persistPath);
         }
@@ -179,21 +204,76 @@ export class MessageBus {
     /**
      * Records a tool execution into the activity log. Called by the scoped tool
      * wrapper in `scopedTools.ts` — zero cost to the agent.
+     * Sanitizes and caps result summaries and target paths to eliminate payload bloat.
      */
     logActivity(entry) {
+        if (entry.resultSummary && entry.resultSummary.length > 120) {
+            entry.resultSummary = entry.resultSummary.substring(0, 120) + '...';
+        }
+        if (entry.target && entry.target.length > 300) {
+            entry.target = entry.target.substring(0, 300) + '...';
+        }
         this.activityLog.push(entry);
         this.persistToDiskAsync();
     }
     // ─── Formatting Helpers ──────────────────────────────────────────
+    /**
+     * Retrieves newly arrived urgent signals relevant to an agent's task scope
+     * that have NOT yet been delivered in-band to this agent, and advances the in-band cursor.
+     * This ensures an urgent notice is delivered ONCE on the next tool execution
+     * rather than being repetitively injected on every single subsequent tool turn.
+     */
+    getNewUrgentSignals(agentId, scope) {
+        const cursor = this.inBandNoticeCursors.get(agentId) ?? 0;
+        if (cursor >= this.signals.length)
+            return [];
+        const newSignals = this.signals.slice(cursor).filter((s) => s.fromAgent !== agentId);
+        const urgent = [];
+        const scopedFiles = [...(scope?.targetFiles || []), ...(scope?.readOnlyFiles || [])];
+        for (const signal of newSignals) {
+            // 1. Direct targeted request to this agent
+            if (signal.type === 'request' && (signal.toAgent === agentId || signal.toAgent === 'all')) {
+                urgent.push(signal);
+                continue;
+            }
+            // 2. Warnings from upstream dependencies or affecting scoped files
+            if (signal.type === 'warning') {
+                if (!scope?.dependsOn || scope.dependsOn.length === 0 || scope.dependsOn.includes(signal.fromAgent)) {
+                    urgent.push(signal);
+                    continue;
+                }
+                if (scopedFiles.length > 0) {
+                    const warn = signal;
+                    const touches = scopedFiles.some((f) => {
+                        const normF = f.replace(/\\/g, '/').toLowerCase();
+                        return (warn.content.toLowerCase().includes(normF) ||
+                            Boolean(warn.changedSignature && warn.changedSignature.toLowerCase().includes(normF)));
+                    });
+                    if (touches) {
+                        urgent.push(signal);
+                        continue;
+                    }
+                }
+            }
+            // 3. Upstream completion signals from direct dependencies
+            if (signal.type === 'completion' && scope?.dependsOn && scope.dependsOn.includes(signal.fromAgent)) {
+                urgent.push(signal);
+                continue;
+            }
+        }
+        this.inBandNoticeCursors.set(agentId, this.signals.length);
+        return urgent;
+    }
     /**
      * Peeks urgent signals (breaking warnings or direct requests) that are relevant
      * to a sub-agent's task scope without advancing its cursor. Used for in-band notice
-     * delivery in scopedTools.
+     * delivery or diagnostics.
      */
     peekUrgentSignals(agentId, scope) {
         const sigCursor = this.signalCursors.get(agentId) ?? 0;
         const unreadSignals = this.signals.slice(sigCursor).filter((s) => s.fromAgent !== agentId);
         const urgent = [];
+        const scopedFiles = [...(scope?.targetFiles || []), ...(scope?.readOnlyFiles || [])];
         for (const signal of unreadSignals) {
             // 1. Direct targeted request to this agent
             if (signal.type === 'request' && (signal.toAgent === agentId || signal.toAgent === 'all')) {
@@ -202,10 +282,22 @@ export class MessageBus {
             }
             // 2. Warnings from upstream dependencies or affecting target files
             if (signal.type === 'warning') {
-                if (!scope || !scope.dependsOn || scope.dependsOn.includes(signal.fromAgent)) {
+                if (!scope || !scope.dependsOn || scope.dependsOn.length === 0 || scope.dependsOn.includes(signal.fromAgent)) {
                     urgent.push(signal);
                     continue;
                 }
+                if (scopedFiles.length > 0) {
+                    const warn = signal;
+                    const touches = scopedFiles.some((f) => {
+                        const normF = f.replace(/\\/g, '/').toLowerCase();
+                        return (warn.content.toLowerCase().includes(normF) ||
+                            Boolean(warn.changedSignature && warn.changedSignature.toLowerCase().includes(normF)));
+                    });
+                    if (touches) {
+                        urgent.push(signal);
+                        continue;
+                    }
+                }
             }
             // 3. Upstream completion signals from direct dependencies
             if (signal.type === 'completion' && scope?.dependsOn && scope.dependsOn.includes(signal.fromAgent)) {
@@ -219,11 +311,53 @@ export class MessageBus {
      * Posts a semantic signal from an agent. These cost tokens (the agent calls
      * `post_message`) but carry intent that raw tool logs cannot express.
      *
-     * Enforces per-agent signal cap to prevent runaway agents from flooding the bus.
+     * Enforces signal deduplication, content sanitization, and per-agent caps
+     * to eliminate redundant message propagation and bus flooding.
      *
      * @returns `true` if the signal was accepted, `false` if the agent hit the cap.
      */
     postSignal(signal) {
+        if (signal.type === 'completion') {
+            if (signal.summary) {
+                signal.summary = signal.summary.trim();
+                if (signal.summary.length > 500) {
+                    signal.summary = signal.summary.substring(0, 500) + '... (truncated)';
+                }
+            }
+        }
+        else if (signal.content) {
+            signal.content = signal.content.trim();
+            if (signal.content.length > 500) {
+                signal.content = signal.content.substring(0, 500) + '... (truncated)';
+            }
+        }
+        // Deduplication check: suppress identical duplicate signals posted recently
+        const isDuplicate = this.signals.slice(-10).some((s) => {
+            if (s.type !== signal.type || s.fromAgent !== signal.fromAgent) {
+                return false;
+            }
+            if (s.type === 'completion' && signal.type === 'completion') {
+                return s.summary === signal.summary;
+            }
+            if (s.type === 'discovery' && signal.type === 'discovery') {
+                if (s.content !== signal.content)
+                    return false;
+                const sFiles = (s.affectedFiles || []).slice().sort().join(',');
+                const sigFiles = (signal.affectedFiles || []).slice().sort().join(',');
+                return sFiles === sigFiles;
+            }
+            if (s.type === 'request' && signal.type === 'request') {
+                return s.content === signal.content && s.toAgent === signal.toAgent;
+            }
+            if (s.type === 'warning' && signal.type === 'warning') {
+                return s.content === signal.content && s.changedSignature === signal.changedSignature;
+            }
+            return true;
+        });
+        if (isDuplicate) {
+            debugLog(`MessageBus: Suppressed duplicate ${signal.type} signal from ${signal.fromAgent}.`);
+            return true;
+        }
         const agentSignalCount = this.signals.filter((s) => s.fromAgent === signal.fromAgent).length;
         if (agentSignalCount >= MessageBus.MAX_SIGNALS_PER_AGENT) {
             debugLog(`MessageBus: Agent ${signal.fromAgent} hit signal cap (${MessageBus.MAX_SIGNALS_PER_AGENT}). ` +
@@ -238,13 +372,16 @@ export class MessageBus {
     /**
      * Performs an intelligent, scoped query against unread bus activity and signals.
      * Filters out read-only noise for peer sub-agents, enforces unicast delivery for targeted
-     * requests, and supports selective querying by file, agent, or signal type.
+     * requests, applies task-scope and dependency filtering to eliminate payload bloat,
+     * and supports selective querying by file, agent, or signal type.
      */
     queryBus(options) {
         const actCursor = this.activityCursors.get(options.agentId) ?? 0;
         const sigCursor = this.signalCursors.get(options.agentId) ?? 0;
         const onlyMutations = options.onlyMutations ?? true;
         const normalizedFile = options.file ? options.file.replace(/\\/g, '/').toLowerCase() : undefined;
+        const scopedFiles = [...(options.targetFiles || []), ...(options.readOnlyFiles || [])];
+        const hasScopeConstraint = !normalizedFile && (scopedFiles.length > 0 || (options.dependsOn && options.dependsOn.length > 0));
         const activities = this.activityLog.slice(actCursor).filter((e) => {
             // Exclude own actions
             if (e.agentId === options.agentId)
@@ -252,13 +389,21 @@ export class MessageBus {
             // Filter read-only tools if onlyMutations is enabled
             if (onlyMutations && !MUTATING_TOOLS.has(e.tool))
                 return false;
-            // Optional file filter
+            // Optional explicit file filter
             if (normalizedFile) {
                 const entryTarget = e.target.replace(/\\/g, '/').toLowerCase();
                 if (!entryTarget.includes(normalizedFile) && !normalizedFile.includes(entryTarget)) {
                     return false;
                 }
             }
+            else if (hasScopeConstraint) {
+                // Filter by task scope (target/readOnly files or upstream dependencies)
+                const matchesFile = scopedFiles.length > 0 && isPathMatchingScope(e.target, scopedFiles);
+                const matchesDep = Boolean(options.dependsOn && options.dependsOn.includes(e.agentId));
+                if (!matchesFile && !matchesDep) {
+                    return false;
+                }
+            }
             // Optional fromAgent filter
             if (options.fromAgent && e.agentId !== options.fromAgent)
                 return false;
@@ -312,6 +457,45 @@ export class MessageBus {
                         return false;
                 }
             }
+            else if (hasScopeConstraint) {
+                // Scoped signals filtering
+                if (s.type === 'request') {
+                    // Direct or broadcast requests are always relevant
+                }
+                else if (s.type === 'warning') {
+                    const isFromDep = Boolean(options.dependsOn && options.dependsOn.includes(s.fromAgent));
+                    const touchesScopedFile = scopedFiles.length > 0 &&
+                        scopedFiles.some((f) => {
+                            const normF = f.replace(/\\/g, '/').toLowerCase();
+                            return (s.content.toLowerCase().includes(normF) ||
+                                Boolean(s.changedSignature &&
+                                    s.changedSignature.toLowerCase().includes(normF)));
+                        });
+                    const isBroadcast = !options.dependsOn || options.dependsOn.length === 0;
+                    if (!isFromDep && !touchesScopedFile && !isBroadcast)
+                        return false;
+                }
+                else if (s.type === 'completion') {
+                    const isFromDep = Boolean(options.dependsOn && options.dependsOn.includes(s.fromAgent));
+                    const touchesScopedFile = scopedFiles.length > 0 &&
+                        scopedFiles.some((f) => {
+                            const normF = f.replace(/\\/g, '/').toLowerCase();
+                            return (s.summary.toLowerCase().includes(normF) ||
+                                Object.keys(s.exports || {}).some((k) => k.toLowerCase().includes(normF)));
+                        });
+                    if (!isFromDep && !touchesScopedFile)
+                        return false;
+                }
+                else if (s.type === 'discovery') {
+                    const disc = s;
+                    const isFromDep = Boolean(options.dependsOn && options.dependsOn.includes(s.fromAgent));
+                    const touchesScopedFile = scopedFiles.length > 0 &&
+                        ((disc.affectedFiles || []).some((f) => isPathMatchingScope(f, scopedFiles)) ||
+                            scopedFiles.some((f) => disc.content.toLowerCase().includes(f.toLowerCase())));
+                    if (!isFromDep && !touchesScopedFile)
+                        return false;
+                }
+            }
             return true;
         });
         // Advance cursors if requested (default: true)

package/dist/services/orchestration/orchestrator.js

@@ -74,6 +74,9 @@ export class Orchestrator {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 0.1,
             responseMimeType: 'application/json',
+            thinkingConfig: {
+                thinkingLevel: 'HIGH',
+            },
         });
     }
     /**
@@ -196,6 +199,7 @@ export class Orchestrator {
      */
     async decomposeTask(objective, contextInjection, signal) {
         return trackTask('PM Agent: Graph Generation', async () => {
+            debugLog(`Orchestrator: PM Agent decomposing task [Model: ${this.pmChat.getModel()}, Thinking: ${this.pmChat.getThinkingLevel() || 'HIGH'}]`);
             const prompt = `Objective:\n${objective}\n\nContext:\n${contextInjection}`;
             let result = await this.pmChat.sendMessage(prompt, undefined, signal);
             if (signal.aborted)

package/dist/services/orchestration/scopedTools.js

@@ -141,6 +141,7 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
                 type: args.type,
                 onlyMutations: true,
                 targetFiles: taskScope?.targetFiles,
+                readOnlyFiles: taskScope?.readOnlyFiles,
                 dependsOn: taskScope?.dependsOn,
             });
             if (unread.activities.length === 0 && unread.signals.length === 0) {
@@ -235,7 +236,14 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
                     result._orchestrationWarning = `NOTICE: Another agent modified this file while you were waiting. Diff context: ${diffContext}`;
                 }
                 // In-band relevance-gated urgent signals (warnings, targeted requests, or upstream completions)
-                if (typeof result === 'object' && result !== null && typeof bus?.peekUrgentSignals === 'function') {
+                // Uses getNewUrgentSignals so notices are delivered once when they occur, avoiding redundant injection on every turn
+                if (typeof result === 'object' && result !== null && typeof bus?.getNewUrgentSignals === 'function') {
+                    const urgentSignals = bus.getNewUrgentSignals(agentId, taskScope);
+                    if (urgentSignals && urgentSignals.length > 0) {
+                        result._orchestrationNotice = MessageBus.formatSignals(urgentSignals);
+                    }
+                }
+                else if (typeof result === 'object' && result !== null && typeof bus?.peekUrgentSignals === 'function') {
                     const urgentSignals = bus.peekUrgentSignals(agentId, taskScope);
                     if (urgentSignals && urgentSignals.length > 0) {
                         result._orchestrationNotice = MessageBus.formatSignals(urgentSignals);
@@ -253,7 +261,13 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
         }
         else {
             // For cache hit, also check urgent signals from bus if needed
-            if (typeof result === 'object' && result !== null && typeof bus?.peekUrgentSignals === 'function') {
+            if (typeof result === 'object' && result !== null && typeof bus?.getNewUrgentSignals === 'function') {
+                const urgentSignals = bus.getNewUrgentSignals(agentId, taskScope);
+                if (urgentSignals && urgentSignals.length > 0) {
+                    result._orchestrationNotice = MessageBus.formatSignals(urgentSignals);
+                }
+            }
+            else if (typeof result === 'object' && result !== null && typeof bus?.peekUrgentSignals === 'function') {
                 const urgentSignals = bus.peekUrgentSignals(agentId, taskScope);
                 if (urgentSignals && urgentSignals.length > 0) {
                     result._orchestrationNotice = MessageBus.formatSignals(urgentSignals);

package/dist/services/orchestration/subAgent.js

@@ -4,7 +4,7 @@
  * Implements the lifecycle, health monitoring, and tool-loop execution for a single
  * parallelized sub-agent.
  */
-import { ProxyChatSession, getGlobalActiveModel } from '../ai.js';
+import { ProxyChatSession, getGlobalActiveModel, getModelThinkingLevel } from '../ai.js';
 import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
 import { ReadCache } from './readCache.js';
 import { executeScopedTool, getScopedToolDeclarations } from './scopedTools.js';
@@ -165,12 +165,16 @@ export class SubAgentRunner {
         let model = getGlobalActiveModel();
         if (model === GEMINI_MODELS.AUTO)
             model = GEMINI_MODELS.FLASH;
-        // Sub-agents default to flash-3.7 for better reasoning capabilities
+        const thinkingLevel = getModelThinkingLevel(model);
+        // Sub-agents default to flash-3.7 for better reasoning capabilities with dynamic/model-configured thinking level
         this.chat = new ProxyChatSession(model, this.buildSystemInstruction(), [{ functionDeclarations: getScopedToolDeclarations() }], {
             maxOutputTokens: MAX_OUTPUT_TOKENS,
             temperature: 0.3, // Lower temperature for more focused execution
             topP: 0.95,
             topK: 40,
+            thinkingConfig: {
+                thinkingLevel,
+            },
         }, {
             functionCallingConfig: {
                 mode: 'ANY',
@@ -204,6 +208,13 @@ export class SubAgentRunner {
                         const args = matchingCall?.args;
                         if (funcResp.response && typeof funcResp.response === 'object') {
                             const respObj = funcResp.response;
+                            // Clean up historical orchestration notices and warnings to eliminate payload bloat in history
+                            if (respObj._orchestrationNotice) {
+                                delete respObj._orchestrationNotice;
+                            }
+                            if (respObj._orchestrationWarning) {
+                                delete respObj._orchestrationWarning;
+                            }
                             if (toolName === 'read_messages') {
                                 funcResp.response = { output: '[read_messages - peer activity reviewed]' };
                             }
@@ -248,6 +259,7 @@ export class SubAgentRunner {
                 }
             }, 5000);
             try {
+                debugLog(`SubAgent [${this.taskId}]: Starting execution [Model: ${this.chat.getModel()}, Thinking: ${this.chat.getThinkingLevel() || 'DEFAULT'}]`);
                 // Send initial prompt
                 const prompt = `Begin execution for task: ${this.taskId}\nObjective: ${this.intent}\n\nFollow the 3-step workflow: 1) inspect file -> 2) modify code -> 3) respond with text summary. Do not repeat search tools once results are returned.`;
                 let turnResult = await this.chat.sendMessage(prompt, undefined, signal);

package/dist/services/proxyClient.d.ts

@@ -1,4 +1,40 @@
 import type { Content, Tool, ToolConfig, FunctionCall } from '@google/generative-ai';
+import { type ThinkingConfig } from '../utils/config.js';
+/**
+ * ============================================================================
+ *                               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.
+ * - Dynamic ThinkingConfig / ThinkingLevel reasoning configuration pass-through.
+ * ============================================================================
+ */
+/**
+ * Generation configuration passed to Proxy and BYOK endpoints.
+ */
+export interface ProxyGenerationConfig {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxOutputTokens?: number;
+    responseMimeType?: string;
+    responseSchema?: any;
+    thinkingConfig?: ThinkingConfig;
+    [key: string]: any;
+}
+/**
+ * Normalizes generation configuration across Proxy and BYOK endpoints.
+ * Strips 'MINIMAL' thinking level since Gemini 3.x models use default thinking
+ * behavior when no explicit thinking level is provided, preventing 400 Bad Request
+ * rejections from Google's Generative Language API.
+ */
+export declare function normalizeGenerationConfig(config?: ProxyGenerationConfig): ProxyGenerationConfig | undefined;
 /**
  * Metadata containing real-time proxy token and credit usage diagnostics.
  */
@@ -62,7 +98,7 @@ export declare class ProxyClient {
      * @returns A structured promise resolving to gathered text, function calls, and metadata.
      * @throws {Error} If authentication fails (401), credits are insufficient (402), or network/proxy errors occur.
      */
-    generateFunctionCallViaProxy(idToken: string, modelName: string, contents: Content[], tools?: Tool[], toolConfig?: ToolConfig, systemInstruction?: string | Content, generationConfig?: any, streamCallbacks?: {
+    generateFunctionCallViaProxy(idToken: string, modelName: string, contents: Content[], tools?: Tool[], toolConfig?: ToolConfig, systemInstruction?: string | Content, generationConfig?: ProxyGenerationConfig | any, streamCallbacks?: {
         onChunk: (chunk: string) => void;
     }, abortSignal?: AbortSignal): Promise<{
         functionCall: FunctionCall | null;
@@ -76,7 +112,7 @@ export declare class ProxyClient {
      * Generates text, thoughts, or function calls directly via Google's official Gemini REST API (BYOK mode).
      * Ensures identical return structure and standard role mapping parity with proxy mode.
      */
-    generateViaBYOK(apiKey: string, modelName: string, contents: Content[], tools?: Tool[], toolConfig?: ToolConfig, systemInstruction?: string | Content, generationConfig?: any, streamCallbacks?: {
+    generateViaBYOK(apiKey: string, modelName: string, contents: Content[], tools?: Tool[], toolConfig?: ToolConfig, systemInstruction?: string | Content, generationConfig?: ProxyGenerationConfig | any, streamCallbacks?: {
         onChunk: (chunk: string) => void;
     }, abortSignal?: AbortSignal): Promise<{
         functionCall: FunctionCall | null;