@taj-special/dravix-code 1.1.1

package/dist/cli/repl.js

@@ -0,0 +1,2833 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import chalk from 'chalk';
+import { streamChat, fetchSystemPrompt } from '../services/ai.js';
+import { buildContext } from '../services/context.js';
+import { parseOps, executeSingleOp, computeDiff } from '../services/executor.js';
+import { handleCommand } from './commands.js';
+import { printOpResult, printError, printInfo, colors } from '../utils/display.js';
+import { saveConversation, loadConversation, listConversations, generateTitle, generateId } from '../services/conversations.js';
+import { getToken, getSavedUser } from '../services/auth.js';
+import { checkUsage, reportUsage, estimateTokens, usageBar, fmtNum, formatResetTime } from '../services/usage.js';
+// System prompt is fetched from server at runtime — not stored in this package
+const BASE_PROMPT = ``;
+// prompts removed
+// Removed — fetched from server
+const CREATOR_EXTRA = ``;
+// Removed — fetched from server at runtime
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function buildSystemPrompt(_userEmail) { return BASE_PROMPT; }
+let _serverWebDesignerSkill = '';
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SLASH_COMMANDS = [
+    { name: '/files', desc: 'List project files and git status' },
+    { name: '/resume', desc: 'Resume a saved conversation' },
+    { name: '/retry', desc: 'Resend your last message' },
+    { name: '/copy', desc: 'Copy last AI response to clipboard' },
+    { name: '/model', desc: 'Show current AI model info' },
+    { name: '/clear', desc: 'Clear screen' },
+    { name: '/whoami', desc: 'Show signed-in user' },
+    { name: '/logout', desc: 'Sign out from Dravix Code' },
+    { name: '/help', desc: 'Show all commands and shortcuts' },
+    { name: '/exit', desc: 'Exit Dravix Code' },
+];
+function detectActiveStreamingOp(response) {
+    const tags = [
+        { name: 'write_file', label: 'Writing', self: false },
+        { name: 'edit_file', label: 'Editing', self: false },
+        { name: 'create_folder', label: 'Creating', self: true },
+        { name: 'delete_file', label: 'Deleting', self: true },
+        { name: 'run_command', label: 'Running', self: false },
+        { name: 'read_file', label: 'Reading', self: true },
+        { name: 'read_folder', label: 'Reading', self: true },
+        { name: 'search_code', label: 'Searching', self: true },
+    ];
+    for (const { name, label, self } of tags) {
+        const openIdx = response.lastIndexOf(`<${name}`);
+        if (openIdx === -1)
+            continue;
+        const closeIdx = response.indexOf(`</${name}>`, openIdx);
+        if (closeIdx !== -1)
+            continue;
+        if (self && response.indexOf('/>', openIdx) !== -1)
+            continue;
+        const snippet = response.slice(openIdx, openIdx + 300);
+        const pathMatch = snippet.match(/path="([^"]+)"/);
+        if (pathMatch)
+            return `${label}   ${path.basename(pathMatch[1])}`;
+        if (name === 'run_command') {
+            const m = snippet.match(/^<run_command(?:[^>]*)?>([^\n<]{0,55})/);
+            return `${label}   ${m?.[1]?.trim() || '...'}`;
+        }
+        return `${label}   ...`;
+    }
+    return null;
+}
+// ── Streaming tag stripper ──────────────────────────────────────
+const OUR_TAGS = ['write_file', 'edit_file', 'create_folder', 'delete_file', 'run_command', 'read_file', 'read_folder', 'search_code', 'design_mode'];
+const MAX_TAG_PREFIX = 15;
+class TagStripper {
+    buf = '';
+    suppressing = false;
+    closingFor = '';
+    feed(chunk) {
+        let out = '';
+        this.buf += chunk;
+        while (true) {
+            if (this.suppressing) {
+                const closeTag = `</${this.closingFor}>`;
+                if (this.closingFor === 'create_folder' || this.closingFor === 'delete_file') {
+                    const si = this.buf.indexOf('/>');
+                    const ci = this.buf.indexOf(closeTag);
+                    const end = si !== -1 && (ci === -1 || si < ci) ? si + 2
+                        : ci !== -1 ? ci + closeTag.length : -1;
+                    if (end !== -1) {
+                        this.buf = this.buf.slice(end);
+                        this.suppressing = false;
+                        this.closingFor = '';
+                        continue;
+                    }
+                }
+                else {
+                    const ci = this.buf.indexOf(closeTag);
+                    if (ci !== -1) {
+                        this.buf = this.buf.slice(ci + closeTag.length);
+                        this.suppressing = false;
+                        this.closingFor = '';
+                        continue;
+                    }
+                }
+                const guard = closeTag.length;
+                if (this.buf.length > guard)
+                    this.buf = this.buf.slice(this.buf.length - guard);
+                break;
+            }
+            else {
+                const li = this.buf.indexOf('<');
+                if (li === -1) {
+                    out += this.buf;
+                    this.buf = '';
+                    break;
+                }
+                out += this.buf.slice(0, li);
+                this.buf = this.buf.slice(li);
+                let found = false;
+                for (const name of OUR_TAGS) {
+                    if (this.buf.startsWith(`<${name}`)) {
+                        this.suppressing = true;
+                        this.closingFor = name;
+                        found = true;
+                        break;
+                    }
+                }
+                if (found)
+                    continue;
+                const partial = OUR_TAGS.some(n => `<${n}`.startsWith(this.buf.slice(0, Math.min(this.buf.length, `<${n}`.length))));
+                if (partial && this.buf.length < MAX_TAG_PREFIX)
+                    break;
+                out += '<';
+                this.buf = this.buf.slice(1);
+            }
+        }
+        return out;
+    }
+    flush() {
+        if (this.suppressing) {
+            this.buf = '';
+            return '';
+        }
+        const r = this.buf;
+        this.buf = '';
+        return r;
+    }
+}
+// ── Helpers ─────────────────────────────────────────────────────
+function stripAnsi(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+// ── Syntax highlighter ───────────────────────────────────────────
+const SH = {
+    keyword: chalk.hex('#a78bfa'),
+    string: chalk.hex('#86efac'),
+    comment: chalk.hex('#4b5563'),
+    number: chalk.hex('#fb923c'),
+    type: chalk.hex('#67e8f9'),
+    fn: chalk.hex('#60a5fa'),
+    op: chalk.hex('#94a3b8'),
+    plain: chalk.hex('#e2e8f0'),
+    jsonKey: chalk.hex('#93c5fd'),
+    jsonVal: chalk.hex('#86efac'),
+};
+const KW_JS = new Set('break case catch class const continue debugger default delete do else export extends false finally for from function get if import in instanceof let new null of return set static super switch this throw true try typeof undefined var void while with yield async await abstract declare enum interface module namespace override private protected public readonly type'.split(' '));
+const KW_PY = new Set('and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield None True False'.split(' '));
+const KW_GO = new Set('break case chan const continue default defer else fallthrough for func go goto if import interface map package range return select struct switch type var true false nil'.split(' '));
+const KW_RS = new Set('as async await break const continue crate dyn else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type union unsafe use where while'.split(' '));
+function highlightCode(line, lang) {
+    const L = lang.toLowerCase();
+    // ── JSON ─────────────────────────────────────────────────────
+    if (L === 'json' || L === 'jsonc') {
+        let r = '';
+        let i = 0;
+        while (i < line.length) {
+            if (line[i] === '"') {
+                let j = i + 1;
+                while (j < line.length) {
+                    if (line[j] === '\\') {
+                        j += 2;
+                        continue;
+                    }
+                    if (line[j] === '"') {
+                        j++;
+                        break;
+                    }
+                    j++;
+                }
+                const tok = line.slice(i, j);
+                let k = j;
+                while (k < line.length && line[k] === ' ')
+                    k++;
+                r += (line[k] === ':') ? SH.jsonKey(tok) : SH.jsonVal(tok);
+                i = j;
+                continue;
+            }
+            if (line.startsWith('//', i)) {
+                r += SH.comment(line.slice(i));
+                break;
+            }
+            const nm = line.slice(i).match(/^-?\d+\.?\d*(?:[eE][+-]?\d+)?/);
+            if (nm && (i === 0 || !/\w/.test(line[i - 1]))) {
+                r += SH.number(nm[0]);
+                i += nm[0].length;
+                continue;
+            }
+            const bm = line.slice(i).match(/^(true|false|null)\b/);
+            if (bm) {
+                r += SH.keyword(bm[0]);
+                i += bm[0].length;
+                continue;
+            }
+            r += SH.op(line[i]);
+            i++;
+        }
+        return r;
+    }
+    // ── Choose keyword set ────────────────────────────────────────
+    const KW = L === 'py' || L === 'python' ? KW_PY
+        : L === 'go' ? KW_GO
+            : L === 'rs' || L === 'rust' ? KW_RS
+                : KW_JS;
+    const lineComStarts = (L === 'py' || L === 'python' || L === 'sh' || L === 'bash' || L === 'shell' || L === 'zsh') ? ['#']
+        : (L === 'lua' || L === 'sql') ? ['--']
+            : ['//', '#'];
+    // ── Tokenize ─────────────────────────────────────────────────
+    let result = '';
+    let i = 0;
+    while (i < line.length) {
+        // Line comment
+        const lc = lineComStarts.find(s => line.startsWith(s, i));
+        if (lc) {
+            result += SH.comment(line.slice(i));
+            break;
+        }
+        // Block comment /* */
+        if (line.startsWith('/*', i)) {
+            const end = line.indexOf('*/', i + 2);
+            result += SH.comment(end >= 0 ? line.slice(i, end + 2) : line.slice(i));
+            i = end >= 0 ? end + 2 : line.length;
+            continue;
+        }
+        // String / template literal
+        if (line[i] === '"' || line[i] === "'" || line[i] === '`') {
+            const q = line[i];
+            let j = i + 1;
+            while (j < line.length) {
+                if (line[j] === '\\') {
+                    j += 2;
+                    continue;
+                }
+                if (line[j] === q) {
+                    j++;
+                    break;
+                }
+                j++;
+            }
+            result += SH.string(line.slice(i, j));
+            i = j;
+            continue;
+        }
+        // Number
+        if (/\d/.test(line[i]) && (i === 0 || !/[\w$]/.test(line[i - 1]))) {
+            const m = line.slice(i).match(/^(?:0x[\da-fA-F]+|0b[01]+|\d+\.?\d*(?:[eE][+-]?\d+)?)/);
+            if (m) {
+                result += SH.number(m[0]);
+                i += m[0].length;
+                continue;
+            }
+        }
+        // Identifier / keyword / type / function
+        if (/[a-zA-Z_$]/.test(line[i])) {
+            let j = i;
+            while (j < line.length && /[\w$]/.test(line[j]))
+                j++;
+            const word = line.slice(i, j);
+            if (KW.has(word)) {
+                result += SH.keyword(word);
+            }
+            else {
+                let k = j;
+                while (k < line.length && line[k] === ' ')
+                    k++;
+                if (line[k] === '(')
+                    result += SH.fn(word);
+                else if (/^[A-Z]/.test(word))
+                    result += SH.type(word);
+                else
+                    result += SH.plain(word);
+            }
+            i = j;
+            continue;
+        }
+        result += SH.op(line[i]);
+        i++;
+    }
+    return result;
+}
+// ── Markdown renderer (line-buffered, streaming-safe) ───────────
+function applyInline(text) {
+    return text
+        .replace(/\*\*(.+?)\*\*|__(.+?)__/g, (_, a, b) => chalk.bold(a ?? b))
+        .replace(/`([^`\n]+)`/g, (_, c) => chalk.hex('#fbbf24')(c))
+        .replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, (_, t) => chalk.italic(t));
+}
+class MarkdownRenderer {
+    lineBuf = '';
+    inCodeBlock = false;
+    codeLines = [];
+    codeLang = '';
+    blankCount = 0;
+    inTable = false;
+    tableRows = [];
+    format(chunk) {
+        // Strip \r to normalise Windows/mixed line endings
+        const clean = chunk.replace(/\r/g, '');
+        let out = '';
+        for (const c of clean) {
+            if (c === '\n') {
+                out += this.processLine(this.lineBuf);
+                this.lineBuf = '';
+            }
+            else {
+                this.lineBuf += c;
+            }
+        }
+        return out;
+    }
+    flush() {
+        let out = '';
+        if (this.lineBuf) {
+            out += this.processLine(this.lineBuf);
+            this.lineBuf = '';
+        }
+        if (this.inTable) {
+            out += this.renderTable();
+            this.inTable = false;
+        }
+        if (this.inCodeBlock) {
+            out += this.renderCodeBlock();
+            this.inCodeBlock = false;
+        }
+        return out;
+    }
+    processLine(raw) {
+        // ── Inside code block ──────────────────────────────────────
+        if (this.inCodeBlock) {
+            if (raw.trimEnd() === '```') {
+                this.inCodeBlock = false;
+                return this.renderCodeBlock();
+            }
+            this.codeLines.push(raw);
+            return '';
+        }
+        // ── Opening code fence ─────────────────────────────────────
+        if (raw.startsWith('```')) {
+            this.inCodeBlock = true;
+            this.codeLang = raw.slice(3).trim();
+            this.codeLines = [];
+            return '';
+        }
+        // ── Table row ─────────────────────────────────────────────
+        if (raw.startsWith('|')) {
+            this.inTable = true;
+            const allCells = raw.split('|').slice(1, -1).map(c => c.trim());
+            const isSep = allCells.length > 0 && allCells.every(c => /^:?-+:?$/.test(c));
+            if (!isSep && allCells.length > 0) {
+                this.tableRows.push(allCells);
+            }
+            return '';
+        }
+        if (this.inTable) {
+            this.inTable = false;
+            return this.renderTable() + this.processLine(raw);
+        }
+        // ── Blank line (collapse 3+ to 2) ─────────────────────────
+        if (!raw.trim()) {
+            this.blankCount++;
+            return this.blankCount <= 2 ? '\n' : '';
+        }
+        // ── Heading # / ## / ### ──────────────────────────────────
+        const hm = raw.match(/^(#{1,3})\s+(.+)$/);
+        if (hm) {
+            const lvl = hm[1].length;
+            const title = hm[2];
+            const paint = lvl === 1 ? chalk.bold.hex('#818cf8')
+                : lvl === 2 ? chalk.bold.hex('#a78bfa')
+                    : chalk.bold.hex('#c4b5fd');
+            const prefix = this.blankCount === 0 ? '\n' : '';
+            this.blankCount = 0;
+            return prefix + '  ' + paint(title) + '\n';
+        }
+        this.blankCount = 0;
+        // ── Unordered list - or * ─────────────────────────────────
+        const ulm = raw.match(/^(\s*)[-*]\s+(.+)$/);
+        if (ulm) {
+            const indent = '  '.repeat(Math.floor(ulm[1].length / 2) + 1);
+            return indent + colors.muted('·') + '  ' + colors.ai(applyInline(ulm[2])) + '\n';
+        }
+        // ── Ordered list 1. ──────────────────────────────────────
+        const olm = raw.match(/^(\s*)(\d+)\.\s+(.+)$/);
+        if (olm) {
+            const indent = '  '.repeat(Math.floor(olm[1].length / 2) + 1);
+            return indent + colors.muted(olm[2] + '.') + '  ' + colors.ai(applyInline(olm[3])) + '\n';
+        }
+        // ── Blockquote > ─────────────────────────────────────────
+        const bqm = raw.match(/^>\s?(.*)$/);
+        if (bqm) {
+            return '  ' + colors.dim('│') + '  ' + colors.muted(applyInline(bqm[1])) + '\n';
+        }
+        // ── Horizontal rule --- / *** ─────────────────────────────
+        if (/^[-*_]{3,}\s*$/.test(raw.trim())) {
+            return '  ' + colors.dim('─'.repeat(Math.min((process.stdout.columns ?? 80) - 4, 72))) + '\n';
+        }
+        // ── Normal text ───────────────────────────────────────────
+        return '  ' + colors.ai(applyInline(raw)) + '\n';
+    }
+    renderTable() {
+        const rows = this.tableRows;
+        this.tableRows = [];
+        if (rows.length === 0)
+            return '';
+        const cols = Math.max(...rows.map(r => r.length));
+        const termW = process.stdout.columns ?? 80;
+        // max usable width per column (distribute evenly, min 6)
+        const maxColW = Math.max(6, Math.floor((termW - 4 - (cols + 1)) / cols));
+        const widths = Array(cols).fill(0);
+        for (const row of rows) {
+            for (let i = 0; i < cols; i++) {
+                const cellLen = Math.min((row[i] ?? '').length, maxColW);
+                widths[i] = Math.max(widths[i], cellLen + 2);
+            }
+        }
+        const bar = (l, m, r) => colors.dim('  ' + l + widths.map(w => '─'.repeat(w)).join(m) + r);
+        let out = '\n' + bar('┌', '┬', '┐') + '\n';
+        for (let ri = 0; ri < rows.length; ri++) {
+            const row = rows[ri];
+            const cells = widths.map((w, i) => {
+                const raw = row[i] ?? '';
+                const cell = raw.length > w - 2 ? raw.slice(0, w - 3) + '…' : raw;
+                const pad = w - cell.length - 1;
+                const text = ri === 0 ? chalk.bold.white(cell) : colors.ai(cell);
+                return ' ' + text + ' '.repeat(Math.max(pad, 0));
+            });
+            out += colors.dim('  │') + cells.join(colors.dim('│')) + colors.dim('│') + '\n';
+            if (ri === 0 && rows.length > 1)
+                out += bar('├', '┼', '┤') + '\n';
+        }
+        out += bar('└', '┴', '┘') + '\n';
+        return out;
+    }
+    renderCodeBlock() {
+        const lang = this.codeLang;
+        const lines = this.codeLines;
+        // If code block content is a markdown table, render it as a table
+        const nonEmpty = lines.filter(l => l.trim());
+        if (nonEmpty.length > 0 && nonEmpty.every(l => l.trimStart().startsWith('|'))) {
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                const allCells = line.split('|').slice(1, -1).map(c => c.trim());
+                const isSep = allCells.length > 0 && allCells.every(c => /^:?-+:?$/.test(c));
+                if (!isSep && allCells.length > 0)
+                    this.tableRows.push(allCells);
+            }
+            if (this.tableRows.length > 0)
+                return this.renderTable();
+        }
+        const termW = process.stdout.columns ?? 80;
+        const maxInner = Math.min(termW - 8, 80);
+        const maxLen = lines.length > 0 ? Math.max(...lines.map(l => l.length)) : 0;
+        const inner = Math.max(maxLen, lang.length + 4, 20, 0);
+        const capped = Math.min(inner, maxInner);
+        const dashAfterLang = Math.max(0, capped - lang.length - 2);
+        const top = lang
+            ? colors.dim('  ╭─ ') + chalk.hex('#818cf8')(lang) + colors.dim(' ' + '─'.repeat(dashAfterLang))
+            : colors.dim('  ╭' + '─'.repeat(capped + 2));
+        const bot = colors.dim('  ╰' + '─'.repeat(capped + 2));
+        const canHighlight = lang && !['text', 'txt', 'plain', 'output', 'log'].includes(lang.toLowerCase());
+        let out = '\n' + top + '\n';
+        for (const l of lines) {
+            const display = l.length > capped ? l.slice(0, capped - 1) + '…' : l;
+            const colorized = canHighlight ? highlightCode(display, lang) : chalk.hex('#e2e8f0')(display);
+            out += colors.dim('  │ ') + colorized + '\n';
+        }
+        out += bot + '\n';
+        return out;
+    }
+}
+function normalizeResponse(text) {
+    return text.replace(/```[\w]*\n?(<(?:write_file|edit_file|delete_file|create_folder|run_command|read_file|read_folder|search_code)[\s\S]*?(?:<\/(?:write_file|edit_file|run_command)>|<(?:delete_file|create_folder|read_file|read_folder|search_code)[^>]*\/>))\n?```/g, '$1');
+}
+function opLabel(op, cwd) {
+    const exists = op.path ? fs.existsSync(path.resolve(cwd, op.path)) : false;
+    switch (op.type) {
+        case 'write': return exists ? `Modify file: ${op.path}` : `Create file: ${op.path}`;
+        case 'edit': return `Edit file: ${op.path}`;
+        case 'mkdir': return `Create folder: ${op.path}`;
+        case 'delete': return `Delete: ${op.path}`;
+        case 'run': return `Run command: ${op.command}`;
+        default: return op.path ?? '';
+    }
+}
+function opKey(op, cwd) {
+    const exists = op.path ? fs.existsSync(path.resolve(cwd, op.path)) : false;
+    if (op.type === 'write')
+        return exists ? 'modify' : 'create';
+    return op.type;
+}
+// ── Permission prompt ───────────────────────────────────────────
+function opStyle(label) {
+    const l = label.toLowerCase();
+    if (l.startsWith('create folder'))
+        return { icon: '+', paint: colors.success };
+    if (l.startsWith('create'))
+        return { icon: '+', paint: colors.success };
+    if (l.startsWith('delete'))
+        return { icon: '!', paint: colors.error };
+    if (l.startsWith('run'))
+        return { icon: '$', paint: colors.primary };
+    return { icon: '~', paint: colors.warn };
+}
+const OPT_LABELS_DEFAULT = ['Apply this change', 'Apply to all changes', 'Skip this change'];
+const OPT_LABELS_RUN = ['Yes, run it', 'No, skip'];
+const SEP = '─'.repeat(40);
+function clearMenu(lines) {
+    process.stdout.write('\x1b[2K');
+    for (let i = 0; i < lines; i++) {
+        process.stdout.write('\x1b[1A\x1b[2K');
+    }
+}
+async function askPermission(label, key, alwaysAllowed, noAlways) {
+    if (!noAlways && alwaysAllowed.has(key))
+        return true;
+    return new Promise((resolve) => {
+        let sel = 0;
+        let drawn = false;
+        const ci = label.indexOf(': ');
+        const opType = ci !== -1 ? label.slice(0, ci) : label;
+        const opValue = ci !== -1 ? label.slice(ci + 2) : '';
+        const { icon, paint } = opStyle(label);
+        const optLabels = noAlways ? OPT_LABELS_RUN : OPT_LABELS_DEFAULT;
+        const optCount = optLabels.length;
+        // run: 3-line box (╭header + │cmd + ╰) + blank + options
+        // file ops: 4-line box (╭ + │type + │value + ╰) + blank + options
+        const menuLines = (noAlways ? 3 : 4) + 1 + optCount;
+        function printMenu() {
+            if (drawn)
+                clearMenu(menuLines);
+            drawn = true;
+            let boxLines;
+            if (noAlways) {
+                const dashes = SEP.length - 2 - 'run command'.length - 1;
+                boxLines = [
+                    colors.dim('  ╭─ ') + colors.primary('run command') + colors.dim(' ' + '─'.repeat(Math.max(dashes, 1))),
+                    `  │  ${chalk.hex('#fbbf24')('$')}  ${chalk.white(opValue)}`,
+                    colors.dim('  ╰' + SEP),
+                ];
+            }
+            else {
+                boxLines = [
+                    colors.dim('  ╭' + SEP),
+                    `  │  ${paint(icon + '  ' + opType)}`,
+                    `  │     ${chalk.white(opValue)}`,
+                    colors.dim('  ╰' + SEP),
+                ];
+            }
+            const lines = [
+                ...boxLines,
+                '',
+                ...optLabels.map((lbl, i) => i === sel
+                    ? `  ${colors.primary('›')}  ${colors.primary.bold(lbl)}`
+                    : `     ${colors.muted(lbl)}`),
+            ];
+            process.stdout.write(lines.join('\n') + '\n');
+        }
+        printMenu();
+        function cleanup() {
+            process.stdin.removeListener('data', onData);
+        }
+        function confirm(idx) {
+            cleanup();
+            clearMenu(menuLines);
+            const skipIdx = noAlways ? 1 : 2;
+            if (idx === skipIdx) {
+                process.stdout.write(`  ${colors.muted('○')}  ${colors.muted('Skipped: ' + label)}\n`);
+                resolve(false);
+            }
+            else {
+                if (!noAlways && idx === 1)
+                    alwaysAllowed.add(key);
+                resolve(true);
+            }
+        }
+        function onData(data) {
+            try {
+                switch (data) {
+                    case '\x1b[A':
+                        sel = (sel - 1 + optCount) % optCount;
+                        printMenu();
+                        break;
+                    case '\x1b[B':
+                        sel = (sel + 1) % optCount;
+                        printMenu();
+                        break;
+                    case '\r':
+                    case '\n':
+                        confirm(sel);
+                        break;
+                    case 'y':
+                    case 'Y':
+                        confirm(0);
+                        break;
+                    case 'n':
+                    case 'N':
+                        confirm(noAlways ? 1 : 2);
+                        break;
+                    case 'a':
+                    case 'A':
+                        if (!noAlways)
+                            confirm(1);
+                        break;
+                    case '\x03':
+                        cleanup();
+                        clearMenu(menuLines);
+                        process.exit(0);
+                }
+            }
+            catch (e) {
+                cleanup();
+                resolve(false);
+            }
+        }
+        process.stdin.on('data', onData);
+    });
+}
+async function readLine(prompt, cwd) {
+    let SEP = colors.dim('  ' + '─'.repeat(Math.max((process.stdout.columns ?? 80) - 4, 40)));
+    let sepVisualLen = 2 + Math.max((process.stdout.columns ?? 80) - 4, 40); // track visual width for resize
+    process.stdout.write('\n' + SEP + '\n' + prompt);
+    // Draw bottom separator, then move cursor back up to input line
+    process.stdout.write('\r\n' + SEP + '\x1b[1A\r' + prompt);
+    return new Promise((resolve) => {
+        let prefix = '';
+        let pasteBlock = null;
+        let pasteCount = 0;
+        let suffix = '';
+        let ctrlCCount = 0;
+        let ctrlCTimer = null;
+        // @ file-completion state
+        let atMode = false;
+        let atQuery = '';
+        let atSel = 0;
+        let atBoxLines = 0; // total picker box lines on screen (header + items + footer)
+        let allFiles = [];
+        // / slash-command picker state
+        let slashMode = false;
+        let slashQuery = '';
+        let slashSel = 0;
+        let slashBoxLines = 0;
+        let slashDrawn = false;
+        // Tab path-autocomplete state
+        let tabMode = false;
+        let tabQuery = '';
+        let tabSel = 0;
+        let tabBoxLines = 0;
+        let tabDrawn = false;
+        let tabPreWord = ''; // prefix text before the tab-completed token
+        function onResize() {
+            const newCols = process.stdout.columns ?? 80;
+            const oldSepRows = Math.ceil(sepVisualLen / newCols);
+            SEP = colors.dim('  ' + '─'.repeat(Math.max(newCols - 4, 40)));
+            sepVisualLen = 2 + Math.max(newCols - 4, 40);
+            if (atMode) {
+                for (let i = 0; i < atBoxLines + 3; i++)
+                    process.stdout.write('\x1b[1A');
+                process.stdout.write('\r\x1b[0J');
+                atDrawn = false;
+                atBoxLines = 0;
+                drawPicker();
+            }
+            else if (slashMode) {
+                for (let i = 0; i < slashBoxLines + 3; i++)
+                    process.stdout.write('\x1b[1A');
+                process.stdout.write('\r\x1b[0J');
+                slashDrawn = false;
+                slashBoxLines = 0;
+                drawSlashPicker();
+            }
+            else if (tabMode) {
+                for (let i = 0; i < tabBoxLines + 3; i++)
+                    process.stdout.write('\x1b[1A');
+                process.stdout.write('\r\x1b[0J');
+                tabDrawn = false;
+                tabBoxLines = 0;
+                drawTabPicker();
+            }
+            else {
+                // Clear input line, then bottom SEP below it
+                process.stdout.write('\r\x1b[K');
+                process.stdout.write('\x1b[1B\x1b[2K\x1b[1A');
+                // Go up clearing old top SEP rows + blank line above them
+                for (let i = 0; i < oldSepRows + 1; i++)
+                    process.stdout.write('\x1b[1A\x1b[2K');
+                // Redraw: blank line + new SEP + input + bottom SEP
+                process.stdout.write('\n' + SEP + '\n');
+                redraw();
+            }
+        }
+        process.stdout.on('resize', onResize);
+        function cleanup() {
+            if (ctrlCTimer) {
+                clearTimeout(ctrlCTimer);
+                ctrlCTimer = null;
+            }
+            process.stdin.removeListener('data', onData);
+            process.stdout.removeListener('resize', onResize);
+        }
+        function loadFiles() {
+            if (allFiles.length > 0)
+                return;
+            const IGNORE = new Set([
+                'node_modules', '.git', 'dist', '.next', 'build',
+                '__pycache__', '.cache', '.svn', 'coverage',
+            ]);
+            function walk(dir, depth, rel) {
+                if (depth > 4)
+                    return;
+                let entries;
+                try {
+                    entries = fs.readdirSync(dir, { withFileTypes: true });
+                }
+                catch {
+                    return;
+                }
+                for (const e of entries) {
+                    if (IGNORE.has(e.name))
+                        continue;
+                    if (e.name.startsWith('.') && e.name !== '.env' && e.name !== '.gitignore')
+                        continue;
+                    const p = rel ? `${rel}/${e.name}` : e.name;
+                    if (e.isDirectory()) {
+                        allFiles.push(p + '/');
+                        walk(path.join(dir, e.name), depth + 1, p);
+                    }
+                    else {
+                        allFiles.push(p);
+                    }
+                }
+            }
+            walk(cwd, 0, '');
+        }
+        function filterFiles(q) {
+            const dirsFirst = (arr) => [
+                ...arr.filter(f => f.endsWith('/')),
+                ...arr.filter(f => !f.endsWith('/')),
+            ];
+            if (!q)
+                return dirsFirst(allFiles).slice(0, 10);
+            const lq = q.toLowerCase();
+            const a = allFiles.filter(f => f.toLowerCase().startsWith(lq));
+            const b = allFiles.filter(f => !f.toLowerCase().startsWith(lq) && f.toLowerCase().includes(lq));
+            return dirsFirst([...a, ...b]).slice(0, 10);
+        }
+        function filterSlash(q) {
+            if (!q)
+                return SLASH_COMMANDS;
+            const lq = q.toLowerCase();
+            return SLASH_COMMANDS.filter(c => c.name.slice(1).toLowerCase().startsWith(lq));
+        }
+        // Picker layout:  input (A) | bot-sep (A+1) | box (A+2 .. A+1+atBoxLines)
+        // Clearing box:   atBoxLines × \x1b[1A\x1b[2K → cursor at A+2
+        //                 then \x1b[2A\x1b[2K to skip bot-sep and clear input
+        let atDrawn = false;
+        function drawPicker() {
+            if (atDrawn) {
+                for (let i = 0; i < atBoxLines; i++)
+                    process.stdout.write('\x1b[1A\x1b[2K');
+                process.stdout.write('\x1b[2A\x1b[2K');
+            }
+            else {
+                process.stdout.write('\r\x1b[K');
+                atDrawn = true;
+            }
+            atBoxLines = 0;
+            // Re-draw input line + bot sep, cursor lands at A+2
+            const inputLine = colors.primary('  › ') + chalk.white(prefix) +
+                (pasteBlock !== null
+                    ? colors.muted(`[paste: ${pasteCount} lines]`) + chalk.white(suffix)
+                    : '') +
+                chalk.hex('#818cf8')('@') + chalk.white(atQuery);
+            process.stdout.write(inputLine + '\r\n' + SEP + '\r\n');
+            // Box dimensions — DW = total visual width including borders
+            const DW = Math.min(Math.max((process.stdout.columns ?? 80) - 6, 44), 72);
+            const IW = DW - 6; // visible filename area width
+            const filtered = filterFiles(atQuery);
+            if (atSel >= filtered.length && filtered.length > 0)
+                atSel = filtered.length - 1;
+            const shown = filtered.slice(0, 10);
+            // ── Header ────────────────────────────────────────────────
+            const qLabel = atQuery ? `@${atQuery}` : 'files';
+            const hDashes = Math.max(DW - 5 - qLabel.length, 1);
+            process.stdout.write(colors.dim('  ╭─ ') + colors.primary(qLabel) +
+                colors.dim(' ' + '─'.repeat(hDashes) + '╮') + '\n');
+            atBoxLines++;
+            // ── Items ─────────────────────────────────────────────────
+            if (shown.length === 0) {
+                const msg = 'no matches';
+                const pad = ' '.repeat(Math.max(IW - msg.length, 0));
+                process.stdout.write(colors.dim('  │') + '    ' +
+                    colors.muted(msg) + pad + colors.dim('│') + '\n');
+                atBoxLines++;
+            }
+            else {
+                for (let i = 0; i < shown.length; i++) {
+                    const f = shown[i];
+                    const isDir = f.endsWith('/');
+                    const sel = i === atSel;
+                    const mark = sel ? colors.primary('>') : ' ';
+                    const clip = f.length > IW ? f.slice(0, IW - 1) + '…' : f;
+                    const pad = ' '.repeat(Math.max(IW - clip.length, 0));
+                    const name = sel && isDir ? colors.primary.bold(clip) + pad // selected folder: indigo bold
+                        : sel ? colors.primary.bold(clip) + pad // selected file:   indigo bold
+                            : isDir ? chalk.hex('#38bdf8')(clip) + pad // folder: sky-blue
+                                : chalk.hex('#94a3b8')(clip + pad); // file: slate-gray
+                    process.stdout.write(colors.dim('  │') + `  ${mark} ` + name + colors.dim('│') + '\n');
+                    atBoxLines++;
+                }
+            }
+            // ── Footer ────────────────────────────────────────────────
+            const hint = ' ↑↓  Enter  Esc ';
+            const fInner = DW - 2 - hint.length;
+            const fLeft = Math.floor(fInner / 2);
+            const fRight = fInner - fLeft;
+            process.stdout.write(colors.dim('  ╰' + '─'.repeat(Math.max(fLeft, 0))) +
+                colors.muted(hint) +
+                colors.dim('─'.repeat(Math.max(fRight, 0)) + '╯') + '\n');
+            atBoxLines++;
+            // cursor at A+2+atBoxLines
+        }
+        function closePicker() {
+            if (atDrawn) {
+                for (let i = 0; i < atBoxLines; i++)
+                    process.stdout.write('\x1b[1A\x1b[2K');
+                process.stdout.write('\x1b[2A\x1b[2K');
+                atDrawn = false;
+            }
+            else {
+                process.stdout.write('\r\x1b[K');
+            }
+            atBoxLines = 0;
+            atMode = false;
+            atQuery = '';
+            atSel = 0;
+        }
+        function drawSlashPicker() {
+            if (slashDrawn) {
+                for (let i = 0; i < slashBoxLines; i++)
+                    process.stdout.write('\x1b[1A\x1b[2K');
+                process.stdout.write('\x1b[2A\x1b[2K');
+            }
+            else {
+                process.stdout.write('\r\x1b[K');
+                slashDrawn = true;
+            }
+            slashBoxLines = 0;
+            const inputLine = colors.primary('  › ') + colors.primary('/') + chalk.white(slashQuery);
+            process.stdout.write(inputLine + '\r\n' + SEP + '\r\n');
+            const DW = Math.min(Math.max((process.stdout.columns ?? 80) - 6, 44), 72);
+            const nameW = 10;
+            const descW = DW - nameW - 8;
+            const filtered = filterSlash(slashQuery);
+            if (slashSel >= filtered.length && filtered.length > 0)
+                slashSel = filtered.length - 1;
+            const qLabel = slashQuery ? `/${slashQuery}` : 'commands';
+            const hDashes = Math.max(DW - 5 - qLabel.length, 1);
+            process.stdout.write(colors.dim('  ╭─ ') + colors.primary(qLabel) +
+                colors.dim(' ' + '─'.repeat(hDashes) + '╮') + '\n');
+            slashBoxLines++;
+            if (filtered.length === 0) {
+                const msg = 'no matching commands';
+                const pad = ' '.repeat(Math.max(DW - 4 - msg.length, 0));
+                process.stdout.write(colors.dim('  │') + '    ' + colors.muted(msg) + pad + colors.dim('│') + '\n');
+                slashBoxLines++;
+            }
+            else {
+                for (let i = 0; i < filtered.length; i++) {
+                    const cmd = filtered[i];
+                    const sel = i === slashSel;
+                    const mark = sel ? colors.primary('>') : ' ';
+                    const nameStr = cmd.name.padEnd(nameW);
+                    const descStr = cmd.desc.length > descW ? cmd.desc.slice(0, descW - 1) + '…' : cmd.desc;
+                    const descPad = ' '.repeat(Math.max(descW - descStr.length, 0));
+                    const namePaint = sel ? colors.primary.bold(nameStr) : chalk.hex('#818cf8')(nameStr);
+                    const descPaint = sel ? colors.muted(descStr) : chalk.hex('#4b5563')(descStr);
+                    process.stdout.write(colors.dim('  │') + `  ${mark} ` + namePaint + '  ' + descPaint + descPad + colors.dim('│') + '\n');
+                    slashBoxLines++;
+                }
+            }
+            const hint = ' ↑↓  Enter  Esc ';
+            const fInner = DW - 2 - hint.length;
+            const fLeft = Math.floor(fInner / 2);
+            const fRight = fInner - fLeft;
+            process.stdout.write(colors.dim('  ╰' + '─'.repeat(Math.max(fLeft, 0))) +
+                colors.muted(hint) +
+                colors.dim('─'.repeat(Math.max(fRight, 0)) + '╯') + '\n');
+            slashBoxLines++;
+        }
+        function closeSlashPicker() {
+            if (slashDrawn) {
+                for (let i = 0; i < slashBoxLines; i++)
+                    process.stdout.write('\x1b[1A\x1b[2K');
+                process.stdout.write('\x1b[2A\x1b[2K');
+                slashDrawn = false;
+            }
+            else {
+                process.stdout.write('\r\x1b[K');
+            }
+            slashBoxLines = 0;
+            slashMode = false;
+            slashQuery = '';
+            slashSel = 0;
+        }
+        function drawTabPicker() {
+            if (tabDrawn) {
+                for (let i = 0; i < tabBoxLines; i++)
+                    process.stdout.write('\x1b[1A\x1b[2K');
+                process.stdout.write('\x1b[2A\x1b[2K');
+            }
+            else {
+                process.stdout.write('\r\x1b[K');
+                tabDrawn = true;
+            }
+            tabBoxLines = 0;
+            const inputLine = colors.primary('  › ') + chalk.white(tabPreWord) +
+                chalk.hex('#34d399')(tabQuery);
+            process.stdout.write(inputLine + '\r\n' + SEP + '\r\n');
+            const DW = Math.min(Math.max((process.stdout.columns ?? 80) - 6, 44), 72);
+            const IW = DW - 6;
+            const filtered = filterFiles(tabQuery);
+            if (tabSel >= filtered.length && filtered.length > 0)
+                tabSel = filtered.length - 1;
+            const shown = filtered.slice(0, 10);
+            const TC = chalk.hex('#34d399');
+            const qLabel = tabQuery || 'tab complete';
+            const hDashes = Math.max(DW - 5 - qLabel.length, 1);
+            process.stdout.write(colors.dim('  ╭─ ') + TC(qLabel) +
+                colors.dim(' ' + '─'.repeat(hDashes) + '╮') + '\n');
+            tabBoxLines++;
+            if (shown.length === 0) {
+                const msg = 'no matches';
+                const pad = ' '.repeat(Math.max(IW - msg.length, 0));
+                process.stdout.write(colors.dim('  │') + '    ' + colors.muted(msg) + pad + colors.dim('│') + '\n');
+                tabBoxLines++;
+            }
+            else {
+                for (let i = 0; i < shown.length; i++) {
+                    const f = shown[i];
+                    const isDir = f.endsWith('/');
+                    const sel = i === tabSel;
+                    const mark = sel ? TC('>') : ' ';
+                    const clip = f.length > IW ? f.slice(0, IW - 1) + '…' : f;
+                    const pad = ' '.repeat(Math.max(IW - clip.length, 0));
+                    const name = sel ? TC.bold(clip) + pad
+                        : isDir ? chalk.hex('#38bdf8')(clip) + pad
+                            : chalk.hex('#94a3b8')(clip + pad);
+                    process.stdout.write(colors.dim('  │') + `  ${mark} ` + name + colors.dim('│') + '\n');
+                    tabBoxLines++;
+                }
+            }
+            const hint = ' Tab/↑↓  Enter  Esc ';
+            const fInner = DW - 2 - hint.length;
+            const fLeft = Math.floor(fInner / 2);
+            const fRight = fInner - fLeft;
+            process.stdout.write(colors.dim('  ╰' + '─'.repeat(Math.max(fLeft, 0))) +
+                colors.muted(hint) +
+                colors.dim('─'.repeat(Math.max(fRight, 0)) + '╯') + '\n');
+            tabBoxLines++;
+        }
+        function closeTabPicker() {
+            if (tabDrawn) {
+                for (let i = 0; i < tabBoxLines; i++)
+                    process.stdout.write('\x1b[1A\x1b[2K');
+                process.stdout.write('\x1b[2A\x1b[2K');
+                tabDrawn = false;
+            }
+            else {
+                process.stdout.write('\r\x1b[K');
+            }
+            tabBoxLines = 0;
+            tabMode = false;
+            tabQuery = '';
+            tabSel = 0;
+            tabPreWord = '';
+        }
+        function redraw() {
+            const cols = process.stdout.columns ?? 80;
+            const maxLen = Math.max(cols - 6, 10);
+            // Truncate to terminal width — prevents line wrapping on resize
+            let displayPre = prefix;
+            if (displayPre.length > maxLen)
+                displayPre = '…' + displayPre.slice(-(maxLen - 1));
+            let inp;
+            if (pasteBlock !== null) {
+                inp = colors.primary('  › ') + chalk.white(displayPre) +
+                    colors.muted(`[paste: ${pasteCount} lines]`) + chalk.white(suffix);
+            }
+            else {
+                inp = colors.primary('  › ') + chalk.white(displayPre);
+            }
+            process.stdout.write('\r\x1b[K' + inp);
+            process.stdout.write('\r\n' + SEP + '\x1b[1A\r' + inp);
+        }
+        function submit() {
+            if (atMode)
+                closePicker();
+            if (tabMode) {
+                prefix = tabPreWord + tabQuery;
+                closeTabPicker();
+            }
+            const parts = [];
+            if (prefix.trim())
+                parts.push(prefix.trim());
+            if (pasteBlock)
+                parts.push(...pasteBlock.split('\n').filter(Boolean));
+            if (suffix.trim())
+                parts.push(suffix.trim());
+            const text = parts.join('\n');
+            const lns = parts.length > 0 ? parts : (text ? [text] : []);
+            cleanup();
+            // Clear input → bot sep → top sep, replace with styled sent message
+            process.stdout.write('\r\x1b[K'); // clear input line
+            process.stdout.write('\x1b[1B\x1b[2K'); // down to bot sep, clear
+            process.stdout.write('\x1b[2A\x1b[2K'); // up 2 to top sep, clear
+            if (!text) {
+                resolve(null);
+                return;
+            }
+            const cols = process.stdout.columns ?? 80;
+            const msgBg = chalk.bgHex('#334155').hex('#f1f5f9');
+            const fillMsg = (raw) => ('  > ' + raw + ' ').padEnd(cols);
+            if (pasteBlock !== null) {
+                const parts = [
+                    prefix ? prefix : '',
+                    `[${pasteCount} lines]`,
+                    suffix.trim() ? suffix.trim() : '',
+                ].filter(Boolean).join(' ');
+                process.stdout.write(msgBg(fillMsg(parts)) + '\n');
+            }
+            else {
+                process.stdout.write(msgBg(fillMsg(text)) + '\n');
+            }
+            resolve({ text, lines: lns });
+        }
+        function onData(data) {
+            try {
+                if (data === '\x03') {
+                    // Close any active picker first
+                    if (atMode)
+                        closePicker();
+                    if (slashMode)
+                        closeSlashPicker();
+                    if (tabMode)
+                        closeTabPicker();
+                    // If there is typed input — clear it (safe copy behavior, like bash)
+                    if (prefix || pasteBlock !== null || suffix) {
+                        prefix = '';
+                        pasteBlock = null;
+                        pasteCount = 0;
+                        suffix = '';
+                        ctrlCCount = 0;
+                        if (ctrlCTimer) {
+                            clearTimeout(ctrlCTimer);
+                            ctrlCTimer = null;
+                        }
+                        redraw();
+                        return;
+                    }
+                    // No input: require double Ctrl+C to exit (prevents accidental exit from copy)
+                    ctrlCCount++;
+                    if (ctrlCTimer)
+                        clearTimeout(ctrlCTimer);
+                    if (ctrlCCount >= 2) {
+                        cleanup();
+                        process.stdout.write('\n\n  ' + colors.muted('Goodbye!') + '\n\n');
+                        process.exit(0);
+                    }
+                    process.stdout.write('\r\x1b[K  ' + colors.muted('(Ctrl+C again to exit — use /exit or close window)'));
+                    ctrlCTimer = setTimeout(() => { ctrlCCount = 0; redraw(); }, 1500);
+                    return;
+                }
+                if (ctrlCCount > 0) {
+                    ctrlCCount = 0;
+                    if (ctrlCTimer) {
+                        clearTimeout(ctrlCTimer);
+                        ctrlCTimer = null;
+                    }
+                }
+                if (data === '\x04') {
+                    cleanup();
+                    resolve(null);
+                    return;
+                }
+                // Ctrl+L — clear screen, redraw input
+                if (data === '\x0c') {
+                    if (atMode)
+                        closePicker();
+                    console.clear();
+                    process.stdout.write('\n' + SEP + '\n' + prompt);
+                    process.stdout.write('\r\n' + SEP + '\x1b[1A\r' + prompt);
+                    return;
+                }
+                // ── @ picker mode ─────────────────────────────────────────
+                if (atMode) {
+                    if (data === '\x1b') { // Escape → cancel
+                        closePicker();
+                        redraw();
+                        return;
+                    }
+                    if (data === '\x1b[A') { // Arrow up
+                        const f = filterFiles(atQuery);
+                        if (f.length) {
+                            atSel = (atSel - 1 + f.length) % f.length;
+                            drawPicker();
+                        }
+                        return;
+                    }
+                    if (data === '\x1b[B') { // Arrow down
+                        const f = filterFiles(atQuery);
+                        if (f.length) {
+                            atSel = (atSel + 1) % f.length;
+                            drawPicker();
+                        }
+                        return;
+                    }
+                    if (data === '\x1b[C') { // Arrow right → enter folder
+                        const f = filterFiles(atQuery);
+                        if (f.length > 0) {
+                            const file = f[Math.min(atSel, f.length - 1)];
+                            if (file.endsWith('/')) {
+                                atQuery = file;
+                                atSel = 0;
+                                drawPicker();
+                            }
+                        }
+                        return;
+                    }
+                    if (data === '\x1b[D') { // Arrow left → go up one level
+                        const noTrail = atQuery.endsWith('/') ? atQuery.slice(0, -1) : atQuery;
+                        const lastSlash = noTrail.lastIndexOf('/');
+                        atQuery = lastSlash >= 0 ? noTrail.slice(0, lastSlash + 1) : '';
+                        atSel = 0;
+                        drawPicker();
+                        return;
+                    }
+                    if (data === '\r' || data === '\n' || data === '\t') { // Enter/Tab → drill into folder or insert file
+                        const filtered = filterFiles(atQuery);
+                        if (filtered.length > 0) {
+                            const file = filtered[Math.min(atSel, filtered.length - 1)];
+                            if (file.endsWith('/')) {
+                                atQuery = file;
+                                atSel = 0;
+                                drawPicker();
+                            }
+                            else {
+                                const mention = '@' + file;
+                                closePicker();
+                                if (pasteBlock !== null)
+                                    suffix += mention;
+                                else
+                                    prefix += mention;
+                                redraw();
+                            }
+                        }
+                        else {
+                            closePicker();
+                            redraw();
+                        }
+                        return;
+                    }
+                    if (data === ' ') { // Space → select current item (file or folder)
+                        const filtered = filterFiles(atQuery);
+                        if (filtered.length > 0) {
+                            const file = filtered[Math.min(atSel, filtered.length - 1)];
+                            const mention = '@' + file;
+                            closePicker();
+                            if (pasteBlock !== null)
+                                suffix += mention;
+                            else
+                                prefix += mention;
+                            redraw();
+                        }
+                        else {
+                            closePicker();
+                            redraw();
+                        }
+                        return;
+                    }
+                    if (data === '\x7f' || data === '\b') { // Backspace
+                        if (atQuery.length > 0) {
+                            atQuery = atQuery.slice(0, -1);
+                            atSel = 0;
+                            drawPicker();
+                        }
+                        else {
+                            closePicker();
+                            redraw();
+                        }
+                        return;
+                    }
+                    if (data.length === 1 && data >= ' ') { // type to filter
+                        atQuery += data;
+                        atSel = 0;
+                        drawPicker();
+                        return;
+                    }
+                    return;
+                }
+                // ── / slash picker mode ───────────────────────────────────
+                if (slashMode) {
+                    if (data === '\x1b') {
+                        closeSlashPicker();
+                        redraw();
+                        return;
+                    }
+                    if (data === '\x1b[A') {
+                        const f = filterSlash(slashQuery);
+                        if (f.length) {
+                            slashSel = (slashSel - 1 + f.length) % f.length;
+                            drawSlashPicker();
+                        }
+                        return;
+                    }
+                    if (data === '\x1b[B') {
+                        const f = filterSlash(slashQuery);
+                        if (f.length) {
+                            slashSel = (slashSel + 1) % f.length;
+                            drawSlashPicker();
+                        }
+                        return;
+                    }
+                    if (data === '\r' || data === '\n' || data === '\t') {
+                        const filtered = filterSlash(slashQuery);
+                        if (filtered.length > 0) {
+                            const cmd = filtered[Math.min(slashSel, filtered.length - 1)];
+                            prefix = cmd.name + ' ';
+                            closeSlashPicker();
+                            redraw();
+                        }
+                        else {
+                            closeSlashPicker();
+                            redraw();
+                        }
+                        return;
+                    }
+                    if (data === '\x7f' || data === '\b') {
+                        if (slashQuery.length > 0) {
+                            slashQuery = slashQuery.slice(0, -1);
+                            slashSel = 0;
+                            drawSlashPicker();
+                        }
+                        else {
+                            closeSlashPicker();
+                            redraw();
+                        }
+                        return;
+                    }
+                    if (data === ' ') {
+                        const filtered = filterSlash(slashQuery);
+                        if (filtered.length > 0) {
+                            const cmd = filtered[Math.min(slashSel, filtered.length - 1)];
+                            prefix = cmd.name + ' ';
+                        }
+                        else {
+                            prefix = '/' + slashQuery + ' ';
+                        }
+                        closeSlashPicker();
+                        redraw();
+                        return;
+                    }
+                    if (data.length === 1 && data >= ' ') {
+                        slashQuery += data;
+                        slashSel = 0;
+                        drawSlashPicker();
+                        return;
+                    }
+                    return;
+                }
+                // ── Tab path-autocomplete mode ────────────────────────────
+                if (tabMode) {
+                    if (data === '\x1b') { // Escape → cancel, restore text
+                        const saved = tabPreWord + tabQuery;
+                        closeTabPicker();
+                        prefix = saved;
+                        redraw();
+                        return;
+                    }
+                    if (data === '\x1b[A') { // Arrow up
+                        const f = filterFiles(tabQuery);
+                        if (f.length) {
+                            tabSel = (tabSel - 1 + f.length) % f.length;
+                            drawTabPicker();
+                        }
+                        return;
+                    }
+                    if (data === '\x1b[B' || data === '\t') { // Arrow down / Tab → next
+                        const f = filterFiles(tabQuery);
+                        if (f.length) {
+                            tabSel = (tabSel + 1) % f.length;
+                            drawTabPicker();
+                        }
+                        return;
+                    }
+                    if (data === '\x1b[C') { // Arrow right → enter folder
+                        const f = filterFiles(tabQuery);
+                        if (f.length > 0) {
+                            const file = f[Math.min(tabSel, f.length - 1)];
+                            if (file.endsWith('/')) {
+                                tabQuery = file;
+                                tabSel = 0;
+                                drawTabPicker();
+                            }
+                        }
+                        return;
+                    }
+                    if (data === '\x1b[D') { // Arrow left → go up
+                        const noTrail = tabQuery.endsWith('/') ? tabQuery.slice(0, -1) : tabQuery;
+                        const lastSlash = noTrail.lastIndexOf('/');
+                        tabQuery = lastSlash >= 0 ? noTrail.slice(0, lastSlash + 1) : '';
+                        tabSel = 0;
+                        drawTabPicker();
+                        return;
+                    }
+                    if (data === '\r' || data === '\n') { // Enter → insert or drill
+                        const filtered = filterFiles(tabQuery);
+                        if (filtered.length > 0) {
+                            const file = filtered[Math.min(tabSel, filtered.length - 1)];
+                            if (file.endsWith('/')) {
+                                tabQuery = file;
+                                tabSel = 0;
+                                drawTabPicker();
+                            }
+                            else {
+                                prefix = tabPreWord + file;
+                                closeTabPicker();
+                                redraw();
+                            }
+                        }
+                        else {
+                            prefix = tabPreWord + tabQuery;
+                            closeTabPicker();
+                            redraw();
+                        }
+                        return;
+                    }
+                    if (data === '\x7f' || data === '\b') { // Backspace
+                        if (tabQuery.length > 0) {
+                            tabQuery = tabQuery.slice(0, -1);
+                            tabSel = 0;
+                            drawTabPicker();
+                        }
+                        else {
+                            closeTabPicker();
+                            prefix = tabPreWord;
+                            redraw();
+                        }
+                        return;
+                    }
+                    if (data.length === 1 && data >= ' ') { // Type to filter
+                        tabQuery += data;
+                        tabSel = 0;
+                        drawTabPicker();
+                        return;
+                    }
+                    return;
+                }
+                // Enter
+                if (data === '\r' || data === '\n' || data === '\r\n') {
+                    submit();
+                    return;
+                }
+                // ── Tab trigger ───────────────────────────────────────────
+                if (data === '\t' && pasteBlock === null) {
+                    loadFiles();
+                    const spaceIdx = prefix.lastIndexOf(' ');
+                    tabPreWord = spaceIdx >= 0 ? prefix.slice(0, spaceIdx + 1) : '';
+                    tabQuery = spaceIdx >= 0 ? prefix.slice(spaceIdx + 1) : prefix;
+                    tabSel = 0;
+                    tabMode = true;
+                    drawTabPicker();
+                    return;
+                }
+                // ── @ trigger ─────────────────────────────────────────────
+                if (data === '@') {
+                    loadFiles();
+                    atMode = true;
+                    atQuery = '';
+                    atSel = 0;
+                    drawPicker();
+                    return;
+                }
+                // ── / trigger ─────────────────────────────────────────────
+                if (data === '/' && prefix === '' && pasteBlock === null) {
+                    slashMode = true;
+                    slashQuery = '';
+                    slashSel = 0;
+                    drawSlashPicker();
+                    return;
+                }
+                // ── Paste detection ───────────────────────────────────────
+                const normalized = data.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+                if (normalized.includes('\n')) {
+                    prefix += suffix;
+                    suffix = '';
+                    const pasted = normalized.replace(/\n$/, '');
+                    pasteBlock = pasted;
+                    pasteCount = pasted.split('\n').filter(l => l.length > 0).length || 1;
+                    redraw();
+                    return;
+                }
+                // Backspace
+                if (data === '\x7f' || data === '\b') {
+                    if (suffix.length > 0) {
+                        suffix = suffix.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                    else if (pasteBlock !== null) {
+                        pasteBlock = null;
+                        pasteCount = 0;
+                        redraw();
+                    }
+                    else if (prefix.length > 0) {
+                        prefix = prefix.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                    return;
+                }
+                // Ignore unrecognised escape sequences (arrow keys, Fn keys, etc.)
+                if (data.startsWith('\x1b'))
+                    return;
+                // Single-line paste (multiple printable chars arriving at once — no newline)
+                if (data.length > 1) {
+                    const printable = data.split('').filter(c => c >= ' ').join('');
+                    if (printable) {
+                        if (pasteBlock !== null)
+                            suffix += printable;
+                        else
+                            prefix += printable;
+                        process.stdout.write(printable);
+                    }
+                    return;
+                }
+                // Regular single printable char
+                if (data.length === 1 && data >= ' ') {
+                    if (pasteBlock !== null)
+                        suffix += data;
+                    else
+                        prefix += data;
+                    process.stdout.write(data);
+                }
+            }
+            catch (e) {
+                // If any keypress handler throws, restore terminal so keys don't get stuck
+                cleanup();
+                resolve(null);
+            }
+        }
+        process.stdin.on('data', onData);
+    });
+}
+// ── Main REPL ───────────────────────────────────────────────────
+function fmtDate(iso) {
+    const d = new Date(iso);
+    const mo = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][d.getMonth()];
+    return `${mo} ${String(d.getDate()).padStart(2, ' ')} ${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+}
+function timeAgoShort(iso) {
+    const diff = Date.now() - new Date(iso).getTime();
+    const m = Math.floor(diff / 60000);
+    if (m < 1)
+        return 'now';
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h`;
+    const d = Math.floor(h / 24);
+    if (d < 30)
+        return `${d}d`;
+    return `${Math.floor(d / 30)}mo`;
+}
+async function showConversationPicker() {
+    const allConvs = listConversations(100);
+    if (allConvs.length === 0) {
+        printInfo('No saved conversations yet.');
+        return null;
+    }
+    return new Promise((resolve) => {
+        let sel = 0;
+        let query = '';
+        let drawnLines = 0;
+        let lastDW = 0;
+        const MAX_SHOWN = 10;
+        let scroll = 0; // first visible index within filtered list
+        function getAllFiltered() {
+            if (!query)
+                return allConvs;
+            const lq = query.toLowerCase();
+            return allConvs.filter(c => c.title.toLowerCase().includes(lq));
+        }
+        function draw() {
+            const cols = process.stdout.columns ?? 80;
+            const DW = Math.min(Math.max(cols - 6, 50), 84);
+            lastDW = DW;
+            const all = getAllFiltered();
+            const total = all.length;
+            if (total > 0 && sel >= total)
+                sel = total - 1;
+            if (sel < 0)
+                sel = 0;
+            // Keep sel in visible window
+            if (sel < scroll)
+                scroll = sel;
+            if (sel >= scroll + MAX_SHOWN)
+                scroll = sel - MAX_SHOWN + 1;
+            scroll = Math.max(0, Math.min(scroll, Math.max(0, total - MAX_SHOWN)));
+            const shown = all.slice(scroll, scroll + MAX_SHOWN);
+            const N = shown.length;
+            // Clear previous draw
+            if (drawnLines > 0) {
+                for (let i = 0; i < drawnLines; i++)
+                    process.stdout.write('\x1b[1A\x1b[2K');
+            }
+            drawnLines = 0;
+            const BC = chalk.hex('#4338ca');
+            const PC = chalk.hex('#818cf8');
+            const DIM = chalk.hex('#4b5563');
+            // ── Header ─────────────────────────────────────────────────
+            // Visible: "  ╭─" (4) + hLabel + " " + "─"*hDashes + "╮" (1) = DW+2
+            const hLabel = query
+                ? `  / ${query}  ` + DIM(`${total} found`)
+                : `  ${allConvs.length} conversation${allConvs.length !== 1 ? 's' : ''}`;
+            const hLabelVis = stripAnsi(hLabel).length;
+            const hDashes = Math.max(DW - 4 - hLabelVis, 1);
+            process.stdout.write(BC('  ╭─') + PC(hLabel) + BC(' ' + '─'.repeat(hDashes) + '╮') + '\n');
+            drawnLines++;
+            // ── Search input ────────────────────────────────────────────
+            // Visible: "  │" (3) + "  /  " (5) + query + cursor(1) + pad + "│" (1) = DW+2
+            // → pad = DW - 8 - query.length
+            const sCursor = colors.primary('│');
+            const sPad = ' '.repeat(Math.max(DW - 8 - query.length, 0));
+            process.stdout.write(BC('  │') + colors.muted('  /  ') + chalk.white(query) + sCursor + sPad + BC('│') + '\n');
+            drawnLines++;
+            // ── Separator ──────────────────────────────────────────────
+            process.stdout.write(BC('  ├' + '─'.repeat(DW - 2) + '┤') + '\n');
+            drawnLines++;
+            // ── Items ──────────────────────────────────────────────────
+            // Row visible: "  │" (3) + "  > " (4) + TITLE_W + "  " (2) + msgs(7) + "  " (2) + ago(3) + " │" (2) = DW+2
+            // → 3+4+TITLE_W+2+7+2+3+2 = 23+TITLE_W = DW+2 → TITLE_W = DW-21
+            const TITLE_W = Math.max(DW - 21, 12);
+            if (N === 0) {
+                const msg = query ? 'no matching conversations' : 'no conversations yet';
+                const ipad = ' '.repeat(Math.max(DW - 6 - msg.length, 0));
+                process.stdout.write(BC('  │') + '    ' + colors.muted(msg) + ipad + BC('│') + '\n');
+                drawnLines++;
+            }
+            else {
+                for (let i = 0; i < N; i++) {
+                    const c = shown[i];
+                    const isSel = (scroll + i) === sel;
+                    const mark = isSel ? PC('>') : ' ';
+                    const title = c.title.replace(/\s+/g, ' ');
+                    const disp = title.length > TITLE_W ? title.slice(0, TITLE_W - 1) + '…' : title;
+                    const gap = ' '.repeat(Math.max(TITLE_W - disp.length, 0));
+                    // msgs: always 7 chars — e.g. " 2 msgs" or "20 msgs"
+                    const msgs = String(c.messageCount).padStart(2) + ' msgs';
+                    // ago: always 3 chars
+                    const ago = timeAgoShort(c.updatedAt).padStart(3);
+                    const titleC = isSel ? PC.bold(disp) : chalk.hex('#94a3b8')(disp);
+                    const msgsC = isSel ? chalk.hex('#818cf8')(msgs) : DIM(msgs);
+                    const agoC = isSel ? PC(ago) : DIM(ago);
+                    process.stdout.write(BC('  │') + `  ${mark} ` + titleC + gap + `  ` + msgsC + `  ` + agoC + ` ` + BC('│') + '\n');
+                    drawnLines++;
+                }
+            }
+            // ── Scroll indicator row (if needed) ───────────────────────
+            if (total > MAX_SHOWN) {
+                const above = scroll > 0;
+                const below = scroll + MAX_SHOWN < total;
+                const pos = `${sel + 1} / ${total}`;
+                const arrows = (above ? '↑ ' : '  ') + pos + (below ? ' ↓' : '  ');
+                const ipad = ' '.repeat(Math.max(DW - 4 - arrows.length, 0));
+                process.stdout.write(BC('  │') + ipad + colors.muted(arrows) + `  ` + BC('│') + '\n');
+                drawnLines++;
+            }
+            // ── Footer ─────────────────────────────────────────────────
+            const hint = ' ↑↓ navigate  Enter open  Esc cancel ';
+            const fInner = DW - 2 - hint.length;
+            const fLeft = Math.max(Math.floor(fInner / 2), 0);
+            const fRight = Math.max(fInner - fLeft, 0);
+            process.stdout.write(BC('  ╰' + '─'.repeat(fLeft)) + colors.muted(hint) + BC('─'.repeat(fRight) + '╯') + '\n');
+            drawnLines++;
+        }
+        draw();
+        function onResize() {
+            const newCols = process.stdout.columns ?? 80;
+            const rowsPerLine = Math.max(1, Math.ceil((lastDW + 2) / newCols));
+            const physRows = drawnLines * rowsPerLine;
+            for (let i = 0; i < physRows; i++)
+                process.stdout.write('\x1b[1A');
+            process.stdout.write('\r\x1b[0J');
+            drawnLines = 0;
+            draw();
+        }
+        process.stdout.on('resize', onResize);
+        function cleanup() {
+            process.stdin.removeListener('data', onKey);
+            process.stdout.removeListener('resize', onResize);
+        }
+        function close(id) {
+            cleanup();
+            for (let i = 0; i < drawnLines; i++)
+                process.stdout.write('\x1b[1A\x1b[2K');
+            resolve(id);
+        }
+        function onKey(data) {
+            const all = getAllFiltered();
+            const N = all.length;
+            switch (data) {
+                case '\x1b[A': // Arrow up
+                    if (N > 0) {
+                        sel = Math.max(sel - 1, 0);
+                        draw();
+                    }
+                    break;
+                case '\x1b[B': // Arrow down
+                    if (N > 0) {
+                        sel = Math.min(sel + 1, N - 1);
+                        draw();
+                    }
+                    break;
+                case '\r':
+                case '\n':
+                    close(all[sel]?.id ?? null);
+                    break;
+                case '\x1b':
+                    close(null);
+                    break;
+                case '\x03':
+                    cleanup();
+                    process.exit(0);
+                    break;
+                case '\x7f':
+                case '\b':
+                    if (query.length > 0) {
+                        query = query.slice(0, -1);
+                        sel = 0;
+                        scroll = 0;
+                        draw();
+                    }
+                    break;
+                default:
+                    if (data.length === 1 && data >= ' ') {
+                        query += data;
+                        sel = 0;
+                        scroll = 0;
+                        draw();
+                    }
+            }
+        }
+        process.stdin.on('data', onKey);
+    });
+}
+function printConversationHistory(messages) {
+    const cols = process.stdout.columns ?? 80;
+    const chatMsgs = messages.filter(m => m.role === 'user' || m.role === 'assistant');
+    if (chatMsgs.length === 0)
+        return;
+    // Build map: filepath → last known content (from system read_file messages)
+    const fileSnapshot = new Map();
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            const text = String(msg.content);
+            const match = text.match(/^\[File content — ([^\]]+)\]:\n([\s\S]*)$/);
+            if (match)
+                fileSnapshot.set(match[1], match[2]);
+        }
+    }
+    const toShow = chatMsgs.length > 20 ? chatMsgs.slice(-20) : chatMsgs;
+    if (chatMsgs.length > 20) {
+        process.stdout.write(colors.muted(`\n  … ${chatMsgs.length - 20} earlier messages …\n`));
+    }
+    const msgBg = chalk.bgHex('#334155').hex('#f1f5f9');
+    const BC = chalk.hex('#4338ca');
+    const FC = chalk.hex('#e2e8f0');
+    for (const msg of toShow) {
+        if (msg.role === 'user') {
+            const raw = String(msg.content).replace(/\s+/g, ' ').trim();
+            const display = raw.length > cols - 8 ? raw.slice(0, cols - 11) + '...' : raw;
+            process.stdout.write('\n' + msgBg(('  > ' + display + ' ').padEnd(cols)) + '\n');
+        }
+        else {
+            const raw = String(msg.content);
+            const stripper = new TagStripper();
+            const renderer = new MarkdownRenderer();
+            const stripped = stripper.feed(raw) + stripper.flush();
+            const rendered = (renderer.format(stripped) + renderer.flush()).replace(/^\n+/, '');
+            if (rendered.trim())
+                process.stdout.write('\n' + rendered);
+            const allOps = parseOps(normalizeResponse(raw));
+            const readOps = allOps.filter(op => (op.type === 'read_file' && op.path) ||
+                (op.type === 'read_folder' && op.path) ||
+                (op.type === 'search_code' && op.pattern));
+            const fileOps = allOps.filter(op => op.type !== 'read_file' && op.type !== 'read_folder' && op.type !== 'search_code');
+            // ── File operation summaries ─────────────────────────────
+            if (fileOps.length > 0) {
+                const maxW = Math.min(cols - 12, 120);
+                const clip = (t) => t.length > maxW ? t.slice(0, maxW - 1) + '…' : t;
+                const renderDiffLines = (diff, maxLines = 60) => {
+                    const CONTEXT = 2;
+                    const show = new Uint8Array(diff.length);
+                    for (let i = 0; i < diff.length; i++) {
+                        if (diff[i].kind !== 'context') {
+                            for (let c = Math.max(0, i - CONTEXT); c <= Math.min(diff.length - 1, i + CONTEXT); c++)
+                                show[c] = 1;
+                        }
+                    }
+                    const renderLine = (line) => {
+                        const num = String(line.lineNo).padStart(5, ' ');
+                        if (line.kind === 'remove') {
+                            const content = `  ${num}  ${chalk.hex('#f87171')('-')}  ${clip(line.text)}`;
+                            process.stdout.write('  ' + chalk.hex('#7f1d1d')('▌') + chalk.bgHex('#1c0a0a')(content.padEnd(cols - 3)) + '\n');
+                        }
+                        else if (line.kind === 'add') {
+                            const content = `  ${num}  ${chalk.hex('#34d399')('+')}  ${clip(line.text)}`;
+                            process.stdout.write('  ' + chalk.hex('#065f46')('▌') + chalk.bgHex('#021a0e')(content.padEnd(cols - 3)) + '\n');
+                        }
+                        else {
+                            process.stdout.write(chalk.hex('#374151')(`       ${num}     ${clip(line.text)}\n`));
+                        }
+                    };
+                    // Build hunks
+                    const hunks = [];
+                    let curHunk = [];
+                    let lastIdx = -1;
+                    for (let i = 0; i < diff.length; i++) {
+                        if (!show[i])
+                            continue;
+                        if (lastIdx >= 0 && i > lastIdx + 1) {
+                            hunks.push(curHunk);
+                            curHunk = [];
+                        }
+                        lastIdx = i;
+                        curHunk.push(diff[i]);
+                    }
+                    if (curHunk.length > 0)
+                        hunks.push(curHunk);
+                    // Per-hunk: leading context, all removes, all adds, trailing context
+                    let shown = 0;
+                    for (let h = 0; h < hunks.length; h++) {
+                        if (shown >= maxLines)
+                            break;
+                        if (h > 0)
+                            process.stdout.write(chalk.hex('#374151')('        ╌╌╌\n'));
+                        const hunk = hunks[h];
+                        const before = [];
+                        const hRemoves = [];
+                        const hAdds = [];
+                        let pendingCtx = [];
+                        let seenChange = false;
+                        for (const line of hunk) {
+                            if (line.kind === 'context') {
+                                if (!seenChange)
+                                    before.push(line);
+                                else
+                                    pendingCtx.push(line);
+                            }
+                            else {
+                                seenChange = true;
+                                pendingCtx = [];
+                                if (line.kind === 'remove')
+                                    hRemoves.push(line);
+                                else
+                                    hAdds.push(line);
+                            }
+                        }
+                        for (const l of before)
+                            renderLine(l);
+                        for (const l of hRemoves) {
+                            if (shown >= maxLines)
+                                break;
+                            renderLine(l);
+                            shown++;
+                        }
+                        for (const l of hAdds) {
+                            if (shown >= maxLines)
+                                break;
+                            renderLine(l);
+                            shown++;
+                        }
+                        for (const l of pendingCtx)
+                            renderLine(l);
+                    }
+                    const total = diff.filter(d => d.kind !== 'context').length;
+                    if (total > maxLines) {
+                        process.stdout.write(chalk.hex('#4b5563')(`        … ${total - maxLines} more lines\n`));
+                    }
+                };
+                process.stdout.write('\n');
+                for (const op of fileOps) {
+                    if (op.type === 'write' && op.path && op.content !== undefined) {
+                        const oldContent = fileSnapshot.get(op.path) ?? fileSnapshot.get(op.path.replace(/\\/g, '/')) ?? '';
+                        const diff = computeDiff(oldContent, op.content);
+                        const adds = diff.filter(d => d.kind === 'add').length;
+                        const removes = diff.filter(d => d.kind === 'remove').length;
+                        const statStr = [
+                            removes > 0 ? chalk.hex('#f87171').bold(`-${removes}`) : '',
+                            adds > 0 ? chalk.hex('#34d399').bold(`+${adds}`) : '',
+                        ].filter(Boolean).join('  ');
+                        process.stdout.write(chalk.hex('#fbbf24')('  ~') + chalk.hex('#94a3b8')('  Updated  ') +
+                            chalk.hex('#e2e8f0')(op.path) + (statStr ? '   ' + statStr : '') + '\n');
+                        renderDiffLines(diff);
+                        // Update snapshot so subsequent ops see the new content
+                        fileSnapshot.set(op.path, op.content);
+                    }
+                    else if (op.type === 'edit' && op.path && op.find !== undefined && op.replace !== undefined) {
+                        const diff = computeDiff(op.find, op.replace);
+                        const adds = diff.filter(d => d.kind === 'add').length;
+                        const removes = diff.filter(d => d.kind === 'remove').length;
+                        const statStr = [
+                            removes > 0 ? chalk.hex('#f87171').bold(`-${removes}`) : '',
+                            adds > 0 ? chalk.hex('#34d399').bold(`+${adds}`) : '',
+                        ].filter(Boolean).join('  ');
+                        process.stdout.write(chalk.hex('#fbbf24')('  ~') + chalk.hex('#94a3b8')('  Updated  ') +
+                            chalk.hex('#e2e8f0')(op.path) + (statStr ? '   ' + statStr : '') + '\n');
+                        renderDiffLines(diff);
+                    }
+                    else if (op.type === 'run' && op.command) {
+                        process.stdout.write(colors.primary('  $') + '  ' + chalk.white(op.command) + '\n');
+                    }
+                    else if (op.type === 'delete' && op.path) {
+                        process.stdout.write(colors.error('  ✗') + chalk.hex('#94a3b8')('  Deleted  ') + colors.muted(op.path) + '\n');
+                    }
+                    else if (op.type === 'mkdir' && op.path) {
+                        process.stdout.write(colors.success('  ✓') + chalk.hex('#94a3b8')('  Created  ') + colors.muted(op.path) + '\n');
+                    }
+                }
+            }
+            // ── Read / search / folder summary (compact box) ────────
+            if (readOps.length > 0) {
+                const total = readOps.length;
+                const boxW = Math.min(Math.max(cols - 2, 52), 100);
+                const maxFnameW = Math.max(boxW - 10, 8);
+                const titleText = ` ${total} operation${total === 1 ? '' : 's'} `;
+                const dashCount = Math.max(boxW - 3 - titleText.length, 2);
+                process.stdout.write('\n  ' + BC('╭─') + colors.muted(titleText) + BC('─'.repeat(dashCount) + '╮') + '\n');
+                for (const op of readOps) {
+                    let label;
+                    if (op.type === 'search_code') {
+                        label = `search: "${op.pattern}"`;
+                    }
+                    else if (op.type === 'read_folder') {
+                        label = `folder: ${op.path}`;
+                    }
+                    else {
+                        label = op.path;
+                    }
+                    const disp = label.length > maxFnameW ? '…' + label.slice(-(maxFnameW - 1)) : label;
+                    const pad = ' '.repeat(Math.max(boxW - 7 - disp.length, 2));
+                    process.stdout.write('  ' + BC('│') + '  ' + colors.muted('✓') + '  ' + FC(disp) + pad + BC('│') + '\n');
+                }
+                process.stdout.write('  ' + BC('╰' + '─'.repeat(boxW - 2) + '╯') + '\n');
+            }
+        }
+    }
+}
+async function generateAITitle(userMsg, aiMsg, token) {
+    const msgs = [
+        { role: 'system', content: 'Generate a short 2-5 word English title for this conversation. Reply with ONLY the title words. No punctuation, no quotes.' },
+        { role: 'user', content: userMsg.slice(0, 400) },
+        { role: 'assistant', content: aiMsg.slice(0, 400) },
+        { role: 'user', content: 'Title:' },
+    ];
+    return new Promise((resolve) => {
+        let out = '';
+        streamChat(msgs, token, (chunk) => { out += chunk; }, () => {
+            const title = out.replace(/['"]/g, '').replace(/\s+/g, ' ').trim().slice(0, 50);
+            resolve(title || 'New Conversation');
+        }, () => resolve('New Conversation'));
+    });
+}
+async function showDesignModeLoader(skills) {
+    const P = chalk.hex('#a78bfa');
+    const G = chalk.hex('#34d399');
+    const D = chalk.hex('#6b7280');
+    const W = chalk.hex('#e2e8f0');
+    const FR = SPINNER_FRAMES;
+    const items = skills.length > 0 ? skills.slice(0, 8) : ['Preparing design system...'];
+    process.stdout.write('\n');
+    // ── Spinner ───────────────────────────────────────────────────
+    let fi = 0;
+    const spin = setInterval(() => {
+        process.stdout.write(`\r  ${P(FR[fi++ % FR.length])}  ${D('Loading Web Designer skill...')}`);
+    }, 60);
+    await new Promise(r => setTimeout(r, 500));
+    clearInterval(spin);
+    process.stdout.write('\r\x1b[K');
+    // ── Box with dynamic skill lines ─────────────────────────────
+    const cols = process.stdout.columns ?? 80;
+    const maxW = Math.max(...items.map(s => s.length), 30);
+    const lineW = Math.min(maxW + 8, cols - 6);
+    process.stdout.write('  ' + P('╭' + '─'.repeat(lineW)) + '\n');
+    for (const skill of items) {
+        let fi2 = 0;
+        const sp2 = setInterval(() => {
+            process.stdout.write(`\r  ${P('│')}  ${D(FR[fi2++ % FR.length])}  ${D(skill)}`);
+        }, 60);
+        await new Promise(r => setTimeout(r, 200));
+        clearInterval(sp2);
+        process.stdout.write(`\r  ${P('│')}  ${G('✓')}  ${W(skill)}\n`);
+    }
+    process.stdout.write('  ' + P('╰' + '─'.repeat(lineW)) + '\n');
+    // ── Final badge ───────────────────────────────────────────────
+    await new Promise(r => setTimeout(r, 100));
+    process.stdout.write('\n  ' + G('✓') + '  ' + chalk.hex('#c4b5fd').bold('Design') +
+        W(' mode activated') + '\n\n');
+}
+export async function startRepl(cwd) {
+    const alwaysAllowed = new Set();
+    const { email: userEmail } = getSavedUser();
+    // Fetch system prompt from server — never stored in package
+    const token = getToken() ?? '';
+    let SYSTEM_PROMPT = '';
+    if (token) {
+        const { prompt, webDesignerSkill } = await fetchSystemPrompt(token);
+        SYSTEM_PROMPT = prompt;
+        _serverWebDesignerSkill = webDesignerSkill;
+    }
+    // activeCwd can change when /resume loads a conversation from a different directory
+    let activeCwd = cwd;
+    const buildSystemMsg = (dir) => ({
+        role: 'system',
+        content: SYSTEM_PROMPT + '\n\nProject context:\n' + buildContext(dir),
+    });
+    const history = [buildSystemMsg(activeCwd)];
+    let sessionId = generateId();
+    const PROMPT = colors.primary('  › ');
+    let queuedResult = null;
+    let lastUserLine = '';
+    let lastAIResponse = '';
+    let readFileContinue = false;
+    let readFileTurnCount = 0; // resets each user message; caps read loops
+    let forcedEditMode = false; // blocks further read ops after limit
+    let conversationTitle = null;
+    let webDesignerActive = false;
+    let pendingOutputTokens = 0;
+    let pendingUserTokens = 0;
+    let hasPendingReport = false;
+    process.stdin.once('end', () => {
+        console.log(colors.muted('\n  Goodbye!\n'));
+        process.exit(0);
+    });
+    // Prevent any unhandled rejection from crashing the process — log to file for debugging
+    const ERROR_LOG = path.join(os.homedir(), '.dravix-code', 'error.log');
+    const logError = (label, err) => {
+        try {
+            const line = `[${new Date().toISOString()}] ${label}: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`;
+            fs.appendFileSync(ERROR_LOG, line);
+        }
+        catch { }
+    };
+    // Always restore terminal on any error — prevents keyboard from getting stuck
+    const resetTerminal = () => {
+        try {
+            process.stdin.setRawMode(false);
+        }
+        catch { }
+        try {
+            process.stdin.pause();
+        }
+        catch { }
+    };
+    process.on('exit', resetTerminal);
+    process.on('SIGINT', () => { resetTerminal(); process.exit(0); });
+    process.on('SIGTERM', () => { resetTerminal(); process.exit(0); });
+    process.on('unhandledRejection', (reason) => { logError('unhandledRejection', reason); resetTerminal(); });
+    process.on('uncaughtException', (err) => { logError('uncaughtException', err); resetTerminal(); });
+    // Set raw mode ONCE — never toggle it during the session to avoid CMD getting stuck
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    // Sequential loop — queued input lets user type during AI stream
+    while (true) {
+        try {
+            const cliTok = getToken() ?? '';
+            // Flush pending usage when starting a new user turn (all auto-continues are done)
+            if (!readFileContinue && hasPendingReport && cliTok) {
+                reportUsage(cliTok, Math.min(pendingUserTokens + pendingOutputTokens, 16000)).catch(() => { });
+                hasPendingReport = false;
+                pendingOutputTokens = 0;
+                pendingUserTokens = 0;
+            }
+            let result;
+            let skipInput = false;
+            if (readFileContinue) {
+                readFileContinue = false;
+                readFileTurnCount++;
+                if (readFileTurnCount > 3 && !forcedEditMode) {
+                    forcedEditMode = true;
+                    history.push({
+                        role: 'system',
+                        content: `[FORCED EDIT MODE] You have done ${readFileTurnCount} read/search operations — reads are now BLOCKED.\nYou MUST output a tag RIGHT NOW. No more explanation, no more searching:\n  • <edit_file path="..."><find>EXACT text from file</find><replace>new content</replace></edit_file>\n  • <write_file path="...">COMPLETE file content here</write_file>\nIf you are unsure of exact text → use <write_file> with the complete corrected content. OUTPUT THE TAG NOW.`,
+                    });
+                    process.stdout.write('\n' + colors.muted('  ⚠  Too many read operations — forced edit mode') + '\n');
+                }
+                else if (readFileTurnCount >= 2) {
+                    // Escalating signal: AI has read enough, must act now
+                    history.push({
+                        role: 'system',
+                        content: `[ACTION REQUIRED] You have done ${readFileTurnCount} read operations. STOP reading. You have enough context — output <edit_file> or <write_file> NOW. Do NOT search or read again. Output ONLY the tag.`,
+                    });
+                }
+                else {
+                    // First continuation: gentle signal
+                    history.push({ role: 'system', content: 'You now have the file content. Proceed with the task — output the edit or write tag directly, no explanation needed.' });
+                }
+                skipInput = true;
+                result = { text: '', lines: [] };
+            }
+            else if (queuedResult) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const q = queuedResult;
+                queuedResult = null;
+                result = q;
+                // Show queued message as if just submitted
+                const cols = process.stdout.columns ?? 80;
+                const msgBgQ = chalk.bgHex('#334155').hex('#f1f5f9');
+                process.stdout.write(msgBgQ(('  > ' + q.text + ' ').padEnd(cols)) + '\n');
+            }
+            else {
+                result = await readLine(PROMPT, activeCwd);
+            }
+            if (!result)
+                continue;
+            const { text: line } = result;
+            if (!skipInput)
+                lastUserLine = line;
+            // ── Slash commands ──────────────────────────────────────────
+            if (!skipInput && line.trim() === '/resume') {
+                const convId = await showConversationPicker();
+                if (convId) {
+                    const conv = loadConversation(convId);
+                    if (conv) {
+                        // Restore the original working directory so file ops work correctly
+                        activeCwd = conv.cwd;
+                        // Rebuild system message with the correct directory
+                        history[0] = buildSystemMsg(activeCwd);
+                        history.splice(1);
+                        history.push(...conv.messages);
+                        // Warn AI that file states may have changed since the saved session
+                        history.push({
+                            role: 'system',
+                            content: `[Resumed session] Working directory: ${activeCwd}\nFile contents may have changed since the last session. ALWAYS use <read_file> or <search_code> to get the CURRENT file content before editing. Never assume files match the conversation history.`,
+                        });
+                        sessionId = convId;
+                        conversationTitle = conv.title;
+                        printConversationHistory(conv.messages);
+                    }
+                }
+                continue;
+            }
+            if (!skipInput && line.startsWith('/')) {
+                await handleCommand(line, activeCwd, () => {
+                    activeCwd = cwd;
+                    history.splice(1);
+                    history[0] = buildSystemMsg(activeCwd);
+                    conversationTitle = null;
+                    sessionId = generateId();
+                }, (filePath, content) => {
+                    const existing = history.findIndex(m => m.role === 'system' && m.content.startsWith(`[Added file: ${filePath}]`));
+                    const msg = { role: 'system', content: `[Added file: ${filePath}]\n${content}` };
+                    if (existing !== -1)
+                        history[existing] = msg;
+                    else
+                        history.push(msg);
+                }, () => lastAIResponse || null, () => {
+                    if (lastUserLine)
+                        queuedResult = { text: lastUserLine, lines: [lastUserLine] };
+                });
+                continue;
+            }
+            if (!skipInput) {
+                readFileTurnCount = 0; // reset loop counter for each new user message
+                forcedEditMode = false; // reset forced edit mode for each new user message
+                // ── Refresh project context (files may have changed since last turn) ──
+                history[0] = buildSystemMsg(activeCwd);
+                // ── Clear stale operational messages left from previous auto-continue turns ──
+                // They pollute future user messages when prepareMessages merges consecutive roles.
+                const STALE_PREFIXES = ['[File updated]', '[SYSTEM LIMIT]', '[BLOCKED]', 'Please proceed with the task'];
+                for (let i = history.length - 1; i > 0; i--) {
+                    if (history[i].role === 'system' &&
+                        STALE_PREFIXES.some(p => history[i].content.startsWith(p))) {
+                        history.splice(i, 1);
+                    }
+                }
+                // ── Trim history: keep system[0] + last 20 messages ──
+                if (history.length > 22) {
+                    history.splice(1, history.length - 22);
+                }
+                // ── Auto-inject mentioned file contents ──────────────────────
+                // Files ≤ 3000 lines: full raw content injected — AI has exact text for <find>, no reads needed.
+                // Files > 3000 lines: first 300 lines preview + AI does ONE <read_file> to get target section.
+                const FILE_PATTERN = /[\w\-.\/\\]+\.\w{2,5}/g;
+                const mentioned = [...new Set(line.match(FILE_PATTERN) ?? [])];
+                let fileContext = '';
+                const FULL_INJECT_LINES = 3000;
+                for (const fname of mentioned) {
+                    const fullPath = path.resolve(activeCwd, fname);
+                    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf-8');
+                            const lines = content.split('\n');
+                            const lineCount = lines.length;
+                            if (lineCount <= FULL_INJECT_LINES) {
+                                fileContext += `\n\n[File: ${fname} — FULL CONTENT — ${lineCount} lines]\n` +
+                                    `⚠ Complete file is here — do NOT use <read_file> for this file. Use <edit_file> directly.\n\n` +
+                                    content;
+                            }
+                            else {
+                                // Very large file (>3000 lines): preview + single read instruction
+                                const preview = lines.slice(0, 300).join('\n');
+                                fileContext += `\n\n[File: ${fname} — ${lineCount} lines — first 300 lines shown]\n` +
+                                    `⚠ Use <read_file path="${fname}"/> (no lines=) to get full content, then edit.\n\n` +
+                                    preview +
+                                    `\n\n... (${lineCount - 300} more lines)`;
+                            }
+                        }
+                        catch { /* skip unreadable */ }
+                    }
+                }
+                history.push({ role: 'user', content: fileContext ? line + fileContext : line });
+            }
+            // ── Token limit check ────────────────────────────────────────
+            if (cliTok && !skipInput) {
+                const usage = await checkUsage(cliTok);
+                if (usage && !usage.allowed) {
+                    const resetStr = formatResetTime(usage);
+                    process.stdout.write('\n');
+                    process.stdout.write('  ' + colors.error('✗') + '  ' + chalk.hex('#e2e8f0').bold('Daily token limit reached') + '\n' +
+                        '  ' + colors.muted(`   ${fmtNum(usage.tokens_used)} / ${fmtNum(usage.limit)} tokens used`) + '\n' +
+                        '  ' + colors.muted(`   Resets in ${resetStr}`) +
+                        (usage.is_plus ? '' : '  ' + chalk.hex('#fcd34d')('· Upgrade to Plus for 100k tokens/day')) + '\n\n');
+                    continue;
+                }
+                // Warning when >80% used
+                if (usage && usage.tokens_used / usage.limit >= 0.8) {
+                    const { bar, pct } = usageBar(usage.tokens_used, usage.limit, 14);
+                    process.stdout.write('\n  ' + colors.warn('⚠') + '  ' + chalk.hex('#fbbf24')(`Token limit: ${pct}% used`) + '  ' +
+                        chalk.hex('#f87171')(bar) + '  ' +
+                        colors.muted(`${fmtNum(usage.remaining)} remaining · resets in ${formatResetTime(usage)}`) + '\n');
+                }
+            }
+            // ── Ctrl+C cancel during streaming ──────────────────────────
+            let streamCancelled = false;
+            const streamAbort = new AbortController();
+            const onStreamKey = (data) => {
+                try {
+                    if (data === '\x03') {
+                        streamCancelled = true;
+                        streamAbort.abort();
+                    }
+                }
+                catch { /* ignore */ }
+            };
+            process.stdin.on('data', onStreamKey);
+            // ── Spinner ──────────────────────────────────────────────────
+            if (!skipInput)
+                process.stdout.write('\n');
+            let frameIdx = 0;
+            const aiStart = Date.now();
+            const spinnerInterval = setInterval(() => {
+                process.stdout.write(`\r\x1b[K  ${colors.muted(SPINNER_FRAMES[frameIdx++ % SPINNER_FRAMES.length])}  ${colors.muted('Thinking...')}`);
+            }, 80);
+            // ── Stream AI response ──────────────────────────────────────
+            let fullResponse = '';
+            let streamStarted = false;
+            let inStreamingOp = false;
+            let streamOpLabel = '';
+            let streamOpFrame = 0;
+            let streamOpInterval = null;
+            let showingMidLoader = false;
+            let midStreamFrame = 0;
+            let midStreamInterval = null;
+            // ── Inline op execution (write/edit/delete run inline as tags complete) ──
+            const executedInlineOps = new Set();
+            let inlineOpRunning = false;
+            let inlineTextQueue = ''; // AI text buffered while inline op runs
+            const inlineFileOpErrors = [];
+            const inlineSkippedPaths = new Set();
+            const inlineOpFingerprint = (op) => JSON.stringify({
+                t: op.type, p: op.path ?? null,
+                f: op.find ? op.find.slice(0, 200) : null,
+                r: op.replace ? op.replace.slice(0, 200) : null,
+                c: op.content ? op.content.length + ':' + op.content.slice(0, 100) : null,
+                cmd: op.command ?? null,
+            });
+            const runInlineOp = async (op) => {
+                inlineOpRunning = true;
+                try {
+                    // Clear any active streaming spinner before showing the permission dialog
+                    if (streamOpInterval) {
+                        clearInterval(streamOpInterval);
+                        streamOpInterval = null;
+                    }
+                    if (inStreamingOp) {
+                        process.stdout.write('\r\x1b[K');
+                        inStreamingOp = false;
+                        streamOpLabel = '';
+                        streamOpFrame = 0;
+                    }
+                    if (midStreamTimer)
+                        clearTimeout(midStreamTimer);
+                    if (midStreamInterval) {
+                        clearInterval(midStreamInterval);
+                        midStreamInterval = null;
+                        showingMidLoader = false;
+                    }
+                    if (showingMidLoader) {
+                        process.stdout.write('\r\x1b[K');
+                        showingMidLoader = false;
+                    }
+                    if (hasRenderedContent && trailingNLs === 0)
+                        process.stdout.write('\n');
+                    const label = opLabel(op, activeCwd);
+                    const key = opKey(op, activeCwd);
+                    const depSkipped = op.type === 'run' && op.command &&
+                        [...inlineSkippedPaths].some(p => op.command.includes(path.basename(p)));
+                    if (depSkipped) {
+                        process.stdout.write(`  ${colors.muted('○')}  ${colors.muted('Skipped: ' + label + ' (dependency missing)')}\n`);
+                        executedInlineOps.add(inlineOpFingerprint(op));
+                    }
+                    else {
+                        const allowed = await askPermission(label, key, alwaysAllowed, op.type === 'run');
+                        executedInlineOps.add(inlineOpFingerprint(op));
+                        if (!allowed) {
+                            if (op.path)
+                                inlineSkippedPaths.add(op.path);
+                        }
+                        else {
+                            let stageSpinInterval2 = null;
+                            let stageSpinFrame2 = 0;
+                            let stageSpinMsg2 = '';
+                            const opResult = await executeSingleOp(op, activeCwd, (msg) => {
+                                stageSpinMsg2 = msg;
+                                if (!stageSpinInterval2) {
+                                    stageSpinFrame2 = 0;
+                                    stageSpinInterval2 = setInterval(() => {
+                                        const f = SPINNER_FRAMES[stageSpinFrame2++ % SPINNER_FRAMES.length];
+                                        process.stdout.write(`\r\x1b[K  ${colors.muted(f)}  ${chalk.hex('#94a3b8')(stageSpinMsg2)}`);
+                                    }, 80);
+                                }
+                            });
+                            if (stageSpinInterval2) {
+                                clearInterval(stageSpinInterval2);
+                                stageSpinInterval2 = null;
+                            }
+                            process.stdout.write('\r\x1b[K');
+                            printOpResult(opResult);
+                            if (opResult.type === 'error' && op.type !== 'run') {
+                                // If text not found, include current file content so AI can retry accurately
+                                let errMsg = `[Operation failed — ${label}]: ${opResult.message ?? 'Unknown error'}`;
+                                if (opResult.message?.includes('not found') && op.path) {
+                                    try {
+                                        const fp = path.resolve(activeCwd, op.path);
+                                        if (fs.existsSync(fp)) {
+                                            const cur = fs.readFileSync(fp, 'utf-8');
+                                            const nLines = cur.split('\n').length;
+                                            if (nLines <= 400) {
+                                                errMsg += `\n\nCurrent content of ${op.path}:\n${cur}\n\nUse <write_file> with the complete corrected content.`;
+                                            }
+                                            else {
+                                                errMsg += `\n\nFile has ${nLines} lines. Use the correct workflow:\n  1. <search_code pattern="first few words of what you want to find" path="${op.path}"/> — get line number\n  2. <read_file path="${op.path}" lines="N-M"/> — read that exact section\n  3. Copy the EXACT text (after the tab, without line numbers) into <find>`;
+                                            }
+                                        }
+                                    }
+                                    catch { /* ignore */ }
+                                }
+                                inlineFileOpErrors.push(errMsg);
+                            }
+                            else if ((opResult.type === 'modified' || opResult.type === 'created') && op.path &&
+                                (op.type === 'edit' || op.type === 'write')) {
+                                // After a successful edit, inject a note so AI knows the file changed
+                                // This prevents subsequent <edit_file> ops from using stale <find> text
+                                history.push({
+                                    role: 'system',
+                                    content: `[File updated] ${op.path} was just modified by a previous operation in this response. If you have more edits for this file, use <read_file path="${op.path}"/> first to get the current content before using <edit_file>, or use <write_file> with the complete new content.`,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+                inlineOpRunning = false;
+                trailingNLs = 1;
+                // Flush buffered AI text that arrived while op was running
+                if (inlineTextQueue) {
+                    const vis = renderer.format(inlineTextQueue);
+                    inlineTextQueue = '';
+                    if (vis) {
+                        process.stdout.write(vis);
+                        hasRenderedContent = true;
+                        const trail = vis.match(/(\n+)$/);
+                        trailingNLs = trail ? trail[1].length : 0;
+                    }
+                }
+                // Check if more ops became complete while this op was running
+                checkForNextInlineOp();
+            };
+            const checkForNextInlineOp = () => {
+                if (inlineOpRunning)
+                    return;
+                // Don't run inline ops in design_mode — let the post-stream flow handle them
+                if (fullResponse.includes('<design_mode>'))
+                    return;
+                const allParsed = parseOps(normalizeResponse(fullResponse));
+                // Only write/edit/delete/mkdir ops are executed inline — run/read ops stay post-stream
+                const writeOps = allParsed.filter(op => op.type === 'write' || op.type === 'edit' || op.type === 'delete' || op.type === 'mkdir');
+                const nextOp = writeOps.find(op => !executedInlineOps.has(inlineOpFingerprint(op)));
+                if (nextOp)
+                    runInlineOp(nextOp);
+            };
+            let midStreamTimer = null;
+            let hasRenderedContent = false;
+            let trailingNLs = 0; // trailing newlines written by AI text renders
+            const stripper = new TagStripper();
+            const renderer = new MarkdownRenderer();
+            const token = getToken() ?? '';
+            await new Promise((resolve) => {
+                streamChat(history, token, (chunk) => {
+                    fullResponse += chunk;
+                    if (!streamStarted) {
+                        streamStarted = true;
+                        clearInterval(spinnerInterval);
+                        process.stdout.write('\r\x1b[K');
+                        trailingNLs = 1; // cursor on cleared line = effectively blank line start
+                    }
+                    // ── Clear mid-stream loader ────────────────────────────
+                    if (showingMidLoader) {
+                        if (midStreamInterval) {
+                            clearInterval(midStreamInterval);
+                            midStreamInterval = null;
+                        }
+                        process.stdout.write('\r\x1b[K');
+                        showingMidLoader = false;
+                        trailingNLs = 1;
+                    }
+                    // Reset mid-stream pause timer
+                    if (midStreamTimer)
+                        clearTimeout(midStreamTimer);
+                    midStreamTimer = setTimeout(() => {
+                        if (!inStreamingOp && !inlineOpRunning) {
+                            showingMidLoader = true;
+                            midStreamFrame = 0;
+                            midStreamInterval = setInterval(() => {
+                                const f = SPINNER_FRAMES[midStreamFrame++ % SPINNER_FRAMES.length];
+                                process.stdout.write(`\r\x1b[K  ${colors.muted(f)}  ${colors.muted('Processing...')}`);
+                            }, 80);
+                        }
+                    }, 900);
+                    // ── Visible text ────────────────────────────────────────
+                    const stripped = stripper.feed(chunk);
+                    const visible = stripped ? renderer.format(stripped) : '';
+                    if (visible) {
+                        if (inStreamingOp && !inlineOpRunning) {
+                            if (streamOpInterval) {
+                                clearInterval(streamOpInterval);
+                                streamOpInterval = null;
+                            }
+                            process.stdout.write('\r\x1b[K');
+                            inStreamingOp = false;
+                            streamOpLabel = '';
+                            streamOpFrame = 0;
+                        }
+                        const toPrint = hasRenderedContent ? visible : visible.replace(/^\n+/, '');
+                        if (toPrint) {
+                            if (toPrint.trim())
+                                hasRenderedContent = true;
+                            if (hasRenderedContent) {
+                                if (inlineOpRunning) {
+                                    inlineTextQueue += toPrint; // buffer while op runs
+                                }
+                                else {
+                                    process.stdout.write(toPrint);
+                                    const trail = toPrint.match(/(\n+)$/);
+                                    trailingNLs = trail ? trail[1].length : 0;
+                                }
+                            }
+                        }
+                    }
+                    // ── Check for newly complete inline ops (write/edit/delete) ──
+                    if (!inlineOpRunning)
+                        checkForNextInlineOp();
+                    // ── Animate spinner while tag is still being generated ──────
+                    if (!inlineOpRunning) {
+                        const currentOp = detectActiveStreamingOp(fullResponse);
+                        if (currentOp && !inStreamingOp) {
+                            inStreamingOp = true;
+                            streamOpLabel = currentOp;
+                            streamOpFrame = 0;
+                            if (hasRenderedContent && trailingNLs === 0)
+                                process.stdout.write('\n');
+                            process.stdout.write(`\r\x1b[K  ${colors.muted(SPINNER_FRAMES[0])}  ${chalk.hex('#94a3b8')(streamOpLabel)}`);
+                            streamOpInterval = setInterval(() => {
+                                streamOpFrame = (streamOpFrame + 1) % SPINNER_FRAMES.length;
+                                process.stdout.write(`\r\x1b[K  ${colors.muted(SPINNER_FRAMES[streamOpFrame])}  ${chalk.hex('#94a3b8')(streamOpLabel)}`);
+                            }, 80);
+                        }
+                        else if (currentOp && inStreamingOp && currentOp !== streamOpLabel) {
+                            streamOpLabel = currentOp;
+                        }
+                        else if (!currentOp && inStreamingOp) {
+                            if (streamOpInterval) {
+                                clearInterval(streamOpInterval);
+                                streamOpInterval = null;
+                            }
+                            process.stdout.write('\r\x1b[K');
+                            inStreamingOp = false;
+                            streamOpLabel = '';
+                            streamOpFrame = 0;
+                            trailingNLs = 1;
+                        }
+                    }
+                }, async () => {
+                    clearInterval(spinnerInterval);
+                    if (midStreamTimer)
+                        clearTimeout(midStreamTimer);
+                    if (midStreamInterval) {
+                        clearInterval(midStreamInterval);
+                        midStreamInterval = null;
+                    }
+                    if (streamOpInterval) {
+                        clearInterval(streamOpInterval);
+                        streamOpInterval = null;
+                    }
+                    if (showingMidLoader || inStreamingOp)
+                        process.stdout.write('\r\x1b[K');
+                    showingMidLoader = false;
+                    inStreamingOp = false;
+                    const tail = stripper.flush();
+                    if (tail) {
+                        const tV = renderer.format(tail);
+                        if (tV) {
+                            hasRenderedContent = true;
+                            process.stdout.write(tV);
+                        }
+                    }
+                    const rest = renderer.flush();
+                    if (rest) {
+                        hasRenderedContent = true;
+                        process.stdout.write(rest);
+                    }
+                    if (!streamStarted) {
+                        clearInterval(spinnerInterval);
+                        process.stdout.write('\r\x1b[K\n');
+                    }
+                    // ── Cancelled by user (Ctrl+C) ────────────────────────
+                    if (streamCancelled) {
+                        process.stdout.write('\r\x1b[K');
+                        if (hasRenderedContent && trailingNLs === 0)
+                            process.stdout.write('\n');
+                        process.stdout.write('\n  ' + colors.muted('◼  Cancelled\n'));
+                        if (fullResponse.trim()) {
+                            history.push({ role: 'assistant', content: normalizeResponse(fullResponse) });
+                        }
+                        resolve();
+                        return;
+                    }
+                    const normalized = normalizeResponse(fullResponse);
+                    lastAIResponse = normalized;
+                    history.push({ role: 'assistant', content: normalized });
+                    if (conversationTitle === null) {
+                        const _msgs = history.slice(1).filter(m => m.role === 'user' || m.role === 'assistant');
+                        const _u = _msgs.find(m => m.role === 'user');
+                        const _a = _msgs.find(m => m.role === 'assistant');
+                        if (_u && _a) {
+                            generateAITitle(String(_u.content), String(_a.content), token).then(t => {
+                                conversationTitle = t;
+                                saveConversation(sessionId, t, activeCwd, history.slice(1));
+                            }).catch(() => { });
+                        }
+                    }
+                    // Wait for any inline op still executing before touching stdout
+                    while (inlineOpRunning)
+                        await new Promise(r => setTimeout(r, 20));
+                    // ── design_mode tag → activate Web Designer skill ────────
+                    const designMatch = fullResponse.match(/<design_mode>([\s\S]*?)<\/design_mode>/);
+                    if (!webDesignerActive && designMatch) {
+                        webDesignerActive = true;
+                        history[0] = { role: 'system', content: history[0].content + _serverWebDesignerSkill };
+                        const skills = designMatch[1]
+                            .split('\n')
+                            .map(l => l.trim())
+                            .filter(Boolean);
+                        await showDesignModeLoader(skills);
+                        history.push({ role: 'system', content: '[Web Designer mode is now active. Apply all design guidelines from your system prompt. Proceed to build the website now.]' });
+                        readFileContinue = true;
+                    }
+                    // Run any ops that became complete just as stream ended
+                    checkForNextInlineOp();
+                    while (inlineOpRunning)
+                        await new Promise(r => setTimeout(r, 20));
+                    // Add inline op errors to history so AI can retry
+                    if (inlineFileOpErrors.length > 0) {
+                        history.push({ role: 'system', content: inlineFileOpErrors.join('\n\n') + '\n\nFix the above errors and retry the failed operations.' });
+                        readFileContinue = true;
+                    }
+                    const allOps = parseOps(normalized);
+                    // ── Detect incomplete plan: AI described steps but didn't output tags ──
+                    // Pattern: response has numbered items like "2. something" or "3. something"
+                    // but very few actual file operation tags were output → force continuation
+                    if (!readFileContinue && !streamCancelled) {
+                        const plannedSteps = (normalized.match(/^\s*[2-9]\.\s+\S/mg) ?? []).length;
+                        const executedOps = allOps.filter(op => op.type !== 'read_file' && op.type !== 'read_folder' && op.type !== 'search_code').length;
+                        if (plannedSteps >= 1 && executedOps === 0 && !allOps.length) {
+                            history.push({ role: 'system', content: 'You described the steps but did not output any <edit_file> or <write_file> tags. Output the actual tags NOW to apply the changes. No more descriptions — just the tags.' });
+                            readFileContinue = true;
+                        }
+                    }
+                    const readOps = allOps.filter(op => op.type === 'read_file' || op.type === 'read_folder' || op.type === 'search_code');
+                    // Skip ops already executed inline (write/edit/delete/mkdir)
+                    const ops = allOps.filter(op => op.type !== 'read_file' && op.type !== 'read_folder' && op.type !== 'search_code' &&
+                        !executedInlineOps.has(inlineOpFingerprint(op)));
+                    // Trailing newline — skip when read ops follow (they start on current line)
+                    if (hasRenderedContent && readOps.length === 0)
+                        process.stdout.write('\n');
+                    // ── Handle read_file ops ──────────────────────────────
+                    // forcedEditMode: block further reads — AI must use existing context
+                    if (readOps.length > 0 && forcedEditMode) {
+                        history.push({
+                            role: 'system',
+                            content: `[BLOCKED] Read/search ops are blocked (limit reached). Use the file content already in context to make edits. Do NOT request more reads.`,
+                        });
+                        readFileContinue = true;
+                    }
+                    else if (readOps.length > 0) {
+                        // Absorb blank lines so reading block starts immediately after user message
+                        if (hasRenderedContent) {
+                            // Ensure cursor is on a new line, then absorb excess trailing blank lines
+                            if (trailingNLs === 0)
+                                process.stdout.write('\n');
+                            const excess = Math.max((trailingNLs || 1) - 1, 0);
+                            for (let i = 0; i < excess; i++)
+                                process.stdout.write('\x1b[1A\x1b[2K');
+                        }
+                        else if (!skipInput) {
+                            // No AI text — absorb the blank line from main loop's \n
+                            const lines = streamStarted ? 1 : 2;
+                            for (let i = 0; i < lines; i++)
+                                process.stdout.write('\x1b[1A\x1b[2K');
+                        }
+                        (async () => {
+                            try {
+                                const validOps = readOps.filter(op => (op.type === 'read_file' && op.path) ||
+                                    (op.type === 'read_folder' && op.path) ||
+                                    (op.type === 'search_code' && op.pattern));
+                                const total = validOps.length;
+                                if (total === 0) {
+                                    readFileContinue = true;
+                                    resolve();
+                                    return;
+                                }
+                                const cols = process.stdout.columns ?? 80;
+                                const boxW = Math.min(Math.max(cols - 2, 52), 100);
+                                const BC = chalk.hex('#4338ca');
+                                const FC = chalk.hex('#e2e8f0');
+                                const RIGHT_W = 22;
+                                const LABEL_W = Math.max(boxW - 11 - RIGHT_W, 8);
+                                const results = [];
+                                for (const op of validOps) {
+                                    let spinLabel = '';
+                                    let spinColor = chalk.hex('#818cf8');
+                                    if (op.type === 'search_code') {
+                                        spinLabel = `Searching   ${chalk.white('"' + (op.pattern ?? '') + '"')}`;
+                                        spinColor = chalk.hex('#f59e0b');
+                                    }
+                                    else if (op.type === 'read_folder') {
+                                        spinLabel = `Reading     ${chalk.white(op.path ?? '')}`;
+                                        spinColor = chalk.hex('#818cf8');
+                                    }
+                                    else {
+                                        spinLabel = `Reading     ${chalk.white(op.path ?? '')}`;
+                                        spinColor = chalk.hex('#818cf8');
+                                    }
+                                    let rfFrame = 0;
+                                    const spinLine = () => `\r\x1b[K  ${colors.muted(SPINNER_FRAMES[rfFrame])}  ${spinColor(spinLabel)}`;
+                                    process.stdout.write(spinLine());
+                                    const rfInterval = setInterval(() => {
+                                        rfFrame = (rfFrame + 1) % SPINNER_FRAMES.length;
+                                        process.stdout.write(spinLine());
+                                    }, 80);
+                                    const t0 = Date.now();
+                                    const res = await executeSingleOp(op, activeCwd);
+                                    const ms = Date.now() - t0;
+                                    clearInterval(rfInterval);
+                                    if (res.type === 'run') {
+                                        let ctxLabel = '';
+                                        let displayLabel = '';
+                                        let rightCol = '';
+                                        if (op.type === 'search_code') {
+                                            ctxLabel = `[Search results — "${op.pattern}"${op.path ? ` in "${op.path}"` : ''}]:\n${res.output ?? ''}`;
+                                            const lastLine = (res.output ?? '').split('\n').filter(Boolean).pop() ?? '';
+                                            rightCol = chalk.hex('#6b7280')(lastLine.startsWith('Total:') ? lastLine.slice(7).trim() : `${ms}ms`);
+                                            displayLabel = `"${op.pattern}"`;
+                                        }
+                                        else if (op.type === 'read_folder') {
+                                            ctxLabel = `[Folder contents — "${op.path}"]:\n${res.output ?? ''}`;
+                                            const firstLine = (res.output ?? '').split('\n')[0] ?? '';
+                                            const counts = firstLine.match(/\((.+)\)/);
+                                            rightCol = chalk.hex('#6b7280')(counts ? counts[1] : `${ms}ms`);
+                                            displayLabel = op.path ?? '';
+                                        }
+                                        else {
+                                            const lineTag = op.lines ? `[lines=${op.lines}]` : '[full]';
+                                            ctxLabel = `[File content — ${res.message ?? op.path}]${lineTag}:\n${res.output ?? ''}`;
+                                            rightCol = chalk.hex('#6b7280')(op.lines ? `lines ${op.lines}` : `${ms}ms`);
+                                            displayLabel = op.lines ? `${op.path ?? ''} :${op.lines}` : (op.path ?? '');
+                                            // Auto-continue paginated reads: if file has more pages, queue next page automatically
+                                            const pageMatch = (res.output ?? '').match(/\.\.\. \((\d+) more lines — next page: lines (\d+)-(\d+)\)/);
+                                            if (pageMatch && op.path) {
+                                                const [, , nextStart, nextEnd] = pageMatch;
+                                                history.push({
+                                                    role: 'system',
+                                                    content: `[Auto-reading next page of ${op.path}...]`,
+                                                });
+                                                // Queue the next page read by injecting it as a system op
+                                                validOps.push({ type: 'read_file', path: op.path, lines: `${nextStart}-${nextEnd}` });
+                                            }
+                                        }
+                                        // Deduplicate: don't push the exact same read twice in recent history
+                                        // For read_file with lines=, include the range so different sections are NOT deduped
+                                        const dupKey = op.type === 'read_file'
+                                            ? `[File content — ${res.message ?? op.path}]${op.lines ? `[lines=${op.lines}]` : '[full]'}`
+                                            : op.type === 'read_folder'
+                                                ? `[Folder contents — "${op.path}"]`
+                                                : null;
+                                        const alreadyInHistory = dupKey
+                                            ? history.slice(-8).some(m => m.role === 'system' && m.content.includes(dupKey))
+                                            : false;
+                                        if (!alreadyInHistory) {
+                                            history.push({ role: 'system', content: ctxLabel });
+                                        }
+                                        results.push({ label: displayLabel, right: rightCol, ok: true, contextMsg: ctxLabel });
+                                    }
+                                    else {
+                                        const displayLabel = op.type === 'search_code'
+                                            ? `"${op.pattern ?? ''}"`
+                                            : (op.path ?? '');
+                                        results.push({ label: displayLabel, right: chalk.hex('#f87171')('err'), ok: false, contextMsg: '' });
+                                    }
+                                }
+                                // ── Phase 2: summary box ────────────────────────────────
+                                process.stdout.write('\r\x1b[K');
+                                const hasSearch = validOps.some(o => o.type === 'search_code');
+                                const hasFolder = validOps.some(o => o.type === 'read_folder');
+                                const hasFiles = validOps.some(o => o.type === 'read_file');
+                                const titleParts = [];
+                                if (hasSearch)
+                                    titleParts.push(`Search`);
+                                if (hasFolder)
+                                    titleParts.push(`Folder`);
+                                if (hasFiles)
+                                    titleParts.push(total === 1 ? '1 file' : `${total} files`);
+                                const titleText = ` ${titleParts.join(' · ')} `;
+                                const dashCount = Math.max(boxW - 3 - titleText.length, 2);
+                                process.stdout.write(`  ` + BC('╭─') + colors.primary.bold(titleText) + BC('─'.repeat(dashCount) + '╮') + `\n`);
+                                for (const r of results) {
+                                    const icon = r.ok ? colors.success('✓') : colors.error('✗');
+                                    const disp = r.label.length > LABEL_W
+                                        ? '…' + r.label.slice(-(LABEL_W - 1))
+                                        : r.label;
+                                    const labelPad = ' '.repeat(Math.max(LABEL_W - disp.length, 0));
+                                    const rightVis = stripAnsi(r.right);
+                                    const rightPad = ' '.repeat(Math.max(RIGHT_W - rightVis.length, 0));
+                                    process.stdout.write(`  ` + BC('│') + `  ` + icon + `  ` + FC(disp) + labelPad + `  ` + r.right + rightPad + `  ` + BC('│') + `\n`);
+                                }
+                                process.stdout.write(`  ` + BC('╰' + '─'.repeat(boxW - 2) + '╯') + `\n`);
+                                readFileContinue = true;
+                                resolve();
+                            }
+                            catch (e) {
+                                logError('readOps', e);
+                                resolve();
+                            }
+                        })();
+                        return;
+                    } // end else if (readOps.length > 0)
+                    if (ops.length > 0) {
+                        (async () => {
+                            try {
+                                const skippedPaths = new Set();
+                                const runOutputs = [];
+                                const fileOpErrors = [];
+                                const declinedCmds = [];
+                                for (const op of ops) {
+                                    const label = opLabel(op, activeCwd);
+                                    const key = opKey(op, activeCwd);
+                                    if (op.type === 'run' && op.command) {
+                                        const depSkipped = [...skippedPaths].some(p => op.command.includes(path.basename(p)));
+                                        if (depSkipped) {
+                                            process.stdout.write(`  ${colors.muted('○')}  ${colors.muted('Skipped: ' + label)}  ${colors.muted('(dependency missing)')}\n`);
+                                            continue;
+                                        }
+                                    }
+                                    const allowed = await askPermission(label, key, alwaysAllowed, op.type === 'run');
+                                    if (!allowed) {
+                                        if (op.path)
+                                            skippedPaths.add(op.path);
+                                        if (op.type === 'run' && op.command)
+                                            declinedCmds.push(op.command);
+                                        continue;
+                                    }
+                                    let stageSpinInterval = null;
+                                    let stageSpinFrame = 0;
+                                    let stageSpinMsg = '';
+                                    const opResult = await executeSingleOp(op, activeCwd, (stageMsg) => {
+                                        stageSpinMsg = stageMsg;
+                                        if (!stageSpinInterval) {
+                                            stageSpinFrame = 0;
+                                            stageSpinInterval = setInterval(() => {
+                                                const f = SPINNER_FRAMES[stageSpinFrame++ % SPINNER_FRAMES.length];
+                                                process.stdout.write(`\r\x1b[K  ${colors.muted(f)}  ${chalk.hex('#94a3b8')(stageSpinMsg)}`);
+                                            }, 80);
+                                        }
+                                    });
+                                    if (stageSpinInterval) {
+                                        clearInterval(stageSpinInterval);
+                                        stageSpinInterval = null;
+                                    }
+                                    process.stdout.write('\r\x1b[K');
+                                    printOpResult(opResult);
+                                    // Collect file operation errors for AI feedback
+                                    if (opResult.type === 'error' && op.type !== 'run') {
+                                        fileOpErrors.push(`[Operation failed — ${label}]: ${opResult.message ?? 'Unknown error'}`);
+                                    }
+                                    if (op.type === 'run' && op.command) {
+                                        if (opResult.type === 'run') {
+                                            runOutputs.push({ cmd: op.command, output: opResult.output || '(command executed successfully — no terminal output)', isError: false });
+                                        }
+                                        else if (opResult.type === 'error') {
+                                            runOutputs.push({ cmd: op.command, output: opResult.message ?? 'Unknown error', isError: true });
+                                        }
+                                    }
+                                }
+                                if (runOutputs.length > 0) {
+                                    const NO_OUTPUT_MARKER = '(command executed successfully — no terminal output)';
+                                    const content = runOutputs.map(r => r.isError
+                                        ? `[Command failed — ${r.cmd}]:\n${r.output}`
+                                        : `[Command output — ${r.cmd}]:\n${r.output}`).join('\n\n');
+                                    history.push({ role: 'system', content });
+                                    // Only auto-continue if there is real output to react to, or an error to explain
+                                    const needsReaction = runOutputs.some(r => r.isError || r.output !== NO_OUTPUT_MARKER);
+                                    if (needsReaction)
+                                        readFileContinue = true;
+                                }
+                                // ── Feed file operation errors back to AI so it can retry ──
+                                if (fileOpErrors.length > 0) {
+                                    history.push({ role: 'system', content: fileOpErrors.join('\n\n') + '\n\nFix the above errors and retry the failed operations.' });
+                                    readFileContinue = true;
+                                }
+                                if (declinedCmds.length > 0) {
+                                    const content = declinedCmds.map(cmd => `[User declined to run — ${cmd}]: User pressed No. Do not retry or ask about this command.`).join('\n\n');
+                                    history.push({ role: 'system', content });
+                                    // No readFileContinue — AI already responded; wait for user's next message
+                                }
+                                resolve();
+                            }
+                            catch (e) {
+                                logError('ops', e);
+                                resolve();
+                            }
+                        })();
+                    }
+                    else {
+                        resolve();
+                    }
+                }, (err) => {
+                    clearInterval(spinnerInterval);
+                    if (midStreamTimer)
+                        clearTimeout(midStreamTimer);
+                    if (midStreamInterval) {
+                        clearInterval(midStreamInterval);
+                        midStreamInterval = null;
+                    }
+                    if (streamOpInterval) {
+                        clearInterval(streamOpInterval);
+                        streamOpInterval = null;
+                    }
+                    process.stdout.write('\r\x1b[K');
+                    const raw = err.message;
+                    const msg = raw.includes('timed out')
+                        ? 'Connection timed out — check your internet and try again'
+                        : raw.includes('401') || raw.includes('403') || raw.includes('Unauthorized')
+                            ? 'Authentication error — run  dravix --login  to sign in again'
+                            : raw.includes('429') || raw.includes('rate')
+                                ? 'Rate limit reached — please wait a moment and try again'
+                                : raw.includes('500') || raw.includes('502') || raw.includes('503')
+                                    ? 'Server error — the AI service is temporarily unavailable'
+                                    : raw;
+                    printError(msg);
+                    resolve();
+                }, streamAbort.signal);
+            });
+            // ── Remove streaming key listener ─────────────────────────
+            process.stdin.removeListener('data', onStreamKey);
+            // ── Accumulate token usage (deferred — report on next user turn) ──
+            if (cliTok && fullResponse) {
+                pendingOutputTokens += estimateTokens(normalizeResponse(fullResponse));
+                if (!skipInput && lastUserLine) {
+                    pendingUserTokens = estimateTokens(lastUserLine);
+                    hasPendingReport = true;
+                }
+            }
+            // ── Auto-save conversation ────────────────────────────────
+            const chatMsgs = history.slice(1).filter(m => m.role === 'user' || m.role === 'assistant');
+            if (chatMsgs.length > 0) {
+                saveConversation(sessionId, conversationTitle ?? generateTitle(chatMsgs), activeCwd, history.slice(1));
+            }
+        }
+        catch (loopErr) {
+            // Never let an internal error crash the session — show it and continue
+            const msg = loopErr instanceof Error ? loopErr.message : String(loopErr);
+            printError(`Internal error: ${msg}`);
+            readFileContinue = false;
+        }
+    }
+}