minovative-mind-cli 2.10.0 → 2.11.2

package/README.md

@@ -122,6 +122,7 @@ Background tasks automatically route to dedicated auxiliary models with native `
 | Command         | What it does                                                                                                                                    |
 | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
 | `/config-key`   | Configure custom Google AI Studio API key (BYOK mode)                                                                                           |
+| `/profile`      | View, inspect, delete, or reset global adaptive persona memory and AI side-notes                                                                |
 | `/models`       | Hot-swap the active model                                                                                                                       |
 | `/plan`         | Toggle plan mode to review implementation strategies                                                                                            |
 | `/paste`        | Multi-line input mode (cancel with Ctrl+C)                                                                                                      |

package/dist/commands/chat.d.ts

@@ -9,7 +9,7 @@ import { Command } from '@oclif/core';
 export default class DefaultCommand extends Command {
     /**
      * The description displayed in the CLI help output.
-     * Details all supported slash commands (/config-key, /paste, /plan, /clear, /models,
+     * Details all supported slash commands (/config-key, /profile, /paste, /plan, /clear, /models,
      * /debug, /auto-approve, /sub-agents, /stats, /revert, /chats, /workspaces, /commit)
      * along with interactive chat controls.
      */

package/dist/commands/chat.js

@@ -17,7 +17,7 @@ import { updateWorkspaceStatus } from '../services/workspace.js';
 export default class DefaultCommand extends Command {
     /**
      * The description displayed in the CLI help output.
-     * Details all supported slash commands (/config-key, /paste, /plan, /clear, /models,
+     * Details all supported slash commands (/config-key, /profile, /paste, /plan, /clear, /models,
      * /debug, /auto-approve, /sub-agents, /stats, /revert, /chats, /workspaces, /commit)
      * along with interactive chat controls.
      */
@@ -25,6 +25,7 @@ export default class DefaultCommand extends Command {
 
 Inside the chat session, you can use the following commands in the slash menu:
   /config-key    - BYOK — Configure, clear, or view status of custom Google AI Studio API key
+  /profile       - View, inspect, delete, or reset global adaptive persona memory and AI side-notes
   /paste         - Enter multi-line paste mode for long code snippets and prompts
   /plan          - Toggle plan mode to review step-by-step implementation strategies
   /clear         - Clear conversation history, reset terminal screen, and display logo

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

@@ -17,12 +17,14 @@ import { checkByokSubscription } from '../auth.js';
 import { GEMINI_MODELS, isByokEnabled } from '../../utils/config.js';
 import { loadCredentials, updateCredentialField } from '../../utils/credentialStore.js';
 import { getGlobalActiveModel, setGlobalActiveModel, ProxyChatSession } from '../ai.js';
+import { loadUserProfile, deleteSideNote, clearUserProfile, getUserProfilePath, } from '../userProfileService.js';
 /**
  * @file slashCommands.ts
  * @description Interactive slash command handler module for Minovative Mind CLI.
  *
  * Supported slash commands:
  * - `/config-key`  : Configure, validate, toggle, or clear Bring Your Own Key (BYOK) Google AI Studio API credentials.
+ * - `/profile`     : View, inspect, delete, or reset global adaptive persona memory and AI side-notes.
  * - `/paste`       : Enter multi-line paste mode using EOF tracking (`Ctrl+D` submission).
  * - `/plan`        : Toggle AI step-by-step implementation planning mode.
  * - `/clear`       : Clear conversation history, wipe terminal screen, and reset CLI header.
@@ -563,73 +565,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 +1034,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');
@@ -1119,5 +1148,138 @@ ${diffOut}
         }
         return { shouldContinue: true };
     }
+    /**
+     * `/profile` - Displays and manages global adaptive user profile traits, persona memory, and AI side-notes.
+     */
+    if (lowerCommand === '/profile') {
+        const profile = await loadUserProfile();
+        const action = await p.select({
+            message: 'Adaptive User Profile & AI Memory Bank:',
+            options: [
+                {
+                    value: 'view',
+                    label: 'View Profile & Observations',
+                    hint: `${profile.agentNotes.length} side-note(s) recorded`,
+                },
+                {
+                    value: 'delete_note',
+                    label: 'Delete Specific Side-Note',
+                    hint: 'Select and remove an individual note',
+                },
+                {
+                    value: 'clear_all',
+                    label: 'Reset Profile & Clear Memory',
+                    hint: 'Wipe all persona traits and side-notes',
+                },
+                { value: 'cancel', label: 'Back to Chat', hint: 'Return to active session' },
+            ],
+        });
+        if (p.isCancel(action) || action === 'cancel') {
+            return { shouldContinue: true };
+        }
+        if (action === 'view') {
+            const hasStyle = profile.communicationStyle?.tonePreference ||
+                profile.communicationStyle?.verbosity ||
+                profile.communicationStyle?.formulationStyle;
+            const hasCognitive = profile.cognitiveTraits?.architecturalStyle ||
+                profile.cognitiveTraits?.decisionPreference ||
+                profile.cognitiveTraits?.riskTolerance ||
+                profile.cognitiveTraits?.delegationDepth ||
+                profile.cognitiveTraits?.debuggingStyle ||
+                profile.cognitiveTraits?.explanationFormat;
+            const hasStrengths = profile.technicalPreferences?.strengths && profile.technicalPreferences.strengths.length > 0;
+            const hasConventions = profile.technicalPreferences?.conventions && profile.technicalPreferences.conventions.length > 0;
+            const hasNotes = profile.agentNotes && profile.agentNotes.length > 0;
+            console.log(`\n${pc.bold(pc.cyan('🧠 Global Adaptive User Profile & Persona Memory'))}`);
+            console.log(`${pc.dim('Storage:')} ${pc.dim(getUserProfilePath())}\n`);
+            if (!hasStyle && !hasCognitive && !hasStrengths && !hasConventions && !hasNotes) {
+                p.log.info(pc.yellow('No personalized observations recorded yet. Mino will learn your communication style and preferences organically as you chat.'));
+            }
+            else {
+                if (hasStyle) {
+                    console.log(pc.bold('Communication Style:'));
+                    if (profile.communicationStyle?.tonePreference) {
+                        console.log(`  ${pc.dim('•')} Tone & Demeanor: ${pc.green(profile.communicationStyle.tonePreference)}`);
+                    }
+                    if (profile.communicationStyle?.verbosity) {
+                        console.log(`  ${pc.dim('•')} Output Formatting: ${pc.green(profile.communicationStyle.verbosity)}`);
+                    }
+                    if (profile.communicationStyle?.formulationStyle) {
+                        console.log(`  ${pc.dim('•')} Thought Formulation: ${pc.green(profile.communicationStyle.formulationStyle)}`);
+                    }
+                    console.log('');
+                }
+                if (hasCognitive) {
+                    console.log(pc.bold('Decision-Making & Cognitive Traits:'));
+                    if (profile.cognitiveTraits?.architecturalStyle) {
+                        console.log(`  ${pc.dim('•')} Architectural Orientation: ${pc.magenta(profile.cognitiveTraits.architecturalStyle)}`);
+                    }
+                    if (profile.cognitiveTraits?.decisionPreference) {
+                        console.log(`  ${pc.dim('•')} Decision Autonomy: ${pc.magenta(profile.cognitiveTraits.decisionPreference)}`);
+                    }
+                    if (profile.cognitiveTraits?.riskTolerance) {
+                        console.log(`  ${pc.dim('•')} Risk & Velocity: ${pc.magenta(profile.cognitiveTraits.riskTolerance)}`);
+                    }
+                    if (profile.cognitiveTraits?.delegationDepth) {
+                        console.log(`  ${pc.dim('•')} Delegation Depth: ${pc.magenta(profile.cognitiveTraits.delegationDepth)}`);
+                    }
+                    if (profile.cognitiveTraits?.debuggingStyle) {
+                        console.log(`  ${pc.dim('•')} Debugging Preference: ${pc.magenta(profile.cognitiveTraits.debuggingStyle)}`);
+                    }
+                    if (profile.cognitiveTraits?.explanationFormat) {
+                        console.log(`  ${pc.dim('•')} Explanation Preference: ${pc.magenta(profile.cognitiveTraits.explanationFormat)}`);
+                    }
+                    console.log('');
+                }
+                if (hasStrengths || hasConventions) {
+                    console.log(pc.bold('Technical Preferences:'));
+                    if (hasStrengths) {
+                        console.log(`  ${pc.dim('•')} Strengths: ${pc.cyan(profile.technicalPreferences.strengths.join(', '))}`);
+                    }
+                    if (hasConventions) {
+                        console.log(`  ${pc.dim('•')} Conventions: ${pc.cyan(profile.technicalPreferences.conventions.join(', '))}`);
+                    }
+                    console.log('');
+                }
+                if (hasNotes) {
+                    console.log(pc.bold(`AI Observations & Side-Notes (${profile.agentNotes.length}):`));
+                    profile.agentNotes.forEach((note, idx) => {
+                        console.log(`  ${pc.yellow(`[${idx + 1}]`)} ${note}`);
+                    });
+                    console.log('');
+                }
+            }
+        }
+        else if (action === 'delete_note') {
+            if (profile.agentNotes.length === 0) {
+                p.log.warn('No side-notes recorded yet to delete.');
+            }
+            else {
+                const noteChoices = profile.agentNotes.map((note, idx) => ({
+                    value: idx,
+                    label: `${idx + 1}. ${note.length > 70 ? note.slice(0, 67) + '...' : note}`,
+                }));
+                const selectedIndex = await p.select({
+                    message: 'Select a side-note to delete:',
+                    options: [...noteChoices, { value: -1, label: 'Cancel' }],
+                });
+                if (!p.isCancel(selectedIndex) && typeof selectedIndex === 'number' && selectedIndex >= 0) {
+                    await deleteSideNote(selectedIndex);
+                    p.log.success(`Deleted side-note [${selectedIndex + 1}].`);
+                }
+            }
+        }
+        else if (action === 'clear_all') {
+            const confirmClear = await p.confirm({
+                message: 'Are you sure you want to clear your global profile and all AI side-notes?',
+                initialValue: false,
+            });
+            if (confirmClear && !p.isCancel(confirmClear)) {
+                await clearUserProfile();
+                p.log.success('User profile memory and side-notes have been reset.');
+            }
+        }
+        return { shouldContinue: true };
+    }
     return { shouldContinue: true };
 }

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.