minovative-mind-cli 1.4.0 → 1.4.2

package/dist/services/agent.js

@@ -17,633 +17,24 @@
  */
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import { debugLog, toggleDebugMode } from '../utils/logger.js';
-import { ensureProjectStorage, ensureIgnored, readCache, writeCache, invalidateCacheForDependents } from '../utils/projectStorage.js';
 import * as crypto from 'node:crypto';
-const execAsync = promisify(exec);
-/**
- * Asynchronous Input Handler (AsyncInputHandler)
- *
- * This class intercepts user keyboard input from standard input (stdin) while
- * background processes (e.g., Gemini model generations or long shell tool runs)
- * are executing. It provides seamless execution management by letting users:
- *
- * 1. **Pause execution** at any time by pressing a key.
- * 2. **Queue feedback** ("chained messages") without waiting for the entire run to finish.
- * 3. **Force abort** the current model or tool run by entering "stop".
- *
- * ### Raw Mode & Terminal States
- * In normal CLI execution, Node.js waits for a line feed (Enter) before emitting input.
- * To intercept immediate keystrokes, we put `process.stdin` into *raw mode*.
- * While in raw mode, we listen for direct data buffers.
- * To avoid visual conflicts with our logging output and Clack's CLI spinners,
- * we dynamically pause spinners, detach listeners, disable raw mode, open standard
- * interactive text-prompt forms, and resume raw mode and spinners upon completion.
- */
-export class AsyncInputHandler {
-    /** Queue of pending user feedback/instructions typed during active background execution */
-    queue = [];
-    /** Guard flag preventing multiple simultaneous input prompt overlays */
-    isPrompting = false;
-    /** Reference to the Clack CLI spinner which must be paused/restarted during prompts */
-    spinner = null;
-    /** Stores the terminal's raw mode configuration state before handler activation */
-    originalRawMode = false;
-    /** Indicates whether the input handler is currently inactive/stopped */
-    stopped = true;
-    /** Reference to the AbortController controlling the active AI request to trigger cancellations */
-    ac = null;
-    /**
-     * Registers the active AbortController for the current AI request.
-     * This is triggered when the user commands a process cancel (e.g., typing "stop").
-     *
-     * @param ac - The AbortController controlling the current generation.
-     */
-    setAbortController(ac) {
-        this.ac = ac;
-    }
-    /**
-     * Determines if a user-prompt dialog is actively running.
-     * Useful for coordinating other console logging output to avoid UI overlap.
-     *
-     * @returns True if a text prompt is currently displayed, false otherwise.
-     */
-    isCurrentlyPrompting() {
-        return this.isPrompting;
-    }
-    /**
-     * Blocks and waits until any active prompting action is completed.
-     * Guarantees terminal stdout is clean before resuming logs.
-     */
-    async waitForPrompt() {
-        while (this.isPrompting) {
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-    }
-    /**
-     * Core stdin event listener. Detects pressed keys, pauses background visual elements,
-     * handles exit interrupts, and opens a Clack text dialog for input.
-     *
-     * Handles recovery of the standard input stream and raw mode states even if
-     * errors occur during prompt initialization.
-     *
-     * @param chunk - The raw terminal buffer containing keypress data.
-     * @private
-     */
-    onData = async (chunk) => {
-        try {
-            if (this.isPrompting)
-                return;
-            const char = chunk.toString();
-            // Handle Ctrl+C (End of Text ASCII 0x03) immediately
-            if (char === '\u0003') {
-                process.exit(0);
-            }
-            // Ignore standard non-printable control keys, escape sequences, etc.
-            if (char.charCodeAt(0) < 32 || char === '\u007f')
-                return;
-            this.isPrompting = true;
-            process.stdin.removeListener('data', this.onData);
-            if (process.stdin.isTTY) {
-                process.stdin.setRawMode(false);
-            }
-            // Hide the background spinner before prompt output to avoid corrupting terminal lines
-            if (this.spinner) {
-                this.spinner.stop();
-            }
-            p.log.step(pc.cyan('Paused to receive input'));
-            // Capture the user feedback. The character typed to trigger this event is passed
-            // as the initial value of the prompt to avoid losing the first keystroke.
-            const userInput = await p.text({
-                message: 'Add chained message:',
-                placeholder: '(Leave blank and press Enter to cancel)',
-                initialValue: char,
-            });
-            let wasAborted = false;
-            if (!p.isCancel(userInput) && userInput.trim()) {
-                const text = userInput.trim();
-                if (text.toLowerCase() === 'stop') {
-                    if (this.ac) {
-                        this.ac.abort();
-                        p.log.warn(pc.yellow(`Generation aborted by user.`));
-                        wasAborted = true;
-                    }
-                }
-                else {
-                    this.queue.push(text);
-                    p.log.info(pc.cyan(`📥 Queued message: "${text}"`));
-                }
-            }
-            if (this.spinner && !wasAborted) {
-                const resumeMsg = this.spinner._lastMessage || 'Resuming execution...';
-                this.spinner.start(resumeMsg);
-            }
-        }
-        catch (err) {
-            // Absorb and suppress errors safely during raw stream intercepts
-        }
-        finally {
-            if (!this.stopped) {
-                if (process.stdin.isTTY) {
-                    process.stdin.setRawMode(true);
-                }
-                process.stdin.resume();
-                // Small delay before reattaching listener to avoid capturing duplicate keypress frames
-                setTimeout(() => {
-                    if (!this.stopped) {
-                        process.stdin.on('data', this.onData);
-                    }
-                    this.isPrompting = false;
-                }, 50);
-            }
-            else {
-                this.isPrompting = false;
-            }
-        }
-    };
-    /**
-     * Starts intercepting keystrokes and enables raw terminal processing.
-     * Saves the original raw mode configuration to ensure a clean restoration later.
-     *
-     * @param spinner - The current active Clack spinner UI reference, if any.
-     */
-    start(spinner) {
-        this.stopped = false;
-        if (spinner) {
-            this.spinner = spinner;
-            // Monkey-patch to track the latest message for un-pausing
-            if (!spinner._isPatched) {
-                ;
-                spinner._isPatched = true;
-                spinner._lastMessage = 'Executing...';
-                const originalMessage = spinner.message.bind(spinner);
-                spinner.message = (msg) => {
-                    if (msg) {
-                        ;
-                        spinner._lastMessage = msg;
-                    }
-                    originalMessage(msg);
-                };
-                const originalStart = spinner.start.bind(spinner);
-                spinner.start = (msg) => {
-                    if (msg) {
-                        ;
-                        spinner._lastMessage = msg;
-                    }
-                    originalStart(msg);
-                };
-            }
-        }
-        if (process.stdin.isTTY) {
-            this.originalRawMode = process.stdin.isRaw;
-            process.stdin.setRawMode(true);
-        }
-        process.stdin.resume();
-        process.stdin.on('data', this.onData);
-    }
-    /**
-     * Disables raw mode, stops intercepting keystrokes, and restores
-     * the terminal stdin stream to its original raw/cooked state.
-     */
-    stop() {
-        this.stopped = true;
-        process.stdin.removeListener('data', this.onData);
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(this.originalRawMode);
-        }
-        this.spinner = null;
-    }
-    /**
-     * Retrieves and flushes all user feedback messages accumulated during execution.
-     *
-     * @returns A concatenated string of all queued user messages separated by newlines,
-     *          or an empty string if nothing was queued.
-     */
-    getAndClear() {
-        if (this.queue.length === 0)
-            return '';
-        const messages = this.queue.join('\n');
-        this.queue = [];
-        return messages;
-    }
-}
-import { consumeSkipOnce, executeTool, getApprovalMode, setApprovalMode } from './agent-tools.js';
-import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, ProxyChatSession, compressTextUsingFlashLite, } from './ai.js';
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import { debugLog } from '../utils/logger.js';
+import { ensureProjectStorage, ensureIgnored, readCache, writeCache, invalidateCacheForDependents, } from '../utils/projectStorage.js';
+import { createSharedChatSession, getGeneralChatConfig, getPlanExecutionConfig, compressTextUsingFlashLite, } from './ai.js';
 import { changeLogger } from './changeLogger.js';
 import { gatherContext, routeIntent } from './contextAgent.js';
-import { printLogo } from '../utils/logo.js';
 import { verifyChangedFiles } from './verificationService.js';
 import { buildContextInjection } from '../utils/contextPrompts.js';
-import { readPaste } from '../utils/paste.js';
-import { marked } from 'marked';
-import { markedTerminal } from 'marked-terminal';
+// Submodule Imports
+import { AsyncInputHandler } from './agent/inputHandler.js';
+import { processResponse } from './agent/toolLoop.js';
+import { handleSlashCommand } from './agent/slashCommands.js';
 marked.use(markedTerminal());
-// ─── Constants ───────────────────────────────────────────────────────
-/**
- * Mapping of tool identifiers to user-friendly terminal emojis.
- * Enhances the visual feedback during background tool execution turns.
- */
-const TOOL_ICONS = {
-    read_file: '📖',
-    write_file: '✏️',
-    modify_file: '🔧',
-    list_directory: '📂',
-    run_command: '⚡',
-    grep_search: '🔍',
-    delete_file: '🗑️',
-    rename_file: '🚚',
-    find_dependencies: '🔗',
-    run_analysis_script: '🔬',
-};
-/**
- * Human-readable translations for tool actions.
- * Used for constructing clear, active-verb descriptive log headers in the CLI.
- */
-const TOOL_LABELS = {
-    read_file: 'Reading file',
-    write_file: 'Writing file',
-    modify_file: 'Modifying file',
-    list_directory: 'Listing directory',
-    run_command: 'Running command',
-    grep_search: 'Searching code',
-    delete_file: 'Deleting file',
-    rename_file: 'Moving file',
-    find_dependencies: 'Tracing dependencies',
-    run_analysis_script: 'Analyzing code structure',
-};
-// ─── Helpers ─────────────────────────────────────────────────────────
-/**
- * Formats a tool execution call into a beautifully stylized console status line.
- * Extracts context-specific arguments to display relevant parameters in real-time.
- *
- * @param name - The identifier of the tool being called (e.g. 'read_file').
- * @param args - The dictionary of parameters supplied to the tool.
- * @returns A fully colorized and formatted ANSI console string.
- */
-function formatToolCall(name, args) {
-    const icon = TOOL_ICONS[name] ?? '🔧';
-    const label = TOOL_LABELS[name] ?? name;
-    const formatPath = (path) => pc.cyan(path);
-    const argsMap = {
-        read_file: () => {
-            if (args.startLine !== undefined || args.endLine !== undefined) {
-                const start = args.startLine ?? 1;
-                const end = args.endLine ?? 'end';
-                return pc.dim(` (Lines ${start}-${end})`) + `: ${formatPath(String(args.filePath))}`;
-            }
-            if (Array.isArray(args.targetElements) && args.targetElements.length > 0) {
-                return pc.dim(` (Elements: ${args.targetElements.join(', ')})`) + `: ${formatPath(String(args.filePath))}`;
-            }
-            return `: ${formatPath(String(args.filePath))}`;
-        },
-        write_file: () => `: ${formatPath(String(args.filePath))}`,
-        modify_file: () => `: ${formatPath(String(args.filePath))}`,
-        list_directory: () => `: ${formatPath(String(args.dirPath ?? '.'))}`,
-        run_command: () => `: ${pc.yellow(String(args.command))}`,
-        grep_search: () => `: ${pc.magenta(String(args.pattern))}`,
-        delete_file: () => `: ${pc.red(String(args.filePath))}`,
-        rename_file: () => `: ${formatPath(String(args.sourcePath))} -> ${formatPath(String(args.targetPath))}`,
-        find_dependencies: () => `: ${formatPath(String(args.filePath))}${args.direction ? ` (${args.direction})` : ''}`,
-        run_analysis_script: () => `: ${formatPath(String(args.targetFile ?? 'workspace'))}`,
-    };
-    const formatter = argsMap[name];
-    const details = formatter ? formatter() : '';
-    return `${icon} ${label}${details}`;
-}
-function isCommandDestructive(command) {
-    const destructivePatterns = [
-        // Unix deletion (catches rm -r, rm -rf, rm -fr, rm --recursive, rm --force, anywhere in args)
-        /\brm\s+.*?(?:-[a-zA-Z]*[rfR]|--(?:recursive|force))\b/i,
-        /\bmv\s+.*\/dev\/null\b/i, // Move to void
-        // Windows deletion (catches rd /s, del /f /s)
-        /\b(?:rd|rmdir)\s+.*\/[sq]\b/i,
-        /\bdel\s+.*\/[fs]\b/i,
-        // Remote script execution (catches curl/wget piped to any shell or runtime)
-        /\b(?:curl|wget)\b.*?\|\s*(?:sh|bash|zsh|dash|python|node|ruby|perl)\b/i,
-        // Git overwriting (catches hard resets, clean -f, force pushes, hard branch deletes)
-        /\bgit\s+(?:reset|clean)\s+.*(?:--hard|-f|--force)\b/i,
-        /\bgit\s+push\s+.*(?:-f|--force)\b/i,
-        /\bgit\s+branch\s+.*-D\b/i,
-        // DB & Cluster Drops (catches truncates, deletes, drop db/table, docker volume/system prunes, kubectl wipes)
-        /\b(?:drop|truncate|delete)\s+(?:database|table|schema)\b/i,
-        /\bdocker\s+system\s+prune\b/i,
-        /\bdocker\s+volume\s+(?:rm|prune)\b/i,
-        /\bkubectl\s+delete\s+(?:namespace|all|--all)\b/i,
-        // Disk & System destruction (format, fdisk, dd, overwriting block devices, shutdown, fork bombs)
-        /\b(?:mkfs|fdisk|parted|mkswap)\b/i,
-        /\bformat\s+[A-Z]:/i,
-        /\bdd\s+.*(?:if=|of=)\b/i,
-        />\s*\/dev\/(?:sda|disk|hda|nvme)\b/i,
-        /\b(?:shutdown|reboot|halt|poweroff)\b/i,
-        /:\(\)\{\s*:\|:&\s*\};:/, // Fork bomb
-        // User data/config erasure
-        /\bcrontab\s+-r\b/i,
-        /\bhistory\s+-c\b/i,
-        // Massive permission shifts (chmod 777, recursive chowns)
-        /\bchmod\s+(?:-[R\w]*\s+)?777\b/i,
-        /\bchown\s+-[R\w]*\b/i,
-    ];
-    return destructivePatterns.some((pattern) => pattern.test(command));
-}
-function isCommandSafe(command) {
-    // Do not auto-approve chained, redirected, or sudo commands
-    if (/[;&|>]/.test(command) || /\bsudo\b/.test(command)) {
-        return false;
-    }
-    const safePatterns = [
-        /^\s*ls\b/i,
-        /^\s*pwd\b/i,
-        /^\s*whoami\b/i,
-        /^\s*cat\b/i,
-        /^\s*echo\b/i,
-        /^\s*grep\b/i,
-        /^\s*find\b/i,
-        /^\s*npm\s+(install|i|ci|run\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*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,
-        /^\s*uv\s+(add|pip|sync|run\b)/i,
-        /^\s*rustc\b/i,
-        /^\s*git\s+(status|log|diff|show|branch)\b/i,
-        /^\s*(node|python|ruby|java|go|rustc)\s+(--version|-v)\b/i,
-        /^\s*tsc\b/i,
-        /^\s*eslint\b/i,
-        /^\s*prettier\b/i,
-    ];
-    return safePatterns.some((pattern) => pattern.test(command));
-}
-/**
- * Executes an interactive approval prompt via `@clack/prompts`.
- *
- * Supports pattern-based approvals and three user approval models:
- * 1. **Ask**: Prompts the user for every shell execution command (except implicitly safe ones).
- * 2. **Skip-Once**: Automatically grants permission to the current command, then resets.
- * 3. **Skip-All / Auto-Approve**: Grants permission to all future terminal commands.
- *
- * Destructive commands will ALWAYS prompt the user, regardless of mode.
- *
- * @param command - The terminal string requested for execution.
- * @returns A promise resolving to `true` if approved, or `false` if denied/cancelled.
- */
-async function requestCommandApproval(command) {
-    const mode = getApprovalMode();
-    const isDestructive = isCommandDestructive(command);
-    const isSafe = isCommandSafe(command);
-    // Force prompt for destructive commands
-    if (isDestructive) {
-        p.log.warn(`${pc.bgRed(pc.white(' WARNING '))} Destructive command detected. Explicit approval required.`);
-    }
-    else {
-        if (mode === 'skip-all') {
-            p.log.info(`${pc.dim('Auto-approved (skip-all):')} ${pc.yellow(command)}`);
-            return true;
-        }
-        if (mode === 'skip-once') {
-            p.log.info(`${pc.dim('Auto-approved (skip-once):')} ${pc.yellow(command)}`);
-            consumeSkipOnce();
-            return true;
-        }
-        if (isSafe) {
-            p.log.info(`${pc.dim('Auto-approved (safe command):')} ${pc.yellow(command)}`);
-            return true;
-        }
-    }
-    // mode === 'ask' or isDestructive
-    const result = await p.select({
-        message: `Approve command: ${pc.yellow(command)}`,
-        options: [
-            { value: 'approve', label: 'Yes, run this command' },
-            { value: 'skip-once', label: 'Yes, and skip approval for the next command too' },
-            {
-                value: 'skip-all',
-                label: 'Yes, auto-approve all future commands (Note: this lasts until you restart the CLI)',
-            },
-            { value: 'deny', label: 'No, deny this command' },
-        ],
-    });
-    if (p.isCancel(result) || result === 'deny') {
-        return false;
-    }
-    if (result === 'skip-once') {
-        setApprovalMode('skip-once');
-    }
-    else if (result === 'skip-all') {
-        setApprovalMode('skip-all');
-    }
-    return true;
-}
-// ─── Agent Loop ──────────────────────────────────────────────────────
-/**
- * Processes a single model response that may contain tool calls.
- * Handles the full tool-call loop: execute → feed results → repeat
- * until the model produces a final text response.
- *
- * @param chat - The current active proxy chat session.
- * @param result - The current result returned from sending a message to the model.
- * @param workspaceRoot - The absolute/relative path to the workspace root.
- * @param inputHandler - The input handler to check for queued interrupts.
- * @param agentState - State tracker for whether the target agent configuration is CHAT or EXECUTE.
- * @param abortSignal - Signal to detect when the operation has been cancelled.
- * @returns A promise that resolves to the final text response.
- */
-/**
- * Coordinates and executes the recursive model-response tool-execution loop.
- *
- * ### Execution Mechanism:
- * This function processes the initial response from the generative model. If the model determines
- * it needs to execute tools (e.g. read_file, run_command, modify_file) to answer or fulfill the request:
- *
- * 1. **Analyze Tool Requirements**: Parses requested `functionCalls` from the LLM.
- * 2. **Check for User Abortion**: Periodically examines the `AbortSignal` to stop execution if requested.
- * 3. **Manage Safety Approvals**: For high-risk operations (like `run_command`), requests explicit confirmation from the user (or uses auto-approve configurations).
- * 4. **Execute Operations**: Runs requested tool actions via `executeTool` in parallel or series as requested.
- * 5. **Handle Interrupts**: Integrates background user inputs queued in `inputHandler` as new context prompts back into the active LLM context.
- * 6. **Submit Loop Frame**: Feeds execution outcomes back to the Gemini session and recursively repeats this sequence until the LLM produces a final text answer without further tool requests.
- *
- * ### Limits & Recovery Guardrails:
- * - **Turn-Limiting**: Capped at `MAX_TURNS` (25) to prevent infinite loops, API token drain, or excessive billing if the AI gets stuck in a repetitive loop.
- * - **Empty-Response Healing**: If the API returns an empty text response with no tools, the system initiates up to `MAX_EMPTY_RETRIES` (3) system-driven wake-up prompts to re-engage the model.
- *
- * @param chat - The current active proxy chat session.
- * @param result - The current result returned from sending a message to the model.
- * @param workspaceRoot - The absolute/relative path to the workspace root.
- * @param inputHandler - The input handler to check for queued interrupts.
- * @param agentState - State tracker for whether the target agent configuration is CHAT or EXECUTE.
- * @param abortSignal - Signal to detect when the operation has been cancelled.
- * @returns A promise that resolves to the final text response.
- */
-async function processResponse(chat, result, workspaceRoot, inputHandler, agentState, abortSignal) {
-    let response = result.response;
-    // Upper limit on autonomous sequential tool executions to prevent out-of-control loops
-    let turnCount = 0;
-    const MAX_TURNS = 50;
-    // Recovery thresholds for handling unexpected empty API payloads
-    let emptyRetryCount = 0;
-    const MAX_EMPTY_RETRIES = 3;
-    // Loop while the model keeps requesting tool calls
-    while (true) {
-        turnCount++;
-        if (turnCount > MAX_TURNS) {
-            p.log.error(`${pc.red('System Error:')} Agent exceeded maximum autonomous turns (${MAX_TURNS}). Force stopping to prevent infinite loop.`);
-            try {
-                p.log.info(pc.cyan(`Requesting final summary from AI based on gathered information...`));
-                const originalTools = chat.tools || [];
-                const originalInstruction = chat.systemInstruction || '';
-                // Temporarily clear tools to force a pure text response
-                chat.setAgentConfig(originalInstruction, []);
-                const finalFollowUp = await chat.sendMessage(`[SYSTEM INTERRUPTION] You have exceeded the maximum number of allowed tool operations (${MAX_TURNS} turns). You must now provide a final answer to the user based ONLY on the information you have gathered so far. Do NOT attempt to call any more tools, just answer the user directly.`, undefined, abortSignal);
-                // Restore tools
-                chat.setAgentConfig(originalInstruction, originalTools);
-                const finalOutput = finalFollowUp.response.text();
-                if (finalOutput && finalOutput.trim()) {
-                    return finalOutput;
-                }
-                return '';
-            }
-            catch (e) {
-                if (e.name === 'AbortError' || e.message?.includes('abort')) {
-                    p.log.warn(pc.yellow('Generation stopped by user.'));
-                    return '[Generation stopped by user]';
-                }
-                return '';
-            }
-        }
-        const functionCalls = response.functionCalls();
-        if (!functionCalls || functionCalls.length === 0) {
-            // No more tool calls — return the final text response
-            let finalOutput = response.text() ?? '';
-            if (!finalOutput.trim()) {
-                if (emptyRetryCount < MAX_EMPTY_RETRIES) {
-                    emptyRetryCount++;
-                    p.log.warn(pc.yellow(`AI returned an empty response. Attempting to recover (retry ${emptyRetryCount}/${MAX_EMPTY_RETRIES})...`));
-                    // System-driven injection to kickstart the LLM's conversation generation
-                    const wakeUpMessage = 'SYSTEM: You just returned a completely empty response with no tool calls. If you are stuck, please use your tools to explore the workspace, or explain what you are trying to do and ask the user for clarification. Do not return empty responses.';
-                    try {
-                        const retry = await chat.sendMessage(wakeUpMessage, undefined, abortSignal);
-                        response = retry.response;
-                        continue;
-                    }
-                    catch (e) {
-                        if (e.name === 'AbortError' || e.message?.includes('abort')) {
-                            p.log.warn(pc.yellow('Generation stopped by user during recovery.'));
-                            return '[Generation stopped by user]';
-                        }
-                        finalOutput = '[System Error: The AI returned an empty response and failed to recover.]';
-                    }
-                }
-                else {
-                    finalOutput =
-                        '[The AI repeatedly returned empty responses and could not recover. This usually means it hit an API filter/limit or is stuck. Try rewording your prompt.]';
-                }
-            }
-            return finalOutput;
-        }
-        // Process each tool call requested by the model
-        const toolResponses = [];
-        for (const fc of functionCalls) {
-            await inputHandler.waitForPrompt();
-            if (abortSignal.aborted) {
-                p.log.warn(pc.yellow('Execution aborted by user.'));
-                return '[Generation stopped by user]';
-            }
-            const toolName = fc.name;
-            const toolArgs = (fc.args ?? {});
-            // Log the ongoing tool action to the console
-            p.log.step(formatToolCall(toolName, toolArgs));
-            // If executing a CLI/shell command, wait for approval
-            if (toolName === 'run_command') {
-                await inputHandler.waitForPrompt();
-                inputHandler.stop(); // Temporarily release raw-mode during blocking interactive prompt
-                const approved = await requestCommandApproval(toolArgs.command);
-                inputHandler.start(); // Re-engage raw-mode for continuous background monitoring
-                if (!approved) {
-                    toolResponses.push({
-                        functionResponse: {
-                            name: toolName,
-                            response: {
-                                output: '',
-                                error: 'Command was denied by the user. Do not retry this command. Ask the user how they would like to proceed.',
-                            },
-                        },
-                    });
-                    continue;
-                }
-            }
-            // Execute the underlying filesystem, shell or search tool logic
-            const toolResult = await executeTool(workspaceRoot, toolName, toolArgs, abortSignal);
-            await inputHandler.waitForPrompt();
-            if (toolResult.error) {
-                debugLog(`Raw Tool Error for ${toolName}: ${toolResult.error}`);
-                // Do not spam the user with expected chunking warnings
-                if (!toolResult.error.includes('File is too large')) {
-                    // Truncate the error message for the terminal UI to prevent console clutter
-                    // (e.g. hiding the large file previews sent to the AI)
-                    const displayError = toolResult.error.split('\n')[0].substring(0, 100);
-                    p.log.warn(`${pc.red('Tool error:')} [${displayError}]`);
-                }
-            }
-            toolResponses.push({
-                functionResponse: {
-                    name: toolName,
-                    response: {
-                        output: toolResult.output,
-                        ...(toolResult.error ? { error: toolResult.error } : {}),
-                    },
-                },
-            });
-        }
-        // Check if the user entered any feedback or interrupt commands during the tool execution cycle
-        await inputHandler.waitForPrompt();
-        const queuedMsg = inputHandler.getAndClear();
-        let additionalText = undefined;
-        if (queuedMsg) {
-            additionalText = `[USER INTERRUPTION] The user sent the following message during your execution:\n"${queuedMsg}"\n\nPlease incorporate this feedback into your ongoing work. Address the user's message, but DO NOT lose track of your original overall plan or focus. After addressing this interruption, continue with your broader objective.`;
-            p.log.info(pc.cyan(`Sending queued message to AI...`));
-            // Dynamically upgrade agent permissions/intent to EXECUTE mode if the interrupted instruction requires system modifications
-            const newIntent = await routeIntent(queuedMsg);
-            if (agentState.targetAgent === 'CHAT') {
-                if (newIntent.targetAgent === 'EXECUTE' || newIntent.needsContext) {
-                    agentState.targetAgent = 'EXECUTE';
-                    const config = getPlanExecutionConfig();
-                    chat.setAgentConfig(config.systemInstruction, config.tools);
-                    p.log.info(pc.yellow(`Upgraded session intent to EXECUTE based on chained message.`));
-                }
-            }
-        }
-        // Feed tool results and potential interruption text back to the model
-        let followUp;
-        try {
-            followUp = await chat.sendMessage(toolResponses, additionalText, abortSignal);
-        }
-        catch (e) {
-            if (e.name === 'AbortError' || e.message?.includes('abort')) {
-                p.log.warn(pc.yellow('Generation stopped by user.'));
-                return '[Generation stopped by user]';
-            }
-            throw e;
-        }
-        await inputHandler.waitForPrompt();
-        const grounding = followUp.response.groundingMetadata?.();
-        if (grounding?.webSearchQueries && grounding.webSearchQueries.length > 0) {
-            p.log.info(`${pc.blue('🌐')} ${pc.dim('Google Search Queries:')} ${grounding.webSearchQueries.map((q) => pc.cyan(`"${q}"`)).join(', ')}`);
-        }
-        response = followUp.response;
-    }
-}
-/**
- * Starts the interactive agent chat loop.
- * Runs until the user types "exit", "quit", or presses Ctrl+C.
- *
- * @param workspaceRoot - The root directory of the workspace.
- * @param version - The active version of the CLI utility.
- */
+// Export submodules for potential external uses if required
+export { AsyncInputHandler } from './agent/inputHandler.js';
 /**
  * Starts and orchestrates the primary interactive command-line interface (REPL) loop.
  *
@@ -659,13 +50,7 @@ async function processResponse(chat, result, workspaceRoot, inputHandler, agentS
  *    - Intercepts and filters OS clipboard paste buffers to allow inserting massive scripts cleanly.
  *
  * 2. **Slash Commands Processing**:
- *    - `/paste`: Interactively captures large copy-pasted blocks using EOF tracking.
- *    - `/clear`: Hard-clears active terminal histories and resets session state.
- *    - `/models`: Dynamic runtime model hot-swapping (e.g., swapping between Flash and Pro variants).
- *    - `/debug`: Toggles active runtime execution telemetry logging.
- *    - `/auto-approve`: Grants blanket terminal script permissions to bypass prompt approval blocks.
- *    - `/revert`: Pops the most recent change-set log and rolls back mutated files to original states.
- *    - `/commit`: Performs git diff staging, executes model summaries to write micro-commits, and executes local git commits.
+ *    - Delegated to `handleSlashCommand` within `src/services/agent/slashCommands.ts`.
  *
  * 3. **Workspace Context Gathering & Intention Routing**:
  *    - Leverages the Context Agent (`gatherContext`) to perform exploratory scans of the active repository.
@@ -709,55 +94,19 @@ export async function startAgentLoop(workspaceRoot, version) {
     console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
     while (true) {
         inputHandler.stop();
-        let lines = [];
-        let isMultiLine = false;
-        let canceledGlobal = false;
-        // Input collection sub-loop (handles multiline line-by-line gathering)
-        while (true) {
-            const userInputRaw = await p.text({
-                message: isMultiLine ? '  ' : pc.magenta('❯'),
-                placeholder: isMultiLine ? '' : 'Use "\\" for new lines',
-            });
-            if (p.isCancel(userInputRaw)) {
-                if (isMultiLine) {
-                    p.log.warn(pc.yellow('Multi-line input canceled.'));
-                    lines = [];
-                    isMultiLine = false;
-                    continue;
-                }
-                else {
-                    canceledGlobal = true;
-                    break;
-                }
-            }
-            let line = (userInputRaw || '');
-            // Require a space before the backslash to prevent Windows directory paths (e.g., C:\foo\) from triggering multiline
-            if (line.trimEnd().endsWith(' \\')) {
-                const cleanLine = line.trimEnd().slice(0, -2);
-                lines.push(cleanLine);
-                isMultiLine = true;
-                // Clack's text prompt dims the submitted value, which can be completely invisible on some terminal themes.
-                // We explicitly log the line here so the user can see what they are typing in multiline mode.
-                p.log.step(pc.cyan(cleanLine));
-            }
-            else {
-                lines.push(line);
-                // Unconditionally log the user's message so it is always visible
-                p.log.step(pc.cyan(line));
-                break;
-            }
-        }
-        if (canceledGlobal) {
+        // Input collection (delegated to a helper function to avoid nested loop warning)
+        const { userInput: rawInput, canceled } = await collectUserInput();
+        if (canceled) {
             p.outro(pc.green('Goodbye! Happy coding. 🚀'));
             return;
         }
-        let userInput = lines.join('\n').trim();
+        let userInput = rawInput;
         if (!userInput) {
             continue;
         }
         // Capture standalone forward slash triggers to open the selection console
         if (userInput === '/') {
-            const commandMenu = await p.select({
+            const commandMenu = await p['select']({
                 message: 'Command Menu',
                 options: [
                     { value: '/models', label: '/models', hint: 'Change the active AI model' },
@@ -787,183 +136,24 @@ export async function startAgentLoop(workspaceRoot, version) {
             debugLog(`Executing slash command: ${userInput}`);
         }
         // ─── Slash Commands Handling ─────────────────────────────────────
-        if (userInput.toLowerCase() === '/paste') {
-            p.log.info(pc.cyan('Paste mode activated. Paste your text below, then press Ctrl+D on an empty line to submit. (Ctrl+C to cancel)'));
-            try {
-                isRawPasteMode = true;
-                const content = await readPaste();
-                isRawPasteMode = false;
-                if (!content) {
-                    p.log.warn('Paste mode closed with no content.');
-                    continue;
-                }
-                userInput = content;
-                p.log.step(pc.cyan(`Loaded ${content.length} characters from paste.`));
-            }
-            catch (err) {
-                isRawPasteMode = false;
-                p.log.error(`Paste failed: ${err instanceof Error ? err.message : String(err)}`);
-                continue;
-            }
-        }
-        else if (userInput.toLowerCase() === '/clear') {
-            chat.clearHistory();
-            process.stdout.write('\x1B[2J\x1B[3J\x1B[H'); // Hard clear screen and scrollback
-            printLogo();
-            p.intro(`${pc.bgCyan(pc.black(' Minovative Mind CLI '))} ${pc.dim('v' + version)}`);
-            p.log.info(`${pc.dim('Workspace:')} ${pc.cyan(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('Chat history cleared.');
-            console.log(pc.dim('\nType your coding request below. Type "exit" or "quit" to leave.\n'));
-            continue;
-        }
-        if (userInput.toLowerCase() === '/models') {
-            const currentModel = chat.getModel();
-            const selectedModel = await p.select({
-                message: `Select AI Model (Current: ${pc.cyan(currentModel)})`,
-                initialValue: currentModel,
-                options: [
-                    {
-                        value: 'gemini-3.1-pro-preview',
-                        label: 'Gemini 3.1 Pro',
-                        hint: 'The newest Pro model for complex logic',
-                    },
-                    {
-                        value: 'gemini-3.5-flash',
-                        label: 'Gemini 3.5 Flash',
-                        hint: 'Balanced performance',
-                    },
-                    {
-                        value: 'gemini-3.1-flash-lite',
-                        label: 'Gemini 3.1 Flash-Lite',
-                        hint: 'Ultra-fast and cost-effective',
-                    },
-                ],
-            });
-            if (!p.isCancel(selectedModel)) {
-                chat.setModel(selectedModel);
-                p.log.success(`Model successfully switched to ${pc.cyan(selectedModel)}`);
-            }
-            continue;
-        }
-        if (userInput.toLowerCase() === '/debug') {
-            const debugMode = toggleDebugMode();
-            if (debugMode) {
-                p.log.info('Debug mode enabled. Internal logs will now be shown.');
-            }
-            else {
-                p.log.info('Debug mode disabled.');
-            }
-            continue;
-        }
-        if (userInput.toLowerCase() === '/auto-approve') {
-            setApprovalMode('skip-all');
-            p.log.success('Auto-approve enabled for all future commands in this session.');
-            continue;
-        }
-        if (userInput.toLowerCase() === '/revert') {
-            const history = changeLogger.getHistory();
-            if (!history || history.length === 0) {
-                p.log.warn('No changes to revert.');
-                continue;
-            }
-            const lastChangeSet = history[history.length - 1];
-            const truncate = (str, max) => (str.length > max ? str.substring(0, max - 3) + '...' : str);
-            const revertMenu = await p.select({
-                message: 'Revert Menu',
-                options: [
-                    { value: 'revert_last', label: `Revert last change (${truncate(lastChangeSet.description, 50)})` },
-                    { value: 'view_history', label: 'View history' },
-                    { value: 'cancel', label: 'Cancel' },
-                ],
-            });
-            if (p.isCancel(revertMenu) || revertMenu === 'cancel') {
+        if (userInput.startsWith('/')) {
+            const slashCtx = {
+                chat,
+                inputHandler,
+                workspaceRoot,
+                version,
+                isRawPasteMode,
+            };
+            const slashResult = await handleSlashCommand(userInput, slashCtx);
+            if (slashResult.isRawPasteMode !== undefined) {
+                isRawPasteMode = slashResult.isRawPasteMode;
+            }
+            if (slashResult.userInputOverride !== undefined) {
+                userInput = slashResult.userInputOverride;
+            }
+            else if (slashResult.shouldContinue) {
                 continue;
             }
-            let targetTimestamp = lastChangeSet.timestamp;
-            if (revertMenu === 'view_history') {
-                // Reverse history so newest is at the top
-                const historyOptions = history
-                    .slice()
-                    .reverse()
-                    .map((cs, i) => ({
-                    value: cs.timestamp,
-                    label: `[${i === 0 ? 'Latest' : `-${i}`}] ${truncate(cs.description, 50)} (${new Date(cs.timestamp).toLocaleTimeString()})`,
-                    hint: `Reverts this and all ${i} changes after it`,
-                }));
-                const selectedHistory = await p.select({
-                    message: 'Select the point in history to revert back to:',
-                    options: [...historyOptions, { value: -1, label: 'Cancel' }],
-                });
-                if (p.isCancel(selectedHistory) || selectedHistory === -1) {
-                    continue;
-                }
-                targetTimestamp = selectedHistory;
-            }
-            const spinner = p.spinner();
-            spinner.start('Reverting selected changes...');
-            try {
-                const changesToRevert = changeLogger.popUntil(targetTimestamp);
-                // changesToRevert is ordered from newest to oldest. We must apply them sequentially.
-                for (const changeSet of changesToRevert) {
-                    for (const change of changeSet.changes) {
-                        const absPath = path.resolve(workspaceRoot, change.filePath);
-                        if (change.action === 'create') {
-                            await fs.rm(absPath, { force: true });
-                        }
-                        else if (change.originalContent !== null) {
-                            await fs.writeFile(absPath, change.originalContent, 'utf-8');
-                        }
-                    }
-                }
-                spinner.stop('Reverted successfully.');
-                p.log.success(`Reverted ${changesToRevert.length} changeset(s) successfully.`);
-            }
-            catch (err) {
-                spinner.stop('Revert failed.');
-                p.log.error(`Failed to revert: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            continue;
-        }
-        if (userInput.toLowerCase() === '/commit') {
-            const commitSpinner = p.spinner();
-            commitSpinner.start('Staging changes and analyzing diff...');
-            try {
-                await execAsync('git add .', { cwd: workspaceRoot });
-                const { stdout: diffOut } = await execAsync('git diff --cached', { cwd: workspaceRoot });
-                if (!diffOut || diffOut.trim().length === 0) {
-                    commitSpinner.stop('No changes to commit.');
-                    p.log.warn('Git working tree is clean.');
-                    continue;
-                }
-                commitSpinner.message('Generating commit message...');
-                const prompt = `Generate a concise, standard git commit message for the following diff. Only return the commit message text.
-
-<diff>
-${diffOut}
-</diff>`;
-                // Use flash-lite for extreme speed and low cost for this simple task
-                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 commitAgent = new ProxyChatSession('gemini-3.1-flash-lite', commitSystemPrompt, [], {});
-                const commitResult = await commitAgent.sendMessage(prompt);
-                const commitMsg = commitResult.response.text().trim();
-                commitSpinner.message('Committing...');
-                const tmpMsgPath = path.join(workspaceRoot, '.gemini-commit-msg.tmp');
-                await fs.writeFile(tmpMsgPath, commitMsg, 'utf-8');
-                try {
-                    await execAsync(`git commit -F .gemini-commit-msg.tmp`, { cwd: workspaceRoot });
-                }
-                finally {
-                    await fs.rm(tmpMsgPath, { force: true });
-                }
-                commitSpinner.stop('Committed successfully.');
-                p.log.success(`Committed with message:\n\n${pc.dim(commitMsg)}`);
-            }
-            catch (err) {
-                commitSpinner.stop('Commit failed.');
-                p.log.error(`Failed to commit: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            continue;
         }
         // ─── Main Execution Cycle ────────────────────────────────────────
         const turnStartTime = Date.now();
@@ -1018,43 +208,8 @@ ${diffOut}
             let dynamicSystemInstruction = config.systemInstruction;
             // Inject gathered workspace directories, dependency configurations, and matching search patterns
             if (gatherRes.contextResult) {
-                const cachedContext = readCache(workspaceRoot, 'context_cache.json') || {};
-                let cacheUpdated = false;
-                // Compress each relevant file individually to allow granular cache hits
-                const compressedFiles = new Map();
-                for (const [filePath, content] of gatherRes.contextResult.relevantFiles.entries()) {
-                    if (content.length < 2000) {
-                        debugLog(`Bypassing cache and compression for ${filePath} (length ${content.length} < 2000)`);
-                        compressedFiles.set(filePath, content);
-                        continue;
-                    }
-                    const fileHash = crypto.createHash('sha256').update(filePath + content).digest('hex');
-                    if (cachedContext[fileHash]) {
-                        debugLog(`Context cache HIT for file ${filePath} (hash ${fileHash.substring(0, 8)})`);
-                        compressedFiles.set(filePath, cachedContext[fileHash]);
-                    }
-                    else {
-                        debugLog(`Context cache MISS for file ${filePath} (hash ${fileHash.substring(0, 8)})`);
-                        const compressPrompt = `Summarize the following file contents concisely. Preserve all exports, functions, classes, variables, and architectural purpose. Keep it under 2000 characters if possible. File: ${filePath}`;
-                        const summary = await compressTextUsingFlashLite(content, compressPrompt);
-                        compressedFiles.set(filePath, summary);
-                        cachedContext[fileHash] = summary;
-                        cacheUpdated = true;
-                    }
-                }
-                if (cacheUpdated) {
-                    // Keep cache size manageable by restricting to recent 100 file entries
-                    const keys = Object.keys(cachedContext);
-                    if (keys.length > 100) {
-                        const toDelete = keys.length - 100;
-                        for (let i = 0; i < toDelete; i++) {
-                            delete cachedContext[keys[i]];
-                        }
-                    }
-                    writeCache(workspaceRoot, 'context_cache.json', cachedContext);
-                }
-                // Replace raw file contents with their compressed summaries
-                gatherRes.contextResult.relevantFiles = compressedFiles;
+                // Compress each relevant file individually using helper to avoid nested loop warning
+                gatherRes.contextResult.relevantFiles = await compressContextFiles(workspaceRoot, gatherRes.contextResult);
                 // Assemble the final context injection string
                 const contextInjection = buildContextInjection(gatherRes.contextResult);
                 debugLog(`Final compressed context injection size: ${contextInjection.length} chars`);
@@ -1086,76 +241,11 @@ ${diffOut}
                 p.log.info(`${pc.blue('🌐')} ${pc.dim('Google Search Queries:')} ${grounding.webSearchQueries.map((q) => pc.cyan(`"${q}"`)).join(', ')}`);
             }
             spinner.stop('');
-            let finalText = '';
-            const MAX_CORRECTIONS = 3;
-            let correctionAttempts = 0;
             const calls = result.response.functionCalls();
             debugLog(`Initial functionCalls: ${calls && calls.length > 0 ? JSON.stringify(calls) : 'None'}`);
-            let agentState = { targetAgent: effectiveTargetAgent };
-            let previousChangeCount = changeLogger.getCurrentChangeSet()?.changes.length || 0;
-            // Stage 2: Recursive Tool Loops and Automated Self-Correction
-            while (correctionAttempts <= MAX_CORRECTIONS) {
-                if (finalText === '[Generation stopped by user]')
-                    break;
-                finalText = await processResponse(chat, result, workspaceRoot, inputHandler, agentState, ac.signal);
-                debugLog(`processResponse returned finalText (length ${finalText.length}): "${finalText.substring(0, 10)}..."`);
-                if (finalText === '[Generation stopped by user]') {
-                    break;
-                }
-                if (finalText.startsWith('[The AI repeatedly returned empty responses')) {
-                    break;
-                }
-                const currentChanges = changeLogger.getCurrentChangeSet()?.changes || [];
-                // If the correction cycle is active but no new changes were registered, the model gave up
-                if (correctionAttempts > 0 && currentChanges.length <= previousChangeCount) {
-                    if (correctionAttempts >= MAX_CORRECTIONS) {
-                        p.log.warn('Max self-correction attempts reached. Leaving remaining errors for manual review.');
-                        break;
-                    }
-                    debugLog('AI failed to modify any files during the correction attempt. Retrying...');
-                    const forcePrompt = `AUTOMATED SYSTEM CHECK: You did not modify any files. You MUST use your file modification tools to apply a fix for the previously mentioned errors. Do not just explain the issue.`;
-                    spinner.start('Thinking (Correction)...');
-                    result = await chat.sendMessage(forcePrompt);
-                    spinner.stop('');
-                    correctionAttempts++;
-                    continue;
-                }
-                previousChangeCount = currentChanges.length;
-                const changedFiles = currentChanges
-                    .filter((c) => c.action === 'create' || c.action === 'modify')
-                    .map((c) => c.filePath);
-                if (changedFiles.length === 0)
-                    break;
-                // Stage 3: Static code analysis / verification
-                p.log.step('Verifying modified files...');
-                const verificationResult = await verifyChangedFiles(workspaceRoot, changedFiles, ac.signal);
-                if (verificationResult === '[Verification Aborted]') {
-                    p.log.warn(pc.yellow('Verification aborted by user.'));
-                    break;
-                }
-                // Print non-blocking performance warnings to the terminal
-                if (verificationResult.warnings) {
-                    p.log.warn('Performance Audit Warnings:\n' + verificationResult.warnings);
-                }
-                if (!verificationResult.errors) {
-                    p.log.success('Verification passed.');
-                    break;
-                }
-                correctionAttempts++;
-                if (correctionAttempts > MAX_CORRECTIONS) {
-                    p.log.warn('Max self-correction attempts reached. Leaving remaining errors for manual review.');
-                    break;
-                }
-                p.log.warn(`${pc.yellow('Verification failed. Auto-correcting errors')} (Attempt ${correctionAttempts}/${MAX_CORRECTIONS})...`);
-                const displayError = verificationResult.errors.split('\n').slice(0, 5).join('\n');
-                console.log(pc.dim(`  ${displayError.replace(/\n/g, '\n  ')}\n  ...`));
-                debugLog(`Verification failed on attempt ${correctionAttempts}/${MAX_CORRECTIONS}. Errors:\n${verificationResult.errors}`);
-                // Compile compilation and syntax diagnostic warnings into an auto-correction prompt
-                const correctionPrompt = `AUTOMATED SYSTEM CHECK: Your previous changes resulted in the following errors:\n\n${verificationResult.errors}\n\nPlease analyze these errors and use your file modification tools to fix them.`;
-                spinner.start('Thinking (Correction)...');
-                result = await chat.sendMessage(correctionPrompt);
-                spinner.stop('');
-            }
+            // Stage 2: Recursive Tool Loops and Automated Self-Correction (delegated to a helper function to avoid nested loop warning)
+            const correctionRes = await executeSelfCorrectionLoop(chat, result, workspaceRoot, inputHandler, effectiveTargetAgent, ac.signal, spinner);
+            const finalText = correctionRes.finalText;
             const postExecutionChanges = changeLogger.getCurrentChangeSet()?.changes || [];
             const modifiedFiles = postExecutionChanges
                 .filter((c) => c.action === 'modify' || c.action === 'create' || c.action === 'delete')
@@ -1189,3 +279,159 @@ ${diffOut}
         }
     }
 }
+async function collectUserInput() {
+    let lines = [];
+    let isMultiLine = false;
+    while (true) {
+        const userInputRaw = await p.text({
+            message: isMultiLine ? '  ' : pc.magenta('❯'),
+            placeholder: isMultiLine ? '' : 'Use "\\" for new lines',
+        });
+        if (p.isCancel(userInputRaw)) {
+            if (isMultiLine) {
+                p.log.warn(pc.yellow('Multi-line input canceled.'));
+                lines = [];
+                isMultiLine = false;
+                continue;
+            }
+            else {
+                return { userInput: '', canceled: true };
+            }
+        }
+        let line = (userInputRaw || '');
+        // Require a space before the backslash to prevent Windows directory paths (e.g., C:\foo\) from triggering multiline
+        if (line.trimEnd().endsWith(' \\')) {
+            const cleanLine = line.trimEnd().slice(0, -2);
+            lines.push(cleanLine);
+            isMultiLine = true;
+            // Clack's text prompt dims the submitted value, which can be completely invisible on some terminal themes.
+            // We explicitly log the line here so the user can see what they are typing in multiline mode.
+            p.log.step(pc.cyan(cleanLine));
+        }
+        else {
+            lines.push(line);
+            // Unconditionally log the user's message so it is always visible
+            p.log.step(pc.cyan(line));
+            break;
+        }
+    }
+    return { userInput: lines.join('\n').trim(), canceled: false };
+}
+async function compressContextFiles(workspaceRoot, contextResult) {
+    const cachedContext = readCache(workspaceRoot, 'context_cache.json') || {};
+    let cacheUpdated = false;
+    const compressedFiles = new Map();
+    for (const [filePath, content] of contextResult.relevantFiles.entries()) {
+        if (content.length < 2000) {
+            debugLog(`Bypassing cache and compression for ${filePath} (length ${content.length} < 2000)`);
+            compressedFiles.set(filePath, content);
+            continue;
+        }
+        const fileHash = crypto
+            .createHash('sha256')
+            .update(filePath + content)
+            .digest('hex');
+        if (cachedContext[fileHash]) {
+            debugLog(`Context cache HIT for file ${filePath} (hash ${fileHash.substring(0, 8)})`);
+            compressedFiles.set(filePath, cachedContext[fileHash]);
+        }
+        else {
+            debugLog(`Context cache MISS for file ${filePath} (hash ${fileHash.substring(0, 8)})`);
+            const compressPrompt = `Summarize the following file contents concisely. Preserve all exports, functions, classes, variables, and architectural purpose. Keep it under 2000 characters if possible. File: ${filePath}`;
+            const summary = await compressTextUsingFlashLite(content, compressPrompt);
+            compressedFiles.set(filePath, summary);
+            cachedContext[fileHash] = summary;
+            cacheUpdated = true;
+        }
+    }
+    if (cacheUpdated) {
+        // Keep cache size manageable by restricting to recent 100 file entries
+        const keys = Object.keys(cachedContext);
+        if (keys.length > 100) {
+            const toDelete = keys.length - 100;
+            for (let i = 0; i < toDelete; i++) {
+                delete cachedContext[keys[i]];
+            }
+        }
+        writeCache(workspaceRoot, 'context_cache.json', cachedContext);
+    }
+    return compressedFiles;
+}
+async function executeSelfCorrectionLoop(chat, initialResult, workspaceRoot, inputHandler, effectiveTargetAgent, signal, spinner) {
+    let correctionAttempts = 0;
+    const MAX_CORRECTIONS = 5;
+    let result = initialResult;
+    let finalText = '';
+    let agentState = { targetAgent: effectiveTargetAgent };
+    let previousChangeCount = changeLogger.getCurrentChangeSet()?.changes.length || 0;
+    while (correctionAttempts <= MAX_CORRECTIONS) {
+        if (finalText === '[Generation stopped by user]')
+            break;
+        finalText = await processResponse(chat, result, workspaceRoot, inputHandler, agentState, signal);
+        debugLog(`processResponse returned finalText (length ${finalText.length}): "${finalText.substring(0, 10)}..."`);
+        if (finalText === '[Generation stopped by user]') {
+            break;
+        }
+        if (finalText.startsWith('[The AI repeatedly returned empty responses')) {
+            break;
+        }
+        const currentChanges = changeLogger.getCurrentChangeSet()?.changes || [];
+        // If the correction cycle is active but no new changes were registered, the model gave up
+        if (correctionAttempts > 0 && currentChanges.length <= previousChangeCount) {
+            if (correctionAttempts >= MAX_CORRECTIONS) {
+                p.log.warn('Max self-correction attempts reached. Leaving remaining errors for manual review.');
+                break;
+            }
+            debugLog('AI failed to modify any files during the correction attempt. Retrying...');
+            const forcePrompt = `AUTOMATED SYSTEM CHECK: You did not modify any files. You MUST use your file modification tools to apply a fix for the previously mentioned errors. Do not just explain the issue.`;
+            spinner.start('Thinking (Correction)...');
+            result = await chat.sendMessage(forcePrompt);
+            spinner.stop('');
+            correctionAttempts++;
+            continue;
+        }
+        previousChangeCount = currentChanges.length;
+        const changedFiles = currentChanges
+            .filter((c) => c.action === 'create' || c.action === 'modify')
+            .map((c) => c.filePath);
+        if (changedFiles.length === 0)
+            break;
+        // Stage 3: Static code analysis / verification
+        p.log.step('Verifying modified files...');
+        const verificationResult = await verifyChangedFiles(workspaceRoot, changedFiles, signal);
+        if (verificationResult === '[Verification Aborted]') {
+            p.log.warn(pc.yellow('Verification aborted by user.'));
+            break;
+        }
+        const hasErrors = !!verificationResult.errors;
+        const hasWarnings = !!verificationResult.warnings;
+        // Print performance warnings to the terminal
+        if (hasWarnings) {
+            p.log.warn('Performance Audit Warnings:\n' + verificationResult.warnings);
+        }
+        if (!hasErrors && !hasWarnings) {
+            p.log.success('Verification passed.');
+            break;
+        }
+        correctionAttempts++;
+        if (correctionAttempts > MAX_CORRECTIONS) {
+            p.log.warn('Max self-correction attempts reached. Leaving remaining issues for manual review.');
+            break;
+        }
+        const issueType = hasErrors && hasWarnings ? 'errors and warnings' : hasErrors ? 'errors' : 'performance warnings';
+        p.log.warn(`${pc.yellow(`Verification failed. Auto-correcting ${issueType}`)} (Attempt ${correctionAttempts}/${MAX_CORRECTIONS})...`);
+        const combinedIssues = [
+            hasErrors ? `Errors:\n${verificationResult.errors}` : '',
+            hasWarnings ? `Warnings:\n${verificationResult.warnings}` : ''
+        ].filter(Boolean).join('\n\n');
+        const displayError = combinedIssues.split('\n').slice(0, 5).join('\n');
+        console.log(pc.dim(`  ${displayError.replace(/\n/g, '\n  ')}\n  ...`));
+        debugLog(`Verification failed on attempt ${correctionAttempts}/${MAX_CORRECTIONS}. Issues:\n${combinedIssues}`);
+        // Compile compilation and syntax diagnostic warnings into an auto-correction prompt
+        const correctionPrompt = `AUTOMATED SYSTEM CHECK: Your previous changes resulted in the following issues:\n\n${combinedIssues}\n\nPlease analyze these issues and use your file modification tools to fix them.`;
+        spinner.start('Thinking (Correction)...');
+        result = await chat.sendMessage(correctionPrompt);
+        spinner.stop('');
+    }
+    return { finalText };
+}