codehere 0.3.0-rc.11 → 0.3.0-rc.12

package/dist/presentation/cli/repl.js

@@ -1,75 +1,424 @@
 /**
- * Interactive REPL · faithful port of v0.2's session.ts (commit 796d4b7).
+ * Interactive REPL · raw-mode live command palette.
  *
- * Same banner, prompt, slash dispatcher, /help formatter, legacy non-slash
- * syntax, and keyboard-shortcut hints as the v0.2 REPL. Backends adapted
- * to v0.3 reality:
- *   - chat/edit/review/planner functions (removed in D7) → Conductor.spawn
- *   - /cost (no v0.3 cost tracking) → alias to /status
- *   - /trust → runs `codehere trust` inline
- *   - /undo (no v0.3 undo layer) → queued for v0.5 (F3 memory)
+ * Faithful port of v0.2.2's session.ts (commit f4828c2 · "REPL fixes,
+ * Palette Enter completes selected command, stdin multi-char chunk
+ * processing"). Same banner with state badges, same `> ` prompt with
+ * brand color, same filter-as-you-type palette under the prompt, same
+ * escape-buffering keystroke handler, same Tab/Enter complete, same
+ * arrow-key palette navigation when palette is visible / history when not.
  *
- * Citing 796d4b7 for lineage. Do not redesign without searching git first.
+ * Backends adapted to v0.3 (chat/edit/review/planner removed in D7):
+ *   - Task slash commands (ask, explain, fix, review, plan, test, refactor,
+ *     orchestrate, run) → spawn via Conductor
+ *   - Subcommand slash (trust, report, hook, status, health, serve, setup,
+ *     config) → invoke `node dist/index.js <cmd>` inline
+ *   - /undo → "queued for v0.5 (F3 memory layer)"
+ *
+ * Citing f4828c2 for lineage. Don't redesign.
  */
-import * as readline from 'readline';
-import { colors, newline, success, error, warning, info, createWelcomeMessage } from '../../ui.js';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import { spawn as childSpawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { colors, success, error, warning, newline, createCodehereLogo, } from '../../ui.js';
+import { getVersion } from '../../utils/version.js';
 import { SessionManager, availableAgents } from '../../infrastructure/orchestration/session-manager.js';
+import chalk from 'chalk';
+const brandBlue = chalk.rgb(74, 144, 226);
+const stdin = process.stdin;
+const stdout = process.stdout;
+const SLASH_COMMANDS = [
+    // Tasks · delegate via Conductor
+    {
+        name: 'ask',
+        args: '<question>',
+        description: 'Ask anything about your codebase',
+        kind: 'task',
+        promptTemplate: (a) => a,
+    },
+    {
+        name: 'explain',
+        args: '<file>',
+        description: 'Explain a file',
+        kind: 'task',
+        promptTemplate: (a) => `Explain this file in plain English: ${a}`,
+    },
+    {
+        name: 'fix',
+        args: '<file> <hint>',
+        description: 'Apply a targeted fix',
+        kind: 'task',
+        promptTemplate: (a) => {
+            const parts = a.split(/\s+/);
+            const file = parts[0];
+            const hint = parts.slice(1).join(' ');
+            return `fix ${file}: ${hint}`;
+        },
+    },
+    {
+        name: 'review',
+        args: '<file>',
+        description: 'Code review with findings',
+        kind: 'task',
+        promptTemplate: (a) => `Review ${a} for bugs, security issues, and risks. Concrete findings only.`,
+    },
+    {
+        name: 'plan',
+        args: '<goal>',
+        description: 'Break a goal into steps',
+        kind: 'task',
+        promptTemplate: (a) => `Plan: ${a}. Break into concrete steps before any execution.`,
+    },
+    {
+        name: 'test',
+        args: '<file>',
+        description: 'Generate tests for a file',
+        kind: 'task',
+        promptTemplate: (a) => `add tests for ${a}. Cover edge cases and likely failure modes.`,
+    },
+    {
+        name: 'refactor',
+        args: '<pattern> <instr>',
+        description: 'Refactor across files',
+        kind: 'task',
+        promptTemplate: (a) => `refactor: ${a}`,
+    },
+    // Subcommands · run an existing CLI subcommand inline
+    { name: 'trust', args: '[path]', description: 'Scan for vulnerabilities', kind: 'sub', noKey: true, subcommand: 'trust' },
+    { name: 'report', args: '[path]', description: 'Security audit report', kind: 'sub', noKey: true, subcommand: 'report' },
+    { name: 'hook', args: '[install|status]', description: 'Safety hook management', kind: 'sub', noKey: true, subcommand: 'hook' },
+    { name: 'status', args: '', description: 'Dashboard — hook activity', kind: 'sub', noKey: true, subcommand: 'status' },
+    { name: 'health', args: '', description: 'System health check', kind: 'sub', noKey: true, subcommand: 'health' },
+    { name: 'setup', args: '', description: 'Configure first-run preferences', kind: 'sub', noKey: true, subcommand: 'setup' },
+    { name: 'config', args: '[key] [value]', description: 'Manage preferences', kind: 'sub', noKey: true, subcommand: 'config' },
+    { name: 'agents', args: '', description: 'List installed specialists', kind: 'session', noKey: true },
+    { name: 'undo', args: '<file>', description: 'Undo file changes (queued for v0.5)', kind: 'session', noKey: true },
+    { name: 'history', args: '', description: 'Show command history', kind: 'session', noKey: true },
+    // Helpers
+    { name: 'help', args: '', description: 'Command reference', kind: 'session', noKey: true },
+    { name: 'clear', args: '', description: 'Clear the screen', kind: 'session', noKey: true },
+    { name: 'exit', args: '', description: 'Leave the session', kind: 'session', noKey: true },
+];
+const PALETTE_CMDS = SLASH_COMMANDS.map((c) => ({
+    sig: `/${c.name}${c.args ? ' ' + c.args : ''}`,
+    name: c.name,
+    desc: c.description,
+    noKey: c.noKey,
+}));
+function maxPalette() {
+    const rows = process.stdout.rows || 24;
+    return Math.min(rows - 8, 20);
+}
+// ── State detection (badges in welcome) ──────────────────────────────────
+function detectState() {
+    const cwd = process.cwd();
+    const name = basename(cwd);
+    const settingsPath = join(process.env.HOME || '', '.claude', 'settings.json');
+    let hasHooks = false;
+    try {
+        hasHooks = existsSync(settingsPath) && readFileSync(settingsPath, 'utf-8').includes('codehere');
+    }
+    catch {
+        /* ignore */
+    }
+    const hasAnyAgent = availableAgents().some((a) => a.installed && a.id !== 'conductor');
+    const isGitRepo = existsSync(join(cwd, '.git'));
+    let fileCount = 0;
+    try {
+        const count = (dir, d) => {
+            if (d > 3)
+                return 0;
+            let n = 0;
+            for (const e of readdirSync(dir, { withFileTypes: true })) {
+                if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === 'dist')
+                    continue;
+                if (e.isDirectory())
+                    n += count(join(dir, e.name), d + 1);
+                else
+                    n++;
+            }
+            return n;
+        };
+        fileCount = count(cwd, 0);
+    }
+    catch {
+        /* ignore */
+    }
+    return { name, hasHooks, hasAgents: hasAnyAgent, isGitRepo, fileCount };
+}
+function printWelcome() {
+    const state = detectState();
+    const logo = createCodehereLogo();
+    const ver = colors.dim(`v${getVersion()}`);
+    console.log();
+    console.log(`  ${logo} ${ver}`);
+    console.log();
+    const badges = [
+        state.hasHooks ? colors.green('● hooks') : colors.dim('○ hooks'),
+        state.hasAgents ? colors.green('● agents') : colors.dim('○ agents'),
+    ];
+    console.log('  ' + badges.join('  '));
+    console.log();
+    console.log(colors.dim(`  ${state.name}`) + colors.dim(` · ${state.isGitRepo ? 'git' : 'dir'} · ${state.fileCount} files`));
+    console.log();
+    if (!state.hasHooks)
+        console.log('  ' + colors.yellow('→') + ' ' + colors.cyan('/hook install') + colors.dim(' to activate safety scanning'));
+    else if (!state.hasAgents)
+        console.log('  ' + colors.yellow('→') + ' Install ' + colors.cyan('claude-code') + colors.dim(' / ') + colors.cyan('codex') + colors.dim(' / aider / opencode to delegate tasks'));
+    console.log(colors.dim('  Type / for commands, or ask anything'));
+    console.log();
+}
+// ── Main session ─────────────────────────────────────────────────────────
 export async function runInteractiveRepl() {
-    console.clear();
-    console.log(createWelcomeMessage());
-    newline();
-    console.log(colors.dim('Type your questions naturally, or use /commands. Type /help for all commands, exit to quit.'));
-    newline();
-    console.log(colors.dim('Keyboard Shortcuts: ↑/↓ for history, Ctrl+C to cancel, Ctrl+D to exit, Ctrl+L to clear'));
-    newline();
-    console.log(colors.dim('────────────────────────────────────────────────────'));
-    newline();
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: colors.cyan('codehere> '),
-        historySize: 100,
-        terminal: true,
-    });
+    printWelcome();
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
     const state = { history: [] };
-    rl.prompt();
-    rl.on('line', async (input) => {
-        const trimmed = input.trim();
-        if (!trimmed) {
-            rl.prompt();
+    const historyBuf = [];
+    let historyIdx = -1;
+    let line = '';
+    let selected = 0;
+    let pLines = 0;
+    let processing = false;
+    let escBuf = '';
+    let escTimer = null;
+    const cols = () => stdout.columns || 80;
+    function truncate(s, maxWidth) {
+        const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+        if (visible.length <= maxWidth)
+            return s;
+        let vis = 0;
+        let cut = 0;
+        for (let i = 0; i < s.length; i++) {
+            if (s[i] === '\x1b') {
+                const end = s.indexOf('m', i);
+                if (end !== -1) {
+                    i = end;
+                    continue;
+                }
+            }
+            vis++;
+            if (vis >= maxWidth - 1) {
+                cut = i + 1;
+                break;
+            }
+        }
+        return cut > 0 ? s.slice(0, cut) + '\x1b[0m' : s;
+    }
+    function render() {
+        stdout.write('\r\x1b[J');
+        stdout.write(brandBlue('> ') + line);
+        if (line.startsWith('/') && !line.includes(' ')) {
+            const filter = line.slice(1).toLowerCase();
+            const allMatching = PALETTE_CMDS.filter((c) => c.name.startsWith(filter));
+            const limit = maxPalette();
+            const filtered = allMatching.slice(0, limit);
+            const overflow = allMatching.length - filtered.length;
+            if (filtered.length > 0) {
+                const maxLen = Math.max(...filtered.map((c) => c.sig.length));
+                const w = cols();
+                let drawnLines = 0;
+                for (let i = 0; i < filtered.length; i++) {
+                    const c = filtered[i];
+                    const pad = ' '.repeat(Math.max(1, maxLen - c.sig.length + 2));
+                    const badge = c.noKey ? colors.dim(' (free)') : '';
+                    const prefix = i === selected ? brandBlue('▸') : ' ';
+                    const text = i === selected ? brandBlue(c.sig) : c.sig;
+                    const row = `  ${prefix} ${text}${pad}${colors.dim(c.desc)}${badge}`;
+                    stdout.write('\n' + truncate(row, w));
+                    drawnLines++;
+                }
+                if (overflow > 0) {
+                    stdout.write('\n' + colors.dim(`  ... +${overflow} more (type to filter)`));
+                    drawnLines++;
+                }
+                stdout.write(`\x1b[${drawnLines}A`);
+                stdout.write(`\x1b[${line.length + 3}G`);
+                pLines = drawnLines;
+            }
+            else {
+                stdout.write('\n' + colors.dim('  No matching commands'));
+                stdout.write('\x1b[1A');
+                stdout.write(`\x1b[${line.length + 3}G`);
+                pLines = 1;
+            }
+        }
+        else {
+            pLines = 0;
+        }
+    }
+    function handle(key) {
+        if (processing)
+            return;
+        // Ctrl+C
+        if (key === '\x03') {
+            if (line.length > 0) {
+                line = '';
+                selected = 0;
+                stdout.write('\r\x1b[J\n');
+                render();
+            }
+            else {
+                stdout.write('\r\x1b[J\n');
+                process.exit(0);
+            }
             return;
         }
-        const lower = trimmed.toLowerCase();
-        if (lower === 'exit' || lower === 'quit' || trimmed === 'q') {
-            console.log(info('Goodbye! 👋'));
-            rl.close();
+        // Ctrl+D
+        if (key === '\x04') {
+            stdout.write('\r\x1b[J\n' + colors.dim('  See you.') + '\n');
+            process.exit(0);
+        }
+        // Ctrl+L
+        if (key === '\x0c') {
+            line = '';
+            selected = 0;
+            stdout.write('\x1b[2J\x1b[H');
+            printWelcome();
+            render();
             return;
         }
-        if (lower === 'help' || trimmed === '?') {
-            showHelp();
-            showKeyboardShortcuts();
-            rl.prompt();
+        // Arrow up
+        if (key === '\x1b[A') {
+            if (pLines > 0) {
+                selected = Math.max(0, selected - 1);
+            }
+            else if (historyBuf.length > 0 && historyIdx < historyBuf.length - 1) {
+                historyIdx++;
+                line = historyBuf[historyIdx];
+            }
+            render();
             return;
         }
-        if (lower === 'clear') {
-            console.clear();
-            console.log(createWelcomeMessage());
-            newline();
-            rl.prompt();
+        // Arrow down
+        if (key === '\x1b[B') {
+            if (pLines > 0) {
+                selected = Math.min(pLines - 1, selected + 1);
+            }
+            else {
+                if (historyIdx > 0) {
+                    historyIdx--;
+                    line = historyBuf[historyIdx];
+                }
+                else {
+                    historyIdx = -1;
+                    line = '';
+                }
+            }
+            render();
             return;
         }
-        try {
-            await executeCommand(trimmed, state);
+        // Tab
+        if (key === '\t' && pLines > 0) {
+            const filter = line.slice(1).toLowerCase();
+            const filtered = PALETTE_CMDS.filter((c) => c.name.startsWith(filter)).slice(0, maxPalette());
+            if (filtered[selected]) {
+                line = `/${filtered[selected].name} `;
+                selected = 0;
+            }
+            render();
+            return;
         }
-        catch (err) {
-            console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        // Enter
+        if (key === '\r' || key === '\n') {
+            if (pLines > 0 && line.startsWith('/') && !line.includes(' ')) {
+                const filter = line.slice(1).toLowerCase();
+                const filtered = PALETTE_CMDS.filter((c) => c.name.startsWith(filter)).slice(0, maxPalette());
+                if (filtered[selected]) {
+                    line = `/${filtered[selected].name}`;
+                }
+            }
+            stdout.write('\r\x1b[J\n');
+            const trimmed = line.trim();
+            if (trimmed) {
+                historyBuf.unshift(trimmed);
+                historyIdx = -1;
+            }
+            line = '';
+            selected = 0;
+            pLines = 0;
+            if (!trimmed) {
+                render();
+                return;
+            }
+            processing = true;
+            executeInput(trimmed, state)
+                .catch((err) => {
+                console.log(error('  ' + (err instanceof Error ? err.message : String(err))));
+            })
+                .finally(() => {
+                processing = false;
+                stdin.resume();
+                stdin.ref();
+                if (stdin.isTTY && !stdin.isRaw)
+                    stdin.setRawMode(true);
+                console.log();
+                render();
+            });
+            return;
+        }
+        // Backspace
+        if (key === '\x7f' || key === '\b') {
+            if (line.length > 0) {
+                line = line.slice(0, -1);
+                selected = 0;
+                render();
+            }
+            return;
+        }
+        // Ignore stray escape sequences
+        if (key.startsWith('\x1b'))
+            return;
+        // Regular character
+        line += key;
+        selected = 0;
+        render();
+    }
+    render();
+    stdin.on('data', (raw) => {
+        if (processing)
+            return;
+        if (raw.startsWith('\x1b') && raw.length >= 2) {
+            handle(raw);
+            return;
+        }
+        for (let i = 0; i < raw.length; i++) {
+            if (processing)
+                return;
+            const ch = raw[i];
+            if (escBuf.length > 0) {
+                escBuf += ch;
+                if (escTimer)
+                    clearTimeout(escTimer);
+                if (escBuf.length >= 3) {
+                    const seq = escBuf;
+                    escBuf = '';
+                    handle(seq);
+                }
+                else {
+                    escTimer = setTimeout(() => {
+                        const seq = escBuf;
+                        escBuf = '';
+                        handle(seq);
+                    }, 50);
+                }
+                continue;
+            }
+            if (ch === '\x1b') {
+                escBuf = ch;
+                escTimer = setTimeout(() => {
+                    const seq = escBuf;
+                    escBuf = '';
+                    handle(seq);
+                }, 50);
+                continue;
+            }
+            handle(ch);
         }
-        rl.prompt();
-    });
-    rl.on('close', () => {
-        newline();
-        console.log(colors.dim('Session ended.'));
-        process.exit(0);
     });
 }
 /** One-shot · `codehere "review src/auth.ts"` runs that task and exits. */
@@ -87,245 +436,126 @@ export async function runOneShot(prompt) {
         process.exit(1);
     }
 }
-async function executeCommand(input, state) {
-    const lower = input.toLowerCase().trim();
+// ── Dispatch ─────────────────────────────────────────────────────────────
+async function executeInput(input, state) {
+    const lower = input.toLowerCase();
     if (lower.startsWith('/')) {
-        await handleSlashCommand(input.substring(1), state);
+        const parts = input.substring(1).trim().split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        const args = parts.slice(1).join(' ');
+        await handleSlash(cmd, args, state);
         return;
     }
     // Legacy non-slash syntax (v0.2 backwards compat)
-    if (lower.startsWith('explain ') || lower.startsWith('e ')) {
-        const file = input.substring(lower.startsWith('explain ') ? 8 : 2).trim();
-        await handleExplain(file);
-    }
-    else if (lower.startsWith('fix ') || lower.startsWith('edit ')) {
-        const rest = input.substring(lower.startsWith('fix ') ? 4 : 5).trim();
-        const parts = rest.split(' ');
-        const file = parts[0];
-        const instruction = parts.slice(1).join(' ');
-        await handleFix(file, instruction);
+    if (lower.startsWith('explain '))
+        return runTask(`Explain this file in plain English: ${input.substring(8).trim()}`, state);
+    if (lower.startsWith('e '))
+        return runTask(`Explain this file in plain English: ${input.substring(2).trim()}`, state);
+    if (lower.startsWith('fix ')) {
+        const rest = input.substring(4).trim();
+        const parts = rest.split(/\s+/);
+        return runTask(`fix ${parts[0]}: ${parts.slice(1).join(' ')}`, state);
     }
-    else if (lower.startsWith('review ')) {
-        await handleReview(input.substring(7).trim());
+    if (lower.startsWith('review '))
+        return runTask(`Review ${input.substring(7).trim()} for bugs, security, and risks.`, state);
+    if (lower.startsWith('plan '))
+        return runTask(`Plan: ${input.substring(5).trim()}. Break into steps.`, state);
+    // Default: ask via Conductor
+    await runTask(input, state);
+}
+async function handleSlash(cmd, args, state) {
+    if (cmd === 'help' || cmd === '?') {
+        showSlashCommandMenu();
+        return;
     }
-    else if (lower.startsWith('plan ')) {
-        await handlePlan(input.substring(5).trim());
+    if (cmd === 'clear') {
+        stdout.write('\x1b[2J\x1b[H');
+        printWelcome();
+        return;
     }
-    else {
-        // Default: delegate via Conductor
-        await handleAsk(input, state);
+    if (cmd === 'exit' || cmd === 'quit' || cmd === 'q') {
+        console.log(colors.dim('Goodbye! 👋'));
+        process.exit(0);
     }
-}
-async function handleSlashCommand(input, state) {
-    const parts = input.trim().split(/\s+/);
-    const command = parts[0].toLowerCase();
-    const args = parts.slice(1).join(' ');
-    switch (command) {
-        case 'fix':
-        case 'edit': {
-            const fixParts = args.split(/\s+/);
-            if (fixParts.length < 2) {
-                console.log(warning('Usage: /fix <file> <instruction>'));
-                console.log(colors.dim('Example: /fix src/utils.ts "add error handling"'));
-                return;
-            }
-            await handleFix(fixParts[0], fixParts.slice(1).join(' '));
-            break;
+    if (cmd === 'agents') {
+        const all = availableAgents();
+        newline();
+        console.log(colors.bold('  Installed specialists:'));
+        for (const a of all) {
+            const tag = a.installed ? colors.green('  ✓ ') : colors.dim('  · ');
+            const status = a.installed ? '' : colors.dim('  (not installed)');
+            console.log(tag + colors.cyan(a.id.padEnd(14)) + colors.dim(a.label) + status);
         }
-        case 'explain':
-        case 'e':
-            if (!args) {
-                console.log(warning('Usage: /explain <file>'));
-                console.log(colors.dim('Example: /explain src/auth.ts'));
-                return;
-            }
-            await handleExplain(args.split(/\s+/)[0]);
-            break;
-        case 'review':
-        case 'r':
-            if (!args) {
-                console.log(warning('Usage: /review <file>'));
-                console.log(colors.dim('Example: /review src/auth.ts'));
-                return;
-            }
-            await handleReview(args.split(/\s+/)[0]);
-            break;
-        case 'plan':
-        case 'p':
-            if (!args) {
-                console.log(warning('Usage: /plan <instruction>'));
-                console.log(colors.dim('Example: /plan "add user authentication"'));
-                return;
-            }
-            await handlePlan(args);
-            break;
-        case 'cost':
-        case 'status': {
-            // v0.3: no separate cost tracking; both surface the audit-log dashboard
-            try {
-                const { executeStatusCommand } = await import('./commands/status-command.js');
-                await executeStatusCommand({});
-            }
-            catch {
-                console.log(error('Failed to get status'));
-            }
-            break;
+        newline();
+        return;
+    }
+    if (cmd === 'history' || cmd === 'h') {
+        if (state.history.length === 0) {
+            console.log(colors.dim('No command history yet.'));
         }
-        case 'trust': {
-            // v0.3: trust scan inline
-            const target = args || '.';
-            const { spawn } = await import('child_process');
-            const { fileURLToPath } = await import('url');
-            const { join, dirname } = await import('path');
-            const here = fileURLToPath(import.meta.url);
-            const cliPath = join(dirname(here), '..', '..', 'index.js');
-            await new Promise((resolve) => {
-                const child = spawn('node', [cliPath, 'trust', target], { stdio: 'inherit' });
-                child.on('close', () => resolve());
-                child.on('error', (err) => {
-                    console.log(error('Trust scan failed: ' + err.message));
-                    resolve();
-                });
+        else {
+            console.log(colors.bold('Recent Commands:'));
+            state.history.slice(-10).forEach((h, i) => {
+                const preview = h.command.length > 60 ? h.command.slice(0, 57) + '…' : h.command;
+                console.log(colors.dim(`  ${i + 1}. ${preview}`));
             });
-            break;
-        }
-        case 'agents': {
-            const all = availableAgents();
-            newline();
-            console.log(colors.bold('  Installed specialists:'));
-            for (const a of all) {
-                const tag = a.installed ? colors.green('  ✓ ') : colors.dim('  · ');
-                const status = a.installed ? '' : colors.dim('  (not installed)');
-                console.log(tag + colors.cyan(a.id.padEnd(14)) + colors.dim(a.label) + status);
-            }
-            newline();
-            break;
         }
-        case 'undo':
-            console.log(colors.dim('  /undo is queued for v0.5 (F3 memory layer).'));
-            console.log(colors.dim('  For now: ') + colors.cyan('git diff') + colors.dim(' / ') + colors.cyan('git checkout -- <file>'));
-            break;
-        case 'history':
-        case 'h':
-            if (state.history.length === 0) {
-                console.log(colors.dim('No command history yet.'));
-            }
-            else {
-                console.log(colors.bold('Recent Commands:'));
-                state.history.slice(-10).forEach((h, i) => {
-                    const preview = h.command.length > 60 ? h.command.slice(0, 57) + '...' : h.command;
-                    console.log(colors.dim(`  ${i + 1}. ${preview}`));
-                });
-            }
-            break;
-        case 'clear':
-            console.clear();
-            console.log(createWelcomeMessage());
-            newline();
-            break;
-        case 'help':
-        case '?':
-            showSlashCommandHelp();
-            break;
-        default:
-            console.log(warning(`Unknown command: /${command}`));
-            console.log(colors.dim('Type /help to see available commands'));
+        return;
     }
-}
-function showSlashCommandHelp() {
-    newline();
-    console.log(colors.bold('Slash Commands'));
-    console.log(colors.dim('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    newline();
-    const commands = [
-        ['/fix <file> <instruction>', 'Apply AI-generated edit to a file'],
-        ['/explain <file>', 'Get AI explanation of a file'],
-        ['/review <file>', 'Review code quality and get suggestions'],
-        ['/plan <instruction>', 'Create an implementation plan'],
-        ['/agents', 'List installed specialist agents'],
-        ['/trust [path]', 'Scan path for security issues (default: cwd)'],
-        ['/status', 'Show project / audit dashboard'],
-        ['/cost', 'Alias for /status (no separate cost layer in v0.3)'],
-        ['/undo', 'Undo last edit (queued for v0.5)'],
-        ['/history', 'Show command history this session'],
-        ['/clear', 'Clear the screen'],
-        ['/help', 'Show this help message'],
-    ];
-    commands.forEach(([cmd, desc]) => {
-        console.log(`  ${colors.cyan(cmd.padEnd(30))} ${colors.dim(desc)}`);
-    });
-    newline();
-    console.log(colors.dim('Tip: You can also just type your question naturally!'));
-    console.log(colors.dim('Example: "how does authentication work?"'));
-    newline();
-}
-function showHelp() {
-    newline();
-    console.log(colors.bold('Slash Commands (recommended):'));
-    newline();
-    console.log(colors.cyan('  /fix <file> <instruction>') + '  Apply AI-generated edit');
-    console.log(colors.cyan('  /explain <file>') + '            Get AI explanation');
-    console.log(colors.cyan('  /review <file>') + '             Review code quality');
-    console.log(colors.cyan('  /plan <instruction>') + '        Create implementation plan');
-    console.log(colors.cyan('  /agents') + '                    List installed specialists');
-    console.log(colors.cyan('  /trust [path]') + '              Scan for security issues');
-    console.log(colors.cyan('  /status') + '                    Show project status');
-    console.log(colors.cyan('  /history') + '                   Show command history');
-    console.log(colors.cyan('  /help') + '                      Show all commands');
-    newline();
-    console.log(colors.bold('Quick Commands:'));
-    newline();
-    console.log(colors.cyan('  <question>') + '                 Ask anything · Conductor routes to the right specialist');
-    console.log(colors.cyan('  clear') + '                      Clear screen');
-    console.log(colors.cyan('  exit') + '                       Exit session (or: quit, q)');
-    newline();
-    console.log(colors.dim('Examples:'));
-    console.log(colors.dim('  How does authentication work?'));
-    console.log(colors.dim('  /explain src/auth.ts'));
-    console.log(colors.dim('  /fix src/utils.js "Add error handling"'));
-    newline();
-}
-function showKeyboardShortcuts() {
-    console.log(colors.bold('Keyboard Shortcuts:'));
-    newline();
-    console.log(colors.cyan('  ↑/↓') + '           Navigate command history');
-    console.log(colors.cyan('  Ctrl+C') + '        Cancel current command');
-    console.log(colors.cyan('  Ctrl+D') + '        Exit session');
-    console.log(colors.cyan('  Ctrl+L') + '        Clear screen');
-    newline();
-}
-// ── Handlers · all delegate via Conductor in v0.3 ────────────────────────
-async function handleAsk(question, state) {
-    await spawnViaConductor(question, state);
-}
-async function handleExplain(file) {
-    if (!file) {
-        console.log(warning('Usage: explain <file>'));
+    if (cmd === 'undo') {
+        console.log(colors.dim('  /undo is queued for v0.5 (F3 memory layer).'));
+        console.log(colors.dim('  For now: ') + colors.cyan('git diff') + colors.dim(' / ') + colors.cyan('git checkout -- <file>'));
         return;
     }
-    await spawnViaConductor(`Explain this file in plain English: ${file}`);
-}
-async function handleFix(file, instruction) {
-    if (!file || !instruction) {
-        console.log(warning('Usage: fix <file> <instruction>'));
-        console.log(colors.dim('Example: fix src/utils.ts "add error handling"'));
+    const def = SLASH_COMMANDS.find((c) => c.name === cmd);
+    if (!def) {
+        console.log(warning(`Unknown command: /${cmd}`));
+        console.log(colors.dim('Type /help to see available commands'));
         return;
     }
-    await spawnViaConductor(`fix ${file}: ${instruction}`);
-}
-async function handleReview(file) {
-    if (!file) {
-        console.log(warning('Usage: review <file>'));
+    if (def.kind === 'task' && def.promptTemplate) {
+        if (!args && def.args) {
+            console.log(warning(`Usage: /${def.name} ${def.args}`));
+            return;
+        }
+        await runTask(def.promptTemplate(args), state);
         return;
     }
-    await spawnViaConductor(`Review ${file} for bugs, security issues, and risks. Concrete findings only.`);
-}
-async function handlePlan(instruction) {
-    if (!instruction) {
-        console.log(warning('Usage: plan <instruction>'));
+    if (def.kind === 'sub' && def.subcommand) {
+        await runSubcommand(def.subcommand, args ? args.split(/\s+/) : []);
         return;
     }
-    await spawnViaConductor(`Plan: ${instruction}. Break into concrete steps before any execution.`);
+}
+function showSlashCommandMenu() {
+    newline();
+    console.log(colors.bold('  Slash commands'));
+    newline();
+    const maxNameLen = Math.max(...SLASH_COMMANDS.map((c) => c.name.length + c.args.length)) + 1;
+    for (const cmd of SLASH_COMMANDS) {
+        const signature = `/${cmd.name}${cmd.args ? ' ' + cmd.args : ''}`;
+        const pad = ' '.repeat(Math.max(0, maxNameLen + 2 - signature.length + 8));
+        const badge = cmd.noKey ? colors.dim(' (free)') : '';
+        console.log(`  ${colors.cyan(signature)}${pad}${colors.dim(cmd.description)}${badge}`);
+    }
+    newline();
+    console.log(colors.dim('  Type any command with / prefix, or just ask a question directly.'));
+    newline();
+}
+// ── Run-task / Run-subcommand helpers ────────────────────────────────────
+async function runTask(prompt, state) {
+    await spawnViaConductor(prompt, state);
+}
+async function runSubcommand(name, extraArgs) {
+    const here = fileURLToPath(import.meta.url);
+    const cliPath = join(dirname(here), '..', '..', 'index.js');
+    await new Promise((resolve) => {
+        const child = childSpawn('node', [cliPath, name, ...extraArgs], { stdio: 'inherit' });
+        child.on('close', () => resolve());
+        child.on('error', (err) => {
+            console.log(error('  ' + err.message));
+            resolve();
+        });
+    });
 }
 async function spawnViaConductor(prompt, state) {
     const installed = availableAgents().filter((a) => a.installed);
@@ -358,11 +588,7 @@ async function spawnViaConductor(prompt, state) {
             : error('  └─ ' + status);
     console.log(verdict);
     if (state) {
-        state.history.push({
-            command: prompt,
-            response: captured,
-            timestamp: new Date().toISOString(),
-        });
+        state.history.push({ command: prompt, response: captured, timestamp: new Date().toISOString() });
     }
 }
 function renderEvent(event) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehere",
-  "version": "0.3.0-rc.11",
+  "version": "0.3.0-rc.12",
   "description": "A PM for your AI coding agents. Delegate, orchestrate, and audit Claude Code, Codex, Aider, and OpenCode from one local web UI — every AI action traced, every file scored.",
   "main": "dist/index.js",
   "type": "module",