minovative-mind-cli 2.9.1 → 2.11.0

package/README.md

@@ -89,7 +89,7 @@ Hot-swap during a session using `/models`:
 | Model                     | Best for                                            |
 | ------------------------- | --------------------------------------------------- |
 | **Auto** (default)        | Automatically selects (3.7 Flash or 3.5 Flash Lite) |
-| **Gemini 3.7 Flash**      | Next-gen performance, reasoning & fast execution   |
+| **Gemini 3.7 Flash**      | Next-gen performance, reasoning & fast execution    |
 | **Gemini 3.6 Flash**      | Everyday coding — fast and accurate                 |
 | **Gemini 3.1 Pro**        | Complex architectural changes                       |
 | **Gemini 3.5 Flash Lite** | Best for speed and cost efficiency                  |
@@ -101,11 +101,19 @@ If you prefer to use your own API key instead of credits, you can configure it v
 - **Configuration:** Use `/config-key` in the chat session to set and manage your API key.
 - **Error Handling:** If your key is invalid, expired, or you hit rate limits, the CLI will report a `BYOK AI Error`. Please check your API key status in the [Google AI Studio dashboard](https://aistudio.google.com).
 
-> Background tasks (routing, history summarization, context compression, commits) always use lightweight
-> models automatically. You pay for those lightweight model
-> background ai models and for your selected model
-> during chat and code execution.
-> Use `/debug` to see exactly what's running.
+### Auxiliary Model Routing Defaults
+
+Background tasks automatically route to dedicated auxiliary models with native `responseSchema` constraints for optimal latency, cost efficiency, and structured output reliability:
+
+- **Intent Router (`routeIntent`)**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`) — zero-temperature classification of `SEARCH` vs `SKIP` and `CHAT` vs `EXECUTE`.
+- **Complexity Evaluators**: `Gemini 3.7 Flash` (Temp 0, native `responseSchema`) — domain partitioning and parallel execution wave feasibility.
+- **Context Compressor**: `Gemini 3.7 Flash` (Temp 0.2) — surgical code distillation for files exceeding 2,000 characters.
+- **Session Titling**: `Gemini 3.7 Flash` (Temp 0.7, native `responseSchema`) — automated concise chat session titling.
+- **Semantic Cache Classifier**: `Gemini 3.5 Flash Lite` (Temp 0, native `responseSchema`) — intent and topic classification for cache hits.
+- **History Summarizer**: `Gemini 3.7 Flash` (Temp 0.2) — 3-part structured conversation compression preserving recent history.
+- **Commit Generator**: `Gemini 3.5 Flash Lite` — conventional commit message synthesis.
+
+> You pay for auxiliary model background AI operations and for your selected model during chat and code execution. Use `/debug` to inspect real-time routing diagnostics.
 
 ---
 

package/dist/services/agent/commandApproval.js

@@ -33,6 +33,9 @@ export function isCommandDestructive(command) {
         // Massive permission shifts (chmod 777, recursive chowns)
         /\bchmod\s+(?:-[R\w]*\s+)?777\b/i,
         /\bchown\s+-[R\w]*\b/i,
+        // Privileged root escalation commands (require explicit interactive password / system-level access)
+        /\bsudo\b/i,
+        /\bsu\s+/i,
     ];
     return destructivePatterns.some((pattern) => pattern.test(command));
 }
@@ -49,10 +52,10 @@ export function isCommandSafe(command) {
         /^\s*echo\b/i,
         /^\s*grep\b/i,
         /^\s*find\b/i,
-        /^\s*npm\s+(install|i|ci|run\b)/i,
+        /^\s*npm\s+(install|i|ci|run\b|test\b|t\b)/i,
         /^\s*yarn\s+(install|add|build|lint|test|run\b)/i,
         /^\s*pnpm\s+(install|i|add|build|lint|test|run\b)/i,
-        /^\s*bun\s+(install|i|add|run\b)/i,
+        /^\s*bun\s+(install|i|add|run\b|test\b)/i,
         /^\s*cargo\s+(build|check|add|test|run\b)/i,
         /^\s*go\s+(mod|get|build|test|run\b)/i,
         /^\s*pip\s+(install|list|show)\b/i,

package/dist/services/agent/slashCommands.js

@@ -563,73 +563,87 @@ export async function handleSlashCommand(command, context) {
                 p.log.info(`${pc.dim('Workspace:')} ${brandFg(workspaceRoot)}`);
                 p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu and "${pc.yellow('stop')}" to stop the ai generation. Type ${pc.yellow('exit')} to leave.`);
                 p.log.success(`Resumed session: ${session.title}`);
-                // Print the loaded history so the user can see past context
-                let sessionTasks = [];
+                // Print the loaded history cleanly: only user and AI conversational messages,
+                // with a clean indicator label if the turn involved tool/code changes.
+                let turnHadModifications = false;
+                let turnHadInspections = false;
+                let renderedIndicatorForTurn = false;
                 for (const item of session.history) {
                     if (item.role === 'user') {
+                        const hasFunctionResponse = item.parts?.some((p) => p.functionResponse);
+                        if (hasFunctionResponse) {
+                            // Internal tool response from the execution loop — do not display as a user message
+                            continue;
+                        }
                         const textParts = item.parts
-                            .filter((p) => p.text)
+                            ?.filter((p) => p.text)
                             .map((p) => p.text)
                             .join('');
-                        if (textParts && !textParts.includes('SYSTEM CHECK: Please objectively verify')) {
+                        if (textParts &&
+                            !textParts.includes('SYSTEM CHECK: Please objectively verify') &&
+                            !textParts.includes('[PREVIOUS CONVERSATION SUMMARY]') &&
+                            !textParts.startsWith('[USER INTERRUPTION]')) {
+                            // Reset turn tool flags for the new user prompt
+                            turnHadModifications = false;
+                            turnHadInspections = false;
+                            renderedIndicatorForTurn = false;
                             p.log.step(pc.bgBlue(pc.white(` ${textParts} `)));
                         }
                     }
                     else if (item.role === 'model') {
-                        // First, print all function calls
-                        for (const part of item.parts) {
+                        // Track if any tool actions were called in this turn
+                        for (const part of item.parts || []) {
                             if (part.functionCall) {
-                                const call = part.functionCall;
-                                p.log.message(`◇  ${pc.blue('🔧')} ${pc.bold(call.name)}`);
-                                const args = (call.args || {});
-                                if (call.name === 'create_todo_list' && Array.isArray(args.tasks)) {
-                                    sessionTasks = args.tasks;
-                                    p.log.message(pc.bold(pc.cyan('  📋 Agent Task List:')));
-                                    args.tasks.forEach((task, index) => {
-                                        p.log.message(`    ${pc.dim(`[ ] ${index + 1}.`)} ${task}`);
-                                    });
-                                }
-                                else if (call.name === 'update_todo_status') {
-                                    const status = args.status;
-                                    const taskIndex = args.taskIndex;
-                                    const taskText = sessionTasks[taskIndex - 1] || 'completed';
-                                    let icon = '[ ]';
-                                    let color = pc.dim;
-                                    if (status?.toLowerCase() === 'completed' || status?.toLowerCase() === 'done') {
-                                        icon = '[x]';
-                                        color = pc.green;
-                                    }
-                                    else if (status?.toLowerCase() === 'in_progress' || status?.toLowerCase() === 'started') {
-                                        icon = '[/]';
-                                        color = pc.yellow;
-                                    }
-                                    else if (status?.toLowerCase() === 'failed' || status?.toLowerCase() === 'error') {
-                                        icon = '[!]';
-                                        color = pc.red;
-                                    }
-                                    p.log.message(color(`    ${icon} ${taskIndex}. ${taskText}`));
+                                const name = part.functionCall.name;
+                                if (name === 'modify_file' ||
+                                    name === 'write_file' ||
+                                    name === 'delete_file' ||
+                                    name === 'rename_file' ||
+                                    name === 'run_command') {
+                                    turnHadModifications = true;
                                 }
-                                else {
-                                    let argsStr = '';
-                                    try {
-                                        argsStr = JSON.stringify(args);
-                                    }
-                                    catch (e) {
-                                        argsStr = String(call.args);
-                                    }
-                                    const argsPreview = argsStr.slice(0, 50);
-                                    p.log.message(pc.dim(`  ├─ Executed tool`));
+                                else if (name === 'read_file' ||
+                                    name === 'grep_search' ||
+                                    name === 'list_directory' ||
+                                    name === 'find_dependencies') {
+                                    turnHadInspections = true;
                                 }
                             }
                         }
-                        // Then aggregate and print all text
-                        const textParts = item.parts
+                        // Aggregate and extract model conversational text
+                        let textParts = (item.parts || [])
                             .filter((p) => p.text && !p.text.includes('[TASK_FINISHED]'))
                             .map((p) => p.text)
                             .join('');
-                        if (textParts.trim()) {
+                        // Backward-compatibility: if text is empty, check finish_task args.summary
+                        if (!textParts.trim()) {
+                            const finishCall = (item.parts || []).find((p) => p.functionCall?.name === 'finish_task');
+                            const finishArgs = finishCall?.functionCall?.args;
+                            if (finishArgs?.summary) {
+                                textParts = String(finishArgs.summary);
+                            }
+                        }
+                        if (textParts.includes('[ORCHESTRATOR_EXECUTION]')) {
+                            turnHadModifications = true;
+                        }
+                        const cleanText = textParts
+                            .replace(/\[TASK_FINISHED\]/g, '')
+                            .replace(/\[ORCHESTRATOR_EXECUTION\]\n?/g, '')
+                            .replace(/\[PREVIOUS CONVERSATION SUMMARY\]:[\s\S]*?(?=\n\n|$)/g, '')
+                            .trim();
+                        if (cleanText) {
+                            if (!renderedIndicatorForTurn) {
+                                if (turnHadModifications) {
+                                    p.log.message(pc.dim('  ⚡ [Mino applied workspace modifications & commands]'));
+                                    renderedIndicatorForTurn = true;
+                                }
+                                else if (turnHadInspections) {
+                                    p.log.message(pc.dim('  🔍 [Inspected workspace context]'));
+                                    renderedIndicatorForTurn = true;
+                                }
+                            }
                             console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim('(History)')}\n`);
-                            console.log(renderTerminalMarkdown(textParts));
+                            console.log(renderTerminalMarkdown(cleanText));
                         }
                     }
                 }
@@ -715,7 +729,7 @@ export async function handleSlashCommand(command, context) {
         }
         else if (chatsMenu === 'bulk-delete') {
             const selectedIds = await p['multiselect']({
-                message: 'Select chat sessions to delete:',
+                message: `Select chat sessions to delete: ${pc.dim('(Press Esc to go back / cancel)')}`,
                 options: sessions
                     .slice()
                     .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
@@ -723,7 +737,7 @@ export async function handleSlashCommand(command, context) {
                     value: s.id,
                     label: `${truncate(s.title, 50)} (${new Date(s.timestamp).toLocaleString()})`,
                 })),
-                required: true,
+                required: false,
             });
             if (p.isCancel(selectedIds) || !Array.isArray(selectedIds) || selectedIds.length === 0) {
                 p.log.warn('Bulk delete canceled.');
@@ -735,6 +749,16 @@ export async function handleSlashCommand(command, context) {
             if (confirm) {
                 await chatHistoryService.bulkDeleteSessions(selectedIds);
                 p.log.success(`Successfully deleted ${selectedIds.length} session(s).`);
+                if (chatSessionState && selectedIds.includes(chatSessionState.id)) {
+                    chat.clearHistory();
+                    process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
+                    printLogo();
+                    p.intro(`${brandBg(' Minovative Mind CLI ')} ${pc.dim('v' + version)}`);
+                    p.log.info(`${pc.dim('Workspace:')} ${brandFg(workspaceRoot)}`);
+                    p.log.info(`${pc.dim('Commands:')} Type ${pc.yellow('/')} to open the command menu and "${pc.yellow('stop')}" to stop the ai generation. Type ${pc.yellow('exit')} to leave.`);
+                    p.log.warn('Active session was deleted. Chat history cleared.');
+                    console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
+                }
             }
             else {
                 p.log.warn('Bulk delete canceled.');
@@ -1008,10 +1032,23 @@ export async function handleSlashCommand(command, context) {
 <diff>
 ${diffOut}
 </diff>`;
-            const commitSystemPrompt = 'You are an expert developer. Output only the git commit message, no markdown formatting, no explanations. Follow Conventional Commits format (feat:, fix:, chore:, refactor:, etc.) for the first line, keeping it under 70 characters and using the imperative mood. Then, add a blank line followed by a more descriptive bulleted list explaining the "what" and "why" of the changes based on the diff.';
+            const commitSystemPrompt = `You are a strict Conventional Commits generator and expert software engineer.
+Output ONLY the raw commit message text. Absolutely NO conversational preambles, NO markdown code blocks (e.g. no \`\`\`), and NO post-explanations.
+
+Strict Formatting Rules:
+1. First line must follow Conventional Commits format: type(scope): description
+   - Allowed types: feat, fix, refactor, test, docs, chore, perf, style
+   - Subject line must be in imperative mood (e.g. "add support for...", "fix bug in...") and strictly under 50 characters.
+2. Leave a single blank line after the subject.
+3. Provide a concise bulleted list (using '-' or '*') explaining the architectural "what" and "why" of the changes based on the provided diff. If diff spans multiple areas, prioritize the primary architectural change.`;
             const commitAgent = new ProxyChatSession(GEMINI_MODELS.FLASH_LITE, commitSystemPrompt, [], {});
             const commitResult = await commitAgent.sendMessage(prompt);
-            const commitMsg = commitResult.response.text().trim();
+            let commitMsg = commitResult.response.text().trim();
+            // Sanitize markdown fences if model included them despite instructions
+            commitMsg = commitMsg
+                .replace(/^```[a-zA-Z]*\n?/gm, '')
+                .replace(/```\s*$/gm, '')
+                .trim();
             commitSpinner.message('Committing...');
             const tmpMsgPath = path.join(workspaceRoot, '.gemini-commit-msg.tmp');
             await fs.writeFile(tmpMsgPath, commitMsg, 'utf-8');

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

@@ -180,11 +180,12 @@ export declare function traceDependencies(workspaceRoot: string, filePath: strin
  */
 export declare function findRecentChanges(workspaceRoot: string, dirPath?: string, minutes?: number, maxDepth?: number): Promise<ToolResult>;
 /**
- * Writes a disposable scratchpad script to a temporary file, executes it using the specified runtime,
- * and returns standard output and standard error.
+ * Executes an ephemeral debugging or validation script in the specified language runtime.
+ * Delegates to the sandboxed ephemeral script runner in `os.tmpdir()` with automatic ESM/CJS
+ * module resolution and multi-language runtime detection.
  *
  * @param workspaceRoot - Absolute path to the workspace root directory.
- * @param language - Runtime language (`'node'`, `'ts-node'`, `'python'`, `'bash'`, `'go'`, or `'rust'`).
+ * @param language - Runtime language (`'node'`, `'ts-node'`, `'python'`, `'bash'`, `'go'`, `'rust'`, `'c'`, `'cpp'`, `'ruby'`, `'php'`, `'java'`, or `'auto'`).
  * @param code - The exact script source code to execute.
  * @param abortSignal - Optional AbortSignal to cancel execution.
  * @returns A promise resolving to a {@link ToolResult} containing execution output.

package/dist/services/agent-tools.js

@@ -13,7 +13,6 @@
  */
 import { exec } from 'node:child_process';
 import { promises as fs } from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { SchemaType } from '@google/generative-ai';
@@ -31,7 +30,7 @@ import { extractSymbols } from '../utils/symbolExtractor.js';
 import { getMetricCollector } from './metrics.js';
 import { getCurrentAgentId } from '../utils/asyncContext.js';
 import { recordFileRead, hasAgentReadFile } from '../utils/fileReadGuard.js';
-import { runFuzzProbe, checkHeapDelta as runCheckHeapDelta, checkBehavioralDrift as runCheckBehavioralDrift, } from '../utils/analysisRunner.js';
+import { runFuzzProbe, checkHeapDelta as runCheckHeapDelta, checkBehavioralDrift as runCheckBehavioralDrift, runEphemeralScript, } from '../utils/analysisRunner.js';
 import ignore from 'ignore';
 const execAsync = promisify(exec);
 // ─── Tool Declarations for Gemini Function Calling ───────────────────
@@ -1112,6 +1111,13 @@ export async function listDirectory(workspaceRoot, dirPath, maxDepth = 3) {
  * @returns A promise resolving to a {@link ToolResult} containing stdout/stderr or an error.
  */
 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)) {
+        return {
+            output: '',
+            error: "Execution blocked: Commands requiring 'sudo' or root privileges cannot be executed automatically in background tool loops. Please explain to the user in your text response that they must run this command manually in their own terminal.",
+        };
+    }
     try {
         const { stdout, stderr } = await execAsync(command, {
             cwd: workspaceRoot,
@@ -1351,102 +1357,49 @@ export async function findRecentChanges(workspaceRoot, dirPath = '.', minutes =
 }
 // ─── Tool Dispatcher ─────────────────────────────────────────────────
 /**
- * Writes a disposable scratchpad script to a temporary file, executes it using the specified runtime,
- * and returns standard output and standard error.
+ * Executes an ephemeral debugging or validation script in the specified language runtime.
+ * Delegates to the sandboxed ephemeral script runner in `os.tmpdir()` with automatic ESM/CJS
+ * module resolution and multi-language runtime detection.
  *
  * @param workspaceRoot - Absolute path to the workspace root directory.
- * @param language - Runtime language (`'node'`, `'ts-node'`, `'python'`, `'bash'`, `'go'`, or `'rust'`).
+ * @param language - Runtime language (`'node'`, `'ts-node'`, `'python'`, `'bash'`, `'go'`, `'rust'`, `'c'`, `'cpp'`, `'ruby'`, `'php'`, `'java'`, or `'auto'`).
  * @param code - The exact script source code to execute.
  * @param abortSignal - Optional AbortSignal to cancel execution.
  * @returns A promise resolving to a {@link ToolResult} containing execution output.
  */
 export async function runDebugScript(workspaceRoot, language, code, abortSignal) {
-    const extMap = {
-        node: '.js',
-        'ts-node': '.ts',
-        python: '.py',
-        bash: '.sh',
-        go: '.go',
-        rust: '.rs',
-    };
-    const ext = extMap[language.toLowerCase()] || '.txt';
-    const tmpFileName = `.minovative-scratch${ext}`;
-    const absPath = path.join(workspaceRoot, tmpFileName);
     try {
         const p = await import('@clack/prompts');
         const pc = (await import('picocolors')).default;
-        p.log.info(pc.dim(`🛠️ Running temporary ${language} debug script...`));
-        await fs.writeFile(absPath, code, 'utf-8');
-        let cmd = '';
-        switch (language.toLowerCase()) {
-            case 'node':
-                cmd = `node ${tmpFileName}`;
-                break;
-            case 'ts-node':
-                cmd = `npx ts-node ${tmpFileName}`;
-                break;
-            case 'python':
-                cmd = `python3 ${tmpFileName}`;
-                break;
-            case 'bash':
-                cmd = `bash ${tmpFileName}`;
-                break;
-            case 'go':
-                cmd = `go run ${tmpFileName}`;
-                break;
-            case 'rust': {
-                const binExt = os.platform() === 'win32' ? '.exe' : '';
-                const binPath = tmpFileName.replace('.rs', binExt);
-                const runCmd = os.platform() === 'win32' ? binPath : `./${binPath}`;
-                cmd = `rustc ${tmpFileName} -o ${binPath} && ${runCmd}`;
-                break;
-            }
-            default:
-                return { output: '', error: `Unsupported language runtime: ${language}` };
+        p.log.info(pc.dim(`🛠️ Running temporary ${language || 'script'} debug script...`));
+        const res = await runEphemeralScript(workspaceRoot, language || 'auto', code, {
+            abortSignal,
+            timeoutMs: 60_000,
+        });
+        let finalOutput = '';
+        if (res.exitCode !== 0) {
+            finalOutput += `Script failed with exit code ${res.exitCode}.\n`;
         }
-        try {
-            const { stdout, stderr } = await execAsync(cmd, { cwd: workspaceRoot, timeout: 60_000, signal: abortSignal });
-            const out = stdout.trim();
-            const errOut = stderr.trim();
-            let finalOutput = '';
-            if (out)
-                finalOutput += `[STDOUT]\n${out}\n`;
-            if (errOut)
-                finalOutput += `[STDERR]\n${errOut}\n`;
-            if (!finalOutput)
-                finalOutput = 'Script executed successfully with no output.';
-            return { output: `<test_results>\n${sanitizeForCDATA(finalOutput)}\n</test_results>` };
+        if (res.stdout) {
+            finalOutput += `[STDOUT]\n${res.stdout}\n`;
         }
-        catch (err) {
-            const out = (err.stdout || '').trim();
-            const errOut = (err.stderr || '').trim();
-            let finalOutput = `Script failed with exit code ${err.code || 1}.\n`;
-            if (out)
-                finalOutput += `[STDOUT]\n${out}\n`;
-            if (errOut)
-                finalOutput += `[STDERR]\n${errOut}\n`;
-            return { output: `<test_results>\n${sanitizeForCDATA(finalOutput)}\n</test_results>` };
+        if (res.stderr) {
+            finalOutput += `[STDERR]\n${res.stderr}\n`;
         }
+        if (!finalOutput.trim()) {
+            finalOutput = 'Script executed successfully with no output.';
+        }
+        return {
+            output: `<test_results>\n${sanitizeForCDATA(finalOutput.trim())}\n</test_results>`,
+            ...(res.exitCode !== 0 ? { error: `Script failed with exit code ${res.exitCode}` } : {}),
+        };
     }
     catch (err) {
         return {
             output: '',
-            error: `Failed to create or run test script: ${err instanceof Error ? err.message : String(err)}`,
+            error: `Failed to execute debug script: ${err instanceof Error ? err.message : String(err)}`,
         };
     }
-    finally {
-        try {
-            await fs.rm(absPath, { force: true });
-            if (language.toLowerCase() === 'rust') {
-                const binExt = os.platform() === 'win32' ? '.exe' : '';
-                const binPath = absPath.replace('.rs', binExt);
-                await fs.rm(binPath, { force: true });
-            }
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    }
 }
 /**
  * Executes a fuzz probing analysis script and formats the resulting pass/fail and crash statistics.

package/dist/services/agent.d.ts

@@ -112,15 +112,14 @@ export declare function executeSingleTurn(workspaceRoot: string, userInput: stri
 } | void>;
 /**
  * Raw chat history entry count threshold to trigger chat history summarization.
- * 50 entries = 25 conversational user/model turns.
+ * 2 entries = 1 complete conversational user/model turn.
  */
-export declare const HISTORY_SUMMARIZATION_THRESHOLD = 50;
+export declare const HISTORY_SUMMARIZATION_THRESHOLD = 2;
 /**
- * Summarizes older chat history entries if the active session's history
- * exceeds {@link HISTORY_SUMMARIZATION_THRESHOLD} entries.
+ * Summarizes chat history entries starting from the first full user/model turn.
  *
- * Preserves the most recent 20 entries (10 turns) intact for conversational continuity,
- * replacing all preceding turns with a single summarized pair in the chat history.
+ * Compresses preceding conversation history into a structured high-density summary pair
+ * in the active session while permanently preserving uncompressed history in fullHistory.
  *
  * @param chat - The active ProxyChatSession instance.
  * @returns A promise resolving to true if history was summarized and updated; false otherwise.

package/dist/services/agent.js

@@ -544,7 +544,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                             parts: [{ text: userInput }],
                         }, {
                             role: 'model',
-                            parts: [{ text: handledByOrchestrator }],
+                            parts: [{ text: `[ORCHESTRATOR_EXECUTION]\n${handledByOrchestrator}` }],
                         });
                         // Print the summary text just like single-agent mode
                         console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(Orchestrator)`)}\n`);
@@ -670,6 +670,7 @@ export async function executeSingleTurn(workspaceRoot, userInput, chat, inputHan
                 if (cleanFinalText) {
                     console.log(`\n${pc.blue('◆')} ${pc.bold('Minovative Mind')} ${pc.dim(`(${chat.getModel()})`)}\n`);
                     console.log(renderTerminalMarkdown(cleanFinalText));
+                    chat.appendFinalSummary(cleanFinalText);
                 }
             }
             if (usage) {
@@ -989,15 +990,14 @@ async function compressContextFiles(workspaceRoot, contextResult) {
 }
 /**
  * Raw chat history entry count threshold to trigger chat history summarization.
- * 50 entries = 25 conversational user/model turns.
+ * 2 entries = 1 complete conversational user/model turn.
  */
-export const HISTORY_SUMMARIZATION_THRESHOLD = 50;
+export const HISTORY_SUMMARIZATION_THRESHOLD = 2;
 /**
- * Summarizes older chat history entries if the active session's history
- * exceeds {@link HISTORY_SUMMARIZATION_THRESHOLD} entries.
+ * Summarizes chat history entries starting from the first full user/model turn.
  *
- * Preserves the most recent 20 entries (10 turns) intact for conversational continuity,
- * replacing all preceding turns with a single summarized pair in the chat history.
+ * Compresses preceding conversation history into a structured high-density summary pair
+ * in the active session while permanently preserving uncompressed history in fullHistory.
  *
  * @param chat - The active ProxyChatSession instance.
  * @returns A promise resolving to true if history was summarized and updated; false otherwise.
@@ -1008,12 +1008,8 @@ export async function summarizeHistoryIfNeeded(chat, abortSignal) {
         return false;
     }
     try {
-        // Keep the most recent 20 entries (10 full user/model turns) intact
-        const recentCount = 20;
-        const olderHistory = history.slice(0, history.length - recentCount);
-        const recentHistory = history.slice(history.length - recentCount);
-        debugLog(`Summarizing ${olderHistory.length} older chat history entries...`);
-        const summaryText = await summarizeChatHistory(olderHistory, abortSignal);
+        debugLog(`Summarizing ${history.length} chat history entries (Flash-Lite Summarizer triggered after first turn)...`);
+        const summaryText = await summarizeChatHistory(history, abortSignal);
         if (summaryText && summaryText.trim().length > 0) {
             const summaryContent = [
                 {
@@ -1025,8 +1021,8 @@ export async function summarizeHistoryIfNeeded(chat, abortSignal) {
                     parts: [{ text: 'Understood. I have reviewed and absorbed the summary of our preceding conversation.' }],
                 },
             ];
-            chat.loadCompressedHistory([...summaryContent, ...recentHistory]);
-            debugLog(`Chat history compressed successfully from ${history.length} to ${summaryContent.length + recentHistory.length} entries.`);
+            chat.loadCompressedHistory(summaryContent);
+            debugLog(`Chat history compressed successfully from ${history.length} to ${summaryContent.length} entries.`);
             return true;
         }
     }

package/dist/services/ai.d.ts

@@ -22,6 +22,12 @@ export declare class ProxyChatSession {
     loadRawHistory(history: Content[]): void;
     loadCompressedHistory(history: Content[]): void;
     addTurn(userContent: Content, modelContent: Content): void;
+    /**
+     * Appends or merges the final conversational summary text into the active session history.
+     * Ensures that the final response produced by finish_task, PM reconciliation, or final turns
+     * is permanently preserved as a model text response in both working history and full transcript.
+     */
+    appendFinalSummary(text: string): void;
     /**
      * Retrieves the most recent conversation history as a formatted string.
      * Useful for passing conversation context to stateless background agents.
@@ -42,6 +48,19 @@ export declare class ProxyChatSession {
      * conversational context while preventing OOM crashes.
      */
     private pruneHistory;
+    /**
+     * Collapses oversized functionResponse outputs in historical turns (>1 turn old)
+     * while strictly maintaining Gemini functionCall and functionResponse pairing.
+     *
+     * Gemini requires every functionCall in a model turn to have a matching functionResponse
+     * in the immediately following user turn. Deleting parts or entries breaks this invariant and
+     * causes 400 Bad Request errors. This method mutates oversized response outputs in-place
+     * on older turns to drastically conserve context window tokens.
+     *
+     * @param threshold Maximum characters allowed for a historical tool response before collapsing (default: 1500).
+     * @param turnsToKeep Number of recent turns to preserve unpruned (default: 1).
+     */
+    pruneToolOutputHistory(threshold?: number, turnsToKeep?: number): void;
     sendMessage(message: string | Array<{
         functionResponse: {
             name: string;
@@ -77,7 +96,7 @@ export declare function getPlanModeConfig(): {
     tools: never[];
 };
 /**
- * Compresses a large string of text using gemini-3.5-flash-lite.
+ * Compresses a large string of text using Gemini Flash.
  * Used for shrinking context payloads to prevent OOM/choking.
  */
 export declare function compressTextUsingFlashLite(text: string, instruction?: string, inlineData?: any, force?: boolean, abortSignal?: AbortSignal): Promise<string>;
@@ -91,6 +110,7 @@ export declare function createContextAgentSession(): any;
 export declare function createIntentRouterSession(): any;
 export declare function createExecutionComplexitySession(): any;
 export declare function createInvestigationComplexitySession(): any;
+export declare function createInvestigationSemanticSession(): any;
 export declare function createWebSearchAgentSession(): any;
 export declare function createHistorySummarizerSession(): any;
 /**