minovative-mind-cli 2.10.0 → 2.11.0

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));
                         }
                     }
                 }
@@ -1018,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;

package/dist/services/ai.js

@@ -62,6 +62,14 @@ 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) {
+    if (val.length <= threshold || val.includes('[Historical tool output collapsed')) {
+        return val;
+    }
+    return `${val.substring(0, threshold)}${COLLAPSED_TOOL_OUTPUT_MARKER}`;
+}
 function truncatePartText(text) {
     if (text.length <= MAX_PART_TEXT_LENGTH)
         return text;
@@ -117,6 +125,64 @@ export class ProxyChatSession {
         this.fullHistory.push(JSON.parse(JSON.stringify(userContent)));
         this.fullHistory.push(JSON.parse(JSON.stringify(modelContent)));
     }
+    /**
+     * 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) {
+        if (!text || !text.trim())
+            return;
+        const clean = text.replace(/\[TASK_FINISHED\]/g, '').trim();
+        if (!clean)
+            return;
+        // 1. Ensure fullHistory has the model text response
+        if (this.fullHistory.length > 0) {
+            const lastFull = this.fullHistory[this.fullHistory.length - 1];
+            if (lastFull.role === 'model') {
+                const hasText = lastFull.parts?.some((p) => p.text && p.text.trim() === clean);
+                if (!hasText) {
+                    lastFull.parts = lastFull.parts || [];
+                    lastFull.parts.push({ text: clean });
+                }
+            }
+            else {
+                this.fullHistory.push({
+                    role: 'model',
+                    parts: [{ text: clean }],
+                });
+            }
+        }
+        else {
+            this.fullHistory.push({
+                role: 'model',
+                parts: [{ text: clean }],
+            });
+        }
+        // 2. Ensure working history has the model text response
+        if (this.history.length > 0) {
+            const lastHist = this.history[this.history.length - 1];
+            if (lastHist.role === 'model') {
+                const hasText = lastHist.parts?.some((p) => p.text && p.text.trim() === clean);
+                if (!hasText) {
+                    lastHist.parts = lastHist.parts || [];
+                    lastHist.parts.push({ text: clean });
+                }
+            }
+            else {
+                this.history.push({
+                    role: 'model',
+                    parts: [{ text: clean }],
+                });
+            }
+        }
+        else {
+            this.history.push({
+                role: 'model',
+                parts: [{ text: clean }],
+            });
+        }
+    }
     /**
      * Retrieves the most recent conversation history as a formatted string.
      * Useful for passing conversation context to stateless background agents.
@@ -164,6 +230,7 @@ export class ProxyChatSession {
      * conversational context while preventing OOM crashes.
      */
     async pruneHistory() {
+        this.pruneToolOutputHistory();
         if (this.history.length > MAX_HISTORY_ENTRIES) {
             const excess = this.history.length - MAX_HISTORY_ENTRIES;
             const trimCount = excess % 2 === 0 ? excess : excess + 1;
@@ -181,6 +248,46 @@ export class ProxyChatSession {
             }
         }
     }
+    /**
+     * 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 = HISTORICAL_TOOL_OUTPUT_THRESHOLD, turnsToKeep = 1) {
+        // 1 turn = 1 user Content + 1 model Content pair (2 entries)
+        const cutoffIndex = Math.max(0, this.history.length - turnsToKeep * 2);
+        if (cutoffIndex <= 0)
+            return;
+        for (let i = 0; i < cutoffIndex; i++) {
+            const entry = this.history[i];
+            if (entry && entry.role === 'user' && Array.isArray(entry.parts)) {
+                for (const part of entry.parts) {
+                    if (part && typeof part === 'object' && 'functionResponse' in part && part.functionResponse) {
+                        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);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     async sendMessage(message, additionalText, abortSignal, onChunk) {
         const idToken = await getAuthorizedIdToken();
         if (!idToken) {
@@ -773,7 +880,7 @@ export async function generateChatTitle(firstMessage, abortSignal) {
         const contents = [{ role: 'user', parts: [{ text: firstMessage.substring(0, 500) }] }];
         let model = getGlobalActiveModel();
         if (model === 'auto' || model.includes('claude'))
-            model = GEMINI_MODELS.FLASH;
+            model = GEMINI_MODELS.FLASH_LITE;
         const byokEnabled = await isByokEnabled();
         let result;
         if (byokEnabled) {