minovative-mind-cli 1.5.1 → 2.1.0

package/dist/services/orchestration/investigationAgent.js

@@ -0,0 +1,362 @@
+/**
+ * @fileoverview Read-Only Investigation Sub-Agent Runner.
+ *
+ * Implements the lifecycle, health monitoring, and tool-loop execution for a single
+ * parallelized investigation agent. Unlike execution sub-agents in `subAgent.ts`,
+ * investigation agents are **strictly read-only** — they have no filesystem write
+ * tools, no file locks, and no message bus. They share a `ReadCache` to avoid
+ * redundant file reads across sibling agents.
+ *
+ * Each investigation agent is scoped to a set of domains (e.g., "Frontend auth
+ * components" + "Auth UI styling") and produces an `InvestigationResult` containing
+ * the files it found and a summary of its findings.
+ */
+import { ProxyChatSession, getContextToolDeclarations, getGlobalActiveModel } from '../ai.js';
+import { GEMINI_MODELS, MAX_OUTPUT_TOKENS } from '../../utils/config.js';
+import { CONTEXT_SYSTEM_INSTRUCTION } from '../../utils/systemPrompts.js';
+import { debugLog } from '../../utils/logger.js';
+import { listDirectory, grepSearch, readFile, traceDependencies, findRecentChanges } from '../agent-tools.js';
+import { runEphemeralScript } from '../../utils/analysisRunner.js';
+// ─── Investigation Agent Runner ──────────────────────────────────────
+/**
+ * Executes a read-only investigation within a scoped set of domains.
+ *
+ * Key differences from `SubAgentRunner` (execution):
+ * - **No write tools**: Cannot modify, create, or delete files
+ * - **No file locks**: Read-only access means zero contention
+ * - **No message bus**: Agents don't need to coordinate — they work independently
+ * - **Shared ReadCache**: Checks cache before hitting disk to avoid redundant reads
+ * - **Shorter stall timeout**: 30s vs 60s — investigation should be faster
+ */
+export class InvestigationAgentRunner {
+    agentLabel;
+    domains;
+    workspaceRoot;
+    readCache;
+    projectTree;
+    projectType;
+    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;
+    constructor(agentLabel, domains, workspaceRoot, readCache, projectTree, projectType) {
+        this.agentLabel = agentLabel;
+        this.domains = domains;
+        this.workspaceRoot = workspaceRoot;
+        this.readCache = readCache;
+        this.projectTree = projectTree;
+        this.projectType = projectType;
+        let model = getGlobalActiveModel();
+        if (model === GEMINI_MODELS.AUTO)
+            model = GEMINI_MODELS.FLASH_3_5;
+        this.chat = new ProxyChatSession(model, this.buildSystemInstruction(), getContextToolDeclarations(), {
+            maxOutputTokens: MAX_OUTPUT_TOKENS,
+            temperature: 1,
+            topP: 0.95,
+            topK: 40,
+        });
+    }
+    /**
+     * Builds a domain-scoped system instruction. Extends the base Context Agent
+     * instruction with a domain focus preamble.
+     */
+    buildSystemInstruction() {
+        const domainList = this.domains.map((d) => `  - ${d}`).join('\n');
+        return (CONTEXT_SYSTEM_INSTRUCTION +
+            `\n\n<investigation_scope>` +
+            `\nYou are investigation agent "${this.agentLabel}", part of a parallel investigation team.` +
+            `\nYour assigned investigation domains:\n${domainList}` +
+            `\n\nFocus your investigation ONLY on files and code related to your assigned domains.` +
+            `\nOther agents are simultaneously investigating other domains — do not duplicate their work.` +
+            `\nBe thorough within your scope, but do not stray outside it.` +
+            `\n</investigation_scope>`);
+    }
+    /**
+     * Updates the heartbeat timestamp. Prevents the stall detector from
+     * killing the agent during long-running tool calls.
+     */
+    pingHeartbeat = () => {
+        this.lastHeartbeat = Date.now();
+    };
+    /**
+     * Executes the investigation agent's tool loop.
+     *
+     * @param userRequest - The original user prompt.
+     * @param chatHistory - Recent conversation history for context.
+     * @param abortSignal - Signal to cancel execution.
+     * @param onProgress - Callback for spinner/terminal updates.
+     * @returns The investigation result with discovered files and summary.
+     */
+    async execute(userRequest, chatHistory, abortSignal, onProgress) {
+        debugLog(`InvestigationAgent [${this.agentLabel}]: Starting execution for domains: ${this.domains.join(', ')}`);
+        this.lastHeartbeat = Date.now();
+        const relevantFiles = new Map();
+        let summary = 'No relevant context found.';
+        let webSearchSummary = '';
+        let success = false;
+        let crashed = false;
+        // Health Monitor
+        const healthMonitor = setInterval(() => {
+            if (Date.now() - this.lastHeartbeat > InvestigationAgentRunner.STALL_TIMEOUT_MS) {
+                debugLog(`InvestigationAgent [${this.agentLabel}]: STALL DETECTED. No heartbeat for ${InvestigationAgentRunner.STALL_TIMEOUT_MS}ms.`);
+                crashed = true;
+            }
+        }, 5000);
+        try {
+            // Build the initial investigation prompt
+            let currentMessage = `User Request: "${userRequest}"\n\nProject Type: ${this.projectType}\n\nProject Structure:\n${this.projectTree}`;
+            if (chatHistory) {
+                currentMessage = `Previous Conversation Context:\n${chatHistory}\n\n` + currentMessage;
+            }
+            currentMessage += `\n\nStart investigating to find relevant files within your assigned domains.`;
+            let isFinished = false;
+            // Tool loop — mirrors the existing context agent loop in contextAgent.ts
+            while (!crashed && !abortSignal.aborted && !isFinished) {
+                this.pingHeartbeat();
+                let result;
+                try {
+                    result = await this.chat.sendMessage(currentMessage, undefined, abortSignal, () => this.pingHeartbeat());
+                }
+                catch (e) {
+                    if (e.name === 'AbortError' || e.message?.includes('abort'))
+                        break;
+                    throw e;
+                }
+                this.updateUsage(result);
+                const functionCalls = result.response.functionCalls();
+                if (!functionCalls || functionCalls.length === 0) {
+                    // Model returned text — take as summary
+                    summary = result.response.text();
+                    success = true;
+                    break;
+                }
+                const functionResponses = [];
+                for (const call of functionCalls) {
+                    if (crashed || abortSignal.aborted)
+                        break;
+                    this.pingHeartbeat();
+                    const args = call.args;
+                    const logPrefix = `[${this.agentLabel}]`;
+                    if (call.name === 'finish_investigation') {
+                        summary = args.summary || '';
+                        const filesToRead = args.relevantFiles || [];
+                        if (onProgress)
+                            onProgress(`${logPrefix} Finished investigation (${filesToRead.length} files)`);
+                        debugLog(`InvestigationAgent ${logPrefix}: Finished. Selected files: ${JSON.stringify(filesToRead)}`);
+                        for (const filePath of filesToRead) {
+                            if (!relevantFiles.has(filePath)) {
+                                // Check shared cache first
+                                if (this.readCache.has(filePath)) {
+                                    relevantFiles.set(filePath, this.readCache.get(filePath));
+                                }
+                                else {
+                                    const readResult = await readFile(this.workspaceRoot, filePath);
+                                    if (!readResult.error) {
+                                        const contentObj = { text: readResult.output, inlineData: readResult.inlineData };
+                                        relevantFiles.set(filePath, contentObj);
+                                        this.readCache.set(filePath, contentObj);
+                                    }
+                                }
+                            }
+                        }
+                        isFinished = true;
+                        success = true;
+                        functionResponses.push({
+                            functionResponse: { name: call.name, response: { output: 'Investigation finished.' } },
+                        });
+                        break;
+                    }
+                    else if (call.name === 'select_files') {
+                        const filesToRead = args.files || [];
+                        if (onProgress)
+                            onProgress(`${logPrefix} Selected ${filesToRead.length} files`);
+                        let output = '';
+                        for (const filePath of filesToRead) {
+                            // Check cache first
+                            if (this.readCache.has(filePath)) {
+                                const cached = this.readCache.get(filePath);
+                                relevantFiles.set(filePath, cached);
+                                output += `\n--- File: ${filePath} ---\n${cached.text}\n`;
+                            }
+                            else {
+                                const readResult = await readFile(this.workspaceRoot, filePath);
+                                if (!readResult.error) {
+                                    const contentObj = { text: readResult.output, inlineData: readResult.inlineData };
+                                    relevantFiles.set(filePath, contentObj);
+                                    this.readCache.set(filePath, contentObj);
+                                    output += `\n--- File: ${filePath} ---\n${readResult.output}\n`;
+                                }
+                                else {
+                                    output += `\n--- File: ${filePath} ---\nError: ${readResult.error}\n`;
+                                }
+                            }
+                        }
+                        functionResponses.push({
+                            functionResponse: { name: call.name, response: { output: output || 'No files read.' } },
+                        });
+                    }
+                    else if (call.name === 'list_directory') {
+                        if (onProgress)
+                            onProgress(`${logPrefix} Listing: ${args.dirPath}`);
+                        const listRes = await listDirectory(this.workspaceRoot, args.dirPath, args.maxDepth || 1);
+                        functionResponses.push({
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: listRes.output, ...(listRes.error ? { error: listRes.error } : {}) },
+                            },
+                        });
+                    }
+                    else if (call.name === 'search_codebase') {
+                        if (onProgress)
+                            onProgress(`${logPrefix} Searching: "${args.pattern}"`);
+                        const grepRes = await grepSearch(this.workspaceRoot, args.pattern, args.fileGlob);
+                        functionResponses.push({
+                            functionResponse: { name: call.name, response: { output: grepRes.error ? grepRes.error : grepRes.output } },
+                        });
+                    }
+                    else if (call.name === 'read_file') {
+                        const filePath = args.filePath;
+                        if (onProgress)
+                            onProgress(`${logPrefix} Reading: ${filePath}`);
+                        // Check cache for full-file reads (no line range or target elements)
+                        if (!args.startLine && !args.endLine && !args.targetElements && this.readCache.has(filePath)) {
+                            const cached = this.readCache.get(filePath);
+                            relevantFiles.set(filePath, cached);
+                            functionResponses.push({ functionResponse: { name: call.name, response: { output: cached.text } } });
+                        }
+                        else {
+                            const readRes = await readFile(this.workspaceRoot, filePath, args.startLine, args.endLine, args.targetElements);
+                            if (!readRes.error) {
+                                const contentObj = { text: readRes.output, inlineData: readRes.inlineData };
+                                relevantFiles.set(filePath, contentObj);
+                                // Only cache full-file reads (partial reads shouldn't overwrite full content)
+                                if (!args.startLine && !args.endLine && !args.targetElements) {
+                                    this.readCache.set(filePath, contentObj);
+                                }
+                            }
+                            functionResponses.push({
+                                functionResponse: { name: call.name, response: { output: readRes.error ? readRes.error : readRes.output } },
+                            });
+                        }
+                    }
+                    else if (call.name === 'semantic_search') {
+                        const query = args.query;
+                        const topK = args.topK || 5;
+                        if (onProgress)
+                            onProgress(`${logPrefix} Semantic search: "${query}"`);
+                        let output = '';
+                        try {
+                            const { getEmbeddingIndex } = await import('../embeddingIndex.js');
+                            const index = getEmbeddingIndex();
+                            if (!index.isReady()) {
+                                const loaded = await index.load(this.workspaceRoot);
+                                if (!loaded) {
+                                    output = 'Semantic search index not available. Use search_codebase instead.';
+                                }
+                            }
+                            if (index.isReady()) {
+                                const results = await index.search(query, topK);
+                                output =
+                                    results.length === 0
+                                        ? 'No semantically similar code found.'
+                                        : results
+                                            .map((r) => `[Score: ${r.score.toFixed(3)}] ${r.filePath}:${r.startLine}-${r.endLine}\n${r.preview}`)
+                                            .join('\n---\n');
+                            }
+                        }
+                        catch (e) {
+                            output = `Semantic search failed: ${e.message}`;
+                        }
+                        functionResponses.push({ functionResponse: { name: call.name, response: { output } } });
+                    }
+                    else if (call.name === 'perform_web_search') {
+                        if (onProgress)
+                            onProgress(`${logPrefix} Web search: "${args.query}"`);
+                        try {
+                            const { createWebSearchAgentSession } = await import('../ai.js');
+                            const webSession = createWebSearchAgentSession();
+                            const webResult = await webSession.sendMessage(`Please search the web for the following query and summarize your findings:\n"${args.query}"`, undefined, abortSignal, () => this.pingHeartbeat());
+                            const searchSummary = webResult.response.text()?.trim() || 'No relevant information found.';
+                            webSearchSummary += `\nQuery: ${args.query}\nFindings:\n${searchSummary}\n`;
+                            functionResponses.push({ functionResponse: { name: call.name, response: { output: searchSummary } } });
+                        }
+                        catch (e) {
+                            functionResponses.push({
+                                functionResponse: { name: call.name, response: { error: e.message || 'Failed to search the web' } },
+                            });
+                        }
+                    }
+                    else if (call.name === 'find_dependencies') {
+                        if (onProgress)
+                            onProgress(`${logPrefix} Tracing dependencies: ${args.filePath}`);
+                        const depResult = await traceDependencies(this.workspaceRoot, args.filePath, args.direction, args.maxDepth);
+                        functionResponses.push({
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: depResult.error ? depResult.error : depResult.output },
+                            },
+                        });
+                    }
+                    else if (call.name === 'find_recent_changes') {
+                        if (onProgress)
+                            onProgress(`${logPrefix} Finding recent changes`);
+                        const recentRes = await findRecentChanges(this.workspaceRoot, args.dirPath, args.minutes, args.maxDepth);
+                        functionResponses.push({
+                            functionResponse: {
+                                name: call.name,
+                                response: { output: recentRes.error ? recentRes.error : recentRes.output },
+                            },
+                        });
+                    }
+                    else if (call.name === 'run_analysis_script') {
+                        if (onProgress)
+                            onProgress(`${logPrefix} Running analysis script`);
+                        const analysisResult = await runEphemeralScript(this.workspaceRoot, args.language, args.code, {
+                            abortSignal,
+                        });
+                        const output = analysisResult.exitCode === 0
+                            ? analysisResult.stdout || '(script produced no output)'
+                            : `Script failed (exit ${analysisResult.exitCode}):\n${analysisResult.stderr}`;
+                        functionResponses.push({ functionResponse: { name: call.name, response: { output } } });
+                    }
+                }
+                if (crashed || abortSignal.aborted || isFinished)
+                    break;
+                // Feed tool results back to the model
+                currentMessage = functionResponses;
+            }
+        }
+        catch (err) {
+            debugLog(`InvestigationAgent [${this.agentLabel}]: Execution error: ${err.message}`);
+            crashed = true;
+            summary = `Investigation agent crashed: ${err.message}`;
+        }
+        finally {
+            clearInterval(healthMonitor);
+        }
+        if (abortSignal.aborted) {
+            crashed = true;
+            summary = 'Investigation aborted by user.';
+        }
+        debugLog(`InvestigationAgent [${this.agentLabel}]: Finished. Success=${success && !crashed}, Files=${relevantFiles.size}, Tokens=${this.creditsUsed}`);
+        return {
+            domains: this.domains,
+            agentLabel: this.agentLabel,
+            relevantFiles,
+            summary,
+            webSearchSummary,
+            creditsUsed: this.creditsUsed,
+            success: success && !crashed,
+        };
+    }
+    /**
+     * Accumulates token usage from the chat session.
+     */
+    updateUsage(result) {
+        const usage = result.response.usageMetadata?.();
+        if (usage && usage.totalTokenCount) {
+            this.creditsUsed += usage.totalTokenCount;
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Investigation Orchestrator (Reducer) for Parallel Context Gathering.
+ *
+ * Coordinates parallel investigation agents and merges their results into a single
+ * `ContextAgentResult` — the exact same type the existing single Context Agent
+ * produces. This makes parallel investigation completely transparent to the
+ * downstream execution phase (compression, context injection, model selection).
+ *
+ * Lifecycle:
+ * 1. Creates a shared `ReadCache` instance
+ * 2. Spawns N `InvestigationAgentRunner` instances (one per agent assignment)
+ * 3. Runs all agents in parallel via `Promise.all()`
+ * 4. Reducer merges all `InvestigationResult` objects
+ * 5. Runs auto-trace reverse dependencies (same as single-agent path)
+ * 6. Returns merged `ContextAgentResult`
+ *
+ * Error handling: If any agent crashes, its results are discarded but the
+ * orchestrator continues with surviving agents. If ALL crash, returns null
+ * so the caller can fall back to the single Context Agent.
+ */
+import type { ContextAgentResult } from '../contextAgent.js';
+import type { AgentAssignment } from '../investigationComplexity.js';
+export declare class InvestigationOrchestrator {
+    /**
+     * Runs parallel investigation across multiple domain-scoped agents,
+     * merges their results, and returns a unified `ContextAgentResult`.
+     *
+     * @param userRequest - The original user prompt.
+     * @param agentAssignments - PM-generated agent assignments with domains.
+     * @param workspaceRoot - Absolute path to the workspace root.
+     * @param projectTree - Pre-generated project tree string.
+     * @param projectType - Detected project type (e.g., "Node.js / TypeScript").
+     * @param chatHistory - Recent conversation history.
+     * @param abortSignal - Signal to cancel all agents.
+     * @param onProgress - Callback for spinner/terminal updates.
+     * @returns Merged context result, or null if all agents failed.
+     */
+    runParallelInvestigation(userRequest: string, agentAssignments: AgentAssignment[], workspaceRoot: string, projectTree: string, projectType: string, chatHistory: string, abortSignal: AbortSignal, onProgress?: (msg: string) => void): Promise<ContextAgentResult | null>;
+    /**
+     * Merges multiple `InvestigationResult` objects into a single `ContextAgentResult`.
+     *
+     * - Unions all `relevantFiles` maps (Map.set handles dedup naturally)
+     * - Concatenates summaries with domain headers
+     * - Concatenates web search summaries
+     * - Caps total files at MAX_TOTAL_FILES
+     */
+    private reduceResults;
+    /**
+     * Auto-traces reverse dependencies for all discovered files.
+     * Identical logic to the single-agent path in contextAgent.ts (lines 335-374).
+     */
+    private autoTraceReverseDeps;
+}

package/dist/services/orchestration/investigationOrchestrator.js

@@ -0,0 +1,180 @@
+/**
+ * @fileoverview Investigation Orchestrator (Reducer) for Parallel Context Gathering.
+ *
+ * Coordinates parallel investigation agents and merges their results into a single
+ * `ContextAgentResult` — the exact same type the existing single Context Agent
+ * produces. This makes parallel investigation completely transparent to the
+ * downstream execution phase (compression, context injection, model selection).
+ *
+ * Lifecycle:
+ * 1. Creates a shared `ReadCache` instance
+ * 2. Spawns N `InvestigationAgentRunner` instances (one per agent assignment)
+ * 3. Runs all agents in parallel via `Promise.all()`
+ * 4. Reducer merges all `InvestigationResult` objects
+ * 5. Runs auto-trace reverse dependencies (same as single-agent path)
+ * 6. Returns merged `ContextAgentResult`
+ *
+ * Error handling: If any agent crashes, its results are discarded but the
+ * orchestrator continues with surviving agents. If ALL crash, returns null
+ * so the caller can fall back to the single Context Agent.
+ */
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { ReadCache } from './readCache.js';
+import { InvestigationAgentRunner } from './investigationAgent.js';
+import { readFile } from '../agent-tools.js';
+import { buildDependencyGraph } from '../../utils/dependencyTracer.js';
+import { debugLog } from '../../utils/logger.js';
+// ─── Constants ───────────────────────────────────────────────────────
+/** Maximum total relevant files across all agents after merge. */
+const MAX_TOTAL_FILES = 15;
+// ─── Investigation Orchestrator ──────────────────────────────────────
+export class InvestigationOrchestrator {
+    /**
+     * Runs parallel investigation across multiple domain-scoped agents,
+     * merges their results, and returns a unified `ContextAgentResult`.
+     *
+     * @param userRequest - The original user prompt.
+     * @param agentAssignments - PM-generated agent assignments with domains.
+     * @param workspaceRoot - Absolute path to the workspace root.
+     * @param projectTree - Pre-generated project tree string.
+     * @param projectType - Detected project type (e.g., "Node.js / TypeScript").
+     * @param chatHistory - Recent conversation history.
+     * @param abortSignal - Signal to cancel all agents.
+     * @param onProgress - Callback for spinner/terminal updates.
+     * @returns Merged context result, or null if all agents failed.
+     */
+    async runParallelInvestigation(userRequest, agentAssignments, workspaceRoot, projectTree, projectType, chatHistory, abortSignal, onProgress) {
+        const agentCount = agentAssignments.length;
+        p.log.info(pc.cyan(`🔍 Parallel Investigation (${agentCount} agents)`) +
+            '\n' +
+            agentAssignments
+                .map((a, i) => pc.dim(`  Agent ${i + 1}/${agentCount}: ${a.agentLabel} → [${a.domains.join(', ')}]`))
+                .join('\n'));
+        // 1. Create shared read cache
+        const readCache = new ReadCache();
+        // 2. Spawn investigation agents
+        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();
+        const results = await Promise.all(agents.map((agent, i) => agent.execute(userRequest, chatHistory, abortSignal, (msg) => {
+            if (onProgress) {
+                onProgress(`Agent ${i + 1}/${agentCount}: ${msg}`);
+            }
+        })));
+        const duration = ((Date.now() - startTime) / 1000).toFixed(1);
+        // 4. Filter out crashed agents
+        const successfulResults = results.filter((r) => r.success);
+        const failedResults = results.filter((r) => !r.success);
+        if (failedResults.length > 0) {
+            for (const failed of failedResults) {
+                debugLog(`InvestigationOrchestrator: Agent "${failed.agentLabel}" failed: ${failed.summary}`);
+            }
+            if (onProgress) {
+                onProgress(`${failedResults.length} agent(s) failed — using results from ${successfulResults.length} surviving agent(s)`);
+            }
+        }
+        // If ALL agents crashed, signal the caller to fall back
+        if (successfulResults.length === 0) {
+            p.log.warn(pc.yellow('All investigation agents failed. Falling back to single Context Agent.'));
+            return null;
+        }
+        // 5. Reduce: Merge results
+        const mergedResult = this.reduceResults(successfulResults, projectTree, projectType);
+        // 6. Auto-trace reverse dependencies (same logic as contextAgent.ts)
+        const allSelectedFiles = Array.from(mergedResult.relevantFiles.keys());
+        await this.autoTraceReverseDeps(workspaceRoot, allSelectedFiles, mergedResult.relevantFiles, onProgress);
+        // 7. Log summary
+        const cacheStats = readCache.getStats();
+        const totalTokens = results.reduce((sum, r) => sum + r.creditsUsed, 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()}`);
+        return mergedResult;
+    }
+    /**
+     * Merges multiple `InvestigationResult` objects into a single `ContextAgentResult`.
+     *
+     * - Unions all `relevantFiles` maps (Map.set handles dedup naturally)
+     * - Concatenates summaries with domain headers
+     * - Concatenates web search summaries
+     * - Caps total files at MAX_TOTAL_FILES
+     */
+    reduceResults(results, projectTree, projectType) {
+        const mergedFiles = new Map();
+        const summaryParts = [];
+        let webSearchSummary = '';
+        for (const result of results) {
+            // Merge files
+            for (const [filePath, content] of result.relevantFiles) {
+                if (mergedFiles.size >= MAX_TOTAL_FILES)
+                    break;
+                if (!mergedFiles.has(filePath)) {
+                    mergedFiles.set(filePath, content);
+                }
+            }
+            // Merge summaries with domain headers
+            const domainHeader = `[${result.agentLabel}: ${result.domains.join(', ')}]`;
+            summaryParts.push(`${domainHeader}\n${result.summary}`);
+            // Merge web search results
+            if (result.webSearchSummary) {
+                webSearchSummary += result.webSearchSummary;
+            }
+        }
+        const combinedSummary = summaryParts.join('\n\n');
+        debugLog(`InvestigationOrchestrator Reducer: Merged ${results.length} results → ` +
+            `${mergedFiles.size} files, summary ${combinedSummary.length} chars`);
+        return {
+            projectTree,
+            projectType,
+            relevantFiles: mergedFiles,
+            summary: combinedSummary,
+            webSearchSummary: webSearchSummary || undefined,
+        };
+    }
+    /**
+     * Auto-traces reverse dependencies for all discovered files.
+     * Identical logic to the single-agent path in contextAgent.ts (lines 335-374).
+     */
+    async autoTraceReverseDeps(workspaceRoot, selectedFiles, relevantFiles, onProgress) {
+        try {
+            const graph = await buildDependencyGraph(workspaceRoot);
+            const autoDiscovered = new Set();
+            for (const filePath of selectedFiles) {
+                const reverseDeps = graph.getImportedBy(filePath);
+                for (const dep of reverseDeps) {
+                    if (!selectedFiles.includes(dep) && !autoDiscovered.has(dep)) {
+                        autoDiscovered.add(dep);
+                    }
+                }
+            }
+            // Merge auto-discovered dependents, respecting the file cap
+            const remaining = MAX_TOTAL_FILES - relevantFiles.size;
+            let added = 0;
+            for (const dep of autoDiscovered) {
+                if (added >= remaining)
+                    break;
+                if (!relevantFiles.has(dep)) {
+                    const readResult = await readFile(workspaceRoot, dep);
+                    if (!readResult.error) {
+                        relevantFiles.set(dep, { text: readResult.output, inlineData: readResult.inlineData });
+                        added++;
+                    }
+                }
+            }
+            if (added > 0) {
+                const depMsg = `Auto-traced ${added} reverse dependent(s) into context`;
+                if (onProgress)
+                    onProgress(depMsg);
+                else
+                    debugLog(`InvestigationOrchestrator: ${depMsg}`);
+            }
+        }
+        catch {
+            // Dependency tracing is best-effort — don't block investigation
+        }
+    }
+}