cvc-tui 0.1.0

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

@@ -0,0 +1,292 @@
+// 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.',
+];
+export const coreCommands = [
+    {
+        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'],
+                        ],
+                    },
+                ],
+            });
+        },
+    },
+    {
+        name: 'quit',
+        aliases: ['exit', 'q'],
+        category: 'core',
+        help: 'exit CVC',
+        run: (_arg, ctx) => ctx.emit({ kind: 'die', exitCode: 0 }),
+    },
+    {
+        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: '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: 'status',
+        category: 'core',
+        help: 'show live session info',
+        run: (_a, ctx) => {
+            if (!ctx.sid) {
+                ctx.emit({ kind: 'sys', text: 'no active session' });
+                return;
+            }
+            ctx.emit({ kind: 'rpc', method: 'session.status', params: { session_id: ctx.sid } });
+        },
+    },
+    {
+        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 } : {} }),
+    },
+    {
+        name: 'history',
+        category: 'core',
+        help: 'view current transcript',
+        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') });
+        },
+    },
+    {
+        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 } });
+        },
+    },
+    {
+        name: 'title',
+        category: 'core',
+        help: 'set or show session title',
+        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 },
+            });
+            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'}` });
+        },
+    },
+    {
+        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 } : {} }),
+    },
+    {
+        name: 'commit',
+        category: 'core',
+        help: 'create a CVC commit from the current transcript',
+        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}` });
+        },
+    },
+    {
+        name: 'fortune',
+        category: 'core',
+        help: 'a local CVC fortune',
+        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] });
+            }
+            ctx.emit({ kind: 'sys', text: FORTUNES[Math.floor(Math.random() * FORTUNES.length)] });
+        },
+    },
+    {
+        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` });
+        },
+    },
+    {
+        name: 'paste',
+        category: 'core',
+        help: 'attach clipboard text/image',
+        run: (_a, ctx) => ctx.emit({ kind: 'rpc', method: 'clipboard.read' }),
+    },
+    {
+        name: 'logs',
+        category: 'core',
+        help: 'tail gateway logs',
+        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 } });
+        },
+    },
+    {
+        name: 'details',
+        aliases: ['detail'],
+        category: 'core',
+        help: 'control agent detail visibility',
+        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;
+            }
+            if (!allowed.includes(m)) {
+                return ctx.emit({ kind: 'sys', text: 'usage: /details [hidden|collapsed|expanded|cycle]' });
+            }
+            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.emit({ kind: 'patchUi', ui: { detailsMode: next } });
+            ctx.emit({ kind: 'sys', text: `details: ${next}` });
+        },
+    },
+];

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

@@ -0,0 +1,11 @@
+export const debugCommands = [
+    {
+        name: 'heapdump',
+        category: 'debug',
+        help: 'capture a V8 heap snapshot',
+        run: (_a, ctx) => {
+            ctx.emit({ kind: 'rpc', method: 'debug.heapdump' });
+            ctx.emit({ kind: 'sys', text: 'heap snapshot requested' });
+        },
+    },
+];

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

@@ -0,0 +1,163 @@
+export const opsCommands = [
+    {
+        name: 'model',
+        category: 'ops',
+        help: 'switch model (arrow-key picker if blank)',
+        run: (arg, ctx) => {
+            const name = arg.trim();
+            if (!name)
+                return ctx.emit({ kind: 'overlay', overlay: 'modelPicker' });
+            ctx.emit({ kind: 'rpc', method: 'config.set', params: { key: 'model', value: name } });
+            ctx.emit({ kind: 'sys', text: `model: ${name}` });
+        },
+    },
+    {
+        name: 'provider',
+        category: 'ops',
+        help: 'switch provider',
+        run: (arg, ctx) => {
+            const name = arg.trim();
+            if (!name)
+                return ctx.emit({ kind: 'rpc', method: 'config.get', params: { key: 'provider' } });
+            ctx.emit({ kind: 'rpc', method: 'config.set', params: { key: 'provider', value: name } });
+            ctx.emit({ kind: 'sys', text: `provider: ${name}` });
+        },
+    },
+    {
+        name: 'skills',
+        category: 'ops',
+        help: 'browse the skills hub',
+        run: (_a, ctx) => ctx.emit({ kind: 'overlay', overlay: 'skillsHub' }),
+    },
+    {
+        name: 'reload-skills',
+        category: 'ops',
+        help: 'rescan skill directory',
+        run: (_a, ctx) => {
+            ctx.emit({ kind: 'rpc', method: 'skills.reload' });
+            ctx.emit({ kind: 'sys', text: 'skills reloaded' });
+        },
+    },
+    {
+        name: 'agents',
+        category: 'ops',
+        help: 'list registered agents',
+        run: (_a, ctx) => ctx.emit({ kind: 'overlay', overlay: 'agentsList' }),
+    },
+    {
+        name: 'memory',
+        aliases: ['mem'],
+        category: 'ops',
+        help: 'open the memory editor',
+        run: (arg, ctx) => {
+            const m = arg.trim().toLowerCase();
+            if (m === 'clear') {
+                ctx.emit({ kind: 'rpc', method: 'memory.clear' });
+                return ctx.emit({ kind: 'sys', text: 'memory cleared' });
+            }
+            if (m === 'show')
+                return ctx.emit({ kind: 'rpc', method: 'memory.show' });
+            ctx.emit({ kind: 'overlay', overlay: 'memoryEditor' });
+        },
+    },
+    {
+        name: 'tools',
+        category: 'ops',
+        help: 'list available tools',
+        run: (_a, ctx) => ctx.emit({ kind: 'rpc', method: 'tools.list' }),
+    },
+    {
+        name: 'reload',
+        category: 'ops',
+        help: 'reload CVC config',
+        run: (_a, ctx) => {
+            ctx.emit({ kind: 'rpc', method: 'config.reload' });
+            ctx.emit({ kind: 'sys', text: 'config reloaded' });
+        },
+    },
+    {
+        name: 'reload-mcp',
+        category: 'ops',
+        help: 'reload MCP servers',
+        run: (_a, ctx) => {
+            ctx.emit({ kind: 'rpc', method: 'mcp.reload' });
+            ctx.emit({ kind: 'sys', text: 'mcp servers reloading' });
+        },
+    },
+    {
+        name: 'personality',
+        category: 'ops',
+        help: 'switch personality',
+        run: (arg, ctx) => {
+            const name = arg.trim();
+            if (!name)
+                return ctx.emit({ kind: 'rpc', method: 'config.get', params: { key: 'personality' } });
+            ctx.emit({ kind: 'rpc', method: 'config.set', params: { key: 'personality', value: name } });
+            ctx.emit({ kind: 'sys', text: `personality: ${name}` });
+        },
+    },
+    {
+        name: 'skin',
+        category: 'ops',
+        help: 'switch CLI skin',
+        run: (arg, ctx) => {
+            const name = arg.trim();
+            if (!name)
+                return ctx.emit({ kind: 'rpc', method: 'config.get', params: { key: 'skin' } });
+            ctx.emit({ kind: 'rpc', method: 'config.set', params: { key: 'skin', value: name } });
+            ctx.emit({ kind: 'sys', text: `skin: ${name}` });
+        },
+    },
+    {
+        name: 'statusbar',
+        aliases: ['sb'],
+        category: 'ops',
+        help: 'status bar position (on|off|top|bottom)',
+        run: (arg, ctx) => {
+            const m = arg.trim().toLowerCase();
+            const cur = ctx.ui.statusBar ?? 'top';
+            const next = !m || m === 'toggle'
+                ? (cur === 'off' ? 'top' : 'off')
+                : m === 'on' || m === 'top'
+                    ? 'top'
+                    : (m === 'off' || m === 'bottom') ? m : null;
+            if (!next)
+                return ctx.emit({ kind: 'sys', text: 'usage: /statusbar [on|off|top|bottom|toggle]' });
+            ctx.emit({ kind: 'patchUi', ui: { statusBar: next } });
+            ctx.emit({ kind: 'rpc', method: 'config.set', params: { key: 'statusbar', value: next } });
+            ctx.emit({ kind: 'sys', text: `statusbar: ${next}` });
+        },
+    },
+    {
+        name: 'indicator',
+        category: 'ops',
+        help: 'busy-indicator style [dots|braille|kawaii|off]',
+        run: (arg, ctx) => {
+            const m = arg.trim().toLowerCase();
+            const allowed = ['dots', 'braille', 'kawaii', 'off'];
+            if (!m)
+                return ctx.emit({ kind: 'sys', text: `indicator: ${ctx.ui.indicator ?? 'kawaii'}` });
+            if (!allowed.includes(m))
+                return ctx.emit({ kind: 'sys', text: `usage: /indicator [${allowed.join('|')}]` });
+            ctx.emit({ kind: 'patchUi', ui: { indicator: m } });
+            ctx.emit({ kind: 'rpc', method: 'config.set', params: { key: 'indicator', value: m } });
+            ctx.emit({ kind: 'sys', text: `indicator: ${m}` });
+        },
+    },
+    {
+        name: 'mouse',
+        aliases: ['scroll'],
+        category: 'ops',
+        help: 'toggle mouse/wheel tracking',
+        run: (arg, ctx) => {
+            const cur = Boolean(ctx.ui.mouseTracking);
+            const m = arg.trim().toLowerCase();
+            const next = !m || m === 'toggle' ? !cur : m === 'on' ? true : m === 'off' ? false : null;
+            if (next === null)
+                return ctx.emit({ kind: 'sys', text: 'usage: /mouse [on|off|toggle]' });
+            ctx.emit({ kind: 'patchUi', ui: { mouseTracking: next } });
+            ctx.emit({ kind: 'rpc', method: 'config.set', params: { key: 'mouse', value: next ? 'on' : 'off' } });
+            ctx.emit({ kind: 'sys', text: `mouse tracking ${next ? 'on' : 'off'}` });
+        },
+    },
+];

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

@@ -0,0 +1,91 @@
+export const sessionCommands = [
+    {
+        name: 'sessions',
+        category: 'session',
+        help: 'browse prior sessions',
+        run: (_a, ctx) => ctx.emit({ kind: 'overlay', overlay: 'sessionPicker' }),
+    },
+    {
+        name: 'resume',
+        category: 'session',
+        help: 'resume a prior session by id',
+        run: (arg, ctx) => {
+            const id = arg.trim();
+            if (!id)
+                return ctx.emit({ kind: 'overlay', overlay: 'sessionPicker' });
+            ctx.emit({ kind: 'rpc', method: 'session.resume', params: { session_id: id } });
+            ctx.emit({ kind: 'sys', text: `resuming session ${id}…` });
+        },
+    },
+    {
+        name: 'checkpoint',
+        category: 'session',
+        help: 'create a CVC checkpoint commit',
+        run: (arg, ctx) => {
+            const msg = arg.trim() || 'tui checkpoint';
+            ctx.emit({ kind: 'rpc', method: 'cvc.commit', params: { message: msg, commit_type: 'checkpoint' } });
+            ctx.emit({ kind: 'sys', text: `checkpoint: ${msg}` });
+        },
+    },
+    {
+        name: 'rollback',
+        category: 'session',
+        help: 'rollback to a checkpoint',
+        run: (arg, ctx) => {
+            const h = arg.trim();
+            if (!h)
+                return ctx.emit({ kind: 'sys', text: 'usage: /rollback <commit-hash>' });
+            ctx.emit({ kind: 'rpc', method: 'cvc.restore', params: { commit_hash: h } });
+            ctx.emit({ kind: 'sys', text: `rolling back to ${h}…` });
+        },
+    },
+    {
+        name: 'undo',
+        category: 'session',
+        help: 'undo the last turn',
+        run: (_a, ctx) => ctx.emit({ kind: 'rpc', method: 'session.undo', params: ctx.sid ? { session_id: ctx.sid } : {} }),
+    },
+    {
+        name: 'retry',
+        category: 'session',
+        help: 'retry the last user message',
+        run: (_a, ctx) => ctx.emit({ kind: 'rpc', method: 'session.retry', params: ctx.sid ? { session_id: ctx.sid } : {} }),
+    },
+    {
+        name: 'branch',
+        category: 'session',
+        help: 'create a CVC cognitive branch',
+        run: (arg, ctx) => {
+            const name = arg.trim();
+            if (!name)
+                return ctx.emit({ kind: 'sys', text: 'usage: /branch <name>' });
+            ctx.emit({ kind: 'rpc', method: 'cvc.branch', params: { name } });
+            ctx.emit({ kind: 'sys', text: `branch created: ${name}` });
+        },
+    },
+    {
+        name: 'stop',
+        category: 'session',
+        help: 'interrupt the current turn',
+        run: (_a, ctx) => {
+            ctx.emit({ kind: 'rpc', method: 'session.stop', params: ctx.sid ? { session_id: ctx.sid } : {} });
+            ctx.emit({ kind: 'sys', text: 'interrupt requested' });
+        },
+    },
+    {
+        name: 'steer',
+        category: 'session',
+        help: 'steer the in-flight turn',
+        run: (arg, ctx) => {
+            const hint = arg.trim();
+            if (!hint)
+                return ctx.emit({ kind: 'sys', text: 'usage: /steer <hint>' });
+            ctx.emit({
+                kind: 'rpc',
+                method: 'session.steer',
+                params: { session_id: ctx.sid, hint },
+            });
+            ctx.emit({ kind: 'sys', text: 'steer queued' });
+        },
+    },
+];

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

@@ -0,0 +1,47 @@
+export const setupCommands = [
+    {
+        name: 'setup',
+        category: 'setup',
+        help: 'launch the CVC setup wizard',
+        run: (_a, ctx) => {
+            ctx.emit({ kind: 'rpc', method: 'cli.setup' });
+            ctx.emit({ kind: 'sys', text: 'launching setup wizard…' });
+        },
+    },
+    {
+        name: 'terminal-setup',
+        category: 'setup',
+        help: 'configure IDE terminal keybindings (auto|cursor|vscode|windsurf)',
+        run: (arg, ctx) => {
+            const target = arg.trim().toLowerCase() || 'auto';
+            const ok = ['auto', 'cursor', 'vscode', 'windsurf'];
+            if (!ok.includes(target)) {
+                return ctx.emit({ kind: 'sys', text: 'usage: /terminal-setup [auto|cursor|vscode|windsurf]' });
+            }
+            ctx.emit({ kind: 'rpc', method: 'cli.terminalSetup', params: { target } });
+            ctx.emit({ kind: 'sys', text: `terminal-setup (${target})…` });
+        },
+    },
+    {
+        name: 'replay',
+        category: 'setup',
+        help: 'replay a prior session by id',
+        run: (arg, ctx) => {
+            const id = arg.trim();
+            if (!id)
+                return ctx.emit({ kind: 'sys', text: 'usage: /replay <session-id>' });
+            ctx.emit({ kind: 'rpc', method: 'session.replay', params: { session_id: id } });
+        },
+    },
+    {
+        name: 'replay-diff',
+        category: 'setup',
+        help: 'diff two replays  /replay-diff <a> <b>',
+        run: (arg, ctx) => {
+            const [a, b] = arg.trim().split(/\s+/);
+            if (!a || !b)
+                return ctx.emit({ kind: 'sys', text: 'usage: /replay-diff <a> <b>' });
+            ctx.emit({ kind: 'rpc', method: 'session.replayDiff', params: { a, b } });
+        },
+    },
+];

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

@@ -0,0 +1,36 @@
+// Trivial toggle-style commands — boolean UI flags routed through patchUi
+// + a config.set RPC so the gateway can persist them.
+import { flagFromArg } from '../types.js';
+const TOGGLES = [
+    { name: 'verbose', help: 'toggle verbose logging', key: 'verbose' },
+    { name: 'reasoning', help: 'toggle reasoning trace display', key: 'reasoning' },
+    { name: 'fast', help: 'toggle fast mode (skip extras)', key: 'fast' },
+    { name: 'yolo', help: 'toggle YOLO mode (auto-approve)', key: 'yolo' },
+    { name: 'busy', help: 'toggle busy indicator', key: 'busy' },
+    { name: 'queue', help: 'toggle queued-input mode', key: 'queue' },
+    { name: 'background', help: 'toggle background-task display', key: 'background' },
+    { name: 'browser', help: 'toggle browser tool', key: 'browserEnabled', aliases: ['br'] },
+    { name: 'voice', help: 'toggle voice input/output', key: 'voice' },
+    { name: 'image', help: 'toggle inline image rendering', key: 'image' },
+];
+export const toggleCommands = TOGGLES.map(t => ({
+    name: t.name,
+    aliases: t.aliases,
+    category: 'toggles',
+    help: t.help,
+    run: (arg, ctx) => {
+        const cur = Boolean(ctx.ui[t.key]);
+        const next = flagFromArg(arg, cur);
+        if (next === null) {
+            ctx.emit({ kind: 'sys', text: `usage: /${t.name} [on|off|toggle]` });
+            return;
+        }
+        ctx.emit({ kind: 'patchUi', ui: { [t.key]: next } });
+        ctx.emit({
+            kind: 'rpc',
+            method: 'config.set',
+            params: { key: t.configKey ?? t.name, value: next ? 'on' : 'off' },
+        });
+        ctx.emit({ kind: 'sys', text: `${t.name} ${next ? 'on' : 'off'}` });
+    },
+}));