codehere 0.3.0-rc.8 → 0.3.1

package/dist/presentation/cli/repl.js

@@ -1,161 +1,686 @@
 /**
- * Interactive REPL for codehere.
+ * Interactive REPL · raw-mode live command palette.
  *
- * Bare `codehere` (no args) drops here — the CLI surface, parallel to the
- * web UI at `codehere start`. Type a task in plain English; the Conductor
- * routes to the right specialist; events stream to the terminal; you get
- * the next prompt when the task completes.
+ * 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.
  *
- * Why this exists:
- * - The v0.2 REPL was removed in D7 along with the rest of the v0.2 CLI
- *   surface. That trim went too far — it removed a CLI entry point users
- *   relied on. rc.6 brings it back, this time backed by the v0.3
- *   Conductor (rule-based routing) instead of v0.2's smart-route.
- * - codehere is "PM you talk to" — terminal users should be able to talk
- *   to it in the terminal, not be forced to a web UI. Both surfaces, both
- *   first-class.
+ * 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)"
  *
- * What's here:
- * - Read a line → route via Conductor → spawn specialist → stream events
- *   to stdout → await completion → next prompt
- * - `/agents` lists installed specialists and the routing rules
- * - `/status` shows recent audit activity
- * - `/quit` (or Ctrl+C / Ctrl+D) exits cleanly
+ * Citing f4828c2 for lineage. Don't redesign.
  */
-import readline from 'readline';
-import { colors, newline } 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';
-export async function runInteractiveRepl(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    newline();
-    console.log(colors.bold('codehere ') + colors.dim('v' + getVersion()));
-    console.log(colors.dim('Talk to your AI coding agents. Type a task; codehere routes to the right specialist.'));
-    newline();
-    console.log(colors.dim('  /agents       list installed specialists + routing rules'));
-    console.log(colors.dim('  /status       recent activity from the audit log'));
-    console.log(colors.dim('  /web          open the web UI at http://127.0.0.1:3773'));
-    console.log(colors.dim('  /quit         exit  (or Ctrl+C / Ctrl+D)'));
-    newline();
-    const installed = availableAgents().filter((a) => a.installed);
-    if (installed.length === 0) {
-        console.log(colors.yellow('  No specialist agents installed. Install at least one to delegate tasks:'));
-        console.log(colors.dim('    npm install -g @anthropic-ai/claude-code'));
-        console.log(colors.dim('    npm install -g @openai/codex'));
-        console.log(colors.dim('    brew install aider'));
-        console.log(colors.dim('    curl -fsSL https://opencode.ai/install | bash'));
-        newline();
-        console.log(colors.dim('You can still use ') +
-            colors.cyan('/status') +
-            colors.dim(', ') +
-            colors.cyan('codehere trust .') +
-            colors.dim(', and the safety hook here.'));
-        newline();
+import { collectCodeFiles } from '../../infrastructure/security/file-collection.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');
     }
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: colors.cyan('› '),
-        terminal: true,
-    });
-    const manager = SessionManager.getInstance();
-    const prompt = () => {
-        rl.setPrompt(colors.cyan('› '));
-        rl.prompt();
-    };
-    rl.on('close', () => {
-        newline();
-        console.log(colors.dim('Goodbye.'));
-        process.exit(0);
-    });
-    rl.on('SIGINT', () => {
-        // Ctrl+C: if we're idle at the prompt, exit; if a task is mid-flight the
-        // task's own kill hook handles it via session.kill() (TODO: wire up).
-        rl.close();
-    });
-    prompt();
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-            prompt();
-            continue;
+    catch {
+        /* ignore */
+    }
+    const hasAnyAgent = availableAgents().some((a) => a.installed && a.id !== 'conductor');
+    const isGitRepo = existsSync(join(cwd, '.git'));
+    let fileCount = 0;
+    let scannableCount = 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);
+        // rc.21: surface the scannable count — code files that trust/scan
+        // would actually look at. Honest count beats a single inflated number.
+        // UX_OBSERVATIONS P3. Static ESM import (rc.20 used `require()` which is
+        // undefined in this package's ESM runtime — Codex caught the silent fail).
+        try {
+            scannableCount = collectCodeFiles(cwd).length;
+        }
+        catch {
+            /* ignore — banner stays silent rather than crashes */
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return { name, hasHooks, hasAgents: hasAnyAgent, isGitRepo, fileCount, scannableCount };
+}
+/**
+ * Format the banner's "X files (Y scannable)" line.
+ *
+ * Pure function (no I/O) so the rc.20 silent-fail regression that Codex
+ * caught — banner falling back to total-only when scannable load fails —
+ * has a tight unit test.
+ *
+ * Contract:
+ *   - scannable > 0 AND scannable < total → "<total> files (<scannable> scannable)"
+ *   - otherwise                            → "<total> files"
+ *
+ * Exported for test/cli/rc15-fixes.test.ts banner integration test.
+ */
+export function formatFileLine(total, scannable) {
+    if (scannable > 0 && scannable < total) {
+        return `${total} files (${scannable} scannable)`;
+    }
+    return `${total} files`;
+}
+export function buildWelcomeLines(state, version) {
+    const logo = createCodehereLogo();
+    const ver = colors.dim(`v${version}`);
+    const badges = [
+        state.hasHooks ? colors.green('● hooks') : colors.dim('○ hooks'),
+        state.hasAgents ? colors.green('● agents') : colors.dim('○ agents'),
+    ];
+    const lines = [
+        '',
+        `  ${logo} ${ver}`,
+        '',
+        '  ' + badges.join('  '),
+        '',
+        colors.dim(`  ${state.name}`) +
+            colors.dim(` · ${state.isGitRepo ? 'git' : 'dir'} · ${formatFileLine(state.fileCount, state.scannableCount)}`),
+        '',
+    ];
+    if (!state.hasHooks) {
+        lines.push('  ' + colors.yellow('→') + ' ' + colors.cyan('/hook install') + colors.dim(' to activate safety scanning'));
+    }
+    else if (!state.hasAgents) {
+        lines.push('  ' +
+            colors.yellow('→') +
+            ' Install ' +
+            colors.cyan('claude-code') +
+            colors.dim(' / ') +
+            colors.cyan('codex') +
+            colors.dim(' / aider / opencode to delegate tasks'));
+    }
+    lines.push(colors.dim('  Type / for commands, or ask anything'));
+    lines.push('');
+    return lines;
+}
+function printWelcome() {
+    const state = detectState();
+    for (const line of buildWelcomeLines(state, getVersion())) {
+        console.log(line);
+    }
+}
+// ── Main session ─────────────────────────────────────────────────────────
+export async function runInteractiveRepl() {
+    printWelcome();
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    const state = { history: [] };
+    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) {
+        // eslint-disable-next-line no-control-regex -- ANSI escape stripping requires the literal ESC byte
+        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;
         }
-        if (trimmed === '/quit' || trimmed === '/exit') {
-            rl.close();
+    }
+    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;
         }
-        if (trimmed === '/agents') {
-            printAgentsAndRoutingRules();
-            prompt();
-            continue;
+        // Ctrl+D
+        if (key === '\x04') {
+            stdout.write('\r\x1b[J\n' + colors.dim('  See you.') + '\n');
+            process.exit(0);
         }
-        if (trimmed === '/status') {
-            await printStatusSummary();
-            prompt();
-            continue;
+        // Ctrl+L
+        if (key === '\x0c') {
+            line = '';
+            selected = 0;
+            stdout.write('\x1b[2J\x1b[H');
+            printWelcome();
+            render();
+            return;
         }
-        if (trimmed === '/web' || trimmed === '/start') {
-            console.log(colors.dim('  Tip: run ') + colors.cyan('codehere start') + colors.dim(' in another terminal to launch the web UI.'));
-            prompt();
-            continue;
+        // 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 (trimmed.startsWith('/')) {
-            console.log(colors.yellow(`  Unknown REPL command: ${trimmed}`));
-            console.log(colors.dim('  Try /agents, /status, /web, or /quit.'));
-            prompt();
-            continue;
+        // 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;
         }
-        // Plain text → delegate via Conductor
-        if (installed.length === 0) {
-            console.log(colors.yellow('  No specialist installed — install one and try again.'));
-            prompt();
-            continue;
+        // 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;
         }
-        try {
-            await runTask(trimmed, cwd, manager);
+        // 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;
         }
-        catch (err) {
-            console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+        // Backspace
+        if (key === '\x7f' || key === '\b') {
+            if (line.length > 0) {
+                line = line.slice(0, -1);
+                selected = 0;
+                render();
+            }
+            return;
         }
-        newline();
-        prompt();
+        // 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);
+        }
+    });
 }
-/**
- * Run a single task and exit — bypass the REPL prompt loop.
- * Use case: `codehere "review src/auth.ts"` or scripts piping a task in.
- */
-export async function runOneShot(prompt, cwd = process.cwd()) {
+/** One-shot · `codehere "review src/auth.ts"` runs that task and exits. */
+export async function runOneShot(prompt) {
     const installed = availableAgents().filter((a) => a.installed);
     if (installed.length === 0) {
-        console.log(colors.yellow('  No specialist installed. Install one (see `codehere setup`) and try again.'));
+        console.log(warning('No specialist installed. Run `codehere setup` and try again.'));
         process.exit(1);
     }
-    const manager = SessionManager.getInstance();
     try {
-        await runTask(prompt, cwd, manager);
+        await spawnViaConductor(prompt);
     }
     catch (err) {
-        console.log(colors.red('  ✗ ') + (err instanceof Error ? err.message : String(err)));
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
         process.exit(1);
     }
 }
-async function runTask(prompt, cwd, manager) {
-    const session = manager.spawn(prompt, 'conductor', { cwd });
-    const startedLabel = colors.dim('  ┌─ ') + colors.bold(session.sessionId.slice(0, 8)) + colors.dim(' · ' + new Date(session.startedAt).toLocaleTimeString());
-    console.log(startedLabel);
+// ── Dispatch ─────────────────────────────────────────────────────────────
+async function executeInput(input, state) {
+    const lower = input.toLowerCase();
+    if (lower.startsWith('/')) {
+        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 '))
+        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);
+    }
+    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;
+    }
+    if (cmd === 'clear') {
+        stdout.write('\x1b[2J\x1b[H');
+        printWelcome();
+        return;
+    }
+    if (cmd === 'exit' || cmd === 'quit' || cmd === 'q') {
+        console.log(colors.dim('Goodbye! 👋'));
+        process.exit(0);
+    }
+    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);
+        }
+        newline();
+        return;
+    }
+    if (cmd === 'history' || cmd === '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}`));
+            });
+        }
+        return;
+    }
+    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;
+    }
+    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;
+    }
+    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;
+    }
+    if (def.kind === 'sub' && def.subcommand) {
+        await runSubcommand(def.subcommand, args ? args.split(/\s+/) : []);
+        return;
+    }
+}
+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);
+    if (installed.length === 0) {
+        console.log(warning('No specialist installed — install one and try again.'));
+        return;
+    }
+    const manager = SessionManager.getInstance();
+    const session = manager.spawn(prompt, 'conductor', { cwd: process.cwd() });
+    console.log(colors.dim('  ┌─ ') +
+        colors.bold(session.sessionId.slice(0, 8)) +
+        colors.dim(' · ' + new Date(session.startedAt).toLocaleTimeString()));
+    let captured = '';
     await new Promise((resolve) => {
         const unsubscribe = session.subscribe((event) => {
-            renderEvent(event);
+            const text = renderEvent(event);
+            if (text)
+                captured += text + '\n';
             if (event.type === 'codehere:complete' || event.type === 'codehere:error' || event.type === 'exit') {
                 unsubscribe();
                 resolve();
             }
         });
     });
-    const finalStatus = session.status;
-    const verdict = finalStatus === 'completed' ? colors.green('  └─ done') : finalStatus === 'killed' ? colors.yellow('  └─ killed') : colors.red('  └─ ' + finalStatus);
+    const status = session.status;
+    const verdict = status === 'completed'
+        ? success('  └─ done')
+        : status === 'killed'
+            ? warning('  └─ killed')
+            : error('  └─ ' + status);
     console.log(verdict);
+    if (state) {
+        state.history.push({ command: prompt, response: captured, timestamp: new Date().toISOString() });
+    }
 }
 function renderEvent(event) {
     switch (event.type) {
@@ -165,11 +690,7 @@ function renderEvent(event) {
                 colors.bold('routing → ') +
                 colors.cyan(data.delegatedTo ?? '?') +
                 colors.dim(' · ' + (data.reason ?? '')));
-            break;
-        }
-        case 'codehere:steps': {
-            // Step snapshots replay frequently — skip the noisy ones; the UI handles them
-            break;
+            return null;
         }
         case 'stdout':
         case 'stderr': {
@@ -177,89 +698,21 @@ function renderEvent(event) {
             const line = data?.line;
             if (line) {
                 const text = String(line).trimEnd();
-                if (text)
+                if (text) {
                     console.log(colors.dim('  │ ') + text);
+                    return text;
+                }
             }
-            break;
+            return null;
         }
         case 'error': {
             const data = event.data;
             if (data?.message)
                 console.log(colors.red('  │ ✗ ') + data.message);
-            break;
-        }
-        case 'codehere:complete':
-        case 'exit': {
-            // handled by runTask's verdict line
-            break;
+            return null;
         }
         default:
-            // Other event types — quiet by default to keep the REPL readable
-            break;
-    }
-}
-function printAgentsAndRoutingRules() {
-    newline();
-    console.log(colors.bold('  Installed specialists:'));
-    const all = availableAgents();
-    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();
-    console.log(colors.bold('  Routing (rule-based; LLM classifier in v0.4):'));
-    console.log(colors.dim('    review · audit · explain → claude-code'));
-    console.log(colors.dim('    refactor · restructure → codex'));
-    console.log(colors.dim('    fix · patch · bugfix → aider'));
-    console.log(colors.dim('    scaffold · generate · bootstrap → opencode'));
-    console.log(colors.dim('    add tests · write tests → codex'));
-    console.log(colors.dim('    (anything else) → claude-code'));
-    newline();
-}
-async function printStatusSummary() {
-    newline();
-    try {
-        const { existsSync, readFileSync } = await import('fs');
-        const { join } = await import('path');
-        const { homedir } = await import('os');
-        const auditPath = process.env.CODEHERE_AUDIT_FILE || join(homedir(), '.codehere', 'audit', 'hook-events.jsonl');
-        if (!existsSync(auditPath)) {
-            console.log(colors.dim('  No audit log yet. Run a task or `codehere hook install`.'));
-            newline();
-            return;
-        }
-        const lines = readFileSync(auditPath, 'utf-8').split('\n').filter(Boolean).slice(-10);
-        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-        let actions = 0;
-        let blocked = 0;
-        let trustSum = 0;
-        let trustN = 0;
-        for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                const ts = entry.timestamp ? Date.parse(entry.timestamp) : 0;
-                if (ts < cutoff)
-                    continue;
-                actions++;
-                if (entry.blocked)
-                    blocked++;
-                if (typeof entry.riskScore === 'number') {
-                    trustSum += 100 - entry.riskScore;
-                    trustN++;
-                }
-            }
-            catch {
-                /* skip malformed line */
-            }
-        }
-        const avgTrust = trustN > 0 ? Math.round(trustSum / trustN) : null;
-        console.log(colors.bold('  Last 24h:'));
-        console.log(`    ${actions} actions · ${blocked} blocked${avgTrust !== null ? ` · avg trust ${avgTrust}` : ''}`);
-    }
-    catch (err) {
-        console.log(colors.dim('  Could not read audit log: ' + (err instanceof Error ? err.message : String(err))));
+            return null;
     }
-    newline();
 }
 //# sourceMappingURL=repl.js.map