deepclause-sdk 0.0.60 → 0.0.62

package/dist/cli/tui.js

@@ -1,16 +1,37 @@
+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, setModel } from './config.js';
 import { run } from './run.js';
-import { createConductorSession, getConductorSessionDetail, listConductorSessions, runConductorTurn, } from '../system/runtime/conductor.js';
+import { createLocalSkill, createConductorSession, getConductorSessionDetail, listConductorSessions, runConductorTurn, } from '../system/runtime/conductor.js';
+import { getSystemAssetSourcePaths } from '../system/assets/index.js';
+import { createShellManager } from '../system/runtime/shell-manager.js';
+import { buildToolCompletionEvent, buildToolFailureEvent, buildToolStartEvent, createShellToolEventBridge, } from '../system/runtime/shell-tool-events.js';
 const IGNORED_LIVE_LOG_TOOLS = new Set(['set_result', 'update_memory']);
-const BUILTIN_SLASH_COMMANDS = ['new', 'sessions', 'help', 'cancel', 'exit', 'quit'];
+const BUILTIN_SLASH_COMMANDS = ['new', 'sessions', 'help', 'compile', 'skill-creator', 'set-model', 'cancel', 'exit', 'quit'];
+const MODEL_SLOTS = ['gateway', 'run', 'compile'];
+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',
@@ -40,7 +61,7 @@ export class LiveExecutionPrinter {
     }
     handle(logEvent) {
         const { event } = logEvent;
-        if (event.type === 'usage' || event.type === 'finished' || event.type === 'input_required') {
+        if (event.type === 'usage' || event.type === 'finished') {
             return;
         }
         if (event.type === 'stream') {
@@ -50,10 +71,7 @@ export class LiveExecutionPrinter {
         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)})`);
+                this.handleToolCall(logEvent);
                 break;
             case 'output':
                 if (event.content) {
@@ -75,6 +93,11 @@ export class LiveExecutionPrinter {
                     this.writeLine(`${formatEventPrefix(logEvent)}log ${event.content}`);
                 }
                 break;
+            case 'input_required':
+                if (event.prompt) {
+                    this.writeLine(`${formatEventPrefix(logEvent)}clarify ${event.prompt}`);
+                }
+                break;
         }
     }
     finish() {
@@ -104,14 +127,22 @@ export class LiveExecutionPrinter {
         this.streamOpen = false;
         this.activeStreamKey = null;
     }
+    handleToolCall(logEvent) {
+        const line = formatToolEventLine(logEvent);
+        if (!line) {
+            return;
+        }
+        this.writeLine(line);
+    }
 }
-class ActivityBuffer {
+export class ActivityBuffer {
     lines = [];
+    activeTools = new Map();
     activeStreamKey = null;
     activeStreamLine = '';
     handle(logEvent) {
         const { event } = logEvent;
-        if (event.type === 'usage' || event.type === 'finished' || event.type === 'input_required') {
+        if (event.type === 'usage' || event.type === 'finished') {
             return;
         }
         if (event.type === 'stream') {
@@ -121,10 +152,7 @@ class ActivityBuffer {
         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)})`);
+                this.handleToolCall(logEvent);
                 break;
             case 'output':
                 if (event.content) {
@@ -146,6 +174,11 @@ class ActivityBuffer {
                     this.pushLine(`${formatEventPrefix(logEvent)}log ${event.content}`);
                 }
                 break;
+            case 'input_required':
+                if (event.prompt) {
+                    this.pushLine(`${formatEventPrefix(logEvent)}clarify ${event.prompt}`);
+                }
+                break;
         }
     }
     pushLine(line) {
@@ -158,11 +191,25 @@ class ActivityBuffer {
     }
     finish() {
         this.flushStream();
+        this.activeTools.clear();
+    }
+    clear() {
+        this.lines.length = 0;
+        this.activeTools.clear();
+        this.activeStreamKey = null;
+        this.activeStreamLine = '';
     }
     snapshot() {
-        return this.activeStreamLine
+        const body = this.activeStreamLine
             ? [...this.lines, this.activeStreamLine]
             : [...this.lines];
+        const activeLines = this.buildActiveToolLines();
+        if (activeLines.length === 0) {
+            return body;
+        }
+        return body.length > 0
+            ? [...activeLines, '', ...body]
+            : activeLines;
     }
     handleStream(logEvent) {
         const streamKey = logEvent.scope === 'child' ? `child:${logEvent.childSlug ?? '?'}` : 'main';
@@ -193,6 +240,43 @@ class ActivityBuffer {
             this.lines.splice(0, this.lines.length - MAX_ACTIVITY_LINES);
         }
     }
+    handleToolCall(logEvent) {
+        const { event } = logEvent;
+        if (!event.toolName || IGNORED_LIVE_LOG_TOOLS.has(event.toolName)) {
+            return;
+        }
+        if (event.toolState) {
+            const scopeKey = toolScopeKey(logEvent);
+            if (event.toolState === 'starting' || event.toolState === 'running') {
+                this.activeTools.set(scopeKey, {
+                    scopeKey,
+                    scopeLabel: toolScopeLabel(logEvent),
+                    toolName: event.toolName,
+                    toolState: event.toolState,
+                    toolPid: event.toolPid,
+                    toolBackend: event.toolBackend,
+                });
+            }
+            else {
+                this.activeTools.delete(scopeKey);
+            }
+        }
+        const line = formatToolEventLine(logEvent);
+        if (line) {
+            this.pushLine(line);
+        }
+    }
+    buildActiveToolLines() {
+        if (this.activeTools.size === 0) {
+            return [];
+        }
+        const lines = ['Active Tool Status'];
+        const entries = [...this.activeTools.values()].sort((left, right) => left.scopeKey.localeCompare(right.scopeKey));
+        for (const entry of entries) {
+            lines.push(formatActiveToolStatus(entry));
+        }
+        return lines;
+    }
 }
 class FullscreenTui {
     workspaceRoot;
@@ -204,6 +288,14 @@ class FullscreenTui {
     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,
@@ -217,7 +309,13 @@ class FullscreenTui {
     busy = false;
     exitRequested = false;
     statusLine = 'Loading...';
-    pendingQuestion = null;
+    pendingPrompt = null;
+    pickerState = null;
+    viewerState = null;
+    editorState = null;
+    recentFiles = [];
+    lastSubmittedInput = null;
+    shellWorkspacePath;
     renderTimer = null;
     animationTimer = null;
     closeResolver = null;
@@ -227,12 +325,13 @@ class FullscreenTui {
     constructor(workspaceRoot, options = {}) {
         this.workspaceRoot = workspaceRoot;
         this.options = options;
+        this.shellWorkspacePath = path.resolve(workspaceRoot, 'workspace');
     }
     async start() {
         try {
             await this.refreshCommands();
             await this.refreshSessions({ createIfMissing: true });
-            this.statusLine = 'Ready. Left/right changes pane. Up/down and PgUp/PgDn scroll the focused pane when input is empty.';
+            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);
@@ -266,15 +365,28 @@ class FullscreenTui {
         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.pendingQuestion) {
-                const pending = this.pendingQuestion;
-                this.pendingQuestion = null;
+            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;
@@ -284,6 +396,22 @@ class FullscreenTui {
             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();
@@ -354,8 +482,12 @@ class FullscreenTui {
                 await this.applyCompletion();
                 return;
             case 'escape':
-                this.inputValue = '';
-                this.cursor = 0;
+                {
+                    const previousInput = this.inputValue;
+                    this.inputValue = '';
+                    this.cursor = 0;
+                    this.refreshCommandBarStatus(previousInput);
+                }
                 break;
             default:
                 if (text && !key.ctrl && !key.meta) {
@@ -365,16 +497,271 @@ class FullscreenTui {
         }
         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.pendingQuestion) {
-            const pending = this.pendingQuestion;
-            this.pendingQuestion = null;
+        if (this.pendingPrompt) {
+            const pending = this.pendingPrompt;
+            this.pendingPrompt = null;
             pending.resolve(trimmedInput);
-            this.statusLine = 'Continuing...';
+            this.statusLine = pending.kind === 'clarify' ? 'Continuing...' : 'Working...';
             this.requestRender();
             return;
         }
@@ -382,8 +769,8 @@ class FullscreenTui {
             this.requestRender();
             return;
         }
-        const parsed = parseSlashInput(trimmedInput);
-        if (this.busy && !this.pendingQuestion && !canSubmitParsedInputWhileBusy(parsed)) {
+        const parsed = parseCommandBarInput(rawInput);
+        if (this.busy && !this.pendingPrompt && !canSubmitParsedInputWhileBusy(parsed)) {
             this.statusLine = 'Execution is still running. Use /cancel or Ctrl+C to stop it.';
             this.requestRender();
             return;
@@ -396,6 +783,10 @@ class FullscreenTui {
             await this.executeSkill(parsed.name, parsed.args);
             return;
         }
+        if (parsed.kind === 'shell') {
+            await this.executeShellCommand(parsed.command);
+            return;
+        }
         await this.executeTask(parsed.prompt);
     }
     async executeBuiltin(parsed) {
@@ -416,6 +807,13 @@ class FullscreenTui {
                 this.requestRender();
                 return;
             }
+            case 'compile':
+            case 'skill-creator':
+                await this.executeSkillCreator(parsed.name, parsed.rawArgs);
+                return;
+            case 'set-model':
+                await this.executeSetModel(parsed.rawArgs);
+                return;
             case 'sessions':
                 await this.refreshSessions({ createIfMissing: true, selectedSessionId: this.selectedSessionId });
                 await this.refreshCommands();
@@ -434,6 +832,7 @@ class FullscreenTui {
     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;
@@ -488,10 +887,11 @@ class FullscreenTui {
         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 });
+        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();
@@ -502,7 +902,7 @@ class FullscreenTui {
             const result = await runSkillCommand(this.workspaceRoot, skillName, args, {
                 sandbox: this.options.sandbox,
                 signal: this.currentAbortController.signal,
-                onUserInput: (question) => this.requestClarification(`[${skillName}] ${question}`),
+                onUserInput: (question) => this.requestClarification(question),
                 onEvent: (event) => {
                     activity.handle(event);
                     this.updatePreviewFromEvent(event);
@@ -537,32 +937,181 @@ class FullscreenTui {
             }
         }
     }
-    async requestClarification(promptText) {
-        this.currentProcessActivity().pushLine(`clarify ${condenseWhitespace(promptText)}`);
-        this.inputValue = '';
-        this.cursor = 0;
-        this.statusLine = 'Awaiting clarification...';
-        this.requestRender();
-        return new Promise((resolve) => {
-            this.pendingQuestion = { prompt: promptText, resolve };
+    async executeSkillCreator(commandName, specText) {
+        const trimmedSpec = specText.trim();
+        if (!trimmedSpec) {
+            this.statusLine = `Provide a skill specification after /${commandName}.`;
             this.requestRender();
-        });
-    }
-    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;
+        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.`;
         }
-        if (completion.matches.length === 0) {
-            this.statusLine = 'No matching commands or skills.';
+        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 executeShellCommand(commandText) {
+        const trimmedCommand = commandText.trim();
+        if (!trimmedCommand) {
+            this.statusLine = 'Enter a shell command after !.';
+            this.requestRender();
+            return;
+        }
+        const sessionId = this.selectedSessionId || 'global';
+        const activity = this.activityFor(sessionId);
+        this.lastSubmittedInput = { kind: 'shell', command: trimmedCommand };
+        this.focusedPane = 'messages';
+        this.paneScroll.messages = 0;
+        this.paneScroll.process = 0;
+        this.beginExecutionPreview(sessionId, 'shell', {
+            role: 'system',
+            kind: 'output',
+            tag: 'shell',
+            content: `!${trimmedCommand}`,
+        }, 'shell');
+        activity.pushLine(`shell !${trimmedCommand}`);
+        this.busy = true;
+        this.currentAbortController = new AbortController();
+        this.startAnimation();
+        this.statusLine = `Running !${trimmedCommand}...`;
+        this.requestRender();
+        try {
+            const result = await runShellCommand(this.workspaceRoot, trimmedCommand, {
+                sandbox: this.options.sandbox,
+                signal: this.currentAbortController.signal,
+                onEvent: (event) => {
+                    activity.handle(event);
+                    this.requestRender();
+                },
+            });
+            activity.finish();
+            await this.refreshCommands();
+            this.finishExecutionPreview(result.success
+                ? { persist: true, finalText: formatShellCommandSummary(result) }
+                : { persist: true, error: formatShellCommandSummary(result) });
+            this.statusLine = result.success ? 'Shell command finished.' : 'Shell command failed.';
+        }
+        catch (error) {
+            activity.finish();
+            const message = error.message;
+            this.finishExecutionPreview({ persist: true, error: message });
+            this.statusLine = isAbortError(error) ? 'Shell command cancelled.' : 'Shell command failed.';
+        }
+        finally {
+            this.busy = false;
+            this.currentAbortController = null;
+            this.stopAnimation();
+            if (this.exitRequested) {
+                this.close();
+            }
+            else {
+                this.requestRender();
+            }
+        }
+    }
+    async executeSetModel(rawArgs) {
+        try {
+            const { model, slot } = parseSetModelCommandArgs(rawArgs);
+            const result = await setModel(this.workspaceRoot, model, slot);
+            const slotsLabel = result.updatedSlots.join(', ');
+            this.currentProcessActivity().pushLine(`config model ${result.modelId} slots=${slotsLabel}`);
+            this.statusLine = `Model set to ${result.modelId} for ${slotsLabel}. Applies on the next turn.`;
+        }
+        catch (error) {
+            this.statusLine = error.message;
+        }
+        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]}`;
@@ -588,18 +1137,852 @@ class FullscreenTui {
         this.statusLine = `Focus: ${paneDisplayName(this.focusedPane)}. Left/right switches panes; PgUp/PgDn scrolls.`;
         this.requestRender();
     }
-    beginExecutionPreview(sessionId, kind, lead) {
+    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.shell', label: 'Run Shell Command…', description: 'Prefill the command bar for a direct workspace shell command.' },
+                    { id: 'run.repeat', label: 'Repeat Last Command', description: 'Re-run the last prompt, shell command, 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: 'Commands', description: 'Show slash commands, shell 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.shell':
+                this.closeMenuMode();
+                this.inputValue = '!';
+                this.cursor = this.inputValue.length;
+                this.statusLine = formatShellModeStatus(this.workspaceRoot, this.shellWorkspacePath, this.options.sandbox);
+                this.requestRender();
+                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('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.',
+                    'Type !<command> to run a direct shell command in the configured workspace shell.',
+                    '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, shell command, 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 === 'shell') {
+            await this.executeShellCommand(this.lastSubmittedInput.command);
+            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,
-            entries: [lead, { role: 'assistant', content: '', pending: true }],
+            rootTag,
+            activeChildTag: kind === 'skill' ? rootTag : undefined,
+            entries: kind === 'shell'
+                ? [lead]
+                : [lead, { role: 'assistant', content: '', pending: true }],
         };
     }
     updatePreviewFromEvent(logEvent) {
         if (!this.currentPreview) {
             return;
         }
-        if (this.currentPreview.kind === 'task' && logEvent.scope !== 'main') {
+        this.updatePreviewChildState(logEvent);
+        const previewMessage = previewMessageFromEvent(logEvent);
+        if (previewMessage) {
+            this.insertPreviewMessage(previewMessage);
+        }
+        if (!this.isPrimaryPreviewEvent(logEvent)) {
             return;
         }
         const message = this.ensurePreviewAssistantMessage();
@@ -625,15 +2008,64 @@ class FullscreenTui {
                 break;
         }
     }
+    isPrimaryPreviewEvent(logEvent) {
+        if (!this.currentPreview) {
+            return false;
+        }
+        if (this.currentPreview.kind === 'task') {
+            return logEvent.scope === 'main';
+        }
+        if (this.currentPreview.kind === 'shell') {
+            return false;
+        }
+        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 };
+        const created = { role: 'assistant', content: '', pending: true, tag: desiredTag };
         this.currentPreview.entries.push(created);
         return created;
     }
@@ -641,6 +2073,24 @@ class FullscreenTui {
         if (!this.currentPreview) {
             return;
         }
+        this.currentPreview.activeChildTag = undefined;
+        if (this.currentPreview.kind === 'shell') {
+            const detail = typeof options.error === 'string' && options.error.trim()
+                ? { role: 'system', kind: 'output', tag: 'shell', content: options.error, error: true }
+                : typeof options.finalText === 'string' && options.finalText.trim()
+                    ? { role: 'system', kind: 'output', tag: 'shell', content: options.finalText }
+                    : null;
+            if (detail) {
+                this.currentPreview.entries.push(detail);
+            }
+            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;
+            return;
+        }
         const assistant = this.ensurePreviewAssistantMessage();
         if (typeof options.finalText === 'string' && options.finalText.trim()) {
             assistant.content = options.finalText;
@@ -751,24 +2201,49 @@ class FullscreenTui {
         return this.activityFor(this.selectedSessionId || 'global');
     }
     insertText(text) {
+        const previousInput = this.inputValue;
         this.inputValue = `${this.inputValue.slice(0, this.cursor)}${text}${this.inputValue.slice(this.cursor)}`;
         this.cursor += text.length;
+        this.refreshCommandBarStatus(previousInput);
     }
     deleteBackward() {
         if (this.cursor === 0) {
             return;
         }
+        const previousInput = this.inputValue;
         this.inputValue = `${this.inputValue.slice(0, this.cursor - 1)}${this.inputValue.slice(this.cursor)}`;
         this.cursor -= 1;
+        this.refreshCommandBarStatus(previousInput);
     }
     deleteForward() {
         if (this.cursor >= this.inputValue.length) {
             return;
         }
+        const previousInput = this.inputValue;
         this.inputValue = `${this.inputValue.slice(0, this.cursor)}${this.inputValue.slice(this.cursor + 1)}`;
+        this.refreshCommandBarStatus(previousInput);
     }
     async refreshCommands() {
         this.commands = await listCommands(this.workspaceRoot);
+        await this.refreshShellContext();
+    }
+    async refreshShellContext() {
+        const config = await loadConfig(this.workspaceRoot);
+        this.shellWorkspacePath = path.resolve(this.workspaceRoot, config.workspace || './workspace');
+    }
+    refreshCommandBarStatus(previousInput = '') {
+        if (this.busy || this.pendingPrompt || this.uiMode !== 'command') {
+            return;
+        }
+        const wasShell = previousInput.trimStart().startsWith('!');
+        const isShell = this.inputValue.trimStart().startsWith('!');
+        if (isShell) {
+            this.statusLine = formatShellModeStatus(this.workspaceRoot, this.shellWorkspacePath, this.options.sandbox);
+            return;
+        }
+        if (wasShell) {
+            this.statusLine = 'Command bar ready.';
+        }
     }
     async refreshSessions(options = {}) {
         let sessions = await listConductorSessions(this.workspaceRoot);
@@ -824,21 +2299,34 @@ class FullscreenTui {
         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 header = renderMenuBar(this.buildHeaderLine(), columns);
-        const status = renderStatusBar(this.buildStatusLine(), columns, this.focusedPane);
-        const inputPrefix = this.pendingQuestion ? ' Clarify ? ' : ' Command > ';
-        const inputLine = renderCommandBar(inputPrefix, this.inputValue, columns);
+        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];
-        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}`);
+        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`);
     }
@@ -869,19 +2357,66 @@ class FullscreenTui {
             ? `${this.commands.length} skill${this.commands.length === 1 ? '' : 's'}`
             : 'no skills';
         const mode = this.busy ? '[Running]' : '[Idle]';
-        return ` DeepClause  Session  Skills  Run  Help   ${sessionLabel}   ${mode}   ${skillLabel}`;
+        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.pendingQuestion && this.focusedPane !== 'sessions') {
+        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.pendingQuestion) {
-            return `Clarify: ${condenseWhitespace(this.pendingQuestion.prompt)} | Focus ${focus}`;
+        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.'];
@@ -946,6 +2481,7 @@ class FullscreenTui {
             return ['No session selected.'];
         }
         const contextSize = summarizeContextSize(this.sessionDetail);
+        const systemAssetSources = getSystemAssetSourcePaths(this.workspaceRoot);
         const usageEntries = Object.entries(this.sessionDetail.usageByModel ?? {})
             .sort((left, right) => right[1].totalTokens - left[1].totalTokens || left[0].localeCompare(right[0]));
         const body = [
@@ -956,6 +2492,17 @@ class FullscreenTui {
             `Assistant Memory ${formatByteSize(contextSize.assistantMemoryBytes)} (~${formatInteger(contextSize.assistantMemoryTokens)} tok)`,
             `Total ${formatByteSize(contextSize.totalBytes)} (~${formatInteger(contextSize.totalTokens)} tok)`,
             '',
+            'System Asset Sources',
+            `Conductor DML ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.conductorDml)}`,
+            `Conductor Prompt ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.conductorPrompt)}`,
+            `Skill Creator DML ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.skillCreatorDml)}`,
+            `Skill Creator Prompt ${formatSystemAssetSourcePath(this.workspaceRoot, systemAssetSources.skillCreatorPrompt)}`,
+            'Changes apply on the next turn or /compile run. No TUI reload is required.',
+            '',
+            'Shell Execution',
+            `Backend ${this.options.sandbox ? 'sandbox' : 'host'}`,
+            `CWD ${this.shellWorkspacePath}`,
+            '',
             'Session Token Usage',
         ];
         if (usageEntries.length === 0) {
@@ -987,6 +2534,141 @@ class FullscreenTui {
         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;
@@ -1047,14 +2729,7 @@ class FullscreenTui {
     }
     formatMessageHeader(entry) {
         const spinner = entry.pending ? ` ${currentSpinnerFrame()}` : '';
-        switch (entry.role) {
-            case 'user':
-                return '[You]';
-            case 'assistant':
-                return entry.error ? '[Assistant Error]' : `[Assistant${spinner}]`;
-            case 'system':
-                return `[System${spinner}]`;
-        }
+        return formatDisplayMessageHeader(entry, spinner);
     }
     close() {
         if (!this.closeResolver) {
@@ -1065,7 +2740,7 @@ class FullscreenTui {
         resolve();
     }
     isEditingInput() {
-        return !this.pendingQuestion && this.inputValue.length > 0;
+        return this.uiMode !== 'editor' && this.inputValue.length > 0;
     }
 }
 export async function startTui(workspaceRoot = process.cwd(), options = {}) {
@@ -1087,7 +2762,7 @@ async function startLineTui(workspaceRoot = process.cwd(), options = {}) {
             if (!line) {
                 continue;
             }
-            const parsed = parseSlashInput(line);
+            const parsed = parseCommandBarInput(line);
             if (parsed.kind === 'builtin') {
                 switch (parsed.name) {
                     case 'cancel':
@@ -1112,7 +2787,73 @@ async function startLineTui(workspaceRoot = process.cwd(), options = {}) {
                             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;
+                    case 'set-model': {
+                        try {
+                            const { model, slot } = parseSetModelCommandArgs(parsed.rawArgs);
+                            const result = await setModel(workspaceRoot, model, slot);
+                            console.log(`Model set to ${result.modelId} (${result.updatedSlots.join(', ')}).`);
+                        }
+                        catch (error) {
+                            console.log(`${paint('error', ANSI.red)} ${error.message}`);
+                        }
+                        continue;
+                    }
+                }
+            }
+            if (parsed.kind === 'shell') {
+                console.log(divider('-'));
+                console.log(`${paint('shell', ANSI.dim)} !${parsed.command}`);
+                console.log(divider('-'));
+                const printer = new LiveExecutionPrinter();
+                try {
+                    const result = await runShellCommand(workspaceRoot, parsed.command, {
+                        sandbox: options.sandbox,
+                        onEvent: (event) => printer.handle(event),
+                    });
+                    printer.finish();
+                    console.log(formatShellCommandSummary(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('-'));
@@ -1209,9 +2950,122 @@ async function runSkillCommand(workspaceRoot, skillName, args, options = {}) {
         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,
+    });
+}
+async function runShellCommand(workspaceRoot, command, options = {}) {
+    const trimmedCommand = command.trim();
+    if (!trimmedCommand) {
+        throw new Error('command is required');
+    }
+    const toolName = 'shell';
+    const toolArgs = { command: trimmedCommand };
+    const emit = (event) => options.onEvent?.({ scope: 'main', event });
+    emit(buildToolStartEvent(toolName, toolArgs));
+    let shellManager = null;
+    try {
+        const config = await loadConfig(workspaceRoot);
+        const workspacePath = path.resolve(workspaceRoot, config.workspace || './workspace');
+        shellManager = createShellManager({
+            workspacePath,
+            sandbox: options.sandbox,
+        });
+        const observer = createShellToolEventBridge({
+            toolName,
+            toolArgs,
+            emit,
+        });
+        const result = await shellManager.exec(trimmedCommand, options.signal, observer);
+        emit(buildToolCompletionEvent(toolName, toolArgs, result));
+        return result;
+    }
+    catch (error) {
+        emit(buildToolFailureEvent(toolName, toolArgs, error));
+        throw error;
+    }
+    finally {
+        await shellManager?.dispose();
+    }
+}
+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}.`;
+}
+function formatShellCommandSummary(result) {
+    if (result.success) {
+        return result.summary || 'Shell command completed successfully.';
+    }
+    return result.summary || `Shell command failed with exit code ${result.exitCode}.`;
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+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 = '';
@@ -1257,7 +3111,14 @@ export function parseCommandArgs(rawArgs) {
     }
     return args;
 }
-export function parseSlashInput(line) {
+export function parseCommandBarInput(line) {
+    const trimmedStart = line.trimStart();
+    if (trimmedStart.startsWith('\\!')) {
+        return { kind: 'text', prompt: trimmedStart.slice(1).trim() };
+    }
+    if (trimmedStart.startsWith('!')) {
+        return { kind: 'shell', command: trimmedStart.slice(1).trim() };
+    }
     const trimmed = line.trim();
     if (!trimmed.startsWith('/')) {
         return { kind: 'text', prompt: trimmed };
@@ -1272,11 +3133,14 @@ export function parseSlashInput(line) {
     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: name === 'new' && rawArgs ? [rawArgs] : parseCommandArgs(rawArgs),
+            args: passthroughRawArgBuiltins.has(name) && rawArgs
+                ? [rawArgs]
+                : parseCommandArgs(rawArgs),
         };
     }
     return {
@@ -1286,6 +3150,9 @@ export function parseSlashInput(line) {
         args: parseCommandArgs(rawArgs),
     };
 }
+export function parseSlashInput(line) {
+    return parseCommandBarInput(line);
+}
 export function canSubmitParsedInputWhileBusy(parsed) {
     return parsed.kind === 'builtin' && (parsed.name === 'cancel' || parsed.name === 'exit' || parsed.name === 'quit');
 }
@@ -1368,21 +3235,117 @@ async function createSessionInteractive(rl, workspaceRoot) {
 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)} /new  /sessions  /help  /exit  /skill args`);
+    console.log(`${paint('commands', ANSI.dim)} /compile <spec>  /set-model <model>  /new  /sessions  /help  /exit  /skill args`);
     console.log(`${paint('session', ANSI.dim)}  ${paint(session.id, ANSI.cyan)}`);
     console.log(divider('='));
     console.log('');
 }
+export function parseSetModelCommandArgs(rawArgs) {
+    const args = parseCommandArgs(rawArgs);
+    let model;
+    let slot;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--slot') {
+            const candidate = args[index + 1];
+            if (!candidate) {
+                throw new Error('Provide a slot after --slot.');
+            }
+            if (!isModelSlot(candidate)) {
+                throw new Error('Slot must be one of: gateway, run, compile.');
+            }
+            if (slot) {
+                throw new Error('Provide --slot only once.');
+            }
+            slot = candidate;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--slot=')) {
+            const candidate = arg.slice('--slot='.length);
+            if (!isModelSlot(candidate)) {
+                throw new Error('Slot must be one of: gateway, run, compile.');
+            }
+            if (slot) {
+                throw new Error('Provide --slot only once.');
+            }
+            slot = candidate;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown option: ${arg}`);
+        }
+        if (model) {
+            throw new Error('Provide exactly one model for /set-model.');
+        }
+        model = arg;
+    }
+    if (!model) {
+        throw new Error('Provide a model after /set-model.');
+    }
+    return { model, slot };
+}
 function streamLabel(logEvent) {
     return logEvent.scope === 'child'
-        ? `[${logEvent.childSlug ?? '?'}] llm`
+        ? `${CHILD_EVENT_INDENT}[${logEvent.childSlug ?? '?'}] llm`
         : 'llm';
 }
 function formatEventPrefix(logEvent) {
     return logEvent.scope === 'child'
-        ? `[${logEvent.childSlug ?? '?'}] `
+        ? `${CHILD_EVENT_INDENT}[${logEvent.childSlug ?? '?'}] `
         : '';
 }
+function toolScopeKey(logEvent) {
+    return logEvent.scope === 'child'
+        ? `child:${logEvent.childSlug ?? '?'}`
+        : 'main';
+}
+function toolScopeLabel(logEvent) {
+    return logEvent.scope === 'child'
+        ? logEvent.childSlug ?? '?'
+        : 'main';
+}
+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 '';
@@ -1397,16 +3360,74 @@ function formatToolArgs(args) {
     }
     return parts.join(', ');
 }
+function formatSystemAssetSourcePath(workspaceRoot, filePath) {
+    const relativePath = path.relative(workspaceRoot, filePath);
+    if (relativePath && !relativePath.startsWith('..') && !path.isAbsolute(relativePath)) {
+        return relativePath || '.';
+    }
+    return filePath;
+}
+function formatToolEventLine(logEvent) {
+    const { event } = logEvent;
+    if (!event.toolName || IGNORED_LIVE_LOG_TOOLS.has(event.toolName)) {
+        return null;
+    }
+    const prefix = formatEventPrefix(logEvent);
+    const callLabel = `${event.toolName}(${formatToolArgs(event.toolArgs)})`;
+    if (!event.toolState) {
+        return `${prefix}tool ${callLabel}`;
+    }
+    return `${prefix}tool ${callLabel} ${event.toolState}${formatToolEventDetails(event)}`;
+}
+function formatToolEventDetails(event) {
+    const details = [];
+    if (typeof event.toolPid === 'number') {
+        details.push(`pid=${event.toolPid}`);
+    }
+    else if (event.toolBackend === 'sandbox') {
+        details.push('sandbox');
+    }
+    if (typeof event.toolExitCode === 'number') {
+        details.push(`exit=${event.toolExitCode}`);
+    }
+    const message = event.toolError
+        ?? (event.toolSummary && event.toolSummary !== 'Command completed successfully' ? event.toolSummary : undefined);
+    if (message) {
+        details.push(message);
+    }
+    return details.length > 0 ? ` ${details.join(' ')}` : '';
+}
+function formatActiveToolStatus(entry) {
+    const details = [];
+    if (typeof entry.toolPid === 'number') {
+        details.push(`pid=${entry.toolPid}`);
+    }
+    else if (entry.toolBackend === 'sandbox') {
+        details.push('sandbox');
+    }
+    const detailSuffix = details.length > 0 ? ` ${details.join(' ')}` : '';
+    return `${entry.scopeLabel} ${entry.toolName} ${entry.toolState}${detailSuffix}`;
+}
+function formatShellModeStatus(workspaceRoot, shellWorkspacePath, sandbox) {
+    const displayPath = path.relative(workspaceRoot, shellWorkspacePath) || '.';
+    return `Shell mode: ${sandbox ? 'AgentVM sandbox' : 'host shell'} in ${displayPath}. Enter runs, /cancel stops.`;
+}
 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',
+        '/set-model <model> [--slot <slot>] update the configured model selection',
         '/cancel         abort the current execution',
         '/help           show this help',
         '/quit           exit the TUI',
         '/<skill> [args] run a compiled skill directly',
+        '!<command>     run a shell command directly in the workspace shell',
         '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',
@@ -1414,6 +3435,19 @@ function buildHelpLines() {
         '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 isModelSlot(value) {
+    return MODEL_SLOTS.includes(value);
+}
 function computePaneWidths(columns) {
     const available = Math.max(36, columns - 2);
     let left = Math.max(18, Math.floor(available * 0.2));
@@ -1468,45 +3502,144 @@ function buildPane(title, body, width, height, kind, active = false) {
     }
     return lines.slice(0, height);
 }
-function wrapPlainText(text, width) {
+export function wrapPlainText(text, width) {
     if (width <= 0) {
         return [''];
     }
     const result = [];
     for (const rawLine of text.split(/\r?\n/)) {
-        const line = rawLine || '';
+        const line = expandTabs(rawLine || '', CHILD_EVENT_TAB_WIDTH);
         if (!line) {
             result.push('');
             continue;
         }
         let remaining = line;
-        while (remaining.length > width) {
-            const slice = remaining.slice(0, width);
+        while (measureDisplayWidth(remaining) > width) {
+            const { head: slice, tail } = splitByDisplayWidth(remaining, width, { forceOne: true });
             const breakIndex = slice.lastIndexOf(' ');
-            if (breakIndex > Math.floor(width * 0.4)) {
-                result.push(slice.slice(0, breakIndex));
+            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 = remaining.slice(width);
+                remaining = tail;
             }
         }
         result.push(remaining);
     }
     return result;
 }
-function padRight(text, width) {
-    return text.length >= width ? text : `${text}${' '.repeat(width - text.length)}`;
+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);
 }
-function ellipsize(text, width) {
-    if (text.length <= width) {
+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 text.slice(0, width);
+        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;
     }
-    return `${text.slice(0, width - 3)}...`;
+    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();
@@ -1572,21 +3705,24 @@ function longestCommonPrefix(values) {
     }
     return prefix;
 }
-function renderMenuBar(text, columns) {
-    return paint(padRight(ellipsize(text, columns), columns), ANSI.black, ANSI.bgWhite, ANSI.bold);
+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, focusedPane) {
-    const hotkeys = [
-        ['<- ->', 'Pane'],
-        [focusedPane === 'sessions' ? 'Up/Down' : 'PgUp/PgDn', focusedPane === 'sessions' ? 'Select' : 'Scroll'],
-        ['End', focusedPane === 'sessions' ? 'Bottom' : 'Follow'],
-        ['/cancel', 'Stop'],
-        ['^C', 'Quit'],
-    ];
+function renderStatusBar(status, columns, hotkeys) {
     let hotkeyWidth = 0;
     const selected = [];
     for (const hotkey of hotkeys) {
-        const width = hotkey[0].length + hotkey[1].length + 4;
+        const width = measureDisplayWidth(hotkey[0]) + measureDisplayWidth(hotkey[1]) + 4;
         if (hotkeyWidth + width > Math.max(0, columns - 12)) {
             break;
         }
@@ -1600,13 +3736,13 @@ function renderStatusBar(status, columns, focusedPane) {
 }
 function renderCommandBar(prefix, value, columns) {
     const prefixPart = paint(prefix, ANSI.black, ANSI.bgWhite, ANSI.bold);
-    const remainingWidth = Math.max(0, columns - prefix.length);
+    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 - safeLabel.length);
+    const fillWidth = Math.max(0, innerWidth - measureDisplayWidth(safeLabel));
     const leftFill = Math.floor(fillWidth / 2);
     const rightFill = fillWidth - leftFill;
     return [
@@ -1622,6 +3758,9 @@ 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}`;
     }
@@ -1701,6 +3840,27 @@ function paneDimensionsForKind(kind, columns, rows) {
             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) {
@@ -1708,6 +3868,63 @@ function wrapBodyLines(body, 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;