@compass-ai/nova 1.0.74 → 1.0.76

package/dist/ui/InteractiveSession.js

@@ -1,3611 +0,0 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * React/ink component for main interactive session
- * Manages the prompt, streaming responses, slash command handling,
- * approval dialogs, and conversation state.
- */
-import React, { useState, useEffect, useCallback, useRef, useMemo } from 'react';
-import { Box, Text, useInput, Static } from 'ink';
-import chalk from 'chalk';
-import { Prompt } from './components/Prompt.js';
-import { Markdown } from './components/StreamingResponse.js';
-import { InterleavedStream } from './components/InterleavedStream.js';
-import { ApprovalDialog } from './components/ApprovalDialog.js';
-import { PlanApprovalDialog } from './components/PlanApprovalDialog.js';
-import { ClarificationWizard } from './components/ClarificationWizard.js';
-import { HelpMenu } from './components/HelpMenu.js';
-import { TokenUsage } from './components/TokenUsage.js';
-import { AgentManager } from './components/AgentManager.js';
-import { AgentCreationWizard } from './components/AgentCreationWizard.js';
-import { DiffPreview } from './components/DiffPreview.js';
-import { PlanExecutionTracker } from './components/PlanExecutionTracker.js';
-import { ExecutionModeSelector } from './components/ExecutionModeSelector.js';
-import { ConfirmationSelector } from './components/ConfirmationSelector.js';
-import { RatingPanel } from './components/RatingPanel.js';
-import { CompassSpinner } from './components/CompassSpinner.js';
-import { createTextBlock, createToolBlock } from '../types/stream.js';
-import { parseInput } from '../core/command-parser.js';
-import { executeSlashCommand, registerSlashCommand, getSlashCommandRegistry, CommandCategory, } from '../core/slash-command-handler.js';
-import { registerAllSlashCommands } from '../commands/slash/index.js';
-import { getSessionManager } from '../services/session-manager.js';
-import { getAnthropicClient } from '../services/anthropic-client.js';
-import { getApprovalManager } from '../services/approval-manager.js';
-import { getTokenTracker } from '../services/token-tracker.js';
-import { getCompassAuthService } from '../services/compass-auth-service.js';
-import { getEventEmitter } from '../core/event-emitter.js';
-import { getCodebaseIndexer } from '../services/codebase-indexer.js';
-import { getAuditLogger } from '../services/audit-logger.js';
-import { getSystemEventLogger } from '../services/system-event-logger.js';
-import { getContextBuilder } from '../core/context-builder.js';
-import { getToolRegistry } from '../services/tool-registry.js';
-import { registerBuiltInTools } from '../tools/index.js';
-import { getFileService } from '../services/file-service.js';
-import { getBackupManager } from '../services/backup-manager.js';
-import { getStatusLineExecutor } from '../services/statusline-executor.js';
-import { getConfigManager } from '../services/config-manager.js';
-import { getAgentStateService } from '../services/agent-state-service.js';
-import { checkPlanModeFallback } from '../services/plan-mode-fallback.js';
-import { pathExists } from '../utils/file-system.js';
-import { getProjectCompassDir } from '../utils/path.js';
-import { detectCloudSync } from '../utils/cloud-detection.js';
-import path from 'path';
-import { ApprovalMode, } from '../types/approval.js';
-import { logger } from '../utils/logger.js';
-import { getIdeStateService } from '../services/ide-state-service.js';
-import { getPromptPreprocessor } from '../services/prompt-preprocessor.js';
-import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_AGENTIC_ITERATIONS, DEFAULT_MAX_ITERATIONS_PER_TASK, CONTEXT_WINDOW_SAFETY_MARGIN, SLIDING_WINDOW_MAX_MESSAGES, MAX_DYNAMIC_STREAM_BLOCKS } from '../constants/defaults.js';
-import { estimateTokens, estimateSystemPromptTokens } from '../utils/token-counter.js';
-import { buildSystemPrompt as buildSystemPromptFromModule } from '../prompts/index.js';
-import { getIterationScoper } from '../services/iteration-scoper.js';
-import { getPlanPersistence } from '../services/plan-persistence.js';
-import { captureConsoleOutput } from '../utils/console-capture.js';
-import { hash as sha256Hash } from '../utils/crypto.js';
-import { getConversationCompactor } from '../services/conversation-compactor.js';
-import { getRatingStateManager } from '../services/rating-state-manager.js';
-import { getRatingService } from '../services/rating-service.js';
-import { buildSkillDescriptionsForPrompt } from '../services/skill-service.js';
-import { loadAllMemory } from '../services/memory-service.js';
-import { getModelConfig } from '../constants/models.js';
-import { getSystemUtilitiesPromptSection } from '../services/system-utility-detector.js';
-import { hasSupportedClipboardContent, extractAttachmentsFromClipboard, getClipboardContent } from '../utils/clipboard-handler.js';
-import { buildMessageContent } from '../utils/attachment-handler.js';
-/**
- * Estimates token count for a messages array that may contain complex content blocks.
- * Handles both simple string content and arrays of tool_use/tool_result blocks.
- *
- * @param messages - Array of messages with role and content
- * @returns Estimated token count
- */
-function estimateMessagesArrayTokens(messages) {
-    let totalTokens = 0;
-    const MESSAGE_OVERHEAD = 4; // Overhead per message for role markers
-    for (const message of messages) {
-        totalTokens += MESSAGE_OVERHEAD;
-        if (typeof message.content === 'string') {
-            totalTokens += estimateTokens(message.content);
-        }
-        else if (Array.isArray(message.content)) {
-            // Handle content blocks (tool_use, tool_result, text, etc.)
-            for (const block of message.content) {
-                if (typeof block === 'string') {
-                    totalTokens += estimateTokens(block);
-                }
-                else if (block && typeof block === 'object') {
-                    // Content block object
-                    const contentBlock = block;
-                    if (contentBlock.type === 'text' && typeof contentBlock.text === 'string') {
-                        totalTokens += estimateTokens(contentBlock.text);
-                    }
-                    else if (contentBlock.type === 'tool_use') {
-                        // Tool use block: name + input JSON
-                        totalTokens += estimateTokens(contentBlock.name || '');
-                        totalTokens += estimateTokens(JSON.stringify(contentBlock.input || {}));
-                        totalTokens += 10; // Overhead for tool_use structure
-                    }
-                    else if (contentBlock.type === 'tool_result') {
-                        // Tool result block: can have string content or nested content
-                        const resultContent = contentBlock.content;
-                        if (typeof resultContent === 'string') {
-                            totalTokens += estimateTokens(resultContent);
-                        }
-                        else if (resultContent && typeof resultContent === 'object') {
-                            totalTokens += estimateTokens(JSON.stringify(resultContent));
-                        }
-                        totalTokens += 10; // Overhead for tool_result structure
-                    }
-                    else {
-                        // Unknown block type - estimate from JSON
-                        totalTokens += estimateTokens(JSON.stringify(contentBlock));
-                    }
-                }
-            }
-        }
-    }
-    return totalTokens;
-}
-/**
- * Formats a duration in milliseconds to a human-readable string.
- */
-function formatDuration(ms) {
-    const totalSeconds = Math.round(ms / 1000);
-    if (totalSeconds < 60)
-        return `${totalSeconds}s`;
-    const hours = Math.floor(totalSeconds / 3600);
-    const minutes = Math.floor((totalSeconds % 3600) / 60);
-    const seconds = totalSeconds % 60;
-    if (hours > 0)
-        return `${hours}h${minutes > 0 ? `${minutes}m` : ''}`;
-    return seconds > 0 ? `${minutes}m${seconds}s` : `${minutes}m`;
-}
-/**
- * Extracts a short suggested reply when the assistant's response ends with a question.
- * Returns undefined when no actionable question is detected.
- */
-function deriveQuestionSuggestion(response) {
-    if (!response)
-        return undefined;
-    // Get the last meaningful line (skip trailing whitespace / blank lines)
-    const lines = response.trimEnd().split('\n');
-    const lastLine = lines[lines.length - 1]?.trim();
-    if (!lastLine || !lastLine.endsWith('?'))
-        return undefined;
-    const lower = lastLine.toLowerCase();
-    // Yes/no style questions — suggest "yes"
-    const yesNoPatterns = [
-        /^(shall|should|do you want|would you like|want me to|can i|may i|ready to)\b/i,
-        /\b(proceed|go ahead|continue|start|do that|make sense)\s*\?$/i,
-    ];
-    for (const pat of yesNoPatterns) {
-        if (pat.test(lower))
-            return 'yes';
-    }
-    // "Which" / "what option" questions with numbered or lettered choices above
-    const hasChoices = lines.slice(-6).some(l => /^\s*(\d+[\.\):]|[a-c][\.\):]|-\s)/.test(l));
-    if (hasChoices && /^(which|what)\b/i.test(lower))
-        return '1';
-    // Generic question — just offer "yes" as a safe default for action-oriented questions
-    if (/\b(ok|okay|alright|right|correct)\s*\?$/i.test(lower))
-        return 'yes';
-    return undefined;
-}
-/**
- * InteractiveSession component manages the main interactive CLI experience.
- * It handles:
- * - User input via the Prompt component
- * - Streaming responses from Claude
- * - Slash command execution
- * - Approval dialogs for file modifications
- * - Token usage tracking and display
- * - Conversation history management
- *
- * @example
- * ```tsx
- * <InteractiveSession
- *   onExit={() => process.exit(0)}
- *   projectRoot={process.cwd()}
- * />
- * ```
- */
-/**
- * Renders a single conversation entry (user, assistant, or system message).
- * Extracted as a standalone component for use with both <Static> and dynamic rendering.
- */
-const ConversationEntryComponent = ({ entry, showToolBlocks, collapseUserPrompts, expandMCPResults, formatTime }) => {
-    return (_jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [entry.role !== 'system' && (_jsxs(Box, { marginBottom: 1, children: [entry.role === 'user' ? (_jsx(Text, { color: "cyan", bold: true, children: "\u276F You" })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: "#a855f7", bold: true, children: "\u2B21" }), _jsx(Text, { color: "#c4b5fd", bold: true, children: " Nova" })] })), _jsxs(Text, { dimColor: true, children: [" ", formatTime(entry.timestamp)] })] })), _jsx(Box, { paddingLeft: entry.role === 'system' ? 0 : 2, children: entry.role === 'assistant' ? (showToolBlocks && entry.blocks && entry.blocks.length > 0 ? (_jsx(InterleavedStream, { blocks: entry.blocks, isStreaming: false, showThinkingIndicator: false, expandMCPResults: expandMCPResults })) : (_jsx(Markdown, { children: entry.content }))) : entry.role === 'user' ? ((() => {
-                    const lines = entry.content.split('\n');
-                    const maxCollapsedLines = 3;
-                    const maxCollapsedChars = 300;
-                    const hasMultipleLines = lines.length > maxCollapsedLines;
-                    const isVeryLong = entry.content.length > maxCollapsedChars;
-                    const shouldCollapse = collapseUserPrompts && (hasMultipleLines || isVeryLong);
-                    let displayContent;
-                    let truncationHint = null;
-                    if (!shouldCollapse) {
-                        displayContent = entry.content;
-                    }
-                    else if (hasMultipleLines) {
-                        displayContent = lines.slice(0, maxCollapsedLines).join('\n');
-                        const hiddenLines = lines.length - maxCollapsedLines;
-                        truncationHint = `... +${hiddenLines} lines`;
-                    }
-                    else {
-                        displayContent = entry.content.slice(0, maxCollapsedChars);
-                        const hiddenChars = entry.content.length - maxCollapsedChars;
-                        truncationHint = `... +${hiddenChars} chars`;
-                    }
-                    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { wrap: "wrap", dimColor: true, children: displayContent }), truncationHint && (_jsxs(Text, { dimColor: true, italic: true, children: [" ", truncationHint] }))] }));
-                })()) : (_jsx(Text, { wrap: "wrap", children: entry.content })) }), entry.role === 'assistant' && entry.durationMs != null && entry.durationMs >= 60000 && (_jsx(Box, { paddingLeft: 2, marginTop: 0, children: _jsxs(Text, { dimColor: true, children: ["\uD83D\uDD50 ", formatDuration(entry.durationMs)] }) }))] }));
-};
-/**
- * Self-contained "Working..." indicator with pulsing dot.
- * Uses direct stdout writes for the dot animation to avoid React/Ink re-renders entirely.
- * The offset (lines from cursor to dot) is passed via a ref so it can be updated
- * without triggering re-renders.
- * Memoized so parent re-renders don't affect it either.
- */
-const WorkingIndicator = React.memo(({ linesBelowRef }) => {
-    const dotRef = useRef(false);
-    useEffect(() => {
-        const timer = setInterval(() => {
-            dotRef.current = !dotRef.current;
-            const dot = dotRef.current ? '●' : '○';
-            const n = linesBelowRef.current;
-            const cyan = '\x1b[36m';
-            const reset = '\x1b[0m';
-            // Save cursor → move up N lines to dot position → write dot → restore cursor
-            process.stdout.write(`\x1b7\x1b[${n}F\r ${cyan}${dot}${reset}\x1b8`);
-        }, 700);
-        return () => clearInterval(timer);
-    }, [linesBelowRef]);
-    return (_jsx(Box, { paddingX: 1 }));
-});
-export const InteractiveSession = ({ onExit, projectRoot = process.cwd(), showWelcome = true, smartMode = false, initialPrompt, continueSession = false, initialAttachments, 
-// planStatus and orgName are rendered in the banner by App before session mounts
-planStatus: _planStatus, orgName: _orgName, }) => {
-    // Conversation state
-    const [conversation, setConversation] = useState([]);
-    const [isProcessing, setIsProcessing] = useState(false);
-    const [queuedMessages, setQueuedMessages] = useState([]);
-    const queuedMessagesRef = useRef([]);
-    // Lines between the working indicator dot and the terminal cursor (bottom of Ink output).
-    // Layout: WorkingIndicator | queued msgs (N) | Prompt top hr | input | bottom hr | status line
-    // = 4 fixed lines + N queued messages
-    const workingDotOffsetRef = useRef(3);
-    const [sessionPhase, setSessionPhase] = useState('idle');
-    // NOTE: streamingContent state removed - was causing flicker by triggering renders on every chunk
-    // The InterleavedStream component now handles all streaming display via streamBlocksRef
-    const [error, setError] = useState(null);
-    const [showHistory, setShowHistory] = useState(false);
-    const [, setShouldShowWelcome] = useState(showWelcome);
-    const [isInitialized, setIsInitialized] = useState(false);
-    const initialPromptSubmittedRef = useRef(false);
-    // Compass spinner state for visual feedback during operations
-    const [compassSpinner, setCompassSpinner] = useState(null);
-    // Interleaved stream blocks for Claude Code style display
-    // Using ref + throttled render counter pattern for proper Ink re-rendering during rapid updates
-    const streamBlocksRef = useRef([]);
-    // Stable empty array for InterleavedStream when idle — same reference prevents React.memo re-renders
-    const emptyBlocksRef = useRef([]);
-    const [, forceRender] = useState(0);
-    const renderScheduledRef = useRef(false);
-    // Refs to track modal states for use in scheduleRender (avoids stale closures)
-    const modalActiveRef = useRef(false);
-    // Throttled render - batches multiple streaming updates into a single re-render
-    // This prevents flickering by coalescing rapid chunk updates (~10fps for CLI)
-    // Using 100ms provides smooth CLI updates without visible flicker
-    const scheduleRender = useCallback(() => {
-        // Skip scheduling when approval modals are active to prevent flicker
-        if (modalActiveRef.current) {
-            return;
-        }
-        if (!renderScheduledRef.current) {
-            renderScheduledRef.current = true;
-            setTimeout(() => {
-                renderScheduledRef.current = false;
-                // Double-check modal state before forcing render
-                if (!modalActiveRef.current) {
-                    // Create a new array reference so React.memo on InterleavedStream
-                    // detects the change. In-place mutations (appendTextChunk, updateToolBlockById)
-                    // are batched between renders — this single shallow copy per frame (~10fps)
-                    // is cheaper than full JSON.parse and markdown parsing on every chunk.
-                    streamBlocksRef.current = [...streamBlocksRef.current];
-                    // Flush batched plan ref updates into React state in the same render frame.
-                    // This avoids separate re-renders for plan events vs streaming events.
-                    setActivePlan(activePlanRef.current);
-                    forceRender(n => n + 1);
-                }
-            }, 100); // ~10fps - optimal for CLI, eliminates flicker while staying responsive
-        }
-    }, []);
-    // Lightweight plan-only render: updates plan state without copying stream blocks.
-    // Used by plan event handlers to avoid triggering InterleavedStream re-renders
-    // (React.memo on InterleavedStream checks array reference equality).
-    const planRenderScheduledRef = useRef(false);
-    const schedulePlanRender = useCallback(() => {
-        if (modalActiveRef.current)
-            return;
-        if (!planRenderScheduledRef.current) {
-            planRenderScheduledRef.current = true;
-            setTimeout(() => {
-                planRenderScheduledRef.current = false;
-                if (!modalActiveRef.current) {
-                    setActivePlan(activePlanRef.current);
-                }
-            }, 100);
-        }
-    }, []);
-    // Helper to update stream blocks and trigger throttled re-render
-    const updateStreamBlocks = useCallback((updater) => {
-        streamBlocksRef.current = updater(streamBlocksRef.current);
-        scheduleRender();
-    }, [scheduleRender]);
-    // Optimized helper: append text to the last text block or create a new one.
-    // Mutates the ref array in-place (replacing only the changed element) to avoid
-    // creating a full new array on every streamed token (~100+ times per response).
-    const appendTextChunk = useCallback((chunk) => {
-        const blocks = streamBlocksRef.current;
-        const lastBlock = blocks[blocks.length - 1];
-        if (lastBlock && lastBlock.type === 'text') {
-            // Replace last element in-place — no spread/slice needed
-            blocks[blocks.length - 1] = { ...lastBlock, content: lastBlock.content + chunk };
-        }
-        else {
-            blocks.push(createTextBlock(chunk));
-        }
-        scheduleRender();
-    }, [scheduleRender]);
-    // Optimized helper: update a single tool block by ID without mapping the entire array.
-    // Finds the block by ID and replaces only that element in-place.
-    const updateToolBlockById = useCallback((toolId, updates, statusFilter) => {
-        const blocks = streamBlocksRef.current;
-        for (let i = blocks.length - 1; i >= 0; i--) {
-            const block = blocks[i];
-            if (block.type === 'tool' && block.id === toolId && (!statusFilter || block.status === statusFilter)) {
-                blocks[i] = { ...block, ...updates };
-                break;
-            }
-        }
-        scheduleRender();
-    }, [scheduleRender]);
-    // Helper to reset stream blocks (immediate render for clean state)
-    const resetStreamBlocks = useCallback(() => {
-        streamBlocksRef.current = [];
-        forceRender(n => n + 1);
-    }, []);
-    // Track partial JSON input per tool during generation (for incremental param display)
-    const toolPartialJsonRef = useRef(new Map());
-    // Track last rendered param count per tool to avoid unnecessary updates
-    const toolLastParamCountRef = useRef(new Map());
-    // Track last parsed length per tool to debounce tryParsePartialJson calls
-    const toolLastParsedLenRef = useRef(new Map());
-    // Abort flag for breaking the agentic loop (Esc to cancel during processing)
-    const abortLoopRef = useRef(false);
-    // AbortController for cancelling API requests immediately when user presses Esc
-    const abortControllerRef = useRef(null);
-    // Per-tool AbortController for skipping individual execute_command calls (Ctrl+X)
-    const toolAbortRef = useRef(null);
-    const currentToolNameRef = useRef(null);
-    // Checkpoint for conversation rollback on cancel
-    // Stores the conversation state before current request, allowing clean rollback if user cancels
-    const conversationCheckpointRef = useRef([]);
-    /**
-     * Attempts to parse partial JSON and extract any complete key-value pairs.
-     * This allows showing params like file_path as they stream in during tool generation.
-     * Also detects "likely complete" file paths by extension even without closing quote.
-     */
-    const tryParsePartialJson = useCallback((partialJson) => {
-        const result = {};
-        // Try full parse first (handles complete JSON)
-        try {
-            const parsed = JSON.parse(partialJson);
-            if (typeof parsed === 'object' && parsed !== null) {
-                return parsed;
-            }
-        }
-        catch {
-            // Not valid JSON yet, try to extract complete key-value pairs
-        }
-        // Extract complete string values: "key": "value"
-        // Match key-value pairs where the value is a complete quoted string
-        const stringPattern = /"([^"]+)"\s*:\s*"((?:[^"\\]|\\.)*)"/g;
-        let match;
-        while ((match = stringPattern.exec(partialJson)) !== null) {
-            // Unescape the value
-            const value = match[2].replace(/\\(.)/g, '$1');
-            result[match[1]] = value;
-        }
-        // Extract complete number values: "key": 123
-        const numberPattern = /"([^"]+)"\s*:\s*(-?\d+(?:\.\d+)?)/g;
-        while ((match = numberPattern.exec(partialJson)) !== null) {
-            result[match[1]] = parseFloat(match[2]);
-        }
-        // Extract complete boolean values: "key": true/false
-        const boolPattern = /"([^"]+)"\s*:\s*(true|false)/g;
-        while ((match = boolPattern.exec(partialJson)) !== null) {
-            result[match[1]] = match[2] === 'true';
-        }
-        // Special handling: detect file paths that appear complete by extension
-        // This catches cases like "path": "file.py (without closing quote yet)
-        // Common file extensions that indicate a likely complete path
-        const fileExtensions = /\.(py|js|ts|tsx|jsx|json|md|txt|yaml|yml|toml|rs|go|java|c|cpp|h|hpp|css|scss|html|xml|sql|sh|bash|rb|php|swift|kt|scala|vue|svelte)$/i;
-        // Look for path-like keys with incomplete string values ending in file extension
-        const incompletePathPattern = /"(file_path|path|file|filename)"\s*:\s*"([^"]+)/gi;
-        while ((match = incompletePathPattern.exec(partialJson)) !== null) {
-            const key = match[1];
-            const value = match[2];
-            // Only use if not already found (complete values take precedence) and looks like a file path
-            if (!(key in result) && fileExtensions.test(value)) {
-                result[key] = value;
-            }
-        }
-        return result;
-    }, []);
-    // NOTE: Tool execution tracking state removed - was causing flicker by triggering renders
-    // during tool execution. Audit logging is done directly through the audit logger.
-    // Overlay state
-    const [activeOverlay, setActiveOverlay] = useState('none');
-    const [diffPreview] = useState(null);
-    // Approval state
-    const [approvalMode, setApprovalMode] = useState(ApprovalMode.MANUAL);
-    const [pendingApproval, setPendingApproval] = useState(null);
-    // Execution mode state
-    const [executionMode, setExecutionMode] = useState('hybrid');
-    // Tool blocks display in history (default: true, toggle with Ctrl+T)
-    const [showToolBlocks, setShowToolBlocks] = useState(true);
-    // Collapse long user prompts in history (default: true, toggle with Ctrl+O)
-    const [collapseUserPrompts, setCollapseUserPrompts] = useState(true);
-    // Expand MCP tool results (default: false, toggle with Ctrl+O)
-    const [expandMCPResults, setExpandMCPResults] = useState(false);
-    // Throttle for expand/collapse toggle to prevent yoga-layout WASM crash on rapid toggling
-    const lastExpandToggleRef = useRef(0);
-    // Note: Slash hint moved to Prompt component to avoid parent re-renders on keystroke
-    // Logout confirmation state
-    const [logoutDetails, setLogoutDetails] = useState([]);
-    // Rating state
-    const [showRatingPanel, setShowRatingPanel] = useState(false);
-    const [hasCompassApiKey, setHasCompassApiKey] = useState(false);
-    const ratingStateManagerRef = useRef(null);
-    const ratingUsageIntervalRef = useRef(null);
-    const ratingPanelShownRef = useRef(false); // Track if panel is shown to avoid stale closure
-    // Plan approval state
-    const [pendingPlanApproval, setPendingPlanApproval] = useState(null);
-    const planApprovalClearContextRef = useRef(false);
-    // Clarification wizard state
-    const [pendingClarification, setPendingClarification] = useState(null);
-    // Keep modalActiveRef in sync with approval states and session phase (for use in scheduleRender)
-    useEffect(() => {
-        const inModal = !!(pendingApproval || pendingPlanApproval || pendingClarification);
-        const inTransition = sessionPhase === 'classifying';
-        modalActiveRef.current = inModal || inTransition;
-    }, [pendingApproval, pendingPlanApproval, pendingClarification, sessionPhase]);
-    // Suggestion offer state — shown as ghost text when the LLM ends with a question
-    const [suggestionOffer, setSuggestionOffer] = useState(undefined);
-    // Plan execution state — uses ref + throttled render to avoid per-event re-renders.
-    // Plan events (task-progress, task-completed, execution-completed) fire rapidly during
-    // the agentic loop. Routing them through a ref batches multiple updates into a single
-    // render via scheduleRender(), matching the streaming token pattern.
-    const activePlanRef = useRef(null);
-    // Snapshot for rendering — updated by scheduleRender alongside streamBlocks
-    const [activePlan, setActivePlan] = useState(null);
-    const [planTrackerMode, setPlanTrackerMode] = useState('compact');
-    // Batched metrics state - single state object to prevent multiple re-renders per API call
-    const [metrics, setMetrics] = useState({
-        tokenUsage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-        currentContextTokens: 0,
-        cost: { inputCost: 0, outputCost: 0, totalCost: 0, currency: 'USD' },
-    });
-    // Destructure for convenient access (stable references via same render)
-    const { tokenUsage, currentContextTokens, cost } = metrics;
-    // Model state
-    const [currentModel, setCurrentModel] = useState('Claude Sonnet 4.5');
-    const [contextWindowSize, setContextWindowSize] = useState(200000);
-    // Project context state
-    const [projectSummary, setProjectSummary] = useState(null);
-    const [isContextLoading, setIsContextLoading] = useState(true);
-    const [isContextStale, setIsContextStale] = useState(false);
-    const [, setIsCloudPath] = useState(false);
-    // Status line state
-    const [statusLineText, setStatusLineText] = useState('');
-    const [statusLineVisible, setStatusLineVisible] = useState(false);
-    // Active agent state (for agent switching via /agents use)
-    const [activeAgentName, setActiveAgentName] = useState(null);
-    // Slash command output state (to display output from commands like /context, /commit)
-    const [slashCommandOutput, setSlashCommandOutput] = useState(null);
-    // Streaming command output state (for real-time event-based output)
-    const [streamingCommandOutput, setStreamingCommandOutput] = useState([]);
-    const streamingOutputRef = useRef([]);
-    // Refs for cleanup
-    const unsubscribersRef = useRef([]);
-    /**
-     * Initializes the session, registers commands, and sets up event listeners
-     */
-    useEffect(() => {
-        async function initializeSession() {
-            try {
-                // Initialize audit logger
-                const auditLogger = getAuditLogger(projectRoot);
-                // Initialize session manager
-                const sessionManager = getSessionManager();
-                const existingSession = await sessionManager.load(projectRoot);
-                if (!existingSession) {
-                    sessionManager.createSession(projectRoot);
-                }
-                else {
-                    // Restore state from existing session
-                    const state = sessionManager.getState();
-                    if (state) {
-                        setApprovalMode(state.approvalMode);
-                        setExecutionMode(state.executionMode || 'hybrid');
-                        setShowToolBlocks(state.showToolBlocks ?? true);
-                        // Restore model from session if one was persisted
-                        if (state.currentModel) {
-                            try {
-                                const anthropicClient = await getAnthropicClient();
-                                anthropicClient.setModel(state.currentModel);
-                                // Update React state so the UI reflects the restored model
-                                const restoredConfig = getModelConfig(state.currentModel);
-                                if (restoredConfig) {
-                                    setCurrentModel(restoredConfig.name);
-                                    setContextWindowSize(restoredConfig.contextWindow);
-                                }
-                                logger.debug(`Restored model from session: ${state.currentModel}`);
-                            }
-                            catch (modelError) {
-                                logger.warn('Failed to restore model from session', modelError);
-                            }
-                        }
-                        // Archive and handle conversation history based on -c flag
-                        const hasHistory = state.conversationHistory && state.conversationHistory.length > 0;
-                        const hasOperations = state.operations && state.operations.length > 0;
-                        if (hasHistory) {
-                            if (continueSession) {
-                                // -c flag: Archive, load into UI context, then clear session.json
-                                const { archive, result } = await sessionManager.archiveAndClearSession();
-                                if (result.success && result.filename) {
-                                    logger.info(`Archived previous session to: ${result.filename}`);
-                                }
-                                // Load the archived messages into the UI for display
-                                if (archive && archive.messages.length > 0) {
-                                    const restoredConversation = archive.messages.map((msg, idx) => ({
-                                        id: `archived-${idx}-${Date.now()}`,
-                                        role: msg.role,
-                                        content: msg.content,
-                                        timestamp: new Date(msg.timestamp || Date.now()),
-                                        tokenCount: msg.tokenCount,
-                                    }));
-                                    setConversation(restoredConversation);
-                                    setShowHistory(true);
-                                    logger.info(`Loaded ${restoredConversation.length} messages from archived session`);
-                                }
-                            }
-                            else {
-                                // No -c flag: Archive and clear, don't load into UI
-                                const { result } = await sessionManager.archiveAndClearSession();
-                                if (result.success && result.filename) {
-                                    logger.info(`Archived previous session to: ${result.filename}`);
-                                }
-                            }
-                        }
-                        else {
-                            // No conversation history — clear stale operations if any
-                            if (hasOperations) {
-                                sessionManager.clearHistory();
-                            }
-                            // -c flag: load latest archive even when session is clean
-                            if (continueSession) {
-                                const archivalService = sessionManager.getArchivalService();
-                                const archive = await archivalService.getLatestArchive();
-                                if (archive && archive.messages.length > 0) {
-                                    const restoredConversation = archive.messages.map((msg, idx) => ({
-                                        id: `archived-${idx}-${Date.now()}`,
-                                        role: msg.role,
-                                        content: msg.content,
-                                        timestamp: new Date(msg.timestamp || Date.now()),
-                                        tokenCount: msg.tokenCount,
-                                    }));
-                                    setConversation(restoredConversation);
-                                    setShowHistory(true);
-                                    logger.info(`Loaded ${restoredConversation.length} messages from latest archive`);
-                                }
-                            }
-                        }
-                    }
-                    // If projectPath was updated during load or history was cleared, save immediately
-                    if (sessionManager.isDirty()) {
-                        await sessionManager.save();
-                    }
-                }
-                // Log session start for audit trail
-                const session = sessionManager.getSession();
-                if (session) {
-                    // Initialize system event logger with session ID
-                    const systemEventLogger = getSystemEventLogger(projectRoot);
-                    systemEventLogger.setSessionId(session.id);
-                    await systemEventLogger.logSessionStart(session.id, projectRoot);
-                    // Initialize audit logger with session ID for LLM traces
-                    auditLogger.setSessionId(session.id);
-                    await auditLogger.logSessionStart(session.id, projectRoot);
-                }
-                // Initialize token tracker
-                const tokenTracker = await getTokenTracker();
-                tokenTracker.startSession();
-                // Get current model from client
-                const client = await getAnthropicClient();
-                if (client.isInitialized()) {
-                    const model = client.getCurrentModel();
-                    setCurrentModel(model.name);
-                    setContextWindowSize(model.contextWindow);
-                }
-                // Initialize status line from config
-                try {
-                    const configManager = getConfigManager();
-                    await configManager.load(projectRoot);
-                    const statusLineConfig = configManager.getValue('ui.statusLine');
-                    logger.debug('Status line config lookup', {
-                        projectRoot,
-                        statusLineConfig: statusLineConfig || 'not found',
-                        uiConfig: configManager.getValue('ui')
-                    });
-                    const statusLineExecutor = getStatusLineExecutor();
-                    if (statusLineConfig && statusLineConfig.enabled !== false) {
-                        // User has configured a status line
-                        if (statusLineConfig.type === 'default') {
-                            // Default type: built-in context display
-                            statusLineExecutor.configure(statusLineConfig);
-                            setStatusLineVisible(true);
-                            logger.info('Status line initialized (default type)');
-                        }
-                        else if (statusLineConfig.command) {
-                            // Command type: external script
-                            statusLineExecutor.configure(statusLineConfig);
-                            setStatusLineVisible(true);
-                            logger.info('Status line initialized (command type)', { command: statusLineConfig.command });
-                        }
-                        else {
-                            logger.debug('Status line config missing command for command type');
-                        }
-                    }
-                    else if (!statusLineConfig) {
-                        // No config: use default status line automatically
-                        const defaultConfig = {
-                            type: 'default',
-                            enabled: true,
-                        };
-                        statusLineExecutor.configure(defaultConfig);
-                        setStatusLineVisible(true);
-                        logger.debug('Status line initialized (auto default)');
-                    }
-                    else {
-                        logger.debug('Status line explicitly disabled');
-                    }
-                }
-                catch (err) {
-                    logger.error('Failed to initialize status line', err);
-                }
-                // Register slash commands (includes custom commands from .compass/commands/)
-                await registerCommands();
-                // Initialize SMART mode with session auto-approval if enabled via CLI
-                if (smartMode) {
-                    const approvalManager = getApprovalManager();
-                    approvalManager.setMode(ApprovalMode.SMART);
-                    approvalManager.enableSessionAutoApproval();
-                    setApprovalMode(ApprovalMode.SMART);
-                    logger.info('SMART mode enabled via CLI - session auto-approval active');
-                }
-                // Initialize tool registry with built-in tools
-                const toolRegistry = getToolRegistry();
-                toolRegistry.setProjectRoot(projectRoot);
-                // Initialize file service with project root
-                const fileService = getFileService();
-                fileService.setProjectRoot(projectRoot);
-                logger.debug(`File service project root set to: ${projectRoot}`);
-                // Initialize backup manager with project root
-                const backupManager = await getBackupManager();
-                backupManager.setProjectRoot(projectRoot);
-                logger.debug(`Backup manager project root set to: ${projectRoot}`);
-                registerBuiltInTools();
-                logger.debug(`Registered ${toolRegistry.getAllTools().length} tools`);
-                // Subscribe to events
-                subscribeToEvents();
-                // Emit history-cleared if we cleared on startup (ensures UI state is reset)
-                if (!continueSession) {
-                    getEventEmitter().emit('history-cleared', { isStartup: true });
-                }
-                // Start auto-save
-                sessionManager.startAutoSave(60000); // Auto-save every minute
-                // Check if file index exists and trigger performant re-index in background
-                await checkAndReindexIfNeeded();
-                // Load project context summary for system prompt
-                // On cloud-synced folders, defer to background to avoid blocking the UI
-                const cloudInfo = detectCloudSync(projectRoot);
-                if (cloudInfo.isCloud) {
-                    logger.info(`Cloud-synced folder detected (${cloudInfo.provider}), loading context in background`);
-                    setIsCloudPath(true);
-                    setIsContextLoading(false);
-                    loadProjectContext().catch(err => logger.debug('Background context load failed', err));
-                }
-                else {
-                    await loadProjectContext();
-                }
-                // Subscribe to file-modified events to mark context as stale
-                const eventEmitter = getEventEmitter();
-                const unsubscribeFileModified = eventEmitter.on('file-modified', ({ operation }) => {
-                    // Only mark as stale for create/delete operations (not modifications to existing files)
-                    if (operation === 'create' || operation === 'delete') {
-                        logger.debug(`File ${operation} detected - marking project context as stale`);
-                        setIsContextStale(true);
-                    }
-                });
-                unsubscribersRef.current.push(unsubscribeFileModified);
-                // Subscribe to manual context refresh events (from /context refresh command)
-                const unsubscribeContextRefreshed = eventEmitter.on('project-context-refreshed', ({ summary }) => {
-                    logger.debug('Project context manually refreshed via /context refresh');
-                    setProjectSummary(summary);
-                    setIsContextStale(false);
-                });
-                unsubscribersRef.current.push(unsubscribeContextRefreshed);
-                // Initialize rating system if Compass API key is available
-                try {
-                    const { getCredentialStore } = await import('../services/credential-store.js');
-                    const credentialStore = await getCredentialStore();
-                    const compassApiKey = await credentialStore.getCompassApiKey();
-                    if (compassApiKey) {
-                        setHasCompassApiKey(true);
-                        // Initialize rating state manager
-                        const ratingStateManager = await getRatingStateManager();
-                        ratingStateManagerRef.current = ratingStateManager;
-                        // Configure rating service with API key
-                        const ratingService = getRatingService();
-                        ratingService.setApiKey(compassApiKey);
-                        // Start periodic usage tracking (every 10 seconds)
-                        ratingUsageIntervalRef.current = setInterval(() => {
-                            if (ratingStateManagerRef.current && !ratingPanelShownRef.current) {
-                                ratingStateManagerRef.current.updateUsageTime();
-                                // Check if we should show rating
-                                if (ratingStateManagerRef.current.shouldShowRating()) {
-                                    ratingPanelShownRef.current = true;
-                                    setShowRatingPanel(true);
-                                    ratingStateManagerRef.current.recordRatingShown();
-                                }
-                            }
-                        }, 10000);
-                        logger.debug('[Rating] Rating system initialized');
-                    }
-                }
-                catch (ratingError) {
-                    logger.debug('[Rating] Failed to initialize rating system', ratingError);
-                }
-                // Mark initialization as complete
-                setIsInitialized(true);
-                logger.debug('Session initialization complete');
-            }
-            catch (err) {
-                logger.error('Failed to initialize session', err);
-                setError('Failed to initialize session. Please try again.');
-            }
-        }
-        initializeSession();
-        // Cleanup on unmount
-        return () => {
-            // Clear rating usage interval
-            if (ratingUsageIntervalRef.current) {
-                clearInterval(ratingUsageIntervalRef.current);
-                ratingUsageIntervalRef.current = null;
-            }
-            // Unsubscribe from all events
-            for (const unsubscribe of unsubscribersRef.current) {
-                unsubscribe();
-            }
-            // Disconnect MCP servers
-            import('../services/mcp-server-manager.js')
-                .then(({ getMCPServerManager }) => {
-                const mcpServerManager = getMCPServerManager();
-                return mcpServerManager.disconnectAllServers();
-            })
-                .then(() => {
-                logger.debug('MCP servers disconnected on unmount');
-            })
-                .catch((err) => {
-                logger.debug('Failed to disconnect MCP servers on unmount', err);
-            });
-            // Log session end for audit trail
-            const sessionManager = getSessionManager();
-            const session = sessionManager.getSession();
-            if (session) {
-                // Log to system event logger
-                const systemEventLogger = getSystemEventLogger(projectRoot);
-                systemEventLogger.logSessionEnd().catch((err) => {
-                    logger.debug('Failed to log system session end', err);
-                });
-                // Log to audit logger (LLM traces)
-                const auditLogger = getAuditLogger(projectRoot);
-                auditLogger.logSessionEnd(session.id).catch((err) => {
-                    logger.debug('Failed to log audit session end', err);
-                });
-            }
-            // Stop auto-save and save final state
-            sessionManager.stopAutoSave();
-            sessionManager.save().catch((err) => {
-                logger.error('Failed to save session on exit', err);
-            });
-        };
-    }, [projectRoot, smartMode, continueSession]);
-    /**
-     * Auto-submits initial prompt when provided and session is initialized
-     */
-    useEffect(() => {
-        if (isInitialized && initialPrompt && !initialPromptSubmittedRef.current && !isProcessing) {
-            initialPromptSubmittedRef.current = true;
-            logger.debug('Auto-submitting initial prompt', { promptLength: initialPrompt.length });
-            // Use setTimeout to ensure React has finished rendering
-            setTimeout(() => {
-                handleSubmit(initialPrompt);
-            }, 100);
-        }
-    }, [isInitialized, initialPrompt, isProcessing]);
-    /**
-     * Adds initial attachments to session manager when provided
-     */
-    useEffect(() => {
-        if (isInitialized && initialAttachments && initialAttachments.length > 0) {
-            const sessionManager = getSessionManager();
-            sessionManager.addPendingAttachments(initialAttachments);
-            logger.info(`Added ${initialAttachments.length} initial attachments to session`);
-        }
-    }, [isInitialized, initialAttachments]);
-    /**
-     * Updates the status line when conversation, tokens, or model changes.
-     * Debounced to prevent excessive updates during rapid API calls.
-     */
-    const statusLineTimerRef = useRef(null);
-    useEffect(() => {
-        if (!statusLineVisible) {
-            return;
-        }
-        // Debounce: wait 2s after last dependency change before updating
-        if (statusLineTimerRef.current) {
-            clearTimeout(statusLineTimerRef.current);
-        }
-        statusLineTimerRef.current = setTimeout(async () => {
-            const executor = getStatusLineExecutor();
-            if (!executor.isEnabled()) {
-                return;
-            }
-            try {
-                // Get current session info
-                const sessionManager = getSessionManager();
-                const session = sessionManager.getSession();
-                // Get current model info
-                const client = await getAnthropicClient();
-                const model = client.isInitialized() ? client.getCurrentModel() : null;
-                // Gather rolling window token limit info for the status line
-                let tokenLimitUsed;
-                let tokenLimitMax;
-                let planType;
-                try {
-                    const modelId = model?.id || 'unknown';
-                    const compassAuth = getCompassAuthService();
-                    const planStatus = compassAuth.getPlanStatus();
-                    planType = compassAuth.getPlanType();
-                    const tracker = await getTokenTracker();
-                    const { modelLimit } = tracker.resolveLimit(modelId, planStatus, planType);
-                    if (modelLimit !== Infinity) {
-                        tokenLimitUsed = await tracker.getUsageForModel(modelId);
-                        tokenLimitMax = modelLimit;
-                    }
-                }
-                catch {
-                    // Non-critical — skip token limit display on error
-                }
-                // Build status line context
-                const data = executor.buildStatusData({
-                    sessionId: session?.id,
-                    projectRoot,
-                    cwd: process.cwd(),
-                    modelId: model?.id || 'unknown',
-                    modelDisplayName: model?.name || currentModel,
-                    totalCostUsd: cost.totalCost,
-                    totalDurationMs: 0, // TODO: Track session duration if needed
-                    totalApiDurationMs: 0,
-                    totalLinesAdded: 0,
-                    totalLinesRemoved: 0,
-                    totalInputTokens: currentContextTokens, // Use current context, not cumulative
-                    totalOutputTokens: tokenUsage.outputTokens,
-                    contextWindowSize: model?.contextWindow || 200000,
-                    transcriptPath: session?.id ? `${projectRoot}/.compass/sessions/${session.id}.json` : undefined,
-                    tokenLimitUsed,
-                    tokenLimitMax,
-                    planType: planType ?? undefined,
-                });
-                const result = await executor.execute(data);
-                if (result.success || result.text) {
-                    setStatusLineText(result.text);
-                }
-            }
-            catch (err) {
-                logger.debug('Failed to update status line', err);
-            }
-        }, 2000);
-        return () => {
-            if (statusLineTimerRef.current) {
-                clearTimeout(statusLineTimerRef.current);
-            }
-        };
-    }, [conversation, metrics, currentModel, statusLineVisible, projectRoot]);
-    /**
-     * Checks if file index exists and triggers performant re-index in background
-     */
-    async function checkAndReindexIfNeeded() {
-        try {
-            const indexPath = path.join(getProjectCompassDir(projectRoot), 'index', 'file-index.json');
-            // Check if index exists
-            if (await pathExists(indexPath)) {
-                logger.debug('File index found, starting background re-index for changed files...');
-                // Trigger re-index in background (non-blocking)
-                // This only re-indexes files that have changed since last index
-                const indexer = await getCodebaseIndexer(projectRoot);
-                indexer.indexProject(projectRoot, {
-                    force: false, // Only re-index changed files for performance
-                    onProgress: (current, total) => {
-                        // Log progress periodically (every 10%)
-                        if (current % Math.max(1, Math.floor(total / 10)) === 0) {
-                            logger.debug(`Re-indexing: ${current}/${total} files checked`);
-                        }
-                    },
-                }).then((result) => {
-                    if (result.newFiles > 0 || result.updatedFiles > 0 || result.removedFiles > 0) {
-                        logger.debug(`Index updated: ${result.newFiles} new, ${result.updatedFiles} updated, ${result.removedFiles} removed`);
-                    }
-                    else {
-                        logger.debug('Index is up to date');
-                    }
-                }).catch((err) => {
-                    logger.debug('Background re-index failed', err);
-                });
-            }
-        }
-        catch (err) {
-            logger.debug('Failed to check for file index', err);
-        }
-    }
-    /**
-     * Loads project context summary for system prompt injection
-     */
-    async function loadProjectContext() {
-        try {
-            logger.debug('Loading project context...');
-            const contextBuilder = getContextBuilder({ projectRoot });
-            const summary = await contextBuilder.getProjectSummary();
-            setProjectSummary(summary);
-            logger.debug(`Project context loaded: ${summary.name} (${summary.projectType})`);
-            logger.info(`Project: ${summary.name} (${summary.projectType}) - ${summary.fileCount} files`);
-        }
-        catch (err) {
-            logger.debug('Failed to load project context', err);
-            // Non-fatal - continue without project context
-        }
-        finally {
-            setIsContextLoading(false);
-        }
-    }
-    /**
-     * Refreshes project context if marked as stale (e.g., after file creation/deletion).
-     * This ensures the system prompt has up-to-date project structure information
-     * for Anthropic's prompt caching to work effectively with fresh context.
-     *
-     * Note: Anthropic's prompt cache uses ephemeral TTL (5 minutes by default).
-     * When the system prompt changes, a new cache entry is created and the old
-     * one expires after the TTL - Anthropic doesn't keep historical versions.
-     */
-    async function refreshProjectContext() {
-        if (!isContextStale) {
-            logger.debug('Project context is not stale, skipping refresh');
-            return;
-        }
-        try {
-            logger.info('Refreshing project context (files changed)...');
-            const contextBuilder = getContextBuilder({ projectRoot });
-            const summary = await contextBuilder.getProjectSummary();
-            setProjectSummary(summary);
-            setIsContextStale(false);
-            logger.info(`Project context refreshed: ${summary.name} - ${summary.fileCount} files`);
-        }
-        catch (err) {
-            logger.debug('Failed to refresh project context', err);
-            // Non-fatal - continue with existing context
-        }
-    }
-    /**
-     * Builds the system prompt with project context, model info, and tool guidance.
-     * Uses the centralized buildSystemPrompt from the prompts module.
-     * If an agent is active, uses the agent's system prompt instead.
-     */
-    async function buildSystemPrompt(summary, modelName, modelId) {
-        const agentState = getAgentStateService();
-        const activeAgent = agentState.getActiveAgent();
-        // Get skill descriptions for model invocation awareness
-        const skillDescriptions = await buildSkillDescriptionsForPrompt();
-        // Get effective personality mode and unguarded mode from session
-        const sessionMgr = getSessionManager();
-        const personalityMode = sessionMgr.getEffectivePersonalityMode();
-        const unguardedMode = sessionMgr.getUnguardedMode();
-        // Get system utilities section for unguarded mode
-        let systemUtilitiesSection;
-        if (unguardedMode) {
-            try {
-                systemUtilitiesSection = await getSystemUtilitiesPromptSection();
-                if (systemUtilitiesSection) {
-                    logger.debug('System utilities section generated for unguarded mode');
-                }
-            }
-            catch (error) {
-                logger.debug('Failed to generate system utilities section', error);
-            }
-        }
-        // Load memory content (NOVA.md + auto memory)
-        let memoryContent = '';
-        try {
-            memoryContent = await loadAllMemory(projectRoot);
-        }
-        catch (error) {
-            logger.debug('Failed to load memory content', error);
-        }
-        // If an agent is active, use its system prompt
-        if (activeAgent) {
-            logger.debug(`Using active agent system prompt: ${activeAgent.name}`, {
-                standalone: activeAgent.standalone,
-                model: activeAgent.model,
-            });
-            // Standalone agents use ONLY their prompt, non-standalone agents
-            // get the base prompt with agent prompt appended
-            if (activeAgent.standalone) {
-                // Pure standalone: just the agent's prompt + project context + skills
-                let agentPrompt = activeAgent.systemPrompt;
-                if (skillDescriptions) {
-                    agentPrompt = `${agentPrompt}\n${skillDescriptions}`;
-                }
-                if (summary) {
-                    agentPrompt = `${agentPrompt}\n\n${summary.formatted}`;
-                }
-                if (memoryContent) {
-                    agentPrompt = `${agentPrompt}\n\n${memoryContent}`;
-                }
-                return agentPrompt;
-            }
-            else {
-                // Non-standalone: base prompt + agent's additional instructions
-                const basePrompt = buildSystemPromptFromModule({
-                    projectSummary: summary ? { formatted: summary.formatted } : null,
-                    workingDirectory: projectRoot,
-                    modelName,
-                    modelId,
-                    skillDescriptions,
-                    personalityMode,
-                    unguardedMode,
-                    systemUtilitiesSection,
-                });
-                // Append agent's specialized instructions
-                let combinedPrompt = `# Active Agent: ${activeAgent.name}
-
-You are now operating as the "${activeAgent.name}" agent. Follow these specialized instructions:
-
-${activeAgent.systemPrompt}
-
-# Fallback Instructions
-If the above agent-specific instructions are insufficient to fully satisfy the user request, follow the general instructions below.
-
-${basePrompt}
-`;
-                if (memoryContent) {
-                    combinedPrompt = `${combinedPrompt}\n\n${memoryContent}`;
-                }
-                return combinedPrompt;
-            }
-        }
-        // Default: use the standard Compass system prompt
-        let defaultPrompt = buildSystemPromptFromModule({
-            projectSummary: summary ? { formatted: summary.formatted } : null,
-            workingDirectory: projectRoot,
-            modelName,
-            modelId,
-            skillDescriptions,
-            personalityMode,
-            unguardedMode,
-            systemUtilitiesSection,
-        });
-        if (memoryContent) {
-            defaultPrompt = `${defaultPrompt}\n\n${memoryContent}`;
-        }
-        return defaultPrompt;
-    }
-    /**
-     * Registers all slash commands with the command handler
-     */
-    async function registerCommands() {
-        const registry = getSlashCommandRegistry();
-        // Register all slash commands from the central registry (includes custom commands)
-        await registerAllSlashCommands();
-        // Override specific commands that need UI-specific behavior
-        // (Re-registering will replace the centrally-registered versions)
-        // Help command - shows overlay instead of text output
-        registerSlashCommand({
-            name: 'help',
-            aliases: ['h', '?'],
-            description: 'Show help menu',
-            category: CommandCategory.INFO,
-            requiresLLM: false,
-            canRunOffline: true,
-            handler: () => {
-                setActiveOverlay((prev) => (prev === 'help' ? 'none' : 'help'));
-            },
-        });
-        // Tokens command - shows overlay instead of text output
-        registerSlashCommand({
-            name: 'tokens',
-            aliases: ['usage', 'cost'],
-            description: 'Show token usage statistics',
-            category: CommandCategory.INFO,
-            requiresLLM: false,
-            canRunOffline: true,
-            handler: () => {
-                setActiveOverlay((prev) => (prev === 'tokens' ? 'none' : 'tokens'));
-            },
-        });
-        // Agents command - shows overlay for list, delegates subcommands to original handler
-        registerSlashCommand({
-            name: 'agents',
-            aliases: ['agent', 'subagents'],
-            description: 'Manage sub-agents for task delegation',
-            category: CommandCategory.INFO,
-            requiresLLM: false,
-            canRunOffline: true,
-            handler: async (args) => {
-                // Show overlay for no args or list subcommand
-                if (args.length === 0 || args[0].toLowerCase() === 'list' || args[0].toLowerCase() === 'ls' || args[0] === '-l') {
-                    setActiveOverlay((prev) => (prev === 'agents' ? 'none' : 'agents'));
-                    return;
-                }
-                // For other subcommands, use the original handler from agents.ts
-                const { agentsHandler } = await import('../commands/slash/agents.js');
-                await agentsHandler(args);
-            },
-        });
-        // Clear command - updates React state
-        registerSlashCommand({
-            name: 'clear',
-            aliases: ['cls'],
-            description: 'Clear conversation history',
-            category: CommandCategory.SESSION,
-            requiresLLM: false,
-            canRunOffline: true,
-            handler: () => {
-                // Reset all UI conversation state
-                setConversation([]);
-                setShowHistory(false);
-                setSlashCommandOutput(null);
-                setStreamingCommandOutput([]);
-                streamingOutputRef.current = [];
-                setError(null);
-                setIsProcessing(false);
-                setSessionPhase('idle');
-                setCompassSpinner(null);
-                setActiveOverlay('none');
-                setPendingApproval(null);
-                setPendingPlanApproval(null);
-                setPendingClarification(null);
-                setSuggestionOffer(undefined);
-                activePlanRef.current = null;
-                setActivePlan(null);
-                setPlanTrackerMode('compact');
-                setMetrics((prev) => ({ ...prev, currentContextTokens: 0 }));
-                // Reset stream blocks ref (static ref is cleared by useMemo when conversation empties)
-                streamBlocksRef.current = [];
-                // Clear session history and stop plan monitoring
-                const sessionManager = getSessionManager();
-                sessionManager.clearHistory();
-                const planPersistence = getPlanPersistence(projectRoot);
-                planPersistence.stopFileMonitoring();
-                // Notify listeners and confirm
-                getEventEmitter().emit('history-cleared', {});
-                getEventEmitter().emit('slash-command-output', { command: 'clear', message: 'Conversation cleared.', isError: false });
-            },
-        });
-        // Exit command - calls onExit callback
-        registerSlashCommand({
-            name: 'exit',
-            aliases: ['quit', 'q'],
-            description: 'Exit Compass',
-            category: CommandCategory.SYSTEM,
-            requiresLLM: false,
-            canRunOffline: true,
-            executeOnComplete: true,
-            handler: async () => {
-                const sessionManager = getSessionManager();
-                await sessionManager.save();
-                // Trigger graceful cleanup, then force exit as a safety net
-                void onExit();
-                setTimeout(() => process.exit(0), 500);
-                await new Promise(() => { });
-            },
-        });
-        // Approve command - updates React state
-        registerSlashCommand({
-            name: 'approve',
-            aliases: ['approval', 'mode'],
-            description: 'Toggle or set approval mode',
-            category: CommandCategory.MODEL,
-            requiresLLM: false,
-            canRunOffline: true,
-            handler: async (args) => {
-                const approvalManager = getApprovalManager();
-                const sessionManager = getSessionManager();
-                const eventEmitter = getEventEmitter();
-                const emitOutput = (message, isError = false) => {
-                    eventEmitter.emit('slash-command-output', { command: 'approve', message, isError });
-                };
-                if (args.length === 0) {
-                    // Toggle mode
-                    const newMode = approvalManager.toggleMode();
-                    sessionManager.setApprovalMode(newMode);
-                    setApprovalMode(newMode);
-                    emitOutput(`Approval mode: ${newMode.toUpperCase()}`);
-                }
-                else {
-                    const modeArg = args[0].toLowerCase();
-                    let newMode;
-                    switch (modeArg) {
-                        case 'auto':
-                        case 'a':
-                            newMode = ApprovalMode.AUTO;
-                            break;
-                        case 'manual':
-                        case 'm':
-                            newMode = ApprovalMode.MANUAL;
-                            break;
-                        case 'strict':
-                        case 's':
-                            newMode = ApprovalMode.STRICT;
-                            break;
-                        case 'smart':
-                        case 'sm':
-                            newMode = ApprovalMode.SMART;
-                            break;
-                        default:
-                            emitOutput(`Unknown mode: ${modeArg}. Use: auto, manual, strict, or smart`, true);
-                            return;
-                    }
-                    approvalManager.setMode(newMode);
-                    sessionManager.setApprovalMode(newMode);
-                    setApprovalMode(newMode);
-                    emitOutput(`Approval mode set to: ${newMode.toUpperCase()}`);
-                }
-            },
-        });
-        // Model command - updates React state via events
-        registerSlashCommand({
-            name: 'model',
-            description: 'Switch model',
-            category: CommandCategory.MODEL,
-            requiresLLM: false,
-            canRunOffline: true,
-            handler: async (args) => {
-                const client = await getAnthropicClient();
-                const eventEmitter = getEventEmitter();
-                // Helper to emit output that will be captured by the event listener
-                const emitOutput = (message) => {
-                    eventEmitter.emit('slash-command-output', { command: 'model', message, isError: false });
-                };
-                if (args.length === 0) {
-                    // Show current model
-                    const model = client.getCurrentModel();
-                    emitOutput(`Current model: ${model.name}`);
-                    emitOutput('Available: sonnet, opus, haiku');
-                    return;
-                }
-                const modelArg = args[0].toLowerCase();
-                const success = client.setModel(modelArg);
-                if (success) {
-                    const model = client.getCurrentModel();
-                    setCurrentModel(model.name);
-                    setContextWindowSize(model.contextWindow);
-                    const sessionManager = getSessionManager();
-                    sessionManager.setModel(model.id);
-                    emitOutput(`Switched to: ${model.name}`);
-                }
-                else {
-                    eventEmitter.emit('slash-command-output', { command: 'model', message: `Unknown model: ${modelArg}. Use: sonnet, opus, or haiku`, isError: true });
-                }
-            },
-        });
-        // Switch-plan command - toggles execution mode
-        registerSlashCommand({
-            name: 'switch-plan',
-            aliases: ['sp', 'mode'],
-            description: 'Switch execution mode (hybrid/direct/plan)',
-            category: CommandCategory.MODEL,
-            requiresLLM: false,
-            canRunOffline: true,
-            executeOnComplete: true,
-            handler: async (args) => {
-                const sessionManager = getSessionManager();
-                const eventEmitter = getEventEmitter();
-                const emitOutput = (message) => {
-                    eventEmitter.emit('slash-command-output', { command: 'switch-plan', message, isError: false });
-                };
-                const modeDescriptions = {
-                    hybrid: 'LLM decides when to use planning based on complexity',
-                    direct: 'Pure agentic execution, no planning',
-                    plan: 'Always forces planning for every task'
-                };
-                const modeAliases = {
-                    hybrid: 'h',
-                    direct: 'd',
-                    plan: 'p'
-                };
-                // No arguments - show interactive mode selector
-                if (args.length === 0) {
-                    setActiveOverlay('mode-selector');
-                    return;
-                }
-                // Argument provided - switch to specific mode
-                const modeArg = args[0].toLowerCase();
-                let newMode;
-                switch (modeArg) {
-                    case 'hybrid':
-                    case 'h':
-                        newMode = 'hybrid';
-                        break;
-                    case 'direct':
-                    case 'd':
-                        newMode = 'direct';
-                        break;
-                    case 'plan':
-                    case 'p':
-                        newMode = 'plan';
-                        break;
-                    default:
-                        emitOutput('');
-                        emitOutput(chalk.red(`Unknown mode: ${modeArg}`));
-                        emitOutput(chalk.gray('Available modes: hybrid, direct, plan'));
-                        emitOutput('');
-                        return;
-                }
-                setExecutionMode(newMode);
-                sessionManager.setExecutionMode(newMode);
-                const color = newMode === 'hybrid' ? chalk.cyan : newMode === 'direct' ? chalk.yellow : chalk.magenta;
-                emitOutput('');
-                emitOutput(chalk.green('✓') + ` Switched to ${color.bold(newMode.toUpperCase())} ${chalk.gray(`(${modeAliases[newMode]})`)}`);
-                emitOutput(`  ${chalk.gray(modeDescriptions[newMode])}`);
-                emitOutput('');
-            },
-        });
-        // Logout command - shows interactive confirmation selector
-        registerSlashCommand({
-            name: 'logout',
-            aliases: ['signout'],
-            description: 'Clear stored API keys and logout from Compass',
-            category: CommandCategory.AUTH,
-            requiresLLM: false,
-            canRunOffline: true,
-            executeOnComplete: true,
-            handler: async (args) => {
-                const forceLogout = args.includes('--force') || args.includes('-f');
-                if (forceLogout) {
-                    // Skip confirmation with --force flag
-                    await performLogout();
-                    return;
-                }
-                // Check what credentials exist
-                const { getCredentialStore } = await import('../services/credential-store.js');
-                const credentialStore = await getCredentialStore();
-                const hasCompassKey = await credentialStore.hasCompassApiKey();
-                const hasAnthropicKey = await credentialStore.hasApiKey();
-                // Check provider-specific keys
-                const providerNames = ['ollama', 'zai', 'minimax'];
-                const storedProviders = [];
-                for (const provider of providerNames) {
-                    if (await credentialStore.hasProviderApiKey(provider)) {
-                        storedProviders.push(provider);
-                    }
-                }
-                if (!hasCompassKey && !hasAnthropicKey && storedProviders.length === 0) {
-                    const eventEmitter = getEventEmitter();
-                    eventEmitter.emit('slash-command-output', { command: 'logout', message: '', isError: false });
-                    eventEmitter.emit('slash-command-output', { command: 'logout', message: chalk.yellow('⚠️  No API keys are currently stored.'), isError: false });
-                    eventEmitter.emit('slash-command-output', { command: 'logout', message: chalk.gray('   You are already logged out.'), isError: false });
-                    eventEmitter.emit('slash-command-output', { command: 'logout', message: '', isError: false });
-                    return;
-                }
-                // Build details list
-                const details = ['The following credentials will be cleared:'];
-                if (hasCompassKey) {
-                    details.push('  • Compass API Key');
-                }
-                if (hasAnthropicKey) {
-                    details.push('  • Anthropic API Key');
-                }
-                for (const provider of storedProviders) {
-                    details.push(`  • ${provider.charAt(0).toUpperCase() + provider.slice(1)} API Key`);
-                }
-                setLogoutDetails(details);
-                setActiveOverlay('logout-confirm');
-            },
-        });
-        // Check if save command needs UI-specific handling
-        if (!registry.has('save')) {
-            registerSlashCommand({
-                name: 'save',
-                description: 'Save current session',
-                category: CommandCategory.SESSION,
-                requiresLLM: false,
-                canRunOffline: true,
-                handler: async (args) => {
-                    const sessionManager = getSessionManager();
-                    const name = args[0] || `session-${Date.now()}`;
-                    try {
-                        await sessionManager.saveAs(name);
-                        logger.output(`Session saved as: ${name}`);
-                    }
-                    catch (err) {
-                        logger.output(`Failed to save session: ${err}`);
-                    }
-                },
-            });
-        }
-        if (!registry.has('context')) {
-            registerSlashCommand({
-                name: 'context',
-                description: 'Show context window usage',
-                category: CommandCategory.INFO,
-                requiresLLM: false,
-                canRunOffline: true,
-                handler: async () => {
-                    const client = await getAnthropicClient();
-                    const model = client.getCurrentModel();
-                    const usagePercent = Math.round((tokenUsage.totalTokens / model.contextWindow) * 100);
-                    logger.output(`Context Usage:`);
-                    logger.output(`  Model: ${model.name}`);
-                    logger.output(`  Window: ${model.contextWindow.toLocaleString()} tokens`);
-                    logger.output(`  Used: ${tokenUsage.totalTokens.toLocaleString()} tokens (${usagePercent}%)`);
-                    logger.output(`  Available: ${(model.contextWindow - tokenUsage.totalTokens).toLocaleString()} tokens`);
-                },
-            });
-        }
-        if (!registry.has('reset')) {
-            registerSlashCommand({
-                name: 'reset',
-                description: 'Reset session to clean state',
-                category: CommandCategory.SESSION,
-                requiresLLM: false,
-                canRunOffline: true,
-                handler: async () => {
-                    setConversation([]);
-                    setMetrics({
-                        tokenUsage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
-                        currentContextTokens: 0,
-                        cost: { inputCost: 0, outputCost: 0, totalCost: 0, currency: 'USD' },
-                    });
-                    setError(null);
-                    setShowHistory(false);
-                    // Clear plan execution UI state and persistence
-                    activePlanRef.current = null;
-                    setActivePlan(null);
-                    setPlanTrackerMode('compact');
-                    setSessionPhase('idle');
-                    setPendingApproval(null);
-                    setPendingPlanApproval(null);
-                    setPendingClarification(null);
-                    setSuggestionOffer(undefined);
-                    const planPersistence = getPlanPersistence(projectRoot);
-                    planPersistence.stopFileMonitoring();
-                    const sessionManager = getSessionManager();
-                    sessionManager.createSession(projectRoot);
-                    logger.output('Session reset to clean state.');
-                },
-            });
-        }
-    }
-    /**
-     * Subscribes to event emitter events for real-time updates
-     */
-    function subscribeToEvents() {
-        const eventEmitter = getEventEmitter();
-        // Token updates - single batched state update to prevent multiple re-renders
-        const unsubTokens = eventEmitter.on('token-update', ({ usage, cost: newCost }) => {
-            setMetrics((prev) => ({
-                tokenUsage: {
-                    inputTokens: prev.tokenUsage.inputTokens + usage.inputTokens,
-                    outputTokens: prev.tokenUsage.outputTokens + usage.outputTokens,
-                    totalTokens: prev.tokenUsage.totalTokens + usage.totalTokens,
-                },
-                currentContextTokens: usage.inputTokens,
-                cost: {
-                    inputCost: prev.cost.inputCost + newCost.inputCost,
-                    outputCost: prev.cost.outputCost + newCost.outputCost,
-                    totalCost: prev.cost.totalCost + newCost.totalCost,
-                    currency: 'USD',
-                },
-            }));
-        });
-        unsubscribersRef.current.push(unsubTokens);
-        // History cleared (from /clear command) - token reset and terminal clear only.
-        // All UI state is already reset by the /clear handler itself; duplicating
-        // setConversation/setActivePlan/etc. here triggers a second React render cycle
-        // that can race yoga-layout node teardown and cause WASM OOB crashes.
-        const unsubHistoryCleared = eventEmitter.on('history-cleared', (data) => {
-            setMetrics((prev) => ({ ...prev, currentContextTokens: 0 }));
-            // Clear the terminal screen including Static scrollback buffer (skip on startup to preserve banner).
-            // Deferred via setTimeout so React state updates flush first — writing ANSI escape codes
-            // synchronously corrupts Ink's internal cursor tracking, causing duplicate renders.
-            if (!data?.isStartup) {
-                setTimeout(() => {
-                    process.stdout.write('\x1B[2J\x1B[H');
-                }, 0);
-            }
-        });
-        unsubscribersRef.current.push(unsubHistoryCleared);
-        // Agent state changed (from /agents use and /agents reset)
-        const unsubAgentState = eventEmitter.on('agent-state-changed', ({ activeAgent }) => {
-            setActiveAgentName(activeAgent?.name ?? null);
-        });
-        unsubscribersRef.current.push(unsubAgentState);
-        // Approval requests
-        const unsubApproval = eventEmitter.on('approval-required', ({ request }) => {
-            setPendingApproval(request);
-        });
-        unsubscribersRef.current.push(unsubApproval);
-        // Plan approval requests
-        const unsubPlanApproval = eventEmitter.on('plan-approval-required', ({ request }) => {
-            setPendingPlanApproval(request);
-        });
-        unsubscribersRef.current.push(unsubPlanApproval);
-        // Clarification wizard requests
-        const unsubClarification = eventEmitter.on('clarification-required', ({ request }) => {
-            setPendingClarification(request);
-        });
-        unsubscribersRef.current.push(unsubClarification);
-        // Plan update started — hide the current plan tracker while a new plan is being generated
-        const unsubPlanUpdateStarted = eventEmitter.on('plan-update-started', () => {
-            activePlanRef.current = null;
-            setActivePlan(null);
-            setPlanTrackerMode('compact'); // Reset for when the new plan is approved
-        });
-        unsubscribersRef.current.push(unsubPlanUpdateStarted);
-        // Plan execution events - initialize tracker when plan approved.
-        // All plan events mutate activePlanRef and call schedulePlanRender() to update
-        // only the plan state without triggering InterleavedStream re-renders.
-        const unsubPlanExecStarted = eventEmitter.on('plan-execution-started', ({ planId, tasks }) => {
-            setPlanTrackerMode('compact'); // Reset visibility for new plan
-            activePlanRef.current = {
-                planId,
-                title: '',
-                tasks: tasks.map((task) => ({ task, status: 'pending' })),
-                isComplete: false,
-                success: false,
-            };
-            schedulePlanRender();
-        });
-        unsubscribersRef.current.push(unsubPlanExecStarted);
-        // Plan task completed - update tracker
-        const unsubPlanTaskCompleted = eventEmitter.on('plan-task-completed', ({ planId, taskId, status, summary: _summary }) => {
-            const prev = activePlanRef.current;
-            if (!prev || prev.planId !== planId)
-                return;
-            activePlanRef.current = {
-                ...prev,
-                tasks: prev.tasks.map((t) => t.task.id === taskId ? { ...t, status } : t),
-            };
-            schedulePlanRender();
-        });
-        unsubscribersRef.current.push(unsubPlanTaskCompleted);
-        // Plan task progress - update tracker for in-progress detection
-        const unsubPlanTaskProgress = eventEmitter.on('plan-task-progress', ({ planId, taskId }) => {
-            const prev = activePlanRef.current;
-            if (!prev || prev.planId !== planId)
-                return;
-            activePlanRef.current = {
-                ...prev,
-                tasks: prev.tasks.map((t) => t.task.id === taskId && t.status === 'pending'
-                    ? { ...t, status: 'in_progress' }
-                    : t),
-            };
-            schedulePlanRender();
-        });
-        unsubscribersRef.current.push(unsubPlanTaskProgress);
-        // Plan execution completed — mark complete synchronously, clear on next idle transition.
-        // No setTimeout: the deferred clear used to cause a second layout shift 500ms after
-        // processing ended. Instead, activePlanRef is cleared when isProcessing transitions to false.
-        const unsubPlanExecCompleted = eventEmitter.on('plan-execution-completed', ({ planId, success }) => {
-            const prev = activePlanRef.current;
-            if (!prev || prev.planId !== planId)
-                return;
-            activePlanRef.current = { ...prev, isComplete: true, success };
-            schedulePlanRender();
-        });
-        unsubscribersRef.current.push(unsubPlanExecCompleted);
-        // Model switches
-        const unsubModel = eventEmitter.on('model-switched', ({ model }) => {
-            setCurrentModel(model.name);
-            setContextWindowSize(model.contextWindow);
-        });
-        unsubscribersRef.current.push(unsubModel);
-        // Errors
-        const unsubError = eventEmitter.on('error', ({ message }) => {
-            setError(message);
-        });
-        unsubscribersRef.current.push(unsubError);
-        // Tool status messages (for granular progress during long-running tools)
-        const unsubToolStatus = eventEmitter.on('tool-status-message', ({ toolId, message }) => {
-            updateStreamBlocks((prev) => prev.map((block) => block.type === 'tool' && block.id === toolId
-                ? { ...block, statusMessage: message }
-                : block));
-        });
-        unsubscribersRef.current.push(unsubToolStatus);
-        // Tool complexity reasoning (persistent reasoning for plan mode)
-        const unsubComplexityReasoning = eventEmitter.on('tool-complexity-reasoning', ({ toolId, reasoning }) => {
-            updateStreamBlocks((prev) => prev.map((block) => block.type === 'tool' && block.id === toolId
-                ? { ...block, complexityReasoning: reasoning }
-                : block));
-        });
-        unsubscribersRef.current.push(unsubComplexityReasoning);
-        // Slash command output events (for real-time streaming output from commands like /commit)
-        // Accumulate synchronously - React batching is fine since we add to conversation at the end
-        const unsubSlashCommandOutput = eventEmitter.on('slash-command-output', ({ message }) => {
-            logger.debug(`[StreamingOutput Event] Received: ${message.substring(0, 50)}, total lines: ${streamingOutputRef.current.length + 1}`);
-            streamingOutputRef.current.push(message);
-            // Trigger state update for real-time display during command execution
-            setStreamingCommandOutput([...streamingOutputRef.current]);
-        });
-        unsubscribersRef.current.push(unsubSlashCommandOutput);
-        // Compass spinner events (for visual feedback during operations like /commit)
-        const unsubCompassSpinner = eventEmitter.on('compass-spinner', (data) => {
-            logger.debug(`[CompassSpinner Event] Received: active=${data.active}, message=${data.message}`);
-            setCompassSpinner(data.active ? data : null);
-        });
-        unsubscribersRef.current.push(unsubCompassSpinner);
-        // Agent wizard events (for /agents create and /agents edit)
-        const unsubAgentWizard = eventEmitter.on('open-agent-wizard', ({ mode, agentName }) => {
-            logger.debug(`[AgentWizard Event] Opening wizard: mode=${mode}, agentName=${agentName}`);
-            setActiveOverlay('agent-wizard');
-        });
-        unsubscribersRef.current.push(unsubAgentWizard);
-    }
-    /**
-     * Helper to update a tool block in stream blocks by ID
-     */
-    function updateToolBlock(toolId, updates) {
-        // Use optimized in-place update instead of full array map
-        updateToolBlockById(toolId, updates);
-    }
-    /**
-     * Executes tool calls and returns tool results with timing records.
-     * Updates UI state progressively as each tool completes.
-     */
-    async function executeToolCalls(toolUseBlocks) {
-        const toolRegistry = getToolRegistry();
-        const toolResults = [];
-        const toolRecords = [];
-        let userRejected = false;
-        let endTurn = false;
-        for (const toolUse of toolUseBlocks) {
-            // Check abort flag before each tool execution
-            if (abortLoopRef.current) {
-                logger.info('Tool execution aborted by user');
-                break;
-            }
-            logger.debug(`Executing tool: ${toolUse.name}`);
-            // Update existing tool block to "running" status (block was added during streaming)
-            updateToolBlockById(toolUse.id, { status: 'running', params: toolUse.input });
-            // Create per-tool AbortController for execute_command (allows Ctrl+X skip)
-            const isExecuteCommand = toolUse.name === 'execute_command';
-            if (isExecuteCommand) {
-                toolAbortRef.current = new AbortController();
-                currentToolNameRef.current = 'execute_command';
-            }
-            const startTime = Date.now();
-            try {
-                // Use per-tool signal for execute_command, loop-wide signal for others
-                const abortSignal = isExecuteCommand
-                    ? toolAbortRef.current.signal
-                    : abortControllerRef.current?.signal;
-                const result = await toolRegistry.executeTool(toolUse.name, toolUse.input, { projectRoot, toolCallId: toolUse.id, abortSignal });
-                const duration = Date.now() - startTime;
-                // Clear per-tool abort state
-                if (isExecuteCommand) {
-                    toolAbortRef.current = null;
-                    currentToolNameRef.current = null;
-                }
-                // Check if the tool was skipped by the user (Ctrl+X)
-                const toolData = result.data;
-                if (toolData?.skippedByUser) {
-                    const partialOutput = (toolData.stdout || '').slice(0, 200) + (toolData.stderr || '').slice(0, 200);
-                    updateToolBlock(toolUse.id, {
-                        status: 'skipped',
-                        result: JSON.stringify(result.data),
-                        duration_ms: duration,
-                    });
-                    toolResults.push({
-                        type: 'tool_result',
-                        tool_use_id: toolUse.id,
-                        content: `Command was skipped by the user.${partialOutput ? ` Partial output:\n${partialOutput}` : ''}`,
-                    });
-                    const record = {
-                        name: toolUse.name,
-                        input: toolUse.input,
-                        result: result.data,
-                        success: false,
-                        error: 'Skipped by user',
-                        duration_ms: duration,
-                    };
-                    toolRecords.push(record);
-                    logger.debug(`Tool ${toolUse.name} skipped by user after ${duration}ms`);
-                    continue;
-                }
-                if (result.success) {
-                    // Check if the tool's return data indicates a user rejection
-                    // (tool handler returns success: false but doesn't throw)
-                    const isToolRejection = toolData?.success === false &&
-                        (toolData?.error?.toLowerCase().includes('rejected by user') ||
-                            toolData?.error?.toLowerCase().includes('rejected'));
-                    // Check if a plan was cancelled — this signals the turn should end
-                    if (toolData?.planCancelled === true) {
-                        endTurn = true;
-                        logger.info(`Plan cancelled via ${toolUse.name} — will end turn`);
-                    }
-                    if (isToolRejection) {
-                        userRejected = true;
-                        // Update tool block with error
-                        updateToolBlock(toolUse.id, {
-                            status: 'error',
-                            error: toolData?.error || 'Operation rejected by user',
-                            duration_ms: duration,
-                        });
-                        // Still add the result for the LLM to see, but mark as error
-                        toolResults.push({
-                            type: 'tool_result',
-                            tool_use_id: toolUse.id,
-                            content: `Error: ${toolData?.error || 'Operation rejected by user'}`,
-                            is_error: true,
-                        });
-                        const record = {
-                            name: toolUse.name,
-                            input: toolUse.input,
-                            result: null,
-                            success: false,
-                            error: toolData?.error || 'Operation rejected by user',
-                            duration_ms: duration,
-                        };
-                        toolRecords.push(record);
-                        logger.debug(`Tool ${toolUse.name} rejected by user`);
-                    }
-                    else {
-                        // Update tool block with success.
-                        // Store parsedResult to avoid re-parsing JSON in the render path.
-                        updateToolBlock(toolUse.id, {
-                            status: 'success',
-                            result: JSON.stringify(result.data),
-                            parsedResult: result.data,
-                            duration_ms: duration,
-                        });
-                        toolResults.push({
-                            type: 'tool_result',
-                            tool_use_id: toolUse.id,
-                            content: JSON.stringify(result.data, null, 2),
-                        });
-                        const record = {
-                            name: toolUse.name,
-                            input: toolUse.input,
-                            result: result.data,
-                            success: true,
-                            duration_ms: duration,
-                        };
-                        toolRecords.push(record);
-                        logger.debug(`Tool ${toolUse.name} succeeded in ${duration}ms`);
-                    }
-                }
-                else {
-                    // Check if this was a user rejection (tool threw an error)
-                    const isUserRejection = result.error?.toLowerCase().includes('rejected by user') ||
-                        result.error?.toLowerCase().includes('rejected');
-                    if (isUserRejection) {
-                        userRejected = true;
-                    }
-                    // Update tool block with error
-                    updateToolBlock(toolUse.id, {
-                        status: 'error',
-                        error: result.error,
-                        duration_ms: duration,
-                    });
-                    toolResults.push({
-                        type: 'tool_result',
-                        tool_use_id: toolUse.id,
-                        content: `Error: ${result.error}`,
-                        is_error: true,
-                    });
-                    const record = {
-                        name: toolUse.name,
-                        input: toolUse.input,
-                        result: null,
-                        success: false,
-                        error: result.error,
-                        duration_ms: duration,
-                    };
-                    toolRecords.push(record);
-                    logger.debug(`Tool ${toolUse.name} failed: ${result.error}`);
-                }
-            }
-            catch (err) {
-                // Clear per-tool abort state on error
-                if (isExecuteCommand) {
-                    toolAbortRef.current = null;
-                    currentToolNameRef.current = null;
-                }
-                const duration = Date.now() - startTime;
-                const errorMsg = err instanceof Error ? err.message : 'Tool execution failed';
-                // Update tool block with error
-                updateToolBlock(toolUse.id, {
-                    status: 'error',
-                    error: errorMsg,
-                    duration_ms: duration,
-                });
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: toolUse.id,
-                    content: `Error: ${errorMsg}`,
-                    is_error: true,
-                });
-                const record = {
-                    name: toolUse.name,
-                    input: toolUse.input,
-                    result: null,
-                    success: false,
-                    error: errorMsg,
-                    duration_ms: duration,
-                };
-                toolRecords.push(record);
-                logger.error(`Tool ${toolUse.name} threw error`, err);
-            }
-        }
-        return { results: toolResults, records: toolRecords, userRejected, endTurn };
-    }
-    /**
-     * Handles clipboard paste (Ctrl+V)
-     * Extracts images and files from clipboard and adds them as pending attachments
-     */
-    const handlePaste = useCallback(async () => {
-        try {
-            // Check if clipboard contains supported content
-            const hasContent = await hasSupportedClipboardContent();
-            if (!hasContent) {
-                logger.output(chalk.yellow('⚠ No supported content (images or PDFs) in clipboard'));
-                return;
-            }
-            // Get clipboard content
-            const clipboardContent = await getClipboardContent();
-            if (clipboardContent.images.length === 0 && clipboardContent.files.length === 0) {
-                logger.output(chalk.yellow('⚠ Could not extract any attachments from clipboard'));
-                return;
-            }
-            // Extract attachments from clipboard content
-            const attachments = await extractAttachmentsFromClipboard(clipboardContent);
-            if (attachments.length === 0) {
-                logger.output(chalk.yellow('⚠ Could not extract any attachments from clipboard'));
-                return;
-            }
-            // Add attachments to session manager
-            const sessionManager = getSessionManager();
-            sessionManager.addPendingAttachments(attachments);
-            // Show feedback to user
-            const imageCount = attachments.filter(a => a.type === 'image').length;
-            const pdfCount = attachments.filter(a => a.type === "document").length;
-            let message = chalk.green(`✓ Pasted ${attachments.length} file${attachments.length > 1 ? 's' : ''}`);
-            if (imageCount > 0)
-                message += chalk.gray(` (${imageCount} image${imageCount > 1 ? 's' : ''})`);
-            if (pdfCount > 0)
-                message += chalk.gray(` (${pdfCount} PDF${pdfCount > 1 ? 's' : ''})`);
-            logger.output('');
-            logger.output(message);
-            logger.output(chalk.cyan(`💡 ${attachments.length} attachment${attachments.length > 1 ? 's' : ''} pending for next message`));
-            logger.output('');
-            // Emit event to update UI
-            const eventEmitter = getEventEmitter();
-            eventEmitter.emit('attachments-updated', {
-                attachments: sessionManager.getPendingAttachments(),
-            });
-            logger.info(`Pasted ${attachments.length} attachments from clipboard`);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Failed to paste from clipboard';
-            logger.debug('Clipboard paste failed', { error });
-            logger.output(chalk.red(`❌ ${errorMessage}`));
-        }
-    }, []);
-    /**
-     * Handles user input submission from the Prompt component
-     * Implements an agentic loop with proper tool use
-     */
-    const handleSubmit = useCallback(async (input) => {
-        const parsed = parseInput(input);
-        // Hide welcome message after first input
-        setShouldShowWelcome(false);
-        // Record activity for rating tracking
-        if (ratingStateManagerRef.current) {
-            ratingStateManagerRef.current.recordActivity();
-        }
-        // Clear any previous suggestion offer when user submits new input
-        setSuggestionOffer(undefined);
-        // Initialize iteration scoper (accessible in finally block)
-        const iterationScoper = getIterationScoper();
-        let isPlanMode = false;
-        // Log user input for audit trail
-        const auditLogger = getAuditLogger(projectRoot);
-        // Handle slash commands
-        if (parsed.type === 'slash') {
-            await auditLogger.logUserInput(input, true);
-            // Clear any previous slash command output
-            setSlashCommandOutput(null);
-            // Clear streaming command output and reset the ref
-            streamingOutputRef.current = [];
-            setStreamingCommandOutput([]);
-            try {
-                // Only show "Thinking..." indicator for commands that require LLM interaction.
-                // Local commands (e.g. /model, /help, /clear) execute instantly and don't need it.
-                const registry = getSlashCommandRegistry();
-                const needsLLM = parsed.command ? registry.requiresLLM(parsed.command) : false;
-                if (needsLLM) {
-                    setIsProcessing(true);
-                }
-                logger.debug(`[InteractiveSession] Starting slash command: ${parsed.command}, isProcessing=${needsLLM}`);
-                // Capture console output during slash command execution
-                // This supports both new-style (event emission) and old-style (console.log) commands
-                const { result, output: capturedConsoleOutput } = await captureConsoleOutput(async () => {
-                    return await executeSlashCommand(parsed);
-                });
-                logger.debug(`[InteractiveSession] Slash command completed: ${parsed.command}, streamingOutputRef.length=${streamingOutputRef.current.length}, capturedConsoleOutput.length=${capturedConsoleOutput.length}`);
-                if (!result.handled) {
-                    setError(`Unknown command: /${parsed.command}. Type /help for available commands.`);
-                    setIsProcessing(false);
-                    return;
-                }
-                // Check if this is a custom command that wants to continue as a prompt
-                if (result.continueAsPrompt) {
-                    // Continue with LLM flow using the processed prompt
-                    // Fall through to natural language handling with the processed content
-                    logger.debug('Custom command continuing as prompt', {
-                        command: parsed.command,
-                        contentLength: result.continueAsPrompt.length,
-                    });
-                    // Override input for LLM processing
-                    // The original command is shown to user, but processed content goes to LLM
-                    // We need to continue below with the processed content
-                    // Store the custom command result for use below
-                    parsed.customCommandResult = result;
-                    // Set back to true for LLM processing
-                    setIsProcessing(true);
-                }
-                else {
-                    // Regular slash command handled - display output ephemerally (NOT added to conversation/LLM context)
-                    // Prefer streaming events (new-style), fall back to captured console output (old-style)
-                    const hasStreamingOutput = streamingOutputRef.current.length > 0;
-                    const hasCapturedOutput = capturedConsoleOutput.trim().length > 0;
-                    logger.debug(`[InteractiveSession] Processing output: streaming=${streamingOutputRef.current.length} lines, captured=${capturedConsoleOutput.length} chars`);
-                    if (hasStreamingOutput || hasCapturedOutput) {
-                        // Prefer streaming output if available, otherwise use captured console output
-                        const combinedOutput = hasStreamingOutput
-                            ? streamingOutputRef.current.join('\n')
-                            : capturedConsoleOutput;
-                        logger.info(`[InteractiveSession] Setting ephemeral slash command output (${combinedOutput.length} chars, source=${hasStreamingOutput ? 'events' : 'console'})`);
-                        // Clear streaming refs FIRST to prevent both streamingCommandOutput and slashCommandOutput
-                        // from rendering simultaneously (which could show duplicate/stale content)
-                        streamingOutputRef.current = [];
-                        setStreamingCommandOutput([]);
-                        // Use ephemeral state - this output is cleared when user types next command or prompt
-                        // This prevents slash command output (like /help) from being sent to LLM as conversation context
-                        setSlashCommandOutput(combinedOutput);
-                        // Set isProcessing to false to display the output
-                        setIsProcessing(false);
-                        logger.debug('[InteractiveSession] Set ephemeral output and cleared streaming refs');
-                    }
-                    else {
-                        logger.debug(`[InteractiveSession] No output for command: ${parsed.command} (silent command)`);
-                        setIsProcessing(false);
-                    }
-                    return;
-                }
-            }
-            catch (err) {
-                const errorMessage = err instanceof Error ? err.message : 'Command failed';
-                setError(errorMessage);
-                logger.error(`Slash command error: ${parsed.command}`, err);
-                await auditLogger.logError(errorMessage, err);
-                setIsProcessing(false);
-                // Still clear streaming output even on error
-                streamingOutputRef.current = [];
-                setStreamingCommandOutput([]);
-                return;
-            }
-        }
-        // Clear slash command output when starting new LLM interaction
-        setSlashCommandOutput(null);
-        // Check if input is just "/" (incomplete slash command)
-        if (input.trim() === '/') {
-            setError('Incomplete command. Type /help to see available commands.');
-            return;
-        }
-        // Check if this is from a custom command that should continue as prompt
-        const customCommandResult = parsed.customCommandResult;
-        const isCustomCommand = !!customCommandResult?.continueAsPrompt;
-        // Log user input for audit trail (only if not a custom command, which was already logged)
-        if (!isCustomCommand) {
-            await auditLogger.logUserInput(input, false);
-        }
-        // Parse any system-reminders in the input for IDE state
-        const ideStateService = getIdeStateService();
-        ideStateService.updateFromMessage(input);
-        // For custom commands, use the processed prompt directly
-        // Otherwise, preprocess for IDE context injection
-        let inputForLLM;
-        if (isCustomCommand && customCommandResult?.continueAsPrompt) {
-            inputForLLM = customCommandResult.continueAsPrompt;
-            logger.debug('Using custom command processed content for LLM', {
-                contentLength: inputForLLM.length,
-            });
-        }
-        else {
-            const promptPreprocessor = getPromptPreprocessor();
-            const { processedInput, contextInjected, injectionDetails } = await promptPreprocessor.process(input);
-            if (contextInjected && injectionDetails) {
-                logger.info('IDE context injected into prompt', {
-                    filePath: injectionDetails.filePath,
-                    lineCount: injectionDetails.lineCount,
-                    truncated: injectionDetails.truncated,
-                });
-            }
-            inputForLLM = processedInput;
-        }
-        // Enable history display on first user message
-        setShowHistory(true);
-        // Handle natural language input - send to Claude
-        setIsProcessing(true);
-        setSessionPhase('classifying');
-        setError(null);
-        resetStreamBlocks();
-        // Handle plan execution tracker state on new request
-        {
-            const prev = activePlanRef.current;
-            if (prev) {
-                if (prev.isComplete || executionMode === 'direct') {
-                    activePlanRef.current = null;
-                }
-                else if (prev.isPaused) {
-                    activePlanRef.current = { ...prev, isPaused: false };
-                }
-            }
-            setActivePlan(activePlanRef.current);
-        }
-        // Classify the request for SMART mode approval decisions
-        // This must happen BEFORE any tool execution so the ApprovalManager can use the context
-        const approvalManager = getApprovalManager();
-        approvalManager.classifyAndSetContext(input);
-        // Save checkpoint for potential rollback if user cancels mid-execution
-        conversationCheckpointRef.current = [...conversation];
-        // Add user message to conversation (show original input to user)
-        const userEntry = {
-            id: `user-${Date.now()}`,
-            role: 'user',
-            content: input,
-            timestamp: new Date(),
-        };
-        setConversation((prev) => [...prev, userEntry]);
-        // Hoisted so `finally` can read the last assistant response for question detection
-        let finalResponseForSuggestion = '';
-        try {
-            const client = await getAnthropicClient();
-            if (!client.isInitialized()) {
-                const initialized = await client.initialize();
-                if (!initialized) {
-                    throw new Error('Failed to initialize API client. Please check your API key with: compass setup');
-                }
-            }
-            // Refresh project context if stale (files created/deleted since last call)
-            // This ensures Anthropic's prompt cache gets fresh context when project structure changes
-            await refreshProjectContext();
-            // Build system prompt with project context and model info
-            const model = client.getCurrentModel();
-            const systemPrompt = await buildSystemPrompt(projectSummary, model.name, model.id);
-            // Log system prompt for audit trail
-            await auditLogger.logSystemPrompt(systemPrompt);
-            // Get tool definitions from registry
-            const toolRegistry = getToolRegistry();
-            let tools = toolRegistry.getToolDefinitions();
-            // Filter tools based on execution mode
-            if (executionMode === 'direct') {
-                // In DIRECT mode, remove the enter_plan_mode tool
-                tools = tools.filter(tool => tool.name !== 'enter_plan_mode');
-                logger.debug('Execution mode: DIRECT - enter_plan_mode tool removed');
-            }
-            else {
-                logger.debug(`Execution mode: ${executionMode.toUpperCase()} - all tools available`);
-            }
-            // Build initial messages for API from conversation history
-            const messages = conversation.map((entry) => ({
-                role: entry.role === 'system' ? 'user' : entry.role,
-                content: entry.content,
-            }));
-            // ACTIVE PLAN CONTEXT INJECTION
-            // If there's an active plan being executed, inject the pending tasks context
-            // This ensures the LLM knows exactly what tasks remain when user says "continue"
-            const planPersistence = getPlanPersistence(projectRoot);
-            const activePlanId = planPersistence.getActivePlanId();
-            if (activePlanId) {
-                const pendingContext = await planPersistence.getPendingTasksContext(activePlanId);
-                if (pendingContext) {
-                    logger.info('Injecting active plan context', {
-                        planId: activePlanId,
-                        completedTasks: pendingContext.completedTasks,
-                        totalTasks: pendingContext.totalTasks,
-                        pendingCount: pendingContext.pendingTasks.length,
-                    });
-                    // Insert plan context BEFORE the user's message
-                    messages.push({
-                        role: 'user',
-                        content: pendingContext.formattedContext,
-                    });
-                }
-            }
-            // Use processedInput (with potential IDE context) for LLM
-            // Check for pending attachments and build appropriate content
-            const sessionMgrForAttachments = getSessionManager();
-            let userMessageContent;
-            if (sessionMgrForAttachments.hasPendingAttachments()) {
-                const pendingAttachments = sessionMgrForAttachments.consumePendingAttachments();
-                userMessageContent = buildMessageContent(inputForLLM, pendingAttachments);
-                logger.info(`Sending message with ${pendingAttachments.length} attachment(s)`);
-            }
-            else {
-                userMessageContent = inputForLLM;
-            }
-            messages.push({ role: 'user', content: userMessageContent });
-            // EXECUTION MODE HANDLING
-            if (executionMode === 'plan' && !isCustomCommand) {
-                // PLAN MODE: Force planning for EVERY request (except custom commands/skills)
-                // Skills have their own execution logic and should not be forced into planning
-                // BUT: skip forcing if there's already an active plan that's been approved/is executing
-                // This prevents re-entering plan mode on follow-up confirmations like "yes, proceed"
-                const planPersistenceForMode = getPlanPersistence(projectRoot);
-                const activePlanIdForMode = planPersistenceForMode.getActivePlanId();
-                let hasActivePlan = false;
-                if (activePlanIdForMode) {
-                    const activePlanRecord = await planPersistenceForMode.loadPlanRecord(activePlanIdForMode);
-                    if (activePlanRecord && (activePlanRecord.phase === 'approved' || activePlanRecord.phase === 'executing')) {
-                        hasActivePlan = true;
-                        logger.info('PLAN mode: skipping forced planning - active plan already approved/executing', {
-                            planId: activePlanIdForMode,
-                            phase: activePlanRecord.phase,
-                        });
-                    }
-                }
-                if (!hasActivePlan) {
-                    logger.info('PLAN mode active - forcing planning for this request');
-                    const forcePlanningMessage = `[SYSTEM REQUIREMENT - MANDATORY]
-The system is in PLAN mode. You MUST use the \`enter_plan_mode\` tool FIRST before taking any other actions.
-
-Do NOT directly execute commands, create files, or modify code without first creating an implementation plan.
-
-Call \`enter_plan_mode\` with:
-- task_summary: Brief description of what needs to be done
-- complexity_reason: Why planning is needed for this task
-
-After the plan is approved, proceed with execution following the plan tasks.`;
-                    // Insert mandatory planning instruction before the user's message
-                    messages.splice(messages.length - 1, 0, {
-                        role: 'user',
-                        content: forcePlanningMessage,
-                    });
-                }
-            }
-            else if (executionMode === 'hybrid') {
-                // HYBRID MODE: Run complexity checks to suggest planning when appropriate
-                // Skip pre-flight for custom commands/skills that return continueAsPrompt
-                // These have already been processed and should execute directly
-                // Also skip for short follow-up messages when conversation has context
-                // This handles cases like "yes", "no", "please do" responses to assistant questions
-                const hasConversationContext = conversation.some(entry => entry.role === 'assistant');
-                const isShortFollowUp = input.trim().length < 50 && input.trim().split(/\s+/).length < 10;
-                if (isCustomCommand || (hasConversationContext && isShortFollowUp)) {
-                    if (isCustomCommand) {
-                        logger.debug('Skipping pre-flight check for custom command/skill');
-                    }
-                    else {
-                        logger.debug('Skipping pre-flight check for short follow-up message', {
-                            inputLength: input.length,
-                            wordCount: input.trim().split(/\s+/).length,
-                        });
-                    }
-                    // Skip pre-flight and proceed directly to agentic loop with full conversation
-                }
-                else {
-                    // Create a fresh AbortController BEFORE pre-flight so a previously-aborted signal
-                    // doesn't immediately cancel the complexity classifier request
-                    abortControllerRef.current = new AbortController();
-                    try {
-                        // Get personality mode for consistent classifier tone
-                        const sessionMgrPreflight = getSessionManager();
-                        const preflightPersonality = sessionMgrPreflight.getEffectivePersonalityMode();
-                        // Convert conversation history to Message format for analyzer context
-                        const conversationForAnalyzer = conversation
-                            .filter(entry => entry.role === 'user' || entry.role === 'assistant')
-                            .map(entry => ({
-                            role: entry.role,
-                            content: entry.content
-                        }));
-                        const preflightResult = await checkPlanModeFallback(input, false, // LLM hasn't called plan mode yet
-                        projectRoot, preflightPersonality, abortControllerRef.current?.signal, // Pass abort signal for cancellation
-                        conversationForAnalyzer // Pass conversation history for context
-                        );
-                        // Handle NO_ACTION mode - display explanation and skip LLM call
-                        if (preflightResult.noActionNeeded) {
-                            logger.info('Pre-flight complexity check: no action needed', {
-                                confidence: preflightResult.confidence,
-                                explanation: preflightResult.noActionExplanation,
-                            });
-                            // Build a response message for the user
-                            const noActionResponse = preflightResult.noActionExplanation || preflightResult.reasoning;
-                            // Add assistant response to conversation
-                            const assistantEntry = {
-                                id: `assistant-${Date.now()}`,
-                                role: 'assistant',
-                                content: noActionResponse,
-                                timestamp: new Date(),
-                            };
-                            setConversation((prev) => [...prev, assistantEntry]);
-                            // Save to session manager
-                            const sessionManager = getSessionManager();
-                            sessionManager.addMessage({ role: 'user', content: input });
-                            sessionManager.addMessage({ role: 'assistant', content: noActionResponse });
-                            // Clear streaming state and stop processing
-                            setIsProcessing(false);
-                            setSessionPhase('idle');
-                            // Skip the LLM call entirely
-                            return;
-                        }
-                        // Handle CLARIFICATION mode - ask user questions before proceeding
-                        if (preflightResult.needsClarification && preflightResult.clarificationQuestions && preflightResult.clarificationQuestions.length > 0) {
-                            logger.info('Pre-flight complexity check: clarification needed', {
-                                confidence: preflightResult.confidence,
-                                questionCount: preflightResult.clarificationQuestions.length,
-                            });
-                            // Request clarification from user via the wizard
-                            const clarificationResponse = await approvalManager.requestClarification(input.substring(0, 200), // Task summary (truncated)
-                            preflightResult.clarificationQuestions, preflightResult.reasoning);
-                            if (clarificationResponse.completed && clarificationResponse.answers && clarificationResponse.answers.length > 0) {
-                                // Format answers for LLM context
-                                const answersContext = clarificationResponse.answers
-                                    .map(a => `- ${a.questionId}: ${Array.isArray(a.answer) ? a.answer.join(', ') : a.answer}`)
-                                    .join('\n');
-                                const clarificationContext = `[USER CLARIFICATION - IMPORTANT]
-The user has answered the following clarification questions about their request:
-
-${answersContext}
-
-Please incorporate these preferences into your implementation.`;
-                                // Insert clarification context before the user's message
-                                messages.splice(messages.length - 1, 0, {
-                                    role: 'user',
-                                    content: clarificationContext,
-                                });
-                                logger.info('Clarification answers injected into context', {
-                                    answerCount: clarificationResponse.answers.length,
-                                });
-                            }
-                            else {
-                                // User cancelled clarification - continue without answers
-                                logger.info('Clarification cancelled by user, proceeding without');
-                            }
-                        }
-                        // Handle SPAWN_AGENT mode - inject guidance so the agentic loop calls spawn_task
-                        if (preflightResult.shouldSpawnAgent && preflightResult.spawnAgentName && preflightResult.spawnAgentTask) {
-                            logger.info('Pre-flight complexity check: advising agent spawn via agentic loop', {
-                                confidence: preflightResult.confidence,
-                                agentName: preflightResult.spawnAgentName,
-                                reasoning: preflightResult.reasoning,
-                            });
-                            const spawnAgentAdvice = `[SYSTEM GUIDANCE - IMPORTANT]
-This task has been analyzed and should be delegated to a specialized sub-agent (confidence: ${preflightResult.confidence}%).
-${preflightResult.reasoning}
-
-You MUST use the \`spawn_task\` tool to delegate this task with the following parameters:
-- agent_name: "${preflightResult.spawnAgentName}"
-- task: "${preflightResult.spawnAgentTask.replace(/"/g, '\\"')}"
-
-Do NOT attempt to handle this task directly. Use spawn_task immediately.`;
-                            messages.splice(messages.length - 1, 0, {
-                                role: 'user',
-                                content: spawnAgentAdvice,
-                            });
-                        }
-                        if (preflightResult.shouldSuggestPlanMode && preflightResult.suggestedPrompt) {
-                            logger.info('Pre-flight complexity check: advising plan mode', {
-                                confidence: preflightResult.confidence,
-                                detectedMode: preflightResult.detectedMode,
-                            });
-                            // Inject strong guidance BEFORE the user's request
-                            const planModeAdvice = `[SYSTEM GUIDANCE - IMPORTANT]
-This task has been analyzed as complex (confidence: ${preflightResult.confidence}%).
-${preflightResult.reasoning}
-
-You MUST use the \`enter_plan_mode\` tool FIRST before taking any other actions.
-Do NOT directly create files or execute commands without planning first.
-
-After calling enter_plan_mode, wait for the plan to be approved before proceeding.`;
-                            // Insert advice before the user's message
-                            messages.splice(messages.length - 1, 0, {
-                                role: 'user',
-                                content: planModeAdvice,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        // Check if this was an abort (user cancelled)
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        const isAbort = errorMessage === 'Request aborted' ||
-                            (error instanceof Error && error.name === 'AbortError') ||
-                            abortLoopRef.current;
-                        if (isAbort) {
-                            logger.debug('Pre-flight complexity check cancelled by user');
-                            setIsProcessing(false);
-                            setSessionPhase('idle');
-                            return; // Exit early, cancellation message already shown
-                        }
-                        logger.warn('Pre-flight complexity check failed', { error });
-                        // Continue without advice on error
-                    }
-                } // end of else block for non-follow-up messages
-            }
-            else {
-                // DIRECT MODE: Skip all complexity checks and planning
-                logger.debug('DIRECT mode active - skipping all complexity checks');
-            }
-            // Track agentic loop data for logging
-            const loopStartTime = Date.now();
-            const agenticIterations = [];
-            let totalToolCalls = 0;
-            const totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-            const totalCost = { inputCost: 0, outputCost: 0, totalCost: 0 };
-            // Load agentic configuration
-            const configManager = getConfigManager();
-            const agenticConfig = configManager.getValue('agentic');
-            const maxIterations = agenticConfig?.maxIterations ?? DEFAULT_MAX_AGENTIC_ITERATIONS;
-            const maxIterationsPerTask = agenticConfig?.maxIterationsPerTask ?? DEFAULT_MAX_ITERATIONS_PER_TASK;
-            const costWarningThreshold = agenticConfig?.costWarningThreshold ?? 5.0;
-            const costHardCap = agenticConfig?.costHardCap ?? 0;
-            const autoCompactPercent = agenticConfig?.autoCompactAtPercent ?? 80;
-            const stuckDetectionEnabled = agenticConfig?.stuckDetectionEnabled ?? true;
-            const stuckDetectionThreshold = agenticConfig?.stuckDetectionThreshold ?? 3;
-            // Get model context window for auto-compaction
-            const modelConfig = getModelConfig(client.getCurrentModelId());
-            const contextWindow = modelConfig?.contextWindow ?? 200000;
-            // Stuck detection tracking
-            const recentToolCalls = [];
-            let costWarningShown = false;
-            let lastProactiveCompactionIter = -Infinity; // Iteration when proactive compaction last ran
-            const PROACTIVE_COMPACT_MIN_INTERVAL = 10; // Minimum iterations between proactive compactions
-            let lastCompactionFailureTime = 0; // Cooldown tracking for compaction failures
-            const COMPACTION_COOLDOWN_MS = 30_000; // 30s cooldown after a compaction failure
-            // Helper: Re-inject active plan context after compaction so the LLM
-            // retains structured plan/task ID references that survive summarization.
-            const reinjectPlanContextAfterCompaction = async (msgs) => {
-                try {
-                    const planPersistence = getPlanPersistence(projectRoot);
-                    const activePlanId = planPersistence.getActivePlanId();
-                    if (activePlanId) {
-                        const pendingContext = await planPersistence.getPendingTasksContext(activePlanId);
-                        if (pendingContext) {
-                            // Append plan context to the compaction summary message to avoid
-                            // message alternation issues. The summary is always the user message
-                            // containing "[CONTEXT SUMMARY".
-                            const summaryIdx = msgs.findIndex((m) => m.role === 'user' && typeof m.content === 'string' && m.content.includes('[CONTEXT SUMMARY'));
-                            if (summaryIdx >= 0 && typeof msgs[summaryIdx].content === 'string') {
-                                msgs[summaryIdx] = {
-                                    ...msgs[summaryIdx],
-                                    content: msgs[summaryIdx].content + '\n\n' + pendingContext.formattedContext,
-                                };
-                            }
-                            else {
-                                // No summary message found (e.g., crude truncation) — append as last user message
-                                const lastUserIdx = msgs.reduce((acc, m, i) => m.role === 'user' ? i : acc, -1);
-                                if (lastUserIdx >= 0 && typeof msgs[lastUserIdx].content === 'string') {
-                                    msgs[lastUserIdx] = {
-                                        ...msgs[lastUserIdx],
-                                        content: msgs[lastUserIdx].content + '\n\n' + pendingContext.formattedContext,
-                                    };
-                                }
-                            }
-                            logger.info(`Re-injected plan context after compaction (plan: ${activePlanId}, ${pendingContext.completedTasks}/${pendingContext.totalTasks} done)`);
-                        }
-                    }
-                }
-                catch (planErr) {
-                    logger.debug('Failed to re-inject plan context after compaction', { error: planErr });
-                }
-            };
-            // Agentic loop: call LLM, execute tools, feed results back
-            setSessionPhase('executing');
-            let iterations = 0;
-            let accumulatedText = '';
-            let finalResponse = '';
-            let reachedMaxIterations = false;
-            let planModeTriggered = false; // Track if enter_plan_mode tool was called
-            let fallbackCheckDone = false; // Only run fallback once
-            let stuckDetected = false;
-            let costCapExceeded = false;
-            let wasAborted = false;
-            while (iterations < maxIterations &&
-                (!isPlanMode || iterationScoper.shouldContinueIteration(iterations))) {
-                // Check abort flag at start of each iteration (set by Esc during clarification or double-Esc)
-                if (abortLoopRef.current) {
-                    logger.info('Agentic loop aborted by user');
-                    abortLoopRef.current = false; // Reset for next request
-                    wasAborted = true;
-                    break;
-                }
-                iterations++;
-                iterationScoper.incrementIteration();
-                logger.debug(`Agentic loop iteration ${iterations}`);
-                // SLIDING WINDOW CHECK: Compact if message count exceeds limit (first line of defense)
-                const compactionOnCooldown = lastCompactionFailureTime > 0 && (Date.now() - lastCompactionFailureTime) < COMPACTION_COOLDOWN_MS;
-                if (messages.length > SLIDING_WINDOW_MAX_MESSAGES) {
-                    if (compactionOnCooldown) {
-                        logger.debug('Sliding window compaction skipped (cooldown active)');
-                    }
-                    else {
-                        logger.info(`Sliding window: ${messages.length} messages > ${SLIDING_WINDOW_MAX_MESSAGES}, compacting`);
-                        try {
-                            const compactor = await getConversationCompactor();
-                            await compactor.initialize();
-                            const compactionResult = await compactor.compactApiMessages(messages, 10, 6000);
-                            if (compactionResult.messagesCompacted > 0) {
-                                messages.length = 0;
-                                messages.push(...compactionResult.compactedMessages);
-                                const sessionManager = getSessionManager();
-                                sessionManager.syncAfterCompaction(compactionResult.summary, compactionResult.compactedMessages.length - 2);
-                                await reinjectPlanContextAfterCompaction(messages);
-                                lastProactiveCompactionIter = iterations;
-                                lastCompactionFailureTime = 0; // Reset on success
-                            }
-                        }
-                        catch (compactError) {
-                            logger.warn('Sliding window compaction failed', { error: compactError });
-                            lastCompactionFailureTime = Date.now();
-                        }
-                    }
-                }
-                // PRE-API CHECK: Estimate message size and apply intelligent compaction if needed
-                // This prevents the 200k token limit error
-                const estimatedMessageTokens = estimateMessagesArrayTokens(messages);
-                const estimatedSystemTokens = estimateSystemPromptTokens(systemPrompt);
-                const estimatedTotalTokens = estimatedMessageTokens + estimatedSystemTokens + DEFAULT_MAX_TOKENS; // Reserve space for output
-                const maxAllowedTokens = Math.floor(contextWindow * (CONTEXT_WINDOW_SAFETY_MARGIN / 100));
-                const proactiveCompactThreshold = Math.floor(contextWindow * 0.70); // Trigger at 70% to avoid emergency
-                // Sync estimated context tokens with session for accurate compaction checks
-                const sessionManager = getSessionManager();
-                sessionManager.updateEstimatedContextTokens(estimatedMessageTokens);
-                // Log compaction evaluation on every 5th iteration or when approaching thresholds
-                const contextUsagePct = Math.round((estimatedTotalTokens / contextWindow) * 100);
-                if (iterations % 5 === 0 || contextUsagePct >= 50) {
-                    logger.debug(`Compaction eval [iter ${iterations}]: ${estimatedTotalTokens.toLocaleString()} tokens (${contextUsagePct}% of ${contextWindow.toLocaleString()}) | ` +
-                        `thresholds: proactive=${proactiveCompactThreshold.toLocaleString()} (70%), emergency=${maxAllowedTokens.toLocaleString()} (90%) | ` +
-                        `messages=${messages.length}, itersSinceCompaction=${iterations - lastProactiveCompactionIter}`);
-                }
-                // Proactive compaction at 70% context usage (percentage-based only).
-                // Uses an iteration-based interval instead of a one-shot flag so compaction
-                // can re-trigger in long-running agentic loops that keep accumulating context.
-                const iterationsSinceLastCompaction = iterations - lastProactiveCompactionIter;
-                const shouldProactiveCompact = iterationsSinceLastCompaction >= PROACTIVE_COMPACT_MIN_INTERVAL &&
-                    messages.length > 8 &&
-                    estimatedTotalTokens > proactiveCompactThreshold;
-                if (shouldProactiveCompact) {
-                    if (compactionOnCooldown) {
-                        logger.debug('Proactive compaction skipped (cooldown active)');
-                    }
-                    else {
-                        logger.info(`Proactive compaction triggered: ${contextUsagePct}% context usage`);
-                        lastProactiveCompactionIter = iterations;
-                        try {
-                            const compactor = await getConversationCompactor();
-                            await compactor.initialize();
-                            const compactionResult = await compactor.compactApiMessages(messages, 10, 6000);
-                            if (compactionResult.messagesCompacted > 0) {
-                                logger.info(`Proactive compaction: ${compactionResult.tokensBefore} → ${compactionResult.tokensAfter} tokens (${compactionResult.messagesCompacted} messages compacted)`);
-                                messages.length = 0;
-                                messages.push(...compactionResult.compactedMessages);
-                                // Sync with session to prevent state drift
-                                const sessionManager = getSessionManager();
-                                sessionManager.syncAfterCompaction(compactionResult.summary, compactionResult.compactedMessages.length - 2); // -2 for summary message and original
-                                await reinjectPlanContextAfterCompaction(messages);
-                                lastCompactionFailureTime = 0; // Reset on success
-                            }
-                        }
-                        catch (compactError) {
-                            logger.warn('Proactive compaction failed, will use emergency fallback if needed', { error: compactError });
-                            lastCompactionFailureTime = Date.now();
-                        }
-                    }
-                }
-                // Emergency compaction at 90% - must succeed to continue
-                if (estimatedTotalTokens > maxAllowedTokens) {
-                    logger.warn(`Pre-API check: estimated ${estimatedTotalTokens} tokens exceeds ${maxAllowedTokens} limit (${CONTEXT_WINDOW_SAFETY_MARGIN}% of ${contextWindow})`);
-                    const minMessagesToKeep = 4;
-                    if (messages.length > minMessagesToKeep) {
-                        // Try intelligent compaction first
-                        try {
-                            const compactor = await getConversationCompactor();
-                            await compactor.initialize();
-                            const compactionResult = await compactor.compactApiMessages(messages, 6, 4000);
-                            if (compactionResult.messagesCompacted > 0) {
-                                const newEstimate = estimateMessagesArrayTokens(compactionResult.compactedMessages) + estimatedSystemTokens + DEFAULT_MAX_TOKENS;
-                                if (newEstimate < maxAllowedTokens) {
-                                    logger.info(`Emergency intelligent compaction: ${compactionResult.tokensBefore} → ${compactionResult.tokensAfter} tokens`);
-                                    messages.length = 0;
-                                    messages.push(...compactionResult.compactedMessages);
-                                    // Sync with session to prevent state drift
-                                    const sessionManager = getSessionManager();
-                                    sessionManager.syncAfterCompaction(compactionResult.summary, compactionResult.compactedMessages.length - 2);
-                                    await reinjectPlanContextAfterCompaction(messages);
-                                }
-                                else {
-                                    // Compaction wasn't enough, fall back to crude truncation
-                                    throw new Error('Compaction insufficient');
-                                }
-                            }
-                            else {
-                                throw new Error('Nothing to compact');
-                            }
-                        }
-                        catch (compactError) {
-                            // Fall back to crude truncation as last resort
-                            logger.warn('Emergency compaction failed, using crude truncation', { error: compactError });
-                            const originalFirstMessage = messages[0];
-                            const recentMessages = messages.slice(-Math.min(messages.length - 1, 4));
-                            const truncatedMessages = [
-                                originalFirstMessage,
-                                {
-                                    role: 'user',
-                                    content: `[EMERGENCY: Context severely truncated. ${messages.length - recentMessages.length - 1} earlier messages removed. Key context may be lost - please ask if you need clarification on previous work.]`,
-                                },
-                                ...recentMessages,
-                            ];
-                            const newEstimate = estimateMessagesArrayTokens(truncatedMessages) + estimatedSystemTokens + DEFAULT_MAX_TOKENS;
-                            if (newEstimate < maxAllowedTokens) {
-                                logger.info(`Crude truncation: ${messages.length} -> ${truncatedMessages.length} messages`);
-                                messages.length = 0;
-                                messages.push(...truncatedMessages);
-                                await reinjectPlanContextAfterCompaction(messages);
-                            }
-                            else {
-                                // Absolute last resort - keep only original request
-                                logger.error('All compaction strategies failed, keeping minimal context');
-                                messages.length = 0;
-                                messages.push(originalFirstMessage, {
-                                    role: 'user',
-                                    content: '[CRITICAL: All context removed due to size limits. Please summarize what you remember and ask for clarification.]',
-                                });
-                                await reinjectPlanContextAfterCompaction(messages);
-                            }
-                        }
-                    }
-                }
-                // Create AbortController for this request so Esc can cancel immediately
-                abortControllerRef.current = new AbortController();
-                // Call Claude with tools
-                const response = await client.createAgenticMessage(messages, {
-                    system: systemPrompt,
-                    tools,
-                    maxTokens: DEFAULT_MAX_TOKENS,
-                    abortSignal: abortControllerRef.current.signal,
-                }, (chunk) => {
-                    // Stream text chunks to UI (display handled by streamBlocksRef)
-                    accumulatedText += chunk;
-                    // Append text chunk using optimized in-place update (avoids full array copy)
-                    appendTextChunk(chunk);
-                }, (toolEvent) => {
-                    // Handle tool streaming events for real-time visibility
-                    if (toolEvent.type === 'tool_start') {
-                        // Initialize trackers for this tool
-                        toolPartialJsonRef.current.set(toolEvent.id, '');
-                        toolLastParamCountRef.current.set(toolEvent.id, 0);
-                        // Add tool block in "generating" status as soon as we know the tool name
-                        streamBlocksRef.current.push(createToolBlock(toolEvent.id, toolEvent.name, {}, 'generating'));
-                        scheduleRender();
-                    }
-                    else if (toolEvent.type === 'tool_input_delta') {
-                        // Accumulate partial JSON and extract available params for display
-                        const currentJson = toolPartialJsonRef.current.get(toolEvent.id) || '';
-                        const newJson = currentJson + toolEvent.partialInput;
-                        toolPartialJsonRef.current.set(toolEvent.id, newJson);
-                        // Debounce: only attempt parse every 50 chars to avoid calling
-                        // JSON.parse() (which will throw) on every tiny delta event.
-                        const lastParsedLen = toolLastParsedLenRef.current.get(toolEvent.id) || 0;
-                        if (newJson.length - lastParsedLen < 50) {
-                            // Skip parsing until enough new data accumulated
-                        }
-                        else {
-                            toolLastParsedLenRef.current.set(toolEvent.id, newJson.length);
-                            const partialParams = tryParsePartialJson(newJson);
-                            const paramCount = Object.keys(partialParams).length;
-                            const lastParamCount = toolLastParamCountRef.current.get(toolEvent.id) || 0;
-                            // Only update if we have new params (param count increased)
-                            if (paramCount > lastParamCount) {
-                                toolLastParamCountRef.current.set(toolEvent.id, paramCount);
-                                updateToolBlockById(toolEvent.id, { params: partialParams }, 'generating');
-                            }
-                        }
-                    }
-                    else if (toolEvent.type === 'tool_complete') {
-                        // Clean up trackers
-                        toolPartialJsonRef.current.delete(toolEvent.id);
-                        toolLastParamCountRef.current.delete(toolEvent.id);
-                        toolLastParsedLenRef.current.delete(toolEvent.id);
-                        // Update tool block to "pending" with full params when generation complete
-                        updateToolBlockById(toolEvent.id, { params: toolEvent.input, status: 'pending' });
-                    }
-                });
-                logger.debug(`Response stop_reason: ${response.stopReason}, tool calls: ${response.toolUseBlocks.length}`);
-                // Accumulate usage and cost
-                totalUsage.inputTokens += response.usage.inputTokens;
-                totalUsage.outputTokens += response.usage.outputTokens;
-                totalUsage.totalTokens += response.usage.totalTokens;
-                totalCost.inputCost += response.cost.inputCost;
-                totalCost.outputCost += response.cost.outputCost;
-                totalCost.totalCost += response.cost.totalCost;
-                // Cost warning check (internal tracking only, not shown in UI)
-                if (!costWarningShown && totalCost.totalCost >= costWarningThreshold) {
-                    logger.debug(`Agentic loop cost warning: $${totalCost.totalCost.toFixed(2)} exceeds threshold of $${costWarningThreshold.toFixed(2)}`);
-                    costWarningShown = true;
-                }
-                // Cost hard cap check
-                if (costHardCap > 0 && totalCost.totalCost >= costHardCap) {
-                    logger.warn(`Agentic loop stopped: cost hard cap of $${costHardCap.toFixed(2)} exceeded`);
-                    costCapExceeded = true;
-                    finalResponse = accumulatedText + `\n\n⛔ *Session stopped: Cost cap of $${costHardCap.toFixed(2)} reached*`;
-                    break;
-                }
-                // Context window usage check for auto-compaction (post-API check using LAST call's input tokens, not cumulative)
-                const postApiContextUsagePct = (response.usage.inputTokens / contextWindow) * 100;
-                const postApiItersSinceCompaction = iterations - lastProactiveCompactionIter;
-                const shouldPostApiCompact = postApiItersSinceCompaction >= PROACTIVE_COMPACT_MIN_INTERVAL &&
-                    postApiContextUsagePct >= autoCompactPercent;
-                if (shouldPostApiCompact) {
-                    const postApiCooldown = lastCompactionFailureTime > 0 && (Date.now() - lastCompactionFailureTime) < COMPACTION_COOLDOWN_MS;
-                    if (postApiCooldown) {
-                        logger.debug('Post-API compaction skipped (cooldown active)');
-                    }
-                    else {
-                        logger.info(`Post-API compaction triggered: ${postApiContextUsagePct.toFixed(1)}% context usage`);
-                        lastProactiveCompactionIter = iterations;
-                        try {
-                            const compactor = await getConversationCompactor();
-                            await compactor.initialize();
-                            // Use API messages compaction directly since that's what's actually growing
-                            const compactionResult = await compactor.compactApiMessages(messages, 10, 6000);
-                            if (compactionResult.messagesCompacted > 0) {
-                                logger.info(`Post-API compaction: ${compactionResult.tokensBefore} → ${compactionResult.tokensAfter} tokens`);
-                                messages.length = 0;
-                                messages.push(...compactionResult.compactedMessages);
-                                // Sync with session
-                                const sessionManager = getSessionManager();
-                                sessionManager.syncAfterCompaction(compactionResult.summary, compactionResult.compactedMessages.length - 2);
-                                await reinjectPlanContextAfterCompaction(messages);
-                                lastCompactionFailureTime = 0; // Reset on success
-                            }
-                        }
-                        catch (compactError) {
-                            logger.warn('Post-API compaction failed', { error: compactError });
-                            lastCompactionFailureTime = Date.now();
-                        }
-                    }
-                }
-                // Handle max_tokens - prompt continuation
-                if (response.stopReason === 'max_tokens') {
-                    logger.warn('Response truncated due to max_tokens - prompting continuation');
-                    agenticIterations.push({
-                        iteration: iterations,
-                        llm_call: {
-                            messages_count: messages.length,
-                            response_text: response.textContent,
-                            tool_calls_count: 0,
-                            usage: response.usage,
-                            cost: response.cost,
-                        },
-                        tool_calls: [],
-                        stop_reason: response.stopReason,
-                    });
-                    // Add the partial response to conversation and prompt to continue
-                    messages.push({
-                        role: 'assistant',
-                        content: response.contentBlocks,
-                    });
-                    messages.push({
-                        role: 'user',
-                        content: 'Continue from where you left off. If you were about to use tools, please proceed with those tool calls now.',
-                    });
-                    continue; // Continue the loop to get the next part of the response
-                }
-                // If no tool calls, we're done
-                if (response.stopReason !== 'tool_use' || response.toolUseBlocks.length === 0) {
-                    // Check queue before ending the loop — drain ALL queued messages at once
-                    if (queuedMessagesRef.current.length > 0) {
-                        // Separate slash commands from regular messages.
-                        // Regular messages get batched; the first slash command (if any) breaks the loop after.
-                        const allQueued = [...queuedMessagesRef.current];
-                        const regularMessages = [];
-                        let slashCommand = null;
-                        for (const msg of allQueued) {
-                            const parsed = parseInput(msg);
-                            if (parsed.type === 'slash') {
-                                slashCommand = msg;
-                                break; // Stop — everything before this gets batched, slash runs after
-                            }
-                            regularMessages.push(msg);
-                        }
-                        // Remove consumed messages from the queue (regular + the slash command if found)
-                        const consumed = regularMessages.length + (slashCommand ? 1 : 0);
-                        queuedMessagesRef.current = queuedMessagesRef.current.slice(consumed);
-                        setQueuedMessages([...queuedMessagesRef.current]);
-                        // If we only got a slash command with no regular messages, handle it directly
-                        if (regularMessages.length === 0 && slashCommand) {
-                            logger.info(`Queued message is a slash command: ${slashCommand}, breaking loop to execute`);
-                            agenticIterations.push({
-                                iteration: iterations,
-                                llm_call: {
-                                    messages_count: messages.length,
-                                    response_text: response.textContent,
-                                    tool_calls_count: 0,
-                                    usage: response.usage,
-                                    cost: response.cost,
-                                },
-                                tool_calls: [],
-                                stop_reason: 'queue_drain_slash',
-                            });
-                            setTimeout(() => handleSubmit(slashCommand), 0);
-                            break;
-                        }
-                        // Batch all regular messages into a single well-formatted prompt
-                        const combinedMessage = regularMessages.length === 1
-                            ? regularMessages[0]
-                            : regularMessages.map((msg, i) => `${i + 1}. ${msg}`).join('\n');
-                        // Add the LLM's response to messages
-                        messages.push({
-                            role: 'assistant',
-                            content: response.contentBlocks,
-                        });
-                        // Add combined queued message to conversation display
-                        const now = new Date();
-                        setConversation((prev) => [...prev,
-                            { id: `assistant-${Date.now()}`, role: 'assistant', content: response.textContent, timestamp: now },
-                            { id: `user-queued-${Date.now()}`, role: 'user', content: combinedMessage, timestamp: now },
-                        ]);
-                        // Add user message to API messages with reinforcement framing
-                        const preamble = regularMessages.length === 1
-                            ? 'The user has provided additional input while you were working. This is likely related to your current task — treat it as a follow-up instruction, correction, or new insight. Integrate it into your ongoing work naturally.'
-                            : `The user has provided ${regularMessages.length} additional messages while you were working. These are likely related to your current task — treat them as follow-up instructions, corrections, or new insights. Address all of them together in your ongoing work.`;
-                        const framedMessage = `<system-reminder>${preamble}</system-reminder>\n\n${combinedMessage}`;
-                        messages.push({ role: 'user', content: framedMessage });
-                        // Reset stream blocks for the new response
-                        resetStreamBlocks();
-                        logger.info(`Injected ${regularMessages.length} queued message(s) as batch: "${combinedMessage.substring(0, 80)}..."`);
-                        // Record iteration metrics before continuing
-                        agenticIterations.push({
-                            iteration: iterations,
-                            llm_call: {
-                                messages_count: messages.length,
-                                response_text: response.textContent,
-                                tool_calls_count: 0,
-                                usage: response.usage,
-                                cost: response.cost,
-                            },
-                            tool_calls: [],
-                            stop_reason: 'queue_drain',
-                        });
-                        // If there's a slash command waiting after the regular messages,
-                        // schedule it to run after this loop iteration completes
-                        if (slashCommand) {
-                            const cmd = slashCommand;
-                            setTimeout(() => handleSubmit(cmd), 0);
-                            // Don't break yet — continue so the LLM processes the batched messages first
-                        }
-                        continue; // Continue loop with the batched message
-                    }
-                    // Log final iteration (no tool calls)
-                    agenticIterations.push({
-                        iteration: iterations,
-                        llm_call: {
-                            messages_count: messages.length,
-                            response_text: response.textContent,
-                            tool_calls_count: 0,
-                            usage: response.usage,
-                            cost: response.cost,
-                        },
-                        tool_calls: [],
-                        stop_reason: response.stopReason,
-                    });
-                    finalResponse = response.textContent;
-                    break;
-                }
-                // Execute tool calls
-                const { results: toolResults, records: toolRecords, userRejected, endTurn } = await executeToolCalls(response.toolUseBlocks);
-                totalToolCalls += toolRecords.length;
-                // Stuck detection: check if we're calling the same tools with the same inputs repeatedly
-                if (stuckDetectionEnabled && response.toolUseBlocks.length > 0) {
-                    for (const toolUse of response.toolUseBlocks) {
-                        // Create a SHA-256 hash of the full tool input for accurate comparison
-                        // Using full hash ensures different content in the same file is detected
-                        const inputHash = sha256Hash(JSON.stringify(toolUse.input || {}));
-                        recentToolCalls.push({ name: toolUse.name, inputHash });
-                    }
-                    // Keep only the last N * threshold calls for comparison
-                    const maxTracked = stuckDetectionThreshold * 3;
-                    while (recentToolCalls.length > maxTracked) {
-                        recentToolCalls.shift();
-                    }
-                    // Check for stuck pattern: same tool call repeated consecutively
-                    if (recentToolCalls.length >= stuckDetectionThreshold) {
-                        const lastCalls = recentToolCalls.slice(-stuckDetectionThreshold);
-                        const firstCall = lastCalls[0];
-                        const isStuck = lastCalls.every((call) => call.name === firstCall.name && call.inputHash === firstCall.inputHash);
-                        if (isStuck) {
-                            logger.warn(`Stuck detection triggered: tool "${firstCall.name}" called ${stuckDetectionThreshold} times with same input`);
-                            stuckDetected = true;
-                            finalResponse = accumulatedText + `\n\n⚠️ *Stuck detected: The same operation was attempted ${stuckDetectionThreshold} times. Consider rephrasing your request or providing more context.*`;
-                            break;
-                        }
-                    }
-                    // Early warning: inject guidance on 2nd consecutive identical attempt (before stuck triggers)
-                    // This gives the LLM a chance to try a different approach
-                    const warningThreshold = stuckDetectionThreshold - 1;
-                    if (warningThreshold >= 2 && recentToolCalls.length >= warningThreshold) {
-                        const lastCallsForWarning = recentToolCalls.slice(-warningThreshold);
-                        const firstCallForWarning = lastCallsForWarning[0];
-                        const isRepeating = lastCallsForWarning.every((call) => call.name === firstCallForWarning.name && call.inputHash === firstCallForWarning.inputHash);
-                        if (isRepeating) {
-                            logger.info(`Early stuck warning: tool "${firstCallForWarning.name}" called ${warningThreshold} times with same input`);
-                            // Inject warning message to the LLM in the next iteration
-                            messages.push({
-                                role: 'user',
-                                content: `⚠️ SYSTEM WARNING: You have attempted the same operation (${firstCallForWarning.name}) ${warningThreshold} times with identical parameters. The operation appears to be failing repeatedly. Please try a DIFFERENT approach - consider: using different parameters, trying an alternative tool, or explaining what's blocking you so we can help. One more identical attempt will trigger stuck detection and terminate execution.`,
-                            });
-                        }
-                    }
-                }
-                // Check if enter_plan_mode was called
-                let planJustApproved = false;
-                if (response.toolUseBlocks.some((tool) => tool.name === 'enter_plan_mode')) {
-                    planModeTriggered = true;
-                    logger.debug('Plan mode tool was called by LLM');
-                    // Check if plan was approved and execution started
-                    // activePlanId is only set when startExecution() is called (after user approval)
-                    const planPersistence = getPlanPersistence(projectRoot);
-                    const activePlanId = planPersistence.getActivePlanId();
-                    if (activePlanId) {
-                        isPlanMode = true;
-                        iterationScoper.startPlanExecution(activePlanId, maxIterationsPerTask);
-                        logger.info(`Started per-task iteration tracking for plan ${activePlanId} with ${maxIterationsPerTask} iterations per task`);
-                        planJustApproved = true;
-                    }
-                    else {
-                        // Expected when plan was clarified, edited, rejected, or errored
-                        // The LLM may call enter_plan_mode again after clarification
-                        logger.debug('Plan mode tool called but no active execution (plan may need clarification/modification)');
-                    }
-                }
-                // If user rejected an operation, log it but continue the loop
-                // The LLM will see the rejection error in the tool result and can decide what to do
-                if (userRejected) {
-                    logger.info('User rejected operation - continuing agentic loop so LLM can respond');
-                }
-                // If a plan was cancelled, end the turn immediately — don't let the LLM continue
-                if (endTurn) {
-                    logger.info('End turn signalled (plan cancelled) — stopping agentic loop');
-                    finalResponse = accumulatedText;
-                    break;
-                }
-                // Log this iteration
-                agenticIterations.push({
-                    iteration: iterations,
-                    llm_call: {
-                        messages_count: messages.length,
-                        response_text: response.textContent,
-                        tool_calls_count: response.toolUseBlocks.length,
-                        usage: response.usage,
-                        cost: response.cost,
-                    },
-                    tool_calls: toolRecords,
-                    stop_reason: response.stopReason,
-                });
-                // Add assistant response (with tool use) to messages
-                messages.push({
-                    role: 'assistant',
-                    content: response.contentBlocks,
-                });
-                // Add tool results as user message
-                messages.push({
-                    role: 'user',
-                    content: toolResults,
-                });
-                // Add explicit continuation instruction after plan approval
-                // This ensures the LLM continues with tool calls instead of just responding with text
-                if (planJustApproved) {
-                    if (planApprovalClearContextRef.current) {
-                        // Full clear: keep only the last 2 messages (enter_plan_mode tool_use + plan result)
-                        const lastTwo = messages.slice(-2);
-                        messages.length = 0;
-                        messages.push(...lastTwo);
-                        planApprovalClearContextRef.current = false;
-                        setMetrics((prev) => ({ ...prev, currentContextTokens: 0 }));
-                        logger.info('Plan approval full context clear: messages reduced to 2');
-                    }
-                    else {
-                        // Partial compaction: keep last 3 messages + LLM-generated summary
-                        try {
-                            const compactor = await getConversationCompactor();
-                            await compactor.initialize();
-                            const compactionResult = await compactor.compactForPlanApproval(messages, 3);
-                            if (compactionResult.messagesCompacted > 0) {
-                                messages.length = 0;
-                                messages.push(...compactionResult.compactedMessages);
-                                const sessionManager = getSessionManager();
-                                sessionManager.syncAfterCompaction(compactionResult.summary, compactionResult.compactedMessages.length - 2);
-                                await reinjectPlanContextAfterCompaction(messages);
-                                logger.info(`Plan approval compaction: ${compactionResult.tokensBefore} → ${compactionResult.tokensAfter} tokens`);
-                            }
-                        }
-                        catch (compactError) {
-                            logger.warn('Plan approval compaction failed, continuing with full context', { error: compactError });
-                        }
-                    }
-                    messages.push({
-                        role: 'user',
-                        content: 'Plan approved by user. Proceed immediately with executing Task 1 using the appropriate tools. Do not ask for confirmation - begin implementation now.',
-                    });
-                    logger.debug('Added plan continuation instruction to messages');
-                }
-                // Update accumulated text (display handled by streamBlocksRef)
-                accumulatedText = response.textContent;
-                // Plan mode fallback check: after first iteration, if LLM didn't call enter_plan_mode,
-                // run heuristic check and suggest plan mode if complexity is high
-                // Only run in HYBRID mode (PLAN mode already forces planning, DIRECT skips all planning)
-                if (executionMode === 'hybrid' && iterations === 1 && !planModeTriggered && !fallbackCheckDone) {
-                    fallbackCheckDone = true;
-                    try {
-                        // Get personality mode for consistent classifier tone
-                        const sessionMgrFallback = getSessionManager();
-                        const fallbackPersonality = sessionMgrFallback.getEffectivePersonalityMode();
-                        // Convert conversation history to Message format for analyzer context
-                        const conversationForFallback = conversation
-                            .filter(entry => entry.role === 'user' || entry.role === 'assistant')
-                            .map(entry => ({
-                            role: entry.role,
-                            content: entry.content
-                        }));
-                        const fallbackResult = await checkPlanModeFallback(input, // Original user input
-                        planModeTriggered, projectRoot, fallbackPersonality, abortControllerRef.current?.signal, // Pass abort signal for cancellation
-                        conversationForFallback // Pass conversation history for context
-                        );
-                        if (fallbackResult.shouldSuggestPlanMode && fallbackResult.suggestedPrompt) {
-                            logger.info('Plan mode fallback triggered - suggesting plan mode to LLM', {
-                                confidence: fallbackResult.confidence,
-                                detectedMode: fallbackResult.detectedMode,
-                            });
-                            // Inject system suggestion into the conversation
-                            messages.push({
-                                role: 'user',
-                                content: fallbackResult.suggestedPrompt,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        // Check if this was an abort (user cancelled)
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        const isAbort = errorMessage === 'Request aborted' ||
-                            (error instanceof Error && error.name === 'AbortError') ||
-                            abortLoopRef.current;
-                        if (isAbort) {
-                            logger.debug('Plan mode fallback check cancelled by user');
-                            wasAborted = true;
-                            break; // Exit the loop
-                        }
-                        logger.warn('Plan mode fallback check failed', { error });
-                        // Continue without suggestion on error
-                    }
-                }
-                // Check iteration limits at end of iteration
-                if (iterations >= maxIterations && !stuckDetected && !costCapExceeded) {
-                    // Global iteration limit reached (not plan mode specific)
-                    logger.warn('Agentic loop reached global maximum iterations');
-                    finalResponse = accumulatedText + '\n\n*(Reached maximum tool iterations)*';
-                    reachedMaxIterations = true;
-                    break;
-                }
-                else if (isPlanMode && !iterationScoper.shouldContinueIteration(iterations)) {
-                    // Task-specific iteration limit reached in plan mode
-                    const status = iterationScoper.getIterationStatus();
-                    logger.warn(`Task ${status.task} reached iteration limit (${status.iteration}/${status.max})`);
-                    // Get plan details to check if there are more tasks
-                    const planPersistence = getPlanPersistence(projectRoot);
-                    const activePlanId = planPersistence.getActivePlanId();
-                    const executionSummary = activePlanId ? await planPersistence.getExecutionSummary(activePlanId) : null;
-                    if (executionSummary && executionSummary.pending > 0) {
-                        // There are more tasks - prompt to continue with next task
-                        logger.info(`${executionSummary.pending} tasks remaining after iteration limit`);
-                        // Add continuation prompt to move to next task
-                        const continuationPrompt = `\n\n*Task iteration limit reached (${status.iteration}/${status.max}). ${executionSummary.completed} of ${executionSummary.total} tasks completed.*\n\nPlease move to the next pending task and continue execution.`;
-                        accumulatedText += continuationPrompt;
-                        // Update stream blocks with continuation message
-                        updateStreamBlocks((prev) => {
-                            const lastBlock = prev[prev.length - 1];
-                            if (lastBlock && lastBlock.type === 'text') {
-                                return [...prev.slice(0, -1), { ...lastBlock, content: lastBlock.content + continuationPrompt }];
-                            }
-                            return [...prev, createTextBlock(continuationPrompt)];
-                        });
-                        // Note: response.contentBlocks was already added to messages earlier in the iteration
-                        // Just add the continuation prompt as a user message
-                        messages.push({
-                            role: 'user',
-                            content: `The current task has used its iteration budget. Please proceed with the next task from the plan. Use complete_plan_task to mark the current task status, then move to the next task.`,
-                        });
-                        // Reset task iterations for next task (will be done automatically by event)
-                        // Continue the loop
-                        continue;
-                    }
-                    else {
-                        // No more tasks or couldn't get summary - end execution
-                        const iterationLimitMessage = `\n\n*(Task "${status.task}" reached iteration limit: ${status.iteration}/${status.max}. Type "continue" to resume work if the task is not yet complete.)*`;
-                        finalResponse = accumulatedText + iterationLimitMessage;
-                        // Ensure the message is displayed to the user
-                        updateStreamBlocks((prev) => {
-                            const lastBlock = prev[prev.length - 1];
-                            if (lastBlock && lastBlock.type === 'text') {
-                                return [...prev.slice(0, -1), { ...lastBlock, content: lastBlock.content + iterationLimitMessage }];
-                            }
-                            return [...prev, createTextBlock(iterationLimitMessage)];
-                        });
-                        reachedMaxIterations = true;
-                        break;
-                    }
-                }
-            }
-            // Handle user cancellation: rollback conversation state and clean up UI
-            // This removes the user's prompt so they can submit a corrected version
-            if (wasAborted) {
-                logger.info('Rolling back conversation state after user cancellation');
-                setConversation(conversationCheckpointRef.current);
-                resetStreamBlocks();
-                // Exit without adding any messages - finally block still runs for cleanup
-                return;
-            }
-            // Log the complete agentic loop
-            const loopDuration = Date.now() - loopStartTime;
-            // Collect per-task iteration data if in plan mode
-            const taskIterationData = isPlanMode
-                ? Array.from(iterationScoper.getTaskIterationHistory().entries()).map(([taskId, record]) => ({
-                    taskId,
-                    taskName: taskId, // TODO: Could enrich with actual task name from plan
-                    iterations: record.iterations,
-                    toolCalls: 0, // TODO: Could track tool calls per task
-                }))
-                : undefined;
-            await auditLogger.logAgenticLoop({
-                user_input: input,
-                system_prompt: systemPrompt,
-                model: client.getCurrentModel().id,
-                iterations: agenticIterations,
-                final_response: finalResponse,
-                total_iterations: iterations,
-                total_tool_calls: totalToolCalls,
-                total_usage: totalUsage,
-                total_cost: totalCost,
-                duration_ms: loopDuration,
-                reached_max_iterations: reachedMaxIterations,
-                isPlanMode,
-                planId: isPlanMode ? iterationScoper.getCurrentPlanId() || undefined : undefined,
-                task_iterations: taskIterationData,
-            });
-            // Expose to `finally` for post-response question detection
-            finalResponseForSuggestion = finalResponse;
-            // Add final assistant response to conversation (skip if empty - e.g., user rejected)
-            if (finalResponse) {
-                // Capture stream blocks before they get reset (for history display)
-                const capturedBlocks = [...streamBlocksRef.current];
-                const assistantEntry = {
-                    id: `assistant-${Date.now()}`,
-                    role: 'assistant',
-                    content: finalResponse,
-                    timestamp: new Date(),
-                    blocks: capturedBlocks.length > 0 ? capturedBlocks : undefined,
-                    durationMs: loopDuration,
-                };
-                setConversation((prev) => [...prev, assistantEntry]);
-                // Save to session manager
-                const sessionManager = getSessionManager();
-                sessionManager.addMessage({ role: 'user', content: input });
-                sessionManager.addMessage({ role: 'assistant', content: finalResponse });
-            }
-        }
-        catch (err) {
-            // Handle abort errors gracefully - don't show as error since user cancelled
-            if (err instanceof Error && (err.message === 'Request aborted' || err.name === 'AbortError')) {
-                logger.info('Request cancelled by user');
-                // Rollback conversation state on abort
-                setConversation(conversationCheckpointRef.current);
-                resetStreamBlocks();
-            }
-            else {
-                const errorMessage = err instanceof Error ? err.message : 'Failed to get response';
-                setError(errorMessage);
-                logger.error('API request failed', err);
-                await auditLogger.logError(errorMessage, err);
-            }
-        }
-        finally {
-            setIsProcessing(false);
-            setSessionPhase('idle');
-            // Clear complexity context after request completes
-            approvalManager.clearComplexityContext();
-            // Detect if the LLM ended with a question and suggest a short reply
-            setSuggestionOffer(deriveQuestionSuggestion(finalResponseForSuggestion));
-            // Clear temporary personality mode after response completes
-            const sessionMgrForCleanup = getSessionManager();
-            if (sessionMgrForCleanup.hasTemporaryPersonalityMode()) {
-                sessionMgrForCleanup.clearTemporaryPersonalityMode();
-                logger.debug('Temporary personality mode cleared after response');
-            }
-            // Stop iteration scoping if plan mode was active
-            if (isPlanMode) {
-                iterationScoper.stopPlanExecution();
-            }
-            // Pause the plan execution tracker when processing ends but plan is not complete
-            // This hides the tracker when the LLM asks a follow-up question
-            {
-                const prev = activePlanRef.current;
-                if (prev && !prev.isComplete) {
-                    activePlanRef.current = { ...prev, isPaused: true };
-                }
-                setActivePlan(activePlanRef.current);
-            }
-        }
-    }, [conversation, projectRoot, projectSummary, executionMode]);
-    /**
-     * Routes prompt submissions: queues during processing, submits directly when idle
-     * Uses refs to keep the callback identity stable across renders, preventing
-     * React.memo on Prompt from breaking during the agentic loop (which would cause
-     * full Prompt re-renders on every scheduleRender tick, blocking stdin events).
-     */
-    const isProcessingRef = useRef(isProcessing);
-    isProcessingRef.current = isProcessing;
-    const handleSubmitRef = useRef(handleSubmit);
-    handleSubmitRef.current = handleSubmit;
-    const handlePromptSubmit = useCallback((input) => {
-        if (isProcessingRef.current) {
-            const trimmed = input.trim();
-            if (!trimmed)
-                return;
-            // Slash commands cannot be queued — show feedback instead of silently dropping
-            if (trimmed.startsWith('/')) {
-                setError(`Slash commands cannot be queued while processing. Wait for the current operation to complete, then retry: ${trimmed.length > 60 ? trimmed.substring(0, 60) + '...' : trimmed}`);
-                return;
-            }
-            queuedMessagesRef.current = [...queuedMessagesRef.current, trimmed];
-            setQueuedMessages([...queuedMessagesRef.current]);
-            return;
-        }
-        handleSubmitRef.current(input);
-    }, []); // Stable identity — never changes
-    /**
-     * Handles approval dialog choices
-     */
-    const handleApprovalChoice = useCallback((choice, userFeedback) => {
-        const approvalManager = getApprovalManager();
-        const request = approvalManager.getPendingRequest();
-        // Update modalActiveRef synchronously BEFORE resolving the approval
-        // This ensures that scheduleRender won't skip renders for tool results
-        // that complete immediately after approval (before useEffect runs)
-        modalActiveRef.current = false;
-        // Handle approve_all_session: enable session auto-approval and treat as 'approve'
-        if (choice === 'approve_all_session') {
-            approvalManager.enableSessionAutoApproval();
-            // Also switch to SMART mode for consistency with /smart switch
-            const sessionManager = getSessionManager();
-            approvalManager.setMode(ApprovalMode.SMART);
-            sessionManager.setApprovalMode(ApprovalMode.SMART);
-            setApprovalMode(ApprovalMode.SMART);
-            approvalManager.resolveRequest('approve');
-            setPendingApproval(null);
-            logger.debug('Operation approved - Auto-approving all changes this session (SMART mode)');
-            return;
-        }
-        // Handle approve_command_type: approve this command prefix for the session
-        if (choice === 'approve_command_type') {
-            const command = request?.details.command;
-            if (command) {
-                approvalManager.approveCommandPrefix(command);
-                const prefix = approvalManager.getCommandPrefix(command);
-                approvalManager.resolveRequest('approve');
-                setPendingApproval(null);
-                logger.debug(`Operation approved - "${prefix}" commands will be auto-approved this session`);
-                return;
-            }
-        }
-        // Pass user feedback as reason if provided
-        const reason = userFeedback && userFeedback.trim()
-            ? `User feedback: ${userFeedback}`
-            : undefined;
-        approvalManager.resolveRequest(choice, reason);
-        setPendingApproval(null);
-        if (choice === 'approve') {
-            logger.debug('Operation approved');
-        }
-        else if (choice === 'reject') {
-            // Log rejection details at debug level - user already knows they rejected it
-            const operationType = request?.type || 'operation';
-            const affectedFiles = request?.details.filePaths?.join(', ') || 'unknown';
-            logger.debug(`Operation rejected - type: ${operationType}, files: ${affectedFiles}`);
-            if (userFeedback && userFeedback.trim()) {
-                logger.debug(`User feedback: ${userFeedback}`);
-            }
-        }
-        else if (choice === 'cancel') {
-            logger.debug('Operation cancelled - NO changes were made');
-        }
-    }, []);
-    /**
-     * Handles plan approval dialog choices
-     */
-    const handlePlanApprovalChoice = useCallback((choice, input) => {
-        const approvalManager = getApprovalManager();
-        // Update modalActiveRef synchronously to allow immediate renders after approval
-        modalActiveRef.current = false;
-        // Helper: build task list preserving completed status for plan updates
-        const buildActivePlan = (request) => {
-            if (!request)
-                return;
-            const completedSet = new Set(request.completedTaskIds || []);
-            setPlanTrackerMode('compact');
-            activePlanRef.current = {
-                planId: request.plan.id,
-                title: request.plan.problemStatement,
-                tasks: request.plan.tasks.map((task) => ({
-                    task,
-                    status: completedSet.has(task.id) ? 'completed' : 'pending',
-                })),
-                isComplete: false,
-                success: false,
-            };
-            setActivePlan(activePlanRef.current);
-        };
-        if (choice === 'approve') {
-            // Initialize plan execution tracker with the approved plan
-            buildActivePlan(pendingPlanApproval);
-            // Always clear context on plan approval so execution starts fresh with only the plan
-            planApprovalClearContextRef.current = true;
-            approvalManager.resolvePlanApproval('approve');
-            setPendingPlanApproval(null);
-        }
-        else if (choice === 'approve-compact') {
-            buildActivePlan(pendingPlanApproval);
-            planApprovalClearContextRef.current = true;
-            approvalManager.resolvePlanApproval('approve');
-            setPendingPlanApproval(null);
-        }
-        else if (choice === 'approve-auto-edits') {
-            buildActivePlan(pendingPlanApproval);
-            // Always clear context on plan approval so execution starts fresh with only the plan
-            planApprovalClearContextRef.current = true;
-            approvalManager.enableFileEditsAutoApproval();
-            approvalManager.resolvePlanApproval('approve');
-            setPendingPlanApproval(null);
-        }
-        else if (choice === 'clarify') {
-            approvalManager.resolvePlanApproval('clarify', undefined, input);
-            setPendingPlanApproval(null);
-            logger.output('Clarification requested - returning to planning');
-        }
-        else if (choice === 'edit') {
-            approvalManager.resolvePlanApproval('edit', input, undefined);
-            setPendingPlanApproval(null);
-            logger.output('Plan modification requested - updating plan');
-        }
-        else if (choice === 'reject') {
-            approvalManager.resolvePlanApproval('reject');
-            setPendingPlanApproval(null);
-        }
-    }, [pendingPlanApproval]);
-    /**
-     * Handles clarification wizard completion
-     */
-    const handleClarificationComplete = useCallback((answers) => {
-        const approvalManager = getApprovalManager();
-        // Update modalActiveRef synchronously to allow immediate renders after completion
-        modalActiveRef.current = false;
-        approvalManager.resolveClarificationWizard(answers);
-        setPendingClarification(null);
-        logger.debug('✅ Clarification completed');
-    }, []);
-    /**
-     * Handles clarification wizard cancellation
-     */
-    const handleClarificationCancel = useCallback(() => {
-        const approvalManager = getApprovalManager();
-        // Update modalActiveRef synchronously to allow immediate renders after cancellation
-        modalActiveRef.current = false;
-        approvalManager.resolveClarificationWizard(null);
-        setPendingClarification(null);
-        abortLoopRef.current = true; // Signal agentic loop to stop
-        logger.output('Clarification cancelled - returning to prompt');
-    }, []);
-    /**
-     * Handles execution mode selection from the mode selector
-     */
-    const handleModeSelect = useCallback((mode) => {
-        const sessionManager = getSessionManager();
-        setExecutionMode(mode);
-        sessionManager.setExecutionMode(mode);
-        setActiveOverlay('none');
-        // Show confirmation message
-        const modeDescriptions = {
-            hybrid: 'LLM decides when to use planning based on complexity',
-            direct: 'Pure agentic execution, no planning',
-            plan: 'Always forces planning for every task'
-        };
-        const modeAliases = {
-            hybrid: 'h',
-            direct: 'd',
-            plan: 'p'
-        };
-        const color = mode === 'hybrid' ? chalk.cyan : mode === 'direct' ? chalk.yellow : chalk.magenta;
-        logger.output('');
-        logger.output(chalk.green('✓') + ` Switched to ${color.bold(mode.toUpperCase())} ${chalk.gray(`(${modeAliases[mode]})`)}`);
-        logger.output(`  ${chalk.gray(modeDescriptions[mode])}`);
-        logger.output('');
-    }, []);
-    /**
-     * Handles mode selector cancellation
-     */
-    const handleModeCancel = useCallback(() => {
-        setActiveOverlay('none');
-    }, []);
-    /**
-     * Performs the actual logout operation
-     */
-    const performLogout = useCallback(async () => {
-        try {
-            const { getCredentialStore } = await import('../services/credential-store.js');
-            const credentialStore = await getCredentialStore();
-            logger.output('');
-            logger.output(chalk.gray('Clearing credentials...'));
-            const hasCompassKey = await credentialStore.hasCompassApiKey();
-            const hasAnthropicKey = await credentialStore.hasApiKey();
-            let compassCleared = true;
-            let anthropicCleared = true;
-            if (hasCompassKey) {
-                compassCleared = await credentialStore.deleteCompassApiKey();
-            }
-            if (hasAnthropicKey) {
-                anthropicCleared = await credentialStore.deleteApiKey();
-            }
-            // Clear provider-specific keys
-            const providerNames = ['ollama', 'zai', 'minimax'];
-            const providerResults = {};
-            for (const provider of providerNames) {
-                if (await credentialStore.hasProviderApiKey(provider)) {
-                    providerResults[provider] = await credentialStore.deleteProviderApiKey(provider);
-                }
-            }
-            const allProvidersCleared = Object.values(providerResults).every(v => v);
-            const allCleared = compassCleared && anthropicCleared && allProvidersCleared;
-            if (allCleared) {
-                logger.output('');
-                logger.output(chalk.green.bold('✅ Logged out successfully'));
-                logger.output(chalk.gray('All API keys have been cleared from secure storage.'));
-                logger.output('');
-                logger.output(chalk.gray('Exiting Compass...'));
-                logger.output('');
-                logger.info('User logged out - all API keys cleared - exiting');
-                // Exit via the proper Ink exit flow (avoids yoga WASM use-after-free)
-                await onExit();
-            }
-            else {
-                logger.output('');
-                logger.output(chalk.yellow('⚠️  Partial logout'));
-                logger.output(chalk.gray('Some credentials could not be cleared. See logs for details.'));
-                logger.output('');
-                logger.warn('Partial logout - some credentials may not have been cleared', {
-                    compassCleared,
-                    anthropicCleared,
-                    providerResults,
-                });
-                // Still exit even on partial logout
-                logger.output(chalk.gray('Exiting Compass...'));
-                logger.output('');
-                await onExit();
-            }
-        }
-        catch (error) {
-            logger.output('');
-            logger.output(chalk.red('❌ Logout failed'));
-            if (error instanceof Error) {
-                logger.output(chalk.red(`   ${error.message}`));
-            }
-            logger.output('');
-            logger.error('Logout failed', error);
-        }
-    }, []);
-    /**
-     * Handles logout confirmation from the selector
-     */
-    const handleLogoutConfirm = useCallback(() => {
-        setActiveOverlay('none');
-        performLogout();
-    }, [performLogout]);
-    /**
-     * Handles logout cancellation from the selector
-     */
-    const handleLogoutCancel = useCallback(() => {
-        setActiveOverlay('none');
-        logger.output('');
-        logger.output(chalk.gray('Logout cancelled.'));
-        logger.output('');
-    }, []);
-    /**
-     * Handles rating submission
-     */
-    const handleRatingSubmit = useCallback(async (rating) => {
-        const ratingService = getRatingService();
-        try {
-            const result = await ratingService.submitRating(rating);
-            if (result.success && ratingStateManagerRef.current) {
-                await ratingStateManagerRef.current.recordRatingSubmitted();
-            }
-            logger.debug('[Rating] Rating submitted', { rating, success: result.success });
-        }
-        catch (error) {
-            logger.debug('[Rating] Failed to submit rating', error);
-        }
-        setShowRatingPanel(false);
-        ratingPanelShownRef.current = false;
-    }, []);
-    /**
-     * Handles rating panel close without submission
-     */
-    const handleRatingClose = useCallback(() => {
-        setShowRatingPanel(false);
-        ratingPanelShownRef.current = false;
-        // Note: Not recording as "shown" here to allow it to appear again
-        // The rating will appear again after continued usage
-    }, []);
-    /**
-     * Handles keyboard input for overlay navigation and shortcuts
-     */
-    useInput((input, key) => {
-        // Escape handling
-        if (key.escape) {
-            // During processing (agentic loop), single Esc gracefully breaks the loop
-            if (isProcessing && !pendingClarification && !pendingApproval && !pendingPlanApproval) {
-                // Set abort flag to break the agentic loop
-                abortLoopRef.current = true;
-                // Clear queued messages on abort
-                queuedMessagesRef.current = [];
-                setQueuedMessages([]);
-                // Also abort any in-flight API request immediately
-                if (abortControllerRef.current) {
-                    abortControllerRef.current.abort();
-                }
-                // Cancel any pending plan approval or clarification wizards
-                const approvalManager = getApprovalManager();
-                approvalManager.cancelPendingPlanApproval();
-                approvalManager.cancelPendingClarificationWizard();
-                logger.debug('Cancelled by the user');
-                return;
-            }
-            // Close overlays
-            if (activeOverlay !== 'none') {
-                setActiveOverlay('none');
-                return;
-            }
-            if (error) {
-                setError(null);
-                return;
-            }
-        }
-        // Ctrl+X to skip current execute_command (kill subprocess, continue agentic loop)
-        if (key.ctrl && input === 'x' && isProcessing && toolAbortRef.current && currentToolNameRef.current === 'execute_command') {
-            toolAbortRef.current.abort();
-            return;
-        }
-        // Ctrl+C to cancel current operation or exit
-        if (key.ctrl && input === 'c') {
-            if (isProcessing) {
-                queuedMessagesRef.current = [];
-                setQueuedMessages([]);
-                setIsProcessing(false);
-                resetStreamBlocks();
-                setError('Operation cancelled');
-            }
-            return;
-        }
-        // Ctrl+L to clear screen (including Static items in scrollback)
-        if (key.ctrl && input === 'l') {
-            process.stdout.write('\x1B[2J\x1B[H');
-            setConversation([]);
-            setError(null);
-            return;
-        }
-        // Ctrl+T to toggle tool blocks display in history
-        if (key.ctrl && input === 't') {
-            setShowToolBlocks((prev) => {
-                const newValue = !prev;
-                // Persist to session
-                const sessionManager = getSessionManager();
-                sessionManager.setShowToolBlocks(newValue);
-                logger.output(newValue ? 'Tool execution details enabled in history.' : 'Minimal history mode (text only).');
-                return newValue;
-            });
-            return;
-        }
-        // Ctrl+O to toggle user prompt collapse and MCP result expansion in history
-        // Throttled to prevent yoga-layout WASM crash on rapid toggling
-        if (key.ctrl && input === 'o') {
-            const now = Date.now();
-            if (now - lastExpandToggleRef.current < 150) {
-                return; // Throttle rapid toggling
-            }
-            lastExpandToggleRef.current = now;
-            setCollapseUserPrompts((prev) => {
-                const newValue = !prev;
-                // Also toggle MCP results (inverse logic: when prompts collapse, MCP results are trimmed)
-                setExpandMCPResults(!newValue);
-                return newValue;
-            });
-            return;
-        }
-        // Cycle plan tracker mode with 'p' key during plan execution: compact → full → hidden → compact
-        if (input === 'p' && activePlan && !activePlan.isComplete && isProcessing) {
-            setPlanTrackerMode((prev) => prev === 'compact' ? 'full' : prev === 'full' ? 'hidden' : 'compact');
-            return;
-        }
-    }, { isActive: !pendingApproval && !pendingPlanApproval && !pendingClarification });
-    // Conversation entries are split between <Static> (scrollback) and dynamic rendering.
-    // <Static> is FROZEN during active streaming to prevent layout shifts. Adding items to
-    // <Static> mid-stream forces Ink to write permanent content above the dynamic area,
-    // causing reflow/flickering. However, when the user is interacting with a modal
-    // (tool approval, clarification, plan approval), streaming has stopped and the dynamic
-    // area is minimal — safe to settle completed entries into Static. This prevents long
-    // agentic loops from accumulating unbounded dynamic entries that re-render on every update.
-    //
-    // Entries between the Static freeze point and the latest are rendered dynamically
-    // (outside <Static>) so they remain visible without causing scrollback writes.
-    // A ref ensures items are never re-committed to <Static> across re-renders.
-    const staticCommittedRef = useRef([]);
-    const { settledEntries, dynamicEntries } = useMemo(() => {
-        if (conversation.length === 0) {
-            staticCommittedRef.current = [];
-            return { settledEntries: [], dynamicEntries: [] };
-        }
-        // Settle into Static when idle OR when a modal is active (streaming is paused,
-        // user is focused on the modal, and all prior entries are finalized).
-        const inModal = !!(pendingApproval || pendingPlanApproval || pendingClarification);
-        if (!isProcessing || inModal) {
-            if (conversation.length > staticCommittedRef.current.length) {
-                staticCommittedRef.current = conversation;
-            }
-            return { settledEntries: staticCommittedRef.current, dynamicEntries: [] };
-        }
-        // During active streaming, freeze <Static> — don't commit new entries mid-stream.
-        // Any entries added since the freeze point are rendered dynamically.
-        const frozenCount = staticCommittedRef.current.length;
-        return {
-            settledEntries: staticCommittedRef.current,
-            dynamicEntries: frozenCount < conversation.length
-                ? conversation.slice(frozenCount)
-                : [],
-        };
-    }, [conversation, isProcessing, pendingApproval, pendingPlanApproval, pendingClarification]);
-    /**
-     * Formats a timestamp for display
-     */
-    function formatTime(date) {
-        return date.toLocaleTimeString('en-US', {
-            hour: '2-digit',
-            minute: '2-digit',
-        });
-    }
-    // Keep working-dot ANSI offset in sync: 3 fixed lines (top hr, input, bottom hr)
-    // plus one line per queued message. Status line shares the bottom hr line.
-    workingDotOffsetRef.current = 3 + queuedMessages.length;
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Static, { items: showHistory ? settledEntries : [], children: (entry) => (_jsx(ConversationEntryComponent, { entry: entry, showToolBlocks: showToolBlocks, collapseUserPrompts: collapseUserPrompts, expandMCPResults: expandMCPResults, formatTime: formatTime }, entry.id)) }), showHistory && dynamicEntries.map((entry) => (_jsx(ConversationEntryComponent, { entry: entry, showToolBlocks: showToolBlocks, collapseUserPrompts: collapseUserPrompts, expandMCPResults: expandMCPResults, formatTime: formatTime }, entry.id))), isProcessing && streamingCommandOutput.length > 0 && (_jsx(Box, { marginBottom: 1, flexDirection: "column", children: streamingCommandOutput.map((line, idx) => (_jsx(Text, { children: line }, idx))) })), !isProcessing && slashCommandOutput && slashCommandOutput.trim().length > 0 && (_jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsx(Text, { children: slashCommandOutput }) })), sessionPhase === 'executing' && activePlan && !activePlan.isComplete && planTrackerMode !== 'hidden' && !pendingApproval && (_jsx(PlanExecutionTracker, { planId: activePlan.planId, title: activePlan.title, tasks: activePlan.tasks, isComplete: activePlan.isComplete, success: activePlan.success, compact: planTrackerMode === 'compact' })), sessionPhase === 'executing' && activePlan && !activePlan.isComplete && planTrackerMode === 'hidden' && !pendingApproval && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "blue", children: '\u2500'.repeat(Math.max(0, (process.stdout.columns || 80) - 4)) }), _jsx(Text, { dimColor: true, children: "Plan progress hidden (press p to show)" }), _jsx(Text, { color: "blue", children: '\u2500'.repeat(Math.max(0, (process.stdout.columns || 80) - 4)) })] })), _jsx(Box, { flexDirection: "column", children: _jsx(InterleavedStream, { blocks: isProcessing ? streamBlocksRef.current : emptyBlocksRef.current, isStreaming: isProcessing && !pendingApproval && !pendingPlanApproval && !pendingClarification, showThinkingIndicator: isProcessing && !pendingApproval && !pendingPlanApproval && !pendingClarification, expandMCPResults: expandMCPResults, maxVisibleBlocks: MAX_DYNAMIC_STREAM_BLOCKS }) }), error && !isProcessing && (_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { color: "red", children: ["\u274C ", error] }), _jsx(Text, { dimColor: true, children: " (Press Esc to dismiss)" })] })), pendingApproval && (_jsx(ApprovalDialog, { request: pendingApproval, onChoice: handleApprovalChoice })), pendingPlanApproval && (_jsx(PlanApprovalDialog, { request: pendingPlanApproval, onChoice: handlePlanApprovalChoice, contextTokens: currentContextTokens })), pendingClarification && (_jsx(ClarificationWizard, { questions: pendingClarification.questions, onComplete: handleClarificationComplete, onCancel: handleClarificationCancel })), activeOverlay === 'help' && (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsx(HelpMenu, {}) })), activeOverlay === 'tokens' && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(TokenUsage, { usage: tokenUsage, cost: cost, contextWindow: contextWindowSize, showDetails: true }), _jsx(Text, { dimColor: true, children: "Press Esc to close" })] })), activeOverlay === 'agents' && (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsx(AgentManager, { onClose: () => setActiveOverlay('none'), isActive: true, projectRoot: projectRoot }) })), activeOverlay === 'agent-wizard' && (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsx(AgentCreationWizard, { onComplete: (agentPath) => {
-                        logger.info(`Agent created: ${agentPath}`);
-                        setActiveOverlay('none');
-                    }, onCancel: () => setActiveOverlay('none'), isActive: true, projectRoot: projectRoot, enabledTools: getToolRegistry().getToolDefinitions().map(t => t.name) }) })), activeOverlay === 'diff' && diffPreview && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(DiffPreview, { diff: diffPreview }), _jsx(Text, { dimColor: true, children: "Press Esc to close" })] })), activeOverlay === 'mode-selector' && (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsx(ExecutionModeSelector, { currentMode: executionMode, onSelect: handleModeSelect, onCancel: handleModeCancel, isActive: true }) })), activeOverlay === 'logout-confirm' && (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsx(ConfirmationSelector, { title: "\uD83D\uDEAA Logout", question: "Are you sure you want to logout and clear all stored API keys?", details: logoutDetails, onConfirm: handleLogoutConfirm, onCancel: handleLogoutCancel, isActive: true }) })), showRatingPanel && hasCompassApiKey && !pendingApproval && !pendingPlanApproval && !pendingClarification && !isProcessing && activeOverlay === 'none' && (_jsx(RatingPanel, { onClose: handleRatingClose, onSubmit: handleRatingSubmit, isActive: true })), _jsx(CompassSpinner, { isActive: compassSpinner?.active ?? false, message: compassSpinner?.message }), isProcessing && !pendingApproval && !pendingPlanApproval && !pendingClarification && streamBlocksRef.current.length > 0 && (_jsx(WorkingIndicator, { linesBelowRef: workingDotOffsetRef })), queuedMessages.length > 0 && (_jsx(Box, { flexDirection: "column", paddingX: 1, children: queuedMessages.map((msg, i) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "  queued: " }), _jsx(Text, { dimColor: true, italic: true, children: msg.length > 60 ? msg.substring(0, 60) + '...' : msg })] }, i))) })), !isContextLoading && !pendingApproval && !pendingPlanApproval && !pendingClarification && activeOverlay !== 'mode-selector' && activeOverlay !== 'logout-confirm' && activeOverlay !== 'agents' && activeOverlay !== 'agent-wizard' && (_jsx(Prompt, { approvalMode: approvalMode, model: currentModel, activeAgentName: activeAgentName, onSubmit: handlePromptSubmit, onPaste: handlePaste, disabled: false, isProcessing: isProcessing, projectRoot: projectRoot, showStatusBar: false, suggestionOffer: suggestionOffer })), _jsxs(Box, { width: "100%", justifyContent: "space-between", children: [_jsxs(Box, { children: [executionMode === 'direct' && _jsx(Text, { color: "yellow", children: "direct mode" }), executionMode === 'plan' && _jsx(Text, { color: "magenta", children: "plan mode" }), activeAgentName && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: " \u2502 " }), _jsxs(Text, { color: "magenta", bold: true, children: ["\uD83E\uDD16 ", activeAgentName] })] }))] }), statusLineVisible && statusLineText && (_jsx(Text, { children: statusLineText }))] })] }));
-};
-export default InteractiveSession;
-//# sourceMappingURL=InteractiveSession.js.map