profclaw 0.0.1-beta.3 → 2.3.0

package/dist/cli/commands/tools.js

@@ -11,9 +11,9 @@ import { registerBuiltinTools } from '../../chat/execution/tools/index.js';
 import { getToolRegistry } from '../../chat/execution/registry.js';
 // Lazy initialization - only register tools when a tools command actually runs
 let toolsInitialized = false;
-function getRegistry() {
+async function getRegistry() {
     if (!toolsInitialized) {
-        registerBuiltinTools();
+        await registerBuiltinTools();
         toolsInitialized = true;
     }
     return getToolRegistry();
@@ -93,7 +93,7 @@ export function toolsCommands() {
         .option('--json', 'Output as JSON')
         .option('-c, --category <cat>', 'Filter by category')
         .action(async (options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         let toolList = registry.list();
         if (options.category) {
             toolList = toolList.filter((t) => t.category === options.category);
@@ -145,7 +145,7 @@ export function toolsCommands() {
         .description('Show detailed information about a tool')
         .option('--json', 'Output as JSON')
         .action(async (name, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get(name);
         if (!tool) {
             error(`Tool '${name}' not found`);
@@ -192,7 +192,7 @@ export function toolsCommands() {
         .option('--json', 'Output result as JSON')
         .option('-y, --yes', 'Skip approval for moderate tools')
         .action(async (name, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get(name);
         if (!tool) {
             error(`Tool '${name}' not found`);
@@ -270,7 +270,7 @@ export function toolsCommands() {
         .option('--json', 'Output as JSON')
         .action(async (commandParts, options) => {
         const command = commandParts.join(' ');
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('exec');
         if (!tool) {
             error('exec tool not found');
@@ -308,7 +308,7 @@ export function toolsCommands() {
         .option('-s, --short', 'Short format')
         .option('-w, --workdir <path>', 'Repository path')
         .action(async (options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('git_status');
         if (!tool) {
             error('git_status tool not found');
@@ -332,7 +332,7 @@ export function toolsCommands() {
         .option('-t, --type <type>', 'Info type: all, cpu, memory, os, network', 'all')
         .option('--json', 'Output as JSON')
         .action(async (options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('system_info');
         if (!tool) {
             error('system_info tool not found');
@@ -359,7 +359,7 @@ export function toolsCommands() {
         .description('Shortcut: Show environment variables')
         .option('-f, --filter <pattern>', 'Filter by pattern')
         .action(async (name, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('env');
         if (!tool) {
             error('env tool not found');
@@ -381,7 +381,7 @@ export function toolsCommands() {
         .command('which <command>')
         .description('Shortcut: Find command location')
         .action(async (command) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('which');
         if (!tool) {
             error('which tool not found');
@@ -403,7 +403,7 @@ export function toolsCommands() {
         .description('Shortcut: Read a file')
         .option('-l, --lines <n>', 'Max lines to read', '100')
         .action(async (filePath, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('read_file');
         if (!tool) {
             error('read_file tool not found');
@@ -431,7 +431,7 @@ export function toolsCommands() {
         .option('-p, --path <dir>', 'Search directory', '.')
         .option('-t, --type <type>', 'File type: file, directory, both', 'file')
         .action(async (pattern, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('search_files');
         if (!tool) {
             error('search_files tool not found');
@@ -469,7 +469,7 @@ export function toolsCommands() {
         .option('-i, --ignore-case', 'Case insensitive')
         .option('-c, --context <n>', 'Context lines', '0')
         .action(async (pattern, searchPath, options) => {
-        const registry = getRegistry();
+        const registry = await getRegistry();
         const tool = registry.get('grep');
         if (!tool) {
             error('grep tool not found');

package/dist/cli/commands/tui.js

@@ -2,6 +2,20 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { api } from '../utils/api.js';
 import { spinner, error, createTable, formatRelativeTime, truncate } from '../utils/output.js';
+async function launchInkDashboard() {
+    // Check if we have a real TTY (Ink needs raw mode)
+    if (!process.stdin.isTTY) {
+        console.error(chalk.red('Error: Ink TUI requires an interactive terminal (TTY).'));
+        console.error(chalk.dim('Run this command directly in your terminal, not piped.'));
+        process.exit(1);
+    }
+    // Dynamic import so ink is only loaded when --ink flag is used
+    const { render } = await import('ink');
+    const React = await import('react');
+    const { DashboardApp } = await import('../ink/DashboardApp.js');
+    const { waitUntilExit } = render(React.createElement(DashboardApp));
+    await waitUntilExit();
+}
 function formatUptime(seconds) {
     const d = Math.floor(seconds / 86400);
     const h = Math.floor((seconds % 86400) / 3600);
@@ -130,8 +144,19 @@ export function tuiCommand() {
     const cmd = new Command('tui')
         .description('Show terminal dashboard')
         .option('--watch', 'Refresh dashboard every 5 seconds')
-        .option('--interval <seconds>', 'Refresh interval in seconds', '5');
+        .option('--interval <seconds>', 'Refresh interval in seconds', '5')
+        .option('--ink', 'Launch rich interactive Ink dashboard (tabs, auto-refresh, keyboard nav)');
     cmd.action(async (options) => {
+        if (options.ink) {
+            try {
+                await launchInkDashboard();
+            }
+            catch (err) {
+                error(err instanceof Error ? err.message : 'Failed to launch Ink dashboard');
+                process.exit(1);
+            }
+            return;
+        }
         try {
             await renderDashboard();
             if (options.watch) {

package/dist/cli/index.js

@@ -2,6 +2,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import figlet from 'figlet';
+import { checkForUpdate, formatUpdateMessage } from '../utils/auto-update.js';
 import { taskCommands } from './commands/task.js';
 import { ticketCommands } from './commands/ticket.js';
 import { summaryCommands } from './commands/summary.js';
@@ -23,18 +24,19 @@ import { sessionCommands } from './commands/session.js';
 import { doctorCommand } from './commands/doctor.js';
 import { providerCommands } from './commands/provider.js';
 import { mcpCommands } from './commands/mcp.js';
-import { browserCommands } from './commands/browser.js';
 import { devicesCommands } from './commands/devices.js';
 import { daemonCommand } from './commands/daemon.js';
 import { completionCommands } from './commands/completion.js';
-import { canvasCommands } from './commands/canvas.js';
 import { webhooksCommands } from './commands/webhooks.js';
 import { channelsCommands } from './commands/channels.js';
 import { securityCommands } from './commands/security.js';
 import { logsCommand } from './commands/logs.js';
 import { modelsCommands } from './commands/models.js';
-import { nodesCommands } from './commands/nodes.js';
 import { tuiCommand } from './commands/tui.js';
+import { importCommands } from './commands/import.js';
+import { historyCommands } from './commands/history.js';
+import { planCommands } from './commands/plan.js';
+import { initCommand } from './commands/init.js';
 const VERSION = '2.0.0';
 // ASCII Banner
 function showBanner() {
@@ -77,18 +79,19 @@ program.addCommand(doctorCommand());
 program.addCommand(providerCommands());
 program.addCommand(mcpCommands());
 // Phase 9 - OpenClaw parity commands
-program.addCommand(browserCommands());
 program.addCommand(devicesCommands());
 program.addCommand(daemonCommand());
 program.addCommand(completionCommands());
-program.addCommand(canvasCommands());
 program.addCommand(webhooksCommands());
 program.addCommand(channelsCommands());
 program.addCommand(securityCommands());
 program.addCommand(logsCommand());
 program.addCommand(modelsCommands());
-program.addCommand(nodesCommands());
 program.addCommand(tuiCommand());
+program.addCommand(importCommands());
+program.addCommand(historyCommands());
+program.addCommand(planCommands());
+program.addCommand(initCommand());
 // Default action (no command) - show banner and help
 program.action(() => {
     showBanner();
@@ -124,4 +127,14 @@ program.action(() => {
 });
 // Parse and execute (parseAsync required for async command actions)
 await program.parseAsync();
+// Non-blocking update check — runs after the main command completes.
+// Only checks if 24h have elapsed (enforced inside checkForUpdate via cache).
+checkForUpdate().then((info) => {
+    const msg = formatUpdateMessage(info);
+    if (msg) {
+        console.log('\n' + chalk.yellow('  ' + msg));
+    }
+}).catch(() => {
+    // Update check is best-effort; never surface errors to the user
+});
 //# sourceMappingURL=index.js.map

package/dist/cli/ink/App.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Ink App Wrapper
+ *
+ * Root container for all Ink-based TUI screens. Provides consistent
+ * padding and flex column layout.
+ */
+import React from 'react';
+interface AppProps {
+    children: React.ReactNode;
+}
+export declare const App: React.FC<AppProps>;
+export {};
+//# sourceMappingURL=App.d.ts.map

package/dist/cli/ink/App.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+export const App = ({ children }) => {
+    return (_jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 0, children: children }));
+};
+//# sourceMappingURL=App.js.map

package/dist/cli/ink/ChatApp.d.ts

@@ -0,0 +1,60 @@
+/**
+ * ChatApp — Full Interactive Chat TUI
+ *
+ * Layout:
+ *   ┌ SessionHeader ──────────────────────────────────┐
+ *   │  message history (StreamingMessage list)        │
+ *   │  AgentStatus (while streaming)                  │
+ *   │  PermissionPrompt (overlay when needed)         │
+ *   ├─────────────────────────────────────────────────┤
+ *   │  CostBar                                        │
+ *   │  > TextInput                                    │
+ *   └─────────────────────────────────────────────────┘
+ */
+import React from 'react';
+import { type SessionHeaderProps } from './components/SessionHeader.js';
+import { type AgentStatusState } from './components/AgentStatus.js';
+import { type PermissionDecision, type PermissionLevel } from './components/PermissionPrompt.js';
+import type { ChatMessage } from '../interactive/types.js';
+import type { Suggestion } from '../../agents/prompt-suggestions.js';
+export interface PendingPermission {
+    toolName: string;
+    args: Record<string, unknown>;
+    permissionLevel: PermissionLevel;
+    reason?: string;
+    resolve: (decision: PermissionDecision) => void;
+}
+export interface PickerOption {
+    label: string;
+    value: string;
+    description?: string;
+    active?: boolean;
+    disabled?: boolean;
+}
+export interface ChatAppProps {
+    sessionInfo: Omit<SessionHeaderProps, 'sessionId'> & {
+        sessionId: string;
+    };
+    tokensUsed: number;
+    tokensMax: number;
+    estimatedCost?: number;
+    agentStatus: AgentStatusState;
+    agentAction?: string;
+    stepCount: number;
+    elapsedMs: number;
+    messages: ChatMessage[];
+    streamingContent?: string;
+    pendingPermission?: PendingPermission;
+    availableModels?: PickerOption[];
+    availableProviders?: PickerOption[];
+    suggestions?: Suggestion[];
+    /** Connection status forwarded from the stream client / offline detector */
+    connectionStatus?: 'connected' | 'reconnecting' | 'disconnected';
+    /** Measured round-trip latency in ms (updated after each successful ping) */
+    connectionLatencyMs?: number;
+    onSubmit: (message: string) => void;
+    onPermissionDecision?: (decision: PermissionDecision) => void;
+    onCancel?: () => void;
+}
+export declare const ChatApp: React.FC<ChatAppProps>;
+//# sourceMappingURL=ChatApp.d.ts.map

package/dist/cli/ink/ChatApp.js

@@ -0,0 +1,325 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * ChatApp — Full Interactive Chat TUI
+ *
+ * Layout:
+ *   ┌ SessionHeader ──────────────────────────────────┐
+ *   │  message history (StreamingMessage list)        │
+ *   │  AgentStatus (while streaming)                  │
+ *   │  PermissionPrompt (overlay when needed)         │
+ *   ├─────────────────────────────────────────────────┤
+ *   │  CostBar                                        │
+ *   │  > TextInput                                    │
+ *   └─────────────────────────────────────────────────┘
+ */
+import { useState, useCallback, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import { App } from './App.js';
+import { SessionHeader } from './components/SessionHeader.js';
+import { StreamingMessage } from './components/StreamingMessage.js';
+import { AgentStatus } from './components/AgentStatus.js';
+import { CostBar } from './components/CostBar.js';
+import { PermissionPrompt, } from './components/PermissionPrompt.js';
+import { SuggestionBar } from './components/SuggestionBar.js';
+import { ConnectionStatus } from './components/ConnectionStatus.js';
+const SLASH_COMMANDS = [
+    { name: '/model', description: 'Switch AI model', hasSubPicker: true, immediate: false },
+    { name: '/provider', description: 'Switch provider', hasSubPicker: true, immediate: false },
+    { name: '/agentic', description: 'Toggle agentic mode (tools + multi-step)', hasSubPicker: false, immediate: true },
+    { name: '/effort', description: 'Set effort: low | medium | high', hasSubPicker: false, immediate: false },
+    { name: '/thinking', description: 'Toggle thinking display', hasSubPicker: false, immediate: true },
+    { name: '/tools', description: 'Toggle tool call verbosity', hasSubPicker: false, immediate: true },
+    { name: '/new', description: 'Start a fresh conversation', hasSubPicker: false, immediate: true },
+    { name: '/sessions', description: 'List recent conversations', hasSubPicker: false, immediate: true },
+    { name: '/resume', description: 'Resume a session by id prefix', hasSubPicker: false, immediate: false },
+    { name: '/status', description: 'Server and provider health', hasSubPicker: false, immediate: true },
+    { name: '/insights', description: 'Session and server usage analytics', hasSubPicker: false, immediate: true },
+    { name: '/run', description: 'Execute a shell command', hasSubPicker: false, immediate: false },
+    { name: '/retry', description: 'Retry last message', hasSubPicker: false, immediate: true },
+    { name: '/diff', description: 'Show unified diff of all file changes this session', hasSubPicker: false, immediate: true },
+    { name: '/rewind', description: 'List or restore file snapshots (optional: <path> or --turn <n>)', hasSubPicker: false, immediate: false },
+    { name: '/compact', description: 'Compact context — summarize old turns (--llm for LLM summary)', hasSubPicker: false, immediate: true },
+    { name: '/branch', description: 'Fork conversation at current turn (or /branch <n> for turn N)', hasSubPicker: false, immediate: false },
+    { name: '/branches', description: 'List all branches for this conversation', hasSubPicker: false, immediate: true },
+    { name: '/clear', description: 'Clear display', hasSubPicker: false, immediate: true },
+    { name: '/help', description: 'Show all commands', hasSubPicker: false, immediate: true },
+    { name: '/exit', description: 'Quit', hasSubPicker: false, immediate: true },
+];
+// Max number of history entries to retain
+const MAX_HISTORY = 50;
+export const ChatApp = ({ sessionInfo, tokensUsed, tokensMax, estimatedCost, agentStatus, agentAction, stepCount, elapsedMs, messages, streamingContent, pendingPermission, availableModels = [], availableProviders = [], suggestions = [], connectionStatus = 'connected', connectionLatencyMs, onSubmit, onPermissionDecision, onCancel, }) => {
+    const { exit } = useApp();
+    const [inputValue, setInputValue] = useState('');
+    const [pickerMode, setPickerMode] = useState('none');
+    const [selectedIdx, setSelectedIdx] = useState(0);
+    const [subPickerTitle, setSubPickerTitle] = useState('');
+    const [subPickerItems, setSubPickerItems] = useState([]);
+    const [subPickerCommand, setSubPickerCommand] = useState('');
+    // ── Multiline state ──────────────────────────────────────────────────────────
+    const [isMultiline, setIsMultiline] = useState(false);
+    const [multilineLines, setMultilineLines] = useState([]);
+    // ── Input history state ──────────────────────────────────────────────────────
+    const [inputHistory, setInputHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    // Saved draft before navigating history (so Down arrow restores it)
+    const [historyDraft, setHistoryDraft] = useState('');
+    const isStreaming = agentStatus === 'thinking' || agentStatus === 'executing';
+    // Compute matching commands when in command picker mode
+    const inCommandPicker = inputValue.startsWith('/') && inputValue.indexOf(' ') === -1 && !isStreaming && !isMultiline;
+    const matchingCmds = inCommandPicker
+        ? SLASH_COMMANDS.filter(c => c.name.startsWith(inputValue.toLowerCase()))
+        : [];
+    // Auto-show/hide command picker
+    useEffect(() => {
+        if (inCommandPicker && matchingCmds.length > 0 && pickerMode === 'none') {
+            setPickerMode('commands');
+            setSelectedIdx(0);
+        }
+        else if (!inCommandPicker && pickerMode === 'commands') {
+            setPickerMode('none');
+        }
+    }, [inCommandPicker, matchingCmds.length, pickerMode]);
+    // Current picker items
+    const pickerItems = pickerMode === 'commands'
+        ? matchingCmds.map(c => ({ label: c.name, value: c.name, description: c.description }))
+        : pickerMode === 'sub'
+            ? subPickerItems
+            : [];
+    // Keep index in bounds
+    const maxIdx = Math.max(0, pickerItems.length - 1);
+    const safeIdx = Math.min(selectedIdx, maxIdx);
+    // Ghost text
+    const ghostText = pickerMode === 'commands' && matchingCmds.length > 0
+        ? (matchingCmds[safeIdx]?.name ?? '').slice(inputValue.length)
+        : '';
+    // Open sub-picker for a command
+    const openSubPicker = useCallback((cmd) => {
+        if (cmd.name === '/model') {
+            setSubPickerTitle(`Select Model (${availableModels.length} available)`);
+            setSubPickerItems(availableModels);
+            setSubPickerCommand('/model');
+        }
+        else if (cmd.name === '/provider') {
+            setSubPickerTitle(`Select Provider (${availableProviders.length} available)`);
+            setSubPickerItems(availableProviders);
+            setSubPickerCommand('/provider');
+        }
+        setPickerMode('sub');
+        setSelectedIdx(0);
+        setInputValue('');
+    }, [availableModels, availableProviders]);
+    // ── Ctrl+C handler — always active to intercept before Ink's default exit ────
+    useInput((input, key) => {
+        if (!key.ctrl || input !== 'c')
+            return;
+        if (isStreaming) {
+            // Cancel the in-flight stream; do not exit
+            onCancel?.();
+            return;
+        }
+        if (inputValue.length > 0 || isMultiline) {
+            // Clear pending input
+            setInputValue('');
+            setIsMultiline(false);
+            setMultilineLines([]);
+            setHistoryIndex(-1);
+            return;
+        }
+        // Nothing to cancel — exit normally
+        exit();
+    });
+    // ── Alt+Enter / history navigation ──────────────────────────────────────────
+    useInput((input, key) => {
+        // Alt+Enter: toggle multiline mode
+        if (key.meta && key.return) {
+            if (!isMultiline) {
+                setIsMultiline(true);
+            }
+            else {
+                // Cancel multiline; discard accumulated lines
+                setIsMultiline(false);
+                setMultilineLines([]);
+            }
+            return;
+        }
+        // Up arrow: navigate backward through history (picker closed, not in multiline)
+        if (key.upArrow && pickerMode === 'none' && !isMultiline) {
+            if (inputHistory.length === 0)
+                return;
+            if (historyIndex === -1) {
+                setHistoryDraft(inputValue);
+            }
+            const newIdx = historyIndex === -1
+                ? inputHistory.length - 1
+                : Math.max(0, historyIndex - 1);
+            setHistoryIndex(newIdx);
+            setInputValue(inputHistory[newIdx] ?? '');
+            return;
+        }
+        // Down arrow: navigate forward through history (picker closed, not in multiline)
+        if (key.downArrow && pickerMode === 'none' && !isMultiline) {
+            if (historyIndex === -1)
+                return;
+            const newIdx = historyIndex + 1;
+            if (newIdx >= inputHistory.length) {
+                setHistoryIndex(-1);
+                setInputValue(historyDraft);
+            }
+            else {
+                setHistoryIndex(newIdx);
+                setInputValue(inputHistory[newIdx] ?? '');
+            }
+            return;
+        }
+        // Ctrl+Enter in multiline mode: submit all accumulated lines + current line
+        if (isMultiline && key.ctrl && key.return) {
+            const allLines = [...multilineLines, inputValue].filter(l => l.length > 0);
+            if (allLines.length === 0)
+                return;
+            const combined = allLines.join('\n');
+            setIsMultiline(false);
+            setMultilineLines([]);
+            setInputValue('');
+            setHistoryIndex(-1);
+            setHistoryDraft('');
+            setInputHistory(prev => {
+                const next = [...prev, combined];
+                return next.length > MAX_HISTORY ? next.slice(next.length - MAX_HISTORY) : next;
+            });
+            onSubmit(combined);
+            return;
+        }
+        void input;
+    }, { isActive: !isStreaming && pendingPermission === undefined });
+    // ── Picker keyboard navigation ───────────────────────────────────────────────
+    useInput((_input, key) => {
+        if (pickerMode === 'none' || pickerItems.length === 0)
+            return;
+        if (key.upArrow) {
+            setSelectedIdx(prev => {
+                let next = prev <= 0 ? pickerItems.length - 1 : prev - 1;
+                // Skip disabled items
+                let attempts = 0;
+                while (pickerItems[next] && pickerItems[next]?.disabled && attempts < pickerItems.length) {
+                    next = next <= 0 ? pickerItems.length - 1 : next - 1;
+                    attempts++;
+                }
+                return next;
+            });
+        }
+        else if (key.downArrow) {
+            setSelectedIdx(prev => {
+                let next = prev >= pickerItems.length - 1 ? 0 : prev + 1;
+                let attempts = 0;
+                while (pickerItems[next] && pickerItems[next]?.disabled && attempts < pickerItems.length) {
+                    next = next >= pickerItems.length - 1 ? 0 : next + 1;
+                    attempts++;
+                }
+                return next;
+            });
+        }
+        else if (key.escape) {
+            setPickerMode('none');
+            setInputValue('');
+            setSelectedIdx(0);
+        }
+    }, { isActive: pickerMode !== 'none' && !isStreaming });
+    const handleSubmit = useCallback((value) => {
+        // In multiline mode, Enter appends the current line and moves to the next
+        if (isMultiline) {
+            setMultilineLines(prev => [...prev, value]);
+            setInputValue('');
+            return;
+        }
+        const trimmed = value.trim();
+        // Sub-picker: Enter selects the highlighted option (skip disabled)
+        if (pickerMode === 'sub' && subPickerItems.length > 0) {
+            const item = subPickerItems[safeIdx];
+            if (item && !(item.disabled)) {
+                setPickerMode('none');
+                setInputValue('');
+                setSelectedIdx(0);
+                onSubmit(`${subPickerCommand} ${item.value}`);
+            }
+            return;
+        }
+        // Command picker: Enter selects highlighted command
+        if (pickerMode === 'commands' && matchingCmds.length > 0) {
+            const cmd = matchingCmds[safeIdx];
+            if (cmd) {
+                if (cmd.hasSubPicker) {
+                    openSubPicker(cmd);
+                }
+                else if (cmd.immediate) {
+                    setPickerMode('none');
+                    setInputValue('');
+                    setSelectedIdx(0);
+                    if (cmd.name === '/exit') {
+                        exit();
+                        return;
+                    }
+                    onSubmit(cmd.name);
+                }
+            }
+            return;
+        }
+        if (trimmed.length === 0)
+            return;
+        if (trimmed === '/exit' || trimmed === '/quit') {
+            exit();
+            return;
+        }
+        setInputValue('');
+        setSelectedIdx(0);
+        setPickerMode('none');
+        setHistoryIndex(-1);
+        setHistoryDraft('');
+        setInputHistory(prev => {
+            const next = [...prev, trimmed];
+            return next.length > MAX_HISTORY ? next.slice(next.length - MAX_HISTORY) : next;
+        });
+        onSubmit(trimmed);
+    }, [
+        onSubmit,
+        exit,
+        pickerMode,
+        safeIdx,
+        matchingCmds,
+        subPickerItems,
+        subPickerCommand,
+        openSubPicker,
+        isMultiline,
+    ]);
+    const handlePermission = useCallback((decision) => {
+        if (pendingPermission) {
+            pendingPermission.resolve(decision);
+        }
+        onPermissionDecision?.(decision);
+    }, [pendingPermission, onPermissionDecision]);
+    // ── Prompt prefix ────────────────────────────────────────────────────────────
+    const promptPrefix = isMultiline ? '... ' : '> ';
+    return (_jsxs(App, { children: [_jsxs(Box, { flexDirection: "row", justifyContent: "space-between", alignItems: "center", children: [_jsx(SessionHeader, { model: sessionInfo.model, provider: sessionInfo.provider, sessionId: sessionInfo.sessionId, mode: sessionInfo.mode }), connectionStatus !== 'connected' && (_jsx(Box, { paddingX: 1, children: _jsx(ConnectionStatus, { status: connectionStatus, latencyMs: connectionLatencyMs, provider: sessionInfo.provider }) }))] }), connectionStatus === 'disconnected' && (_jsxs(Box, { borderStyle: "round", borderColor: "red", paddingX: 2, paddingY: 0, marginX: 1, children: [_jsx(Text, { color: "red", bold: true, children: "Server unreachable \u2014 waiting for connection..." }), _jsx(Text, { dimColor: true, children: "  Messages will be sent once the server is back online." })] })), connectionStatus === 'reconnecting' && (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "yellow", children: "Reconnecting to server..." }) })), _jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingY: 1, children: [messages.map((msg, idx) => (_jsx(StreamingMessage, { role: msg.role === 'system' ? 'assistant' : msg.role, content: msg.content, model: msg.model }, `msg-${msg.timestamp?.getTime?.() ?? idx}-${idx}`))), streamingContent !== undefined && streamingContent.length > 0 && (_jsx(StreamingMessage, { role: "assistant", content: streamingContent, isStreaming: true, model: sessionInfo.model }))] }), (isStreaming || agentStatus === 'complete') && (_jsx(AgentStatus, { status: agentStatus, currentAction: agentAction, stepCount: stepCount, tokensUsed: tokensUsed, elapsedMs: elapsedMs })), pendingPermission !== undefined && (_jsx(PermissionPrompt, { toolName: pendingPermission.toolName, args: pendingPermission.args, permissionLevel: pendingPermission.permissionLevel, reason: pendingPermission.reason, onDecision: handlePermission })), pickerMode !== 'none' && pickerItems.length > 0 && (() => {
+                const MAX_VISIBLE = 6;
+                const total = pickerItems.length;
+                const start = Math.max(0, Math.min(safeIdx - Math.floor(MAX_VISIBLE / 2), total - MAX_VISIBLE));
+                const visible = pickerItems.slice(start, start + MAX_VISIBLE);
+                const showScrollUp = start > 0;
+                const showScrollDown = start + MAX_VISIBLE < total;
+                const title = pickerMode === 'sub' ? subPickerTitle : 'Commands';
+                return (_jsx(Box, { flexDirection: "column", paddingX: 2, children: _jsxs(Box, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "cyan", children: [' ', title] }), _jsx(Text, { dimColor: true, children: ' ─'.repeat(20) }), showScrollUp && _jsxs(Text, { dimColor: true, children: ["  \u2191 more (", start, " above)"] }), visible.map((item) => {
+                                const realIdx = pickerItems.indexOf(item);
+                                const isSelected = realIdx === safeIdx;
+                                const isDisabled = item.disabled;
+                                return (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: isDisabled ? 'gray' : isSelected ? 'cyan' : undefined, bold: isSelected && !isDisabled, inverse: isSelected && !isDisabled, dimColor: isDisabled, strikethrough: isDisabled, children: [' ', item.label.padEnd(20)] }), item.description && _jsx(Text, { dimColor: true, children: item.description }), item.active && !isDisabled && _jsx(Text, { color: "green", children: " \u25CF" }), isDisabled && _jsx(Text, { color: "gray", children: " \u2298" })] }, item.value + (isDisabled ? '-disabled' : '')));
+                            }), showScrollDown && _jsxs(Text, { dimColor: true, children: ["  \u2193 more (", total - start - MAX_VISIBLE, " below)"] }), _jsx(Text, { dimColor: true, children: "  \u2191\u2193 navigate \u00B7 Enter select \u00B7 Esc back" })] }) }));
+            })(), suggestions.length > 0 && !isStreaming && pickerMode === 'none' && (_jsx(SuggestionBar, { suggestions: suggestions, isActive: pendingPermission === undefined && !isStreaming && pickerMode === 'none', onSelect: (text) => {
+                    onSubmit(text);
+                } })), isMultiline && multilineLines.length > 0 && (_jsx(Box, { flexDirection: "column", paddingX: 1, children: multilineLines.map((line, idx) => (_jsxs(Box, { flexDirection: "row", gap: 0, children: [_jsx(Text, { color: "yellow", bold: true, children: '... ' }), _jsx(Text, { children: line })] }, idx))) })), _jsxs(Box, { flexDirection: "row", gap: 0, paddingX: 1, children: [_jsx(Text, { color: isMultiline ? 'yellow' : 'cyan', bold: true, children: promptPrefix }), connectionStatus === 'disconnected' ? (_jsx(Text, { dimColor: true, color: "red", children: "Offline \u2014 waiting for server..." })) : pendingPermission === undefined && !isStreaming ? (_jsxs(Box, { flexDirection: "row", children: [_jsx(TextInput, { value: inputValue, onChange: (val) => { setInputValue(val); if (!isMultiline)
+                                    setSelectedIdx(0); }, onSubmit: handleSubmit, placeholder: isMultiline
+                                    ? 'Add line... (Ctrl+Enter to send · Alt+Enter to cancel)'
+                                    : 'Message profClaw... (/ for commands)' }), ghostText.length > 0 && _jsx(Text, { dimColor: true, children: ghostText })] })) : (_jsx(Text, { dimColor: true, children: pendingPermission !== undefined
+                            ? 'Waiting for permission...'
+                            : 'Agent is working... (Ctrl+C to cancel)' }))] }), isMultiline && (_jsx(Box, { paddingX: 1, children: _jsx(Text, { dimColor: true, children: "  multiline \u2014 Enter adds line \u00B7 Ctrl+Enter sends \u00B7 Alt+Enter cancels" }) })), _jsx(CostBar, { tokensUsed: tokensUsed, tokensMax: tokensMax, estimatedCost: estimatedCost })] }));
+};
+//# sourceMappingURL=ChatApp.js.map

package/dist/cli/ink/DashboardApp.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function DashboardApp(): React.ReactElement;
+//# sourceMappingURL=DashboardApp.d.ts.map