@quatcode/agent 0.1.2 → 0.2.0

package/dist/tui.js

@@ -0,0 +1,2456 @@
+import path from "node:path";
+import { homedir } from "node:os";
+import { Session, ToolRegistry, addUsage, createProviderFromEnv, emptyUsage, estimateCost, runAgent, } from "@quatcode/core";
+import { analyzeCommand, createProjectTools, McpManager } from "@quatcode/tools";
+import { buildProjectContext, createBrainTools, scanProject } from "@quatcode/brain";
+import { Keyboard } from "./keyboard.js";
+import { LineBuffer, defaultPrompt } from "./input.js";
+import { Picker } from "./picker.js";
+import { Screen } from "./screen.js";
+import { TurnController, fmtCost, fmtDuration, fmtTokens } from "./turn.js";
+import { renderBanner } from "./logo.js";
+import { renderMarkdown } from "./markdown.js";
+import { CUSTOM_MODEL, PROVIDERS, buildProvider, defaultModelFor, effortsForModel, fetchProviderModels, hasKey, keyEnvFor, resolveProviderForModel, } from "./models.js";
+import { activeThemeId, bg, bold, buildColorRemap, clipAnsi, fg, getThemes, glyphs, padEndTo, palette, remapColors, setTheme, stringWidth, stripAnsi, tone, } from "./theme.js";
+import { listSessionsForDir, loadConfig, makeSessionId, saveConfig, saveSession, deleteSession } from "./store.js";
+import { configFile, conversationKey, deleteConversation, displayTitle, latestPerConversation, messagesForStorage, sortConversations, updateConversation, } from "./store.js";
+import { MCP_USAGE, isMcpUrl, mcpInstructionsSection, parseMcpAdd } from "./mcp.js";
+import { copyToClipboard, readClipboardImage, readClipboardText, } from "./clipboard.js";
+import { createLoadSkillTool, fetchSkillFromUrl, importSkillFile, listSkills, parseSkill, removeSkill, saveSkill, skillsRoot, skillsSystemSection, } from "./skills.js";
+import { VERSION } from "./version.js";
+const COMMAND_INFO = [
+    { name: "/help", desc: "show this help" },
+    { name: "/new", desc: "new conversation (clears the screen)" },
+    { name: "/model", args: "[id]", desc: "pick or set the model" },
+    { name: "/effort", args: "[level]", desc: "reasoning effort (minimal…high)" },
+    { name: "/key", desc: "enter the API key for the current provider" },
+    { name: "/dir", args: "[path]", desc: "change the project directory" },
+    { name: "/context", desc: "project summary" },
+    { name: "/usage", desc: "tokens, cost and time" },
+    { name: "/sessions", desc: "list and resume recent sessions" },
+    { name: "/timeline", desc: "jump to a sent message" },
+    { name: "/undo", desc: "take back the last message" },
+    { name: "/verbose", desc: "toggle full tool output" },
+    { name: "/skills", args: "[add|remove|list]", desc: "manage agent skills" },
+    { name: "/mcp", args: "[list|add|remove]", desc: "manage MCP servers" },
+    { name: "/theme", args: "[id]", desc: "change the color theme" },
+    { name: "/clear", desc: "clear the screen (ctrl+l)" },
+    { name: "/exit", desc: "quit" },
+];
+const COMMANDS = COMMAND_INFO.map((command) => command.name);
+const READ_ONLY_TOOLS = new Set([
+    "read_file",
+    "list_dir",
+    "search",
+    "git",
+    "inspect_project",
+    "load_skill",
+    "screenshot",
+    "list_servers",
+]);
+export async function runTui(options) {
+    const input = options.io?.input ?? process.stdin;
+    const output = options.io?.output ?? process.stdout;
+    if (!input.isTTY || !output.isTTY) {
+        output.write("quatcode: the interactive interface needs a TTY.\nuse: quatcode \"<task>\" for headless mode.\n");
+        return 1;
+    }
+    const app = new TuiApp(options, input, output);
+    return app.run();
+}
+class TuiApp {
+    opts;
+    kb;
+    screen;
+    out;
+    startedAt = performance.now();
+    buffer = new LineBuffer();
+    dir;
+    provider = null;
+    providerId = "anthropic";
+    model = "";
+    effort = null;
+    config = {};
+    summary = null;
+    skills = [];
+    system = "";
+    tools = null;
+    mcp = new McpManager();
+    session = new Session("");
+    gateMode;
+    verbose = false;
+    conversationId = makeSessionId();
+    totalUsage = emptyUsage();
+    turns = 0;
+    transcript = [];
+    splashLines = 0;
+    liveBase = -1;
+    scrollOffset = 0;
+    status = null;
+    statusStartedAt = 0;
+    spinnerFrame = 0;
+    spinnerTimer = null;
+    picker = null;
+    mode = "idle";
+    inputPrompt = defaultPrompt();
+    inputMask = false;
+    inputPlaceholder = "ask anything, or /help";
+    permissionHint = "";
+    permissionOptionLine = null;
+    permissionSelected = 0;
+    permissionOptions = [];
+    permissionInner = 0;
+    permissionBorder = palette.steel;
+    lastVisibleStart = 0;
+    lastInputRender = null;
+    lastInputOffset = 1;
+    lastHeaderRows = 2;
+    lastViewport = 3;
+    suggestionIndex = 0;
+    resolveLine = null;
+    resolveChoice = null;
+    resolvePicker = null;
+    pickerAction = null;
+    abort = null;
+    abortRequested = false;
+    undoAfterAbort = false;
+    renderQueued = false;
+    pendingKeys = [];
+    padX = 2;
+    padTop = 1;
+    padBottom = 1;
+    agentMode = "build";
+    lastTurn = null;
+    turnUndo = null;
+    pendingInitial = null;
+    pendingImages = [];
+    userMarkers = [];
+    messageCursor = -1;
+    selection = null;
+    frameLines = [];
+    constructor(options, input, output) {
+        this.opts = options;
+        this.dir = path.resolve(options.dir);
+        this.gateMode = options.allowAll ? "always" : "ask";
+        this.out = output;
+        this.kb = new Keyboard(input, output);
+        this.screen = new Screen(output);
+    }
+    async run() {
+        this.kb.start();
+        this.screen.enter();
+        this.kb.setHandler(this.onKeys);
+        const cleanup = () => {
+            try {
+                this.stopSpinner();
+                this.kb.stop();
+                this.screen.exit();
+            }
+            catch {
+                // ignore
+            }
+        };
+        process.once("exit", cleanup);
+        process.once("SIGINT", () => {
+            cleanup();
+            process.exit(130);
+        });
+        process.once("SIGTERM", () => {
+            cleanup();
+            process.exit(143);
+        });
+        this.config = await loadConfig().catch(() => ({}));
+        for (const [name, value] of Object.entries(this.config.keys ?? {})) {
+            if (value && process.env[name] === undefined)
+                process.env[name] = value;
+        }
+        this.effort = this.opts.effort ?? this.config.effort ?? null;
+        setTheme(this.config.theme ?? "quatcode");
+        this.screen.applyBackground();
+        let configMeta = null;
+        try {
+            configMeta = await this.loadConfiguration();
+        }
+        catch (err) {
+            this.append([
+                `  ${tone.red(`// ${errorMessage(err)}`)}`,
+                `  ${tone.mist("// hint: run quatcode from a project directory or pass --dir <path>")}`,
+            ]);
+            this.renderNow();
+            await this.pause(1200);
+            this.shutdown();
+            return 1;
+        }
+        await this.splash();
+        try {
+            await this.bootStep("CONFIGURATION", () => configMeta ?? "");
+            await this.bootStep("PROJECT", () => this.loadProject());
+            const mcpConfigs = this.config.mcp ?? {};
+            if (Object.keys(mcpConfigs).length > 0) {
+                await this.bootStep("MCP SERVERS", () => this.connectMcpServers(mcpConfigs));
+            }
+        }
+        catch (err) {
+            this.append([
+                `  ${tone.red(`// ${errorMessage(err)}`)}`,
+                `  ${tone.mist("// hint: run quatcode from a project directory or pass --dir <path>")}`,
+            ]);
+            this.renderNow();
+            await this.pause(1200);
+            this.shutdown();
+            return 1;
+        }
+        this.append([`  ${tone.mist("// type / to see commands · esc interrupts a run")}`, ""]);
+        if (this.opts.initialPrompt) {
+            const prompt = this.opts.initialPrompt;
+            this.buffer.addHistory(prompt);
+            this.clearSplash();
+            this.append(this.userBlockLines(prompt));
+            await this.turn(prompt);
+        }
+        for (;;) {
+            const result = await this.readLine();
+            if (result.kind === "interrupt" || result.kind === "eof")
+                break;
+            if (result.kind === "cancel") {
+                this.append([`  ${tone.mist("// cancelled")}`]);
+                continue;
+            }
+            const input = result.text;
+            this.buffer.addHistory(input);
+            const images = this.pendingImages;
+            this.pendingImages = [];
+            const isCommand = input.startsWith("/");
+            if (!isCommand)
+                this.clearSplash();
+            const transcriptAt = this.transcript.length;
+            this.turnUndo = {
+                input,
+                snapshot: this.session.getMessages().map((message) => ({ ...message })),
+                transcriptLength: transcriptAt,
+            };
+            this.messageCursor = -1;
+            this.append(this.userBlockLines(input, images.length));
+            if (isCommand) {
+                this.turnUndo = null;
+                const shouldExit = await this.command(input);
+                if (shouldExit)
+                    break;
+                continue;
+            }
+            this.userMarkers.push({ line: transcriptAt, text: input });
+            await this.turn(input, images);
+        }
+        this.printGoodbye();
+        this.renderNow();
+        await this.pause(120);
+        const summary = this.summaryLine();
+        this.shutdown();
+        this.out.write(`${summary}\n`);
+        return 0;
+    }
+    shutdown() {
+        this.stopSpinner();
+        this.kb.stop();
+        this.screen.exit();
+        void this.mcp.closeAll().catch(() => undefined);
+    }
+    pause(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async splash() {
+        const width = this.contentWidth();
+        const info = { version: VERSION, dir: this.dir, mode: this.agentMode };
+        const animate = !process.env.QUATCODE_NO_ANIM && !process.env.CI;
+        if (!animate) {
+            this.applySplash(info, width, null);
+            this.renderNow();
+            return;
+        }
+        for (let sweep = -6; sweep <= 84; sweep += 3) {
+            this.applySplash(info, width, sweep);
+            this.renderNow();
+            await this.pause(16);
+        }
+        this.applySplash(info, width, null);
+        this.renderNow();
+    }
+    applySplash(info, width, sweep) {
+        const lines = renderBanner(info, width, sweep);
+        this.transcript = [...lines, ""];
+        this.splashLines = lines.length + 1;
+    }
+    clearSplash() {
+        if (this.splashLines <= 0)
+            return;
+        const removed = Math.min(this.splashLines, this.transcript.length);
+        if (removed > 0)
+            this.transcript.splice(0, removed);
+        this.splashLines = 0;
+        this.scheduleRender();
+    }
+    async bootStep(label, work) {
+        this.setStatus({ label });
+        try {
+            const meta = await work();
+            this.setStatus(null);
+            this.append([`  ${tone.accent(glyphs.diamond)} ${padEndTo(tone.bone(label), 20)}${meta ?? ""}`]);
+        }
+        catch (err) {
+            this.setStatus(null);
+            this.append([`  ${tone.red(glyphs.cross)} ${padEndTo(tone.red(label), 20)}`]);
+            throw err;
+        }
+    }
+    onKeys = (keys) => {
+        for (const key of keys) {
+            if (key.type === "resize") {
+                this.scheduleRender();
+                continue;
+            }
+            if (key.type === "mouse") {
+                if (key.kind === "wheelup" || key.kind === "wheeldown") {
+                    if (this.mode === "editing" && this.suggestionMatches().length > 0) {
+                        this.moveSuggestion(key.kind === "wheelup" ? -1 : 1);
+                        continue;
+                    }
+                    const delta = key.kind === "wheelup" ? 3 : -3;
+                    if (this.mode === "picker" && this.picker) {
+                        const dir = key.kind === "wheelup" ? "up" : "down";
+                        for (let i = 0; i < 3; i++)
+                            this.picker.handleKey({ type: "nav", dir, ctrl: false });
+                        this.scheduleRender();
+                    }
+                    else {
+                        this.scroll(delta);
+                    }
+                    continue;
+                }
+                if (key.kind === "press") {
+                    this.selection = {
+                        startRow: key.y - 1,
+                        startCol: key.x - 1,
+                        endRow: key.y - 1,
+                        endCol: key.x - 1,
+                        dragging: true,
+                    };
+                    this.scheduleRender();
+                    continue;
+                }
+                if (key.kind === "drag") {
+                    if (this.selection?.dragging) {
+                        this.selection.endRow = key.y - 1;
+                        this.selection.endCol = key.x - 1;
+                        this.scheduleRender();
+                    }
+                    continue;
+                }
+                if (key.kind === "release") {
+                    if (this.selection?.dragging) {
+                        const moved = this.selection.startRow !== key.y - 1 || this.selection.startCol !== key.x - 1;
+                        this.selection.dragging = false;
+                        if (!moved) {
+                            this.selection = null;
+                            this.handleClick(key.y - 1, key.x - 1);
+                        }
+                        else {
+                            this.scheduleRender();
+                        }
+                    }
+                    continue;
+                }
+                continue;
+            }
+            if (key.type === "hover") {
+                this.handleHover(key.y - 1, key.x - 1);
+                continue;
+            }
+            if (key.type === "control" && key.ch === "c" && this.selection && !this.selection.dragging) {
+                this.copySelection();
+                continue;
+            }
+            if (this.selection) {
+                this.selection = null;
+                this.scheduleRender();
+            }
+            if (this.mode === "editing")
+                this.handleEditKey(key);
+            else if (this.mode === "running")
+                this.handleRunKey(key);
+            else if (this.mode === "permission")
+                this.handleConfirmKey(key);
+            else if (this.mode === "picker")
+                this.handlePickerKey(key);
+            else
+                this.pendingKeys.push(key);
+        }
+    };
+    handleRunKey(key) {
+        if (key.type === "control" && key.ch === "z") {
+            if (this.undoAfterAbort)
+                return;
+            this.undoAfterAbort = true;
+            this.abortRequested = true;
+            this.append([`  ${tone.mist("// UNDOING…")}`]);
+            this.abort?.abort();
+            return;
+        }
+        const abortKey = key.type === "escape" || (key.type === "control" && key.ch === "c");
+        if (!abortKey || this.abortRequested)
+            return;
+        this.abortRequested = true;
+        this.append([`  ${tone.mist("// INTERRUPTING…")}`]);
+        this.abort?.abort();
+    }
+    handleEditKey(key) {
+        if (key.type === "text" || key.type === "backspace" || key.type === "delete") {
+            this.suggestionIndex = 0;
+        }
+        switch (key.type) {
+            case "text":
+                this.buffer.insert(key.text);
+                break;
+            case "control":
+                switch (key.ch) {
+                    case "c":
+                        if (this.buffer.isEmpty())
+                            this.finishLine({ kind: "interrupt" });
+                        else
+                            this.buffer.clearLine();
+                        break;
+                    case "d":
+                        if (this.buffer.isEmpty())
+                            this.finishLine({ kind: "eof" });
+                        else
+                            this.buffer.deleteForward();
+                        break;
+                    case "j":
+                        this.buffer.insert("\n");
+                        break;
+                    case "space":
+                        this.buffer.insert("\n");
+                        break;
+                    case "v":
+                        void this.pasteFromClipboard();
+                        return;
+                    case "z":
+                        if (this.buffer.isEmpty()) {
+                            void this.undoTurn("buffer");
+                            return;
+                        }
+                        break;
+                    case "a":
+                        this.buffer.home();
+                        break;
+                    case "e":
+                        this.buffer.end();
+                        break;
+                    case "b":
+                        this.buffer.move(-1);
+                        break;
+                    case "f":
+                        this.buffer.move(1);
+                        break;
+                    case "u":
+                        this.buffer.clearLine();
+                        break;
+                    case "k":
+                        this.buffer.killToEnd();
+                        break;
+                    case "w":
+                        this.buffer.deleteWordBefore();
+                        break;
+                    case "p":
+                        this.buffer.historyPrev();
+                        break;
+                    case "n":
+                        this.buffer.historyNext();
+                        break;
+                    case "l":
+                        this.clearTranscript();
+                        return;
+                    default:
+                        break;
+                }
+                break;
+            case "meta":
+                if (key.ch === "b" || key.ch === "B")
+                    this.buffer.moveWord(-1);
+                else if (key.ch === "f" || key.ch === "F")
+                    this.buffer.moveWord(1);
+                else if (key.ch === "d" || key.ch === "D")
+                    this.buffer.deleteWordAfter();
+                break;
+            case "nav":
+                if ((key.dir === "up" || key.dir === "down") &&
+                    this.suggestionMatches().length > 0) {
+                    this.moveSuggestion(key.dir === "up" ? -1 : 1);
+                    return;
+                }
+                if (key.dir === "up") {
+                    if (!this.buffer.moveVertical(-1))
+                        this.buffer.historyPrev();
+                }
+                else if (key.dir === "down") {
+                    if (!this.buffer.moveVertical(1))
+                        this.buffer.historyNext();
+                }
+                else if (key.dir === "left") {
+                    if (key.ctrl)
+                        this.buffer.moveWord(-1);
+                    else
+                        this.buffer.move(-1);
+                }
+                else if (key.dir === "right") {
+                    if (key.ctrl)
+                        this.buffer.moveWord(1);
+                    else
+                        this.buffer.move(1);
+                }
+                else if (key.dir === "home") {
+                    this.buffer.home();
+                }
+                else if (key.dir === "end") {
+                    this.buffer.end();
+                }
+                else if (key.dir === "pageup") {
+                    this.buffer.historyPrev();
+                }
+                else if (key.dir === "pagedown") {
+                    this.buffer.historyNext();
+                }
+                break;
+            case "newline":
+                this.buffer.insert("\n");
+                break;
+            case "enter": {
+                let text = this.buffer.text();
+                if (text.trim() === "")
+                    return;
+                const matches = this.suggestionMatches();
+                if (matches.length > 0) {
+                    const index = Math.max(0, Math.min(this.suggestionIndex, matches.length - 1));
+                    const selected = matches[index];
+                    if (selected) {
+                        this.finishLine({ kind: "submit", text: selected.name });
+                        return;
+                    }
+                }
+                if (this.buffer.continueLine()) {
+                    this.scheduleRender();
+                    return;
+                }
+                if (/^\/\S*$/.test(text)) {
+                    const unique = COMMAND_INFO.filter((command) => command.name.startsWith(text));
+                    if (unique.length === 1)
+                        text = unique[0].name;
+                }
+                this.finishLine({ kind: "submit", text });
+                return;
+            }
+            case "tab":
+                if (this.suggestionMatches().length > 0)
+                    this.completeCommand();
+                else
+                    this.toggleMode();
+                break;
+            case "backspace":
+                this.buffer.backspace();
+                break;
+            case "delete":
+                this.buffer.deleteForward();
+                break;
+            case "escape":
+                this.finishLine({ kind: "cancel" });
+                return;
+            default:
+                break;
+        }
+        this.scheduleRender();
+    }
+    finishLine(result) {
+        const resolve = this.resolveLine;
+        this.resolveLine = null;
+        this.mode = "idle";
+        this.scheduleRender();
+        resolve?.(result);
+    }
+    readLine(overrides = {}) {
+        const initial = overrides.initial ?? this.pendingInitial ?? "";
+        this.pendingInitial = null;
+        if (initial)
+            this.buffer.setText(initial);
+        else
+            this.buffer.reset();
+        this.inputPrompt = overrides.prompt ?? defaultPrompt();
+        this.inputMask = overrides.mask ?? false;
+        this.inputPlaceholder = overrides.placeholder ?? "ask anything, or /help";
+        this.suggestionIndex = 0;
+        this.mode = "editing";
+        this.scheduleRender();
+        const promise = new Promise((resolve) => {
+            this.resolveLine = resolve;
+        });
+        if (this.pendingKeys.length > 0) {
+            const pending = this.pendingKeys;
+            this.pendingKeys = [];
+            for (const key of pending) {
+                if (this.mode !== "editing")
+                    break;
+                this.handleEditKey(key);
+            }
+        }
+        return promise;
+    }
+    completeCommand() {
+        const text = this.buffer.text();
+        if (text.includes("\n") || !text.startsWith("/"))
+            return;
+        const candidates = COMMANDS.filter((command) => command.startsWith(text));
+        if (candidates.length === 0)
+            return;
+        if (candidates.length === 1) {
+            this.buffer.insert(candidates[0].slice(text.length));
+            return;
+        }
+        const common = longestCommonPrefix(candidates);
+        if (common.length > text.length)
+            this.buffer.insert(common.slice(text.length));
+    }
+    suggestionMatches() {
+        if (this.inputMask)
+            return [];
+        const text = this.buffer.text();
+        if (text.includes("\n") || !/^\/\S*$/.test(text))
+            return [];
+        const matches = COMMAND_INFO.filter((command) => command.name.startsWith(text));
+        if (matches.length === 0)
+            return [];
+        if (matches.length === 1 && matches[0].name === text)
+            return [];
+        return matches;
+    }
+    moveSuggestion(delta) {
+        const matches = this.suggestionMatches();
+        if (matches.length === 0)
+            return;
+        this.suggestionIndex = Math.max(0, Math.min(this.suggestionIndex + delta, matches.length - 1));
+        this.scheduleRender();
+    }
+    suggestions() {
+        const matches = this.suggestionMatches();
+        if (matches.length === 0)
+            return [];
+        this.suggestionIndex = Math.max(0, Math.min(this.suggestionIndex, matches.length - 1));
+        const lines = matches.map((command, index) => {
+            const plain = `${command.name}${command.args ? ` ${command.args}` : ""}`;
+            const styled = `${tone.bone(command.name)}${command.args ? tone.mist(` ${command.args}`) : ""}`;
+            if (index === this.suggestionIndex) {
+                return `  ${tone.accent(glyphs.prompt)} ${tone.onGraphite(` ${padEndTo(plain, 21)} `)}${tone.mist(command.desc)}`;
+            }
+            return `    ${padEndTo(styled, 23)}${tone.mist(command.desc)}`;
+        });
+        if (matches.length > 1) {
+            lines.push(`  ${tone.mist("↑↓ select · enter run · tab complete")}`);
+        }
+        return lines;
+    }
+    handleHover(row, col) {
+        if (this.mode === "permission") {
+            const index = this.permissionOptionAt(row, col);
+            if (index !== null && index !== this.permissionSelected) {
+                this.permissionSelected = index;
+                this.updatePermissionOptions();
+            }
+            return;
+        }
+        if (this.mode === "editing") {
+            const matches = this.suggestionMatches();
+            if (matches.length === 0)
+                return;
+            const top = this.lastHeaderRows + this.lastViewport + 1;
+            const index = row - top;
+            if (index >= 0 && index < matches.length && index !== this.suggestionIndex) {
+                this.suggestionIndex = index;
+                this.scheduleRender();
+            }
+            return;
+        }
+        if (this.mode === "picker" && this.picker) {
+            if (this.picker.hoverAt(row - this.lastHeaderRows))
+                this.scheduleRender();
+        }
+    }
+    handleClick(row, col) {
+        if (this.mode === "permission") {
+            const index = this.permissionOptionAt(row, col);
+            if (index !== null) {
+                this.permissionSelected = index;
+                this.updatePermissionOptions();
+                const choice = this.permissionOptions[index]?.choice;
+                if (choice)
+                    this.resolvePermission(choice);
+            }
+            return;
+        }
+        if (this.mode === "editing") {
+            const matches = this.suggestionMatches();
+            if (matches.length > 0) {
+                const top = this.lastHeaderRows + this.lastViewport + 1;
+                const index = row - top;
+                if (index >= 0 && index < matches.length) {
+                    this.suggestionIndex = index;
+                    this.finishLine({ kind: "submit", text: matches[index].name });
+                }
+            }
+            return;
+        }
+        if (this.mode === "picker" && this.picker) {
+            const value = this.picker.pickAt(row - this.lastHeaderRows);
+            if (value !== null)
+                this.closePicker(value);
+            else
+                this.scheduleRender();
+        }
+    }
+    scroll(delta) {
+        this.scrollOffset = Math.max(0, this.scrollOffset + delta);
+        this.scheduleRender();
+    }
+    async undoTurn(target = "next") {
+        const last = this.lastTurn;
+        if (!last) {
+            this.append([`  ${tone.mist("// nothing to undo")}`]);
+            return;
+        }
+        this.lastTurn = null;
+        this.session = new Session(this.system, last.snapshot);
+        this.transcript = this.transcript.slice(0, last.transcriptLength);
+        this.userMarkers = this.userMarkers.filter((marker) => marker.line < last.transcriptLength);
+        this.messageCursor = -1;
+        this.scrollOffset = 0;
+        if (last.recordId)
+            await deleteSession(last.recordId).catch(() => false);
+        if (target === "buffer") {
+            this.buffer.setText(last.input);
+            this.scheduleRender();
+        }
+        else {
+            this.pendingInitial = last.input;
+        }
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist("// UNDONE — message restored to the input")}`,
+        ]);
+    }
+    async pasteFromClipboard() {
+        const image = readClipboardImage();
+        if (image) {
+            this.pendingImages.push(image);
+            const kb = Math.max(1, Math.round((image.data.length * 3) / 4 / 1024));
+            this.append([
+                `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// image attached (${image.mediaType} · ${kb} KB) · it will be sent with the next message`)}`,
+            ]);
+            return;
+        }
+        const text = readClipboardText();
+        if (text && text.length > 0) {
+            this.buffer.insert(text.replace(/\r\n?/g, "\n"));
+            this.scheduleRender();
+            return;
+        }
+        this.append([`  ${tone.mist("// clipboard is empty or unavailable")}`]);
+    }
+    copySelection() {
+        const text = this.selectionText();
+        this.selection = null;
+        if (!text) {
+            this.scheduleRender();
+            return;
+        }
+        const ok = copyToClipboard(text);
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// ${ok ? "copied" : "copy attempted"} · ${text.length} chars`)}`,
+        ]);
+        this.scheduleRender();
+    }
+    selectionText() {
+        if (!this.selection)
+            return "";
+        const s = this.selection;
+        const forward = s.startRow < s.endRow || (s.startRow === s.endRow && s.startCol <= s.endCol);
+        const startRow = forward ? s.startRow : s.endRow;
+        const startCol = forward ? s.startCol : s.endCol;
+        const endRow = forward ? s.endRow : s.startRow;
+        const endCol = forward ? s.endCol : s.startCol;
+        const lines = [];
+        for (let row = startRow; row <= endRow; row++) {
+            const raw = stripAnsi(this.frameLines[row] ?? "");
+            const chars = Array.from(raw);
+            const from = row === startRow ? startCol : 0;
+            const to = row === endRow ? endCol : chars.length - 1;
+            lines.push(chars
+                .slice(from, to + 1)
+                .join("")
+                .replace(/\s+$/, ""));
+        }
+        return lines.join("\n").replace(/^\n+|\n+$/g, "");
+    }
+    handleConfirmKey(key) {
+        if (key.type === "nav" && (key.dir === "left" || key.dir === "right")) {
+            const count = this.permissionOptions.length;
+            if (count > 0) {
+                this.permissionSelected =
+                    (this.permissionSelected + (key.dir === "right" ? 1 : count - 1)) % count;
+                this.updatePermissionOptions();
+            }
+            return;
+        }
+        let choice = null;
+        if (key.type === "escape" || (key.type === "control" && key.ch === "c"))
+            choice = "deny";
+        else if (key.type === "enter") {
+            choice = this.permissionOptions[this.permissionSelected]?.choice ?? "deny";
+        }
+        else if (key.type === "text") {
+            const ch = key.text.toLowerCase();
+            if (ch === "y")
+                choice = "allow";
+            else if (ch === "a")
+                choice = "always";
+            else if (ch === "n")
+                choice = "deny";
+        }
+        if (!choice)
+            return;
+        this.resolvePermission(choice);
+    }
+    permissionOptionAt(row, col) {
+        if (this.permissionOptionLine === null)
+            return null;
+        const contentIndex = row - this.lastHeaderRows;
+        if (contentIndex < 0 || contentIndex >= this.lastViewport)
+            return null;
+        const transcriptIndex = this.lastVisibleStart + contentIndex;
+        if (transcriptIndex !== this.permissionOptionLine)
+            return null;
+        const line = stripAnsi(this.frameLines[row] ?? "");
+        for (let i = 0; i < this.permissionOptions.length; i++) {
+            const label = this.permissionOptions[i].label;
+            const at = line.indexOf(label);
+            if (at === -1)
+                continue;
+            const start = at - 3;
+            const end = at + label.length + 1;
+            if (col >= start && col <= end)
+                return i;
+        }
+        return null;
+    }
+    handlePickerKey(key) {
+        if (!this.picker)
+            return;
+        const action = this.picker.handleKey(key);
+        if (action === "select") {
+            this.closePicker(this.picker.selectedValue());
+            return;
+        }
+        if (action === "cancel") {
+            this.closePicker(null);
+            return;
+        }
+        if (action === "rename" || action === "pin" || action === "delete") {
+            this.pickerAction = action;
+            this.closePicker(this.picker.selectedValue());
+            return;
+        }
+        this.scheduleRender();
+    }
+    openPicker(picker) {
+        this.picker = picker;
+        this.pickerAction = null;
+        this.mode = "picker";
+        this.scheduleRender();
+        return new Promise((resolve) => {
+            this.resolvePicker = resolve;
+        });
+    }
+    closePicker(value) {
+        const resolve = this.resolvePicker;
+        this.resolvePicker = null;
+        this.picker = null;
+        this.mode = "idle";
+        this.scheduleRender();
+        resolve?.(value);
+    }
+    scheduleRender() {
+        if (this.renderQueued)
+            return;
+        this.renderQueued = true;
+        setImmediate(() => {
+            this.renderQueued = false;
+            this.render();
+        });
+    }
+    renderNow() {
+        this.renderQueued = false;
+        this.render();
+    }
+    render() {
+        const rows = this.screen.rows;
+        const header = this.headerLines();
+        const footer = this.footerLines();
+        const viewport = Math.max(3, rows - header.length - footer.length - this.padTop - this.padBottom);
+        this.lastHeaderRows = header.length + this.padTop;
+        this.lastViewport = viewport;
+        let content;
+        if (this.mode === "picker" && this.picker) {
+            content = this.picker.render(this.contentWidth() - 2, viewport);
+        }
+        else {
+            content = this.visibleTranscript(viewport);
+        }
+        const lines = [""];
+        lines.push(...header, ...content);
+        while (lines.length < this.padTop + header.length + viewport)
+            lines.push("");
+        lines.push(...footer);
+        while (lines.length < rows)
+            lines.push("");
+        let cursor = null;
+        if (this.mode === "editing" && this.lastInputRender) {
+            const inputTop = this.padTop + header.length + viewport + this.lastInputOffset;
+            cursor = {
+                row: inputTop + this.lastInputRender.cursorRow,
+                col: this.padX + this.lastInputRender.cursorCol,
+            };
+        }
+        const padded = lines.map((line) => `${" ".repeat(this.padX)}${line}`);
+        this.frameLines = padded.slice(0, rows);
+        let selection = null;
+        if (this.selection) {
+            const s = this.selection;
+            const collapsed = s.startRow === s.endRow && s.startCol === s.endCol;
+            if (!collapsed) {
+                const forward = s.startRow < s.endRow || (s.startRow === s.endRow && s.startCol <= s.endCol);
+                selection = forward
+                    ? { startRow: s.startRow, startCol: s.startCol, endRow: s.endRow, endCol: s.endCol }
+                    : { startRow: s.endRow, startCol: s.endCol, endRow: s.startRow, endCol: s.startCol };
+            }
+        }
+        this.screen.render({ lines: this.frameLines, cursor, selection });
+    }
+    contentWidth() {
+        return Math.max(40, this.screen.width - this.padX * 2);
+    }
+    headerLines() {
+        const width = this.contentWidth();
+        const effort = this.activeEffort();
+        const modelLabel = this.model
+            ? `${this.providerId} · ${this.model}${effort ? ` · ${effort}` : ""}`
+            : "";
+        const badge = this.agentMode === "plan"
+            ? fg(palette.amber, bg(palette.graphite, " PLAN "))
+            : tone.onGraphite(" BUILD ");
+        const left = [
+            bold(tone.bone("quatcode")),
+            modelLabel ? tone.steel("·") : "",
+            modelLabel ? tone.silver(modelLabel) : "",
+            badge,
+        ]
+            .filter(Boolean)
+            .join("  ");
+        const scrolled = this.scrollOffset > 0 ? tone.mist("↑ ") : "";
+        const right = `${scrolled}${tone.mist(`v${VERSION}`)}`;
+        const gap = Math.max(1, width - 2 - stringWidth(left) - stringWidth(right));
+        return [
+            `  ${left}${" ".repeat(gap)}${right}`,
+            `  ${tone.steel("─".repeat(Math.max(8, width - 2)))}`,
+        ];
+    }
+    footerLines() {
+        const width = this.contentWidth();
+        const bar = `  ${tone.steel("─".repeat(Math.max(8, width - 2)))}`;
+        if (this.mode === "editing") {
+            const rendered = this.buffer.render({
+                width,
+                prompt: this.inputPrompt,
+                placeholder: this.inputPlaceholder,
+                mask: this.inputMask,
+            });
+            this.lastInputRender = rendered;
+            const suggestions = this.suggestions();
+            this.lastInputOffset = 1 + suggestions.length;
+            return [bar, ...suggestions, ...rendered.lines];
+        }
+        this.lastInputRender = null;
+        if (this.status)
+            return [bar, this.statusLine()];
+        if (this.mode === "running") {
+            return [bar, `  ${tone.mist("// esc interrupts")}`];
+        }
+        if (this.mode === "permission")
+            return [bar, `  ${this.permissionHint}`];
+        if (this.mode === "picker" && this.picker) {
+            return [bar, this.picker.footer(this.picker.itemCount())];
+        }
+        return [bar, `  ${tone.mist(`// ${shortenHome(this.dir)}`)}`];
+    }
+    statusLine() {
+        const spin = tone.accent(glyphs.spinner[this.spinnerFrame % glyphs.spinner.length] ?? "-");
+        const elapsed = ((performance.now() - this.statusStartedAt) / 1000).toFixed(1);
+        const meta = [this.status?.meta, `${elapsed}s`].filter(Boolean).join(" · ");
+        return `  ${spin} ${this.status?.label ?? ""}  ${tone.mist(meta)}`;
+    }
+    visibleTranscript(viewport) {
+        const total = this.transcript.length;
+        const maxOffset = Math.max(0, total - viewport);
+        this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+        const end = total - this.scrollOffset;
+        const start = Math.max(0, end - viewport);
+        this.lastVisibleStart = start;
+        return this.transcript.slice(start, end);
+    }
+    append(lines) {
+        const flat = lines.map((line) => line.replace(/\r?\n/g, " "));
+        this.transcript.push(...flat);
+        if (this.transcript.length > 2000) {
+            const removed = this.transcript.length - 2000;
+            this.transcript.splice(0, removed);
+            this.userMarkers = this.userMarkers
+                .map((marker) => ({ ...marker, line: marker.line - removed }))
+                .filter((marker) => marker.line >= 0);
+        }
+        this.scheduleRender();
+    }
+    clearTranscript() {
+        this.transcript = [];
+        this.scrollOffset = 0;
+        this.append([`  ${tone.mist("// screen cleared")}`, ""]);
+    }
+    beginLive() {
+        this.liveBase = this.transcript.length;
+        this.scrollOffset = 0;
+    }
+    pushLive(text) {
+        if (this.liveBase < 0)
+            this.liveBase = this.transcript.length;
+        const width = this.contentWidth() - 2;
+        const rendered = renderMarkdown(text, { width });
+        this.transcript = this.transcript.slice(0, this.liveBase).concat(rendered);
+        this.scheduleRender();
+    }
+    endLive() {
+        this.liveBase = -1;
+    }
+    setStatus(status) {
+        this.status = status;
+        if (status) {
+            this.statusStartedAt = performance.now();
+            this.startSpinner();
+        }
+        else {
+            this.stopSpinner();
+        }
+        this.scheduleRender();
+    }
+    startSpinner() {
+        if (this.spinnerTimer)
+            return;
+        this.spinnerFrame = 0;
+        this.spinnerTimer = setInterval(() => {
+            this.spinnerFrame += 1;
+            this.scheduleRender();
+        }, 90);
+        if (typeof this.spinnerTimer.unref === "function")
+            this.spinnerTimer.unref();
+    }
+    stopSpinner() {
+        if (this.spinnerTimer)
+            clearInterval(this.spinnerTimer);
+        this.spinnerTimer = null;
+    }
+    async loadConfiguration() {
+        this.rebuildTools();
+        const explicit = this.opts.model;
+        if (explicit) {
+            this.providerId = resolveProviderForModel(explicit) ?? this.detectProvider() ?? "anthropic";
+            this.model = explicit;
+        }
+        else if (this.config.model) {
+            this.providerId =
+                this.config.provider ??
+                    resolveProviderForModel(this.config.model) ??
+                    this.detectProvider() ??
+                    "anthropic";
+            this.model = this.config.model;
+        }
+        else {
+            const detected = this.detectEnvSetup();
+            if (detected) {
+                this.providerId = detected.id;
+                this.model = detected.model;
+            }
+            else {
+                const chosen = await this.changeModel();
+                if (!chosen) {
+                    this.providerId = "anthropic";
+                    this.model = defaultModelFor("anthropic");
+                }
+            }
+        }
+        const keyState = hasKey(this.providerId)
+            ? ` ${tone.silver("· key set")}`
+            : ` ${tone.bone("· no key")} ${tone.mist(`(${keyEnvFor(this.providerId)})`)}`;
+        return `${tone.silver(`${this.providerId} · ${this.model}`)}${keyState}`;
+    }
+    detectProvider() {
+        if (process.env.ANTHROPIC_API_KEY)
+            return "anthropic";
+        if (process.env.OPENAI_API_KEY)
+            return "openai";
+        if (process.env.GEMINI_API_KEY)
+            return "gemini";
+        return null;
+    }
+    detectEnvSetup() {
+        const override = process.env.QUATCODE_PROVIDER?.toLowerCase();
+        if (override === "anthropic" || override === "openai" || override === "gemini") {
+            const envModel = {
+                anthropic: process.env.ANTHROPIC_MODEL,
+                openai: process.env.OPENAI_MODEL,
+                gemini: process.env.GEMINI_MODEL,
+            }[override];
+            return { id: override, model: envModel ?? defaultModelFor(override) };
+        }
+        if (process.env.ANTHROPIC_MODEL)
+            return { id: "anthropic", model: process.env.ANTHROPIC_MODEL };
+        if (process.env.OPENAI_MODEL)
+            return { id: "openai", model: process.env.OPENAI_MODEL };
+        if (process.env.GEMINI_MODEL)
+            return { id: "gemini", model: process.env.GEMINI_MODEL };
+        try {
+            const provider = createProviderFromEnv();
+            const id = provider.id;
+            if (provider.defaultModel &&
+                (id === "anthropic" || id === "openai" || id === "gemini")) {
+                return { id, model: provider.defaultModel };
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+    async loadProject() {
+        const summary = await scanProject(this.dir);
+        this.summary = summary;
+        this.system = this.buildSystem("");
+        this.skills = await listSkills().catch(() => []);
+        const recent = await listSessionsForDir(this.dir, 50).catch(() => []);
+        for (const record of [...recent].reverse())
+            this.buffer.addHistory(record.task);
+        const stack = summary.frameworks.slice(0, 3).join("+") ||
+            summary.languages
+                .slice(0, 2)
+                .map((l) => l.ext.replace(".", ""))
+                .join("+");
+        const parts = [
+            summary.name,
+            stack,
+            `${summary.fileCount} files`,
+            summary.packageManager ?? "",
+        ].filter(Boolean);
+        return tone.mist(parts.join(" · "));
+    }
+    buildSystem(query) {
+        if (!this.opts.context || !this.summary)
+            return this.opts.system ?? "";
+        const context = buildProjectContext(this.summary, { query }).system;
+        return this.opts.system ? `${context}\n\n${this.opts.system}` : context;
+    }
+    rebuildTools() {
+        this.tools?.dispose();
+        const full = createProjectTools(this.dir);
+        for (const tool of createBrainTools(this.dir).list())
+            full.register(tool);
+        full.register(createLoadSkillTool());
+        for (const tool of this.mcp.tools())
+            full.register(tool);
+        if (this.agentMode === "plan") {
+            const readOnlyMcp = this.mcp.readOnlyToolNames();
+            const filtered = new ToolRegistry();
+            for (const tool of full.list()) {
+                if (READ_ONLY_TOOLS.has(tool.name) || readOnlyMcp.has(tool.name))
+                    filtered.register(tool);
+            }
+            filtered.onDispose(() => full.dispose());
+            this.tools = filtered;
+            return;
+        }
+        this.tools = full;
+    }
+    async connectMcpServers(configs) {
+        const statuses = await this.mcp.connectAll(configs);
+        this.rebuildTools();
+        const connected = statuses.filter((status) => status.state === "connected");
+        const failed = statuses.filter((status) => status.state === "error");
+        const disabled = statuses.filter((status) => status.state === "disabled");
+        const toolCount = connected.reduce((sum, status) => sum + status.tools.length, 0);
+        for (const status of failed) {
+            this.append([`  ${tone.red(`// MCP ${status.name}: ${status.error ?? "connection failed"}`)}`]);
+        }
+        const parts = [
+            `${connected.length}/${statuses.length} connected`,
+            `${toolCount} tool${toolCount === 1 ? "" : "s"}`,
+        ];
+        if (disabled.length > 0)
+            parts.push(`${disabled.length} disabled`);
+        if (failed.length > 0)
+            parts.push(`${failed.length} failed`);
+        return tone.mist(parts.join(" · "));
+    }
+    toggleMode() {
+        this.agentMode = this.agentMode === "build" ? "plan" : "build";
+        this.rebuildTools();
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// MODE → ${this.agentMode.toUpperCase()}`)}${this.agentMode === "plan" ? `  ${tone.amber("read-only: no edits, no commands")}` : ""}`,
+        ]);
+    }
+    ensureProvider() {
+        if (this.provider)
+            return this.provider;
+        try {
+            this.provider = buildProvider(this.providerId, this.model);
+            return this.provider;
+        }
+        catch {
+            return null;
+        }
+    }
+    async collectModelEntries() {
+        const result = [];
+        for (const provider of PROVIDERS) {
+            let models = provider.models;
+            if (hasKey(provider.id)) {
+                this.setStatus({ label: `LOADING ${provider.label.toUpperCase()} MODELS` });
+                const live = await fetchProviderModels(provider.id);
+                if (live.length > 0)
+                    models = live;
+            }
+            for (const model of models) {
+                result.push({ providerId: provider.id, id: model.id, label: model.label });
+            }
+        }
+        this.setStatus(null);
+        return result;
+    }
+    async changeModel() {
+        this.setStatus({ label: "LOADING MODELS" });
+        const entries = await this.collectModelEntries();
+        this.setStatus(null);
+        const pickerEntries = [];
+        for (const provider of PROVIDERS) {
+            const models = entries.filter((entry) => entry.providerId === provider.id);
+            if (models.length === 0)
+                continue;
+            pickerEntries.push({
+                kind: "header",
+                label: `${provider.label} · ${hasKey(provider.id) ? "key set" : "no key"}`,
+            });
+            for (const model of models) {
+                pickerEntries.push({
+                    kind: "item",
+                    value: `${provider.id}:${model.id}`,
+                    label: model.id,
+                    hint: model.label,
+                });
+            }
+        }
+        pickerEntries.push({ kind: "item", value: CUSTOM_MODEL, label: "custom model id…" });
+        const chosen = await this.openPicker(new Picker({ title: "select a model", entries: pickerEntries, filterable: true }));
+        if (!chosen)
+            return false;
+        if (chosen === CUSTOM_MODEL) {
+            const result = await this.readLine({
+                prompt: `  ${tone.bone("MODEL ID")} ${tone.mist(glyphs.prompt)} `,
+                placeholder: "e.g. claude-sonnet-5-5",
+            });
+            if (result.kind !== "submit" || !result.text.trim())
+                return false;
+            const id = result.text.trim();
+            this.applyModel(resolveProviderForModel(id) ?? this.providerId, id);
+            await this.chooseEffortForModel(id);
+            return true;
+        }
+        const separator = chosen.indexOf(":");
+        const model = chosen.slice(separator + 1);
+        this.applyModel(chosen.slice(0, separator), model);
+        await this.chooseEffortForModel(model);
+        return true;
+    }
+    effortEntries(efforts, current) {
+        const entries = [
+            { kind: "item", value: "default", label: "default", hint: "no effort parameter" },
+        ];
+        for (const level of efforts) {
+            entries.push({
+                kind: "item",
+                value: level,
+                label: level,
+                hint: level === current ? "current" : undefined,
+            });
+        }
+        return entries;
+    }
+    async chooseEffortForModel(model) {
+        const efforts = effortsForModel(model);
+        if (!efforts || efforts.length === 0)
+            return;
+        const chosen = await this.openPicker(new Picker({
+            title: `select effort · ${model}`,
+            entries: this.effortEntries(efforts, this.activeEffort()),
+            filterable: true,
+        }));
+        if (chosen === null)
+            return;
+        this.setEffort(chosen === "default" ? null : chosen);
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// EFFORT → ${this.activeEffort() ?? "default"}`)}`,
+        ]);
+    }
+    async effortCommand(arg) {
+        const value = arg.trim().toLowerCase();
+        const efforts = effortsForModel(this.model);
+        if (!efforts || efforts.length === 0) {
+            this.append([
+                `  ${tone.mist(`// ${this.model || "this model"} does not support effort`)}`,
+            ]);
+            return;
+        }
+        if (value === "off" || value === "default" || value === "none" || value === "auto") {
+            this.setEffort(null);
+            this.append([`  ${tone.mist("// EFFORT → default")}`]);
+            return;
+        }
+        if (value) {
+            if (!efforts.includes(value)) {
+                this.append([
+                    `  ${tone.red(`// unknown effort: ${value}`)}`,
+                    `  ${tone.mist(`// available: ${efforts.join(", ")} · default`)}`,
+                ]);
+                return;
+            }
+            this.setEffort(value);
+            this.append([`  ${tone.mist(`// EFFORT → ${value}`)}`]);
+            return;
+        }
+        const chosen = await this.openPicker(new Picker({
+            title: "select effort",
+            entries: this.effortEntries(efforts, this.activeEffort()),
+            filterable: true,
+        }));
+        if (chosen === null)
+            return;
+        this.setEffort(chosen === "default" ? null : chosen);
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// EFFORT → ${this.activeEffort() ?? "default"}`)}`,
+        ]);
+    }
+    activeEffort() {
+        if (!this.effort)
+            return null;
+        const efforts = effortsForModel(this.model);
+        return efforts && efforts.includes(this.effort) ? this.effort : null;
+    }
+    setEffort(value) {
+        this.effort = value;
+        if (value)
+            this.config.effort = value;
+        else
+            delete this.config.effort;
+        void saveConfig({ ...this.config }).catch(() => undefined);
+    }
+    applyModel(providerId, model) {
+        this.providerId = providerId;
+        this.model = model;
+        this.provider = null;
+        this.config.provider = providerId;
+        this.config.model = model;
+        void saveConfig({ ...this.config, provider: providerId, model }).catch(() => undefined);
+    }
+    async permissionCard(req) {
+        this.setStatus(null);
+        let warning = null;
+        if (req.tool === "run_command") {
+            const command = req.input && typeof req.input === "object" && "command" in req.input
+                ? String(req.input.command)
+                : "";
+            if (command)
+                warning = analyzeCommand(command);
+        }
+        const title = warning?.dangerous
+            ? "DANGER"
+            : warning?.sensitive
+                ? "SENSITIVE"
+                : "PERMISSION";
+        const border = warning?.dangerous ? palette.red : palette.steel;
+        const inner = Math.min(Math.max(44, this.contentWidth() - 8), 66);
+        const body = [bold(tone.bone(req.tool))];
+        const summary = permissionSummary(req);
+        if (summary)
+            body.push(tone.silver(clipAnsi(summary, inner - 2)));
+        if (warning?.dangerous)
+            body.push(tone.red(`danger: ${warning.reasons.join(", ")}`));
+        else if (warning?.sensitive)
+            body.push(tone.amber(`sensitive: ${warning.reasons.join(", ")}`));
+        body.push("");
+        this.permissionOptions = [
+            { choice: "allow", key: "Y", label: "allow" },
+            { choice: "always", key: "A", label: "always" },
+            { choice: "deny", key: "N", label: "deny" },
+        ];
+        this.permissionSelected = 0;
+        this.permissionInner = inner;
+        this.permissionBorder = border;
+        const optionRowIndex = body.length;
+        body.push(this.renderPermissionOptions());
+        const card = box(title, body, inner, border);
+        this.append(card);
+        this.permissionOptionLine = this.transcript.length - card.length + 1 + optionRowIndex;
+        this.permissionHint = ` ${tone.bone("← →")} ${tone.mist("select")}    ${tone.bone("ENTER")} ${tone.mist("confirm")}    ${tone.bone("Y/A/N")} ${tone.mist("direct")}    ${tone.bone("ESC")} ${tone.mist("deny")}    ${tone.mist("(mouse works too)")}`;
+        this.mode = "permission";
+        this.scheduleRender();
+        const choice = await new Promise((resolve) => {
+            this.resolveChoice = resolve;
+        });
+        const granted = choice === "allow" || choice === "always";
+        const marker = granted ? tone.bone(glyphs.diamond) : tone.red(glyphs.cross);
+        this.append([
+            `  ${marker} ${tone.silver(req.tool)} ${tone.mist(granted ? "ALLOWED" : "DENIED")}`,
+        ]);
+        return choice;
+    }
+    renderPermissionOptions() {
+        return this.permissionOptions
+            .map((option, index) => {
+            const text = `${option.key} ${option.label}`;
+            return index === this.permissionSelected
+                ? tone.onGraphite(` ${text} `)
+                : tone.silver(text);
+        })
+            .join("   ");
+    }
+    updatePermissionOptions() {
+        if (this.permissionOptionLine === null)
+            return;
+        const b = glyphs.box;
+        const content = padEndTo(this.renderPermissionOptions(), this.permissionInner - 2);
+        this.transcript[this.permissionOptionLine] =
+            `  ${fg(this.permissionBorder, b.v)} ${content} ${fg(this.permissionBorder, b.v)}`;
+        this.scheduleRender();
+    }
+    resolvePermission(choice) {
+        const resolve = this.resolveChoice;
+        this.resolveChoice = null;
+        this.permissionOptionLine = null;
+        this.mode = "running";
+        this.scheduleRender();
+        resolve?.(choice);
+    }
+    buildGate() {
+        return {
+            request: async (req) => {
+                if (this.agentMode === "plan" && !READ_ONLY_TOOLS.has(req.tool)) {
+                    this.append([
+                        `  ${tone.amber(glyphs.diamondOpen)} ${tone.mist(`// ${req.tool} blocked in PLAN mode (Tab switches to BUILD)`)}`,
+                    ]);
+                    return { allowed: false };
+                }
+                if (this.gateMode === "always")
+                    return { allowed: true };
+                const choice = await this.permissionCard(req);
+                if (choice === "always") {
+                    this.gateMode = "always";
+                    return { allowed: true };
+                }
+                return { allowed: choice === "allow" };
+            },
+        };
+    }
+    async promptForKey(keyEnv) {
+        this.append([`  ${tone.mist(`// ${keyEnv} IS NOT SET`)}`]);
+        const result = await this.readLine({
+            prompt: `  ${tone.bone(keyEnv)} ${tone.mist(glyphs.prompt)} `,
+            mask: true,
+            placeholder: "",
+        });
+        if (result.kind !== "submit" || !result.text.trim()) {
+            this.append([`  ${tone.mist("// request not sent")}`]);
+            return false;
+        }
+        const value = result.text.trim();
+        process.env[keyEnv] = value;
+        this.config.keys = { ...(this.config.keys ?? {}), [keyEnv]: value };
+        void saveConfig({ ...this.config }).catch(() => undefined);
+        this.append([
+            `  ${tone.bone(glyphs.diamond)} ${tone.mist(`${keyEnv} SAVED · ~/.quatcode/config.json (and this session)`)}`,
+        ]);
+        return true;
+    }
+    async turn(input, images = []) {
+        if (!this.tools)
+            return;
+        let provider = this.ensureProvider();
+        if (!provider) {
+            const keyEnv = keyEnvFor(this.providerId);
+            this.append([
+                `  ${tone.red(glyphs.cross)} ${tone.bone(`${this.providerId} NEEDS ${keyEnv}`)}`,
+            ]);
+            const entered = await this.promptForKey(keyEnv);
+            if (!entered)
+                return;
+            provider = this.ensureProvider();
+            if (!provider) {
+                this.append([`  ${tone.red(`// ${keyEnv} IS STILL NOT SET`)}`]);
+                return;
+            }
+        }
+        if (this.opts.context && this.summary)
+            this.system = this.buildSystem(input);
+        const skillsSection = skillsSystemSection(this.skills);
+        let system = skillsSection
+            ? `${this.system ? `${this.system}\n\n` : ""}${skillsSection}`
+            : this.system;
+        const mcpSection = mcpInstructionsSection(this.mcp.instructions());
+        if (mcpSection)
+            system = system ? `${system}\n\n${mcpSection}` : mcpSection;
+        if (this.agentMode === "plan") {
+            system = `${system ? `${system}\n\n` : ""}# mode\nYou are in PLAN mode: analyze the codebase and propose a plan. Do not modify files or run commands. When the plan is ready, present it and tell the user to press Tab to switch to BUILD mode.`;
+        }
+        this.abort = new AbortController();
+        this.abortRequested = false;
+        this.undoAfterAbort = false;
+        this.mode = "running";
+        this.scrollOffset = 0;
+        const controller = new TurnController({ model: this.model, maxSteps: this.opts.maxSteps }, {
+            width: () => this.contentWidth() - 2,
+            append: (lines) => this.append(lines),
+            beginLive: () => this.beginLive(),
+            pushLive: (text) => this.pushLive(text),
+            endLive: () => this.endLive(),
+            setStatus: (status) => this.setStatus(status),
+            verbose: () => this.verbose,
+            aborted: () => this.abortRequested,
+        });
+        let result = null;
+        try {
+            result = await runAgent(input, {
+                provider,
+                model: this.model,
+                system,
+                tools: this.tools,
+                permissions: this.buildGate(),
+                maxSteps: this.opts.maxSteps,
+                reasoningEffort: this.activeEffort() ?? undefined,
+                session: this.session,
+                stream: true,
+                signal: this.abort.signal,
+                images,
+                onEvent: controller.handle,
+            });
+        }
+        catch (err) {
+            this.append([`  ${tone.red(`// ${errorMessage(err)}`)}`]);
+        }
+        finally {
+            this.endLive();
+            this.setStatus(null);
+            this.mode = "idle";
+            this.abort = null;
+        }
+        if (!result) {
+            this.scheduleRender();
+            return;
+        }
+        if (this.undoAfterAbort) {
+            this.undoAfterAbort = false;
+            this.abortRequested = false;
+            const undo = this.turnUndo;
+            this.turnUndo = null;
+            this.lastTurn = null;
+            if (undo) {
+                this.session = new Session(this.system, undo.snapshot);
+                this.transcript = this.transcript.slice(0, undo.transcriptLength);
+                this.userMarkers = this.userMarkers.filter((marker) => marker.line < undo.transcriptLength);
+                this.pendingInitial = undo.input;
+            }
+            this.messageCursor = -1;
+            this.scrollOffset = 0;
+            this.append([
+                `  ${tone.accent(glyphs.diamond)} ${tone.mist("// UNDONE — message restored to the input")}`,
+            ]);
+            this.scheduleRender();
+            return;
+        }
+        this.totalUsage = addUsage(this.totalUsage, result.usage);
+        this.turns += 1;
+        const status = this.abortRequested
+            ? "interrupted"
+            : result.status === "complete"
+                ? "complete"
+                : result.status === "max_steps"
+                    ? "max steps"
+                    : "failed";
+        controller.footer(status);
+        const recordId = await this.saveTurn(input, result, controller.durationMs);
+        if (this.turnUndo) {
+            this.lastTurn = { ...this.turnUndo, recordId };
+            this.turnUndo = null;
+        }
+        this.scheduleRender();
+    }
+    async command(line) {
+        const body = line.slice(1).trim();
+        const space = body.search(/\s/);
+        const name = (space === -1 ? body : body.slice(0, space)).toLowerCase();
+        const arg = space === -1 ? "" : body.slice(space).trim();
+        switch (name) {
+            case "help":
+                this.printHelp();
+                return false;
+            case "new":
+                this.session = new Session(this.system);
+                this.conversationId = makeSessionId();
+                this.lastTurn = null;
+                this.transcript = [];
+                this.userMarkers = [];
+                this.messageCursor = -1;
+                this.scrollOffset = 0;
+                this.append([`  ${tone.mist("// NEW CONVERSATION")}`, ""]);
+                return false;
+            case "undo":
+                await this.undoTurn();
+                return false;
+            case "model":
+                if (arg) {
+                    this.applyModel(resolveProviderForModel(arg) ?? this.providerId, arg);
+                    this.append([`  ${tone.mist(`// MODEL → ${this.providerId} · ${this.model}`)}`]);
+                }
+                else {
+                    const changed = await this.changeModel();
+                    if (changed) {
+                        this.append([`  ${tone.mist(`// MODEL → ${this.providerId} · ${this.model}`)}`]);
+                    }
+                }
+                return false;
+            case "effort":
+                await this.effortCommand(arg);
+                return false;
+            case "key": {
+                const keyEnv = keyEnvFor(this.providerId);
+                if (hasKey(this.providerId)) {
+                    this.append([`  ${tone.mist(`// ${keyEnv} IS SET`)}`]);
+                }
+                else {
+                    await this.promptForKey(keyEnv);
+                }
+                return false;
+            }
+            case "dir":
+                await this.changeDir(arg);
+                return false;
+            case "context":
+                await this.printContext();
+                return false;
+            case "usage":
+            case "cost":
+                this.printUsage();
+                return false;
+            case "sessions":
+                await this.sessionsCommand(arg);
+                return false;
+            case "timeline":
+                await this.timelineCommand();
+                return false;
+            case "verbose":
+                this.verbose = !this.verbose;
+                this.append([
+                    `  ${tone.mist(`// VERBOSE ${this.verbose ? "ON — FULL TOOL OUTPUT" : "OFF"}`)}`,
+                ]);
+                return false;
+            case "theme":
+                await this.changeTheme(arg);
+                return false;
+            case "skills":
+                await this.skillsCommand(arg);
+                return false;
+            case "mcp":
+                await this.mcpCommand(arg);
+                return false;
+            case "clear":
+                this.clearTranscript();
+                return false;
+            case "exit":
+            case "quit":
+                return true;
+            default:
+                this.append([`  ${tone.mist(`// unknown command: /${name} — try /help`)}`]);
+                return false;
+        }
+    }
+    async changeTheme(arg) {
+        const current = activeThemeId();
+        if (arg) {
+            this.applyTheme(arg);
+            return;
+        }
+        const entries = getThemes().map((theme) => ({
+            kind: "item",
+            value: theme.id,
+            label: theme.label,
+            hint: theme.id === current ? "current" : undefined,
+        }));
+        const chosen = await this.openPicker(new Picker({ title: "select a theme", entries, filterable: true }));
+        if (!chosen || chosen === current)
+            return;
+        this.applyTheme(chosen);
+    }
+    applyTheme(id) {
+        const before = { ...palette };
+        const theme = setTheme(id);
+        const pairs = buildColorRemap(before, palette);
+        this.transcript = this.transcript.map((line) => remapColors(line, pairs));
+        this.config.theme = theme.id;
+        void saveConfig({ ...this.config, theme: theme.id }).catch(() => undefined);
+        this.screen.applyBackground();
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// THEME → ${theme.label.toUpperCase()}`)}`,
+            "",
+        ]);
+    }
+    async sessionsCommand(arg) {
+        const limit = Number.parseInt(arg, 10);
+        const max = Number.isFinite(limit) && limit > 0 ? limit : 40;
+        for (;;) {
+            const records = await listSessionsForDir(this.dir, max);
+            const conversations = sortConversations(latestPerConversation(records));
+            if (conversations.length === 0) {
+                this.append([`  ${tone.mist(`// NO SESSIONS YET IN ${shortenHome(this.dir).toUpperCase()}`)}`]);
+                return;
+            }
+            const labelWidth = Math.max(20, this.contentWidth() - 62);
+            const entries = conversations.map((record) => ({
+                kind: "item",
+                value: conversationKey(record),
+                label: `${record.pinned ? `${glyphs.pin} ` : ""}${clipAnsi(displayTitle(record), labelWidth)}`,
+                hint: `${record.pinned ? "pinned · " : ""}${record.createdAt.slice(0, 16).replace("T", " ")} · ${record.model} · ${record.status} · ${record.steps} steps`,
+            }));
+            const chosen = await this.openPicker(new Picker({
+                title: "sessions · enter resumes",
+                entries,
+                filterable: true,
+                actions: ["rename", "pin", "delete"],
+            }));
+            if (!chosen)
+                return;
+            const record = conversations.find((item) => conversationKey(item) === chosen);
+            if (!record)
+                return;
+            const action = this.pickerAction;
+            if (action === "rename") {
+                await this.renameConversation(record);
+                continue;
+            }
+            if (action === "pin") {
+                const pinned = !record.pinned;
+                await updateConversation(chosen, { pinned });
+                this.append([
+                    `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// ${pinned ? "PINNED" : "UNPINNED"} → ${clipAnsi(displayTitle(record), 60)}`)}`,
+                ]);
+                continue;
+            }
+            if (action === "delete") {
+                const confirmed = await this.confirm(`delete session "${clipAnsi(displayTitle(record), 60)}"?`);
+                if (!confirmed) {
+                    this.append([`  ${tone.mist("// cancelled")}`]);
+                    continue;
+                }
+                const removed = await deleteConversation(chosen);
+                this.append([
+                    `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// SESSION DELETED → ${clipAnsi(displayTitle(record), 60)} · ${removed} record${removed === 1 ? "" : "s"}`)}`,
+                ]);
+                continue;
+            }
+            this.resumeSession(record);
+            return;
+        }
+    }
+    async renameConversation(record) {
+        const result = await this.readLine({
+            prompt: `  ${tone.bone("SESSION NAME")} ${tone.mist(glyphs.prompt)} `,
+            placeholder: clipAnsi(displayTitle(record), 60),
+            initial: record.title ?? "",
+        });
+        if (result.kind !== "submit") {
+            this.append([`  ${tone.mist("// cancelled")}`]);
+            return;
+        }
+        const title = result.text.replace(/\s+/g, " ").trim();
+        if (!title)
+            return;
+        await updateConversation(conversationKey(record), { title });
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// SESSION RENAMED → ${clipAnsi(title, 60)}`)}`,
+        ]);
+    }
+    resumeSession(record) {
+        const messages = record.messages ?? [];
+        this.session = new Session(this.system, messages);
+        this.conversationId = conversationKey(record);
+        if (record.model) {
+            this.providerId = resolveProviderForModel(record.model) ?? this.providerId;
+            this.model = record.model;
+            this.provider = null;
+        }
+        const task = record.task.replace(/\s+/g, " ");
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// RESUMED → ${clipAnsi(task, this.contentWidth() - 20)}`)}`,
+            `    ${tone.silver(`${messages.length} message${messages.length === 1 ? "" : "s"} · ${record.model} · ${record.createdAt.slice(0, 16).replace("T", " ")}`)}`,
+        ]);
+        if (record.text) {
+            this.append([`  ${tone.mist("// LAST ANSWER")}`]);
+            this.append(renderMarkdown(record.text, { width: this.contentWidth() - 2 }));
+        }
+        if (messages.length === 0) {
+            this.append([`  ${tone.mist("// no stored messages for this session (saved before resume support)")}`]);
+        }
+        this.append([""]);
+    }
+    async skillsCommand(arg) {
+        const parts = arg.split(/\s+/).filter(Boolean);
+        const sub = (parts[0] ?? "").toLowerCase();
+        const rest = parts.slice(1).join(" ").trim();
+        if (!sub || sub === "list") {
+            this.printSkills();
+            return;
+        }
+        if (sub === "add") {
+            if (!rest) {
+                await this.addSkillPasted();
+                return;
+            }
+            if (/^https?:\/\//i.test(rest)) {
+                await this.addSkillFromUrl(rest);
+                return;
+            }
+            await this.addSkillFromPath(rest);
+            return;
+        }
+        if (sub === "remove" || sub === "rm") {
+            if (!rest) {
+                this.append([`  ${tone.mist("// usage: /skills remove <name>")}`]);
+                return;
+            }
+            const needle = rest.toLowerCase();
+            const target = this.skills.find((skill) => skill.slug === needle || skill.name.toLowerCase() === needle);
+            if (!target) {
+                this.append([`  ${tone.red(`// no skill named ${rest}`)}`]);
+                return;
+            }
+            const confirmed = await this.confirm(`remove skill "${target.name}"?`);
+            if (!confirmed) {
+                this.append([`  ${tone.mist("// cancelled")}`]);
+                return;
+            }
+            const removed = await removeSkill(target.slug);
+            await this.refreshSkills();
+            this.append([
+                `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// SKILL REMOVED → ${removed?.name ?? target.name}`)}`,
+            ]);
+            return;
+        }
+        this.append([
+            `  ${tone.mist("// usage: /skills [list] · /skills add <path|url> · /skills add (paste) · /skills remove <name>")}`,
+        ]);
+    }
+    printSkills() {
+        const lines = [];
+        if (this.skills.length === 0) {
+            lines.push(`  ${tone.mist("// NO SKILLS INSTALLED")}`);
+        }
+        else {
+            lines.push(`  ${tone.mist(`// SKILLS (${this.skills.length})`)}`);
+            for (const skill of this.skills) {
+                lines.push(`  ${tone.bone(skill.name)}${skill.description ? `  ${tone.mist(skill.description)}` : ""}`);
+                lines.push(`    ${tone.silver(shortenHome(skill.path))}`);
+            }
+        }
+        lines.push("");
+        lines.push(`  ${tone.mist("// storage")} ${tone.silver(shortenHome(path.join(skillsRoot(), "<name>", "SKILL.md")))}`);
+        lines.push(`  ${tone.mist("// add: /skills add <path|url> · /skills add (paste markdown) · /skills remove <name>")}`);
+        this.append(lines);
+    }
+    async addSkillFromPath(sourcePath) {
+        try {
+            const skill = await importSkillFile(sourcePath);
+            await this.refreshSkills();
+            this.append([
+                `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// SKILL ADDED → ${skill.name}`)}`,
+                `    ${tone.silver(shortenHome(skill.path))}`,
+            ]);
+        }
+        catch (err) {
+            this.append([`  ${tone.red(`// could not import: ${errorMessage(err)}`)}`]);
+        }
+    }
+    async addSkillFromUrl(url) {
+        this.setStatus({ label: "DOWNLOADING SKILL" });
+        try {
+            const skill = await fetchSkillFromUrl(url);
+            await this.refreshSkills();
+            this.append([
+                `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// SKILL ADDED → ${skill.name}`)}`,
+                `    ${tone.silver(shortenHome(skill.path))}`,
+            ]);
+        }
+        catch (err) {
+            this.append([`  ${tone.red(`// download failed: ${errorMessage(err)}`)}`]);
+        }
+        finally {
+            this.setStatus(null);
+        }
+    }
+    async addSkillPasted() {
+        this.append([
+            `  ${tone.mist("// paste SKILL.md content below · enter to save · esc to cancel")}`,
+        ]);
+        const result = await this.readLine({
+            prompt: `  ${tone.bone("SKILL")} ${tone.mist(glyphs.prompt)} `,
+            placeholder: "paste markdown, then press enter",
+        });
+        if (result.kind !== "submit") {
+            this.append([`  ${tone.mist("// cancelled")}`]);
+            return;
+        }
+        const content = result.text.trim();
+        if (!content) {
+            this.append([`  ${tone.mist("// cancelled")}`]);
+            return;
+        }
+        let name = parseSkill(content, "").name;
+        if (!name) {
+            const nameResult = await this.readLine({
+                prompt: `  ${tone.bone("SKILL NAME")} ${tone.mist(glyphs.prompt)} `,
+                placeholder: "e.g. code-review",
+            });
+            if (nameResult.kind !== "submit" || !nameResult.text.trim()) {
+                this.append([`  ${tone.mist("// cancelled")}`]);
+                return;
+            }
+            name = nameResult.text.trim();
+        }
+        const skill = await saveSkill(name, content);
+        await this.refreshSkills();
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// SKILL ADDED → ${skill.name}`)}`,
+            `    ${tone.silver(shortenHome(skill.path))}`,
+        ]);
+    }
+    async refreshSkills() {
+        this.skills = await listSkills().catch(() => []);
+    }
+    async mcpCommand(arg) {
+        const parts = arg.split(/\s+/).filter(Boolean);
+        const sub = (parts[0] ?? "").toLowerCase();
+        const rest = parts.slice(1).join(" ").trim();
+        if (isMcpUrl(arg)) {
+            await this.addMcpServer(arg.trim());
+            return;
+        }
+        if (!sub || sub === "list" || sub === "ls" || sub === "status") {
+            this.printMcp();
+            return;
+        }
+        if (sub === "add") {
+            await this.addMcpServer(rest);
+            return;
+        }
+        if (sub === "remove" || sub === "rm" || sub === "delete") {
+            await this.removeMcpServer(rest);
+            return;
+        }
+        if (sub === "enable" || sub === "disable") {
+            await this.toggleMcpServer(rest, sub === "enable");
+            return;
+        }
+        if (sub === "reconnect" || sub === "reload" || sub === "restart") {
+            await this.reconnectMcp(rest);
+            return;
+        }
+        if (sub === "tools") {
+            this.printMcpTools(rest);
+            return;
+        }
+        this.append([`  ${tone.mist(`// usage: ${MCP_USAGE}`)}`]);
+    }
+    printMcp() {
+        const statuses = this.mcp.statuses();
+        const lines = [];
+        if (statuses.length === 0) {
+            lines.push(`  ${tone.mist("// NO MCP SERVERS CONFIGURED")}`);
+        }
+        else {
+            lines.push(`  ${tone.mist(`// MCP SERVERS (${statuses.length})`)}`);
+            for (const status of statuses) {
+                const badge = status.state === "connected"
+                    ? tone.accent(glyphs.check)
+                    : status.state === "error"
+                        ? tone.red(glyphs.cross)
+                        : tone.mist(glyphs.bullet);
+                const state = status.state === "connected"
+                    ? tone.mist(`${status.tools.length} tool${status.tools.length === 1 ? "" : "s"}${status.serverName ? ` · ${status.serverName}${status.serverVersion ? ` ${status.serverVersion}` : ""}` : ""}`)
+                    : status.state === "error"
+                        ? tone.red(clipAnsi(status.error ?? "connection failed", this.contentWidth() - 30))
+                        : tone.mist("disabled");
+                lines.push(`  ${badge} ${padEndTo(tone.bone(status.name), 20)}${state}`);
+                lines.push(`    ${tone.silver(status.kind)} ${tone.mist(clipAnsi(status.target, Math.max(20, this.contentWidth() - 16)))}`);
+            }
+        }
+        lines.push("");
+        lines.push(`  ${tone.mist("// config")} ${tone.silver(shortenHome(configFile()))}`);
+        lines.push(`  ${tone.mist(`// ${MCP_USAGE}`)}`);
+        this.append(lines);
+    }
+    async addMcpServer(rest) {
+        let spec = rest;
+        if (!spec) {
+            const nameResult = await this.readLine({
+                prompt: `  ${tone.bone("MCP NAME")} ${tone.mist(glyphs.prompt)} `,
+                placeholder: "e.g. filesystem — or paste a service url",
+            });
+            if (nameResult.kind !== "submit" || !nameResult.text.trim()) {
+                this.append([`  ${tone.mist("// cancelled")}`]);
+                return;
+            }
+            const answer = nameResult.text.trim();
+            if (isMcpUrl(answer)) {
+                spec = answer;
+            }
+            else {
+                const targetResult = await this.readLine({
+                    prompt: `  ${tone.bone("MCP SERVER")} ${tone.mist(glyphs.prompt)} `,
+                    placeholder: "npx -y @modelcontextprotocol/server-filesystem .  ·  https://host/mcp",
+                });
+                if (targetResult.kind !== "submit" || !targetResult.text.trim()) {
+                    this.append([`  ${tone.mist("// cancelled")}`]);
+                    return;
+                }
+                spec = `${answer} ${targetResult.text.trim()}`;
+            }
+        }
+        const parsed = parseMcpAdd(spec);
+        if (!parsed.ok) {
+            this.append([
+                `  ${tone.red(`// ${parsed.error}`)}`,
+                `  ${tone.mist(`// usage: ${MCP_USAGE}`)}`,
+            ]);
+            return;
+        }
+        if (this.config.mcp?.[parsed.name]) {
+            const confirmed = await this.confirm(`replace MCP server "${parsed.name}"?`);
+            if (!confirmed) {
+                this.append([`  ${tone.mist("// cancelled")}`]);
+                return;
+            }
+        }
+        this.config.mcp = { ...(this.config.mcp ?? {}), [parsed.name]: parsed.config };
+        await saveConfig({ ...this.config }).catch(() => undefined);
+        this.setStatus({ label: `MCP · CONNECTING ${parsed.name.toUpperCase()}` });
+        const status = await this.mcp.connect(parsed.name, parsed.config);
+        this.setStatus(null);
+        this.rebuildTools();
+        this.reportMcpStatus(status);
+    }
+    async removeMcpServer(rest) {
+        const name = rest.split(/\s+/).filter(Boolean)[0];
+        if (!name) {
+            this.append([`  ${tone.mist("// usage: /mcp remove <name>")}`]);
+            return;
+        }
+        const configs = this.config.mcp ?? {};
+        if (!(name in configs)) {
+            this.append([`  ${tone.red(`// no MCP server named ${name}`)}`]);
+            return;
+        }
+        const confirmed = await this.confirm(`remove MCP server "${name}"?`);
+        if (!confirmed) {
+            this.append([`  ${tone.mist("// cancelled")}`]);
+            return;
+        }
+        await this.mcp.remove(name);
+        const next = { ...configs };
+        delete next[name];
+        this.config.mcp = next;
+        await saveConfig({ ...this.config }).catch(() => undefined);
+        this.rebuildTools();
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// MCP REMOVED → ${name}`)}`,
+        ]);
+    }
+    async toggleMcpServer(rest, enabled) {
+        const name = rest.split(/\s+/).filter(Boolean)[0];
+        if (!name) {
+            this.append([`  ${tone.mist(`// usage: /mcp ${enabled ? "enable" : "disable"} <name>`)}`]);
+            return;
+        }
+        const configs = this.config.mcp ?? {};
+        const config = configs[name];
+        if (!config) {
+            this.append([`  ${tone.red(`// no MCP server named ${name}`)}`]);
+            return;
+        }
+        const wasEnabled = config.enabled !== false;
+        if (wasEnabled === enabled) {
+            this.append([`  ${tone.mist(`// MCP ${name} IS ALREADY ${enabled ? "ENABLED" : "DISABLED"}`)}`]);
+            return;
+        }
+        const updated = { ...config, enabled };
+        this.config.mcp = { ...configs, [name]: updated };
+        await saveConfig({ ...this.config }).catch(() => undefined);
+        if (enabled)
+            this.setStatus({ label: `MCP · CONNECTING ${name.toUpperCase()}` });
+        const status = await this.mcp.connect(name, updated);
+        this.setStatus(null);
+        this.rebuildTools();
+        this.reportMcpStatus(status);
+    }
+    async reconnectMcp(rest) {
+        const name = rest.split(/\s+/).filter(Boolean)[0];
+        const configs = this.config.mcp ?? {};
+        if (name) {
+            const config = configs[name];
+            if (!config) {
+                this.append([`  ${tone.red(`// no MCP server named ${name}`)}`]);
+                return;
+            }
+            this.setStatus({ label: `MCP · RECONNECTING ${name.toUpperCase()}` });
+            const status = await this.mcp.connect(name, config);
+            this.setStatus(null);
+            this.rebuildTools();
+            this.reportMcpStatus(status);
+            return;
+        }
+        const names = Object.keys(configs);
+        if (names.length === 0) {
+            this.append([`  ${tone.mist("// NO MCP SERVERS CONFIGURED")}`]);
+            return;
+        }
+        this.setStatus({ label: "MCP · RECONNECTING" });
+        const statuses = await this.mcp.connectAll(configs);
+        this.setStatus(null);
+        this.rebuildTools();
+        const failed = statuses.filter((status) => status.state === "error").length;
+        this.append([
+            `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// MCP RECONNECTED · ${statuses.length - failed}/${statuses.length} connected`)}`,
+        ]);
+        this.printMcp();
+    }
+    printMcpTools(rest) {
+        const name = rest.split(/\s+/).filter(Boolean)[0];
+        if (name && !this.mcp.has(name)) {
+            this.append([`  ${tone.red(`// no MCP server named ${name}`)}`]);
+            return;
+        }
+        const statuses = name ? [this.mcp.status(name)] : this.mcp.statuses();
+        const lines = [];
+        let printed = false;
+        for (const status of statuses) {
+            if (status.tools.length === 0)
+                continue;
+            printed = true;
+            lines.push(`  ${tone.mist(`// ${status.name} (${status.tools.length})`)}`);
+            for (const tool of status.tools) {
+                const hint = tool.readOnly ? tone.mist("  · read-only") : "";
+                const descWidth = Math.max(20, this.contentWidth() - 48);
+                lines.push(`  ${padEndTo(tone.bone(tool.name), 42)}${tone.silver(clipAnsi(tool.description, descWidth))}${hint}`);
+            }
+        }
+        if (!printed)
+            lines.push(`  ${tone.mist("// NO MCP TOOLS")}`);
+        this.append(lines);
+    }
+    reportMcpStatus(status) {
+        if (status.state === "connected") {
+            const version = status.serverName
+                ? ` · ${status.serverName}${status.serverVersion ? ` ${status.serverVersion}` : ""}`
+                : "";
+            const lines = [
+                `  ${tone.accent(glyphs.diamond)} ${tone.mist(`// MCP → ${status.name} CONNECTED${version} · ${status.tools.length} tool${status.tools.length === 1 ? "" : "s"}`)}`,
+            ];
+            if (status.tools.length > 0) {
+                const names = status.tools.map((tool) => tool.name).join(", ");
+                lines.push(`    ${tone.silver(clipAnsi(names, this.contentWidth() - 6))}`);
+            }
+            this.append(lines);
+            return;
+        }
+        if (status.state === "disabled") {
+            this.append([`  ${tone.mist(`// MCP → ${status.name} DISABLED`)}`]);
+            return;
+        }
+        this.append([
+            `  ${tone.red(`// MCP → ${status.name} FAILED: ${clipAnsi(status.error ?? "connection failed", Math.max(20, this.contentWidth() - 24))}`)}`,
+        ]);
+    }
+    async confirm(question) {
+        this.permissionOptions = [];
+        this.permissionOptionLine = null;
+        this.append([`  ${tone.amber(question)}`]);
+        this.permissionHint = ` ${tone.bone("Y")} ${tone.mist("yes")}    ${tone.bone("N")} ${tone.mist("no")}`;
+        this.mode = "permission";
+        this.scheduleRender();
+        const choice = await new Promise((resolve) => {
+            this.resolveChoice = resolve;
+        });
+        this.mode = "idle";
+        this.scheduleRender();
+        return choice === "allow" || choice === "always";
+    }
+    async changeDir(arg) {
+        if (!arg) {
+            this.append([`  ${tone.mist(`// DIR ${this.dir}`)}`]);
+            return;
+        }
+        const next = path.resolve(this.dir, arg);
+        if (next === this.dir) {
+            this.append([`  ${tone.mist("// already in this directory")}`]);
+            return;
+        }
+        this.dir = next;
+        this.rebuildTools();
+        this.session = new Session("");
+        try {
+            const meta = await this.loadProject();
+            this.session = new Session(this.system);
+            this.append([
+                `  ${tone.mist(`// DIR → ${shortenHome(this.dir)}`)}`,
+                `  ${tone.mist("// PROJECT")}  ${meta}`,
+            ]);
+        }
+        catch (err) {
+            this.append([`  ${tone.red(`// failed to scan project: ${errorMessage(err)}`)}`]);
+        }
+    }
+    async printContext() {
+        if (!this.summary) {
+            try {
+                this.summary = await scanProject(this.dir);
+            }
+            catch (err) {
+                this.append([`  ${tone.red(`// ${errorMessage(err)}`)}`]);
+                return;
+            }
+        }
+        const summary = this.summary;
+        const rows = [
+            ["name", summary.name],
+            ["stack", summary.frameworks.join(", ") || "—"],
+            [
+                "languages",
+                summary.languages
+                    .slice(0, 4)
+                    .map((l) => `${l.ext} (${l.count})`)
+                    .join(", ") || "—",
+            ],
+            ["files", `${summary.fileCount} (${summary.sourceFileCount} source)`],
+            ["package manager", summary.packageManager ?? "—"],
+            ["dependencies", `${summary.dependencyCount} + ${summary.devDependencyCount} dev`],
+        ];
+        const lines = [`  ${tone.mist("// CONTEXT")}`];
+        for (const [key, value] of rows) {
+            lines.push(`  ${padEndTo(tone.bone(key), 18)}${tone.silver(clipAnsi(value, this.contentWidth() - 24))}`);
+        }
+        if (summary.keyFiles.length > 0) {
+            lines.push(`  ${padEndTo(tone.bone("key files"), 18)}`);
+            for (const file of summary.keyFiles.slice(0, 6)) {
+                lines.push(`    ${tone.silver(file.path)} ${tone.mist(`(${file.kind})`)}`);
+            }
+        }
+        this.append(lines);
+    }
+    printUsage() {
+        const cost = estimateCost(this.totalUsage, this.model, this.providerId);
+        const rows = [
+            ["turns", String(this.turns)],
+            [
+                "tokens",
+                `${fmtTokens(this.totalUsage.inputTokens)}↑ ${fmtTokens(this.totalUsage.outputTokens)}↓`,
+            ],
+            ["cost", fmtCost(cost)],
+            ["elapsed", fmtDuration(performance.now() - this.startedAt)],
+            ["model", `${this.providerId} · ${this.model}`],
+            ["effort", this.activeEffort() ?? "default"],
+        ];
+        const lines = [`  ${tone.mist("// SESSION USAGE")}`];
+        for (const [key, value] of rows) {
+            lines.push(`  ${padEndTo(tone.bone(key), 12)}${tone.silver(value)}`);
+        }
+        this.append(lines);
+    }
+    async timelineCommand() {
+        if (this.userMarkers.length === 0) {
+            this.append([`  ${tone.mist("// NO MESSAGES YET")}`]);
+            return;
+        }
+        const width = Math.max(20, this.contentWidth() - 40);
+        const total = this.userMarkers.length;
+        const entries = this.userMarkers.map((marker, index) => ({
+            kind: "item",
+            value: String(index),
+            label: clipAnsi(marker.text.replace(/\s+/g, " ").trim() || "(empty)", width),
+            hint: `${index + 1}/${total}`,
+        }));
+        const chosen = await this.openPicker(new Picker({ title: "timeline · enter jumps to the message", entries, filterable: true }));
+        if (!chosen)
+            return;
+        const marker = this.userMarkers[Number.parseInt(chosen, 10)];
+        if (!marker)
+            return;
+        this.focusTranscriptLine(marker.line);
+    }
+    focusTranscriptLine(line) {
+        const total = this.transcript.length;
+        const viewport = Math.max(3, this.lastViewport);
+        this.scrollOffset = Math.max(0, total - line - viewport);
+        this.scheduleRender();
+    }
+    printHelp() {
+        const keys = [
+            ["enter", "send"],
+            ["ctrl+enter", "newline (shift+enter, ctrl+space, ctrl+j, \\ + enter too)"],
+            ["ctrl+v", "paste text or an image"],
+            ["mouse drag", "select text · ctrl+c copies"],
+            ["permission card", "← → select · enter confirm · mouse click"],
+            ["sessions picker", "ctrl+r rename · ctrl+p pin · ctrl+d delete"],
+            ["↑ ↓", "input history — previous / next message"],
+            ["wheel", "scroll the conversation"],
+            ["ctrl+p/ctrl+n", "input history (same as ↑ ↓)"],
+            ["tab", "plan/build mode · complete commands"],
+            ["ctrl+z", "undo the last message (works while thinking)"],
+            ["esc", "interrupt a run"],
+            ["ctrl+c", "clear input / exit"],
+        ];
+        const lines = [`  ${tone.mist("// COMMANDS")}`];
+        for (const command of COMMAND_INFO) {
+            const name = `${command.name}${command.args ? ` ${command.args}` : ""}`;
+            lines.push(`  ${padEndTo(tone.bone(name), 20)}${tone.silver(command.desc)}`);
+        }
+        lines.push("", `  ${tone.mist("// KEYS")}`);
+        for (const [name, desc] of keys) {
+            lines.push(`  ${padEndTo(tone.bone(name), 18)}${tone.silver(desc)}`);
+        }
+        this.append(lines);
+    }
+    userBlockLines(input, imageCount = 0) {
+        const lines = input.split("\n");
+        const head = `  ${tone.accent(glyphs.prompt)} ${bold(tone.bone(lines[0] ?? ""))}`;
+        const rest = lines.slice(1).map((line) => `    ${tone.bone(line)}`);
+        const images = imageCount > 0
+            ? [`    ${tone.mist(`[${imageCount} image${imageCount === 1 ? "" : "s"} attached]`)}`]
+            : [];
+        return [head, ...rest, ...images];
+    }
+    async saveTurn(input, result, durationMs) {
+        const cost = estimateCost(result.usage, this.model, this.providerId);
+        const record = {
+            id: makeSessionId(),
+            createdAt: new Date().toISOString(),
+            cwd: this.dir,
+            task: input,
+            model: this.model,
+            status: result.status,
+            steps: result.steps,
+            usage: result.usage,
+            costCents: cost?.totalCents,
+            durationMs,
+            text: result.text,
+            error: result.error,
+            events: result.events
+                .filter((event) => event.type !== "text.delta")
+                .map((event) => event.type === "tool.result" && event.images ? { ...event, images: undefined } : event),
+            conversationId: this.conversationId,
+            messages: messagesForStorage(result.session.getMessages()),
+        };
+        try {
+            await saveSession(record);
+        }
+        catch (err) {
+            this.append([`  ${tone.mist(`// could not save session: ${errorMessage(err)}`)}`]);
+        }
+        return record.id;
+    }
+    printGoodbye() {
+        this.append(["", `  ${tone.mist(`// SESSION CLOSED · ${this.summaryLine()}`)}`]);
+    }
+    summaryLine() {
+        const cost = estimateCost(this.totalUsage, this.model, this.providerId);
+        const parts = [
+            `${this.turns} turn${this.turns === 1 ? "" : "s"}`,
+            `${fmtTokens(this.totalUsage.inputTokens)}↑ ${fmtTokens(this.totalUsage.outputTokens)}↓`,
+            fmtCost(cost),
+        ];
+        return `quatcode: session closed · ${parts.join(" · ")}`;
+    }
+}
+function box(title, body, inner, borderHex) {
+    const b = glyphs.box;
+    const label = ` ${title} `;
+    const fill = Math.max(0, inner - 1 - stringWidth(label));
+    const lines = [
+        `  ${fg(borderHex, b.tl + b.h)}${tone.mist(label)}${fg(borderHex, b.h.repeat(fill))}${fg(borderHex, b.tr)}`,
+    ];
+    for (const row of body) {
+        const content = padEndTo(clipAnsi(row, inner - 2), inner - 2);
+        lines.push(`  ${fg(borderHex, b.v)} ${content} ${fg(borderHex, b.v)}`);
+    }
+    lines.push(`  ${fg(borderHex, b.bl + b.h.repeat(inner) + b.br)}`);
+    return lines;
+}
+function permissionSummary(req) {
+    if (req.input === null || req.input === undefined)
+        return "";
+    if (typeof req.input !== "object")
+        return String(req.input);
+    const record = req.input;
+    const candidate = record.command ?? record.path ?? record.pattern ?? record.url ?? record.query ?? "";
+    if (typeof candidate === "string") {
+        return candidate.replace(/\s+/g, " ").slice(0, 400);
+    }
+    try {
+        return JSON.stringify(req.input).slice(0, 400);
+    }
+    catch {
+        return "";
+    }
+}
+function shortenHome(dir) {
+    const home = homedir();
+    return dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function longestCommonPrefix(items) {
+    if (items.length === 0)
+        return "";
+    let prefix = items[0];
+    for (const item of items.slice(1)) {
+        while (!item.startsWith(prefix)) {
+            prefix = prefix.slice(0, -1);
+            if (prefix === "")
+                return "";
+        }
+    }
+    return prefix;
+}
+//# sourceMappingURL=tui.js.map