deepclause-sdk 0.0.59 → 0.0.61

package/dist/cli/tui.js

@@ -0,0 +1,3552 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { emitKeypressEvents } from 'readline';
+import { createInterface } from 'readline/promises';
+import { stdin as input, stdout as output } from 'process';
+import { listCommands } from './commands.js';
+import { getConfigPath, loadConfig, resolveModelSlot } from './config.js';
+import { run } from './run.js';
+import { createLocalSkill, createConductorSession, getConductorSessionDetail, listConductorSessions, runConductorTurn, } from '../system/runtime/conductor.js';
+const IGNORED_LIVE_LOG_TOOLS = new Set(['set_result', 'update_memory']);
+const BUILTIN_SLASH_COMMANDS = ['new', 'sessions', 'help', 'compile', 'skill-creator', 'cancel', 'exit', 'quit'];
+const CHILD_EVENT_INDENT = '\t';
+const CHILD_EVENT_TAB_WIDTH = 4;
+const MAX_ACTIVITY_LINES = 400;
+const SPINNER_FRAMES = ['|', '/', '-', '\\'];
+const IDLE_RENDER_INTERVAL_MS = 16;
+const BUSY_RENDER_INTERVAL_MS = 40;
+const TYPING_RENDER_INTERVAL_MS = 90;
+const COMBINING_MARK_RE = /\p{Mark}/u;
+const EXTENDED_PICTOGRAPHIC_RE = /\p{Extended_Pictographic}/u;
+const TEXT_FILE_EXTENSIONS = new Set([
+    '.dml', '.md', '.txt', '.json', '.yaml', '.yml', '.toml', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.css', '.scss', '.html', '.sql', '.py', '.sh', '.bash', '.zsh', '.pro', '.pl', '.csv', '.env', '.example',
+]);
+const TEXT_FILE_BASENAMES = new Set(['README', 'README.md', 'AGENTS.md', 'SPEC.md', 'ARCHITECTURE.md', 'CMD_LINE.md']);
+const IGNORED_WORKSPACE_DIRS = new Set(['.git', 'node_modules', 'dist', '.next', 'coverage', 'agentvm-cache']);
+const graphemeSegmenter = (() => {
+    const Segmenter = Intl.Segmenter;
+    return Segmenter ? new Segmenter(undefined, { granularity: 'grapheme' }) : null;
+})();
+const ANSI = {
+    reset: '\u001b[0m',
+    bold: '\u001b[1m',
+    dim: '\u001b[2m',
+    black: '\u001b[30m',
+    red: '\u001b[31m',
+    blue: '\u001b[34m',
+    white: '\u001b[37m',
+    green: '\u001b[32m',
+    yellow: '\u001b[33m',
+    cyan: '\u001b[36m',
+    brightYellow: '\u001b[93m',
+    brightCyan: '\u001b[96m',
+    brightWhite: '\u001b[97m',
+    bgBlue: '\u001b[48;2;0;0;95m',
+    bgCyan: '\u001b[48;2;0;96;128m',
+    bgWhite: '\u001b[47m',
+};
+export class LiveExecutionPrinter {
+    write;
+    writeLine;
+    activeStreamKey = null;
+    streamOpen = false;
+    constructor(write = (text) => process.stdout.write(text), writeLine = (text) => console.log(text)) {
+        this.write = write;
+        this.writeLine = writeLine;
+    }
+    handle(logEvent) {
+        const { event } = logEvent;
+        if (event.type === 'usage' || event.type === 'finished') {
+            return;
+        }
+        if (event.type === 'stream') {
+            this.handleStream(logEvent);
+            return;
+        }
+        this.flushStream();
+        switch (event.type) {
+            case 'tool_call':
+                if (!event.toolName || IGNORED_LIVE_LOG_TOOLS.has(event.toolName)) {
+                    return;
+                }
+                this.writeLine(`${formatEventPrefix(logEvent)}tool ${event.toolName}(${formatToolArgs(event.toolArgs)})`);
+                break;
+            case 'output':
+                if (event.content) {
+                    this.writeLine(`${formatEventPrefix(logEvent)}output ${event.content}`);
+                }
+                break;
+            case 'answer':
+                if (event.content) {
+                    this.writeLine(`${formatEventPrefix(logEvent)}answer ${event.content}`);
+                }
+                break;
+            case 'error':
+                if (event.content) {
+                    this.writeLine(`${formatEventPrefix(logEvent)}error ${event.content}`);
+                }
+                break;
+            case 'log':
+                if (event.content) {
+                    this.writeLine(`${formatEventPrefix(logEvent)}log ${event.content}`);
+                }
+                break;
+            case 'input_required':
+                if (event.prompt) {
+                    this.writeLine(`${formatEventPrefix(logEvent)}clarify ${event.prompt}`);
+                }
+                break;
+        }
+    }
+    finish() {
+        this.flushStream();
+    }
+    handleStream(logEvent) {
+        const streamKey = logEvent.scope === 'child' ? `child:${logEvent.childSlug ?? '?'}` : 'main';
+        if (this.activeStreamKey !== streamKey) {
+            this.flushStream();
+            this.write(`${streamLabel(logEvent)} `);
+            this.activeStreamKey = streamKey;
+            this.streamOpen = true;
+        }
+        if (logEvent.event.content) {
+            this.write(logEvent.event.content);
+        }
+        if (logEvent.event.done) {
+            this.flushStream();
+        }
+    }
+    flushStream() {
+        if (!this.streamOpen) {
+            this.activeStreamKey = null;
+            return;
+        }
+        this.write('\n');
+        this.streamOpen = false;
+        this.activeStreamKey = null;
+    }
+}
+class ActivityBuffer {
+    lines = [];
+    activeStreamKey = null;
+    activeStreamLine = '';
+    handle(logEvent) {
+        const { event } = logEvent;
+        if (event.type === 'usage' || event.type === 'finished') {
+            return;
+        }
+        if (event.type === 'stream') {
+            this.handleStream(logEvent);
+            return;
+        }
+        this.flushStream();
+        switch (event.type) {
+            case 'tool_call':
+                if (!event.toolName || IGNORED_LIVE_LOG_TOOLS.has(event.toolName)) {
+                    return;
+                }
+                this.pushLine(`${formatEventPrefix(logEvent)}tool ${event.toolName}(${formatToolArgs(event.toolArgs)})`);
+                break;
+            case 'output':
+                if (event.content) {
+                    this.pushLine(`${formatEventPrefix(logEvent)}output ${event.content}`);
+                }
+                break;
+            case 'answer':
+                if (event.content) {
+                    this.pushLine(`${formatEventPrefix(logEvent)}answer ${event.content}`);
+                }
+                break;
+            case 'error':
+                if (event.content) {
+                    this.pushLine(`${formatEventPrefix(logEvent)}error ${event.content}`);
+                }
+                break;
+            case 'log':
+                if (event.content) {
+                    this.pushLine(`${formatEventPrefix(logEvent)}log ${event.content}`);
+                }
+                break;
+            case 'input_required':
+                if (event.prompt) {
+                    this.pushLine(`${formatEventPrefix(logEvent)}clarify ${event.prompt}`);
+                }
+                break;
+        }
+    }
+    pushLine(line) {
+        this.flushStream();
+        if (!line) {
+            return;
+        }
+        this.lines.push(line);
+        this.trim();
+    }
+    finish() {
+        this.flushStream();
+    }
+    clear() {
+        this.lines.length = 0;
+        this.activeStreamKey = null;
+        this.activeStreamLine = '';
+    }
+    snapshot() {
+        return this.activeStreamLine
+            ? [...this.lines, this.activeStreamLine]
+            : [...this.lines];
+    }
+    handleStream(logEvent) {
+        const streamKey = logEvent.scope === 'child' ? `child:${logEvent.childSlug ?? '?'}` : 'main';
+        if (this.activeStreamKey !== streamKey) {
+            this.flushStream();
+            this.activeStreamKey = streamKey;
+            this.activeStreamLine = `${streamLabel(logEvent)} `;
+        }
+        if (logEvent.event.content) {
+            this.activeStreamLine += logEvent.event.content;
+        }
+        if (logEvent.event.done) {
+            this.flushStream();
+        }
+    }
+    flushStream() {
+        if (!this.activeStreamLine) {
+            this.activeStreamKey = null;
+            return;
+        }
+        this.lines.push(this.activeStreamLine);
+        this.activeStreamLine = '';
+        this.activeStreamKey = null;
+        this.trim();
+    }
+    trim() {
+        if (this.lines.length > MAX_ACTIVITY_LINES) {
+            this.lines.splice(0, this.lines.length - MAX_ACTIVITY_LINES);
+        }
+    }
+}
+class FullscreenTui {
+    workspaceRoot;
+    options;
+    sessions = [];
+    selectedSessionId = '';
+    sessionDetail = null;
+    commands = [];
+    activityBySessionId = new Map();
+    ephemeralMessagesBySessionId = new Map();
+    focusedPane = 'messages';
+    uiMode = 'command';
+    menuReturnMode = 'command';
+    menuState = {
+        activeIndex: 0,
+        selectedIndex: 0,
+        typeahead: '',
+        typeaheadAt: 0,
+    };
+    paneScroll = {
+        sessions: 0,
+        messages: 0,
+        process: 0,
+        context: 0,
+    };
+    currentPreview = null;
+    currentAbortController = null;
+    inputValue = '';
+    cursor = 0;
+    busy = false;
+    exitRequested = false;
+    statusLine = 'Loading...';
+    pendingPrompt = null;
+    pickerState = null;
+    viewerState = null;
+    editorState = null;
+    recentFiles = [];
+    lastSubmittedInput = null;
+    renderTimer = null;
+    animationTimer = null;
+    closeResolver = null;
+    lastRenderAt = 0;
+    previousFrameLines = null;
+    previousFrameSize = null;
+    constructor(workspaceRoot, options = {}) {
+        this.workspaceRoot = workspaceRoot;
+        this.options = options;
+    }
+    async start() {
+        try {
+            await this.refreshCommands();
+            await this.refreshSessions({ createIfMissing: true });
+            this.statusLine = 'Ready. F10 or Ctrl+G opens menus. Left/right changes pane when the menu is closed.';
+            emitKeypressEvents(input);
+            if (input.isTTY) {
+                input.setRawMode(true);
+            }
+            input.on('keypress', this.onKeypress);
+            output.write('\u001b[?1049h\u001b[2J\u001b[H');
+            this.requestRender();
+            await new Promise((resolve) => {
+                this.closeResolver = resolve;
+            });
+        }
+        finally {
+            if (this.renderTimer) {
+                clearTimeout(this.renderTimer);
+                this.renderTimer = null;
+            }
+            if (this.animationTimer) {
+                clearInterval(this.animationTimer);
+                this.animationTimer = null;
+            }
+            input.off('keypress', this.onKeypress);
+            if (input.isTTY) {
+                input.setRawMode(false);
+            }
+            this.previousFrameLines = null;
+            this.previousFrameSize = null;
+            output.write('\u001b[?25h\u001b[?1049l');
+        }
+    }
+    onKeypress = (text, key) => {
+        void this.handleKeypress(text, key);
+    };
+    async handleKeypress(text, key) {
+        if ((key.ctrl && key.name === 'g') || key.name === 'f10') {
+            this.toggleMenuMode();
+            return;
+        }
+        if (key.ctrl && key.name === 'p' && !this.pendingPrompt && !this.busy) {
+            this.openActionPalette();
+            return;
+        }
+        if (key.ctrl && key.name === 'w') {
+            this.cyclePaneFocus(1);
+            return;
+        }
+        if (key.ctrl && key.name === 'c') {
+            if (this.pendingPrompt) {
+                const pending = this.pendingPrompt;
+                this.pendingPrompt = null;
+                pending.resolve('');
+                if (!this.busy) {
+                    this.statusLine = 'Input cancelled.';
+                    this.requestRender();
+                    return;
+                }
+            }
+            if (this.busy) {
+                this.exitRequested = true;
+                this.cancelCurrentExecution('Cancelling current execution, then quitting...');
+                return;
+            }
+            this.close();
+            return;
+        }
+        if (this.uiMode === 'menu') {
+            await this.handleMenuKeypress(text, key);
+            return;
+        }
+        if (this.uiMode === 'picker' || this.uiMode === 'palette') {
+            await this.handlePickerKeypress(text, key);
+            return;
+        }
+        if (this.uiMode === 'viewer') {
+            await this.handleViewerKeypress(key);
+            return;
+        }
+        if (this.uiMode === 'editor') {
+            await this.handleEditorKeypress(text, key);
+            return;
+        }
+        switch (key.name) {
+            case 'return':
+                await this.submitInput();
+                return;
+            case 'backspace':
+                this.deleteBackward();
+                break;
+            case 'delete':
+                this.deleteForward();
+                break;
+            case 'left':
+                if (!this.inputValue) {
+                    this.cyclePaneFocus(-1);
+                    return;
+                }
+                if (this.cursor > 0) {
+                    this.cursor -= 1;
+                }
+                break;
+            case 'right':
+                if (!this.inputValue) {
+                    this.cyclePaneFocus(1);
+                    return;
+                }
+                if (this.cursor < this.inputValue.length) {
+                    this.cursor += 1;
+                }
+                break;
+            case 'home':
+                if (!this.inputValue) {
+                    this.jumpFocusedPane('top');
+                    return;
+                }
+                this.cursor = 0;
+                break;
+            case 'end':
+                if (!this.inputValue) {
+                    this.jumpFocusedPane('bottom');
+                    return;
+                }
+                this.cursor = this.inputValue.length;
+                break;
+            case 'up':
+                if (!this.inputValue) {
+                    await this.handleUpDown(-1);
+                    return;
+                }
+                break;
+            case 'down':
+                if (!this.inputValue) {
+                    await this.handleUpDown(1);
+                    return;
+                }
+                break;
+            case 'pageup':
+                if (!this.inputValue) {
+                    this.scrollFocusedPane('up', this.pageScrollAmount());
+                    return;
+                }
+                break;
+            case 'pagedown':
+                if (!this.inputValue) {
+                    this.scrollFocusedPane('down', this.pageScrollAmount());
+                    return;
+                }
+                break;
+            case 'tab':
+                await this.applyCompletion();
+                return;
+            case 'escape':
+                this.inputValue = '';
+                this.cursor = 0;
+                break;
+            default:
+                if (text && !key.ctrl && !key.meta) {
+                    this.insertText(text);
+                }
+                break;
+        }
+        this.requestRender();
+    }
+    async handleMenuKeypress(text, key) {
+        const menus = this.getMenuDefinitions();
+        const activeMenu = menus[this.menuState.activeIndex];
+        const activeItems = activeMenu?.items ?? [];
+        if (key.name === 'escape') {
+            this.closeMenuMode();
+            return;
+        }
+        if (key.name && /^[1-6]$/.test(key.name)) {
+            this.selectMenu(Number.parseInt(key.name, 10) - 1);
+            return;
+        }
+        switch (key.name) {
+            case 'left':
+                this.moveMenu(-1);
+                return;
+            case 'right':
+                this.moveMenu(1);
+                return;
+            case 'up':
+                this.moveMenuItem(-1, activeItems.length);
+                return;
+            case 'down':
+                this.moveMenuItem(1, activeItems.length);
+                return;
+            case 'home':
+                this.menuState.selectedIndex = 0;
+                this.statusLine = `${activeMenu?.label ?? 'Menu'} menu.`;
+                this.requestRender();
+                return;
+            case 'end':
+                this.menuState.selectedIndex = Math.max(0, activeItems.length - 1);
+                this.statusLine = `${activeMenu?.label ?? 'Menu'} menu.`;
+                this.requestRender();
+                return;
+            case 'return':
+            case 'space': {
+                const selected = activeItems[this.menuState.selectedIndex];
+                if (selected) {
+                    if (selected.enabled === false) {
+                        this.statusLine = `${selected.label} is not available right now.`;
+                        this.requestRender();
+                        return;
+                    }
+                    await this.runMenuAction(selected.id);
+                }
+                return;
+            }
+            case 'backspace':
+                if (this.menuState.typeahead) {
+                    this.menuState.typeahead = this.menuState.typeahead.slice(0, -1);
+                    this.menuState.typeaheadAt = Date.now();
+                    this.requestRender();
+                }
+                return;
+            default:
+                break;
+        }
+        if (text && !key.ctrl && !key.meta && /\S/.test(text)) {
+            const now = Date.now();
+            this.menuState.typeahead = now - this.menuState.typeaheadAt > 900
+                ? text.toLowerCase()
+                : `${this.menuState.typeahead}${text.toLowerCase()}`;
+            this.menuState.typeaheadAt = now;
+            this.menuState.selectedIndex = selectMenuItemByTypeahead(activeItems, this.menuState.typeahead, this.menuState.selectedIndex);
+            this.requestRender();
+        }
+    }
+    async handlePickerKeypress(text, key) {
+        const picker = this.pickerState;
+        if (!picker) {
+            this.closeWorkspaceMode();
+            return;
+        }
+        switch (key.name) {
+            case 'escape':
+                this.closeWorkspaceMode();
+                return;
+            case 'return':
+                await this.activatePickerSelection();
+                return;
+            case 'up':
+                this.movePickerSelection(-1);
+                return;
+            case 'down':
+                this.movePickerSelection(1);
+                return;
+            case 'pageup':
+                this.movePickerSelection(-Math.max(3, Math.floor(this.workspaceViewportLines() / 2)));
+                return;
+            case 'pagedown':
+                this.movePickerSelection(Math.max(3, Math.floor(this.workspaceViewportLines() / 2)));
+                return;
+            case 'home':
+                picker.selectedIndex = 0;
+                this.ensurePickerSelectionVisible();
+                this.requestRender();
+                return;
+            case 'end':
+                picker.selectedIndex = Math.max(0, picker.filteredItems.length - 1);
+                this.ensurePickerSelectionVisible();
+                this.requestRender();
+                return;
+            case 'backspace':
+                this.deleteBackward();
+                this.refreshPickerFilter();
+                return;
+            case 'delete':
+                this.deleteForward();
+                this.refreshPickerFilter();
+                return;
+            case 'left':
+                if (this.cursor > 0) {
+                    this.cursor -= 1;
+                    this.requestRender();
+                }
+                return;
+            case 'right':
+                if (this.cursor < this.inputValue.length) {
+                    this.cursor += 1;
+                    this.requestRender();
+                }
+                return;
+            default:
+                break;
+        }
+        if (key.ctrl && key.name === 'e') {
+            await this.activatePickerSelection('edit');
+            return;
+        }
+        if (key.ctrl && key.name === 'r') {
+            await this.activatePickerSelection('run');
+            return;
+        }
+        if (key.ctrl && key.name === 'm') {
+            await this.activatePickerSelection('meta');
+            return;
+        }
+        if (key.ctrl && key.name === 's') {
+            await this.activatePickerSelection('source');
+            return;
+        }
+        if (text && !key.ctrl && !key.meta) {
+            this.insertText(text);
+            this.refreshPickerFilter();
+        }
+    }
+    async handleViewerKeypress(key) {
+        if (!this.viewerState) {
+            this.closeWorkspaceMode();
+            return;
+        }
+        if (key.ctrl && key.name === 'e' && this.viewerState.canEdit && this.viewerState.path) {
+            await this.openEditorForFile(this.viewerState.path, { title: this.viewerState.title, preferredExtension: this.viewerState.preferredExtension });
+            return;
+        }
+        if (key.ctrl && key.name === 'r' && this.viewerState.skillName) {
+            this.closeWorkspaceMode();
+            await this.executeSkill(this.viewerState.skillName, []);
+            return;
+        }
+        switch (key.name) {
+            case 'escape':
+                this.closeWorkspaceMode();
+                return;
+            case 'up':
+                this.viewerState.scrollTop = Math.max(0, this.viewerState.scrollTop - 1);
+                this.requestRender();
+                return;
+            case 'down':
+                this.viewerState.scrollTop += 1;
+                this.requestRender();
+                return;
+            case 'pageup':
+                this.viewerState.scrollTop = Math.max(0, this.viewerState.scrollTop - this.workspaceViewportLines());
+                this.requestRender();
+                return;
+            case 'pagedown':
+                this.viewerState.scrollTop += this.workspaceViewportLines();
+                this.requestRender();
+                return;
+            case 'home':
+                this.viewerState.scrollTop = 0;
+                this.requestRender();
+                return;
+            default:
+                return;
+        }
+    }
+    async handleEditorKeypress(text, key) {
+        if (!this.editorState) {
+            this.closeWorkspaceMode();
+            return;
+        }
+        if (key.ctrl && key.name === 's') {
+            await this.saveCurrentEditor(false);
+            return;
+        }
+        switch (key.name) {
+            case 'escape':
+                if (this.editorState.dirty && !this.editorState.discardPending) {
+                    this.editorState.discardPending = true;
+                    this.statusLine = 'Unsaved changes. Press Esc again to discard or Ctrl+S to save.';
+                    this.requestRender();
+                    return;
+                }
+                this.closeWorkspaceMode(true);
+                return;
+            case 'return':
+                this.splitEditorLine();
+                return;
+            case 'backspace':
+                this.deleteEditorBackward();
+                return;
+            case 'delete':
+                this.deleteEditorForward();
+                return;
+            case 'left':
+                this.moveEditorCursor('left');
+                return;
+            case 'right':
+                this.moveEditorCursor('right');
+                return;
+            case 'up':
+                this.moveEditorCursor('up');
+                return;
+            case 'down':
+                this.moveEditorCursor('down');
+                return;
+            case 'pageup':
+                this.pageEditorCursor(-1);
+                return;
+            case 'pagedown':
+                this.pageEditorCursor(1);
+                return;
+            case 'home':
+                this.editorState.cursorColumn = 0;
+                this.ensureEditorCursorVisible();
+                this.requestRender();
+                return;
+            case 'end':
+                this.editorState.cursorColumn = this.currentEditorLine().length;
+                this.ensureEditorCursorVisible();
+                this.requestRender();
+                return;
+            case 'tab':
+                this.insertEditorText('  ');
+                return;
+            default:
+                break;
+        }
+        if (text && !key.ctrl && !key.meta) {
+            this.insertEditorText(text);
+        }
+    }
+    async submitInput() {
+        const rawInput = this.inputValue;
+        const trimmedInput = rawInput.trim();
+        this.inputValue = '';
+        this.cursor = 0;
+        if (this.pendingPrompt) {
+            const pending = this.pendingPrompt;
+            this.pendingPrompt = null;
+            pending.resolve(trimmedInput);
+            this.statusLine = pending.kind === 'clarify' ? 'Continuing...' : 'Working...';
+            this.requestRender();
+            return;
+        }
+        if (!trimmedInput) {
+            this.requestRender();
+            return;
+        }
+        const parsed = parseSlashInput(trimmedInput);
+        if (this.busy && !this.pendingPrompt && !canSubmitParsedInputWhileBusy(parsed)) {
+            this.statusLine = 'Execution is still running. Use /cancel or Ctrl+C to stop it.';
+            this.requestRender();
+            return;
+        }
+        if (parsed.kind === 'builtin') {
+            await this.executeBuiltin(parsed);
+            return;
+        }
+        if (parsed.kind === 'skill') {
+            await this.executeSkill(parsed.name, parsed.args);
+            return;
+        }
+        await this.executeTask(parsed.prompt);
+    }
+    async executeBuiltin(parsed) {
+        switch (parsed.name) {
+            case 'cancel':
+                this.cancelCurrentExecution('Cancellation requested.');
+                return;
+            case 'exit':
+            case 'quit':
+                this.close();
+                return;
+            case 'help': {
+                const activity = this.currentProcessActivity();
+                for (const line of buildHelpLines()) {
+                    activity.pushLine(line);
+                }
+                this.statusLine = 'Help added to the process pane.';
+                this.requestRender();
+                return;
+            }
+            case 'compile':
+            case 'skill-creator':
+                await this.executeSkillCreator(parsed.name, parsed.rawArgs);
+                return;
+            case 'sessions':
+                await this.refreshSessions({ createIfMissing: true, selectedSessionId: this.selectedSessionId });
+                await this.refreshCommands();
+                this.statusLine = `Loaded ${this.sessions.length} session${this.sessions.length === 1 ? '' : 's'}.`;
+                this.requestRender();
+                return;
+            case 'new': {
+                const created = await createConductorSession(this.workspaceRoot, parsed.rawArgs || undefined);
+                await this.refreshSessions({ createIfMissing: true, selectedSessionId: created.id });
+                this.statusLine = `Created session ${created.title}.`;
+                this.requestRender();
+                return;
+            }
+        }
+    }
+    async executeTask(promptText) {
+        const sessionId = this.selectedSessionId;
+        const activity = this.activityFor(sessionId);
+        this.lastSubmittedInput = { kind: 'text', prompt: promptText };
+        this.focusedPane = 'messages';
+        this.paneScroll.messages = 0;
+        this.paneScroll.process = 0;
+        this.beginExecutionPreview(sessionId, 'task', { role: 'user', content: promptText });
+        activity.pushLine(`task ${promptText}`);
+        this.busy = true;
+        this.currentAbortController = new AbortController();
+        this.startAnimation();
+        this.statusLine = 'Running conductor...';
+        this.requestRender();
+        try {
+            const result = await runConductorTurn(promptText, {
+                workspaceRoot: this.workspaceRoot,
+                sessionId,
+                stream: true,
+                headless: true,
+                sandbox: this.options.sandbox,
+                signal: this.currentAbortController.signal,
+                onUserInput: (question) => this.requestClarification(question),
+                onEvent: (event) => {
+                    activity.handle(event);
+                    this.updatePreviewFromEvent(event);
+                    this.requestRender();
+                },
+            });
+            activity.finish();
+            await this.refreshSessions({ createIfMissing: true, selectedSessionId: result.sessionId });
+            await this.refreshCommands();
+            this.finishExecutionPreview({ persist: false });
+            this.statusLine = result.error ? 'Task failed.' : 'Task finished.';
+        }
+        catch (error) {
+            activity.finish();
+            const message = error.message;
+            activity.pushLine(`error ${message}`);
+            this.finishExecutionPreview({ persist: true, error: message });
+            this.statusLine = 'Task failed.';
+        }
+        finally {
+            this.busy = false;
+            this.currentAbortController = null;
+            this.stopAnimation();
+            if (this.exitRequested) {
+                this.close();
+            }
+            else {
+                this.requestRender();
+            }
+        }
+    }
+    async executeSkill(skillName, args) {
+        const sessionId = this.selectedSessionId || 'global';
+        const activity = this.activityFor(sessionId);
+        const commandText = `/${skillName}${args.length > 0 ? ` ${args.join(' ')}` : ''}`;
+        this.lastSubmittedInput = { kind: 'skill', name: skillName, rawArgs: args.join(' '), args: [...args] };
+        this.focusedPane = 'messages';
+        this.paneScroll.messages = 0;
+        this.paneScroll.process = 0;
+        this.beginExecutionPreview(sessionId, 'skill', { role: 'system', content: commandText }, skillName);
+        activity.pushLine(`skill /${skillName}${args.length > 0 ? ` ${args.join(' ')}` : ''}`);
+        this.busy = true;
+        this.currentAbortController = new AbortController();
+        this.startAnimation();
+        this.statusLine = `Running /${skillName}...`;
+        this.requestRender();
+        try {
+            const result = await runSkillCommand(this.workspaceRoot, skillName, args, {
+                sandbox: this.options.sandbox,
+                signal: this.currentAbortController.signal,
+                onUserInput: (question) => this.requestClarification(question),
+                onEvent: (event) => {
+                    activity.handle(event);
+                    this.updatePreviewFromEvent(event);
+                    this.requestRender();
+                },
+            });
+            activity.finish();
+            await this.refreshCommands();
+            this.finishExecutionPreview({
+                persist: true,
+                finalText: result.answer || summarizeRunResult(result),
+                error: result.error,
+            });
+            this.statusLine = result.error ? `/${skillName} failed.` : `/${skillName} finished.`;
+        }
+        catch (error) {
+            activity.finish();
+            const message = error.message;
+            activity.pushLine(`[${skillName}] error ${message}`);
+            this.finishExecutionPreview({ persist: true, error: message });
+            this.statusLine = `/${skillName} failed.`;
+        }
+        finally {
+            this.busy = false;
+            this.currentAbortController = null;
+            this.stopAnimation();
+            if (this.exitRequested) {
+                this.close();
+            }
+            else {
+                this.requestRender();
+            }
+        }
+    }
+    async executeSkillCreator(commandName, specText) {
+        const trimmedSpec = specText.trim();
+        if (!trimmedSpec) {
+            this.statusLine = `Provide a skill specification after /${commandName}.`;
+            this.requestRender();
+            return;
+        }
+        const sessionId = this.selectedSessionId;
+        const activity = this.activityFor(sessionId);
+        const commandText = `/${commandName} ${trimmedSpec}`;
+        this.lastSubmittedInput = { kind: 'builtin', name: commandName, rawArgs: trimmedSpec, args: [trimmedSpec] };
+        this.focusedPane = 'messages';
+        this.paneScroll.messages = 0;
+        this.paneScroll.process = 0;
+        this.beginExecutionPreview(sessionId, 'skill', { role: 'system', content: commandText }, 'skill-creator');
+        activity.pushLine(`skill ${commandText}`);
+        this.busy = true;
+        this.currentAbortController = new AbortController();
+        this.startAnimation();
+        this.statusLine = `Running /${commandName}...`;
+        this.requestRender();
+        try {
+            const result = await runSkillCreatorCommand(this.workspaceRoot, sessionId, trimmedSpec, {
+                sandbox: this.options.sandbox,
+                signal: this.currentAbortController.signal,
+                onUserInput: (question) => this.requestClarification(question),
+                onEvent: (event) => {
+                    activity.handle(event);
+                    this.updatePreviewFromEvent(event);
+                    this.requestRender();
+                },
+            });
+            activity.finish();
+            await this.refreshCommands();
+            this.finishExecutionPreview({
+                persist: true,
+                finalText: formatSkillCreatorSummary(this.workspaceRoot, result),
+            });
+            this.statusLine = `/${commandName} finished.`;
+        }
+        catch (error) {
+            activity.finish();
+            const message = error.message;
+            activity.pushLine(`[skill-creator] error ${message}`);
+            this.finishExecutionPreview({ persist: true, error: message });
+            this.statusLine = `/${commandName} failed.`;
+        }
+        finally {
+            this.busy = false;
+            this.currentAbortController = null;
+            this.stopAnimation();
+            if (this.exitRequested) {
+                this.close();
+            }
+            else {
+                this.requestRender();
+            }
+        }
+    }
+    async requestClarification(promptText) {
+        this.ensureClarificationVisible(promptText);
+        return this.promptForValue(promptText, 'clarify');
+    }
+    async promptForValue(promptText, kind = 'input') {
+        this.inputValue = '';
+        this.cursor = 0;
+        this.statusLine = kind === 'clarify' ? 'Awaiting clarification...' : promptText;
+        this.requestRender();
+        return new Promise((resolve) => {
+            this.pendingPrompt = { kind, prompt: promptText, resolve };
+            this.requestRender();
+        });
+    }
+    ensureClarificationVisible(promptText) {
+        if (!this.currentPreview) {
+            return;
+        }
+        const entry = previewQuestionMessage(promptText);
+        const entries = this.currentPreview.entries;
+        const pendingAssistantIndex = entries.length > 0 && entries[entries.length - 1].role === 'assistant'
+            ? entries.length - 1
+            : entries.length;
+        const previous = pendingAssistantIndex > 0 ? entries[pendingAssistantIndex - 1] : undefined;
+        if (sameDisplayMessage(previous, entry)) {
+            return;
+        }
+        this.insertPreviewMessage(entry);
+    }
+    async applyCompletion() {
+        if (!this.inputValue.startsWith('/')) {
+            return;
+        }
+        await this.refreshCommands();
+        const completion = completeSlashCommand(this.inputValue, [
+            ...BUILTIN_SLASH_COMMANDS,
+            ...this.commands.map((command) => command.name),
+        ]);
+        if (completion.applied) {
+            this.inputValue = completion.value;
+            this.cursor = this.inputValue.length;
+        }
+        if (completion.matches.length === 0) {
+            this.statusLine = 'No matching commands or skills.';
+        }
+        else if (completion.matches.length === 1) {
+            this.statusLine = `Completed /${completion.matches[0]}`;
+        }
+        else {
+            const preview = completion.matches.slice(0, 6).join(', ');
+            this.statusLine = `Matches: ${preview}${completion.matches.length > 6 ? ', ...' : ''}`;
+        }
+        this.requestRender();
+    }
+    async handleUpDown(offset) {
+        if (this.focusedPane === 'sessions') {
+            await this.moveSession(offset);
+            return;
+        }
+        this.scrollFocusedPane(offset < 0 ? 'up' : 'down', 1);
+    }
+    cyclePaneFocus(direction) {
+        const order = ['sessions', 'messages', 'process', 'context'];
+        const currentIndex = order.indexOf(this.focusedPane);
+        const nextIndex = (currentIndex + direction + order.length) % order.length;
+        this.focusedPane = order[nextIndex];
+        this.statusLine = `Focus: ${paneDisplayName(this.focusedPane)}. Left/right switches panes; PgUp/PgDn scrolls.`;
+        this.requestRender();
+    }
+    toggleMenuMode() {
+        if (this.pendingPrompt) {
+            this.statusLine = this.pendingPrompt.kind === 'clarify'
+                ? 'Finish the clarification prompt before opening menus.'
+                : 'Finish the current input prompt before opening menus.';
+            this.requestRender();
+            return;
+        }
+        if (this.uiMode === 'menu') {
+            this.closeMenuMode();
+            return;
+        }
+        this.menuReturnMode = this.uiMode;
+        this.uiMode = 'menu';
+        this.menuState.typeahead = '';
+        this.menuState.typeaheadAt = 0;
+        this.menuState.selectedIndex = 0;
+        this.statusLine = `${this.getMenuDefinitions()[this.menuState.activeIndex]?.label ?? 'Menu'} menu.`;
+        this.requestRender();
+    }
+    closeMenuMode() {
+        if (this.uiMode !== 'menu') {
+            return;
+        }
+        this.uiMode = this.menuReturnMode;
+        this.menuState.typeahead = '';
+        this.menuState.typeaheadAt = 0;
+        this.statusLine = `Focus: ${paneDisplayName(this.focusedPane)}. F10 or Ctrl+G reopens the menu bar.`;
+        this.requestRender();
+    }
+    moveMenu(direction) {
+        const menus = this.getMenuDefinitions();
+        this.menuState.activeIndex = nextWrappedIndex(this.menuState.activeIndex, direction, menus.length);
+        this.menuState.selectedIndex = 0;
+        this.menuState.typeahead = '';
+        this.menuState.typeaheadAt = 0;
+        this.statusLine = `${menus[this.menuState.activeIndex]?.label ?? 'Menu'} menu.`;
+        this.requestRender();
+    }
+    selectMenu(index) {
+        const menus = this.getMenuDefinitions();
+        if (index < 0 || index >= menus.length) {
+            return;
+        }
+        this.menuState.activeIndex = index;
+        this.menuState.selectedIndex = 0;
+        this.menuState.typeahead = '';
+        this.menuState.typeaheadAt = 0;
+        this.statusLine = `${menus[index]?.label ?? 'Menu'} menu.`;
+        this.requestRender();
+    }
+    moveMenuItem(direction, itemCount) {
+        this.menuState.selectedIndex = nextWrappedIndex(this.menuState.selectedIndex, direction, itemCount);
+        this.menuState.typeahead = '';
+        this.menuState.typeaheadAt = 0;
+        this.requestRender();
+    }
+    getMenuDefinitions() {
+        const busy = this.busy || !!this.pendingPrompt;
+        const menus = [
+            {
+                id: 'session',
+                label: 'Session',
+                items: [
+                    { id: 'session.new', label: 'New Session', description: 'Create and switch to a fresh conductor session.', shortcut: 'Enter' },
+                    { id: 'session.refresh', label: 'Refresh Sessions', description: 'Reload the session list and command catalog.' },
+                    { id: 'session.next', label: 'Next Session', description: 'Move to the next session in the left pane.', shortcut: 'Down' },
+                    { id: 'session.previous', label: 'Previous Session', description: 'Move to the previous session in the left pane.', shortcut: 'Up' },
+                    { id: 'session.quit', label: 'Quit', description: 'Leave the fullscreen TUI.', shortcut: 'Ctrl+C' },
+                ],
+            },
+            {
+                id: 'skills',
+                label: 'Skills',
+                items: [
+                    { id: 'skills.browse', label: 'Browse All Skills', description: 'Open a searchable catalog of compiled skills.', shortcut: 'Enter' },
+                    { id: 'skills.run', label: 'Run Skill…', description: 'Pick a skill and execute it from the menu bar.' },
+                    { id: 'skills.inspect', label: 'Inspect Skill Code', description: 'View the compiled DML for a skill.' },
+                    { id: 'skills.edit', label: 'Edit Skill Code', description: 'Open a skill in the inline editor.' },
+                    { id: 'skills.meta', label: 'Inspect Skill Metadata', description: 'View the metadata JSON for a compiled skill.' },
+                    { id: 'skills.source', label: 'Open Skill Source Spec', description: 'Jump from a compiled skill back to its source Markdown.' },
+                ],
+            },
+            {
+                id: 'files',
+                label: 'Files',
+                items: [
+                    { id: 'files.open', label: 'Open Text File…', description: 'Browse workspace text files in a searchable picker.', shortcut: 'Enter' },
+                    { id: 'files.recent', label: 'Recent Files', description: 'Reopen a recently inspected or edited file.' },
+                    { id: 'files.newMarkdown', label: 'New Markdown Note', description: 'Create a new Markdown buffer inside the workspace.' },
+                    { id: 'files.save', label: 'Save', description: 'Save the current editor buffer.', shortcut: 'Ctrl+S', enabled: !!this.editorState },
+                    { id: 'files.saveAs', label: 'Save As…', description: 'Save the current editor buffer to a new path.', enabled: !!this.editorState },
+                    { id: 'files.readme', label: 'Open Workspace README', description: 'Inspect the top-level README.md.' },
+                    { id: 'files.config', label: 'Open .deepclause Config', description: 'Inspect the local DeepClause config file.' },
+                ],
+            },
+            {
+                id: 'run',
+                label: 'Run',
+                items: [
+                    { id: 'run.prompt', label: 'Send Prompt…', description: 'Return to the command bar and enter a freeform prompt.', shortcut: 'Enter' },
+                    { id: 'run.repeat', label: 'Repeat Last Command', description: 'Re-run the last prompt or skill invocation.', enabled: !!this.lastSubmittedInput },
+                    { id: 'run.cancel', label: 'Cancel Current Execution', description: 'Abort the running task or skill.', shortcut: '/cancel', enabled: this.busy },
+                    { id: 'run.clear', label: 'Clear Execution Pane', description: 'Discard the current session execution log.' },
+                    { id: 'run.refreshSkills', label: 'Refresh Skill Catalog', description: 'Re-scan the workspace for compiled skills.' },
+                ],
+            },
+            {
+                id: 'view',
+                label: 'View',
+                items: [
+                    { id: 'view.focus.sessions', label: 'Focus Sessions Pane', description: 'Focus the session list pane.' },
+                    { id: 'view.focus.messages', label: 'Focus Messages Pane', description: 'Focus the conversation history pane.' },
+                    { id: 'view.focus.process', label: 'Focus Execution Pane', description: 'Focus the live execution log pane.' },
+                    { id: 'view.focus.context', label: 'Focus Context Pane', description: 'Focus the session context and token usage pane.' },
+                    { id: 'view.follow', label: 'Follow Focused Pane', description: 'Jump back to the newest visible content in the active pane.' },
+                    { id: 'view.palette', label: 'Open Action Palette', description: 'Search all menu actions from one picker.', shortcut: 'Ctrl+P' },
+                ],
+            },
+            {
+                id: 'help',
+                label: 'Help',
+                items: [
+                    { id: 'help.shortcuts', label: 'Keyboard Shortcuts', description: 'Show the fullscreen keyboard map.' },
+                    { id: 'help.slash', label: 'Slash Commands', description: 'Show available slash commands and direct skill invocation.' },
+                    { id: 'help.about', label: 'About This TUI', description: 'Show a short explanation of the fullscreen workspace.' },
+                ],
+            },
+        ];
+        return menus.map((menu) => ({
+            ...menu,
+            items: menu.items.map((item) => ({
+                ...item,
+                enabled: item.enabled ?? (!busy || item.id === 'run.cancel'),
+            })),
+        }));
+    }
+    async runMenuAction(actionId) {
+        switch (actionId) {
+            case 'session.new': {
+                const created = await createConductorSession(this.workspaceRoot);
+                await this.refreshSessions({ createIfMissing: true, selectedSessionId: created.id });
+                this.closeMenuMode();
+                this.statusLine = `Created session ${created.title}.`;
+                return;
+            }
+            case 'session.refresh':
+                await this.refreshSessions({ createIfMissing: true, selectedSessionId: this.selectedSessionId });
+                await this.refreshCommands();
+                this.closeMenuMode();
+                this.statusLine = `Loaded ${this.sessions.length} session${this.sessions.length === 1 ? '' : 's'}.`;
+                return;
+            case 'session.next':
+                await this.moveSession(1);
+                return;
+            case 'session.previous':
+                await this.moveSession(-1);
+                return;
+            case 'session.quit':
+                this.close();
+                return;
+            case 'skills.browse':
+                await this.openSkillPicker('skills.browse');
+                return;
+            case 'skills.run':
+                await this.openSkillPicker('skills.run');
+                return;
+            case 'skills.inspect':
+                await this.openSkillPicker('skills.inspect');
+                return;
+            case 'skills.edit':
+                await this.openSkillPicker('skills.edit');
+                return;
+            case 'skills.meta':
+                await this.openSkillPicker('skills.meta');
+                return;
+            case 'skills.source':
+                await this.openSkillPicker('skills.source');
+                return;
+            case 'files.open':
+                await this.openFilePicker('files.inspect');
+                return;
+            case 'files.recent':
+                await this.openFilePicker('files.recent');
+                return;
+            case 'files.newMarkdown':
+                this.openEditorBuffer('', { title: 'New Markdown Note', preferredExtension: '.md' });
+                return;
+            case 'files.save':
+                await this.saveCurrentEditor(false);
+                return;
+            case 'files.saveAs':
+                await this.saveCurrentEditor(true);
+                return;
+            case 'files.readme':
+                await this.openFileViewer(path.join(this.workspaceRoot, 'README.md'), { title: 'README.md' });
+                return;
+            case 'files.config':
+                await this.openFileViewer(getConfigPath(this.workspaceRoot), { title: '.deepclause/config.json' });
+                return;
+            case 'run.prompt':
+                this.closeMenuMode();
+                this.statusLine = 'Command bar ready.';
+                return;
+            case 'run.repeat':
+                await this.repeatLastCommand();
+                return;
+            case 'run.cancel':
+                this.closeMenuMode();
+                this.cancelCurrentExecution('Cancellation requested.');
+                return;
+            case 'run.clear':
+                this.currentProcessActivity().clear();
+                this.closeMenuMode();
+                this.statusLine = 'Execution pane cleared.';
+                return;
+            case 'run.refreshSkills':
+                await this.refreshCommands();
+                this.closeMenuMode();
+                this.statusLine = `Loaded ${this.commands.length} skill${this.commands.length === 1 ? '' : 's'}.`;
+                return;
+            case 'view.focus.sessions':
+            case 'view.focus.messages':
+            case 'view.focus.process':
+            case 'view.focus.context': {
+                const pane = actionId.slice('view.focus.'.length);
+                this.focusedPane = pane;
+                this.closeMenuMode();
+                this.statusLine = `Focus: ${paneDisplayName(this.focusedPane)}.`;
+                return;
+            }
+            case 'view.follow':
+                if (this.focusedPane !== 'sessions') {
+                    this.paneScroll[this.focusedPane] = 0;
+                }
+                this.closeMenuMode();
+                this.statusLine = `${paneDisplayName(this.focusedPane)} following newest content.`;
+                return;
+            case 'view.palette':
+                this.openActionPalette();
+                return;
+            case 'help.shortcuts':
+                this.openTextViewer('Keyboard Shortcuts', getShortcutHelpLines().join('\n'), { preferredExtension: '.txt' });
+                return;
+            case 'help.slash':
+                this.openTextViewer('Slash Commands', getSlashHelpLines().join('\n'), { preferredExtension: '.txt' });
+                return;
+            case 'help.about':
+                this.openTextViewer('About This TUI', [
+                    'DeepClause fullscreen TUI',
+                    '',
+                    'Use F10 or Ctrl+G for the menu bar, Ctrl+W to cycle panes, and /cancel to stop a running execution.',
+                    'The Skills and Files menus open searchable pickers, and Ctrl+P opens the action palette directly.',
+                ].join('\n'), { preferredExtension: '.txt' });
+                return;
+            default:
+                this.closeMenuMode();
+                this.statusLine = 'This menu action is being wired up next.';
+                return;
+        }
+    }
+    closeWorkspaceMode(force = false) {
+        if (!force && !this.canReplaceWorkspaceSurface()) {
+            return false;
+        }
+        this.uiMode = 'command';
+        this.pickerState = null;
+        this.viewerState = null;
+        this.editorState = null;
+        this.inputValue = '';
+        this.cursor = 0;
+        this.requestRender();
+        return true;
+    }
+    canReplaceWorkspaceSurface() {
+        if (this.editorState?.dirty) {
+            this.statusLine = 'Save the current editor with Ctrl+S or press Esc again in the editor to discard changes.';
+            this.requestRender();
+            return false;
+        }
+        return true;
+    }
+    workspaceViewportLines() {
+        return Math.max(1, (output.rows ?? 40) - 5);
+    }
+    openActionPalette() {
+        if (!this.canReplaceWorkspaceSurface()) {
+            return;
+        }
+        const items = this.getMenuDefinitions()
+            .flatMap((menu) => menu.items)
+            .filter((item) => item.enabled !== false)
+            .map((item) => ({
+            id: item.id,
+            label: item.label,
+            description: item.description,
+            detail: item.shortcut,
+            actionId: item.id,
+        }));
+        this.openPicker({
+            mode: 'palette',
+            title: 'Action Palette',
+            emptyText: 'No actions match the current query.',
+            items,
+            filteredItems: items,
+            selectedIndex: 0,
+            scrollTop: 0,
+        });
+    }
+    async openSkillPicker(mode) {
+        if (!this.canReplaceWorkspaceSurface()) {
+            return;
+        }
+        await this.refreshCommands();
+        const items = await Promise.all(this.commands.map(async (command) => {
+            const skillPath = this.resolveCommandDmlPath(command);
+            const metaPath = this.resolveCommandMetaPath(command);
+            let sourcePath;
+            try {
+                const meta = JSON.parse(await fs.readFile(metaPath, 'utf8'));
+                if (meta.source) {
+                    sourcePath = path.resolve(this.workspaceRoot, meta.source);
+                }
+            }
+            catch {
+                // Metadata is optional while browsing.
+            }
+            return {
+                id: command.name,
+                label: command.name,
+                description: command.description,
+                detail: command.path,
+                path: skillPath,
+                skillName: command.name,
+                metaPath,
+                sourcePath,
+            };
+        }));
+        const titles = {
+            'skills.browse': 'Browse Skills',
+            'skills.run': 'Run Skill',
+            'skills.inspect': 'Inspect Skill Code',
+            'skills.edit': 'Edit Skill Code',
+            'skills.meta': 'Inspect Skill Metadata',
+            'skills.source': 'Open Skill Source Spec',
+        };
+        this.openPicker({
+            mode,
+            title: titles[mode],
+            emptyText: 'No skills match the current query.',
+            items,
+            filteredItems: items,
+            selectedIndex: 0,
+            scrollTop: 0,
+        });
+    }
+    async openFilePicker(mode) {
+        if (!this.canReplaceWorkspaceSurface()) {
+            return;
+        }
+        const relativePaths = mode === 'files.recent'
+            ? [...this.recentFiles]
+            : await listWorkspaceTextFiles(this.workspaceRoot);
+        const items = relativePaths.map((relativePath) => ({
+            id: relativePath,
+            label: path.basename(relativePath),
+            description: relativePath,
+            detail: path.extname(relativePath) || 'text',
+            path: path.join(this.workspaceRoot, relativePath),
+        }));
+        const titles = {
+            'files.inspect': 'Open Text File',
+            'files.edit': 'Edit Text File',
+            'files.recent': 'Recent Files',
+        };
+        this.openPicker({
+            mode,
+            title: titles[mode],
+            emptyText: mode === 'files.recent'
+                ? 'No recent files yet. Open or edit a file first.'
+                : 'No text files match the current query.',
+            items,
+            filteredItems: items,
+            selectedIndex: 0,
+            scrollTop: 0,
+        });
+    }
+    openPicker(state) {
+        this.closeMenuMode();
+        this.uiMode = state.mode === 'palette' ? 'palette' : 'picker';
+        this.pickerState = state;
+        this.viewerState = null;
+        this.editorState = null;
+        this.inputValue = '';
+        this.cursor = 0;
+        this.ensurePickerSelectionVisible();
+        this.statusLine = `${state.title}.`;
+        this.requestRender();
+    }
+    refreshPickerFilter() {
+        if (!this.pickerState) {
+            return;
+        }
+        this.pickerState.filteredItems = filterPickerItems(this.pickerState.items, this.inputValue);
+        this.pickerState.selectedIndex = clamp(this.pickerState.selectedIndex, 0, Math.max(0, this.pickerState.filteredItems.length - 1));
+        this.pickerState.scrollTop = 0;
+        this.ensurePickerSelectionVisible();
+        this.requestRender();
+    }
+    movePickerSelection(delta) {
+        if (!this.pickerState || this.pickerState.filteredItems.length === 0) {
+            return;
+        }
+        this.pickerState.selectedIndex = clamp(this.pickerState.selectedIndex + delta, 0, Math.max(0, this.pickerState.filteredItems.length - 1));
+        this.ensurePickerSelectionVisible();
+        this.requestRender();
+    }
+    ensurePickerSelectionVisible() {
+        if (!this.pickerState) {
+            return;
+        }
+        const targetLine = 3 + (this.pickerState.selectedIndex * 3);
+        const viewport = this.workspaceViewportLines();
+        if (targetLine < this.pickerState.scrollTop) {
+            this.pickerState.scrollTop = targetLine;
+            return;
+        }
+        if (targetLine >= this.pickerState.scrollTop + viewport) {
+            this.pickerState.scrollTop = Math.max(0, targetLine - viewport + 1);
+        }
+    }
+    async activatePickerSelection(override) {
+        const picker = this.pickerState;
+        const item = picker?.filteredItems[picker.selectedIndex];
+        if (!picker || !item) {
+            return;
+        }
+        if (picker.mode === 'palette') {
+            await this.runMenuAction(item.actionId ?? 'help.about');
+            return;
+        }
+        const action = override ?? picker.mode;
+        switch (action) {
+            case 'skills.browse':
+            case 'skills.inspect':
+                await this.openSkillViewer(item, 'dml');
+                return;
+            case 'skills.run': {
+                this.closeWorkspaceMode();
+                const rawArgs = await this.promptForValue(`Arguments for /${item.skillName} (optional):`);
+                await this.executeSkill(item.skillName ?? item.label, parseCommandArgs(rawArgs));
+                return;
+            }
+            case 'run':
+                if (item.skillName) {
+                    this.closeWorkspaceMode();
+                    const rawArgs = await this.promptForValue(`Arguments for /${item.skillName} (optional):`);
+                    await this.executeSkill(item.skillName, parseCommandArgs(rawArgs));
+                }
+                return;
+            case 'edit':
+            case 'skills.edit':
+            case 'files.edit':
+                if (item.path) {
+                    await this.openEditorForFile(item.path, { title: item.description || item.label });
+                }
+                return;
+            case 'meta':
+            case 'skills.meta':
+                if (item.metaPath) {
+                    await this.openSkillViewer(item, 'meta');
+                }
+                return;
+            case 'source':
+            case 'skills.source':
+                if (item.sourcePath) {
+                    await this.openSkillViewer(item, 'source');
+                }
+                else {
+                    this.statusLine = `No source spec recorded for ${item.label}.`;
+                    this.requestRender();
+                }
+                return;
+            case 'files.inspect':
+            case 'files.recent':
+                if (item.path) {
+                    await this.openFileViewer(item.path, { title: item.description || item.label });
+                }
+                return;
+        }
+    }
+    async openSkillViewer(item, target) {
+        const filePath = target === 'dml' ? item.path : target === 'meta' ? item.metaPath : item.sourcePath;
+        if (!filePath) {
+            this.statusLine = `No ${target} file available for ${item.label}.`;
+            this.requestRender();
+            return;
+        }
+        const title = target === 'dml'
+            ? `Skill: ${item.label}`
+            : target === 'meta'
+                ? `Metadata: ${item.label}`
+                : `Source Spec: ${item.label}`;
+        await this.openFileViewer(filePath, {
+            title,
+            skillName: item.skillName,
+            canEdit: target !== 'meta',
+            preferredExtension: target === 'meta' ? '.json' : path.extname(filePath) || '.txt',
+        });
+    }
+    openTextViewer(title, content, options = {}) {
+        if (!this.canReplaceWorkspaceSurface()) {
+            return;
+        }
+        this.closeMenuMode();
+        this.uiMode = 'viewer';
+        this.pickerState = null;
+        this.editorState = null;
+        this.viewerState = {
+            title,
+            content,
+            path: options.path,
+            canEdit: options.canEdit ?? false,
+            scrollTop: 0,
+            skillName: options.skillName,
+            metaPath: options.metaPath,
+            sourcePath: options.sourcePath,
+            preferredExtension: options.preferredExtension,
+        };
+        this.inputValue = '';
+        this.cursor = 0;
+        if (options.path) {
+            this.pushRecentFile(options.path);
+        }
+        this.statusLine = `Viewing ${title}.`;
+        this.requestRender();
+    }
+    async openFileViewer(filePath, options = {}) {
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            this.openTextViewer(options.title ?? path.relative(this.workspaceRoot, filePath), content, {
+                path: filePath,
+                canEdit: options.canEdit ?? isEditableTextFile(filePath),
+                skillName: options.skillName,
+                preferredExtension: options.preferredExtension ?? (path.extname(filePath) || '.txt'),
+            });
+        }
+        catch (error) {
+            this.closeMenuMode();
+            this.statusLine = `Unable to open ${path.relative(this.workspaceRoot, filePath)}: ${error.message}`;
+            this.requestRender();
+        }
+    }
+    async openEditorForFile(filePath, options = {}) {
+        try {
+            const content = await fs.readFile(filePath, 'utf8');
+            this.openEditorBuffer(content, {
+                title: options.title ?? path.relative(this.workspaceRoot, filePath),
+                path: filePath,
+                preferredExtension: options.preferredExtension ?? (path.extname(filePath) || '.txt'),
+            });
+        }
+        catch (error) {
+            this.statusLine = `Unable to edit ${path.relative(this.workspaceRoot, filePath)}: ${error.message}`;
+            this.requestRender();
+        }
+    }
+    openEditorBuffer(content, options) {
+        if (!this.canReplaceWorkspaceSurface()) {
+            return;
+        }
+        this.closeMenuMode();
+        this.uiMode = 'editor';
+        this.pickerState = null;
+        this.viewerState = null;
+        this.editorState = {
+            title: options.title,
+            path: options.path,
+            lines: splitEditorContent(content),
+            cursorLine: 0,
+            cursorColumn: 0,
+            scrollTop: 0,
+            scrollLeft: 0,
+            dirty: false,
+            preferredExtension: options.preferredExtension ?? '.txt',
+            discardPending: false,
+        };
+        this.inputValue = '';
+        this.cursor = 0;
+        if (options.path) {
+            this.pushRecentFile(options.path);
+        }
+        this.ensureEditorCursorVisible();
+        this.statusLine = `Editing ${options.title}.`;
+        this.requestRender();
+    }
+    currentEditorLine() {
+        return this.editorState?.lines[this.editorState.cursorLine] ?? '';
+    }
+    updateCurrentEditorLine(nextLine) {
+        if (!this.editorState) {
+            return;
+        }
+        this.editorState.lines[this.editorState.cursorLine] = nextLine;
+        this.editorState.dirty = true;
+        this.editorState.discardPending = false;
+    }
+    insertEditorText(text) {
+        if (!this.editorState) {
+            return;
+        }
+        const line = this.currentEditorLine();
+        this.updateCurrentEditorLine(`${line.slice(0, this.editorState.cursorColumn)}${text}${line.slice(this.editorState.cursorColumn)}`);
+        this.editorState.cursorColumn += text.length;
+        this.ensureEditorCursorVisible();
+        this.requestRender();
+    }
+    splitEditorLine() {
+        if (!this.editorState) {
+            return;
+        }
+        const line = this.currentEditorLine();
+        const before = line.slice(0, this.editorState.cursorColumn);
+        const after = line.slice(this.editorState.cursorColumn);
+        this.editorState.lines.splice(this.editorState.cursorLine, 1, before, after);
+        this.editorState.cursorLine += 1;
+        this.editorState.cursorColumn = 0;
+        this.editorState.dirty = true;
+        this.editorState.discardPending = false;
+        this.ensureEditorCursorVisible();
+        this.requestRender();
+    }
+    deleteEditorBackward() {
+        if (!this.editorState) {
+            return;
+        }
+        if (this.editorState.cursorColumn > 0) {
+            const line = this.currentEditorLine();
+            this.updateCurrentEditorLine(`${line.slice(0, this.editorState.cursorColumn - 1)}${line.slice(this.editorState.cursorColumn)}`);
+            this.editorState.cursorColumn -= 1;
+        }
+        else if (this.editorState.cursorLine > 0) {
+            const previous = this.editorState.lines[this.editorState.cursorLine - 1] ?? '';
+            const current = this.currentEditorLine();
+            this.editorState.lines.splice(this.editorState.cursorLine - 1, 2, `${previous}${current}`);
+            this.editorState.cursorLine -= 1;
+            this.editorState.cursorColumn = previous.length;
+            this.editorState.dirty = true;
+            this.editorState.discardPending = false;
+        }
+        this.ensureEditorCursorVisible();
+        this.requestRender();
+    }
+    deleteEditorForward() {
+        if (!this.editorState) {
+            return;
+        }
+        const line = this.currentEditorLine();
+        if (this.editorState.cursorColumn < line.length) {
+            this.updateCurrentEditorLine(`${line.slice(0, this.editorState.cursorColumn)}${line.slice(this.editorState.cursorColumn + 1)}`);
+        }
+        else if (this.editorState.cursorLine < this.editorState.lines.length - 1) {
+            const next = this.editorState.lines[this.editorState.cursorLine + 1] ?? '';
+            this.editorState.lines.splice(this.editorState.cursorLine, 2, `${line}${next}`);
+            this.editorState.dirty = true;
+            this.editorState.discardPending = false;
+        }
+        this.ensureEditorCursorVisible();
+        this.requestRender();
+    }
+    moveEditorCursor(direction) {
+        if (!this.editorState) {
+            return;
+        }
+        switch (direction) {
+            case 'left':
+                if (this.editorState.cursorColumn > 0) {
+                    this.editorState.cursorColumn -= 1;
+                }
+                else if (this.editorState.cursorLine > 0) {
+                    this.editorState.cursorLine -= 1;
+                    this.editorState.cursorColumn = this.currentEditorLine().length;
+                }
+                break;
+            case 'right':
+                if (this.editorState.cursorColumn < this.currentEditorLine().length) {
+                    this.editorState.cursorColumn += 1;
+                }
+                else if (this.editorState.cursorLine < this.editorState.lines.length - 1) {
+                    this.editorState.cursorLine += 1;
+                    this.editorState.cursorColumn = 0;
+                }
+                break;
+            case 'up':
+                if (this.editorState.cursorLine > 0) {
+                    this.editorState.cursorLine -= 1;
+                    this.editorState.cursorColumn = Math.min(this.editorState.cursorColumn, this.currentEditorLine().length);
+                }
+                break;
+            case 'down':
+                if (this.editorState.cursorLine < this.editorState.lines.length - 1) {
+                    this.editorState.cursorLine += 1;
+                    this.editorState.cursorColumn = Math.min(this.editorState.cursorColumn, this.currentEditorLine().length);
+                }
+                break;
+        }
+        this.ensureEditorCursorVisible();
+        this.requestRender();
+    }
+    pageEditorCursor(direction) {
+        if (!this.editorState) {
+            return;
+        }
+        const nextLine = clamp(this.editorState.cursorLine + (direction * this.workspaceViewportLines()), 0, Math.max(0, this.editorState.lines.length - 1));
+        this.editorState.cursorLine = nextLine;
+        this.editorState.cursorColumn = Math.min(this.editorState.cursorColumn, this.currentEditorLine().length);
+        this.ensureEditorCursorVisible();
+        this.requestRender();
+    }
+    ensureEditorCursorVisible() {
+        if (!this.editorState) {
+            return;
+        }
+        const viewportLines = this.workspaceViewportLines();
+        if (this.editorState.cursorLine < this.editorState.scrollTop) {
+            this.editorState.scrollTop = this.editorState.cursorLine;
+        }
+        else if (this.editorState.cursorLine >= this.editorState.scrollTop + viewportLines) {
+            this.editorState.scrollTop = Math.max(0, this.editorState.cursorLine - viewportLines + 1);
+        }
+        const width = output.columns ?? 120;
+        const innerWidth = Math.max(1, width - 2);
+        const lineNumberWidth = Math.max(2, String(Math.max(1, this.editorState.lines.length)).length);
+        const prefixWidth = 2 + lineNumberWidth + 3;
+        const contentWidth = Math.max(1, innerWidth - prefixWidth);
+        if (this.editorState.cursorColumn < this.editorState.scrollLeft) {
+            this.editorState.scrollLeft = this.editorState.cursorColumn;
+        }
+        else if (this.editorState.cursorColumn >= this.editorState.scrollLeft + contentWidth) {
+            this.editorState.scrollLeft = Math.max(0, this.editorState.cursorColumn - contentWidth + 1);
+        }
+    }
+    async saveCurrentEditor(saveAs) {
+        if (!this.editorState) {
+            this.closeMenuMode();
+            this.statusLine = 'No editor buffer is active.';
+            this.requestRender();
+            return;
+        }
+        let targetPath = this.editorState.path;
+        if (saveAs || !targetPath) {
+            const suggested = this.editorState.path
+                ? path.relative(this.workspaceRoot, this.editorState.path)
+                : `notes/${Date.now()}.${this.editorState.preferredExtension.replace(/^\./, '')}`;
+            const requestedPath = (await this.promptForValue(`Save file as (relative path) [${suggested}]:`)).trim() || suggested;
+            targetPath = resolveWorkspaceTextPath(this.workspaceRoot, requestedPath);
+        }
+        try {
+            await fs.mkdir(path.dirname(targetPath), { recursive: true });
+            await fs.writeFile(targetPath, this.editorState.lines.join('\n'), 'utf8');
+            this.editorState.path = targetPath;
+            this.editorState.title = path.relative(this.workspaceRoot, targetPath);
+            this.editorState.dirty = false;
+            this.editorState.discardPending = false;
+            this.pushRecentFile(targetPath);
+            this.statusLine = `Saved ${path.relative(this.workspaceRoot, targetPath)}.`;
+            this.requestRender();
+        }
+        catch (error) {
+            this.statusLine = `Unable to save file: ${error.message}`;
+            this.requestRender();
+        }
+    }
+    pushRecentFile(filePath) {
+        const relativePath = path.relative(this.workspaceRoot, filePath).replace(/\\/g, '/');
+        const existingIndex = this.recentFiles.indexOf(relativePath);
+        if (existingIndex >= 0) {
+            this.recentFiles.splice(existingIndex, 1);
+        }
+        this.recentFiles.unshift(relativePath);
+        if (this.recentFiles.length > 20) {
+            this.recentFiles.length = 20;
+        }
+    }
+    async repeatLastCommand() {
+        if (!this.lastSubmittedInput) {
+            this.closeMenuMode();
+            this.statusLine = 'No previous prompt or skill to repeat yet.';
+            this.requestRender();
+            return;
+        }
+        if (!this.closeWorkspaceMode()) {
+            return;
+        }
+        if (this.lastSubmittedInput.kind === 'text') {
+            await this.executeTask(this.lastSubmittedInput.prompt);
+            return;
+        }
+        if (this.lastSubmittedInput.kind === 'skill') {
+            await this.executeSkill(this.lastSubmittedInput.name, this.lastSubmittedInput.args);
+            return;
+        }
+        if (this.lastSubmittedInput.kind === 'builtin') {
+            await this.executeBuiltin(this.lastSubmittedInput);
+        }
+    }
+    resolveCommandDmlPath(command) {
+        return path.join(this.workspaceRoot, `${command.path}.dml`);
+    }
+    resolveCommandMetaPath(command) {
+        return path.join(this.workspaceRoot, `${command.path}.meta.json`);
+    }
+    beginExecutionPreview(sessionId, kind, lead, rootTag) {
+        this.currentPreview = {
+            sessionId,
+            kind,
+            rootTag,
+            activeChildTag: kind === 'skill' ? rootTag : undefined,
+            entries: [lead, { role: 'assistant', content: '', pending: true }],
+        };
+    }
+    updatePreviewFromEvent(logEvent) {
+        if (!this.currentPreview) {
+            return;
+        }
+        this.updatePreviewChildState(logEvent);
+        const previewMessage = previewMessageFromEvent(logEvent);
+        if (previewMessage) {
+            this.insertPreviewMessage(previewMessage);
+        }
+        if (!this.isPrimaryPreviewEvent(logEvent)) {
+            return;
+        }
+        const message = this.ensurePreviewAssistantMessage();
+        switch (logEvent.event.type) {
+            case 'stream':
+                if (logEvent.event.content) {
+                    message.content += logEvent.event.content;
+                }
+                break;
+            case 'answer':
+                if (logEvent.event.content) {
+                    message.content = logEvent.event.content;
+                }
+                message.pending = false;
+                message.error = false;
+                break;
+            case 'error':
+                message.content = logEvent.event.content ?? (message.content || 'Execution failed');
+                message.pending = false;
+                message.error = true;
+                break;
+            default:
+                break;
+        }
+    }
+    isPrimaryPreviewEvent(logEvent) {
+        if (!this.currentPreview) {
+            return false;
+        }
+        if (this.currentPreview.kind === 'task') {
+            return logEvent.scope === 'main';
+        }
+        return logEvent.scope === 'child' && logEvent.childSlug === this.currentPreview.rootTag;
+    }
+    insertPreviewMessage(entry) {
+        if (!this.currentPreview) {
+            return;
+        }
+        const entries = this.currentPreview.entries;
+        const last = entries[entries.length - 1];
+        if (last && last.role === 'assistant' && last.pending && !last.content) {
+            entries.splice(entries.length - 1, 0, entry);
+            return;
+        }
+        entries.push(entry);
+    }
+    updatePreviewChildState(logEvent) {
+        if (!this.currentPreview || this.currentPreview.kind !== 'task') {
+            return;
+        }
+        if (logEvent.scope === 'child' && logEvent.childSlug) {
+            this.currentPreview.activeChildTag = logEvent.childSlug;
+            this.ensurePreviewChildSkillMessage(logEvent.childSlug);
+            return;
+        }
+        if (logEvent.scope === 'main' && (logEvent.event.type === 'stream' || logEvent.event.type === 'answer' || logEvent.event.type === 'error')) {
+            this.currentPreview.activeChildTag = undefined;
+        }
+    }
+    ensurePreviewChildSkillMessage(childSlug) {
+        if (!this.currentPreview) {
+            return;
+        }
+        const message = previewChildSkillActivityMessage(childSlug);
+        const exists = this.currentPreview.entries.some((entry) => sameDisplayMessage(entry, message));
+        if (!exists) {
+            this.insertPreviewMessage(message);
+        }
+    }
+    ensurePreviewAssistantMessage() {
+        if (!this.currentPreview) {
+            return { role: 'assistant', content: '', pending: false };
+        }
+        const desiredTag = this.currentPreview.rootTag ?? this.currentPreview.activeChildTag;
+        const last = this.currentPreview.entries[this.currentPreview.entries.length - 1];
+        if (last && last.role === 'assistant') {
+            last.tag = desiredTag;
+            return last;
+        }
+        const created = { role: 'assistant', content: '', pending: true, tag: desiredTag };
+        this.currentPreview.entries.push(created);
+        return created;
+    }
+    finishExecutionPreview(options) {
+        if (!this.currentPreview) {
+            return;
+        }
+        this.currentPreview.activeChildTag = undefined;
+        const assistant = this.ensurePreviewAssistantMessage();
+        if (typeof options.finalText === 'string' && options.finalText.trim()) {
+            assistant.content = options.finalText;
+        }
+        if (typeof options.error === 'string' && options.error.trim()) {
+            assistant.content = options.error;
+            assistant.error = true;
+        }
+        assistant.pending = false;
+        if (options.persist) {
+            const existing = this.ephemeralMessagesBySessionId.get(this.currentPreview.sessionId) ?? [];
+            existing.push(...this.currentPreview.entries.map((entry) => ({ ...entry, pending: false })));
+            this.ephemeralMessagesBySessionId.set(this.currentPreview.sessionId, existing);
+        }
+        this.currentPreview = null;
+    }
+    cancelCurrentExecution(message) {
+        if (!this.busy || !this.currentAbortController) {
+            this.statusLine = 'No execution is currently running.';
+            this.requestRender();
+            return;
+        }
+        if (this.currentAbortController.signal.aborted) {
+            this.statusLine = 'Cancellation already requested.';
+            this.requestRender();
+            return;
+        }
+        this.currentAbortController.abort();
+        this.statusLine = message;
+        this.requestRender();
+    }
+    startAnimation() {
+        if (this.animationTimer) {
+            return;
+        }
+        this.animationTimer = setInterval(() => {
+            if ((this.busy || this.currentPreview?.entries.some((entry) => entry.pending)) && !this.isEditingInput()) {
+                this.requestRender();
+            }
+        }, 120);
+    }
+    stopAnimation() {
+        if (!this.animationTimer) {
+            return;
+        }
+        clearInterval(this.animationTimer);
+        this.animationTimer = null;
+    }
+    scrollFocusedPane(direction, amount) {
+        const metrics = this.getPaneMetrics(this.focusedPane);
+        if (metrics.maxStart === 0) {
+            this.statusLine = `${paneDisplayName(this.focusedPane)} fits on screen.`;
+            this.requestRender();
+            return;
+        }
+        if (this.focusedPane === 'sessions') {
+            const delta = direction === 'down' ? amount : -amount;
+            this.paneScroll.sessions = clamp(this.paneScroll.sessions + delta, 0, metrics.maxStart);
+            this.statusLine = `Sessions scroll ${this.paneScroll.sessions + 1}/${metrics.maxStart + 1}.`;
+            this.requestRender();
+            return;
+        }
+        const pane = this.focusedPane;
+        const delta = direction === 'up' ? amount : -amount;
+        this.paneScroll[pane] = clamp(this.paneScroll[pane] + delta, 0, metrics.maxStart);
+        this.statusLine = this.paneScroll[pane] === 0
+            ? `${paneDisplayName(pane)} following newest content.`
+            : `${paneDisplayName(pane)} scrolled ${this.paneScroll[pane]} line${this.paneScroll[pane] === 1 ? '' : 's'} above latest.`;
+        this.requestRender();
+    }
+    jumpFocusedPane(target) {
+        const metrics = this.getPaneMetrics(this.focusedPane);
+        if (this.focusedPane === 'sessions') {
+            this.paneScroll.sessions = target === 'top' ? 0 : metrics.maxStart;
+            this.statusLine = target === 'top'
+                ? 'Sessions at top.'
+                : 'Sessions at bottom.';
+            this.requestRender();
+            return;
+        }
+        const pane = this.focusedPane;
+        this.paneScroll[pane] = target === 'bottom' ? 0 : metrics.maxStart;
+        this.statusLine = target === 'bottom'
+            ? `${paneDisplayName(pane)} following newest content.`
+            : `${paneDisplayName(pane)} at oldest visible content.`;
+        this.requestRender();
+    }
+    pageScrollAmount() {
+        const rows = output.rows ?? 40;
+        return Math.max(3, Math.floor(Math.max(1, rows - 5) / 2));
+    }
+    async moveSession(offset) {
+        if (this.sessions.length === 0) {
+            return;
+        }
+        const currentIndex = Math.max(0, this.sessions.findIndex((session) => session.id === this.selectedSessionId));
+        const nextIndex = (currentIndex + offset + this.sessions.length) % this.sessions.length;
+        const nextSession = this.sessions[nextIndex];
+        if (!nextSession || nextSession.id === this.selectedSessionId) {
+            return;
+        }
+        this.selectedSessionId = nextSession.id;
+        await this.loadSelectedSessionDetail();
+        this.statusLine = `Selected session ${nextSession.title}.`;
+        this.requestRender();
+    }
+    currentProcessActivity() {
+        return this.activityFor(this.selectedSessionId || 'global');
+    }
+    insertText(text) {
+        this.inputValue = `${this.inputValue.slice(0, this.cursor)}${text}${this.inputValue.slice(this.cursor)}`;
+        this.cursor += text.length;
+    }
+    deleteBackward() {
+        if (this.cursor === 0) {
+            return;
+        }
+        this.inputValue = `${this.inputValue.slice(0, this.cursor - 1)}${this.inputValue.slice(this.cursor)}`;
+        this.cursor -= 1;
+    }
+    deleteForward() {
+        if (this.cursor >= this.inputValue.length) {
+            return;
+        }
+        this.inputValue = `${this.inputValue.slice(0, this.cursor)}${this.inputValue.slice(this.cursor + 1)}`;
+    }
+    async refreshCommands() {
+        this.commands = await listCommands(this.workspaceRoot);
+    }
+    async refreshSessions(options = {}) {
+        let sessions = await listConductorSessions(this.workspaceRoot);
+        if (sessions.length === 0 && options.createIfMissing) {
+            const created = await createConductorSession(this.workspaceRoot);
+            sessions = [created];
+        }
+        this.sessions = sessions;
+        const desiredSessionId = options.selectedSessionId ?? this.selectedSessionId ?? sessions[0]?.id ?? '';
+        this.selectedSessionId = sessions.find((session) => session.id === desiredSessionId)?.id ?? sessions[0]?.id ?? '';
+        this.ensureSessionVisible();
+        await this.loadSelectedSessionDetail();
+    }
+    async loadSelectedSessionDetail() {
+        if (!this.selectedSessionId) {
+            this.sessionDetail = null;
+            return;
+        }
+        this.sessionDetail = await getConductorSessionDetail(this.workspaceRoot, this.selectedSessionId);
+    }
+    activityFor(key) {
+        const existing = this.activityBySessionId.get(key);
+        if (existing) {
+            return existing;
+        }
+        const created = new ActivityBuffer();
+        this.activityBySessionId.set(key, created);
+        return created;
+    }
+    requestRender() {
+        if (this.renderTimer) {
+            return;
+        }
+        const minInterval = this.isEditingInput()
+            ? TYPING_RENDER_INTERVAL_MS
+            : this.busy
+                ? BUSY_RENDER_INTERVAL_MS
+                : IDLE_RENDER_INTERVAL_MS;
+        const delay = Math.max(0, minInterval - (Date.now() - this.lastRenderAt));
+        this.renderTimer = setTimeout(() => {
+            this.renderTimer = null;
+            this.render();
+        }, delay);
+    }
+    render() {
+        this.lastRenderAt = Date.now();
+        const columns = output.columns ?? 120;
+        const rows = output.rows ?? 40;
+        const contentHeight = Math.max(1, rows - 3);
+        const widths = computePaneWidths(columns);
+        const rightHeights = computeRightPaneHeights(contentHeight);
+        const sessionsPane = this.buildPaneView('sessions', 'Sessions', widths.left, contentHeight);
+        const messagesPane = this.buildPaneView('messages', 'Messages', widths.center, contentHeight);
+        const processPane = this.buildPaneView('process', 'Execution', widths.right, rightHeights.process);
+        const contextPane = this.buildPaneView('context', 'Context', widths.right, rightHeights.context);
+        const workspaceView = this.uiMode === 'command'
+            ? null
+            : this.buildWorkspacePaneView(columns, contentHeight);
+        const header = renderMenuBar(this.buildHeaderLine(), columns, this.uiMode === 'menu' ? this.menuState.activeIndex : null);
+        const status = renderStatusBar(this.buildStatusLine(), columns, this.buildHotkeys());
+        const inputPrefix = this.buildInputPrefix();
+        const inputValue = this.buildInputValue();
+        const inputLine = renderCommandBar(inputPrefix, inputValue, columns);
+        const gap = paint(' ', ANSI.bgBlue);
+        const lines = [header];
+        if (workspaceView) {
+            lines.push(...workspaceView.lines);
+        }
+        else {
+            for (let index = 0; index < contentHeight; index += 1) {
+                const rightLine = index < rightHeights.process
+                    ? processPane[index]
+                    : contextPane[index - rightHeights.process];
+                lines.push(`${sessionsPane[index]}${gap}${messagesPane[index]}${gap}${rightLine}`);
+            }
+        }
+        lines.push(status);
+        lines.push(inputLine);
+        this.paintFrame(lines, { columns, rows });
+        if (workspaceView?.cursor && !this.pendingPrompt) {
+            output.write(`\u001b[${workspaceView.cursor.row};${workspaceView.cursor.column}H`);
+            return;
+        }
+        const cursorColumn = Math.min(columns, inputPrefix.length + this.cursor + 1);
+        output.write(`\u001b[${rows};${cursorColumn}H`);
+    }
+    paintFrame(lines, size) {
+        const patch = computeFramePatch(this.previousFrameLines, lines, this.previousFrameSize, size);
+        let buffer = '\u001b[0m';
+        if (patch.fullRender) {
+            buffer += `\u001b[H\u001b[2J${lines.join('\n')}\u001b[?25h`;
+        }
+        else if (patch.changedRows.length > 0) {
+            for (const change of patch.changedRows) {
+                buffer += `\u001b[${change.row};1H\u001b[2K${change.line}`;
+            }
+            buffer += '\u001b[?25h';
+        }
+        else {
+            buffer += '\u001b[?25h';
+        }
+        output.write(buffer);
+        this.previousFrameLines = [...lines];
+        this.previousFrameSize = size;
+    }
+    buildHeaderLine() {
+        const sessionLabel = this.sessionDetail
+            ? `${this.sessionDetail.title} (${this.sessionDetail.id.slice(0, 8)})`
+            : 'no session';
+        const skillLabel = this.commands.length > 0
+            ? `${this.commands.length} skill${this.commands.length === 1 ? '' : 's'}`
+            : 'no skills';
+        const mode = this.busy ? '[Running]' : '[Idle]';
+        return `${sessionLabel}   ${mode}   ${skillLabel}`;
+    }
+    buildStatusLine() {
+        if (this.uiMode === 'menu') {
+            const menu = this.getMenuDefinitions()[this.menuState.activeIndex];
+            return `Menu ${menu?.label ?? ''} | ${menu?.items[this.menuState.selectedIndex]?.description ?? 'Choose an action.'}`;
+        }
+        if ((this.uiMode === 'picker' || this.uiMode === 'palette') && this.pickerState) {
+            const selected = this.pickerState.filteredItems[this.pickerState.selectedIndex];
+            return `${this.pickerState.title} | ${selected?.description ?? this.pickerState.emptyText}`;
+        }
+        if (this.uiMode === 'viewer' && this.viewerState) {
+            return `${this.viewerState.title} | ${this.viewerState.path ? path.relative(this.workspaceRoot, this.viewerState.path) : 'read-only view'}`;
+        }
+        if (this.uiMode === 'editor' && this.editorState) {
+            const dirty = this.editorState.dirty ? 'modified' : 'saved';
+            return `${this.editorState.title} | ${dirty} | Ln ${this.editorState.cursorLine + 1}, Col ${this.editorState.cursorColumn + 1}`;
+        }
+        const focus = paneDisplayName(this.focusedPane);
+        if (!this.pendingPrompt && this.focusedPane !== 'sessions') {
+            const follow = this.paneScroll[this.focusedPane] === 0 ? 'follow' : `scroll ${this.paneScroll[this.focusedPane]}`;
+            return `${this.statusLine} | Focus ${focus} | ${follow}`;
+        }
+        if (this.pendingPrompt) {
+            return this.pendingPrompt.kind === 'clarify'
+                ? `Clarify: ${condenseWhitespace(this.pendingPrompt.prompt)} | Focus ${focus}`
+                : `Input: ${condenseWhitespace(this.pendingPrompt.prompt)} | Focus ${focus}`;
+        }
+        return `${this.statusLine} | Focus ${focus}`;
+    }
+    buildInputPrefix() {
+        if (this.uiMode === 'menu') {
+            return ' Menu > ';
+        }
+        if (this.uiMode === 'picker' || this.uiMode === 'palette') {
+            return ' Search > ';
+        }
+        if (this.pendingPrompt?.kind === 'clarify') {
+            return ' Clarify ? ';
+        }
+        if (this.pendingPrompt) {
+            return ' Input > ';
+        }
+        if (this.uiMode === 'editor') {
+            return ' Editor > ';
+        }
+        if (this.uiMode === 'viewer') {
+            return ' Viewer > ';
+        }
+        return ' Command > ';
+    }
+    buildInputValue() {
+        if (this.uiMode === 'editor') {
+            return 'Ctrl+S save  Esc close  arrows move';
+        }
+        if (this.uiMode === 'viewer') {
+            return this.viewerState?.canEdit ? 'Ctrl+E edit  Esc close  PgUp/PgDn scroll' : 'Esc close  PgUp/PgDn scroll';
+        }
+        return this.inputValue;
+    }
+    buildSessionPaneBody() {
+        if (this.sessions.length === 0) {
+            return ['No sessions yet.'];
+        }
+        const lines = [];
+        for (const session of this.sessions) {
+            const selected = session.id === this.selectedSessionId ? '>' : ' ';
+            lines.push(`${selected} ${session.title}`);
+            lines.push(`  ${formatTimestamp(session.updatedAt)}`);
+        }
+        return lines;
+    }
+    buildMessagesPaneBody() {
+        const entries = [];
+        if (this.sessionDetail) {
+            for (const message of this.sessionDetail.messages) {
+                entries.push({ role: message.role, content: message.content });
+            }
+        }
+        const persistedEphemeral = this.ephemeralMessagesBySessionId.get(this.selectedSessionId) ?? [];
+        entries.push(...persistedEphemeral);
+        if (this.currentPreview && this.currentPreview.sessionId === this.selectedSessionId) {
+            entries.push(...this.currentPreview.entries);
+        }
+        if (entries.length === 0) {
+            return [
+                '[System] No messages yet.',
+                '  Enter a prompt to start a conductor turn.',
+                '  The center pane shows user and assistant messages.',
+            ];
+        }
+        const lines = [];
+        for (const entry of entries) {
+            const header = this.formatMessageHeader(entry);
+            lines.push(header);
+            const bodyLines = entry.content
+                ? entry.content.split(/\r?\n/)
+                : (entry.pending ? [''] : ['(empty)']);
+            if (entry.pending && !entry.content) {
+                bodyLines[0] = 'thinking...';
+            }
+            for (const line of bodyLines) {
+                lines.push(`  ${line}`);
+            }
+            lines.push('');
+        }
+        return lines;
+    }
+    buildProcessPaneBody() {
+        const activity = this.currentProcessActivity().snapshot();
+        if (activity.length > 0) {
+            return activity;
+        }
+        return [
+            'No execution activity yet.',
+            'Tool calls, logs, outputs, and exceptions render here.',
+            'Use /cancel to abort the current execution.',
+        ];
+    }
+    buildContextPaneBody() {
+        if (!this.sessionDetail) {
+            return ['No session selected.'];
+        }
+        const contextSize = summarizeContextSize(this.sessionDetail);
+        const usageEntries = Object.entries(this.sessionDetail.usageByModel ?? {})
+            .sort((left, right) => right[1].totalTokens - left[1].totalTokens || left[0].localeCompare(right[0]));
+        const body = [
+            'Context Size',
+            `Messages ${formatInteger(contextSize.messageCount)}`,
+            `Transcript ${formatByteSize(contextSize.messageBytes)} (~${formatInteger(contextSize.messageTokens)} tok)`,
+            `Task Memory ${formatByteSize(contextSize.taskMemoryBytes)} (~${formatInteger(contextSize.taskMemoryTokens)} tok)`,
+            `Assistant Memory ${formatByteSize(contextSize.assistantMemoryBytes)} (~${formatInteger(contextSize.assistantMemoryTokens)} tok)`,
+            `Total ${formatByteSize(contextSize.totalBytes)} (~${formatInteger(contextSize.totalTokens)} tok)`,
+            '',
+            'Session Token Usage',
+        ];
+        if (usageEntries.length === 0) {
+            body.push('(no usage recorded yet)');
+            return body;
+        }
+        for (const [modelId, usage] of usageEntries) {
+            body.push(modelId);
+            body.push(`  total ${formatInteger(usage.totalTokens)}  in ${formatInteger(usage.inputTokens)}  out ${formatInteger(usage.outputTokens)}  calls ${formatInteger(usage.calls)}`);
+            const extras = [];
+            if (usage.cacheReadTokens > 0) {
+                extras.push(`cache-read ${formatInteger(usage.cacheReadTokens)}`);
+            }
+            if (usage.cacheWriteTokens > 0) {
+                extras.push(`cache-write ${formatInteger(usage.cacheWriteTokens)}`);
+            }
+            if (usage.reasoningTokens > 0) {
+                extras.push(`reasoning ${formatInteger(usage.reasoningTokens)}`);
+            }
+            if (extras.length > 0) {
+                body.push(`  ${extras.join('  ')}`);
+            }
+            body.push('');
+        }
+        return body;
+    }
+    buildPaneView(kind, title, width, height) {
+        const metrics = this.getPaneMetrics(kind, width, height);
+        const paneTitle = this.buildPaneTitle(title, kind, metrics);
+        return buildPane(paneTitle, metrics.lines.slice(metrics.start, metrics.start + metrics.viewportLines), width, height, kind, this.focusedPane === kind);
+    }
+    buildWorkspacePaneView(width, height) {
+        if (this.uiMode === 'editor' && this.editorState) {
+            return this.buildEditorPaneView(width, height, this.editorState);
+        }
+        if ((this.uiMode === 'picker' || this.uiMode === 'palette') && this.pickerState) {
+            return {
+                lines: buildPane(this.pickerState.title, this.buildPickerPaneBody(this.pickerState), width, height, 'workspace', true),
+            };
+        }
+        if (this.uiMode === 'viewer' && this.viewerState) {
+            return {
+                lines: buildPane(this.viewerState.title, this.buildViewerPaneBody(this.viewerState), width, height, 'workspace', true),
+            };
+        }
+        const menu = this.getMenuDefinitions()[this.menuState.activeIndex];
+        return {
+            lines: buildPane(`Menu: ${menu?.label ?? 'Menu'}`, this.buildMenuPaneBody(menu), width, height, 'workspace', true),
+        };
+    }
+    buildMenuPaneBody(menu) {
+        if (!menu) {
+            return ['No menu available.'];
+        }
+        const lines = [
+            'Use Left/Right or 1-6 to move across the menu bar, Up/Down to choose an item, and Enter to run it.',
+            '',
+        ];
+        menu.items.forEach((item, index) => {
+            const prefix = index === this.menuState.selectedIndex ? '>' : ' ';
+            const suffix = item.enabled === false ? ' [disabled]' : item.shortcut ? ` [${item.shortcut}]` : '';
+            lines.push(`${prefix} ${item.label}${suffix}`);
+            lines.push(`  ${item.description}`);
+            lines.push('');
+        });
+        return lines;
+    }
+    buildPickerPaneBody(state) {
+        const lines = [
+            `Search: ${this.inputValue || '(type to filter)'}`,
+            `Results: ${state.filteredItems.length}/${state.items.length}`,
+            '',
+        ];
+        if (state.filteredItems.length === 0) {
+            lines.push(state.emptyText);
+            return lines;
+        }
+        state.filteredItems.forEach((item, index) => {
+            const prefix = index === state.selectedIndex ? '>' : ' ';
+            lines.push(`${prefix} ${item.label}${item.detail ? `  ${item.detail}` : ''}`);
+            lines.push(`  ${item.description}`);
+            lines.push('');
+        });
+        return lines.slice(state.scrollTop);
+    }
+    buildViewerPaneBody(state) {
+        const lines = [
+            state.path ? `Path: ${path.relative(this.workspaceRoot, state.path)}` : 'Read-only view',
+            state.canEdit ? 'Ctrl+E opens the editor for this file.' : 'Read-only content.',
+            '',
+            ...state.content.split(/\r?\n/).map((line, index) => `${String(index + 1).padStart(4, ' ')} | ${line}`),
+        ];
+        return lines.slice(state.scrollTop);
+    }
+    buildEditorPaneView(width, height, state) {
+        const innerWidth = Math.max(1, width - 2);
+        const viewportLines = Math.max(0, height - 2);
+        const lineNumberWidth = Math.max(2, String(Math.max(1, state.lines.length)).length);
+        const prefixWidth = 2 + lineNumberWidth + 3;
+        const contentWidth = Math.max(1, innerWidth - prefixWidth);
+        const maxStart = Math.max(0, state.lines.length - viewportLines);
+        state.scrollTop = clamp(state.scrollTop, 0, maxStart);
+        const lines = [renderWindowTop(`${state.title}${state.dirty ? ' [modified]' : ''}`, innerWidth, true)];
+        for (let offset = 0; offset < viewportLines; offset += 1) {
+            const lineIndex = state.scrollTop + offset;
+            const lineNumber = String(lineIndex + 1).padStart(lineNumberWidth, ' ');
+            const content = state.lines[lineIndex] ?? '';
+            const visibleContent = content.slice(state.scrollLeft, state.scrollLeft + contentWidth);
+            const prefix = lineIndex === state.cursorLine ? '> ' : '  ';
+            const rowText = `${prefix}${lineNumber} | ${visibleContent}`;
+            lines.push(renderWindowBody(padRight(rowText, innerWidth), innerWidth, 'workspace'));
+        }
+        if (height >= 2) {
+            lines.push(renderWindowBottom(innerWidth, true));
+        }
+        const cursorRow = Math.min(2 + viewportLines, 3 + Math.max(0, state.cursorLine - state.scrollTop));
+        const cursorColumn = Math.min(width, 2 + prefixWidth + Math.max(0, state.cursorColumn - state.scrollLeft));
+        return {
+            lines: lines.slice(0, height),
+            cursor: { row: cursorRow, column: cursorColumn },
+        };
+    }
+    buildHotkeys() {
+        if (this.uiMode === 'menu') {
+            return [
+                ['1-6', 'Menu'],
+                ['<- ->', 'Switch'],
+                ['Up/Down', 'Item'],
+                ['Enter', 'Run'],
+                ['Esc', 'Close'],
+            ];
+        }
+        if (this.uiMode === 'picker' || this.uiMode === 'palette') {
+            return [
+                ['type', 'Filter'],
+                ['Up/Down', 'Pick'],
+                ['Enter', 'Open'],
+                ['Ctrl+E', 'Edit'],
+                ['Esc', 'Close'],
+            ];
+        }
+        if (this.uiMode === 'viewer') {
+            return [
+                ['PgUp/PgDn', 'Scroll'],
+                ['Ctrl+E', 'Edit'],
+                ['Ctrl+R', 'Run'],
+                ['Esc', 'Close'],
+            ];
+        }
+        if (this.uiMode === 'editor') {
+            return [
+                ['Arrows', 'Move'],
+                ['Enter', 'Split'],
+                ['Ctrl+S', 'Save'],
+                ['Esc', 'Close'],
+            ];
+        }
+        return [
+            ['F10', 'Menu'],
+            ['Ctrl+P', 'Palette'],
+            ['<- ->', 'Pane'],
+            [this.focusedPane === 'sessions' ? 'Up/Down' : 'PgUp/PgDn', this.focusedPane === 'sessions' ? 'Select' : 'Scroll'],
+            ['End', this.focusedPane === 'sessions' ? 'Bottom' : 'Follow'],
+            ['/cancel', 'Stop'],
+        ];
+    }
+    buildPaneTitle(title, kind, metrics) {
+        if (kind === 'sessions') {
+            return this.focusedPane === kind ? `${title} [focus]` : title;
+        }
+        if (metrics.maxStart === 0) {
+            return this.focusedPane === kind ? `${title} [focus]` : title;
+        }
+        return this.paneScroll[kind] === 0
+            ? `${title}${this.focusedPane === kind ? ' [focus]' : ''} [follow]`
+            : `${title}${this.focusedPane === kind ? ' [focus]' : ''} [-${this.paneScroll[kind]}]`;
+    }
+    getPaneMetrics(kind, width = paneDimensionsForKind(kind, output.columns ?? 120, output.rows ?? 40).width, height = paneDimensionsForKind(kind, output.columns ?? 120, output.rows ?? 40).height) {
+        const innerWidth = Math.max(1, width - 2);
+        const rawBody = this.getPaneBody(kind);
+        const lines = wrapBodyLines(rawBody, innerWidth);
+        const viewportLines = Math.max(0, height - 2);
+        const maxStart = Math.max(0, lines.length - viewportLines);
+        if (kind === 'sessions') {
+            this.paneScroll.sessions = clamp(this.paneScroll.sessions, 0, maxStart);
+            return {
+                lines,
+                start: this.paneScroll.sessions,
+                maxStart,
+                viewportLines,
+            };
+        }
+        this.paneScroll[kind] = clamp(this.paneScroll[kind], 0, maxStart);
+        return {
+            lines,
+            start: Math.max(0, maxStart - this.paneScroll[kind]),
+            maxStart,
+            viewportLines,
+        };
+    }
+    getPaneBody(kind) {
+        switch (kind) {
+            case 'sessions':
+                return this.buildSessionPaneBody();
+            case 'messages':
+                return this.buildMessagesPaneBody();
+            case 'process':
+                return this.buildProcessPaneBody();
+            case 'context':
+                return this.buildContextPaneBody();
+        }
+    }
+    ensureSessionVisible() {
+        const selectedIndex = Math.max(0, this.sessions.findIndex((session) => session.id === this.selectedSessionId));
+        const contentRows = Math.max(1, (output.rows ?? 40) - 5);
+        const selectedLine = selectedIndex * 2;
+        if (selectedLine < this.paneScroll.sessions) {
+            this.paneScroll.sessions = selectedLine;
+            return;
+        }
+        if (selectedLine >= this.paneScroll.sessions + contentRows) {
+            this.paneScroll.sessions = Math.max(0, selectedLine - contentRows + 1);
+        }
+    }
+    formatMessageHeader(entry) {
+        const spinner = entry.pending ? ` ${currentSpinnerFrame()}` : '';
+        return formatDisplayMessageHeader(entry, spinner);
+    }
+    close() {
+        if (!this.closeResolver) {
+            return;
+        }
+        const resolve = this.closeResolver;
+        this.closeResolver = null;
+        resolve();
+    }
+    isEditingInput() {
+        return this.uiMode !== 'editor' && this.inputValue.length > 0;
+    }
+}
+export async function startTui(workspaceRoot = process.cwd(), options = {}) {
+    if (input.isTTY && output.isTTY) {
+        const app = new FullscreenTui(workspaceRoot, options);
+        await app.start();
+        return;
+    }
+    await startLineTui(workspaceRoot, options);
+}
+async function startLineTui(workspaceRoot = process.cwd(), options = {}) {
+    const rl = createInterface({ input, output });
+    try {
+        let session = await chooseSession(rl, workspaceRoot);
+        renderHeader(session);
+        while (true) {
+            const prompt = `${paint(session.title || session.id.slice(0, 8), ANSI.bold)} ${paint('>', ANSI.dim)} `;
+            const line = (await rl.question(prompt)).trim();
+            if (!line) {
+                continue;
+            }
+            const parsed = parseSlashInput(line);
+            if (parsed.kind === 'builtin') {
+                switch (parsed.name) {
+                    case 'cancel':
+                        console.log('No execution is currently running in line mode.');
+                        continue;
+                    case 'exit':
+                    case 'quit':
+                        return;
+                    case 'new':
+                        session = parsed.rawArgs
+                            ? await createConductorSession(workspaceRoot, parsed.rawArgs)
+                            : await createSessionInteractive(rl, workspaceRoot);
+                        console.log(`${paint('switched', ANSI.green)} ${session.title}`);
+                        renderHeader(session);
+                        continue;
+                    case 'sessions':
+                        session = await chooseSession(rl, workspaceRoot);
+                        renderHeader(session);
+                        continue;
+                    case 'help':
+                        for (const helpLine of buildHelpLines()) {
+                            console.log(helpLine);
+                        }
+                        continue;
+                    case 'compile':
+                    case 'skill-creator':
+                        if (!parsed.rawArgs.trim()) {
+                            console.log(`Provide a skill specification after /${parsed.name}.`);
+                            continue;
+                        }
+                        console.log(divider('-'));
+                        console.log(`${paint('skill', ANSI.dim)} /${parsed.name} ${parsed.rawArgs}`);
+                        console.log(divider('-'));
+                        {
+                            const printer = new LiveExecutionPrinter();
+                            try {
+                                const result = await runSkillCreatorCommand(workspaceRoot, session.id, parsed.rawArgs, {
+                                    sandbox: options.sandbox,
+                                    onUserInput: async (question) => {
+                                        printer.finish();
+                                        console.log(`${paint('clarify', ANSI.yellow)} ${question}`);
+                                        return (await rl.question('> ')).trim();
+                                    },
+                                    onEvent: (event) => printer.handle(event),
+                                });
+                                printer.finish();
+                                console.log(formatSkillCreatorSummary(workspaceRoot, result));
+                            }
+                            catch (error) {
+                                printer.finish();
+                                console.log(`${paint('error', ANSI.red)} ${error.message}`);
+                            }
+                        }
+                        console.log('');
+                        console.log(divider('-'));
+                        console.log('');
+                        continue;
+                }
+            }
+            if (parsed.kind === 'skill') {
+                console.log(divider('-'));
+                console.log(`${paint('skill', ANSI.dim)} /${parsed.name}${parsed.args.length > 0 ? ` ${parsed.args.join(' ')}` : ''}`);
+                console.log(divider('-'));
+                const printer = new LiveExecutionPrinter();
+                try {
+                    await runSkillCommand(workspaceRoot, parsed.name, parsed.args, {
+                        sandbox: options.sandbox,
+                        onUserInput: async (question) => {
+                            printer.finish();
+                            console.log(`${paint('clarify', ANSI.yellow)} ${question}`);
+                            return (await rl.question('> ')).trim();
+                        },
+                        onEvent: (event) => printer.handle(event),
+                    });
+                }
+                catch (error) {
+                    printer.finish();
+                    console.log(`${paint('error', ANSI.red)} ${error.message}`);
+                }
+                printer.finish();
+                console.log('');
+                console.log(divider('-'));
+                console.log('');
+                continue;
+            }
+            console.log(divider('-'));
+            console.log(`${paint('task', ANSI.dim)} ${parsed.prompt}`);
+            console.log(divider('-'));
+            const printer = new LiveExecutionPrinter();
+            const result = await runConductorTurn(parsed.prompt, {
+                workspaceRoot,
+                sessionId: session.id,
+                stream: true,
+                headless: true,
+                sandbox: options.sandbox,
+                onUserInput: async (question) => {
+                    printer.finish();
+                    console.log(`${paint('clarify', ANSI.yellow)} ${question}`);
+                    return (await rl.question('> ')).trim();
+                },
+                onEvent: (event) => printer.handle(event),
+            });
+            printer.finish();
+            console.log('');
+            console.log(divider('-'));
+            console.log('');
+            const sessions = await listConductorSessions(workspaceRoot);
+            session = sessions.find((entry) => entry.id === result.sessionId) ?? session;
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runPromptHeadless(prompt, workspaceRoot = process.cwd(), options = {}) {
+    const session = await createConductorSession(workspaceRoot);
+    console.log(`Session: ${session.id}`);
+    const result = await runConductorTurn(prompt, {
+        workspaceRoot,
+        sessionId: session.id,
+        stream: false,
+        headless: true,
+        sandbox: options.sandbox,
+    });
+    if (result.output.length > 0 || result.answer) {
+        console.log('');
+    }
+    for (const line of result.output) {
+        console.log(line);
+    }
+    if (result.answer) {
+        if (result.output.length > 0) {
+            console.log('');
+        }
+        console.log(result.answer);
+    }
+    if (result.error) {
+        throw new Error(result.error);
+    }
+}
+async function runSkillCommand(workspaceRoot, skillName, args, options = {}) {
+    const commands = await listCommands(workspaceRoot);
+    const command = commands.find((entry) => entry.name === skillName);
+    if (!command) {
+        throw new Error(`Unknown skill: ${skillName}`);
+    }
+    const result = await run(command.path, args, {
+        configRoot: workspaceRoot,
+        headless: true,
+        stream: true,
+        sandbox: options.sandbox,
+        signal: options.signal,
+        onUserInput: options.onUserInput,
+        onEvent: (event) => options.onEvent?.({ scope: 'child', childSlug: skillName, event }),
+        onChildEvent: (childSlug, event) => options.onEvent?.({ scope: 'child', childSlug, event }),
+    });
+    return result;
+}
+async function runSkillCreatorCommand(workspaceRoot, sessionId, spec, options = {}) {
+    const trimmedSpec = spec.trim();
+    if (!trimmedSpec) {
+        throw new Error('spec is required');
+    }
+    const config = await loadConfig(workspaceRoot);
+    const compileSelection = resolveModelSlot(config, 'compile');
+    const runSelection = resolveModelSlot(config, 'run');
+    return createLocalSkill({
+        spec: trimmedSpec,
+        workspaceRoot,
+        workspacePath: path.resolve(workspaceRoot, config.workspace || './workspace'),
+        config,
+        compileSelection,
+        runSelection,
+        sessionId,
+        sandbox: options.sandbox ?? false,
+        signal: options.signal,
+        onUserInput: options.onUserInput ?? (async () => ''),
+        onEvent: options.onEvent,
+    });
+}
+function formatSkillCreatorSummary(workspaceRoot, result) {
+    const slug = typeof result.slug === 'string' ? result.slug : 'unknown-skill';
+    const outputPath = typeof result.output_path === 'string' ? result.output_path : '';
+    if (!outputPath) {
+        return `Published /${slug}.`;
+    }
+    const relativeOutputPath = path.relative(workspaceRoot, outputPath);
+    return `Published /${slug} to ${relativeOutputPath || outputPath}.`;
+}
+export function previewMessageFromEvent(logEvent) {
+    switch (logEvent.event.type) {
+        case 'output':
+            if (!logEvent.event.content) {
+                return null;
+            }
+            return {
+                role: 'system',
+                kind: 'output',
+                tag: logEvent.scope === 'child' ? logEvent.childSlug : undefined,
+                content: logEvent.event.content,
+            };
+        case 'input_required':
+            if (!logEvent.event.prompt) {
+                return null;
+            }
+            return previewQuestionMessage(logEvent.event.prompt, logEvent.scope === 'child' ? logEvent.childSlug : undefined);
+        default:
+            return null;
+    }
+}
+export function previewChildSkillActivityMessage(childSlug) {
+    return {
+        role: 'system',
+        kind: 'output',
+        tag: childSlug,
+        content: 'Running child skill...',
+    };
+}
+export function previewQuestionMessage(promptText, explicitTag) {
+    const parsed = explicitTag ? { tag: explicitTag, content: promptText } : parseTaggedPrompt(promptText);
+    return {
+        role: 'system',
+        kind: 'question',
+        tag: parsed.tag,
+        content: parsed.content,
+    };
+}
+export function parseCommandArgs(rawArgs) {
+    const args = [];
+    let current = '';
+    let quote = null;
+    let escaping = false;
+    for (const char of rawArgs.trim()) {
+        if (escaping) {
+            current += char;
+            escaping = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaping = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === '"' || char === '\'') {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                args.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (escaping) {
+        current += '\\';
+    }
+    if (current) {
+        args.push(current);
+    }
+    return args;
+}
+export function parseSlashInput(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('/')) {
+        return { kind: 'text', prompt: trimmed };
+    }
+    if (trimmed === '/') {
+        return { kind: 'builtin', name: 'help', rawArgs: '', args: [] };
+    }
+    const match = trimmed.slice(1).match(/^(\S+)(?:\s+(.*))?$/);
+    if (!match) {
+        return { kind: 'builtin', name: 'help', rawArgs: '', args: [] };
+    }
+    const name = match[1];
+    const rawArgs = (match[2] ?? '').trim();
+    if (BUILTIN_SLASH_COMMANDS.includes(name)) {
+        const passthroughRawArgBuiltins = new Set(['new', 'compile', 'skill-creator']);
+        return {
+            kind: 'builtin',
+            name: name,
+            rawArgs,
+            args: passthroughRawArgBuiltins.has(name) && rawArgs
+                ? [rawArgs]
+                : parseCommandArgs(rawArgs),
+        };
+    }
+    return {
+        kind: 'skill',
+        name,
+        rawArgs,
+        args: parseCommandArgs(rawArgs),
+    };
+}
+export function canSubmitParsedInputWhileBusy(parsed) {
+    return parsed.kind === 'builtin' && (parsed.name === 'cancel' || parsed.name === 'exit' || parsed.name === 'quit');
+}
+export function computeFramePatch(previousLines, nextLines, previousSize, nextSize) {
+    if (!previousLines
+        || !previousSize
+        || previousSize.columns !== nextSize.columns
+        || previousSize.rows !== nextSize.rows
+        || previousLines.length !== nextLines.length) {
+        return { fullRender: true, changedRows: [] };
+    }
+    const changedRows = [];
+    for (let index = 0; index < nextLines.length; index += 1) {
+        if (previousLines[index] !== nextLines[index]) {
+            changedRows.push({ row: index + 1, line: nextLines[index] });
+        }
+    }
+    return { fullRender: false, changedRows };
+}
+export function completeSlashCommand(inputValue, candidates) {
+    if (!inputValue.startsWith('/')) {
+        return { value: inputValue, matches: [], applied: false };
+    }
+    const match = inputValue.match(/^\/([^\s]*)(.*)$/s);
+    if (!match) {
+        return { value: inputValue, matches: [], applied: false };
+    }
+    const prefix = match[1];
+    const suffix = match[2] ?? '';
+    const uniqueCandidates = Array.from(new Set(candidates)).sort();
+    const matches = uniqueCandidates.filter((candidate) => candidate.startsWith(prefix));
+    if (matches.length === 0) {
+        return { value: inputValue, matches: [], applied: false };
+    }
+    if (matches.length === 1) {
+        return {
+            value: `/${matches[0]}${suffix.length > 0 ? suffix : ' '}`,
+            matches,
+            applied: true,
+        };
+    }
+    const sharedPrefix = longestCommonPrefix(matches);
+    if (sharedPrefix.length > prefix.length) {
+        return {
+            value: `/${sharedPrefix}${suffix}`,
+            matches,
+            applied: true,
+        };
+    }
+    return { value: inputValue, matches, applied: false };
+}
+async function chooseSession(rl, workspaceRoot) {
+    const sessions = await listConductorSessions(workspaceRoot);
+    if (sessions.length === 0) {
+        return createSessionInteractive(rl, workspaceRoot);
+    }
+    console.log(divider('='));
+    console.log(paint('Sessions', ANSI.bold));
+    sessions.slice(0, 9).forEach((session, index) => {
+        console.log(`${paint(String(index + 1).padStart(2, ' '), ANSI.cyan)}  ${session.title} ${paint(session.updatedAt.replace('T', ' ').slice(0, 16), ANSI.dim)}`);
+    });
+    console.log(`${paint(' 0', ANSI.cyan)}  Start a new session`);
+    console.log(divider('='));
+    while (true) {
+        const answer = (await rl.question(paint('Select a session [0]: ', ANSI.dim))).trim();
+        if (!answer || answer === '0') {
+            return createSessionInteractive(rl, workspaceRoot);
+        }
+        const numeric = Number.parseInt(answer, 10);
+        if (!Number.isNaN(numeric) && numeric >= 1 && numeric <= Math.min(sessions.length, 9)) {
+            return sessions[numeric - 1];
+        }
+        console.log('Enter a listed session number or 0 for a new session.');
+    }
+}
+async function createSessionInteractive(rl, workspaceRoot) {
+    const title = (await rl.question(paint('New session title (optional): ', ANSI.dim))).trim();
+    return createConductorSession(workspaceRoot, title || undefined);
+}
+function renderHeader(session) {
+    console.log(divider('='));
+    console.log(`${paint('DeepClause', ANSI.bold, ANSI.cyan)} ${paint('interactive conductor', ANSI.dim)}`);
+    console.log(`${paint('commands', ANSI.dim)} /compile <spec>  /new  /sessions  /help  /exit  /skill args`);
+    console.log(`${paint('session', ANSI.dim)}  ${paint(session.id, ANSI.cyan)}`);
+    console.log(divider('='));
+    console.log('');
+}
+function streamLabel(logEvent) {
+    return logEvent.scope === 'child'
+        ? `${CHILD_EVENT_INDENT}[${logEvent.childSlug ?? '?'}] llm`
+        : 'llm';
+}
+function formatEventPrefix(logEvent) {
+    return logEvent.scope === 'child'
+        ? `${CHILD_EVENT_INDENT}[${logEvent.childSlug ?? '?'}] `
+        : '';
+}
+function parseTaggedPrompt(promptText) {
+    const match = promptText.match(/^\[([^\]]+)\]\s*(.*)$/);
+    if (!match) {
+        return { content: promptText };
+    }
+    return {
+        tag: match[1],
+        content: match[2] || promptText,
+    };
+}
+function sameDisplayMessage(left, right) {
+    return !!left
+        && left.role === right.role
+        && left.kind === right.kind
+        && left.tag === right.tag
+        && left.content === right.content;
+}
+function formatSystemMessageHeader(entry, spinner) {
+    const base = entry.kind === 'output'
+        ? 'Output'
+        : entry.kind === 'question'
+            ? 'Question'
+            : 'System';
+    return entry.tag
+        ? `[${base}: ${entry.tag}${spinner}]`
+        : `[${base}${spinner}]`;
+}
+export function formatDisplayMessageHeader(entry, spinner = '') {
+    switch (entry.role) {
+        case 'user':
+            return '[You]';
+        case 'assistant': {
+            const base = entry.error ? 'Assistant Error' : 'Assistant';
+            return entry.tag
+                ? `[${base}: ${entry.tag}${spinner}]`
+                : `[${base}${spinner}]`;
+        }
+        case 'system':
+            return formatSystemMessageHeader(entry, spinner);
+    }
+}
+function formatToolArgs(args) {
+    if (!args) {
+        return '';
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(args)) {
+        let rendered = typeof value === 'string' ? value : JSON.stringify(value);
+        if (rendered.length > 80) {
+            rendered = rendered.slice(0, 77) + '...';
+        }
+        parts.push(`${key}=${rendered}`);
+    }
+    return parts.join(', ');
+}
+function buildHelpLines() {
+    return [
+        'commands',
+        '/new [title]    create a new conductor session',
+        '/sessions       refresh or choose sessions',
+        '/compile <spec> compile and publish a new local skill',
+        '/skill-creator <spec> alias for /compile',
+        '/cancel         abort the current execution',
+        '/help           show this help',
+        '/quit           exit the TUI',
+        '/<skill> [args] run a compiled skill directly',
+        'keys',
+        'F10 / Ctrl+G    open the menu bar',
+        'Ctrl+P          open the action palette',
+        'Left/Right      change focused pane',
+        'Up/Down         select session or scroll focused pane',
+        'PgUp/PgDn       page-scroll the focused pane',
+        'End             jump to bottom or re-enable follow mode',
+        'Tab             autocomplete /commands and /skills',
+    ];
+}
+function getSlashHelpLines() {
+    const lines = buildHelpLines();
+    const keysIndex = lines.indexOf('keys');
+    return keysIndex === -1 ? lines : lines.slice(0, keysIndex);
+}
+function getShortcutHelpLines() {
+    const lines = buildHelpLines();
+    const keysIndex = lines.indexOf('keys');
+    return keysIndex === -1 ? [] : lines.slice(keysIndex);
+}
+function computePaneWidths(columns) {
+    const available = Math.max(36, columns - 2);
+    let left = Math.max(18, Math.floor(available * 0.2));
+    let right = Math.max(28, Math.floor(available * 0.3));
+    let center = available - left - right;
+    if (center < 30) {
+        const needed = 30 - center;
+        const reduceRight = Math.min(needed, Math.max(0, right - 18));
+        right -= reduceRight;
+        center += reduceRight;
+        if (center < 30) {
+            const reduceLeft = Math.min(30 - center, Math.max(0, left - 14));
+            left -= reduceLeft;
+            center += reduceLeft;
+        }
+    }
+    center += available - left - center - right;
+    return { left, center, right };
+}
+function computeRightPaneHeights(totalHeight) {
+    if (totalHeight <= 8) {
+        return { process: Math.max(1, totalHeight - 1), context: 1 };
+    }
+    let process = Math.max(8, Math.floor(totalHeight * 0.58));
+    let context = totalHeight - process;
+    if (context < 6) {
+        const deficit = 6 - context;
+        process = Math.max(6, process - deficit);
+        context = totalHeight - process;
+    }
+    return { process, context };
+}
+function buildPane(title, body, width, height, kind, active = false) {
+    if (height <= 0) {
+        return [];
+    }
+    const innerWidth = Math.max(1, width - 2);
+    const lines = [renderWindowTop(title, innerWidth, active)];
+    bodyLoop: for (const line of body) {
+        for (const wrapped of wrapPlainText(line, innerWidth)) {
+            if (lines.length >= height - 1) {
+                break bodyLoop;
+            }
+            lines.push(renderWindowBody(wrapped, innerWidth, kind));
+        }
+    }
+    while (lines.length < height - 1) {
+        lines.push(renderWindowBody('', innerWidth, kind));
+    }
+    if (height >= 2) {
+        lines.push(renderWindowBottom(innerWidth, active));
+    }
+    return lines.slice(0, height);
+}
+export function wrapPlainText(text, width) {
+    if (width <= 0) {
+        return [''];
+    }
+    const result = [];
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = expandTabs(rawLine || '', CHILD_EVENT_TAB_WIDTH);
+        if (!line) {
+            result.push('');
+            continue;
+        }
+        let remaining = line;
+        while (measureDisplayWidth(remaining) > width) {
+            const { head: slice, tail } = splitByDisplayWidth(remaining, width, { forceOne: true });
+            const breakIndex = slice.lastIndexOf(' ');
+            const breakSlice = breakIndex === -1 ? '' : slice.slice(0, breakIndex);
+            if (breakIndex > 0 && measureDisplayWidth(breakSlice) > Math.floor(width * 0.4)) {
+                result.push(breakSlice);
+                remaining = remaining.slice(breakIndex + 1);
+            }
+            else {
+                result.push(slice);
+                remaining = tail;
+            }
+        }
+        result.push(remaining);
+    }
+    return result;
+}
+function expandTabs(text, tabWidth) {
+    if (!text.includes('\t')) {
+        return text;
+    }
+    return text.replace(/\t/g, ' '.repeat(tabWidth));
+}
+export function measureDisplayWidth(text) {
+    return splitGraphemes(text).reduce((total, grapheme) => total + graphemeDisplayWidth(grapheme), 0);
+}
+export function padRight(text, width) {
+    const visibleWidth = measureDisplayWidth(text);
+    return visibleWidth >= width ? text : `${text}${' '.repeat(width - visibleWidth)}`;
+}
+export function ellipsize(text, width) {
+    if (measureDisplayWidth(text) <= width) {
+        return text;
+    }
+    if (width <= 3) {
+        return splitByDisplayWidth(text, width).head;
+    }
+    return `${splitByDisplayWidth(text, width - 3).head}...`;
+}
+function splitGraphemes(text) {
+    if (!text) {
+        return [];
+    }
+    if (!graphemeSegmenter) {
+        return Array.from(text);
+    }
+    return Array.from(graphemeSegmenter.segment(text), (entry) => entry.segment);
+}
+function splitByDisplayWidth(text, width, options = {}) {
+    if (width <= 0) {
+        return { head: '', tail: text };
+    }
+    const graphemes = splitGraphemes(text);
+    let consumedWidth = 0;
+    let index = 0;
+    while (index < graphemes.length) {
+        const nextWidth = graphemeDisplayWidth(graphemes[index]);
+        if (consumedWidth + nextWidth > width) {
+            if (index === 0 && options.forceOne) {
+                index = 1;
+            }
+            break;
+        }
+        consumedWidth += nextWidth;
+        index += 1;
+    }
+    return {
+        head: graphemes.slice(0, index).join(''),
+        tail: graphemes.slice(index).join(''),
+    };
+}
+function graphemeDisplayWidth(grapheme) {
+    if (!grapheme) {
+        return 0;
+    }
+    if (isEmojiGrapheme(grapheme)) {
+        return 2;
+    }
+    let width = 0;
+    for (const symbol of Array.from(grapheme)) {
+        const codePoint = symbol.codePointAt(0);
+        if (codePoint === undefined || isZeroWidthCodePoint(codePoint, symbol)) {
+            continue;
+        }
+        width = Math.max(width, isFullWidthCodePoint(codePoint) ? 2 : 1);
+    }
+    return width;
+}
+function isEmojiGrapheme(grapheme) {
+    if (EXTENDED_PICTOGRAPHIC_RE.test(grapheme) || grapheme.includes('\u200D') || grapheme.includes('\uFE0F') || grapheme.includes('\u20E3')) {
+        return true;
+    }
+    return Array.from(grapheme).some((symbol) => {
+        const codePoint = symbol.codePointAt(0);
+        return codePoint !== undefined && isRegionalIndicatorCodePoint(codePoint);
+    });
+}
+function isZeroWidthCodePoint(codePoint, symbol) {
+    return COMBINING_MARK_RE.test(symbol)
+        || codePoint === 0x200D
+        || (codePoint >= 0xFE00 && codePoint <= 0xFE0F)
+        || (codePoint >= 0xE0100 && codePoint <= 0xE01EF)
+        || (codePoint >= 0x1F3FB && codePoint <= 0x1F3FF);
+}
+function isRegionalIndicatorCodePoint(codePoint) {
+    return codePoint >= 0x1F1E6 && codePoint <= 0x1F1FF;
+}
+function isFullWidthCodePoint(codePoint) {
+    if (codePoint < 0x1100) {
+        return false;
+    }
+    return codePoint <= 0x115F
+        || codePoint === 0x2329
+        || codePoint === 0x232A
+        || (codePoint >= 0x2E80 && codePoint <= 0x3247 && codePoint !== 0x303F)
+        || (codePoint >= 0x3250 && codePoint <= 0x4DBF)
+        || (codePoint >= 0x4E00 && codePoint <= 0xA4C6)
+        || (codePoint >= 0xA960 && codePoint <= 0xA97C)
+        || (codePoint >= 0xAC00 && codePoint <= 0xD7A3)
+        || (codePoint >= 0xF900 && codePoint <= 0xFAFF)
+        || (codePoint >= 0xFE10 && codePoint <= 0xFE19)
+        || (codePoint >= 0xFE30 && codePoint <= 0xFE6B)
+        || (codePoint >= 0xFF01 && codePoint <= 0xFF60)
+        || (codePoint >= 0xFFE0 && codePoint <= 0xFFE6)
+        || (codePoint >= 0x1F200 && codePoint <= 0x1F251)
+        || (codePoint >= 0x20000 && codePoint <= 0x3FFFD);
+}
+function condenseWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function formatTimestamp(value) {
+    return value.replace('T', ' ').slice(0, 16);
+}
+function summarizeContextSize(detail) {
+    const transcript = detail.messages.map((message) => `${message.role}: ${message.content}`).join('\n');
+    const taskMemory = detail.taskMemory ?? '';
+    const assistantMemory = detail.assistantMemory ?? '';
+    const messageBytes = Buffer.byteLength(transcript, 'utf8');
+    const taskMemoryBytes = Buffer.byteLength(taskMemory, 'utf8');
+    const assistantMemoryBytes = Buffer.byteLength(assistantMemory, 'utf8');
+    const messageTokens = estimateTokenCount(transcript);
+    const taskMemoryTokens = estimateTokenCount(taskMemory);
+    const assistantMemoryTokens = estimateTokenCount(assistantMemory);
+    return {
+        messageCount: detail.messages.length,
+        messageBytes,
+        messageTokens,
+        taskMemoryBytes,
+        taskMemoryTokens,
+        assistantMemoryBytes,
+        assistantMemoryTokens,
+        totalBytes: messageBytes + taskMemoryBytes + assistantMemoryBytes,
+        totalTokens: messageTokens + taskMemoryTokens + assistantMemoryTokens,
+    };
+}
+function estimateTokenCount(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return 0;
+    }
+    return Math.max(1, Math.ceil(normalized.length / 4));
+}
+function formatByteSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    if (bytes < 1024 * 1024) {
+        const kib = bytes / 1024;
+        return `${kib >= 10 ? kib.toFixed(0) : kib.toFixed(1)} KB`;
+    }
+    const mib = bytes / (1024 * 1024);
+    return `${mib.toFixed(1)} MB`;
+}
+function formatInteger(value) {
+    return new Intl.NumberFormat('en-US').format(value);
+}
+function longestCommonPrefix(values) {
+    if (values.length === 0) {
+        return '';
+    }
+    let prefix = values[0];
+    for (const value of values.slice(1)) {
+        while (!value.startsWith(prefix) && prefix) {
+            prefix = prefix.slice(0, -1);
+        }
+        if (!prefix) {
+            break;
+        }
+    }
+    return prefix;
+}
+function renderMenuBar(text, columns, activeMenuIndex) {
+    const labels = ['Session', 'Skills', 'Files', 'Run', 'View', 'Help'];
+    let rendered = paint(' DeepClause ', ANSI.black, ANSI.bgWhite, ANSI.bold);
+    let usedWidth = measureDisplayWidth(' DeepClause ');
+    labels.forEach((label, index) => {
+        const raw = ` [${index + 1}] ${label} `;
+        usedWidth += measureDisplayWidth(raw);
+        rendered += paint(raw, ANSI.black, activeMenuIndex === index ? ANSI.bgCyan : ANSI.bgWhite, ANSI.bold);
+    });
+    const trailingWidth = Math.max(0, columns - usedWidth);
+    rendered += paint(padRight(ellipsize(` ${text}`, trailingWidth), trailingWidth), ANSI.black, ANSI.bgWhite);
+    return rendered;
+}
+function renderStatusBar(status, columns, hotkeys) {
+    let hotkeyWidth = 0;
+    const selected = [];
+    for (const hotkey of hotkeys) {
+        const width = measureDisplayWidth(hotkey[0]) + measureDisplayWidth(hotkey[1]) + 4;
+        if (hotkeyWidth + width > Math.max(0, columns - 12)) {
+            break;
+        }
+        hotkeyWidth += width;
+        selected.push(hotkey);
+    }
+    const leftWidth = Math.max(0, columns - hotkeyWidth);
+    const statusPart = paint(padRight(ellipsize(status, leftWidth), leftWidth), ANSI.black, ANSI.bgCyan);
+    const hotkeyPart = selected.map(([key, label]) => (`${paint(` ${key} `, ANSI.black, ANSI.bgWhite, ANSI.bold)}${paint(` ${label} `, ANSI.black, ANSI.bgCyan)}`)).join('');
+    return `${statusPart}${hotkeyPart}`;
+}
+function renderCommandBar(prefix, value, columns) {
+    const prefixPart = paint(prefix, ANSI.black, ANSI.bgWhite, ANSI.bold);
+    const remainingWidth = Math.max(0, columns - measureDisplayWidth(prefix));
+    const valuePart = paint(padRight(ellipsize(value, remainingWidth), remainingWidth), ANSI.brightWhite, ANSI.bgBlue);
+    return `${prefixPart}${valuePart}`;
+}
+function renderWindowTop(title, innerWidth, active) {
+    const safeLabel = ` ${ellipsize(title, Math.max(1, innerWidth - 2))} `;
+    const fillWidth = Math.max(0, innerWidth - measureDisplayWidth(safeLabel));
+    const leftFill = Math.floor(fillWidth / 2);
+    const rightFill = fillWidth - leftFill;
+    return [
+        paint(`╔${'═'.repeat(leftFill)}`, ANSI.brightCyan, ANSI.bgBlue),
+        paint(safeLabel, ANSI.black, active ? ANSI.bgCyan : ANSI.bgWhite, ANSI.bold),
+        paint(`${'═'.repeat(rightFill)}╗`, ANSI.brightCyan, ANSI.bgBlue),
+    ].join('');
+}
+function renderWindowBottom(innerWidth, _active) {
+    return paint(`╚${'═'.repeat(innerWidth)}╝`, ANSI.brightCyan, ANSI.bgBlue);
+}
+function renderWindowBody(text, innerWidth, kind) {
+    const normalized = text.trim().toLowerCase();
+    const content = padRight(ellipsize(text, innerWidth), innerWidth);
+    const border = paint('║', ANSI.brightCyan, ANSI.bgBlue);
+    if (kind === 'workspace' && text.startsWith('> ')) {
+        return `${border}${paint(content, ANSI.black, ANSI.bgCyan, ANSI.bold)}${border}`;
+    }
+    if (kind === 'sessions' && text.startsWith('> ')) {
+        return `${border}${paint(content, ANSI.black, ANSI.bgCyan, ANSI.bold)}${border}`;
+    }
+    if (kind === 'messages') {
+        if (text.startsWith('[You]')) {
+            return `${border}${paint(content, ANSI.brightCyan, ANSI.bgBlue, ANSI.bold)}${border}`;
+        }
+        if (text.startsWith('[Assistant Error]')) {
+            return `${border}${paint(content, ANSI.red, ANSI.bgBlue, ANSI.bold)}${border}`;
+        }
+        if (text.startsWith('[Assistant')) {
+            return `${border}${paint(content, ANSI.brightYellow, ANSI.bgBlue, ANSI.bold)}${border}`;
+        }
+        if (text.startsWith('[System')) {
+            return `${border}${paint(content, ANSI.cyan, ANSI.bgBlue, ANSI.bold)}${border}`;
+        }
+    }
+    if (kind === 'process') {
+        if (normalized.startsWith('error')) {
+            return `${border}${paint(content, ANSI.red, ANSI.bgBlue, ANSI.bold)}${border}`;
+        }
+        if (normalized.startsWith('answer')) {
+            return `${border}${paint(content, ANSI.brightYellow, ANSI.bgBlue, ANSI.bold)}${border}`;
+        }
+        if (normalized.startsWith('tool')) {
+            return `${border}${paint(content, ANSI.brightCyan, ANSI.bgBlue)}${border}`;
+        }
+        if (normalized.startsWith('clarify')) {
+            return `${border}${paint(content, ANSI.yellow, ANSI.bgBlue, ANSI.bold)}${border}`;
+        }
+        if (normalized.startsWith('task') || normalized.startsWith('skill')) {
+            return `${border}${paint(content, ANSI.brightWhite, ANSI.bgBlue, ANSI.bold)}${border}`;
+        }
+    }
+    if (normalized === 'task memory' ||
+        normalized === 'assistant memory' ||
+        normalized === 'recent messages' ||
+        normalized === 'commands' ||
+        normalized === 'keys') {
+        return `${border}${paint(content, ANSI.brightYellow, ANSI.bgBlue, ANSI.bold)}${border}`;
+    }
+    if (kind === 'context' && (normalized.startsWith('created ') || normalized.startsWith('updated ') || normalized.startsWith('session '))) {
+        return `${border}${paint(content, ANSI.cyan, ANSI.bgBlue)}${border}`;
+    }
+    if (kind === 'sessions' && text.startsWith('  ')) {
+        return `${border}${paint(content, ANSI.cyan, ANSI.bgBlue)}${border}`;
+    }
+    return `${border}${paint(content, ANSI.white, ANSI.bgBlue)}${border}`;
+}
+function divider(character) {
+    const glyph = character === '=' ? '═' : character === '-' ? '─' : character;
+    return paint(glyph.repeat(72), ANSI.brightCyan, ANSI.bgBlue);
+}
+function paneDisplayName(kind) {
+    switch (kind) {
+        case 'sessions':
+            return 'Sessions';
+        case 'messages':
+            return 'Messages';
+        case 'process':
+            return 'Execution';
+        case 'context':
+            return 'Context';
+    }
+}
+function paneDimensionsForKind(kind, columns, rows) {
+    const widths = computePaneWidths(columns);
+    const rightHeights = computeRightPaneHeights(Math.max(1, rows - 3));
+    switch (kind) {
+        case 'sessions':
+            return { width: widths.left, height: Math.max(1, rows - 3) };
+        case 'messages':
+            return { width: widths.center, height: Math.max(1, rows - 3) };
+        case 'process':
+            return { width: widths.right, height: rightHeights.process };
+        case 'context':
+            return { width: widths.right, height: rightHeights.context };
+    }
+}
+export function nextWrappedIndex(currentIndex, delta, length) {
+    if (length <= 0) {
+        return 0;
+    }
+    return (currentIndex + delta + length) % length;
+}
+export function selectMenuItemByTypeahead(items, query, currentIndex = -1) {
+    const normalized = query.trim().toLowerCase();
+    if (!normalized || items.length === 0) {
+        return Math.max(0, currentIndex);
+    }
+    const matches = items
+        .map((item, index) => ({ label: item.label.toLowerCase(), index }))
+        .filter((item) => item.label.startsWith(normalized))
+        .map((item) => item.index);
+    if (matches.length === 0) {
+        return Math.max(0, currentIndex);
+    }
+    const next = matches.find((index) => index > currentIndex);
+    return next ?? matches[0];
+}
+function wrapBodyLines(body, innerWidth) {
+    const lines = [];
+    for (const line of body) {
+        lines.push(...wrapPlainText(line, innerWidth));
+    }
+    return lines;
+}
+async function listWorkspaceTextFiles(workspaceRoot) {
+    const results = [];
+    const visit = async (relativeDir) => {
+        const absoluteDir = relativeDir ? path.join(workspaceRoot, relativeDir) : workspaceRoot;
+        let entries;
+        try {
+            entries = await fs.readdir(absoluteDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const relativePath = relativeDir ? path.join(relativeDir, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                if (IGNORED_WORKSPACE_DIRS.has(entry.name)) {
+                    continue;
+                }
+                await visit(relativePath);
+                continue;
+            }
+            if (entry.isFile() && isEditableTextFile(relativePath)) {
+                results.push(relativePath.replace(/\\/g, '/'));
+            }
+        }
+    };
+    await visit('');
+    results.sort((left, right) => left.localeCompare(right));
+    return results;
+}
+function isEditableTextFile(filePath) {
+    const basename = path.basename(filePath);
+    const extension = path.extname(filePath).toLowerCase();
+    return TEXT_FILE_EXTENSIONS.has(extension) || TEXT_FILE_BASENAMES.has(basename);
+}
+function splitEditorContent(content) {
+    const lines = content.split(/\r?\n/);
+    return lines.length > 0 ? lines : [''];
+}
+function resolveWorkspaceTextPath(workspaceRoot, requestedPath) {
+    const absolutePath = path.resolve(workspaceRoot, requestedPath);
+    const resolvedRoot = path.resolve(workspaceRoot);
+    if (absolutePath === resolvedRoot || absolutePath.startsWith(`${resolvedRoot}${path.sep}`)) {
+        return absolutePath;
+    }
+    return path.join(resolvedRoot, path.basename(requestedPath));
+}
+export function filterPickerItems(items, query) {
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) {
+        return [...items];
+    }
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+    return [...items].filter((item) => {
+        const haystack = `${item.label} ${item.description} ${item.detail ?? ''}`.toLowerCase();
+        return tokens.every((token) => haystack.includes(token));
+    });
+}
+function clamp(value, min, max) {
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+}
+function currentSpinnerFrame() {
+    return SPINNER_FRAMES[Math.floor(Date.now() / 120) % SPINNER_FRAMES.length];
+}
+function summarizeRunResult(result) {
+    if (result.answer?.trim()) {
+        return result.answer;
+    }
+    const lastOutput = [...result.output].reverse().find((line) => line.trim());
+    if (lastOutput) {
+        return lastOutput;
+    }
+    if (result.error?.trim()) {
+        return result.error;
+    }
+    return 'Execution completed without a final answer.';
+}
+function paint(text, ...codes) {
+    if (!output.isTTY || codes.length === 0) {
+        return text;
+    }
+    return `${codes.join('')}${text}${ANSI.reset}`;
+}
+//# sourceMappingURL=tui.js.map