caudate-cli 0.1.0__py3-none-any.whl

core/slash_commands.py

@@ -0,0 +1,977 @@
+"""Slash commands — in-conversation UX layer.
+
+Mirrors Claude Code's `/cmd` ergonomics so operations a user reaches for
+mid-chat (clear history, switch model, see cost, export, list tools) are
+one keystroke away instead of an exit-and-relaunch.
+
+Each handler takes `(ctx, args)` where `ctx` is a small object exposing
+the running CognosAgent + console + helpers, and `args` is the raw
+argument string after the command name. Handlers return a string the
+REPL prints, or None to suppress output. Returning the sentinel
+`SlashResult.QUIT` ends the session.
+"""
+
+from __future__ import annotations
+
+import logging
+import shlex
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable
+
+from rich.console import Console
+from rich.table import Table
+
+logger = logging.getLogger(__name__)
+
+
+class SlashResult(str, Enum):
+    QUIT = "__quit__"
+    RESET = "__reset__"
+
+
+@dataclass
+class SlashContext:
+    agent: Any                 # CognosAgent
+    console: Console
+    settings: Any | None = None     # Settings
+
+
+HandlerFn = Callable[[SlashContext, str], Any]
+
+
+# ---- handlers -------------------------------------------------------
+
+def _help(ctx: SlashContext, args: str) -> str:
+    rows = [
+        ("/help", "Show this help"),
+        ("/quit, /exit, /q", "End the session"),
+        ("/clear, /reset", "Reset conversation history"),
+        ("/compact", "Force a context compaction"),
+        ("/model [id|fast|balanced|powerful]", "Switch the active model"),
+        ("/system1 <id|preset>", "Set/swap fast brain (System 1)"),
+        ("/system2 <id|preset>", "Set/swap slow brain (System 2)"),
+        ("/voice [loop]", "Switch to voice (mic + TTS) until you say 'stop'"),
+        ("/serve [start|stop|status]", "Start the HTTP server + Web UI in-process"),
+        ("/cost", "Show token + $ usage so far"),
+        ("/tools", "List registered tools"),
+        ("/sessions", "List saved sessions"),
+        ("/export <md|json|html> [path]", "Export current session"),
+        ("/files [list|delete <id>]", "Manage uploaded files"),
+        ("/permissions [mode]", "Show or change permission mode"),
+        ("/personality", "Show personality state"),
+        ("/router", "Show routing snapshot"),
+        ("/diff <path>", "Diff a file vs. its on-disk state"),
+        ("/status", "Print one-line status"),
+        ("/cron list", "List scheduled jobs"),
+        ("/bg list|watch <id>|kill <id>", "Background tasks"),
+        ("/notify <msg>", "Send a desktop notification"),
+        ("/think on|off", "Toggle chain-of-thought"),
+        ("/caudate [status|train|reload|on|off]", "Inspect/control the neural advisor"),
+        ("/save", "Force-save the session"),
+    ]
+    table = Table(title="Slash commands", show_header=False, box=None)
+    for cmd, desc in rows:
+        table.add_row(f"[bold cyan]{cmd}[/bold cyan]", desc)
+    ctx.console.print(table)
+    return ""
+
+
+def _quit(ctx: SlashContext, args: str) -> Any:
+    return SlashResult.QUIT
+
+
+def _clear(ctx: SlashContext, args: str) -> Any:
+    ctx.agent.reset_conversation()
+    ctx.console.print("[yellow]Conversation reset.[/yellow]")
+    return SlashResult.RESET
+
+
+def _compact(ctx: SlashContext, args: str) -> str:
+    import asyncio
+    loop = asyncio.get_event_loop()
+    if hasattr(ctx.agent, "compactor") and ctx.agent.compactor is not None:
+        before = len(ctx.agent.agentic.messages)
+        new_msgs = loop.run_until_complete(
+            ctx.agent.compactor.compact(ctx.agent.agentic.messages)
+        )
+        ctx.agent.agentic.messages = new_msgs
+        return f"Compacted {before} → {len(new_msgs)} messages."
+    return "Compaction not configured."
+
+
+def _model(ctx: SlashContext, args: str) -> str:
+    """`/model` opens a picker; `/model <id>` switches directly.
+
+    Shows BOTH System 1 and System 2 (when dual-process is on) plus the
+    last-used tier so you can see what's actually running per turn.
+    """
+    new_id = args.strip()
+    if new_id:
+        return _do_switch(ctx, new_id)
+
+    # No args → interactive picker. The slash dispatcher runs between
+    # turns (no active event loop) so asyncio.run is safe here.
+    import asyncio
+    from llm.models import ModelRegistry
+
+    reg = ModelRegistry()
+    try:
+        asyncio.run(reg.refresh())
+    except Exception as e:
+        return f"[red]model registry refresh failed: {e}[/red]"
+
+    models = sorted(reg.models(), key=lambda m: (m.provider, m.name))
+    if not models:
+        return "[yellow]No models detected. Is Ollama running?[/yellow]"
+
+    # Resolve what's actually running:
+    #   - dual-brain: System 1 (fast) + System 2 (slow), last-used highlighted
+    #   - single-brain: just one primary
+    from llm.router import DualLLMProvider
+    s1_id = s2_id = primary_id = None
+    last_tier = None
+    last_used_id = None
+    if isinstance(ctx.agent.llm, DualLLMProvider):
+        s1_id = ctx.agent.llm.fast_model
+        s2_id = ctx.agent.llm.slow_model
+        last_tier = ctx.agent.llm.last_tier
+        last_used_id = ctx.agent.llm.last_provider_model
+    else:
+        primary_id = ctx.agent.llm.model
+
+    def _badge(model_id: str) -> str:
+        """Annotate a model row with the right marker."""
+        tags: list[str] = []
+        if model_id == s1_id:
+            tags.append("[cyan]S1[/cyan]")
+        if model_id == s2_id:
+            tags.append("[magenta]S2[/magenta]")
+        if model_id == primary_id:
+            tags.append("[green]●[/green]")
+        if last_used_id and model_id == last_used_id:
+            tags.append("[bold yellow]← active[/bold yellow]")
+        return ("  " + " ".join(tags)) if tags else ""
+
+    table = Table(
+        title="Available models — type a number or id, blank to cancel",
+        show_lines=False,
+    )
+    table.add_column("#", justify="right", style="bold cyan")
+    table.add_column("id")
+    table.add_column("provider")
+    table.add_column("tools")
+    table.add_column("ctx", justify="right")
+    table.add_column("size", justify="right")
+
+    for i, m in enumerate(models, 1):
+        size = f"{m.size_bytes / (1024 ** 3):.1f}GB" if m.size_bytes else "-"
+        table.add_row(
+            str(i),
+            f"{m.id}{_badge(m.id)}",
+            m.provider,
+            "✓" if m.supports_tool_calling else "-",
+            f"{m.context_window:,}",
+            size,
+        )
+
+    # Append presets as virtual rows
+    preset_offset = len(models)
+    for i, preset in enumerate(("fast", "balanced", "powerful"), 1):
+        table.add_row(
+            str(preset_offset + i),
+            f"[dim]preset:{preset}[/dim]",
+            "—", "—", "—", "—",
+        )
+
+    ctx.console.print(table)
+    if s1_id and s2_id:
+        ctx.console.print(
+            f"[dim]System 1 (fast):[/dim] [cyan]{s1_id}[/cyan]   "
+            f"[dim]System 2 (slow):[/dim] [magenta]{s2_id}[/magenta]"
+            + (f"   [dim]last call →[/dim] [bold]{last_tier or '?'}[/bold]"
+               f" ([yellow]{last_used_id}[/yellow])"
+               if last_used_id else "")
+        )
+        ctx.console.print(
+            "[dim]Switch with /system1 <id|preset>  or  /system2 <id|preset>[/dim]"
+        )
+    else:
+        ctx.console.print(f"[dim]single brain: {primary_id}[/dim]")
+
+    try:
+        raw = ctx.console.input("[bold]pick> [/bold]").strip()
+    except (EOFError, KeyboardInterrupt):
+        return ""
+    if not raw:
+        return ""
+
+    # Numeric? Map to the row
+    if raw.isdigit():
+        n = int(raw)
+        if 1 <= n <= len(models):
+            return _do_switch(ctx, models[n - 1].id)
+        if preset_offset < n <= preset_offset + 3:
+            preset_name = ("fast", "balanced", "powerful")[n - preset_offset - 1]
+            return _do_switch(ctx, preset_name)
+        return f"[red]Out of range: {n}[/red]"
+
+    # Otherwise treat as id (full or prefix). Match against ids first,
+    # then names, then presets.
+    if raw.lower() in ("fast", "balanced", "powerful"):
+        return _do_switch(ctx, raw.lower())
+
+    matches = [m for m in models if m.id == raw]
+    if not matches:
+        matches = [m for m in models if m.id.startswith(raw) or m.name.startswith(raw)]
+    if len(matches) == 1:
+        return _do_switch(ctx, matches[0].id)
+    if len(matches) > 1:
+        ids = ", ".join(m.id for m in matches[:5])
+        return f"[yellow]Ambiguous — matches: {ids}{'…' if len(matches) > 5 else ''}[/yellow]"
+
+    # No match — try the raw string as a literal id (lets users pass
+    # something the registry doesn't know about, e.g. a freshly pulled
+    # Ollama model that hasn't been refreshed).
+    return _do_switch(ctx, raw)
+
+
+def _do_switch(ctx: SlashContext, new_id: str) -> str:
+    try:
+        # Resolve presets through the same path the agent uses on init.
+        from core.agent import _resolve_preset_sync
+        resolved = _resolve_preset_sync(new_id)
+        ctx.agent.switch_model(resolved)
+        return f"model: → {ctx.agent.llm.model}"
+    except Exception as e:
+        return f"[red]switch failed: {e}[/red]"
+
+
+def _swap_tier(ctx: SlashContext, args: str, slot: str) -> str:
+    """Swap System 1 or System 2 mid-session.
+
+    Persists to ~/.cognos/settings.json so the change survives restart.
+    Hot-swaps in place if dual-process is already running; otherwise
+    upgrades the single-brain agent to dual-brain by pairing with the
+    current model.
+    """
+    from core.agent import _resolve_preset_sync
+    from core.settings import write_user_setting
+    from llm.provider import LLMProvider
+    from llm.router import DualLLMProvider, RoutingPolicy, Router
+    from config import ROUTER_COMPLEXITY_THRESHOLD
+
+    new_id = args.strip()
+    if not new_id:
+        # No arg: just report the current value
+        if isinstance(ctx.agent.llm, DualLLMProvider):
+            cur = (ctx.agent.llm.fast_model if slot == "system1"
+                   else ctx.agent.llm.slow_model)
+            return f"{slot}: {cur}"
+        return f"[dim]dual-process not configured. Set both /system1 and /system2 to enable.[/dim]"
+
+    try:
+        resolved = _resolve_preset_sync(new_id)
+    except Exception as e:
+        return f"[red]could not resolve {new_id!r}: {e}[/red]"
+
+    # Already in dual-brain mode — hot-swap the relevant tier.
+    if isinstance(ctx.agent.llm, DualLLMProvider):
+        if slot == "system1":
+            ctx.agent.llm.set_fast(resolved)
+            ctx.agent.llm_fast = ctx.agent.llm._fast
+        else:
+            ctx.agent.llm.set_slow(resolved)
+            ctx.agent.llm_slow = ctx.agent.llm._slow
+        write_user_setting(slot, resolved)
+        cur_s1 = ctx.agent.llm.fast_model
+        cur_s2 = ctx.agent.llm.slow_model
+        return (f"[green]{slot} → {resolved}[/green]   "
+                f"[dim]S1={cur_s1} · S2={cur_s2} (saved)[/dim]")
+
+    # Single-brain mode. Promote to dual-brain by combining with the
+    # current model on the *other* slot.
+    current_model = ctx.agent.llm.model
+    if slot == "system1":
+        s1, s2 = resolved, current_model
+    else:
+        s1, s2 = current_model, resolved
+    try:
+        fast = LLMProvider(model=s1)
+        slow = LLMProvider(model=s2)
+        policy = RoutingPolicy(complexity_threshold=ROUTER_COMPLEXITY_THRESHOLD)
+        new_llm = DualLLMProvider(fast=fast, slow=slow, policy=policy)
+        # Reconnect with the agent's mood + caudate observer
+        if ctx.agent.personality is not None:
+            try: new_llm.set_mood(ctx.agent.personality.mood)
+            except Exception: pass
+        cau = getattr(ctx.agent, "caudate", None)
+        if cau is not None:
+            try: new_llm.router.set_caudate(cau)
+            except Exception: pass
+        ctx.agent.llm = new_llm
+        ctx.agent.llm_fast = fast
+        ctx.agent.llm_slow = slow
+        ctx.agent.agentic.llm = new_llm
+    except Exception as e:
+        return f"[red]could not enable dual-brain: {e}[/red]"
+    write_user_setting("system1", s1)
+    write_user_setting("system2", s2)
+    return (f"[green]dual-brain enabled[/green]\n"
+            f"  [cyan]System 1 (fast):[/cyan]  {s1}\n"
+            f"  [magenta]System 2 (slow):[/magenta] {s2}\n"
+            f"[dim]saved to ~/.cognos/settings.json[/dim]")
+
+
+def _system1(ctx: SlashContext, args: str) -> Any:
+    return _swap_tier(ctx, args, "system1")
+
+
+def _system2(ctx: SlashContext, args: str) -> Any:
+    return _swap_tier(ctx, args, "system2")
+
+
+def _cost(ctx: SlashContext, args: str) -> str:
+    from core.usage import get_global_tracker
+    rep = get_global_tracker().report()
+    table = Table(title="Usage")
+    table.add_column("model")
+    table.add_column("requests")
+    table.add_column("prompt")
+    table.add_column("completion")
+    for model, u in rep["by_model"].items():
+        table.add_row(model, str(u["requests"]), str(u["prompt_tokens"]), str(u["completion_tokens"]))
+    ctx.console.print(table)
+    return f"total_tokens={rep['total_tokens']}  cost=${rep['total_cost_usd']:.6f}"
+
+
+def _tools(ctx: SlashContext, args: str) -> str:
+    table = Table(title="Tools")
+    table.add_column("name")
+    table.add_column("description")
+    for name in sorted(ctx.agent.loop.executor.list_tools()):
+        t = ctx.agent.loop.executor.get_tool(name)
+        if t:
+            table.add_row(name, (t.description or "")[:80])
+    ctx.console.print(table)
+    return ""
+
+
+def _sessions(ctx: SlashContext, args: str) -> str:
+    from core.session import SessionManager
+    from config import SESSIONS_DIR
+    sm = SessionManager(SESSIONS_DIR)
+    items = sm.list()
+    if not items:
+        return "(no saved sessions)"
+    table = Table(title="Sessions")
+    table.add_column("id"); table.add_column("title"); table.add_column("model"); table.add_column("msgs"); table.add_column("updated")
+    for s in items[:20]:
+        table.add_row(s.id[:8], (s.title or "(untitled)")[:30], s.model, str(len(s.messages)), s.updated_at.isoformat(timespec="seconds"))
+    ctx.console.print(table)
+    return ""
+
+
+def _export(ctx: SlashContext, args: str) -> str:
+    from core.export import export_session
+    parts = shlex.split(args) if args else []
+    fmt = parts[0] if parts else "markdown"
+    path = Path(parts[1]) if len(parts) > 1 else Path(f"data/exports/{ctx.agent.session.id}.{ {'markdown':'md','md':'md','json':'json','html':'html'}.get(fmt, 'md') }")
+    out = export_session(ctx.agent.session, path, format=fmt)
+    return f"exported → {out}"
+
+
+def _files(ctx: SlashContext, args: str) -> str:
+    parts = shlex.split(args) if args else []
+    sub = parts[0] if parts else "list"
+    if sub == "list":
+        items = ctx.agent.files.list()
+        if not items:
+            return "(no uploaded files)"
+        table = Table(title="Files")
+        table.add_column("id"); table.add_column("name"); table.add_column("kind"); table.add_column("size")
+        for r in items[:20]:
+            table.add_row(r.id[:8], r.filename, r.kind, str(r.size_bytes))
+        ctx.console.print(table)
+        return ""
+    if sub == "delete" and len(parts) > 1:
+        ok = ctx.agent.files.delete(parts[1])
+        return "deleted" if ok else "[red]not found[/red]"
+    return "usage: /files [list|delete <id>]"
+
+
+def _permissions(ctx: SlashContext, args: str) -> str:
+    from core.permissions import PermissionMode
+    if not args.strip():
+        return f"mode: {ctx.agent.permissions.mode.value}"
+    try:
+        ctx.agent.permissions.mode = PermissionMode(args.strip())
+        return f"mode: → {ctx.agent.permissions.mode.value}"
+    except Exception as e:
+        return f"[red]{e}[/red]"
+
+
+def _personality(ctx: SlashContext, args: str) -> str:
+    if ctx.agent.personality is None:
+        return "(personality disabled)"
+    p = ctx.agent.personality
+    return f"identity: {p.identity.describe()}\nmood: {p.mood.label()}"
+
+
+def _router(ctx: SlashContext, args: str) -> str:
+    from llm.router import DualLLMProvider
+    if isinstance(ctx.agent.llm, DualLLMProvider):
+        return f"fast={ctx.agent.llm_fast.model}  slow={ctx.agent.llm_slow.model}"
+    return "(routing disabled — single model)"
+
+
+def _diff(ctx: SlashContext, args: str) -> str:
+    parts = shlex.split(args) if args else []
+    if not parts:
+        return "usage: /diff <path>"
+    p = Path(parts[0])
+    if not p.exists():
+        return f"[red]not found: {p}[/red]"
+    from core.diff_viewer import render_unified_diff
+    render_unified_diff("", p.read_text(errors="ignore"), "/dev/null", str(p), console=ctx.console)
+    return ""
+
+
+def _status(ctx: SlashContext, args: str) -> str:
+    from core.statusline import build_status_values, render_statusline
+    template = (ctx.settings.get("statusline") if ctx.settings else None) or "{model} | {mood} | tok={tokens} | ${cost:.4f}"
+    return render_statusline(template, build_status_values(ctx.agent))
+
+
+def _cron(ctx: SlashContext, args: str) -> str:
+    from core.scheduler import CronStore
+    store = CronStore(Path("data/cron.json"))
+    parts = shlex.split(args) if args else ["list"]
+    sub = parts[0]
+    if sub == "list":
+        jobs = store.list()
+        if not jobs:
+            return "(no scheduled jobs)"
+        table = Table(title="Cron")
+        table.add_column("id"); table.add_column("schedule"); table.add_column("next"); table.add_column("prompt")
+        for j in jobs:
+            table.add_row(j.id, j.schedule, j.next_run or "-", j.prompt[:40])
+        ctx.console.print(table)
+        return ""
+    if sub == "add" and len(parts) >= 3:
+        schedule = parts[1]
+        prompt = " ".join(parts[2:])
+        try:
+            j = store.add(prompt, schedule)
+            return f"scheduled {j.id}: {schedule}"
+        except Exception as e:
+            return f"[red]{e}[/red]"
+    if sub == "remove" and len(parts) >= 2:
+        ok = store.remove(parts[1])
+        return "removed" if ok else "[red]not found[/red]"
+    return "usage: /cron list | /cron add <schedule> <prompt> | /cron remove <id>"
+
+
+def _bg(ctx: SlashContext, args: str) -> str:
+    from core.background import get_global_pool
+    pool = get_global_pool()
+    parts = shlex.split(args) if args else ["list"]
+    sub = parts[0]
+    if sub == "list":
+        rows = pool.list()
+        if not rows:
+            return "(no background tasks)"
+        table = Table(title="Background tasks")
+        table.add_column("id"); table.add_column("status"); table.add_column("dur"); table.add_column("label")
+        for r in rows[:20]:
+            table.add_row(r.id, r.status, f"{r.duration:.1f}s", r.label[:40])
+        ctx.console.print(table)
+        return ""
+    if sub == "watch" and len(parts) >= 2:
+        bg = pool.get(parts[1])
+        if bg is None:
+            return "[red]no such task[/red]"
+        return f"{bg.id} {bg.status} dur={bg.duration:.1f}s\n{(bg.result or bg.error or '')[:1000]}"
+    if sub == "kill" and len(parts) >= 2:
+        ok = pool.cancel(parts[1])
+        return "cancelled" if ok else "[red]not running[/red]"
+    return "usage: /bg list | /bg watch <id> | /bg kill <id>"
+
+
+def _notify(ctx: SlashContext, args: str) -> str:
+    from core.notifications import notify
+    if not args.strip():
+        return "usage: /notify <message>"
+    notify("Cognos", args.strip())
+    return "sent"
+
+
+def _think(ctx: SlashContext, args: str) -> str:
+    val = args.strip().lower()
+    if val in ("on", "true", "1"):
+        ctx.agent.agentic.thinking = True
+        return "thinking: on"
+    if val in ("off", "false", "0"):
+        ctx.agent.agentic.thinking = False
+        return "thinking: off"
+    return f"thinking: {ctx.agent.agentic.thinking}"
+
+
+def _save(ctx: SlashContext, args: str) -> str:
+    ctx.agent.session.messages = list(ctx.agent.agentic.messages)
+    ctx.agent.sessions.save(ctx.agent.session)
+    return f"saved {ctx.agent.session.id}"
+
+
+def _caudate(ctx: SlashContext, args: str) -> str:
+    """Inspect / control Caudate (the action-selection neural net)."""
+    cau = getattr(ctx.agent, "caudate", None)
+    if cau is None:
+        return "[dim]Caudate is not active in this agent.[/dim]"
+
+    sub = (args.strip() or "status").split()[0].lower()
+    rest = args.strip()[len(sub):].strip()
+
+    if sub == "status":
+        s = cau.status()
+        policy = s.get("policy", {})
+        scorer = s.get("scorer", {})
+        nxt = policy.get("next") or {}
+        lines = [
+            f"trust:      [cyan]{policy.get('level', '?')}[/cyan]"
+            f"{' (frozen)' if policy.get('frozen') else ''}",
+            f"advisor:    {'loaded' if s['advisor_loaded'] else '[yellow]no checkpoint[/yellow]'}",
+            f"replay:     {s['replay_size']}/{cau.cfg.replay_capacity} samples "
+            f"({s['samples_since_train']} new since last train)",
+            f"accuracy:   tool={scorer.get('tool_acc', 0):.2f}  "
+            f"tier={scorer.get('tier_acc', 0):.2f}  "
+            f"think={scorer.get('think_acc', 0):.2f}  "
+            f"composite={scorer.get('composite', 0):.2f}",
+            f"scored:     {scorer.get('samples_in_window', 0)} in window, "
+            f"{scorer.get('lifetime_predictions', 0)} lifetime",
+            f"auto-train: every {s['auto_train_every']} samples · "
+            f"{'[cyan]running[/cyan]' if s['auto_train_in_flight'] else 'idle'}",
+        ]
+        if not nxt.get("at_top"):
+            lines.append(
+                f"next gate:  → [cyan]{nxt.get('next_level', '?')}[/cyan]  "
+                f"(need acc≥{nxt.get('accuracy_needed', 0):.2f}, "
+                f"{nxt.get('samples_needed', 0)} more samples)"
+            )
+        else:
+            lines.append("next gate:  [green]top level reached[/green]")
+
+        p = s.get("last_prediction")
+        if p:
+            lines.append(
+                f"last pred:  tool={p['tool']} ({p['tool_conf']:.2f}) · "
+                f"tier={p['tier']} ({p['tier_conf']:.2f}) · "
+                f"think={p['think']:.2f} · value={p['value']:.2f}"
+            )
+        return "\n".join(lines)
+
+    if sub == "awareness":
+        # Caudate speaks about herself in the first person.
+        s = cau.status()
+        scorer = s.get("scorer", {})
+        policy = s.get("policy", {})
+        nxt = policy.get("next") or {}
+        level = policy.get("level", "silent")
+        if level == "silent":
+            return (
+                '[italic]"I exist, but I have no weights yet. I\'m watching '
+                f'you work — once {cau.cfg.min_episodes_to_train} samples '
+                'land in the replay buffer, the trainer fires and I open '
+                'my eyes."[/italic]'
+            )
+        if level == "observer":
+            return (
+                f'[italic]"I have weights now. I predict every turn, but '
+                f'no one listens yet — and they shouldn\'t. My tool '
+                f'accuracy is {scorer.get("tool_acc", 0):.0%} over '
+                f'{scorer.get("samples_in_window", 0)} predictions. '
+                f"I need {nxt.get('samples_needed', 0)} more samples and "
+                f"composite ≥ {nxt.get('accuracy_needed', 0):.2f} before "
+                f'you let me whisper."[/italic]'
+            )
+        if level == "whisper":
+            return (
+                f'[italic]"I\'m whispering now. My suggestions appear in '
+                f'the LLM\'s system prompt — it can ignore me. Tool '
+                f'accuracy {scorer.get("tool_acc", 0):.0%}, tier '
+                f'{scorer.get("tier_acc", 0):.0%}, composite '
+                f'{scorer.get("composite", 0):.2f}. To advise (override '
+                f'the router) I need composite ≥ '
+                f'{nxt.get("accuracy_needed", 0):.2f} over '
+                f'{nxt.get("current_samples", 0) + nxt.get("samples_needed", 0)} '
+                f'predictions."[/italic]'
+            )
+        if level == "advisor":
+            return (
+                f'[italic]"I pick the routing tier now. The heuristic '
+                f"router doesn't run — my prediction does. Tier accuracy "
+                f"{scorer.get('tier_acc', 0):.0%}. To gate thinking "
+                f'(controller level) I need composite ≥ '
+                f'{nxt.get("accuracy_needed", 0):.2f}."[/italic]'
+            )
+        return (
+            f'[italic]"Controller level. I gate thinking and route every '
+            f"call. I'm not smarter than the cortex (LLM) — I'm faster "
+            f'and more specific to you. Lifetime accuracy: '
+            f'{scorer.get("lifetime_tool_acc", 0):.1%} on '
+            f'{scorer.get("lifetime_predictions", 0)} predictions."[/italic]'
+        )
+
+    if sub in ("train", "fit"):
+        try:
+            cau._train_sync()
+            cau.reload_advisor()
+            return "[green]training complete; advisor reloaded[/green]"
+        except Exception as e:
+            return f"[red]train failed: {e}[/red]"
+
+    if sub == "reload":
+        ok = cau.reload_advisor()
+        return "[green]advisor reloaded[/green]" if ok else "[yellow]no checkpoint to load[/yellow]"
+
+    if sub == "freeze":
+        from nn.policy import TrustLevel
+        target = None
+        if rest:
+            try:
+                target = TrustLevel[rest.upper()]
+            except KeyError:
+                return f"[red]unknown trust level: {rest}[/red]"
+        cau.policy.freeze(level=target)
+        return f"[yellow]Caudate frozen at {cau.policy.level.label}[/yellow]"
+
+    if sub == "thaw":
+        cau.policy.thaw()
+        return f"[green]Caudate thawed — graduation re-enabled[/green]"
+
+    if sub == "demote":
+        from nn.policy import TrustLevel
+        if cau.policy.level <= TrustLevel.OBSERVER:
+            return "[yellow]already at the bottom[/yellow]"
+        cau.policy.force(TrustLevel(int(cau.policy.level) - 1))
+        return f"[yellow]demoted → {cau.policy.level.label}[/yellow]"
+
+    if sub == "promote":
+        from nn.policy import TrustLevel
+        if cau.policy.level >= TrustLevel.CONTROLLER:
+            return "[green]already at the top[/green]"
+        cau.policy.force(TrustLevel(int(cau.policy.level) + 1))
+        return f"[green]promoted → {cau.policy.level.label}[/green]"
+
+    if sub in ("stop", "kill"):
+        # Hard owner override. Deletes weights if `kill`, just silences if `stop`.
+        from core.ownership import kill, get_owner
+        owner = get_owner()
+        if sub == "stop":
+            kill(reason=f"{owner.name} stop")
+            return f"[red bold]Caudate stopped by {owner.name}.[/red bold]\n" \
+                   f"[dim]predictions silenced, no auto-train, no NAS. " \
+                   f"Run `/caudate resume` to lift the killswitch.[/dim]"
+        # kill — also wipe the weights so she has to re-earn trust
+        kill(reason=f"{owner.name} kill — weights wiped")
+        from pathlib import Path
+        for p in (cau.cfg.checkpoint_path, cau.cfg.metadata_path):
+            try: Path(p).unlink(missing_ok=True)
+            except Exception: pass
+        cau.advisor = None
+        return f"[red bold]Caudate killed by {owner.name}.[/red bold]\n" \
+               f"[dim]weights wiped, killswitch on, trust reset to silent. " \
+               f"She has to re-earn everything.[/dim]"
+
+    if sub == "resume":
+        from core.ownership import resume, get_owner
+        resume()
+        cau.reload_advisor()
+        return f"[green]Caudate resumed by {get_owner().name}.[/green]"
+
+    if sub == "obey":
+        # Audit + show that she only obeys the configured owner
+        from core.ownership import get_owner, killswitch_status, audit
+        owner = get_owner()
+        ks = killswitch_status()
+        audit("obedience_check", invoker=owner.name)
+        return (
+            f"owner:        [bold]{owner.name}[/bold]\n"
+            f"set_at:       {owner.set_at}\n"
+            f"killswitch:   "
+            + ("[red]ACTIVE — Caudate is silent[/red]" if ks.get("killed")
+               else "[green]inactive — Caudate may act[/green]") + "\n"
+            f"[dim]Caudate's predictions, auto-train, and NAS all gate on this. "
+            f"You hold the only veto.[/dim]"
+        )
+
+    if sub == "owner":
+        from core.ownership import get_owner, set_owner
+        if not rest:
+            o = get_owner()
+            return f"owner: {o.name}  (set {o.set_at})\n[dim]/caudate owner <name> to reassign[/dim]"
+        new = set_owner(rest.strip())
+        return f"[yellow]owner reassigned: → {new.name}[/yellow]"
+
+    if sub == "undo":
+        # Roll back to the previous champion in NAS history
+        from nn.nas.store import NASStore
+        store = NASStore()
+        history = [h for h in store.history()
+                   if h.get("result", {}).get("fitness", -1) > -1]
+        if len(history) < 2:
+            return "[yellow]not enough NAS history to undo[/yellow]"
+        # Take the second-most-recent (penultimate) by save time
+        history.sort(key=lambda h: h.get("born_at", 0))
+        prev = history[-2]
+        return (f"[yellow]undo would restore {prev.get('id', '')[:8]} "
+                f"(fit={prev.get('result', {}).get('fitness', 0):.3f})[/yellow]\n"
+                f"[dim]not yet implemented — manual NAS history rollback "
+                f"requires checkpoint preservation per trial.[/dim]")
+
+    if sub == "evolve":
+        evo = getattr(cau, "auto_evolver", None)
+        if evo is None:
+            return "[yellow]auto-evolve not initialized[/yellow]"
+        sub2 = (rest.split() or [""])[0].lower()
+        if sub2 == "on":
+            evo.cfg.enabled = True
+            return "[green]auto-evolve enabled[/green]"
+        if sub2 == "off":
+            evo.cfg.enabled = False
+            return "[yellow]auto-evolve disabled[/yellow]"
+        if sub2 == "force":
+            # Bypass plateau check + cooldown for one fire
+            evo._last_fire_at = 0.0
+            try:
+                from nn.nas.scheduler import PlateauScheduler
+                sched = PlateauScheduler()
+                # Pretend we've stalled enough to trigger
+                while not sched.should_fire():
+                    sched.observe_eval(0.0)
+            except Exception:
+                pass
+            evo.maybe_fire()
+            return "[cyan]NAS run forced — running in background[/cyan]"
+        # Default: show status
+        s = evo.status()
+        lines = [
+            f"enabled:    {s['enabled']}",
+            f"fires:      {s['n_fires']}",
+            f"in flight:  {s['in_flight']}",
+            f"cooldown:   {s['cooldown_seconds']}s",
+            f"min VRAM:   {s['min_vram_gb']}GB",
+            f"rotation:   {' → '.join(s['rotation'])}",
+        ]
+        if s.get("seconds_since_last_fire") is not None:
+            lines.append(f"since fire: {s['seconds_since_last_fire']}s ago")
+        return "\n".join(lines)
+
+    if sub == "off":
+        cau.advisor = None
+        return "[yellow]Caudate predictions silenced (replay buffer still recording).[/yellow]"
+
+    if sub == "on":
+        ok = cau.reload_advisor()
+        return "[green]Caudate predictions re-enabled[/green]" if ok else "[yellow]no checkpoint to load[/yellow]"
+
+    return (
+        "usage: /caudate [status|awareness|train|reload|freeze|thaw|"
+        "promote|demote|on|off|evolve {status|on|off|force}|"
+        "stop|kill|resume|obey|owner [name]|undo]"
+    )
+
+
+def _voice(ctx: SlashContext, args: str) -> str:
+    """Hand control to the voice loop. Returns when the user says 'stop'.
+
+    `/voice`         — single turn (listen once, speak the reply)
+    `/voice loop`    — continuous loop until 'stop'/'goodbye' or Ctrl+C
+    `/voice --stt whisper`  — backend override
+    """
+    import asyncio
+    import shlex
+
+    parts = shlex.split(args) if args else []
+    loop = "loop" in parts
+    stt_backend = "moonshine"
+    voice_path: str | None = None
+
+    # Tiny option parser
+    i = 0
+    while i < len(parts):
+        p = parts[i]
+        if p == "--stt" and i + 1 < len(parts):
+            stt_backend = parts[i + 1]; i += 2
+        elif p == "--voice" and i + 1 < len(parts):
+            voice_path = parts[i + 1]; i += 2
+        else:
+            i += 1
+
+    try:
+        from voice.conversation import VoiceConversation
+    except ImportError as e:
+        return f"[red]voice deps missing: {e}[/red]"
+
+    conv = VoiceConversation(
+        agent=ctx.agent, stt=stt_backend, voice_path=voice_path,
+    )
+    ctx.console.print(
+        f"[magenta]Voice mode "
+        f"({'continuous' if loop else 'single turn'}, stt={stt_backend}). "
+        f"Say 'stop' or Ctrl+C to return to text.[/magenta]"
+    )
+    try:
+        if loop:
+            asyncio.run(conv.run(greeting=False))
+        else:
+            asyncio.run(_voice_single_turn(conv))
+    except KeyboardInterrupt:
+        return "[yellow]voice mode interrupted[/yellow]"
+    return "[dim]back to text mode[/dim]"
+
+
+async def _voice_single_turn(conv: Any) -> None:
+    """One listen → think → speak cycle."""
+    print("\n[listening]", end="", flush=True)
+    text = conv.listener.listen()
+    if text is None:
+        print(" (no speech)")
+        return
+    print(f"\rYou said: {text}                    ")
+    reply = await conv.agent.chat(text)
+    print(f"Cognos: {reply}")
+    conv._speak_safely(reply)
+
+
+# Server lifecycle is process-wide; track the running thread/server here.
+_serve_state: dict[str, Any] = {"thread": None, "server": None, "host": None, "port": None}
+
+
+def _serve(ctx: SlashContext, args: str) -> str:
+    """Start, stop, or check the HTTP API server.
+
+      /serve              — show status
+      /serve start [--port 8000] [--host 127.0.0.1]
+      /serve stop
+      /serve url          — print the active URL
+    """
+    import shlex
+    parts = shlex.split(args) if args else []
+    sub = parts[0] if parts else "status"
+
+    if sub in ("status", "url"):
+        if _serve_state["server"] is None:
+            return "[dim]server: stopped[/dim]"
+        url = f"http://{_serve_state['host']}:{_serve_state['port']}/ui"
+        return f"server: running at [cyan]{url}[/cyan]"
+
+    if sub == "start":
+        if _serve_state["server"] is not None:
+            return "[yellow]server already running — /serve stop first[/yellow]"
+        host = "127.0.0.1"
+        port = 8000
+        i = 1
+        while i < len(parts):
+            if parts[i] == "--port" and i + 1 < len(parts):
+                port = int(parts[i + 1]); i += 2
+            elif parts[i] == "--host" and i + 1 < len(parts):
+                host = parts[i + 1]; i += 2
+            else:
+                i += 1
+
+        try:
+            import threading
+            import uvicorn
+            from api.server import create_app
+        except ImportError as e:
+            return f"[red]uvicorn / fastapi not installed: {e}[/red]"
+
+        config = uvicorn.Config(
+            create_app(), host=host, port=port, log_level="warning",
+        )
+        server = uvicorn.Server(config)
+
+        def _run():
+            try:
+                server.run()
+            except Exception as e:
+                logger.warning(f"serve thread exited: {e}")
+
+        thread = threading.Thread(target=_run, daemon=True)
+        thread.start()
+        _serve_state.update(thread=thread, server=server, host=host, port=port)
+        return f"[green]server up:[/green] http://{host}:{port}/ui"
+
+    if sub == "stop":
+        server = _serve_state["server"]
+        if server is None:
+            return "[dim]server not running[/dim]"
+        server.should_exit = True
+        # Best-effort wait, then clear state
+        thread = _serve_state["thread"]
+        if thread is not None:
+            thread.join(timeout=5)
+        _serve_state.update(thread=None, server=None, host=None, port=None)
+        return "[yellow]server stopped[/yellow]"
+
+    return "usage: /serve [start|stop|status]"
+
+
+# ---- registry --------------------------------------------------------
+
+REGISTRY: dict[str, HandlerFn] = {
+    "help": _help, "?": _help,
+    "quit": _quit, "exit": _quit, "q": _quit,
+    "clear": _clear, "reset": _clear,
+    "compact": _compact,
+    "model": _model,
+    "cost": _cost, "usage": _cost,
+    "tools": _tools,
+    "sessions": _sessions,
+    "export": _export,
+    "files": _files,
+    "permissions": _permissions, "perms": _permissions,
+    "personality": _personality,
+    "router": _router,
+    "diff": _diff,
+    "status": _status,
+    "cron": _cron,
+    "bg": _bg, "background": _bg,
+    "notify": _notify,
+    "think": _think,
+    "save": _save,
+    "voice": _voice, "talk": _voice,
+    "serve": _serve, "server": _serve,
+    "caudate": _caudate, "nn": _caudate,
+    "system1": _system1, "s1": _system1,
+    "system2": _system2, "s2": _system2,
+}
+
+
+def is_slash(text: str) -> bool:
+    return text.startswith("/") and len(text) > 1 and not text.startswith("//")
+
+
+def dispatch(text: str, ctx: SlashContext) -> Any:
+    """Run a slash command. Returns:
+       - str  → printable result
+       - SlashResult.QUIT  → caller should exit
+       - SlashResult.RESET → caller should refresh prompt state
+       - None → unhandled (caller should fall through to normal chat)
+    """
+    if not is_slash(text):
+        return None
+    body = text[1:].strip()
+    if not body:
+        return ""
+    name, _, rest = body.partition(" ")
+    handler = REGISTRY.get(name.lower())
+    if handler is None:
+        return f"[red]unknown command: /{name}[/red] (try /help)"
+    try:
+        return handler(ctx, rest)
+    except Exception as e:
+        logger.exception(f"slash /{name} failed: {e}")
+        return f"[red]/{name} failed: {e}[/red]"