deepclause-sdk 0.0.61 → 0.0.63

package/dist/cli/tui.js

@@ -4,11 +4,16 @@ import { emitKeypressEvents } from 'readline';
 import { createInterface } from 'readline/promises';
 import { stdin as input, stdout as output } from 'process';
 import { listCommands } from './commands.js';
-import { getConfigPath, loadConfig, resolveModelSlot } from './config.js';
+import { getConfigPath, loadConfig, resolveModelSlot, setModel } from './config.js';
 import { run } from './run.js';
+import { formatToolArgs } from './tool-args.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', 'compile', 'skill-creator', '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;
@@ -67,10 +72,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) {
@@ -126,9 +128,17 @@ 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) {
@@ -143,10 +153,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) {
@@ -185,16 +192,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';
@@ -225,6 +241,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;
@@ -263,6 +316,7 @@ class FullscreenTui {
     editorState = null;
     recentFiles = [];
     lastSubmittedInput = null;
+    shellWorkspacePath;
     renderTimer = null;
     animationTimer = null;
     closeResolver = null;
@@ -272,6 +326,7 @@ class FullscreenTui {
     constructor(workspaceRoot, options = {}) {
         this.workspaceRoot = workspaceRoot;
         this.options = options;
+        this.shellWorkspacePath = path.resolve(workspaceRoot, 'workspace');
     }
     async start() {
         try {
@@ -428,8 +483,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) {
@@ -711,7 +770,7 @@ class FullscreenTui {
             this.requestRender();
             return;
         }
-        const parsed = parseSlashInput(trimmedInput);
+        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();
@@ -725,6 +784,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) {
@@ -749,6 +812,9 @@ class FullscreenTui {
             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();
@@ -931,6 +997,78 @@ class FullscreenTui {
             }
         }
     }
+    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');
@@ -1101,7 +1239,8 @@ class FullscreenTui {
                 label: 'Run',
                 items: [
                     { id: 'run.prompt', label: 'Send Prompt…', description: 'Return to the command bar and enter a freeform prompt.', shortcut: 'Enter' },
-                    { id: 'run.repeat', label: 'Repeat Last Command', description: 'Re-run the last prompt or skill invocation.', enabled: !!this.lastSubmittedInput },
+                    { id: 'run.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.' },
@@ -1124,7 +1263,7 @@ class FullscreenTui {
                 label: 'Help',
                 items: [
                     { id: 'help.shortcuts', label: 'Keyboard Shortcuts', description: 'Show the fullscreen keyboard map.' },
-                    { id: 'help.slash', label: 'Slash Commands', description: 'Show available slash commands and direct skill invocation.' },
+                    { id: 'help.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.' },
                 ],
             },
@@ -1204,6 +1343,13 @@ class FullscreenTui {
                 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;
@@ -1245,13 +1391,14 @@ class FullscreenTui {
                 this.openTextViewer('Keyboard Shortcuts', getShortcutHelpLines().join('\n'), { preferredExtension: '.txt' });
                 return;
             case 'help.slash':
-                this.openTextViewer('Slash Commands', getSlashHelpLines().join('\n'), { preferredExtension: '.txt' });
+                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;
@@ -1787,7 +1934,7 @@ class FullscreenTui {
     async repeatLastCommand() {
         if (!this.lastSubmittedInput) {
             this.closeMenuMode();
-            this.statusLine = 'No previous prompt or skill to repeat yet.';
+            this.statusLine = 'No previous prompt, shell command, or skill to repeat yet.';
             this.requestRender();
             return;
         }
@@ -1802,6 +1949,10 @@ class FullscreenTui {
             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);
         }
@@ -1818,7 +1969,9 @@ class FullscreenTui {
             kind,
             rootTag,
             activeChildTag: kind === 'skill' ? rootTag : undefined,
-            entries: [lead, { role: 'assistant', content: '', pending: true }],
+            entries: kind === 'shell'
+                ? [lead]
+                : [lead, { role: 'assistant', content: '', pending: true }],
         };
     }
     updatePreviewFromEvent(logEvent) {
@@ -1863,6 +2016,9 @@ class FullscreenTui {
         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) {
@@ -1919,6 +2075,23 @@ class FullscreenTui {
             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;
@@ -2029,24 +2202,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);
@@ -2284,6 +2482,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 = [
@@ -2294,6 +2493,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) {
@@ -2553,7 +2763,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':
@@ -2611,8 +2821,41 @@ async function startLineTui(workspaceRoot = process.cwd(), options = {}) {
                         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('-'));
                 console.log(`${paint('skill', ANSI.dim)} /${parsed.name}${parsed.args.length > 0 ? ` ${parsed.args.join(' ')}` : ''}`);
@@ -2734,6 +2977,40 @@ async function runSkillCreatorCommand(workspaceRoot, sessionId, spec, options =
         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 : '';
@@ -2743,6 +3020,15 @@ function formatSkillCreatorSummary(workspaceRoot, result) {
     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':
@@ -2826,7 +3112,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 };
@@ -2858,6 +3151,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');
 }
@@ -2940,11 +3236,56 @@ 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)} /compile <spec>  /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'
         ? `${CHILD_EVENT_INDENT}[${logEvent.childSlug ?? '?'}] llm`
@@ -2955,6 +3296,16 @@ function formatEventPrefix(logEvent) {
         ? `${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) {
@@ -2996,19 +3347,57 @@ export function formatDisplayMessageHeader(entry, spinner = '') {
             return formatSystemMessageHeader(entry, spinner);
     }
 }
-function formatToolArgs(args) {
-    if (!args) {
-        return '';
+function formatSystemAssetSourcePath(workspaceRoot, filePath) {
+    const relativePath = path.relative(workspaceRoot, filePath);
+    if (relativePath && !relativePath.startsWith('..') && !path.isAbsolute(relativePath)) {
+        return relativePath || '.';
     }
-    const parts = [];
-    for (const [key, value] of Object.entries(args)) {
-        let rendered = typeof value === 'string' ? value : JSON.stringify(value);
-        if (rendered.length > 80) {
-            rendered = rendered.slice(0, 77) + '...';
-        }
-        parts.push(`${key}=${rendered}`);
+    return 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, 80)})`;
+    if (!event.toolState) {
+        return `${prefix}tool ${callLabel}`;
     }
-    return parts.join(', ');
+    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 [
@@ -3017,10 +3406,12 @@ function buildHelpLines() {
         '/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',
@@ -3041,6 +3432,9 @@ function getShortcutHelpLines() {
     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));