agentk8 2.2.6 → 2.3.1

package/dist/cli.js

@@ -4,7 +4,7 @@ import { render } from 'ink';
 import meow from 'meow';
 import { App } from './components/App.js';
 import { checkClaudeInstalled } from './lib/claude.js';
-const VERSION = '2.2.6';
+const VERSION = '2.3.0';
 const cli = meow(`
   Usage
     $ agentk8 [options]

package/dist/components/App.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import { Box, Text, useApp, useInput, Static } from 'ink';
 import { WelcomeBox } from './WelcomeBox.js';
 import { ChatMessage } from './ChatMessage.js';
@@ -7,9 +7,19 @@ import { Input } from './Input.js';
 import { StatusBar } from './StatusBar.js';
 import { ThinkingIndicator } from './ThinkingIndicator.js';
 import { runClaude } from '../lib/claude.js';
+import { runCouncil, checkCouncilAvailable, getAvailableModels } from '../lib/council.js';
+import { Confirmation } from './Confirmation.js';
+import { QuestionWizard } from './QuestionWizard.js';
 export const App = ({ mode, version }) => {
     const { exit } = useApp();
-    const [messages, setMessages] = useState([]);
+    // Initialize with welcome message as permanent first item
+    const [messages, setMessages] = useState([{
+            id: 'welcome',
+            role: 'system',
+            content: '',
+            timestamp: new Date(),
+            isWelcome: true,
+        }]);
     const [isProcessing, setIsProcessing] = useState(false);
     const [processingStartTime, setProcessingStartTime] = useState(null);
     const [totalTokens, setTotalTokens] = useState(0);
@@ -18,10 +28,71 @@ export const App = ({ mode, version }) => {
     const [executionMode, setExecutionMode] = useState('plan');
     const [activeAgent, setActiveAgent] = useState(undefined);
     const [completedAgents, setCompletedAgents] = useState([]);
-    const [pendingPlan, setPendingPlan] = useState(null);
-    const [awaitingApproval, setAwaitingApproval] = useState(false);
+    const [confirmationState, setConfirmationState] = useState(null);
     const [autoAccept, setAutoAccept] = useState(false);
-    const [pendingAutoAccept, setPendingAutoAccept] = useState(false);
+    const [councilMode, setCouncilMode] = useState('off');
+    const [councilAvailable, setCouncilAvailable] = useState(false);
+    const [availableModels, setAvailableModels] = useState({});
+    const [councilStage, setCouncilStage] = useState(null);
+    const [lastEscapeTime, setLastEscapeTime] = useState(0);
+    const [showExitHint, setShowExitHint] = useState(false);
+    const [questionWizardState, setQuestionWizardState] = useState(null);
+    // Clean orchestrator internal tags from response
+    const cleanOrchestratorTags = (response) => {
+        let cleaned = response;
+        // Remove <thinking>...</thinking> blocks
+        cleaned = cleaned.replace(/<thinking>[\s\S]*?<\/thinking>/g, '');
+        // Remove <task_analysis>...</task_analysis> blocks (keep content inside)
+        cleaned = cleaned.replace(/<\/?task_analysis>/g, '');
+        // Remove <response>...</response> tags (keep content inside)
+        cleaned = cleaned.replace(/<\/?response>/g, '');
+        // Clean up multiple consecutive newlines
+        cleaned = cleaned.replace(/\n{3,}/g, '\n\n');
+        // Clean up leading/trailing whitespace
+        cleaned = cleaned.trim();
+        return cleaned;
+    };
+    // Parse questions from orchestrator response
+    const parseQuestions = (response) => {
+        const questions = [];
+        let cleanedResponse = response;
+        // Match <question header="...">...</question> blocks
+        const questionRegex = /<question\s+header="([^"]+)">\s*([\s\S]*?)\s*<options>\s*([\s\S]*?)\s*<\/options>\s*<\/question>/g;
+        let match;
+        while ((match = questionRegex.exec(response)) !== null) {
+            const header = match[1];
+            const questionText = match[2].trim();
+            const optionsBlock = match[3];
+            // Parse options
+            const optionRegex = /<option(?:\s+recommended="true")?>(.*?)<\/option>/g;
+            const options = [];
+            let optionMatch;
+            while ((optionMatch = optionRegex.exec(optionsBlock)) !== null) {
+                const isRecommended = optionMatch[0].includes('recommended="true"');
+                options.push({
+                    label: optionMatch[1].trim(),
+                    recommended: isRecommended,
+                });
+            }
+            if (options.length > 0) {
+                questions.push({
+                    header,
+                    question: questionText,
+                    options,
+                });
+            }
+            // Remove this question block from the response
+            cleanedResponse = cleanedResponse.replace(match[0], '').trim();
+        }
+        // Clean orchestrator internal tags from the remaining response
+        cleanedResponse = cleanOrchestratorTags(cleanedResponse);
+        return { questions, cleanedResponse };
+    };
+    // Check council availability on mount
+    useEffect(() => {
+        checkCouncilAvailable().then(setCouncilAvailable);
+        getAvailableModels().then(setAvailableModels);
+    }, []);
     // Detect agents mentioned in response
     const detectMentionedAgents = (content) => {
         const agents = [];
@@ -42,37 +113,9 @@ export const App = ({ mode, version }) => {
             handleCommand(input);
             return;
         }
-        // Handle auto-accept confirmation
-        if (pendingAutoAccept) {
-            if (input.trim() === '') {
-                // Enter = confirm auto-accept
-                setAutoAccept(true);
-                setPendingAutoAccept(false);
-                return;
-            }
-            // Any other input = cancel and process as normal input
-            setPendingAutoAccept(false);
-        }
-        // Handle approval response
-        if (awaitingApproval) {
-            // Enter (empty input) = approve
-            if (input.trim() === '') {
-                setAwaitingApproval(false);
-                if (pendingPlan) {
-                    await executeTask(pendingPlan);
-                    setPendingPlan(null);
-                }
-                return;
-            }
-            else if (input.toLowerCase() === 'n' || input.toLowerCase() === 'no') {
-                setAwaitingApproval(false);
-                setPendingPlan(null);
-                addSystemMessage('Plan cancelled. What would you like to do instead?');
-                return;
-            }
-            // Any other input cancels and starts new request
-            setAwaitingApproval(false);
-            setPendingPlan(null);
+        // Handle confirmation response
+        if (confirmationState) {
+            return; // Input is disabled when confirmation is active
         }
         // Add user message
         const userMessage = {
@@ -82,13 +125,64 @@ export const App = ({ mode, version }) => {
             timestamp: new Date(),
         };
         setMessages(prev => [...prev, userMessage]);
-        if (executionMode === 'plan') {
+        // Use council mode if enabled
+        if (councilMode !== 'off') {
+            await executeCouncil(input);
+        }
+        else if (executionMode === 'plan') {
             await generatePlan(input);
         }
         else {
             await executeTask(input);
         }
     };
+    // Execute via Council
+    const executeCouncil = async (input) => {
+        setIsProcessing(true);
+        setProcessingStartTime(new Date());
+        setActiveAgent('Orchestrator');
+        setCompletedAgents([]);
+        setError(null);
+        setCouncilStage('scout');
+        try {
+            const result = await runCouncil(input, { mode: councilMode }, (update) => {
+                // Update stage indicator
+                if (update.stage.startsWith('stage1')) {
+                    setCouncilStage('stage1');
+                    setActiveAgent('Orchestrator');
+                }
+                else if (update.stage.startsWith('stage2')) {
+                    setCouncilStage('stage2');
+                }
+                else if (update.stage.startsWith('stage3')) {
+                    setCouncilStage('stage3');
+                }
+            });
+            setCompletedAgents(['Orchestrator']);
+            setActiveAgent(undefined);
+            setCouncilStage(null);
+            const councilMessage = {
+                id: (Date.now() + 1).toString(),
+                role: 'agent',
+                agentName: 'Council',
+                content: result.final_response,
+                tokens: result.total_tokens,
+                timestamp: new Date(),
+            };
+            setMessages(prev => [...prev, councilMessage]);
+            if (result.total_tokens) {
+                setTotalTokens(prev => prev + result.total_tokens.input + result.total_tokens.output);
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Council error');
+        }
+        finally {
+            setIsProcessing(false);
+            setProcessingStartTime(null);
+            setCouncilStage(null);
+        }
+    };
     // Generate a plan for approval
     const generatePlan = async (input) => {
         setIsProcessing(true);
@@ -104,18 +198,21 @@ Respond with:
 1. Task Analysis (complexity, scope)
 2. Agents Required (list which specialists are needed)
 3. Step-by-Step Plan (numbered steps)
-4. Questions (if any clarification needed)
+4. Questions (if any clarification needed - use the XML question format)
 
 Format your response clearly with headers.`;
             const result = await runClaude(planPrompt, mode, autoAccept);
-            const mentioned = detectMentionedAgents(result.response);
+            // Check for questions in response
+            const { questions, cleanedResponse } = parseQuestions(result.response);
+            const mentioned = detectMentionedAgents(cleanedResponse || result.response);
             setCompletedAgents(['Orchestrator', ...mentioned]);
             setActiveAgent(undefined);
+            // Show the cleaned response (without question XML)
             const planMessage = {
                 id: (Date.now() + 1).toString(),
                 role: 'agent',
                 agentName: 'Orchestrator',
-                content: result.response,
+                content: cleanedResponse || result.response,
                 tokens: result.tokens,
                 timestamp: new Date(),
             };
@@ -123,14 +220,58 @@ Format your response clearly with headers.`;
             if (result.tokens) {
                 setTotalTokens(prev => prev + result.tokens.input + result.tokens.output);
             }
-            setPendingPlan(input);
-            setAwaitingApproval(true);
-            addSystemMessage('Press Enter to execute, or type "n" to cancel');
+            // Stop processing BEFORE showing wizard/confirmation to prevent overlap
+            setIsProcessing(false);
+            setProcessingStartTime(null);
+            // If questions were found, show the wizard
+            if (questions.length > 0) {
+                setQuestionWizardState({
+                    questions,
+                    originalInput: input,
+                    onComplete: async (answers) => {
+                        setQuestionWizardState(null);
+                        // Format answers as follow-up message
+                        const answerText = answers.map(a => `- ${a.header}: ${a.answer}`).join('\n');
+                        const followUp = `My answers:\n${answerText}\n\nPlease proceed with these choices.`;
+                        // Add user message with answers
+                        const userAnswer = {
+                            id: Date.now().toString(),
+                            role: 'user',
+                            content: followUp,
+                            timestamp: new Date(),
+                        };
+                        setMessages(prev => [...prev, userAnswer]);
+                        // Continue with the task including answers
+                        await executeTask(`${input}\n\n${followUp}`);
+                    },
+                });
+            }
+            else {
+                // No questions, show plan approval
+                setConfirmationState({
+                    message: 'Do you want to execute this plan?',
+                    options: [
+                        { label: 'Yes, execute plan', value: 'yes', key: 'Enter' },
+                        { label: 'No, cancel', value: 'no', key: 'Esc' },
+                    ],
+                    onSelect: (value) => {
+                        setConfirmationState(null);
+                        if (value === 'yes') {
+                            executeTask(input);
+                        }
+                        else {
+                            addSystemMessage('Plan cancelled.');
+                        }
+                    },
+                    onCancel: () => {
+                        setConfirmationState(null);
+                        addSystemMessage('Plan cancelled.');
+                    },
+                });
+            }
         }
         catch (err) {
             setError(err instanceof Error ? err.message : 'Unknown error');
-        }
-        finally {
             setIsProcessing(false);
             setProcessingStartTime(null);
         }
@@ -144,14 +285,16 @@ Format your response clearly with headers.`;
         setError(null);
         try {
             const result = await runClaude(input, mode, autoAccept);
-            const mentioned = detectMentionedAgents(result.response);
+            // Check for questions in response
+            const { questions, cleanedResponse } = parseQuestions(result.response);
+            const mentioned = detectMentionedAgents(cleanedResponse || result.response);
             setCompletedAgents(['Orchestrator', ...mentioned]);
             setActiveAgent(undefined);
             const agentMessage = {
                 id: (Date.now() + 1).toString(),
                 role: 'agent',
                 agentName: 'Orchestrator',
-                content: result.response,
+                content: cleanedResponse || result.response,
                 tokens: result.tokens,
                 timestamp: new Date(),
             };
@@ -159,11 +302,35 @@ Format your response clearly with headers.`;
             if (result.tokens) {
                 setTotalTokens(prev => prev + result.tokens.input + result.tokens.output);
             }
+            // Stop processing BEFORE showing wizard to prevent overlap
+            setIsProcessing(false);
+            setProcessingStartTime(null);
+            // If questions were found, show the wizard
+            if (questions.length > 0) {
+                setQuestionWizardState({
+                    questions,
+                    originalInput: input,
+                    onComplete: async (answers) => {
+                        setQuestionWizardState(null);
+                        // Format answers as follow-up message
+                        const answerText = answers.map(a => `- ${a.header}: ${a.answer}`).join('\n');
+                        const followUp = `My answers:\n${answerText}\n\nPlease proceed with these choices.`;
+                        // Add user message with answers
+                        const userAnswer = {
+                            id: Date.now().toString(),
+                            role: 'user',
+                            content: followUp,
+                            timestamp: new Date(),
+                        };
+                        setMessages(prev => [...prev, userAnswer]);
+                        // Continue with the task including answers
+                        await executeTask(`${input}\n\n${followUp}`);
+                    },
+                });
+            }
         }
         catch (err) {
             setError(err instanceof Error ? err.message : 'Unknown error');
-        }
-        finally {
             setIsProcessing(false);
             setProcessingStartTime(null);
         }
@@ -188,7 +355,14 @@ Format your response clearly with headers.`;
                 exit();
                 break;
             case 'clear':
-                setMessages([]);
+                // Keep welcome message, clear everything else
+                setMessages([{
+                        id: 'welcome',
+                        role: 'system',
+                        content: '',
+                        timestamp: new Date(),
+                        isWelcome: true,
+                    }]);
                 setActiveAgent(undefined);
                 setCompletedAgents([]);
                 break;
@@ -197,8 +371,27 @@ Format your response clearly with headers.`;
                 addSystemMessage('Plan mode enabled. I will show plans for approval before executing.');
                 break;
             case 'auto':
-                setExecutionMode('auto');
-                addSystemMessage('Auto mode enabled. I will execute tasks directly without approval.');
+                setConfirmationState({
+                    message: '⚠️  Are you sure you want to enable Auto Mode? This will execute actions without further approval.',
+                    options: [
+                        { label: 'Yes, enable auto mode', value: 'yes' },
+                        { label: 'No, stay in plan mode', value: 'no' },
+                    ],
+                    onSelect: (value) => {
+                        setConfirmationState(null);
+                        if (value === 'yes') {
+                            setExecutionMode('auto');
+                            addSystemMessage('Auto mode enabled. I will execute tasks directly without approval.');
+                        }
+                        else {
+                            addSystemMessage('Kept in plan mode.');
+                        }
+                    },
+                    onCancel: () => {
+                        setConfirmationState(null);
+                        addSystemMessage('Kept in plan mode.');
+                    },
+                });
                 break;
             case 'mode':
                 addSystemMessage(`Current execution mode: ${executionMode}\nUse /plan or /auto to switch.`);
@@ -213,6 +406,42 @@ Format your response clearly with headers.`;
                     addSystemMessage(`Agent Status:\n${status}${completed}`);
                 }
                 break;
+            case 'council':
+                if (!councilAvailable) {
+                    addSystemMessage('Council backend not available. Install: pip install -e ./python');
+                }
+                else if (councilMode === 'off') {
+                    // Check available models and recommend mode
+                    const hasMultipleModels = Object.values(availableModels).filter(Boolean).length > 1;
+                    if (hasMultipleModels) {
+                        setCouncilMode('council');
+                        addSystemMessage('Council mode enabled (multi-LLM). Stage 1→2→3 consensus.');
+                    }
+                    else {
+                        setCouncilMode('solo');
+                        addSystemMessage('Council mode enabled (solo). Multi-Claude personas.');
+                    }
+                }
+                else {
+                    setCouncilMode('off');
+                    addSystemMessage('Council mode disabled. Using standard orchestrator.');
+                }
+                break;
+            case 'solo':
+                if (!councilAvailable) {
+                    addSystemMessage('Council backend not available. Install: pip install -e ./python');
+                }
+                else {
+                    setCouncilMode('solo');
+                    addSystemMessage('Solo council mode enabled. Uses Claude CLI with personas.');
+                }
+                break;
+            case 'models':
+                const modelStatus = Object.entries(availableModels)
+                    .map(([k, v]) => `${v ? '✓' : '✗'} ${k}`)
+                    .join('\n');
+                addSystemMessage(`Available Models:\n${modelStatus || 'Checking...'}`);
+                break;
             case 'help':
                 const helpMessage = {
                     id: Date.now().toString(),
@@ -226,12 +455,16 @@ Format your response clearly with headers.`;
 /auto     - Enable auto mode (execute directly)
 /mode     - Show current execution mode
 /agents   - Show active agents
+/council  - Toggle council mode (multi-LLM consensus)
+/solo     - Enable solo council (multi-Claude personas)
+/models   - Show available LLM models
 /exit     - Exit AGENT-K
 
 Keyboard shortcuts:
 ↑/↓       - Browse command history
 Tab       - Autocomplete commands
-Ctrl+C    - Exit
+Shift+Tab - Toggle auto-accept edits
+Esc Esc   - Exit
 Ctrl+U    - Clear input line`,
                     timestamp: new Date(),
                 };
@@ -245,9 +478,11 @@ Ctrl+U    - Clear input line`,
                     content: `Session Status:
 ◇ Mode: ${mode === 'dev' ? 'Development' : 'ML Research'}
 ◇ Execution: ${executionMode === 'plan' ? 'Plan (approval required)' : 'Auto (direct execution)'}
+◇ Council: ${councilMode === 'off' ? 'Off' : councilMode === 'council' ? 'Multi-LLM' : 'Solo (Multi-Claude)'}
 ◇ Messages: ${messages.length}
 ◇ Total Tokens: ${totalTokens}
 ◇ Active Agent: ${activeAgent || 'None'}
+◇ Council Stage: ${councilStage || 'N/A'}
 ◇ Session Time: ${formatElapsed(startTime)}`,
                     timestamp: new Date(),
                 };
@@ -259,8 +494,21 @@ Ctrl+U    - Clear input line`,
     };
     // Handle keyboard shortcuts
     useInput((input, key) => {
-        if (key.ctrl && input === 'c') {
-            exit();
+        // Double-escape to exit (like Claude Code)
+        if (key.escape) {
+            const now = Date.now();
+            if (now - lastEscapeTime < 500) {
+                // Double escape - exit
+                exit();
+            }
+            else {
+                // First escape - show hint and record time
+                setLastEscapeTime(now);
+                if (!questionWizardState && !confirmationState) {
+                    setShowExitHint(true);
+                    setTimeout(() => setShowExitHint(false), 1500);
+                }
+            }
         }
         // Shift+Tab to toggle auto-accept
         if (key.shift && key.tab) {
@@ -270,20 +518,32 @@ Ctrl+U    - Clear input line`,
             }
             else {
                 // Show confirmation prompt
-                setPendingAutoAccept(true);
+                setConfirmationState({
+                    message: 'Enable auto-accept for code edits?',
+                    options: [
+                        { label: 'Yes, enable auto-accept', value: 'yes' },
+                        { label: 'No, keep asking', value: 'no' },
+                    ],
+                    onSelect: (value) => {
+                        setConfirmationState(null);
+                        if (value === 'yes') {
+                            setAutoAccept(true);
+                        }
+                    },
+                    onCancel: () => setConfirmationState(null),
+                });
             }
         }
     });
-    // Prepare items for Static (include welcome box as first item)
-    const staticItems = messages.length === 0
-        ? [{ id: 'welcome', isWelcome: true, role: 'system', content: '', timestamp: new Date() }]
-        : messages;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: staticItems, children: (item) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: messages, children: (item) => {
                     if ('isWelcome' in item && item.isWelcome) {
                         return _jsx(WelcomeBox, { version: version, mode: mode }, "welcome");
                     }
                     return (_jsx(ChatMessage, { role: item.role, agentName: item.agentName, content: item.content, tokens: item.tokens }, item.id));
-                } }), isProcessing && processingStartTime && (_jsx(ThinkingIndicator, { startTime: processingStartTime })), error && (_jsx(Box, { marginY: 1, marginLeft: 1, children: _jsxs(Text, { color: "#e53e3e", children: ["\u2717 Error: ", error] }) })), _jsx(Input, { onSubmit: handleSubmit, disabled: isProcessing, placeholder: pendingAutoAccept ? "Auto-accept: edits applied without asking. Enter to confirm" : awaitingApproval ? "Press Enter to execute, n to cancel" : 'Try "build a password validator"' }), _jsx(StatusBar, { mode: mode, tokens: totalTokens, startTime: startTime, isProcessing: isProcessing, activeAgent: activeAgent, completedAgents: completedAgents, autoAccept: autoAccept })] }));
+                } }), isProcessing && processingStartTime && (_jsx(ThinkingIndicator, { startTime: processingStartTime })), error && (_jsx(Box, { marginY: 1, marginLeft: 1, children: _jsxs(Text, { color: "#e53e3e", children: ["\u2717 Error: ", error] }) })), questionWizardState ? (_jsx(QuestionWizard, { questions: questionWizardState.questions, onComplete: questionWizardState.onComplete, onCancel: () => {
+                    setQuestionWizardState(null);
+                    addSystemMessage('Questions cancelled.');
+                } }, `wizard-${questionWizardState.questions.map(q => q.header).join('-')}`)) : confirmationState ? (_jsx(Confirmation, { message: confirmationState.message, options: confirmationState.options, onSelect: confirmationState.onSelect, onCancel: confirmationState.onCancel })) : (_jsx(Input, { onSubmit: handleSubmit, disabled: isProcessing, placeholder: 'Try "build a password validator"' })), _jsx(StatusBar, { mode: mode, executionMode: executionMode, tokens: totalTokens, startTime: startTime, isProcessing: isProcessing, activeAgent: activeAgent, completedAgents: completedAgents, autoAccept: autoAccept, councilMode: councilMode, councilStage: councilStage, availableModels: availableModels, showExitHint: showExitHint })] }));
 };
 function formatElapsed(start) {
     const secs = Math.floor((Date.now() - start.getTime()) / 1000);

package/dist/components/ChatMessage.js

@@ -10,21 +10,113 @@ const theme = {
     user: '#9f7aea', // Purple for user
     agent: '#4fd1c5', // Teal for agent
     system: '#f6e05e', // Yellow for system
+    code: '#f6ad55', // Orange for inline code
+    header: '#63b3ed', // Blue for headers
 };
+// Parse inline markdown and return React elements
+function parseInlineMarkdown(text, defaultColor) {
+    const elements = [];
+    let remaining = text;
+    let key = 0;
+    while (remaining.length > 0) {
+        // Check for bold **text**
+        const boldMatch = remaining.match(/^\*\*(.+?)\*\*/);
+        if (boldMatch) {
+            elements.push(_jsx(Text, { color: defaultColor, bold: true, children: boldMatch[1] }, key++));
+            remaining = remaining.slice(boldMatch[0].length);
+            continue;
+        }
+        // Check for inline code `code`
+        const codeMatch = remaining.match(/^`([^`]+)`/);
+        if (codeMatch) {
+            elements.push(_jsx(Text, { color: theme.code, children: codeMatch[1] }, key++));
+            remaining = remaining.slice(codeMatch[0].length);
+            continue;
+        }
+        // Check for italic *text* or _text_
+        const italicMatch = remaining.match(/^(\*|_)([^*_]+)\1/);
+        if (italicMatch) {
+            elements.push(_jsx(Text, { color: defaultColor, italic: true, children: italicMatch[2] }, key++));
+            remaining = remaining.slice(italicMatch[0].length);
+            continue;
+        }
+        // Find next special character
+        const nextSpecial = remaining.search(/[\*`_]/);
+        if (nextSpecial === -1) {
+            // No more special chars, add rest as plain text
+            elements.push(_jsx(Text, { color: defaultColor, children: remaining }, key++));
+            break;
+        }
+        else if (nextSpecial === 0) {
+            // Special char at start but didn't match pattern - treat as literal
+            elements.push(_jsx(Text, { color: defaultColor, children: remaining[0] }, key++));
+            remaining = remaining.slice(1);
+        }
+        else {
+            // Add text before special char
+            elements.push(_jsx(Text, { color: defaultColor, children: remaining.slice(0, nextSpecial) }, key++));
+            remaining = remaining.slice(nextSpecial);
+        }
+    }
+    return elements;
+}
+// Render a single line with markdown formatting
+function renderLine(line, index, defaultColor) {
+    // Header detection (## Header)
+    const headerMatch = line.match(/^(#{1,3})\s+(.+)$/);
+    if (headerMatch) {
+        const level = headerMatch[1].length;
+        const content = headerMatch[2];
+        return (_jsx(Box, { children: _jsx(Text, { color: theme.header, bold: true, children: content }) }, index));
+    }
+    // List item detection (- item or * item)
+    const listMatch = line.match(/^(\s*)([-*])\s+(.+)$/);
+    if (listMatch) {
+        const indent = listMatch[1];
+        const content = listMatch[3];
+        return (_jsxs(Box, { children: [_jsxs(Text, { color: defaultColor, children: [indent, "\u2022 "] }), parseInlineMarkdown(content, defaultColor)] }, index));
+    }
+    // Numbered list detection (1. item)
+    const numberedMatch = line.match(/^(\s*)(\d+)\.\s+(.+)$/);
+    if (numberedMatch) {
+        const indent = numberedMatch[1];
+        const num = numberedMatch[2];
+        const content = numberedMatch[3];
+        return (_jsxs(Box, { children: [_jsxs(Text, { color: defaultColor, children: [indent, num, ". "] }), parseInlineMarkdown(content, defaultColor)] }, index));
+    }
+    // Table row detection (| col | col |)
+    if (line.includes('|') && (line.trim().startsWith('|') || line.includes(' | '))) {
+        // Keep table formatting as-is but with subtle styling
+        const isSeparator = line.match(/^[\s|:-]+$/);
+        if (isSeparator) {
+            return (_jsx(Box, { children: _jsx(Text, { color: theme.dim, children: line }) }, index));
+        }
+        return (_jsx(Box, { children: _jsx(Text, { color: defaultColor, children: line }) }, index));
+    }
+    // Regular line with inline markdown
+    return (_jsx(Box, { children: parseInlineMarkdown(line, defaultColor) }, index));
+}
 export const ChatMessage = ({ role, agentName = 'Agent', content, tokens, }) => {
     const isUser = role === 'user';
     const isSystem = role === 'system';
     const symbolColor = isUser ? theme.user : isSystem ? theme.system : theme.agent;
     const title = isUser ? 'You' : agentName;
+    const textColor = theme.text;
     const termWidth = process.stdout.columns || 80;
     const contentWidth = termWidth - 6;
+    // Split content into lines and wrap long lines
     const lines = wrapText(content, contentWidth);
-    return (_jsxs(Box, { flexDirection: "column", marginY: 1, marginLeft: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: symbolColor, children: '◆ ' }), _jsx(Text, { color: symbolColor, bold: true, children: title })] }), _jsx(Box, { flexDirection: "column", marginLeft: 2, children: lines.map((line, i) => (_jsx(Text, { color: theme.text, children: line }, i))) }), tokens && tokens.input + tokens.output > 0 && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.dim, children: ["\u2192 ", tokens.input + tokens.output, " tokens"] }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, marginLeft: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: symbolColor, children: '◆ ' }), _jsx(Text, { color: symbolColor, bold: true, children: title })] }), _jsx(Box, { flexDirection: "column", marginLeft: 2, children: lines.map((line, i) => renderLine(line, i, textColor)) }), tokens && tokens.input + tokens.output > 0 && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: theme.dim, children: ["\u2192 ", tokens.input + tokens.output, " tokens"] }) }))] }));
 };
 function wrapText(text, width) {
     const lines = [];
     const paragraphs = text.split('\n');
     for (const para of paragraphs) {
+        // Don't wrap table lines or lines with special formatting
+        if (para.includes('|') || para.match(/^#{1,3}\s/) || para.match(/^[\s]*[-*]\s/) || para.match(/^[\s]*\d+\.\s/)) {
+            lines.push(para);
+            continue;
+        }
         if (para.length <= width) {
             lines.push(para);
         }