cvc-tui 0.1.0 → 0.4.0

package/dist/app/slash/commands/core.js

@@ -1,292 +1,479 @@
-// Core slash commands: /help /quit /clear /redraw /status /history /save
-// /title /compact /fortune /copy /paste /logs /redraw /details
-import { flagFromArg } from '../types.js';
-const FORTUNES = [
-    'Every commit is a love letter to future-you.',
-    'The mind is a Merkle DAG; tend it well.',
-    'No conversation is ever truly lost — only un-recalled.',
-    'Branch boldly, merge mindfully.',
-    'Context is the only currency that compounds.',
-    'A clean transcript is a clear conscience.',
-];
+// @ts-nocheck
+// SPDX-License-Identifier: MIT
+// Ported from CVC Agent (https://github.com/NousResearch/cvc)
+// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
+import { forceRedraw } from '@cvc/ink';
+import { NO_CONFIRM_DESTRUCTIVE } from '../../../config/env.js';
+import { dailyFortune, randomFortune } from '../../../content/fortunes.js';
+import { HOTKEYS } from '../../../content/hotkeys.js';
+import { SECTION_NAMES, isSectionName, nextDetailsMode, parseDetailsMode } from '../../../domain/details.js';
+import { writeClipboardText } from '../../../lib/clipboard.js';
+import { writeOsc52Clipboard } from '../../../lib/osc52.js';
+import { configureDetectedTerminalKeybindings, configureTerminalKeybindings } from '../../../lib/terminalSetup.js';
+import { patchOverlayState } from '../../overlayStore.js';
+import { patchUiState } from '../../uiStore.js';
+const flagFromArg = (arg, current) => {
+    if (!arg) {
+        return !current;
+    }
+    const mode = arg.trim().toLowerCase();
+    if (mode === 'on') {
+        return true;
+    }
+    if (mode === 'off') {
+        return false;
+    }
+    if (mode === 'toggle') {
+        return !current;
+    }
+    return null;
+};
+const RESET_WORDS = new Set(['reset', 'clear', 'default']);
+const CYCLE_WORDS = new Set(['cycle', 'toggle']);
+const DETAILS_USAGE = 'usage: /details [hidden|collapsed|expanded|cycle]  or  /details <section> [hidden|collapsed|expanded|reset]';
+const DETAILS_SECTION_USAGE = 'usage: /details <section> [hidden|collapsed|expanded|reset]';
 export const coreCommands = [
     {
+        help: 'list commands + hotkeys',
         name: 'help',
-        aliases: ['?'],
-        category: 'core',
-        help: 'list slash commands + hotkeys',
         run: (_arg, ctx) => {
-            // Open the full-screen helpOverlay; also emit the textual panel so
-            // non-TUI consumers (logs, scripts) still see a readable summary.
-            ctx.emit({ kind: 'overlay', overlay: 'help' });
-            ctx.emit({
-                kind: 'panel',
-                title: 'CVC — slash commands',
-                sections: [
-                    {
-                        title: 'Core',
-                        rows: [
-                            ['/help', 'this help panel'],
-                            ['/quit, /exit', 'leave CVC'],
-                            ['/clear, /new', 'start a new session'],
-                            ['/status', 'show live session info'],
-                            ['/usage', 'show token + cost usage'],
-                            ['/history', 'view current transcript'],
-                            ['/save', 'save transcript to JSON'],
-                            ['/title <text>', 'set session title'],
-                            ['/redraw', 'force a full UI repaint'],
-                            ['/fortune [random|daily]', 'a CVC fortune'],
-                        ],
-                    },
-                    {
-                        title: 'Sessions',
-                        rows: [
-                            ['/sessions', 'browse prior sessions'],
-                            ['/resume [id]', 'resume a prior session'],
-                            ['/new [title]', 'new session (alias of /clear)'],
-                            ['/checkpoint', 'create a CVC checkpoint'],
-                            ['/rollback [hash]', 'rollback to a checkpoint'],
-                            ['/undo', 'undo last assistant turn'],
-                            ['/retry', 'retry the last user message'],
-                            ['/branch [name]', 'create a CVC branch'],
-                        ],
-                    },
-                    {
-                        title: 'Models & Tools',
-                        rows: [
-                            ['/model [name]', 'switch model (arrow-key picker if blank)'],
-                            ['/provider [name]', 'switch provider'],
-                            ['/skills', 'browse skills hub'],
-                            ['/reload-skills', 'rescan skill directory'],
-                            ['/agents', 'list registered agents'],
-                            ['/memory [show|edit|clear]', 'memory store'],
-                            ['/mem', 'alias of /memory'],
-                            ['/tools', 'list tools'],
-                            ['/reload', 'reload config'],
-                            ['/reload-mcp', 'reload MCP servers'],
-                            ['/compact', 'toggle compact transcript'],
-                            ['/compress', 'compress conversation'],
-                        ],
-                    },
-                    {
-                        title: 'UI & Toggles',
-                        rows: [
-                            ['/personality [name]', 'switch personality'],
-                            ['/skin [name]', 'switch skin'],
-                            ['/statusbar [on|off|top|bottom]', 'status bar position'],
-                            ['/indicator [on|off]', 'busy indicator'],
-                            ['/details [hidden|collapsed|expanded|cycle]', 'agent detail visibility'],
-                            ['/mouse [on|off]', 'mouse/wheel tracking'],
-                            ['/verbose, /reasoning, /fast, /yolo', 'misc toggles'],
-                            ['/voice, /image, /browser', 'media toggles'],
-                            ['/copy [n], /paste', 'clipboard'],
-                        ],
-                    },
-                    {
-                        title: 'Ops & Debug',
-                        rows: [
-                            ['/stop', 'interrupt current turn'],
-                            ['/steer <hint>', 'steer the in-flight turn'],
-                            ['/logs [n]', 'tail gateway logs'],
-                            ['/heapdump', 'capture a heap snapshot'],
-                            ['/replay [id]', 'replay a session'],
-                            ['/replay-diff <a> <b>', 'diff two replays'],
-                            ['/setup', 'run setup wizard'],
-                            ['/terminal-setup [auto|cursor|vscode|windsurf]', 'IDE keybindings'],
-                        ],
-                    },
+            const sections = (ctx.local.catalog?.categories ?? []).map(cat => ({
+                rows: cat.pairs,
+                title: cat.name
+            }));
+            if (ctx.local.catalog?.skillCount) {
+                sections.push({ text: `${ctx.local.catalog.skillCount} skill commands available — /skills to browse` });
+            }
+            sections.push({
+                rows: [
+                    ['/details [hidden|collapsed|expanded|cycle]', 'set global agent detail visibility mode'],
+                    [
+                        '/details <section> [hidden|collapsed|expanded|reset]',
+                        'override one section (thinking/tools/subagents/activity)'
+                    ],
+                    ['/fortune [random|daily]', 'show a random or daily local fortune']
                 ],
-            });
-        },
+                title: 'TUI'
+            }, { rows: HOTKEYS, title: 'Hotkeys' });
+            ctx.transcript.panel(ctx.ui.theme.brand.helpHeader, sections);
+        }
     },
     {
-        name: 'quit',
         aliases: ['exit', 'q'],
-        category: 'core',
-        help: 'exit CVC',
-        run: (_arg, ctx) => ctx.emit({ kind: 'die', exitCode: 0 }),
+        help: 'exit hermes',
+        name: 'quit',
+        run: (_arg, ctx) => ctx.session.die()
+    },
+    {
+        aliases: ['scroll'],
+        help: 'toggle mouse/wheel tracking [on|off|toggle]',
+        name: 'mouse',
+        run: (arg, ctx) => {
+            const current = ctx.ui.mouseTracking;
+            const next = flagFromArg(arg, current);
+            if (next === null) {
+                return ctx.transcript.sys('usage: /mouse [on|off|toggle]');
+            }
+            patchUiState({ mouseTracking: next });
+            ctx.gateway.rpc('config.set', { key: 'mouse', value: next ? 'on' : 'off' }).catch(() => { });
+            queueMicrotask(() => ctx.transcript.sys(`mouse tracking ${next ? 'on' : 'off'}`));
+        }
     },
     {
-        name: 'clear',
         aliases: ['new'],
-        category: 'core',
         help: 'start a new session',
-        run: (arg, ctx, raw) => {
-            const isNew = raw.startsWith('/new');
-            const title = isNew ? arg.trim() : '';
-            ctx.emit({ kind: 'rpc', method: 'session.new', params: title ? { title } : {} });
-            ctx.emit({ kind: 'patchUi', ui: { status: 'forging session…' } });
-            ctx.emit({ kind: 'sys', text: isNew ? 'new session started' : 'session cleared' });
-        },
+        name: 'clear',
+        run: (arg, ctx, cmd) => {
+            if (ctx.session.guardBusySessionSwitch('switch sessions')) {
+                return;
+            }
+            const isNew = cmd.startsWith('/new');
+            const requestedTitle = isNew ? arg.trim() : '';
+            const commit = () => {
+                patchUiState({ status: 'forging session…' });
+                ctx.session.newSession(isNew ? 'new session started' : undefined, requestedTitle || undefined);
+            };
+            if (NO_CONFIRM_DESTRUCTIVE) {
+                return commit();
+            }
+            patchOverlayState({
+                confirm: {
+                    cancelLabel: 'No, keep going',
+                    confirmLabel: isNew ? 'Yes, start a new session' : 'Yes, clear the session',
+                    danger: true,
+                    detail: 'This ends the current conversation and clears the transcript.',
+                    onConfirm: commit,
+                    title: isNew ? 'Start a new session?' : 'Clear the current session?'
+                }
+            });
+        }
     },
     {
-        name: 'redraw',
-        category: 'core',
         help: 'force a full UI repaint',
-        run: (_a, ctx) => {
-            ctx.emit({ kind: 'patchUi', ui: { _redrawTick: Date.now() } });
-            ctx.emit({ kind: 'sys', text: 'ui redrawn' });
-        },
+        name: 'redraw',
+        run: (_arg, ctx) => {
+            forceRedraw(process.stdout);
+            ctx.transcript.sys('ui redrawn');
+        }
     },
     {
-        name: 'status',
-        category: 'core',
         help: 'show live session info',
-        run: (_a, ctx) => {
+        name: 'status',
+        run: (_arg, ctx) => {
             if (!ctx.sid) {
-                ctx.emit({ kind: 'sys', text: 'no active session' });
+                return ctx.transcript.sys('no active session');
+            }
+            ctx.gateway
+                .rpc('session.status', { session_id: ctx.sid })
+                .then(ctx.guarded(r => ctx.transcript.page(r.output || '(no status)', 'Status')))
+                .catch(ctx.guardedErr);
+        }
+    },
+    {
+        help: 'resume a prior session',
+        name: 'resume',
+        run: (arg, ctx) => {
+            if (ctx.session.guardBusySessionSwitch('switch sessions')) {
                 return;
             }
-            ctx.emit({ kind: 'rpc', method: 'session.status', params: { session_id: ctx.sid } });
-        },
+            arg ? ctx.session.resumeById(arg) : patchOverlayState({ picker: true });
+        }
     },
     {
-        name: 'usage',
-        category: 'core',
-        help: 'show token + cost usage',
-        run: (_a, ctx) => ctx.emit({ kind: 'rpc', method: 'session.usage', params: ctx.sid ? { session_id: ctx.sid } : {} }),
+        help: 'set or show current session title',
+        name: 'title',
+        run: (arg, ctx) => {
+            if (!ctx.sid) {
+                return ctx.transcript.sys('no active session');
+            }
+            const title = arg.trim();
+            if (!arg) {
+                ctx.gateway
+                    .rpc('session.title', { session_id: ctx.sid })
+                    .then(ctx.guarded(r => {
+                    const current = (r?.title ?? '').trim();
+                    ctx.transcript.sys(current ? `title: ${current}` : 'no title set');
+                }))
+                    .catch(ctx.guardedErr);
+                return;
+            }
+            if (!title) {
+                return ctx.transcript.sys('usage: /title <your session title>');
+            }
+            ctx.gateway
+                .rpc('session.title', { session_id: ctx.sid, title })
+                .then(ctx.guarded(r => {
+                const next = (r?.title ?? title).trim();
+                const suffix = r?.pending ? ' (queued while session initializes)' : '';
+                ctx.transcript.sys(`session title set: ${next}${suffix}`);
+            }))
+                .catch(ctx.guardedErr);
+        }
     },
     {
-        name: 'history',
-        category: 'core',
-        help: 'view current transcript',
+        help: 'toggle compact transcript',
+        name: 'compact',
         run: (arg, ctx) => {
-            const items = ctx.history().filter(m => m.role === 'user' || m.role === 'assistant');
-            if (!items.length)
-                return ctx.emit({ kind: 'sys', text: 'no conversation yet' });
-            const preview = Math.max(80, parseInt(arg, 10) || 400);
-            const lines = items.map((m, i) => {
-                const tag = m.role === 'user' ? `You #${i + 1}` : `CVC #${i + 1}`;
-                const body = (m.content || '').trim() || '(empty)';
-                const clip = body.length > preview ? `${body.slice(0, preview).trimEnd()}…` : body;
-                return `[${tag}]\n${clip}`;
-            });
-            ctx.emit({ kind: 'page', title: 'History', text: lines.join('\n\n') });
-        },
+            const next = flagFromArg(arg, ctx.ui.compact);
+            if (next === null) {
+                return ctx.transcript.sys('usage: /compact [on|off|toggle]');
+            }
+            patchUiState({ compact: next });
+            ctx.gateway.rpc('config.set', { key: 'compact', value: next ? 'on' : 'off' }).catch(() => { });
+            queueMicrotask(() => ctx.transcript.sys(`compact ${next ? 'on' : 'off'}`));
+        }
     },
     {
-        name: 'save',
-        category: 'core',
-        help: 'save transcript to JSON',
-        run: (_a, ctx) => {
-            if (!ctx.sid)
-                return ctx.emit({ kind: 'sys', text: 'no active session — nothing to save' });
-            ctx.emit({ kind: 'rpc', method: 'session.save', params: { session_id: ctx.sid } });
-        },
+        aliases: ['detail'],
+        help: 'control agent detail visibility (global or per-section)',
+        name: 'details',
+        run: (arg, ctx) => {
+            const { gateway, transcript, ui } = ctx;
+            if (!arg) {
+                gateway
+                    .rpc('config.get', { key: 'details_mode' })
+                    .then(r => {
+                    if (ctx.stale()) {
+                        return;
+                    }
+                    const mode = parseDetailsMode(r?.value) ?? ui.detailsMode;
+                    patchUiState({ detailsMode: mode, detailsModeCommandOverride: false });
+                    const overrides = SECTION_NAMES.filter(s => ui.sections[s])
+                        .map(s => `${s}=${ui.sections[s]}`)
+                        .join(' ');
+                    transcript.sys(`details: ${mode}${overrides ? `  (${overrides})` : ''}`);
+                })
+                    .catch(() => !ctx.stale() && transcript.sys(`details: ${ui.detailsMode}`));
+                return;
+            }
+            const [first, second] = arg.trim().toLowerCase().split(/\s+/);
+            if (second && isSectionName(first)) {
+                const reset = RESET_WORDS.has(second);
+                const mode = reset ? null : parseDetailsMode(second);
+                if (!reset && !mode) {
+                    return transcript.sys(DETAILS_SECTION_USAGE);
+                }
+                const { [first]: _drop, ...rest } = ui.sections;
+                patchUiState({ sections: mode ? { ...rest, [first]: mode } : rest });
+                gateway
+                    .rpc('config.set', { key: `details_mode.${first}`, value: mode ?? '' })
+                    .catch(() => { });
+                transcript.sys(`details ${first}: ${mode ?? 'reset'}`);
+                return;
+            }
+            const next = CYCLE_WORDS.has(first ?? '') ? nextDetailsMode(ui.detailsMode) : parseDetailsMode(first);
+            if (!next) {
+                return transcript.sys(DETAILS_USAGE);
+            }
+            const sections = Object.fromEntries(SECTION_NAMES.map(section => [section, next]));
+            patchUiState({ detailsMode: next, detailsModeCommandOverride: true, sections });
+            gateway.rpc('config.set', { key: 'details_mode', value: next }).catch(() => { });
+            transcript.sys(`details: ${next}`);
+        }
     },
     {
-        name: 'title',
-        category: 'core',
-        help: 'set or show session title',
+        help: 'local fortune',
+        name: 'fortune',
         run: (arg, ctx) => {
-            if (!ctx.sid)
-                return ctx.emit({ kind: 'sys', text: 'no active session' });
-            const t = arg.trim();
-            ctx.emit({
-                kind: 'rpc',
-                method: 'session.title',
-                params: t ? { session_id: ctx.sid, title: t } : { session_id: ctx.sid },
+            const key = arg.trim().toLowerCase();
+            if (!arg || key === 'random') {
+                return ctx.transcript.sys(randomFortune());
+            }
+            if (['daily', 'stable', 'today'].includes(key)) {
+                return ctx.transcript.sys(dailyFortune(ctx.sid));
+            }
+            ctx.transcript.sys('usage: /fortune [random|daily]');
+        }
+    },
+    {
+        help: 'copy selection or assistant message',
+        name: 'copy',
+        run: async (arg, ctx) => {
+            const { sys } = ctx.transcript;
+            if (!arg && ctx.composer.hasSelection) {
+                const text = await ctx.composer.selection.copySelection();
+                if (text) {
+                    return sys(`copied ${text.length} characters`);
+                }
+                else {
+                    return sys('clipboard copy failed — try CVC_TUI_FORCE_OSC52=1 to force the escape sequence; CVC_TUI_DEBUG_CLIPBOARD=1 for details');
+                }
+            }
+            if (arg && Number.isNaN(parseInt(arg, 10))) {
+                return sys('usage: /copy [number]');
+            }
+            const all = ctx.local.getHistoryItems().filter(m => m.role === 'assistant');
+            const target = all[arg ? Math.min(parseInt(arg, 10), all.length) - 1 : all.length - 1];
+            if (!target) {
+                return sys('nothing to copy — start a conversation first');
+            }
+            void writeClipboardText(target.text)
+                .then(nativeOk => {
+                if (ctx.stale()) {
+                    return;
+                }
+                if (nativeOk) {
+                    sys('copied to clipboard');
+                }
+                else {
+                    writeOsc52Clipboard(target.text);
+                    sys('sent OSC52 copy sequence (terminal support required)');
+                }
+            })
+                .catch(error => {
+                if (!ctx.stale()) {
+                    sys(`copy failed: ${String(error)}`);
+                }
             });
-            if (t)
-                ctx.emit({ kind: 'sys', text: `session title set: ${t}` });
-        },
+        }
     },
     {
-        name: 'compact',
-        category: 'core',
-        help: 'toggle compact transcript',
-        run: (arg, ctx) => {
-            const cur = Boolean(ctx.ui.compact);
-            const next = flagFromArg(arg, cur);
-            if (next === null)
-                return ctx.emit({ kind: 'sys', text: 'usage: /compact [on|off|toggle]' });
-            ctx.emit({ kind: 'patchUi', ui: { compact: next } });
-            ctx.emit({ kind: 'rpc', method: 'config.set', params: { key: 'compact', value: next ? 'on' : 'off' } });
-            ctx.emit({ kind: 'sys', text: `compact ${next ? 'on' : 'off'}` });
-        },
+        help: 'attach clipboard image',
+        name: 'paste',
+        run: (arg, ctx) => (arg ? ctx.transcript.sys('usage: /paste') : ctx.composer.paste())
     },
     {
-        name: 'compress',
-        category: 'core',
-        help: 'compress conversation history',
-        run: (_a, ctx) => ctx.emit({ kind: 'rpc', method: 'session.compress', params: ctx.sid ? { session_id: ctx.sid } : {} }),
+        help: 'configure IDE terminal keybindings for multiline + undo/redo',
+        name: 'terminal-setup',
+        run: (arg, ctx) => {
+            const target = arg.trim().toLowerCase();
+            if (target && !['auto', 'cursor', 'vscode', 'windsurf'].includes(target)) {
+                return ctx.transcript.sys('usage: /terminal-setup [auto|vscode|cursor|windsurf]');
+            }
+            const runner = !target || target === 'auto'
+                ? configureDetectedTerminalKeybindings()
+                : configureTerminalKeybindings(target);
+            void runner
+                .then(result => {
+                if (ctx.stale()) {
+                    return;
+                }
+                ctx.transcript.sys(result.message);
+                if (result.success && result.requiresRestart) {
+                    ctx.transcript.sys('restart the IDE terminal for the new keybindings to take effect');
+                }
+            })
+                .catch(error => {
+                if (!ctx.stale()) {
+                    ctx.transcript.sys(`terminal setup failed: ${String(error)}`);
+                }
+            });
+        }
     },
     {
-        name: 'commit',
-        category: 'core',
-        help: 'create a CVC commit from the current transcript',
+        help: 'view gateway logs',
+        name: 'logs',
         run: (arg, ctx) => {
-            const msg = arg.trim() || 'tui commit';
-            ctx.emit({ kind: 'rpc', method: 'cvc.commit', params: { message: msg, commit_type: 'checkpoint' } });
-            ctx.emit({ kind: 'sys', text: `commit: ${msg}` });
-        },
+            const text = ctx.gateway.gw.getLogTail(Math.min(80, Math.max(1, parseInt(arg, 10) || 20)));
+            text ? ctx.transcript.page(text, 'Logs') : ctx.transcript.sys('no gateway logs');
+        }
     },
     {
-        name: 'fortune',
-        category: 'core',
-        help: 'a local CVC fortune',
+        help: 'view current transcript (user + assistant messages)',
+        name: 'history',
         run: (arg, ctx) => {
-            const k = arg.trim().toLowerCase();
-            if (['daily', 'today', 'stable'].includes(k)) {
-                const seed = (ctx.sid ?? new Date().toISOString().slice(0, 10))
-                    .split('').reduce((a, c) => (a * 31 + c.charCodeAt(0)) >>> 0, 0);
-                return ctx.emit({ kind: 'sys', text: FORTUNES[seed % FORTUNES.length] });
+            // The CLI-side `/history` runs in a detached slash-worker subprocess
+            // that never sees the TUI's turns — it only surfaces whatever was
+            // persisted before this process started.  Render the TUI's own
+            // transcript so `/history` actually reflects what the user just did.
+            const items = ctx.local.getHistoryItems().filter(m => m.role === 'user' || m.role === 'assistant');
+            if (!items.length) {
+                return ctx.transcript.sys('no conversation yet');
             }
-            ctx.emit({ kind: 'sys', text: FORTUNES[Math.floor(Math.random() * FORTUNES.length)] });
-        },
+            const preview = Math.max(80, parseInt(arg, 10) || 400);
+            const lines = items.map((m, i) => {
+                const tag = m.role === 'user' ? `You #${i + 1}` : `Hermes #${i + 1}`;
+                const body = m.text.trim() || (m.tools?.length ? `(${m.tools.length} tool calls)` : '(empty)');
+                const clipped = body.length > preview ? `${body.slice(0, preview).trimEnd()}…` : body;
+                return `[${tag}]\n${clipped}`;
+            });
+            ctx.transcript.page(lines.join('\n\n'), 'History');
+        }
     },
     {
-        name: 'copy',
-        category: 'core',
-        help: 'copy last assistant message',
-        run: (arg, ctx) => {
-            const all = ctx.history().filter(m => m.role === 'assistant');
-            if (!all.length)
-                return ctx.emit({ kind: 'sys', text: 'nothing to copy' });
-            const idx = arg ? Math.min(Math.max(1, parseInt(arg, 10) || all.length), all.length) - 1 : all.length - 1;
-            const target = all[idx];
-            ctx.emit({ kind: 'rpc', method: 'clipboard.write', params: { text: target.content } });
-            ctx.emit({ kind: 'sys', text: `copied ${target.content.length} characters` });
-        },
+        help: 'save the current transcript to JSON',
+        name: 'save',
+        run: (_arg, ctx) => {
+            const hasConversation = ctx.local
+                .getHistoryItems()
+                .some(m => m.role === 'user' || m.role === 'assistant' || m.role === 'tool');
+            if (!hasConversation) {
+                return ctx.transcript.sys('no conversation yet');
+            }
+            if (!ctx.sid) {
+                return ctx.transcript.sys('no active session — nothing to save');
+            }
+            ctx.gateway
+                .rpc('session.save', { session_id: ctx.sid })
+                .then(ctx.guarded(r => {
+                const file = r?.file;
+                if (file) {
+                    ctx.transcript.sys(`conversation saved to: ${file}`);
+                }
+                else {
+                    ctx.transcript.sys('failed to save');
+                }
+            }))
+                .catch(ctx.guardedErr);
+        }
     },
     {
-        name: 'paste',
-        category: 'core',
-        help: 'attach clipboard text/image',
-        run: (_a, ctx) => ctx.emit({ kind: 'rpc', method: 'clipboard.read' }),
+        aliases: ['sb'],
+        help: 'status bar position (on|off|top|bottom)',
+        name: 'statusbar',
+        run: (arg, ctx) => {
+            const mode = arg.trim().toLowerCase();
+            const toggle = ctx.ui.statusBar === 'off' ? 'top' : 'off';
+            const next = !mode || mode === 'toggle'
+                ? toggle
+                : mode === 'on' || mode === 'top'
+                    ? 'top'
+                    : mode === 'off' || mode === 'bottom'
+                        ? mode
+                        : null;
+            if (!next) {
+                return ctx.transcript.sys('usage: /statusbar [on|off|top|bottom|toggle]');
+            }
+            patchUiState({ statusBar: next });
+            ctx.gateway.rpc('config.set', { key: 'statusbar', value: next }).catch(() => { });
+            queueMicrotask(() => ctx.transcript.sys(`status bar ${next}`));
+        }
     },
     {
-        name: 'logs',
-        category: 'core',
-        help: 'tail gateway logs',
+        help: 'inspect or enqueue a message',
+        name: 'queue',
         run: (arg, ctx) => {
-            const n = Math.min(200, Math.max(1, parseInt(arg, 10) || 40));
-            ctx.emit({ kind: 'rpc', method: 'gateway.logs', params: { tail: n } });
-        },
+            if (!arg) {
+                return ctx.transcript.sys(`${ctx.composer.queueRef.current.length} queued message(s)`);
+            }
+            ctx.composer.enqueue(arg);
+            ctx.transcript.sys(`queued: "${arg.slice(0, 50)}${arg.length > 50 ? '…' : ''}"`);
+        }
     },
     {
-        name: 'details',
-        aliases: ['detail'],
-        category: 'core',
-        help: 'control agent detail visibility',
+        help: 'inject a message after the next tool call (no interrupt)',
+        name: 'steer',
         run: (arg, ctx) => {
-            const allowed = ['hidden', 'collapsed', 'expanded', 'cycle'];
-            const m = arg.trim().toLowerCase();
-            if (!m) {
-                ctx.emit({ kind: 'sys', text: `details: ${ctx.ui.detailsMode ?? 'collapsed'}` });
-                return;
+            const payload = arg?.trim() ?? '';
+            if (!payload) {
+                return ctx.transcript.sys('usage: /steer <prompt>');
             }
-            if (!allowed.includes(m)) {
-                return ctx.emit({ kind: 'sys', text: 'usage: /details [hidden|collapsed|expanded|cycle]' });
+            // If the agent isn't running, fall back to the queue so the user's
+            // message isn't lost — identical semantics to the gateway handler.
+            if (!ctx.ui.busy || !ctx.sid) {
+                ctx.composer.enqueue(payload);
+                ctx.transcript.sys(`no active turn — queued for next: "${payload.slice(0, 50)}${payload.length > 50 ? '…' : ''}"`);
+                return;
             }
-            let next = m;
-            if (m === 'cycle') {
-                const order = ['hidden', 'collapsed', 'expanded'];
-                const cur = ctx.ui.detailsMode ?? 'collapsed';
-                next = order[(order.indexOf(cur) + 1) % order.length];
+            ctx.gateway
+                .rpc('session.steer', { session_id: ctx.sid, text: payload })
+                .then(ctx.guarded(r => {
+                if (r?.status === 'queued') {
+                    ctx.transcript.sys(`steer queued — arrives after next tool call: "${payload.slice(0, 50)}${payload.length > 50 ? '…' : ''}"`);
+                }
+                else {
+                    ctx.transcript.sys('steer rejected');
+                }
+            }))
+                .catch(ctx.guardedErr);
+        }
+    },
+    {
+        help: 'undo last exchange',
+        name: 'undo',
+        run: (_arg, ctx) => {
+            if (!ctx.sid) {
+                return ctx.transcript.sys('nothing to undo');
             }
-            ctx.emit({ kind: 'patchUi', ui: { detailsMode: next } });
-            ctx.emit({ kind: 'sys', text: `details: ${next}` });
-        },
+            ctx.gateway.rpc('session.undo', { session_id: ctx.sid }).then(ctx.guarded(r => {
+                if ((r.removed ?? 0) > 0) {
+                    ctx.transcript.setHistoryItems((prev) => ctx.transcript.trimLastExchange(prev));
+                    ctx.transcript.sys(`undid ${r.removed} messages`);
+                }
+                else {
+                    ctx.transcript.sys('nothing to undo');
+                }
+            }));
+        }
     },
+    {
+        help: 'retry last user message',
+        name: 'retry',
+        run: (_arg, ctx) => {
+            const last = ctx.local.getLastUserMsg();
+            if (!last) {
+                return ctx.transcript.sys('nothing to retry');
+            }
+            if (!ctx.sid) {
+                return ctx.transcript.send(last);
+            }
+            ctx.gateway.rpc('session.undo', { session_id: ctx.sid }).then(ctx.guarded(r => {
+                if ((r.removed ?? 0) <= 0) {
+                    return ctx.transcript.sys('nothing to retry');
+                }
+                ctx.transcript.setHistoryItems((prev) => ctx.transcript.trimLastExchange(prev));
+                ctx.transcript.send(last);
+            }));
+        }
+    }
 ];