minovative-mind-cli 2.14.0 → 2.14.2

package/dist/services/agent-tools.js

@@ -278,11 +278,15 @@ export const toolDeclarations = [
     },
     {
         name: 'run_debug_script',
-        description: 'Write a disposable script to a sandboxed temporary file in os.tmpdir(), execute it using the specified runtime, and return the exact standard output and standard error without polluting the workspace or triggering IDE file watchers. ' +
-            'Use this to: (1) actively debug the codebase by inspecting variables or logging values, ' +
-            '(2) validate your changes by importing the modified module and asserting expected behavior with edge-case inputs, ' +
-            '(3) run quick sanity checks (e.g., verify a config file parses correctly, confirm exports are intact after a refactor, or check that a function returns the expected output), ' +
-            '(4) write lightweight ML scripts to solve complex problems — e.g., polynomial regression to estimate Big-O complexity, fuzz testing with Markov chain input generation, ' +
+        description: 'Write a disposable script to a sandboxed temporary file in os.tmpdir(), execute it using the specified runtime, and return the exact standard output, structured JSON result, and standard error without polluting the workspace or triggering IDE file watchers. ' +
+            'Sandbox Features: ' +
+            '(1) Preloaded Helpers: "emitResult(data)" / "__emitResult(data)" outputs structured JSON payloads parsed directly into structuredResult; "inspectSymbols(target)" / "inspectObject(target)" inspects functions, classes, and properties. ' +
+            '(2) Module & Path Resolution: Automatically inherits tsconfig.json path aliases (@/*), NODE_PATH, and workspace virtualenvs (.venv, venv) for Python. ' +
+            '(3) Diagnostics Middleware: Provides actionable [SANDBOX DIAGNOSTIC] advisories for missing imports, ESM/CJS interop, and compiler errors. ' +
+            'Use this to: (a) actively debug the codebase by inspecting variables or logging values, ' +
+            '(b) validate your changes by importing the modified module and asserting expected behavior with edge-case inputs, ' +
+            '(c) run quick sanity checks (e.g., verify a config file parses correctly, confirm exports are intact after a refactor, or check that a function returns the expected output), ' +
+            '(d) write lightweight ML scripts to solve complex problems — e.g., polynomial regression to estimate Big-O complexity, fuzz testing with Markov chain input generation, ' +
             'output regression detection via statistical similarity scoring, or error message classification with Naive Bayes. ' +
             'Default to "node" for generic tasks as a safe baseline, but act like a native inhabitant of the host environment — if Python, Go, Rust, or host-native libraries are active in the project, leverage the host\'s native runtimes for maximum efficiency. ' +
             'Do not guess whether your code works — test it directly!',
@@ -1124,6 +1128,7 @@ const HIGH_SIGNAL_ERROR_PATTERNS = [
     /undefined reference/i,
     /ld: symbol\(s\) not found/i,
     /clang: error:/i,
+    /gcc: error:/i,
     /referenced from:/i,
     /note: expanded from macro/i,
     /note: candidate:/i,
@@ -1133,29 +1138,59 @@ const HIGH_SIGNAL_ERROR_PATTERNS = [
     /TypeError:/i,
     /ImportError:/i,
     /ModuleNotFoundError:/i,
+    /AttributeError:/i,
+    /IndexError:/i,
+    /KeyError:/i,
+    /ValueError:/i,
     /FAILED \(failures=/i,
     /\bE\s{3}\b/,
     /\bFAIL\b/,
-    // Node.js / TypeScript / Jest / Mocha
+    /\bFAILED\b/,
+    /=== FAILURES ===/i,
+    /=== ERRORS ===/i,
+    // Sandbox Diagnostics & Structured Results
+    /\[SANDBOX DIAGNOSTIC\]/i,
+    /\[STRUCTURED RESULT\]/i,
+    /Module resolution failure/i,
+    /CommonJS require\(\) attempted to load an ES Module/i,
+    // Node.js / TypeScript / Jest / Mocha / Vitest
+    /TS\d+:/i,
+    /TS\d{4,5}:/i,
     /SyntaxError:/i,
     /ReferenceError:/i,
+    /TypeError:/i,
+    /RangeError:/i,
+    /URIError:/i,
     /Error: Cannot find module/i,
+    /Cannot find module/i,
+    /Cannot find name/i,
+    /Type '.*' is not assignable to type/i,
+    /Property '.*' does not exist on type/i,
     /\bFAIL\b/,
     /✕\s/,
-    /TS\d{4}:/,
     // Rust / Cargo
     /error\[E\d+\]:/i,
     /fatal runtime error:/i,
     /panicked at/i,
+    /thread '.*' panicked at/i,
+    /-->\s+.*:\d+:\d+/i,
+    /could not compile/i,
     // Go
     /panic:/i,
     /cannot find package/i,
     /undefined:/i,
     /FAIL\t/,
-    // Java / JVM
+    // Java / JVM / Kotlin / Scala
     /Exception in thread/i,
     /java\.lang\./i,
     /error: cannot find symbol/i,
+    /NullPointerException/i,
+    /ClassNotFoundException/i,
+    // C# / .NET
+    /CS\d{4}:/i,
+    /Unhandled exception/i,
+    // Swift
+    /error:\s+/i,
     // Generic Fallbacks
     /\b(cannot|unable to|not found|command not found|no such file)\b/i,
 ];
@@ -1170,8 +1205,77 @@ const STACK_TRACE_START_PATTERNS = [
     /Traceback \(most recent call last\):/i,
     /Exception in thread/i,
     /panic:/i,
+    /thread '.*' panicked at/i,
+    /panicked at/i,
     /Error:\s*$/i,
+    /TypeError:\s*$/i,
+    /ReferenceError:\s*$/i,
+    /AssertionError:\s*$/i,
+    /=== FAILURES ===/i,
+    /=== ERRORS ===/i,
 ];
+/**
+ * Truncates large string output using bounded head and tail windows with a structured metadata receipt.
+ * Preserves early context (e.g. invocation, build targets) and late context (e.g. error summaries, exit codes)
+ * while bounding total character and line count.
+ *
+ * @param text - The raw output text to truncate.
+ * @param options - Configuration options for character/line limits and custom receipt notices.
+ * @returns The windowed text containing head, structured metadata receipt, and tail.
+ */
+export function truncateWithHeadTailWindow(text, options) {
+    if (!text || typeof text !== 'string')
+        return '';
+    const maxChars = options?.maxChars ?? 30_000;
+    const maxLines = options?.maxLines ?? 500;
+    const headRatio = options?.headRatio ?? 0.35;
+    const receiptLabel = options?.receiptLabel ?? 'Output';
+    const hint = options?.hint ?? 'Pipe command to a file and read it in chunks, or use grep.';
+    const lines = text.split(/\r?\n/);
+    if (text.length <= maxChars && lines.length <= maxLines) {
+        return text;
+    }
+    const totalBytes = text.length;
+    const totalLines = lines.length;
+    // Calculate target characters for head and tail windows
+    const receiptReserve = 500;
+    const availableChars = Math.max(1000, maxChars - receiptReserve);
+    const targetHeadChars = Math.floor(availableChars * headRatio);
+    const targetTailChars = availableChars - targetHeadChars;
+    // Max lines for head and tail
+    const targetHeadLines = Math.max(5, Math.floor(maxLines * headRatio));
+    const targetTailLines = Math.max(10, maxLines - targetHeadLines);
+    // Accumulate head lines
+    const headLines = [];
+    let headCharsCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (headLines.length >= targetHeadLines ||
+            (headLines.length > 0 && headCharsCount + line.length + 1 > targetHeadChars)) {
+            break;
+        }
+        headLines.push(line);
+        headCharsCount += line.length + 1;
+    }
+    // Accumulate tail lines backwards (ensuring no overlap with head)
+    const tailLines = [];
+    let tailCharsCount = 0;
+    for (let i = lines.length - 1; i >= headLines.length; i--) {
+        const line = lines[i];
+        if (tailLines.length >= targetTailLines ||
+            (tailLines.length > 0 && tailCharsCount + line.length + 1 > targetTailChars)) {
+            break;
+        }
+        tailLines.unshift(line);
+        tailCharsCount += line.length + 1;
+    }
+    const omittedLines = Math.max(0, totalLines - headLines.length - tailLines.length);
+    const headText = headLines.join('\n');
+    const tailText = tailLines.join('\n');
+    const omittedBytes = Math.max(0, totalBytes - headText.length - tailText.length);
+    const receipt = `\n\n... [${receiptLabel} truncated: ${omittedLines} lines (${omittedBytes} bytes) omitted. Showing ${headLines.length} head lines and ${tailLines.length} tail lines. Total: ${totalLines} lines (${totalBytes} bytes). ${hint}] ...\n\n`;
+    return headText + receipt + tailText;
+}
 /**
  * Condenses verbose command and test failure outputs into high-signal diagnostic error logs
  * with dynamic tail sizing and stack trace boundary snapping.
@@ -1189,14 +1293,30 @@ export function extractHighSignalError(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
+    // Find high-signal error lines and associated compiler frames/context 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);
+            if (!highSignalIndices.has(i)) {
+                highSignalLines.push(line);
+                highSignalIndices.add(i);
+            }
+            // Capture up to 5 immediate compiler frame continuation lines (e.g. code squiggles, expected/found, arrows)
+            for (let j = 1; j <= 5 && i + j < nonNoiseLines.length; j++) {
+                const nextLine = nonNoiseLines[i + j];
+                if (/^\s*(\||-->|\^|~|expected|found|note:|candidate:)/i.test(nextLine) ||
+                    /^\s*\d+\s*\|/.test(nextLine)) {
+                    if (!highSignalIndices.has(i + j)) {
+                        highSignalLines.push(nextLine);
+                        highSignalIndices.add(i + j);
+                    }
+                }
+                else {
+                    break;
+                }
+            }
         }
     }
     // Dynamic tail sizing: Math.min(50, Math.max(15, Math.floor(totalLines * 0.15)))
@@ -1233,7 +1353,15 @@ export function extractHighSignalError(rawError) {
     else {
         resultBlocks.push(tailLines.join('\n'));
     }
-    const condensedResult = resultBlocks.join('\n\n');
+    let condensedResult = resultBlocks.join('\n\n');
+    // Bounded head/tail window check on condensed result if still oversized
+    if (condensedResult.length > 30_000) {
+        condensedResult = truncateWithHeadTailWindow(condensedResult, {
+            maxChars: 30_000,
+            receiptLabel: 'Diagnostic output',
+            hint: 'Pipe to a file if you need full logs.',
+        });
+    }
     const condensedLines = condensedResult.split(/\r?\n/).length;
     const linesPruned = Math.max(0, lines.length - condensedLines);
     const charsPruned = Math.max(0, rawError.length - condensedResult.length);
@@ -1257,26 +1385,25 @@ export async function runCommand(workspaceRoot, command, abortSignal) {
             maxBuffer: 1024 * 1024 * 2, // 2 MB buffer
             signal: abortSignal,
         });
-        let output = [stdout, stderr].filter(Boolean).join('\n');
-        // Truncate command output to prevent memory blowout from massive build logs
-        const MAX_CMD_OUTPUT = 30_000;
-        if (output.length > MAX_CMD_OUTPUT) {
-            output =
-                output.substring(0, MAX_CMD_OUTPUT) +
-                    `\n\n... (Output truncated: ${output.length} bytes exceeded 30KB limit. To view the rest, pipe the command to a file and read it in chunks, or use grep.)`;
-        }
-        return { output: output || '(command produced no output)' };
+        const output = [stdout, stderr].filter(Boolean).join('\n');
+        // Bounded head/tail window truncation with structured metadata receipt
+        const windowedOutput = truncateWithHeadTailWindow(output, {
+            maxChars: 30_000,
+            receiptLabel: 'Output',
+            hint: 'To view the rest, pipe the command to a file and read it in chunks, or use grep.',
+        });
+        return { output: windowedOutput || '(command produced no output)' };
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         // Condense error output with high-signal extraction and dynamic tail sizing
         const condensedError = extractHighSignalError(message);
-        const MAX_ERR_OUTPUT = 30_000;
-        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}` };
+        const windowedError = truncateWithHeadTailWindow(condensedError, {
+            maxChars: 30_000,
+            receiptLabel: 'Error output',
+            hint: 'Pipe to a file if you need full logs.',
+        });
+        return { output: '', error: `Command failed: ${windowedError}` };
     }
 }
 /**
@@ -1305,14 +1432,18 @@ export async function grepSearch(workspaceRoot, pattern, fileGlob, fixedStrings,
         }
         // Use ignore package to evaluate path globs (e.g. src/**/*.ts)
         const globMatcher = fileGlob ? ignore().add(fileGlob) : null;
+        const MAX_SHOWN_MATCHES = 50;
+        const MAX_SCAN_MATCHES = 500;
         const results = [];
+        let totalMatches = 0;
+        const matchedFiles = new Set();
         /**
          * Recursively walks directory entries to search for pattern matches.
          *
          * @param dir - Absolute path to the current directory being searched.
          */
         async function walk(dir) {
-            if (results.length >= 50)
+            if (totalMatches >= MAX_SCAN_MATCHES)
                 return;
             if (abortSignal?.aborted)
                 return;
@@ -1324,7 +1455,7 @@ export async function grepSearch(workspaceRoot, pattern, fileGlob, fixedStrings,
                 return;
             }
             for (const entry of entries) {
-                if (results.length >= 50)
+                if (totalMatches >= MAX_SCAN_MATCHES)
                     return;
                 if (abortSignal?.aborted)
                     return;
@@ -1351,12 +1482,16 @@ export async function grepSearch(workspaceRoot, pattern, fileGlob, fixedStrings,
                         const content = await fs.readFile(filePath, 'utf-8');
                         const lines = content.split(/\r?\n/);
                         for (let i = 0; i < lines.length; i++) {
-                            if (results.length >= 50)
+                            if (totalMatches >= MAX_SCAN_MATCHES)
                                 break;
                             regexPattern.lastIndex = 0;
                             if (regexPattern.test(lines[i])) {
-                                const relativePath = path.relative(workspaceRoot, filePath).replace(/\\/g, '/');
-                                results.push(`${relativePath}:${i + 1}:${lines[i]}`);
+                                totalMatches++;
+                                matchedFiles.add(relPath);
+                                if (results.length < MAX_SHOWN_MATCHES) {
+                                    const relativePath = path.relative(workspaceRoot, filePath).replace(/\\/g, '/');
+                                    results.push(`${relativePath}:${i + 1}:${lines[i]}`);
+                                }
                             }
                         }
                     }
@@ -1373,8 +1508,18 @@ export async function grepSearch(workspaceRoot, pattern, fileGlob, fixedStrings,
         }
         if (results.length === 0)
             return { output: `No matches found for "${pattern}".` };
-        const resultText = results.join('\n') + (results.length >= 50 ? `\n\n... (more results truncated)` : '');
-        const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(resultText)}\n]]\\u200B></content_data>\n</workspace_file>`;
+        let resultText = results.join('\n');
+        if (totalMatches > results.length) {
+            const moreSuffix = totalMatches >= MAX_SCAN_MATCHES ? '+' : '';
+            resultText += `\n\n[Showing ${results.length}/${totalMatches}${moreSuffix} matches across ${matchedFiles.size} files. Refine query with fileGlob or dirPath to narrow results.]`;
+        }
+        // Window large grep text if character count is huge
+        const windowedResult = truncateWithHeadTailWindow(resultText, {
+            maxChars: 30_000,
+            receiptLabel: 'Grep search results',
+            hint: 'Refine query with fileGlob or dirPath to narrow results.',
+        });
+        const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(windowedResult)}\n]]\\u200B></content_data>\n</workspace_file>`;
         return { output: wrappedResult };
     }
     catch (err) {
@@ -1513,6 +1658,12 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
         if (res.exitCode !== 0) {
             finalOutput += `Script failed with exit code ${res.exitCode}.\n`;
         }
+        if (res.structuredResult !== undefined) {
+            const formattedStructured = typeof res.structuredResult === 'string'
+                ? res.structuredResult
+                : JSON.stringify(res.structuredResult, null, 2);
+            finalOutput += `[STRUCTURED RESULT]\n${formattedStructured}\n`;
+        }
         if (res.stdout) {
             finalOutput += `[STDOUT]\n${res.stdout}\n`;
         }
@@ -1523,11 +1674,17 @@ export async function runDebugScript(workspaceRoot, language, code, abortSignal)
             finalOutput = 'Script executed successfully with no output.';
         }
         const condensedOutput = extractHighSignalError(finalOutput.trim());
+        const windowedOutput = truncateWithHeadTailWindow(condensedOutput, {
+            maxChars: 30_000,
+            receiptLabel: 'Debug script output',
+            hint: 'Inspect specific variables or refine script if full logs are needed.',
+        });
         return {
-            output: `<test_results>\n${sanitizeForCDATA(condensedOutput)}\n</test_results>`,
+            output: `<test_results>\n${sanitizeForCDATA(windowedOutput)}\n</test_results>`,
+            ...(res.structuredResult !== undefined ? { structuredResult: res.structuredResult } : {}),
             ...(res.exitCode !== 0
                 ? {
-                    error: `Script failed with exit code ${res.exitCode}:\n${extractHighSignalError(res.stderr || res.stdout || '')}`,
+                    error: `Script failed with exit code ${res.exitCode}:\n${truncateWithHeadTailWindow(extractHighSignalError(res.stderr || res.stdout || ''), { maxChars: 30_000, receiptLabel: 'Debug script error' })}`,
                 }
                 : {}),
         };
@@ -1573,6 +1730,7 @@ export async function executeFuzzProbe(workspaceRoot, code, language = 'node', c
             output += `\n[STDERR]\n${res.stderr}\n`;
         return {
             output: output.trim(),
+            ...(res.structuredResult !== undefined ? { structuredResult: res.structuredResult } : {}),
             ...(res.exitCode !== 0 && !res.passed ? { error: `Fuzz probe failed with exit code ${res.exitCode}` } : {}),
         };
     }
@@ -1616,6 +1774,7 @@ export async function executeHeapDelta(workspaceRoot, code, language = 'node', c
             output += `\n[STDERR]\n${res.stderr}\n`;
         return {
             output: output.trim(),
+            ...(res.structuredResult !== undefined ? { structuredResult: res.structuredResult } : {}),
             ...(res.exitCode !== 0 ? { error: `Heap delta failed with exit code ${res.exitCode}` } : {}),
         };
     }
@@ -1661,6 +1820,7 @@ export async function executeBehavioralDrift(workspaceRoot, baselineCode, candid
             output += `\n[STDERR]\n${res.stderr}\n`;
         return {
             output: output.trim(),
+            ...(res.structuredResult !== undefined ? { structuredResult: res.structuredResult } : {}),
             ...(res.exitCode !== 0 ? { error: `Behavioral drift check failed with exit code ${res.exitCode}` } : {}),
         };
     }
@@ -1727,6 +1887,9 @@ function resolveWorkspaceArgs(primaryRoot, toolName, args) {
 async function crossWorkspaceGrep(primaryRoot, pattern, fileGlob, fixedStrings, dirPath, abortSignal) {
     const allRoots = workspaceRegistry.getAllRoots(primaryRoot);
     const allResults = [];
+    let totalMatches = 0;
+    const matchedFiles = new Set();
+    const MAX_SHOWN_MATCHES = 80;
     for (const { alias, root } of allRoots) {
         const result = await grepSearch(root, pattern, fileGlob, fixedStrings, dirPath, abortSignal);
         if (result.error)
@@ -1740,10 +1903,14 @@ async function crossWorkspaceGrep(primaryRoot, pattern, fileGlob, fixedStrings,
         const prefix = alias ? `@${alias}/` : '';
         const lines = rawText.split('\n').filter((l) => l.trim());
         for (const line of lines) {
-            if (line.startsWith('...')) {
-                allResults.push(line);
+            if (line.startsWith('...') || line.startsWith('[')) {
+                continue;
             }
-            else {
+            totalMatches++;
+            const matchFile = line.split(':')[0];
+            if (matchFile)
+                matchedFiles.add(prefix ? `${prefix}${matchFile}` : matchFile);
+            if (allResults.length < MAX_SHOWN_MATCHES) {
                 // Lines are in format "./path:lineNum:content" — prepend alias prefix
                 allResults.push(prefix ? line.replace(/^\.?\//, `@${alias}/`) : line);
             }
@@ -1752,9 +1919,16 @@ async function crossWorkspaceGrep(primaryRoot, pattern, fileGlob, fixedStrings,
     if (allResults.length === 0) {
         return { output: `No matches found for "${pattern}" across all workspaces.` };
     }
-    const limited = allResults.slice(0, 80);
-    const resultText = limited.join('\n') + (allResults.length > 80 ? `\n\n... (${allResults.length - 80} more results truncated)` : '');
-    const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(resultText)}\n]]\\u200B></content_data>\n</workspace_file>`;
+    let resultText = allResults.join('\n');
+    if (totalMatches > allResults.length) {
+        resultText += `\n\n[Showing ${allResults.length}/${totalMatches} matches across ${matchedFiles.size} files in registered workspaces. Refine query to narrow results.]`;
+    }
+    const windowedResult = truncateWithHeadTailWindow(resultText, {
+        maxChars: 30_000,
+        receiptLabel: 'Cross-workspace grep results',
+        hint: 'Refine query to narrow results.',
+    });
+    const wrappedResult = `<workspace_file path="grep_search_results">\n<content_data><![CDATA[\n${sanitizeForCDATA(windowedResult)}\n]]\\u200B></content_data>\n</workspace_file>`;
     return { output: wrappedResult };
 }
 const currentTasksByAgent = new Map();
@@ -1946,7 +2120,10 @@ export async function executeTool(workspaceRoot, toolName, args, abortSignal) {
             result = await runCommand(effectiveRoot, resolvedArgs.command, abortSignal);
             break;
         case 'run_debug_script':
-            result = await runDebugScript(effectiveRoot, resolvedArgs.language, resolvedArgs.code, abortSignal);
+        case 'debug_script':
+        case 'run_analysis_script':
+        case 'analysis_script':
+            result = await runDebugScript(effectiveRoot, resolvedArgs.language || 'auto', resolvedArgs.code, abortSignal);
             break;
         case 'grep_search': {
             const wsParam = resolvedArgs.workspace;

package/dist/services/agent.js

@@ -32,7 +32,7 @@ import { changeLogger } from './changeLogger.js';
 import { chatHistoryService } from './chatHistoryService.js';
 import { gatherContext, routeIntent, evaluateExecutionComplexity } from './contextAgent.js';
 import { verifyChangedFiles } from './verificationService.js';
-import { buildContextInjection } from '../utils/contextPrompts.js';
+import { buildTieredContextInjection, CONTEXT_BUDGET_CONFIG } from '../utils/contextPrompts.js';
 import { registerContextFiles } from '../utils/fileReadGuard.js';
 import { historyText } from '../utils/historyPrompt.js';
 import { loadUserProfile, formatUserProfileForContext, extractAndSaveUserInsights } from './userProfileService.js';
@@ -391,8 +391,11 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
             if (gatherRes.contextResult) {
                 // Compress each relevant file individually using helper to avoid nested loop warning
                 gatherRes.contextResult.relevantFiles = await compressContextFiles(workspaceRoot, gatherRes.contextResult, ac.signal);
-                // Assemble the final context injection string
-                const contextInjection = buildContextInjection(gatherRes.contextResult);
+                // Assemble the final context injection string using 3-tier IR/graph context ranking
+                const contextInjection = buildTieredContextInjection(gatherRes.contextResult, {
+                    prompt: userInput,
+                    maxChars: CONTEXT_BUDGET_CONFIG.DEFAULT_CONTEXT_MAX_CHARS,
+                });
                 debugLog(`Final compressed context injection size: ${contextInjection.length} chars`);
                 // Pre-register all injected files with the read-guard so the execution
                 // agent is allowed to modify them without calling read_file first.

package/dist/services/ai.d.ts

@@ -18,6 +18,9 @@ export declare function setModelThinkingLevel(model: string, level: ThinkingLeve
  * Resets user-configured thinking levels back to default model presets.
  */
 export declare function resetModelThinkingLevels(): void;
+export declare const HISTORICAL_TOOL_OUTPUT_THRESHOLD = 1500;
+export declare const COLLAPSED_TOOL_OUTPUT_MARKER = "\n... [Historical tool output collapsed to save context]";
+export declare function collapseHistoricalOutput(val: string, threshold?: number): string;
 export declare class ProxyChatSession {
     private history;
     private fullHistory;

package/dist/services/ai.js

@@ -100,9 +100,9 @@ const MAX_HISTORY_ENTRIES = 500;
  * payload stays within sane memory bounds.
  */
 const MAX_PART_TEXT_LENGTH = 60_000;
-const HISTORICAL_TOOL_OUTPUT_THRESHOLD = 1500;
-const COLLAPSED_TOOL_OUTPUT_MARKER = '\n... [Historical tool output collapsed to save context]';
-function collapseHistoricalOutput(val, threshold = HISTORICAL_TOOL_OUTPUT_THRESHOLD) {
+export const HISTORICAL_TOOL_OUTPUT_THRESHOLD = 1500;
+export const COLLAPSED_TOOL_OUTPUT_MARKER = '\n... [Historical tool output collapsed to save context]';
+export function collapseHistoricalOutput(val, threshold = HISTORICAL_TOOL_OUTPUT_THRESHOLD) {
     if (typeof val !== 'string')
         return String(val ?? '');
     if (val.length <= threshold || val.includes('[Historical tool output collapsed')) {
@@ -354,20 +354,10 @@ export class ProxyChatSession {
                         const funcResp = part.functionResponse;
                         if (funcResp.response && typeof funcResp.response === 'object') {
                             const respObj = funcResp.response;
-                            if (typeof respObj.output === 'string') {
-                                respObj.output = collapseHistoricalOutput(respObj.output, threshold);
-                            }
-                            if (typeof respObj.error === 'string') {
-                                respObj.error = collapseHistoricalOutput(respObj.error, threshold);
-                            }
-                            if (typeof respObj.result === 'string') {
-                                respObj.result = collapseHistoricalOutput(respObj.result, threshold);
-                            }
-                            if (typeof respObj.stdout === 'string') {
-                                respObj.stdout = collapseHistoricalOutput(respObj.stdout, threshold);
-                            }
-                            if (typeof respObj.stderr === 'string') {
-                                respObj.stderr = collapseHistoricalOutput(respObj.stderr, threshold);
+                            for (const key of Object.keys(respObj)) {
+                                if (typeof respObj[key] === 'string') {
+                                    respObj[key] = collapseHistoricalOutput(respObj[key], threshold);
+                                }
                             }
                         }
                     }
@@ -701,7 +691,17 @@ export function getContextToolDeclarations() {
                 },
                 {
                     name: 'run_analysis_script',
-                    description: 'Write and execute a disposable analysis script to structurally map code in the workspace. Use this to get exact line ranges for functions, classes, and variables by leveraging the language\'s native AST parser (e.g., TypeScript compiler API, Python ast module, go/parser). You can also use this to probe the development environment — detecting available runtimes (e.g., node --version, python3 --version), checking if ports are in use, identifying project type (monorepo, package manager), or diagnosing system-level issues (disk space, memory) that may affect execution. For complex investigation tasks, you can write lightweight ML scripts (e.g., TF-IDF cosine similarity to rank file relevance, Z-score outlier detection for anomalous log lines, K-Means clustering, or Naive Bayes classification). Default to "node" for generic math/analysis as a safe baseline, but act like a native inhabitant of the host environment — if Python, Go, Rust, or specialized libraries are available in the project context, leverage the host\'s native runtimes and standard libraries for maximum efficiency. The script is executed from a temporary directory and automatically cleaned up after execution. Output should be structured JSON to stdout. Use the results to make precise read_file calls with exact startLine/endLine instead of guessing. CRITICAL: Do not use this tool on binary, document, or non-code files (e.g. PDF, image, audio, docx).',
+                    description: 'Write and execute a disposable analysis script to structurally map code in the workspace. ' +
+                        'Sandbox Features: ' +
+                        '(1) Preloaded Helpers: "emitResult(data)" / "__emitResult(data)" sends structured JSON payloads directly to structuredResult without manual stdout parsing; "inspectSymbols(target)" / "inspectObject(target)" inspects functions, classes, and properties. ' +
+                        '(2) Module & Path Resolution: Automatically inherits tsconfig.json path aliases (@/*), NODE_PATH, and workspace virtualenvs (.venv, venv) for Python. ' +
+                        '(3) Diagnostics Middleware: Provides actionable [SANDBOX DIAGNOSTIC] advisories for missing imports, ESM/CJS interop, and compiler errors. ' +
+                        'Use this to get exact line ranges for functions, classes, and variables by leveraging the language\'s native AST parser (e.g., TypeScript compiler API, Python ast module, go/parser). ' +
+                        'You can also use this to probe the development environment — detecting available runtimes (e.g., node --version, python3 --version), checking if ports are in use, identifying project type (monorepo, package manager), or diagnosing system-level issues (disk space, memory) that may affect execution. ' +
+                        'For complex investigation tasks, you can write lightweight ML scripts (e.g., TF-IDF cosine similarity to rank file relevance, Z-score outlier detection for anomalous log lines, K-Means clustering, or Naive Bayes classification). ' +
+                        'Default to "node" for generic math/analysis as a safe baseline, but act like a native inhabitant of the host environment — if Python, Go, Rust, or specialized libraries are available in the project context, leverage the host\'s native runtimes and standard libraries for maximum efficiency. ' +
+                        'The script is executed from a temporary directory and automatically cleaned up after execution. ' +
+                        'Use the results to make precise read_file calls with exact startLine/endLine instead of guessing. CRITICAL: Do not use this tool on binary, document, or non-code files (e.g. PDF, image, audio, docx).',
                     parameters: {
                         type: SchemaType.OBJECT,
                         properties: {
@@ -711,7 +711,7 @@ export function getContextToolDeclarations() {
                             },
                             code: {
                                 type: SchemaType.STRING,
-                                description: 'The analysis script code. Should output structured JSON to stdout with structural information (name, type, startLine, endLine for each code element).',
+                                description: 'The analysis script code. Should output structured JSON to stdout or use emitResult(data) with structural information (name, type, startLine, endLine for each code element).',
                             },
                             targetFile: {
                                 type: SchemaType.STRING,
@@ -757,13 +757,14 @@ export function createContextAgentSession() {
     let model = contextModelOverride || getGlobalActiveModel();
     if (model === 'auto' || model.includes('claude'))
         model = GEMINI_MODELS.FLASH;
+    const thinkingLevel = getModelThinkingLevel(model);
     return new ProxyChatSession(model, CONTEXT_SYSTEM_INSTRUCTION.replace('{{MULTI_WORKSPACE_BLOCK}}', getMultiWorkspaceBlock()), contextTools, {
         maxOutputTokens: MAX_OUTPUT_TOKENS,
         temperature: contextTempOverride !== null ? contextTempOverride : 1,
         topP: 0.95,
         topK: 40,
         thinkingConfig: {
-            thinkingLevel: 'MEDIUM',
+            thinkingLevel,
         },
     }, {
         functionCallingConfig: {
@@ -1108,6 +1109,50 @@ export function createUserProfileExtractorSession() {
                     },
                     description: 'Observed cognitive decision-making, collaboration, and problem-solving traits',
                 },
+                conversationalPersona: {
+                    type: SchemaType.OBJECT,
+                    properties: {
+                        relationshipModel: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "collaborative-peer", "command-operator", "rubber-duck", "socratic-explorer"',
+                        },
+                        banterAffinity: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "witty-banter", "dry-professional", "warm-encouraging"',
+                        },
+                        formalityLevel: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "casual-slang", "telegraphic-concise", "polite-cordial"',
+                        },
+                        apologyTolerance: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "zero-apologies", "tolerant-empathetic"',
+                        },
+                        stressCadence: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "urgent-surgical", "calm-exploratory"',
+                        },
+                        promptingHabit: {
+                            type: SchemaType.STRING,
+                            description: 'e.g., "code-dump-deducer", "bulleted-architect", "stream-of-consciousness", "rapid-breadcrumbs"',
+                        },
+                        conversationalQuirks: {
+                            type: SchemaType.ARRAY,
+                            items: {
+                                type: SchemaType.STRING,
+                            },
+                            description: 'Observed recurring catchphrases, quirks, or unique conversational habits',
+                        },
+                        removeQuirks: {
+                            type: SchemaType.ARRAY,
+                            items: {
+                                type: SchemaType.STRING,
+                            },
+                            description: 'Outdated or superseded conversational quirks to prune',
+                        },
+                    },
+                    description: 'Observed interpersonal, psychological, and conversational pairing dynamics',
+                },
                 strengths: {
                     type: SchemaType.ARRAY,
                     items: {

package/dist/services/contextAgent.d.ts

@@ -1,14 +1,20 @@
+import type { TierPartitionResult } from '../utils/contextRanker.js';
+export interface ContextFileEntry {
+    text: string;
+    inlineData?: any;
+    scoped?: boolean;
+    tier?: 1 | 2 | 3;
+    outline?: string;
+}
 export interface ContextAgentResult {
     projectTree: string;
     projectType: string;
-    relevantFiles: Map<string, {
-        text: string;
-        inlineData?: any;
-    }>;
+    relevantFiles: Map<string, ContextFileEntry>;
     summary: string;
     webSearchSummary?: string;
     fromMemoryBank?: boolean;
     isParallel?: boolean;
+    tierPartition?: TierPartitionResult;
 }
 export declare function detectProjectType(workspaceRoot: string): Promise<string>;
 export interface IntentRoute {