minovative-mind-cli 2.11.5 → 2.12.0

package/README.md

@@ -76,12 +76,25 @@ Works in any terminal — SSH, Docker, CI pipelines, Vim, Windows Command Prompt
   - Solved one of the hardest logic puzzles on the platform by engineering a mathematically rigorous pruning algorithm based on the Rearrangement Inequality.
   - Completely bypassed naive backtracking (10! permutations).
   - Achieved sub-millisecond execution speeds (~140 microseconds) with zero heap allocations during recursion.
-  - Autonomously navigated the Go toolchain (\`go test -bench=.\`).
+  - Autonomously navigated the Go toolchain (`go test -bench=.`).
   - Parsed its own architectural performance warnings to optimize the solution.
 - [Alphametics Summary](https://github.com/Quarantiine/polyglot-benchmark-mmcli/blob/main/go/exercises/practice/alphametics/minovative-tries/attempt_1.md)
 
+### 🔬 Automated SWE-bench Evaluation Runner
+
+Evaluate the agent on SWE-bench Lite datasets with automated repo isolation, patch extraction, and public-ready telemetry reporting:
+
+```bash
+# Run SWE-bench evaluation and generate JSON report
+minovative-mind-cli eval -i test_instances.jsonl -o predictions.jsonl -r evaluation_report.json --autoClone
+
+# Run with specific repository filter and concurrency
+minovative-mind-cli eval -i instances.jsonl --repo astropy/astropy --concurrency 2
+```
+
 ---
 
+
 ## Models
 
 Hot-swap during a session using `/models`:

package/dist/commands/eval.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+export default class EvalCommand extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        instances: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        report: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        model: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        maxTurns: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        repo: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        instanceId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workspaceDir: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        autoClone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        dryRun: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        concurrency: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/eval.js

@@ -0,0 +1,141 @@
+import { Command, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { runSWEBenchEvaluation, formatEvaluationReportSummary, } from '../services/swebench/index.js';
+export default class EvalCommand extends Command {
+    static description = 'Execute automated evaluation on SWE-bench Lite benchmark instances';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> -i instances.json -o predictions.jsonl',
+        '<%= config.bin %> <%= command.id %> --instances ./test_instances.jsonl --output ./predictions.jsonl --report ./evaluation_report.json',
+        '<%= config.bin %> <%= command.id %> --instances test_instances.jsonl --repo astropy/astropy --limit 5',
+        '<%= config.bin %> <%= command.id %> --instances test_instances.jsonl --instance-id astropy__astropy-12907',
+        '<%= config.bin %> <%= command.id %> --instances test_instances.jsonl --dry-run',
+    ];
+    static flags = {
+        instances: Flags.string({
+            char: 'i',
+            description: 'Path to input instances file (JSON or JSONL format)',
+            required: true,
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Path to write generated predictions JSONL file',
+            default: 'predictions.jsonl',
+        }),
+        report: Flags.string({
+            char: 'r',
+            description: 'Path to export comprehensive evaluation report JSON',
+        }),
+        model: Flags.string({
+            char: 'm',
+            description: 'Model name tag for prediction metadata',
+            default: 'minovative-mind-agent',
+        }),
+        maxTurns: Flags.integer({
+            description: 'Maximum agent execution turns per benchmark instance',
+            default: 30,
+        }),
+        timeout: Flags.integer({
+            description: 'Timeout in milliseconds per instance (default: 600000ms = 10min)',
+            default: 600000,
+        }),
+        repo: Flags.string({
+            description: 'Filter instances by repository name (e.g. astropy/astropy)',
+        }),
+        instanceId: Flags.string({
+            description: 'Filter by specific instance ID (e.g. astropy__astropy-12907)',
+        }),
+        limit: Flags.integer({
+            description: 'Limit the number of instances to evaluate',
+        }),
+        workspaceDir: Flags.string({
+            char: 'w',
+            description: 'Base workspace directory where repo checkouts reside',
+        }),
+        autoClone: Flags.boolean({
+            description: 'Automatically clone repository if not found locally in workspace directory',
+            default: false,
+        }),
+        dryRun: Flags.boolean({
+            description: 'Validate instances and workspace setup without invoking the agent loop',
+            default: false,
+        }),
+        concurrency: Flags.integer({
+            char: 'c',
+            description: 'Number of instances to evaluate concurrently (default: 1)',
+            default: 1,
+        }),
+        verbose: Flags.boolean({
+            char: 'v',
+            description: 'Show detailed per-turn logs during evaluation',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EvalCommand);
+        const instancesPath = path.isAbsolute(flags.instances)
+            ? flags.instances
+            : path.resolve(process.cwd(), flags.instances);
+        const outputPath = path.isAbsolute(flags.output)
+            ? flags.output
+            : path.resolve(process.cwd(), flags.output);
+        const reportPath = flags.report
+            ? path.isAbsolute(flags.report)
+                ? flags.report
+                : path.resolve(process.cwd(), flags.report)
+            : undefined;
+        if (!fs.existsSync(instancesPath)) {
+            this.error(`Instances file not found: ${instancesPath}`);
+            return;
+        }
+        this.log(`\n======================================================`);
+        this.log(`  MINOVATIVE SWE-BENCH LITE EVALUATION RUNNER`);
+        this.log(`======================================================`);
+        this.log(`Instances File   : ${instancesPath}`);
+        this.log(`Output Location  : ${outputPath}`);
+        if (reportPath)
+            this.log(`Report Location  : ${reportPath}`);
+        this.log(`Model Identifier : ${flags.model}`);
+        this.log(`Max Turns        : ${flags.maxTurns}`);
+        this.log(`Timeout / Inst   : ${flags.timeout}ms`);
+        if (flags.repo)
+            this.log(`Repo Filter      : ${flags.repo}`);
+        if (flags.instanceId)
+            this.log(`Instance Filter  : ${flags.instanceId}`);
+        if (flags.limit)
+            this.log(`Instance Limit   : ${flags.limit}`);
+        if (flags.dryRun)
+            this.log(`Execution Mode   : Dry Run (No agent invocation)`);
+        if (flags.autoClone)
+            this.log(`Auto-Clone Repos : Enabled`);
+        this.log(`======================================================\n`);
+        const evalOptions = {
+            instancesPath,
+            outputPredictionsPath: outputPath,
+            reportPath,
+            modelName: flags.model,
+            maxTurns: flags.maxTurns,
+            timeoutMsPerInstance: flags.timeout,
+            repo: flags.repo,
+            instanceIds: flags.instanceId ? [flags.instanceId] : undefined,
+            limit: flags.limit,
+            workspacesBaseDir: flags.workspaceDir,
+            autoCloneRepos: flags.autoClone,
+            dryRun: flags.dryRun,
+            concurrency: flags.concurrency,
+            verbose: flags.verbose,
+            onProgress: (progress) => {
+                const statusStr = progress.status === 'success' ? 'Completed' : progress.status === 'running' ? 'Running' : progress.status;
+                this.log(`[${progress.completed}/${progress.total}] Instance: ${progress.currentInstanceId} (${statusStr})`);
+            },
+        };
+        try {
+            const summary = await runSWEBenchEvaluation(evalOptions);
+            this.log(formatEvaluationReportSummary(summary));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.error(`SWE-bench evaluation failed: ${msg}`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { run } from '@oclif/core';
+export * as swebench from './services/swebench/index.js';

package/dist/index.js

@@ -1 +1,2 @@
 export { run } from '@oclif/core';
+export * as swebench from './services/swebench/index.js';

package/dist/services/agent/toolLoop.d.ts

@@ -37,3 +37,7 @@ export declare function formatToolCall(name: string, args: Record<string, unknow
  * @returns A promise that resolves to the final text response.
  */
 export declare function processResponse(chat: ProxyChatSession, result: any, workspaceRoot: string, inputHandler: AsyncInputHandler, agentState: AgentState, abortSignal: AbortSignal): Promise<string>;
+/**
+ * System advisory appended when consecutive command failures exceed the circuit breaker threshold.
+ */
+export declare const CONSECUTIVE_COMMAND_FAILURE_ADVISORY = "\n\n\u26A0\uFE0F SYSTEM ADVISORY: Multiple consecutive command failures detected. If you are troubleshooting a build or test failure, inspect the build configuration file (e.g., package.json, setup.py, Cargo.toml, Makefile, CMakeLists.txt) or relevant source code to identify the root cause before retrying.";

package/dist/services/agent/toolLoop.js

@@ -6,7 +6,7 @@ import { executeTool } from '../agent-tools.js';
 import { getPlanExecutionConfig } from '../ai.js';
 import { routeIntent } from '../contextAgent.js';
 import { requestCommandApproval } from './commandApproval.js';
-import { getMetricCollector } from '../metrics.js';
+import { getMetricCollector, recordRecoveryCircuitBreakerTrip } from '../metrics.js';
 import { trackTask } from '../../utils/taskVisualizer.js';
 // ─── Constants ───────────────────────────────────────────────────────
 /**
@@ -175,6 +175,8 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
     // Recovery thresholds for handling unexpected empty API payloads
     let emptyRetryCount = 0;
     const MAX_EMPTY_RETRIES = 5;
+    // Consecutive command failure tracking for circuit breaker
+    const commandFailureState = { consecutiveFailures: 0 };
     // Loop while the model keeps requesting tool calls
     while (true) {
         turnCount++;
@@ -251,7 +253,7 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         const collector = getMetricCollector();
         if (collector)
             collector.recordToolTurn();
-        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal);
+        const execRes = await executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal, commandFailureState);
         if (execRes.aborted) {
             return '[Generation stopped by user]';
         }
@@ -294,8 +296,25 @@ export async function processResponse(chat, result, workspaceRoot, inputHandler,
         response = followUp.response;
     }
 }
-async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal) {
+/**
+ * System advisory appended when consecutive command failures exceed the circuit breaker threshold.
+ */
+export const CONSECUTIVE_COMMAND_FAILURE_ADVISORY = '\n\n⚠️ SYSTEM ADVISORY: Multiple consecutive command failures detected. If you are troubleshooting a build or test failure, inspect the build configuration file (e.g., package.json, setup.py, Cargo.toml, Makefile, CMakeLists.txt) or relevant source code to identify the root cause before retrying.';
+/**
+ * Executes a sequence of tool calls returned by the AI model.
+ * Enforces security gates, tracks telemetry, applies circuit breakers for consecutive command failures,
+ * and passes the tool execution results back to the conversation loop.
+ *
+ * @param functionCalls - Array of function call parts from the Gemini API.
+ * @param workspaceRoot - Root directory of the primary active workspace.
+ * @param inputHandler - Async input listener for handling user steering/abort.
+ * @param abortSignal - Signal to cancel ongoing execution turns.
+ * @param commandFailureState - Mutable container tracking consecutive command failure counts across turns.
+ * @returns An object containing tool responses formatted for Gemini API, plus an aborted flag.
+ */
+async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abortSignal, commandFailureState) {
     const toolResponses = [];
+    const state = commandFailureState ?? { consecutiveFailures: 0 };
     for (const fc of functionCalls) {
         await inputHandler.waitForPrompt();
         if (abortSignal.aborted) {
@@ -330,24 +349,56 @@ async function executeToolCalls(functionCalls, workspaceRoot, inputHandler, abor
             return await executeTool(workspaceRoot, toolName, toolArgs, abortSignal);
         });
         await inputHandler.waitForPrompt();
-        if (toolResult.error) {
-            debugLog(`Raw Tool Error for ${toolName}: ${toolResult.error}`);
+        let toolError = toolResult.error;
+        // Circuit Breaker State Tracking:
+        // Reset counter to 0 immediately upon:
+        // 1. A successful (zero-exit / no error) run_command or run_debug_script.
+        // 2. Any investigative tool call (read_file, grep_search, list_directory, find_dependencies, run_analysis_script).
+        // 3. Any file mutation (modify_file, write_file, delete_file, rename_file).
+        const isCommandTool = toolName === 'run_command' || toolName === 'run_debug_script';
+        const isInvestigativeOrMutationTool = [
+            'read_file',
+            'grep_search',
+            'list_directory',
+            'find_dependencies',
+            'find_recent_changes',
+            'run_analysis_script',
+            'modify_file',
+            'write_file',
+            'delete_file',
+            'rename_file',
+        ].includes(toolName);
+        if (isCommandTool) {
+            if (toolError) {
+                state.consecutiveFailures++;
+                if (state.consecutiveFailures >= 2) {
+                    toolError += CONSECUTIVE_COMMAND_FAILURE_ADVISORY;
+                    recordRecoveryCircuitBreakerTrip();
+                }
+            }
+            else {
+                state.consecutiveFailures = 0;
+            }
+        }
+        else if (isInvestigativeOrMutationTool) {
+            state.consecutiveFailures = 0;
+        }
+        if (toolError) {
+            debugLog(`Raw Tool Error for ${toolName}: ${toolError}`);
             // Do not spam the user with expected chunking warnings
-            if (!toolResult.error.includes('File is too large')) {
+            if (!toolError.includes('File is too large')) {
                 // Truncate the error message for the terminal UI to prevent console clutter
                 // (e.g. hiding the large file previews sent to the AI)
-                const displayError = toolResult.error.split('\n')[0].substring(0, 100);
+                const displayError = toolError.split('\n')[0].substring(0, 100);
                 p.log.warn(`${pc.red('Tool error:')} [${displayError}]`);
             }
         }
-        if (!toolResult.error && (toolName === 'write_file' || toolName === 'modify_file' || toolName === 'delete_file')) {
-        }
         toolResponses.push({
             functionResponse: {
                 name: toolName,
                 response: {
                     output: toolResult.output,
-                    ...(toolResult.error ? { error: toolResult.error } : {}),
+                    ...(toolError ? { error: toolError } : {}),
                     ...(toolResult.inlineData ? { inlineData: toolResult.inlineData } : {}),
                 },
             },

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

@@ -139,13 +139,13 @@ export declare function modifyFile(workspaceRoot: string, filePath: string, edit
  */
 export declare function listDirectory(workspaceRoot: string, dirPath: string, maxDepth?: number): Promise<ToolResult>;
 /**
- * Executes a shell command within the workspace root with a timeout and buffer limit.
+ * Condenses verbose command and test failure outputs into high-signal diagnostic error logs
+ * with dynamic tail sizing and stack trace boundary snapping.
  *
- * @param workspaceRoot - Absolute path to the workspace root directory.
- * @param command - The shell command string to execute.
- * @param abortSignal - Optional AbortSignal to cancel execution.
- * @returns A promise resolving to a {@link ToolResult} containing stdout/stderr or an error.
+ * @param rawError - The full error or standard error string.
+ * @returns The condensed high-signal diagnostic output.
  */
+export declare function extractHighSignalError(rawError: string): string;
 export declare function runCommand(workspaceRoot: string, command: string, abortSignal?: AbortSignal): Promise<ToolResult>;
 /**
  * Performs a grep text or regular expression search across files in the workspace.

package/dist/services/agent-tools.js

@@ -27,7 +27,7 @@ import { findDependencies, formatDependencyResult } from '../utils/dependencyTra
 import { atomicWriteFile } from '../utils/atomicWrite.js';
 import { EXCLUDED_EXTENSIONS } from '../utils/excludedExtensions.js';
 import { extractSymbols } from '../utils/symbolExtractor.js';
-import { getMetricCollector } from './metrics.js';
+import { getMetricCollector, recordRecoveryPrunedLogVolume } from './metrics.js';
 import { getCurrentAgentId } from '../utils/asyncContext.js';
 import { recordFileRead, hasAgentReadFile } from '../utils/fileReadGuard.js';
 import { runFuzzProbe, checkHeapDelta as runCheckHeapDelta, checkBehavioralDrift as runCheckBehavioralDrift, runEphemeralScript, } from '../utils/analysisRunner.js';
@@ -1110,6 +1110,137 @@ export async function listDirectory(workspaceRoot, dirPath, maxDepth = 3) {
  * @param abortSignal - Optional AbortSignal to cancel execution.
  * @returns A promise resolving to a {@link ToolResult} containing stdout/stderr or an error.
  */
+/**
+ * High-signal error patterns across major languages and compiler toolchains.
+ * Linker notes and candidate diagnostic details are explicitly retained.
+ */
+const HIGH_SIGNAL_ERROR_PATTERNS = [
+    // C / C++ / Cython / Clang / GCC
+    /fatal error:/i,
+    /#error/i,
+    /\berror:\b/i,
+    /undefined symbol:/i,
+    /undefined reference/i,
+    /ld: symbol\(s\) not found/i,
+    /clang: error:/i,
+    /referenced from:/i,
+    /note: expanded from macro/i,
+    /note: candidate:/i,
+    // Python / Pytest
+    /Traceback \(most recent call last\):/i,
+    /AssertionError:/i,
+    /TypeError:/i,
+    /ImportError:/i,
+    /ModuleNotFoundError:/i,
+    /FAILED \(failures=/i,
+    /\bE\s{3}\b/,
+    /\bFAIL\b/,
+    // Node.js / TypeScript / Jest / Mocha
+    /SyntaxError:/i,
+    /ReferenceError:/i,
+    /Error: Cannot find module/i,
+    /\bFAIL\b/,
+    /✕\s/,
+    /TS\d{4}:/,
+    // Rust / Cargo
+    /error\[E\d+\]:/i,
+    /fatal runtime error:/i,
+    /panicked at/i,
+    // Go
+    /panic:/i,
+    /cannot find package/i,
+    /undefined:/i,
+    /FAIL\t/,
+    // Java / JVM
+    /Exception in thread/i,
+    /java\.lang\./i,
+    /error: cannot find symbol/i,
+    // Generic Fallbacks
+    /\b(cannot|unable to|not found|command not found|no such file)\b/i,
+];
+/**
+ * Noise filter pattern for compiler warning churn when total output is extensive.
+ */
+const COMPILER_WARNING_NOISE_PATTERN = /-W(deprecated-declarations|unused-variable|unused-parameter|unused-function|sign-compare|ignored-qualifiers|nullability-completeness)/i;
+/**
+ * Start boundary patterns for common multi-line stack traces.
+ */
+const STACK_TRACE_START_PATTERNS = [
+    /Traceback \(most recent call last\):/i,
+    /Exception in thread/i,
+    /panic:/i,
+    /Error:\s*$/i,
+];
+/**
+ * Condenses verbose command and test failure outputs into high-signal diagnostic error logs
+ * with dynamic tail sizing and stack trace boundary snapping.
+ *
+ * @param rawError - The full error or standard error string.
+ * @returns The condensed high-signal diagnostic output.
+ */
+export function extractHighSignalError(rawError) {
+    if (!rawError || typeof rawError !== 'string')
+        return '';
+    // Threshold passthrough: if < 3000 chars or < 50 lines, return untouched
+    const lines = rawError.split(/\r?\n/);
+    if (rawError.length < 3000 && lines.length < 50) {
+        return rawError;
+    }
+    // Filter out noise lines (e.g. repetitive compiler warning flags)
+    const nonNoiseLines = lines.filter((l) => !COMPILER_WARNING_NOISE_PATTERN.test(l));
+    // Find high-signal error lines
+    const highSignalLines = [];
+    const highSignalIndices = new Set();
+    for (let i = 0; i < nonNoiseLines.length; i++) {
+        const line = nonNoiseLines[i];
+        if (HIGH_SIGNAL_ERROR_PATTERNS.some((p) => p.test(line))) {
+            highSignalLines.push(line);
+            highSignalIndices.add(i);
+        }
+    }
+    // Dynamic tail sizing: Math.min(50, Math.max(15, Math.floor(totalLines * 0.15)))
+    const dynamicTailCount = Math.min(50, Math.max(15, Math.floor(nonNoiseLines.length * 0.15)));
+    let tailStartIndex = Math.max(0, nonNoiseLines.length - dynamicTailCount);
+    // Stack-trace boundary snapping: if a stack trace starts up to 15 lines above tailStartIndex, snap upward
+    const lookbackMax = Math.max(0, tailStartIndex - 15);
+    for (let i = tailStartIndex; i >= lookbackMax; i--) {
+        if (STACK_TRACE_START_PATTERNS.some((p) => p.test(nonNoiseLines[i]))) {
+            tailStartIndex = i;
+            break;
+        }
+    }
+    const tailLines = nonNoiseLines.slice(tailStartIndex);
+    // If high-signal lines are all already present within the tail, return tail directly (with note if truncated)
+    const isHighSignalInTail = Array.from(highSignalIndices).every((idx) => idx >= tailStartIndex);
+    if (isHighSignalInTail && tailStartIndex === 0) {
+        return nonNoiseLines.join('\n');
+    }
+    const resultBlocks = [];
+    // Add high signal summary if there are high-signal lines occurring before the tail
+    const precedingHighSignal = highSignalLines.filter((_, idx) => {
+        const originalIndex = Array.from(highSignalIndices)[idx];
+        return originalIndex < tailStartIndex;
+    });
+    if (precedingHighSignal.length > 0) {
+        resultBlocks.push(`--- [High-Signal Diagnostic Highlights (${precedingHighSignal.length} findings)] ---\n` +
+            precedingHighSignal.join('\n'));
+    }
+    if (tailStartIndex > 0) {
+        resultBlocks.push(`--- [Output Tail (last ${tailLines.length} of ${nonNoiseLines.length} lines)] ---\n` +
+            tailLines.join('\n'));
+    }
+    else {
+        resultBlocks.push(tailLines.join('\n'));
+    }
+    const condensedResult = resultBlocks.join('\n\n');
+    const condensedLines = condensedResult.split(/\r?\n/).length;
+    const linesPruned = Math.max(0, lines.length - condensedLines);
+    const charsPruned = Math.max(0, rawError.length - condensedResult.length);
+    if (linesPruned > 0 || charsPruned > 0) {
+        recordRecoveryPrunedLogVolume(linesPruned, charsPruned);
+    }
+    return condensedResult;
+}
 export async function runCommand(workspaceRoot, command, abortSignal) {
     // Reject sudo or interactive root commands to prevent non-interactive subshell deadlocks and security escalation
     if (/\bsudo\b/i.test(command)) {
@@ -1137,12 +1268,13 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        // Also truncate error output
+        // Condense error output with high-signal extraction and dynamic tail sizing
+        const condensedError = extractHighSignalError(message);
         const MAX_ERR_OUTPUT = 30_000;
-        const truncatedMsg = message.length > MAX_ERR_OUTPUT
-            ? message.substring(0, MAX_ERR_OUTPUT) +
-                `\n\n... (Error output truncated: ${message.length} bytes exceeded 30KB limit. Pipe to a file if you need full logs.)`
-            : message;
+        const truncatedMsg = condensedError.length > MAX_ERR_OUTPUT
+            ? condensedError.substring(0, MAX_ERR_OUTPUT) +
+                `\n\n... (Error output truncated: ${condensedError.length} bytes exceeded 30KB limit. Pipe to a file if you need full logs.)`
+            : condensedError;
         return { output: '', error: `Command failed: ${truncatedMsg}` };
     }
 }
@@ -1389,15 +1521,21 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
         if (!finalOutput.trim()) {
             finalOutput = 'Script executed successfully with no output.';
         }
+        const condensedOutput = extractHighSignalError(finalOutput.trim());
         return {
-            output: `<test_results>\n${sanitizeForCDATA(finalOutput.trim())}\n</test_results>`,
-            ...(res.exitCode !== 0 ? { error: `Script failed with exit code ${res.exitCode}` } : {}),
+            output: `<test_results>\n${sanitizeForCDATA(condensedOutput)}\n</test_results>`,
+            ...(res.exitCode !== 0
+                ? {
+                    error: `Script failed with exit code ${res.exitCode}:\n${extractHighSignalError(res.stderr || res.stdout || '')}`,
+                }
+                : {}),
         };
     }
     catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
         return {
             output: '',
-            error: `Failed to execute debug script: ${err instanceof Error ? err.message : String(err)}`,
+            error: `Failed to execute debug script: ${extractHighSignalError(msg)}`,
         };
     }
 }

package/dist/services/contextAgent.d.ts

@@ -10,6 +10,7 @@ export interface ContextAgentResult {
     fromMemoryBank?: boolean;
     isParallel?: boolean;
 }
+export declare function detectProjectType(workspaceRoot: string): Promise<string>;
 export interface IntentRoute {
     needsContext: boolean;
     targetAgent: 'CHAT' | 'EXECUTE';

package/dist/services/contextAgent.js

@@ -51,8 +51,15 @@ function boundToolOutput(output) {
         truncationMarker: `\n\n... [Tool output truncated: exceeded ${MAX_TOOL_OUTPUT_TOKENS} tokens limit] ...\n`,
     });
 }
-async function detectProjectType(workspaceRoot) {
+export async function detectProjectType(workspaceRoot) {
     const types = [];
+    // Detect Host Platform & Architecture
+    const platformName = process.platform === 'darwin' ? 'Darwin' : process.platform === 'win32' ? 'Windows' : 'Linux';
+    const isAppleSilicon = process.platform === 'darwin' && process.arch === 'arm64';
+    const hostDesc = isAppleSilicon
+        ? `Host: ${platformName} ${process.arch} (Apple Silicon)`
+        : `Host: ${platformName} ${process.arch}`;
+    types.push(hostDesc);
     const fileExists = async (fileName) => {
         try {
             await fs.access(path.join(workspaceRoot, fileName));
@@ -62,6 +69,13 @@ async function detectProjectType(workspaceRoot) {
             return false;
         }
     };
+    // C / C++ / Native Build Toolchains
+    if (await fileExists('CMakeLists.txt'))
+        types.push('CMake');
+    if (await fileExists('Makefile'))
+        types.push('Makefile');
+    if (await fileExists('meson.build'))
+        types.push('Meson');
     // Node.js Ecosystem
     if (await fileExists('package.json')) {
         types.push('Node.js');
@@ -93,17 +107,17 @@ async function detectProjectType(workspaceRoot) {
                 types.push('NestJS');
             if (deps['vite'])
                 types.push('Vite');
-            if (deps['tailwindcss'])
-                types.push('Tailwind CSS');
-            if (deps['firebase'])
-                types.push('Firebase');
         }
         catch { }
         if (await fileExists('tsconfig.json'))
             types.push('TypeScript');
     }
     // Python Ecosystem
-    if ((await fileExists('pyproject.toml')) || (await fileExists('requirements.txt')) || (await fileExists('Pipfile'))) {
+    if ((await fileExists('pyproject.toml')) ||
+        (await fileExists('requirements.txt')) ||
+        (await fileExists('setup.py')) ||
+        (await fileExists('setup.cfg')) ||
+        (await fileExists('Pipfile'))) {
         types.push('Python');
         try {
             const reqs = (await fileExists('requirements.txt'))
@@ -119,6 +133,15 @@ async function detectProjectType(workspaceRoot) {
                 types.push('Flask');
             if (combined.includes('fastapi'))
                 types.push('FastAPI');
+            if (combined.includes('cython') || (await fileExists('setup.py'))) {
+                try {
+                    const files = await fs.readdir(workspaceRoot);
+                    if (files.some((f) => f.endsWith('.pyx') || f.endsWith('.pxd') || f.endsWith('.c') || f.endsWith('.cpp'))) {
+                        types.push('Cython/C-Extensions');
+                    }
+                }
+                catch { }
+            }
         }
         catch { }
     }

package/dist/services/metrics.d.ts

@@ -19,6 +19,8 @@ export interface MetricCollector {
     recordCacheHit(cacheType?: 'investigation' | 'read'): void;
     recordCacheMiss(cacheType?: 'investigation' | 'read'): void;
     recordCachePerformance(cacheType: 'investigation' | 'read', durationMs: number): void;
+    recordCircuitBreakerTrip?(): void;
+    recordPrunedLogVolume?(lines: number, chars: number): void;
     recordWriteFailure?(): void;
     recordModifyFailure?(): void;
     recordToolFailure?(toolName?: string): void;
@@ -33,3 +35,11 @@ export declare function getTurnTotals(): {
     outputTokens: number;
     cachedTokens: number;
 };
+export declare function recordRecoveryCircuitBreakerTrip(): void;
+export declare function recordRecoveryPrunedLogVolume(lines: number, chars: number): void;
+export declare function getRecoveryMetrics(): {
+    circuitBreakerTrips: number;
+    prunedLines: number;
+    prunedChars: number;
+};
+export declare function resetRecoveryMetrics(): void;