minovative-mind-cli 2.9.1 → 2.11.0

package/dist/services/orchestration/investigationOrchestrator.js

@@ -64,6 +64,8 @@ export class InvestigationOrchestrator {
         const MAX_CONCURRENT = 2;
         const results = [];
         for (let i = 0; i < agents.length; i += MAX_CONCURRENT) {
+            if (abortSignal.aborted)
+                break;
             const chunk = agents.slice(i, i + MAX_CONCURRENT);
             const chunkAssignments = agentAssignments.slice(i, i + MAX_CONCURRENT);
             const chunkPromises = chunk.map((agent, chunkIndex) => {
@@ -107,8 +109,10 @@ export class InvestigationOrchestrator {
         // 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);
+        if (!abortSignal.aborted) {
+            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);
@@ -121,8 +125,17 @@ export class InvestigationOrchestrator {
             `Cache hits: ${cacheStats.hitCount}\n` +
             `  Duration: ${duration}s | Tokens: ${totalTokens.toLocaleString()} ${pc.dim(`(Input: ${totalInputTokens.toLocaleString()}, Output: ${totalOutputTokens.toLocaleString()})`)}`);
         if (mergedResult && mergedResult.relevantFiles.size > 0) {
-            const { saveInvestigation } = await import('./investigationCache.js');
-            await saveInvestigation(workspaceRoot, userRequest, Array.from(mergedResult.relevantFiles.keys()), mergedResult.summary);
+            try {
+                const { saveInvestigation } = await import('./investigationCache.js');
+                const allDomains = Array.from(new Set(agentAssignments.flatMap((a) => a.domains)));
+                await saveInvestigation(workspaceRoot, userRequest, Array.from(mergedResult.relevantFiles.keys()), mergedResult.summary, { topics: allDomains }, abortSignal);
+            }
+            catch (err) {
+                if (err?.name === 'AbortError' || abortSignal?.aborted) {
+                    throw err;
+                }
+                debugLog(`Failed to save parallel investigation to cache: ${err?.message || err}`);
+            }
         }
         return mergedResult;
     }

package/dist/services/orchestration/orchestrator.js

@@ -27,12 +27,13 @@ You must output ONLY raw JSON representing the TaskGraph object. Do not wrap in
 </identity>
 
 <requirements>
-- Break the work down logically based on file isolation and dependency chains.
-- Tasks that don't depend on each other will run in parallel.
+- Break the work down logically based on file isolation, domain boundaries, and dependency chains.
+- Tasks that don't depend on each other will run in parallel (up to 2 concurrent agents per wave).
 - If a task depends on another, it must list its ID in "dependsOn".
 - Do NOT create cyclic dependencies (A -> B -> A).
 - If the entire objective is very simple and only requires modifying 1-2 files sequentially, output a graph with exactly 1 task.
-- Ensure 'targetFiles' lists all files the task will modify.
+- Ensure 'targetFiles' lists all files the task will modify. Isolate targetFiles across parallel tasks in the same wave to avoid file lock contention.
+- Use 'readOnlyFiles' for files the task needs to inspect without modifying.
 </requirements>
 
 <json_schema>
@@ -123,6 +124,8 @@ export class Orchestrator {
             const MAX_CONCURRENT = 2;
             const toolLogs = [];
             for (let i = 0; i < wave.taskIds.length; i += MAX_CONCURRENT) {
+                if (signal.aborted)
+                    break;
                 const chunk = wave.taskIds.slice(i, i + MAX_CONCURRENT);
                 const wavePromises = chunk.map((taskId) => {
                     const taskDef = graph.tasks.find((t) => t.id === taskId);

package/dist/services/orchestration/scopedTools.js

@@ -160,6 +160,11 @@ export async function executeScopedTool(name, args, workspaceRoot, agentId, bus,
             targetDesc = String(args.filePath);
             actionDesc = 'Deleted';
         }
+        else if (name === 'run_debug_script') {
+            targetDesc = String(args.language ?? 'node');
+            actionDesc = 'Ran debug script';
+            resultSummary = typeof result === 'object' && result?.error ? result.error : 'Completed debug script';
+        }
         else if (name === 'run_fuzz_probe') {
             targetDesc = String(args.language ?? 'node');
             actionDesc = 'Ran fuzz probe';

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

@@ -6,6 +6,25 @@
  */
 import { MessageBus } from './messageBus.js';
 import { FileLockRegistry } from './fileLockRegistry.js';
+/**
+ * Scopes workspace file blocks within a context string by replacing full implementation
+ * bodies with compact AST declaration outlines (types, classes, function signatures),
+ * drastically conserving token overhead for parallel sub-agents.
+ *
+ * @param contextStr The raw context string containing workspace_file blocks.
+ * @returns Context string with scoped workspace_file blocks.
+ */
+export declare function scopeContext(contextStr: string): string;
+/**
+ * Generates a concise reference string for completed historical tool executions
+ * to eliminate token bloat while keeping execution history coherent for the model.
+ *
+ * @param toolName Name of the executed tool.
+ * @param output Output text or object from the tool execution.
+ * @param args Arguments passed to the tool call.
+ * @returns Compacted tool execution reference string.
+ */
+export declare function createCompactToolReference(toolName: string, output: any, args?: Record<string, any>): string;
 /**
  * Result returned when a sub-agent completes its execution.
  */
@@ -43,7 +62,9 @@ export declare class SubAgentRunner {
     static readonly STALL_TIMEOUT_MS = 300000;
     constructor(taskId: string, intent: string, workspaceRoot: string, bus: MessageBus, locks: FileLockRegistry, globalContext: string, onProgress?: ((msg: string) => void) | undefined, onTool?: ((msg: string) => void) | undefined);
     /**
-     * Constructs the base system instruction for this specific agent.
+     * Constructs the base system instruction for this specific agent,
+     * injecting scoped AST outlines for referenced workspace files to eliminate
+     * multi-megabyte context bloat during parallel sub-agent execution.
      */
     private buildSystemInstruction;
     /**
@@ -57,6 +78,15 @@ export declare class SubAgentRunner {
      * an error occurs, or the stall timeout is hit.
      */
     execute(signal: AbortSignal): Promise<SubAgentResult>;
+    /**
+     * Compacts older tool responses in the chat session history into concise references
+     * (e.g. `[Read X lines from file.ts - tool execution completed]`), drastically reducing
+     * context window bloat across multi-turn sub-agent executions while preserving
+     * Gemini's functionCall <-> functionResponse protocol.
+     *
+     * @param turnsToKeep Number of recent turns to preserve in full (default: 1).
+     */
+    compactOlderToolResponses(turnsToKeep?: number): void;
     /**
      * Accumulates token usage from the chat session.
      */

package/dist/services/orchestration/subAgent.js

@@ -11,6 +11,108 @@ import { debugLog } from '../../utils/logger.js';
 import { runWithAgentId } from '../../utils/asyncContext.js';
 import { clearReadHistory } from '../../utils/fileReadGuard.js';
 import { formatToolCall } from '../agent/toolLoop.js';
+import { extractDeclarationsOutline } from '../../utils/symbolExtractor.js';
+import { sanitizeForCDATA } from '../../utils/contextPrompts.js';
+/**
+ * Scopes workspace file blocks within a context string by replacing full implementation
+ * bodies with compact AST declaration outlines (types, classes, function signatures),
+ * drastically conserving token overhead for parallel sub-agents.
+ *
+ * @param contextStr The raw context string containing workspace_file blocks.
+ * @returns Context string with scoped workspace_file blocks.
+ */
+export function scopeContext(contextStr) {
+    if (!contextStr)
+        return '';
+    return contextStr.replace(/<workspace_file path="([^"]+)"([^>]*)>[\s\r\n]*<content_data><!\[CDATA\[([\s\S]*?)\]\](?:\\u200B)?>[\s\r\n]*<\/content_data>[\s\r\n]*<\/workspace_file>/g, (match, filePath, attrs, rawContent) => {
+        if (attrs.includes('scoped="outline"'))
+            return match;
+        const unescaped = rawContent.replace(/\]\]\\u200B>/g, ']]>');
+        const outline = extractDeclarationsOutline(unescaped, filePath) || unescaped;
+        const sanitized = sanitizeForCDATA(outline);
+        return `<workspace_file path="${filePath}"${attrs} scoped="outline">\n<content_data><![CDATA[\n${sanitized}\n]]\\u200B></content_data>\n</workspace_file>`;
+    });
+}
+/**
+ * Locates the matching functionCall in the preceding model response entry.
+ *
+ * @param modelEntry The preceding Content entry from the model.
+ * @param toolName The name of the function call.
+ * @param partIndex Index of the function response part.
+ * @returns The matching functionCall object with args if found.
+ */
+function findMatchingFunctionCall(modelEntry, toolName, partIndex) {
+    if (!modelEntry || modelEntry.role !== 'model' || !Array.isArray(modelEntry.parts))
+        return null;
+    const callParts = modelEntry.parts.filter((p) => p && typeof p === 'object' && 'functionCall' in p && p.functionCall);
+    if (partIndex < callParts.length) {
+        const call = callParts[partIndex].functionCall;
+        if (call && call.name === toolName)
+            return call;
+    }
+    // Fallback: search by toolName
+    const match = callParts.find((p) => p.functionCall?.name === toolName);
+    return match ? match.functionCall : null;
+}
+/**
+ * Generates a concise reference string for completed historical tool executions
+ * to eliminate token bloat while keeping execution history coherent for the model.
+ *
+ * @param toolName Name of the executed tool.
+ * @param output Output text or object from the tool execution.
+ * @param args Arguments passed to the tool call.
+ * @returns Compacted tool execution reference string.
+ */
+export function createCompactToolReference(toolName, output, args) {
+    if (typeof output !== 'string') {
+        return `[${toolName} tool execution completed]`;
+    }
+    // If already compacted, return as-is
+    if (output.startsWith('[') && output.endsWith('completed]')) {
+        return output;
+    }
+    const lineCount = output.split('\n').length;
+    if (toolName === 'read_file') {
+        const file = args?.filePath ? `from ${args.filePath}` : 'from file';
+        return `[Read ${lineCount} lines ${file} - tool execution completed]`;
+    }
+    if (toolName === 'grep_search' || toolName === 'search_codebase') {
+        const pattern = args?.pattern ? `for "${args.pattern}"` : '';
+        return `[Grep search ${pattern} completed - ${lineCount} lines returned]`.replace(/\s+/g, ' ');
+    }
+    if (toolName === 'list_directory') {
+        const dir = args?.dirPath ? `for "${args.dirPath}"` : '';
+        return `[Directory listing ${dir} completed - ${lineCount} entries]`.replace(/\s+/g, ' ');
+    }
+    if (toolName === 'modify_file') {
+        const file = args?.filePath ? `${args.filePath}` : 'file';
+        return `[Modified ${file} - tool execution completed]`;
+    }
+    if (toolName === 'write_file') {
+        const file = args?.filePath ? `${args.filePath}` : 'file';
+        return `[Wrote ${file} - tool execution completed]`;
+    }
+    if (toolName === 'find_dependencies') {
+        const file = args?.filePath ? `for ${args.filePath}` : '';
+        return `[Dependency trace ${file} completed]`.replace(/\s+/g, ' ');
+    }
+    if (toolName === 'find_recent_changes') {
+        return `[Recent changes lookup completed]`;
+    }
+    if (toolName === 'run_command' ||
+        toolName === 'run_debug_script' ||
+        toolName === 'run_analysis_script' ||
+        toolName === 'run_fuzz_probe' ||
+        toolName === 'check_heap_delta' ||
+        toolName === 'check_behavioral_drift') {
+        const cmd = args?.command ? ` "${args.command.slice(0, 50)}"` : '';
+        return `[Command/Script${cmd} execution completed (${lineCount} lines output)]`;
+    }
+    if (output.length > 300) {
+        return `[${toolName} tool execution completed (${lineCount} lines)]`;
+    }
+    return output;
+}
 /**
  * Executes a sub-agent task with full health monitoring, tool wrapping,
  * and orchestration integration.
@@ -52,9 +154,12 @@ export class SubAgentRunner {
         });
     }
     /**
-     * Constructs the base system instruction for this specific agent.
+     * Constructs the base system instruction for this specific agent,
+     * injecting scoped AST outlines for referenced workspace files to eliminate
+     * multi-megabyte context bloat during parallel sub-agent execution.
      */
     buildSystemInstruction() {
+        const scopedContext = scopeContext(this.globalContext);
         return (`<identity>\n` +
             `You are an autonomous Senior software developer sub-agent executing a specific portion of a larger task.\n` +
             `</identity>\n\n` +
@@ -64,7 +169,7 @@ export class SubAgentRunner {
             `</task_info>\n\n` +
             `<reference_context>\n` +
             `DO NOT IMPLEMENT THIS FULL REQUEST. THIS IS JUST FOR CONTEXT.\n\n` +
-            `${this.globalContext}\n` +
+            `${scopedContext}\n` +
             `</reference_context>\n\n` +
             `<critical_guidelines>\n` +
             `1. You are ONE worker in a team. Focus EXCLUSIVELY on your specific objective: "${this.intent}".\n` +
@@ -162,6 +267,10 @@ export class SubAgentRunner {
                     }
                     if (crashed || signal.aborted)
                         break;
+                    // Compact older tool responses in chat history before sending new turn
+                    if (turns > 0) {
+                        this.compactOlderToolResponses(1);
+                    }
                     this.pingHeartbeat();
                     // Feed tool results back to the model
                     turnResult = await this.chat.sendMessage(toolResponses, undefined, signal);
@@ -199,6 +308,48 @@ export class SubAgentRunner {
             };
         });
     }
+    /**
+     * Compacts older tool responses in the chat session history into concise references
+     * (e.g. `[Read X lines from file.ts - tool execution completed]`), drastically reducing
+     * context window bloat across multi-turn sub-agent executions while preserving
+     * Gemini's functionCall <-> functionResponse protocol.
+     *
+     * @param turnsToKeep Number of recent turns to preserve in full (default: 1).
+     */
+    compactOlderToolResponses(turnsToKeep = 1) {
+        const rawHistory = this.chat.getRawHistory();
+        // 1 turn = 1 user Content + 1 model Content pair (2 entries)
+        const cutoffIndex = Math.max(0, rawHistory.length - turnsToKeep * 2);
+        if (cutoffIndex <= 0)
+            return;
+        for (let i = 0; i < cutoffIndex; i++) {
+            const entry = rawHistory[i];
+            if (entry && entry.role === 'user' && Array.isArray(entry.parts)) {
+                const prevModelEntry = i > 0 ? rawHistory[i - 1] : undefined;
+                let funcRespIdx = 0;
+                for (const part of entry.parts) {
+                    if (part && typeof part === 'object' && 'functionResponse' in part && part.functionResponse) {
+                        const funcResp = part.functionResponse;
+                        const toolName = funcResp.name || 'tool';
+                        const matchingCall = findMatchingFunctionCall(prevModelEntry, toolName, funcRespIdx);
+                        const args = matchingCall?.args;
+                        if (funcResp.response && typeof funcResp.response === 'object') {
+                            const respObj = funcResp.response;
+                            if (typeof respObj.output === 'string') {
+                                respObj.output = createCompactToolReference(toolName, respObj.output, args);
+                            }
+                            if (typeof respObj.result === 'string') {
+                                respObj.result = createCompactToolReference(toolName, respObj.result, args);
+                            }
+                        }
+                        funcRespIdx++;
+                    }
+                }
+            }
+        }
+        // Also trigger proxy chat session pruning to collapse any remaining long fields
+        this.chat.pruneToolOutputHistory();
+    }
     /**
      * Accumulates token usage from the chat session.
      */

package/dist/utils/analysisRunner.d.ts

@@ -10,6 +10,8 @@ export interface EphemeralScriptOptions {
     maxOutputChars?: number;
     /** AbortSignal to cancel execution. */
     abortSignal?: AbortSignal;
+    /** Optional custom environment variables to merge into execution environment. */
+    env?: Record<string, string>;
 }
 export interface PropertyTestConfig {
     numRuns?: number;
@@ -23,10 +25,37 @@ export interface PropertyTestResult extends EphemeralScriptResult {
     seed?: number;
     numRunsCompleted?: number;
 }
+/** Supported canonical language names list. */
+export declare const SUPPORTED_LANGUAGES: readonly ["node", "ts-node", "python", "bash", "go", "rust", "c", "cpp", "ruby", "php", "java"];
+export type SupportedLanguage = (typeof SUPPORTED_LANGUAGES)[number];
 /**
  * Normalizes user/AI provided language string to a standard runtime identifier.
  */
 export declare function normalizeLanguage(lang: string): string;
+/**
+ * Detects programming language heuristic markers directly from script source code syntax.
+ * Useful when language is omitted or set to 'auto'.
+ *
+ * @param code - The source code to analyze.
+ * @returns Detected runtime identifier (e.g., 'python', 'rust', 'go', 'cpp', 'c', 'bash', 'ruby', 'php', 'java', 'ts-node', 'node').
+ */
+export declare function detectLanguageFromCode(code: string): string;
+/**
+ * Detects the dominant programming language / runtime for a workspace based on project manifest files.
+ *
+ * @param workspaceRoot - Path to the workspace root directory.
+ * @returns Detected runtime identifier (e.g., 'rust', 'go', 'python', 'cpp', 'ts-node', 'node').
+ */
+export declare function detectProjectRuntime(workspaceRoot: string): Promise<string>;
+/**
+ * Resolves the effective runtime language by combining explicit language input,
+ * source code syntax heuristics, and workspace project manifests.
+ *
+ * @param workspaceRoot - Path to workspace root directory.
+ * @param language - Optional language parameter passed by user/agent.
+ * @param code - Optional source code string to inspect.
+ */
+export declare function resolveEffectiveRuntime(workspaceRoot: string, language?: string, code?: string): Promise<string>;
 /**
  * Detects whether the workspace package.json specifies `"type": "module"`.
  * Returns `'module'` or `'commonjs'`.

package/dist/utils/analysisRunner.js

@@ -10,17 +10,52 @@ const LANGUAGE_ALIASES = {
     js: 'node',
     javascript: 'node',
     node: 'node',
+    cjs: 'node',
+    mjs: 'node',
     ts: 'ts-node',
     typescript: 'ts-node',
     'ts-node': 'ts-node',
+    tsx: 'ts-node',
+    mts: 'ts-node',
+    cts: 'ts-node',
     py: 'python',
+    py3: 'python',
     python: 'python',
+    python3: 'python',
     sh: 'bash',
     bash: 'bash',
+    shell: 'bash',
+    zsh: 'bash',
     go: 'go',
+    golang: 'go',
     rs: 'rust',
     rust: 'rust',
+    rustc: 'rust',
+    c: 'c',
+    cpp: 'cpp',
+    'c++': 'cpp',
+    cc: 'cpp',
+    cxx: 'cpp',
+    cplusplus: 'cpp',
+    rb: 'ruby',
+    ruby: 'ruby',
+    php: 'php',
+    java: 'java',
 };
+/** Supported canonical language names list. */
+export const SUPPORTED_LANGUAGES = [
+    'node',
+    'ts-node',
+    'python',
+    'bash',
+    'go',
+    'rust',
+    'c',
+    'cpp',
+    'ruby',
+    'php',
+    'java',
+];
 /**
  * Normalizes user/AI provided language string to a standard runtime identifier.
  */
@@ -28,6 +63,135 @@ export function normalizeLanguage(lang) {
     const key = lang.toLowerCase().trim();
     return LANGUAGE_ALIASES[key] || key;
 }
+/**
+ * Detects programming language heuristic markers directly from script source code syntax.
+ * Useful when language is omitted or set to 'auto'.
+ *
+ * @param code - The source code to analyze.
+ * @returns Detected runtime identifier (e.g., 'python', 'rust', 'go', 'cpp', 'c', 'bash', 'ruby', 'php', 'java', 'ts-node', 'node').
+ */
+export function detectLanguageFromCode(code) {
+    const trimmed = code.trim();
+    if (!trimmed)
+        return 'node';
+    // Shebang check
+    if (trimmed.startsWith('#!')) {
+        const firstLine = trimmed.split('\n')[0].toLowerCase();
+        if (firstLine.includes('python'))
+            return 'python';
+        if (firstLine.includes('bash') || firstLine.includes('sh') || firstLine.includes('zsh'))
+            return 'bash';
+        if (firstLine.includes('node'))
+            return 'node';
+        if (firstLine.includes('ruby'))
+            return 'ruby';
+        if (firstLine.includes('php'))
+            return 'php';
+    }
+    // PHP marker
+    if (trimmed.startsWith('<?php') || trimmed.includes('<?php')) {
+        return 'php';
+    }
+    // Rust markers
+    if (/\b(fn\s+main\s*\(|println!\s*\(|eprintln!\s*\(|use\s+std::|impl\s+[A-Z]\w*|pub\s+fn\b|match\s+\w+\s*\{)/.test(code)) {
+        return 'rust';
+    }
+    // Go markers
+    if (/\bpackage\s+main\b/.test(code) ||
+        (/\bfunc\s+main\s*\(/.test(code) && /\bimport\s+(\(|")/.test(code))) {
+        return 'go';
+    }
+    // C++ markers
+    if (/#\s*include\s*<(iostream|vector|string|memory|algorithm|map|set|utility)>/.test(code) ||
+        /\bstd::(cout|cin|cerr|endl|vector|string|make_unique|make_shared)\b/.test(code) ||
+        /\btemplate\s*<\s*typename\b/.test(code)) {
+        return 'cpp';
+    }
+    // C markers
+    if (/#\s*include\s*<(stdio\.h|stdlib\.h|string\.h|unistd\.h|math\.h)>/.test(code) ||
+        (/\bprintf\s*\(/.test(code) && /\bint\s+main\s*\(/.test(code))) {
+        return 'c';
+    }
+    // Java markers
+    if (/\bpublic\s+class\s+[A-Z]\w*/.test(code) ||
+        /\bpublic\s+static\s+void\s+main\s*\(/.test(code) ||
+        /\bSystem\.(out|err)\.println\b/.test(code)) {
+        return 'java';
+    }
+    // Python markers
+    if (/\b(def\s+[a-zA-Z_]\w*\s*\(|import\s+[a-zA-Z_]\w*|from\s+[a-zA-Z_]\w*\s+import|if\s+__name__\s*==\s*['"]__main__['"])/.test(code) ||
+        (/:\s*$/.test(trimmed) && /\b(elif|except|finally|pass|yield)\b/.test(code))) {
+        return 'python';
+    }
+    // Ruby markers
+    if (/\b(def\s+[a-zA-Z_]\w*(\s*\(|\s*\n)|puts\s+|require_relative\s+|attr_accessor\s+:)/.test(code) &&
+        /\bend\b/.test(code)) {
+        return 'ruby';
+    }
+    // TypeScript markers
+    if (/\b(interface\s+[A-Z]\w*|type\s+[A-Z]\w*\s*=|:\s*(string|number|boolean|Record<|Array<|Promise<|void|unknown|never)\b|as\s+const\b)/.test(code)) {
+        return 'ts-node';
+    }
+    // Bash markers
+    if (/\b(echo\s+['"].*['"]|if\s+\[\s+.*\s+\];\s*then|fi\b|done\b|export\s+[A-Z_]+=\S+)/.test(code) &&
+        !code.includes('console.log')) {
+        return 'bash';
+    }
+    return 'node';
+}
+/**
+ * Detects the dominant programming language / runtime for a workspace based on project manifest files.
+ *
+ * @param workspaceRoot - Path to the workspace root directory.
+ * @returns Detected runtime identifier (e.g., 'rust', 'go', 'python', 'cpp', 'ts-node', 'node').
+ */
+export async function detectProjectRuntime(workspaceRoot) {
+    const probeFiles = [
+        { file: 'Cargo.toml', runtime: 'rust' },
+        { file: 'go.mod', runtime: 'go' },
+        { file: 'pyproject.toml', runtime: 'python' },
+        { file: 'requirements.txt', runtime: 'python' },
+        { file: 'Pipfile', runtime: 'python' },
+        { file: 'setup.py', runtime: 'python' },
+        { file: 'CMakeLists.txt', runtime: 'cpp' },
+        { file: 'Gemfile', runtime: 'ruby' },
+        { file: 'composer.json', runtime: 'php' },
+        { file: 'pom.xml', runtime: 'java' },
+        { file: 'build.gradle', runtime: 'java' },
+        { file: 'tsconfig.json', runtime: 'ts-node' },
+        { file: 'package.json', runtime: 'node' },
+    ];
+    for (const { file, runtime } of probeFiles) {
+        try {
+            await fs.access(path.join(workspaceRoot, file));
+            return runtime;
+        }
+        catch {
+            // Continue searching
+        }
+    }
+    return 'node';
+}
+/**
+ * Resolves the effective runtime language by combining explicit language input,
+ * source code syntax heuristics, and workspace project manifests.
+ *
+ * @param workspaceRoot - Path to workspace root directory.
+ * @param language - Optional language parameter passed by user/agent.
+ * @param code - Optional source code string to inspect.
+ */
+export async function resolveEffectiveRuntime(workspaceRoot, language, code) {
+    if (language && language.toLowerCase().trim() !== 'auto') {
+        return normalizeLanguage(language);
+    }
+    if (code && code.trim()) {
+        const detectedFromCode = detectLanguageFromCode(code);
+        if (detectedFromCode !== 'node') {
+            return detectedFromCode;
+        }
+    }
+    return detectProjectRuntime(workspaceRoot);
+}
 /**
  * Detects whether the workspace package.json specifies `"type": "module"`.
  * Returns `'module'` or `'commonjs'`.
@@ -72,6 +236,11 @@ export async function resolveScriptExtension(workspaceRoot, language, code) {
         bash: '.sh',
         go: '.go',
         rust: '.rs',
+        c: '.c',
+        cpp: '.cpp',
+        ruby: '.rb',
+        php: '.php',
+        java: '.java',
     };
     return defaultExts[normLang] || '.js';
 }
@@ -89,6 +258,7 @@ function buildTempPath(code, ext) {
  */
 function buildCommand(language, scriptPath) {
     const normLang = normalizeLanguage(language);
+    const binExt = os.platform() === 'win32' ? '.exe' : '';
     switch (normLang) {
         case 'node':
             return `node "${scriptPath}"`;
@@ -101,10 +271,23 @@ function buildCommand(language, scriptPath) {
         case 'go':
             return `go run "${scriptPath}"`;
         case 'rust': {
-            const binExt = os.platform() === 'win32' ? '.exe' : '';
             const binPath = scriptPath.replace(/\.rs$/, binExt);
             return `rustc "${scriptPath}" -o "${binPath}" && "${binPath}"`;
         }
+        case 'c': {
+            const binPath = scriptPath.replace(/\.c$/, binExt);
+            return `gcc "${scriptPath}" -o "${binPath}" && "${binPath}"`;
+        }
+        case 'cpp': {
+            const binPath = scriptPath.replace(/\.cpp$/, binExt);
+            return `g++ -std=c++17 "${scriptPath}" -o "${binPath}" && "${binPath}"`;
+        }
+        case 'ruby':
+            return `ruby "${scriptPath}"`;
+        case 'php':
+            return `php "${scriptPath}"`;
+        case 'java':
+            return `java "${scriptPath}"`;
         default:
             return null;
     }
@@ -134,30 +317,39 @@ function truncateOutput(text, max) {
 export async function runEphemeralScript(workspaceRoot, language, code, options) {
     const timeoutMs = options?.timeoutMs ?? 60_000;
     const maxOutputChars = options?.maxOutputChars ?? 100_000;
-    const normLang = normalizeLanguage(language);
+    const normLang = await resolveEffectiveRuntime(workspaceRoot, language, code);
     const ext = await resolveScriptExtension(workspaceRoot, normLang, code);
     const scriptPath = buildTempPath(code, ext);
     const cmd = buildCommand(normLang, scriptPath);
     if (!cmd) {
         return {
             stdout: '',
-            stderr: `Unsupported language runtime: "${language}". Supported: node, ts-node, python, bash, go, rust`,
+            stderr: `Unsupported language runtime: "${language}". Supported: ${SUPPORTED_LANGUAGES.join(', ')}`,
             exitCode: 1,
         };
     }
     // Collect all temp files created so we can clean them up unconditionally
     const tempFiles = [scriptPath];
+    const binExt = os.platform() === 'win32' ? '.exe' : '';
     if (normLang === 'rust') {
-        const binExt = os.platform() === 'win32' ? '.exe' : '';
         tempFiles.push(scriptPath.replace(/\.rs$/, binExt));
+        tempFiles.push(scriptPath.replace(/\.rs$/, '.pdb'));
+    }
+    else if (normLang === 'c') {
+        tempFiles.push(scriptPath.replace(/\.c$/, binExt));
+    }
+    else if (normLang === 'cpp') {
+        tempFiles.push(scriptPath.replace(/\.cpp$/, binExt));
     }
     try {
         await fs.writeFile(scriptPath, code, 'utf-8');
+        const mergedEnv = options?.env ? { ...process.env, ...options.env } : process.env;
         const { stdout, stderr } = await execAsync(cmd, {
             cwd: workspaceRoot,
             timeout: timeoutMs,
             maxBuffer: 1024 * 1024, // 1 MB buffer
             signal: options?.abortSignal,
+            env: mergedEnv,
         });
         return {
             stdout: truncateOutput(stdout.trim(), maxOutputChars),
@@ -170,6 +362,9 @@ export async function runEphemeralScript(workspaceRoot, language, code, options)
         if (err.name === 'AbortError' || err.message?.includes('abort')) {
             return { stdout: '', stderr: 'Analysis script aborted by user.', exitCode: 130 };
         }
+        if (err.killed && err.signal === 'SIGTERM') {
+            return { stdout: '', stderr: `Execution timed out after ${timeoutMs}ms.`, exitCode: 124 };
+        }
         const stdout = truncateOutput((err.stdout || '').trim(), maxOutputChars);
         const stderr = truncateOutput((err.stderr || '').trim(), maxOutputChars);
         const exitCode = typeof err.code === 'number' ? err.code : 1;
@@ -179,7 +374,7 @@ export async function runEphemeralScript(workspaceRoot, language, code, options)
         // Guarantee temp file cleanup regardless of success or failure
         for (const tmpFile of tempFiles) {
             try {
-                await fs.rm(tmpFile, { force: true });
+                await fs.rm(tmpFile, { force: true, recursive: true });
             }
             catch {
                 // Ignore cleanup errors — temp files will be reaped by the OS eventually