cvc-tui 0.1.0 → 0.4.0

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

@@ -1,91 +1,431 @@
+// @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 { attachedImageNotice, introMsg, toTranscriptMessages } from '../../../domain/messages.js';
+import { TUI_SESSION_MODEL_FLAG } from '../../../domain/slash.js';
+import { formatVoiceRecordKey, parseVoiceRecordKey } from '../../../lib/platform.js';
+import { fmtK } from '../../../lib/text.js';
+import { DEFAULT_INDICATOR_STYLE, INDICATOR_STYLES } from '../../interfaces.js';
+import { patchOverlayState } from '../../overlayStore.js';
+import { patchUiState } from '../../uiStore.js';
+const TUI_SESSION_MODEL_RE = new RegExp(`(?:^|\\s)${TUI_SESSION_MODEL_FLAG}(?:\\s|$)`);
+const TUI_SESSION_STRIP_RE = new RegExp(`\\s*${TUI_SESSION_MODEL_FLAG}\\b\\s*`, 'g');
+const stripTuiSessionFlag = (trimmed) => trimmed.replace(TUI_SESSION_STRIP_RE, ' ').replace(/\s+/g, ' ').trim();
+const modelValueForConfigSet = (arg) => {
+    const trimmed = arg.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    if (TUI_SESSION_MODEL_RE.test(trimmed)) {
+        return stripTuiSessionFlag(trimmed);
+    }
+    return trimmed;
+};
 export const sessionCommands = [
     {
-        name: 'sessions',
-        category: 'session',
-        help: 'browse prior sessions',
-        run: (_a, ctx) => ctx.emit({ kind: 'overlay', overlay: 'sessionPicker' }),
+        aliases: ['bg', 'btw'],
+        help: 'launch a background prompt',
+        name: 'background',
+        run: (arg, ctx) => {
+            if (!arg) {
+                return ctx.transcript.sys('/background <prompt>');
+            }
+            ctx.gateway.rpc('prompt.background', { session_id: ctx.sid, text: arg }).then(ctx.guarded(r => {
+                if (!r.task_id) {
+                    return;
+                }
+                patchUiState(state => ({ ...state, bgTasks: new Set(state.bgTasks).add(r.task_id) }));
+                ctx.transcript.sys(`bg ${r.task_id} started`);
+            }));
+        }
     },
     {
-        name: 'resume',
-        category: 'session',
-        help: 'resume a prior session by id',
+        help: 'change or show model',
+        name: 'model',
         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}…` });
-        },
+            if (ctx.session.guardBusySessionSwitch('change models')) {
+                return;
+            }
+            if (!arg.trim()) {
+                return patchOverlayState({ modelPicker: true });
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'model', session_id: ctx.sid, value: modelValueForConfigSet(arg) })
+                .then(ctx.guarded(r => {
+                if (!r.value) {
+                    return ctx.transcript.sys('error: invalid response: model switch');
+                }
+                ctx.transcript.sys(`model → ${r.value}`);
+                ctx.local.maybeWarn(r);
+                patchUiState(state => ({
+                    ...state,
+                    info: state.info ? { ...state.info, model: r.value } : { model: r.value, skills: {}, tools: {} }
+                }));
+            }));
+        }
     },
     {
-        name: 'checkpoint',
-        category: 'session',
-        help: 'create a CVC checkpoint commit',
+        help: 'browse and resume previous sessions',
+        name: 'sessions',
         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}` });
-        },
+            if (ctx.session.guardBusySessionSwitch('switch sessions')) {
+                return;
+            }
+            if (!arg.trim()) {
+                return patchOverlayState({ picker: true });
+            }
+        }
     },
     {
-        name: 'rollback',
-        category: 'session',
-        help: 'rollback to a checkpoint',
+        help: 'attach an image',
+        name: 'image',
         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}…` });
-        },
+            ctx.gateway.rpc('image.attach', { path: arg, session_id: ctx.sid }).then(ctx.guarded(r => {
+                ctx.transcript.sys(attachedImageNotice(r));
+                if (r.remainder) {
+                    ctx.composer.setInput(r.remainder);
+                }
+            }));
+        }
     },
     {
-        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 } : {} }),
+        help: 'switch personality for this session',
+        name: 'personality',
+        run: (arg, ctx) => {
+            if (!arg) {
+                return;
+            }
+            ctx.gateway.rpc('config.set', { key: 'personality', session_id: ctx.sid, value: arg }).then(ctx.guarded(r => {
+                if (r.history_reset) {
+                    ctx.session.resetVisibleHistory(r.info ?? null);
+                }
+                ctx.transcript.sys(`personality: ${r.value || 'default'}${r.history_reset ? ' · transcript cleared' : ''}`);
+                ctx.local.maybeWarn(r);
+            }));
+        }
     },
     {
-        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 } : {} }),
+        help: 'compress transcript',
+        name: 'compress',
+        run: (arg, ctx) => {
+            ctx.gateway
+                .rpc('session.compress', {
+                session_id: ctx.sid,
+                ...(arg ? { focus_topic: arg } : {})
+            })
+                .then(ctx.guarded(r => {
+                if (Array.isArray(r.messages)) {
+                    const rows = toTranscriptMessages(r.messages);
+                    ctx.transcript.setHistoryItems(r.info ? [introMsg(r.info), ...rows] : rows);
+                }
+                if (r.info) {
+                    patchUiState({ info: r.info });
+                }
+                if (r.usage) {
+                    patchUiState(state => ({ ...state, usage: { ...state.usage, ...r.usage } }));
+                }
+                if (r.summary?.headline) {
+                    const prefix = r.summary.noop ? '' : '✓ ';
+                    ctx.transcript.sys(`${prefix}${r.summary.headline}`);
+                    if (r.summary.token_line) {
+                        ctx.transcript.sys(`  ${r.summary.token_line}`);
+                    }
+                    if (r.summary.note) {
+                        ctx.transcript.sys(`  ${r.summary.note}`);
+                    }
+                    return;
+                }
+                if ((r.removed ?? 0) <= 0) {
+                    return ctx.transcript.sys('nothing to compress');
+                }
+                ctx.transcript.sys(`compressed ${r.removed} messages${r.usage?.total ? ` · ${fmtK(r.usage.total)} tok` : ''}`);
+            }))
+                .catch(ctx.guardedErr);
+        }
     },
     {
+        aliases: ['fork'],
+        help: 'branch the session',
         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}` });
-        },
+            const prevSid = ctx.sid;
+            ctx.gateway.rpc('session.branch', { name: arg, session_id: ctx.sid }).then(ctx.guarded(r => {
+                if (!r.session_id) {
+                    return;
+                }
+                void ctx.session.closeSession(prevSid);
+                patchUiState({ sid: r.session_id });
+                ctx.session.setSessionStartedAt(Date.now());
+                ctx.transcript.setHistoryItems([]);
+                ctx.transcript.sys(`branched → ${r.title ?? ''}`);
+            }));
+        }
     },
     {
-        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' });
-        },
+        help: 'voice mode: [on|off|tts|status]',
+        name: 'voice',
+        run: (arg, ctx) => {
+            const normalized = (arg ?? '').trim().toLowerCase();
+            const action = normalized === 'on' || normalized === 'off' || normalized === 'tts' || normalized === 'status'
+                ? normalized
+                : 'status';
+            ctx.gateway.rpc('voice.toggle', { action }).then(ctx.guarded(r => {
+                ctx.voice.setVoiceEnabled(!!r.enabled);
+                // Render the configured record key (config.yaml ``voice.record_key``)
+                // instead of hardcoded "Ctrl+B" — the gateway response carries the
+                // current value so /voice status and /voice on stay in sync with
+                // both the CLI and the TUI's actual binding (#18994).
+                //
+                // Copilot review on #19835 caught that rendering from the fresh
+                // backend response WITHOUT updating the frontend ``voice.recordKey``
+                // state would skew display and binding between config-edit and
+                // the next ``mtime`` poll (~5s). Parse once, push into state so
+                // ``useInputHandlers()`` picks up the new binding immediately.
+                //
+                // Round-2 follow-up: only push state when the response actually
+                // carries ``record_key`` — otherwise an older gateway (or a future
+                // branch that forgets to include it) would clobber a custom user
+                // binding back to the default on every /voice invocation. The
+                // label still falls back to the documented default for display.
+                const parsed = r.record_key ? parseVoiceRecordKey(r.record_key) : undefined;
+                if (parsed) {
+                    ctx.voice.setVoiceRecordKey(parsed);
+                }
+                const recordKeyLabel = formatVoiceRecordKey(parsed ?? parseVoiceRecordKey('ctrl+b'));
+                // Match CLI's _show_voice_status / _enable_voice_mode /
+                // _toggle_voice_tts output shape so users don't have to learn
+                // two vocabularies.
+                if (action === 'status') {
+                    const mode = r.enabled ? 'ON' : 'OFF';
+                    const tts = r.tts ? 'ON' : 'OFF';
+                    ctx.transcript.sys('Voice Mode Status');
+                    ctx.transcript.sys(`  Mode:       ${mode}`);
+                    ctx.transcript.sys(`  TTS:        ${tts}`);
+                    ctx.transcript.sys(`  Record key: ${recordKeyLabel}`);
+                    // CLI's "Requirements:" block — surfaces STT/audio setup issues
+                    // so the user sees "STT provider: MISSING ..." instead of
+                    // silently failing on every record-key press.
+                    if (r.details) {
+                        ctx.transcript.sys('');
+                        ctx.transcript.sys('  Requirements:');
+                        for (const line of r.details.split('\n')) {
+                            if (line.trim()) {
+                                ctx.transcript.sys(`    ${line}`);
+                            }
+                        }
+                    }
+                    return;
+                }
+                if (action === 'tts') {
+                    ctx.transcript.sys(`Voice TTS ${r.tts ? 'enabled' : 'disabled'}.`);
+                    return;
+                }
+                // on/off — mirror cli.py:_enable_voice_mode's 3-line output
+                if (r.enabled) {
+                    const tts = r.tts ? ' (TTS enabled)' : '';
+                    ctx.transcript.sys(`Voice mode enabled${tts}`);
+                    ctx.transcript.sys(`  ${recordKeyLabel} to start/stop recording`);
+                    ctx.transcript.sys('  /voice tts  to toggle speech output');
+                    ctx.transcript.sys('  /voice off  to disable voice mode');
+                }
+                else {
+                    ctx.transcript.sys('Voice mode disabled.');
+                }
+            }));
+        }
     },
     {
-        name: 'steer',
-        category: 'session',
-        help: 'steer the in-flight turn',
+        help: 'switch theme skin (fires skin.changed)',
+        name: 'skin',
         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' });
-        },
+            if (!arg) {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'skin' })
+                    .then(ctx.guarded(r => ctx.transcript.sys(`skin: ${r.value || 'default'}`)));
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'skin', value: arg })
+                .then(ctx.guarded(r => r.value && ctx.transcript.sys(`skin → ${r.value}`)));
+        }
+    },
+    {
+        help: 'pick the busy indicator: kaomoji (default), emoji, unicode (braille), or ascii',
+        name: 'indicator',
+        usage: `/indicator [${INDICATOR_STYLES.join('|')}]`,
+        run: (arg, ctx) => {
+            const value = arg.trim().toLowerCase();
+            if (!value) {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'indicator' })
+                    .then(ctx.guarded(r => ctx.transcript.sys(`indicator: ${r.value || DEFAULT_INDICATOR_STYLE}`)));
+            }
+            if (!INDICATOR_STYLES.includes(value)) {
+                return ctx.transcript.sys(`usage: /indicator [${INDICATOR_STYLES.join('|')}]`);
+            }
+            ctx.gateway.rpc('config.set', { key: 'indicator', value }).then(ctx.guarded(r => {
+                if (!r.value) {
+                    return;
+                }
+                // Hot-swap the running TUI immediately so the next render
+                // uses the new style without waiting for the 5s mtime poll
+                // to re-apply config.full.
+                patchUiState({ indicatorStyle: value });
+                ctx.transcript.sys(`indicator → ${r.value}`);
+            }));
+        }
+    },
+    {
+        help: 'toggle yolo mode (per-session approvals)',
+        name: 'yolo',
+        run: (_arg, ctx) => {
+            ctx.gateway
+                .rpc('config.set', { key: 'yolo', session_id: ctx.sid })
+                .then(ctx.guarded(r => ctx.transcript.sys(`yolo ${r.value === '1' ? 'on' : 'off'}`)));
+        }
+    },
+    {
+        help: 'inspect or set reasoning effort (updates live agent)',
+        name: 'reasoning',
+        run: (arg, ctx) => {
+            if (!arg) {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'reasoning' })
+                    .then(ctx.guarded(r => r.value && ctx.transcript.sys(`reasoning: ${r.value} · display ${r.display || 'hide'}`)));
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'reasoning', session_id: ctx.sid, value: arg })
+                .then(ctx.guarded(r => {
+                if (!r.value) {
+                    return;
+                }
+                if (r.value === 'hide') {
+                    patchUiState(state => ({
+                        ...state,
+                        sections: { ...state.sections, thinking: 'hidden' },
+                        showReasoning: false
+                    }));
+                }
+                else if (r.value === 'show') {
+                    patchUiState(state => ({
+                        ...state,
+                        sections: { ...state.sections, thinking: 'expanded' },
+                        showReasoning: true
+                    }));
+                }
+                ctx.transcript.sys(`reasoning: ${r.value}`);
+            }));
+        }
     },
+    {
+        help: 'toggle fast mode [normal|fast|status|on|off|toggle]',
+        name: 'fast',
+        run: (arg, ctx) => {
+            const mode = arg.trim().toLowerCase();
+            const valid = new Set(['', 'status', 'normal', 'fast', 'on', 'off', 'toggle']);
+            if (!valid.has(mode)) {
+                return ctx.transcript.sys('usage: /fast [normal|fast|status|on|off|toggle]');
+            }
+            if (!mode || mode === 'status') {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'fast', session_id: ctx.sid })
+                    .then(ctx.guarded(r => ctx.transcript.sys(`fast mode: ${r.value === 'fast' ? 'fast' : 'normal'}`)))
+                    .catch(ctx.guardedErr);
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'fast', session_id: ctx.sid, value: mode })
+                .then(ctx.guarded(r => {
+                const next = r.value === 'fast' ? 'fast' : 'normal';
+                ctx.transcript.sys(`fast mode: ${next}`);
+                patchUiState(state => ({
+                    ...state,
+                    info: state.info
+                        ? {
+                            ...state.info,
+                            fast: next === 'fast',
+                            service_tier: next === 'fast' ? 'priority' : ''
+                        }
+                        : state.info
+                }));
+            }))
+                .catch(ctx.guardedErr);
+        }
+    },
+    {
+        help: 'control busy enter mode [queue|steer|interrupt|status]',
+        name: 'busy',
+        run: (arg, ctx) => {
+            const mode = arg.trim().toLowerCase();
+            const valid = new Set(['', 'status', 'queue', 'steer', 'interrupt']);
+            if (!valid.has(mode)) {
+                return ctx.transcript.sys('usage: /busy [queue|steer|interrupt|status]');
+            }
+            if (!mode || mode === 'status') {
+                return ctx.gateway
+                    .rpc('config.get', { key: 'busy' })
+                    .then(ctx.guarded(r => {
+                    const current = r.value || 'interrupt';
+                    ctx.transcript.sys(`busy input mode: ${current}`);
+                }))
+                    .catch(ctx.guardedErr);
+            }
+            ctx.gateway
+                .rpc('config.set', { key: 'busy', value: mode })
+                .then(ctx.guarded(r => {
+                const next = r.value || mode;
+                ctx.transcript.sys(`busy input mode: ${next}`);
+            }))
+                .catch(ctx.guardedErr);
+        }
+    },
+    {
+        help: 'cycle verbose tool-output mode (updates live agent)',
+        name: 'verbose',
+        run: (arg, ctx) => {
+            ctx.gateway
+                .rpc('config.set', { key: 'verbose', session_id: ctx.sid, value: arg || 'cycle' })
+                .then(ctx.guarded(r => r.value && ctx.transcript.sys(`verbose: ${r.value}`)));
+        }
+    },
+    {
+        help: 'session usage (live counts — worker sees zeros)',
+        name: 'usage',
+        run: (_arg, ctx) => {
+            ctx.gateway.rpc('session.usage', { session_id: ctx.sid }).then(r => {
+                if (ctx.stale()) {
+                    return;
+                }
+                if (r) {
+                    patchUiState({
+                        usage: { calls: r.calls ?? 0, input: r.input ?? 0, output: r.output ?? 0, total: r.total ?? 0 }
+                    });
+                }
+                if (!r?.calls) {
+                    return ctx.transcript.sys('no API calls yet');
+                }
+                const f = (v) => (v ?? 0).toLocaleString();
+                const cost = r.cost_usd != null ? `${r.cost_status === 'estimated' ? '~' : ''}$${r.cost_usd.toFixed(4)}` : null;
+                const rows = [
+                    ['Model', r.model ?? ''],
+                    ['Input tokens', f(r.input)],
+                    ['Cache read tokens', f(r.cache_read)],
+                    ['Cache write tokens', f(r.cache_write)],
+                    ['Output tokens', f(r.output)],
+                    ['Total tokens', f(r.total)],
+                    ['API calls', f(r.calls)]
+                ];
+                if (cost) {
+                    rows.push(['Cost', cost]);
+                }
+                const sections = [{ rows }];
+                if (r.context_max) {
+                    sections.push({ text: `Context: ${f(r.context_used)} / ${f(r.context_max)} (${r.context_percent}%)` });
+                }
+                if (r.compressions) {
+                    sections.push({ text: `Compressions: ${r.compressions}` });
+                }
+                ctx.transcript.panel('Usage', sections);
+            });
+        }
+    }
 ];

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

@@ -1,47 +1,20 @@
+// @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 { withInkSuspended } from '@cvc/ink';
+import { launchHermesCommand } from '../../../lib/externalCli.js';
+import { runExternalSetup } from '../../setupHandoff.js';
 export const setupCommands = [
     {
+        help: 'run full setup wizard (launches `hermes setup`)',
         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 } });
-        },
-    },
+        run: (arg, ctx) => void runExternalSetup({
+            args: ['setup', ...arg.split(/\s+/).filter(Boolean)],
+            ctx,
+            done: 'setup complete — starting session…',
+            launcher: launchHermesCommand,
+            suspend: withInkSuspended
+        })
+    }
 ];

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

@@ -1,3 +1,7 @@
+// @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.
 // 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';

package/dist/app/slash/registry.js

@@ -1,79 +1,18 @@
-// Central CVC slash command registry. Mirrors Hermes ui-tui surface so
-// users coming from Hermes feel at home, but every command is owned by CVC.
+// @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 { coreCommands } from './commands/core.js';
 import { debugCommands } from './commands/debug.js';
 import { opsCommands } from './commands/ops.js';
 import { sessionCommands } from './commands/session.js';
 import { setupCommands } from './commands/setup.js';
-import { toggleCommands } from './commands/toggles.js';
 export const SLASH_COMMANDS = [
     ...coreCommands,
     ...sessionCommands,
     ...opsCommands,
     ...setupCommands,
-    ...toggleCommands,
-    ...debugCommands,
+    ...debugCommands
 ];
-const byName = new Map(SLASH_COMMANDS.flatMap(cmd => [cmd.name, ...(cmd.aliases ?? [])].map(n => [n.toLowerCase(), cmd])));
-export function findSlashCommand(name) {
-    return byName.get(name.replace(/^\//, '').toLowerCase());
-}
-export function listSlashNames() {
-    return SLASH_COMMANDS.map(c => `/${c.name}`).sort();
-}
-/**
- * Returns "/"-prefixed canonical names + aliases. Used by completion.ts to
- * populate slash candidates. Keeps both names ("listSlashNames" and
- * "listCommandNames") exported so older slice modules don't drift.
- */
-export function listCommandNames() {
-    const all = new Set();
-    for (const c of SLASH_COMMANDS) {
-        all.add(`/${c.name}`);
-        for (const a of c.aliases ?? [])
-            all.add(`/${a}`);
-    }
-    return Array.from(all).sort();
-}
-/**
- * Parse a raw input line and dispatch it. Returns true if it WAS a slash
- * command (handled or not), false if the line should be treated as a normal
- * user message.
- *
- * Strip a single matched layer of surrounding quotes from `arg`. This is the
- * same affordance Hermes ui-tui applies to inputs like `/title 'foo bar'` or
- * `/title "foo bar"` — users coming from a shell expect quoting to "just
- * work" for arguments containing spaces.
- */
-export function unquoteArg(arg) {
-    const t = arg.trim();
-    if (t.length < 2)
-        return t;
-    const first = t.charCodeAt(0);
-    const last = t.charCodeAt(t.length - 1);
-    if (first === last && (first === 34 /* " */ || first === 39 /* ' */)) {
-        return t.slice(1, -1);
-    }
-    return t;
-}
-export async function dispatchSlash(line, ctx) {
-    if (!line.startsWith('/'))
-        return false;
-    const trimmed = line.trim();
-    const sp = trimmed.indexOf(' ');
-    const head = sp === -1 ? trimmed.slice(1) : trimmed.slice(1, sp);
-    const rawArg = sp === -1 ? '' : trimmed.slice(sp + 1);
-    const arg = unquoteArg(rawArg);
-    const cmd = findSlashCommand(head);
-    if (!cmd) {
-        ctx.emit({ kind: 'sys', text: `unknown command: /${head} — try /help` });
-        return true;
-    }
-    try {
-        await cmd.run(arg, ctx, trimmed);
-    }
-    catch (err) {
-        ctx.emit({ kind: 'sys', text: `command failed: ${String(err)}` });
-    }
-    return true;
-}
+const byName = new Map(SLASH_COMMANDS.flatMap(cmd => [cmd.name, ...(cmd.aliases ?? [])].map(name => [name, cmd])));
+export const findSlashCommand = (name) => byName.get(name.toLowerCase());