polymath-agent 0.4.0__py3-none-any.whl

polymath/main.py

@@ -0,0 +1,1293 @@
+"""
+polymath — multi-model AI orchestrator REPL.
+
+Usage:
+  polymath                            start interactive session (auto-uses repo .polymath/ when present)
+  polymath --setup                    re-run setup wizard
+  polymath --models                   list available models
+  polymath --session <id>             resume a session
+  polymath --sessions                 list all sessions
+  polymath --project <name>           start with a detached local project
+  polymath ask "question"             one-shot answer, no REPL (auto-uses repo .polymath/ when present)
+  polymath ask "question" --project <name>  one-shot with detached local project context
+
+In the REPL:
+  @claude <task>                force Claude
+  @gemini <task>                force Gemini
+  @openai <task>                force OpenAI
+  @ollama <task>                force Ollama
+  --cheap <task>                cost-first routing
+  --fast  <task>                speed-first routing
+  --ask <question>              answer directly without pipeline
+  --verify                      run verify subagent after pipeline
+  --simplify                    run code-simplifier subagent after pipeline
+  /models                       list models
+  /sessions                     list sessions
+  /session <id>                 switch session
+  /session delete <id>          delete a session
+  /new                          new session
+  /project new <name>           create a new project
+  /project use <name>           switch to a project
+  /project list                 list all projects
+  /project init                 create .polymath/ in current directory
+  /context show <type>          show a context file
+  /context add <type> <entry>   append an entry to context
+  /context edit <type>          edit a context file
+  /ship [msg]                   commit + push + PR (AI-generated message)
+  /simplify                     simplify last output
+  /explain                      explain last output
+  /<command>                    run any custom slash command
+  /commands                     list all available slash commands
+  /subagents                    list all available subagents
+  /accounts                     list and switch authenticated accounts
+  /state                        show current project/session/runtime state
+  /queue                        inspect queued commands
+  /queue drop <n>               remove a queued command
+  /queue move <a> <b>           reorder queued commands
+  /exit                         exit
+"""
+from __future__ import annotations
+
+# Bootstrap runs before everything — auto-fixes deps silently
+import polymath.bootstrap as _bootstrap
+_bootstrap.run()
+
+import asyncio
+from collections import deque
+import os
+import re
+import subprocess
+import sys
+import termios
+from typing import Optional
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import ANSI
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.patch_stdout import patch_stdout
+from prompt_toolkit.styles import Style
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+
+from polymath.config import (
+    CONFIG_DIR, TaskComplexity, TaskType, load_config
+)
+from polymath.context_store import (
+    init_db, list_sessions, new_session, get_session,
+    get_recent_sessions, get_last_session_for_project,
+    was_recent, time_ago, new_session_for_project, auto_name_session,
+    session_cost,
+)
+from polymath.detector import detect
+from polymath.router import (
+    classify_task, classify_complexity,
+)
+from polymath.setup_wizard import run_wizard, show_models
+from polymath.command_registry import build_repl_completer
+from polymath.command_service import CommandServiceContext, handle_command
+from polymath.context_manager import (
+    get_project_meta, list_projects, list_context_files, TASK_CONTEXT_MAP,
+)
+from polymath.domain import Project
+from polymath.domain import PermissionRequest
+from polymath.execution_service import ExecutionCallbacks, run_ask_flow, run_pipeline_flow
+from polymath.model_policy import resolve_models
+from polymath.orchestrator import (
+    ExecutionStrategy,
+    OutputPolicy,
+    RunController,
+    RunRequest,
+    run_ensemble,
+    run_fanout,
+    select_ensemble_workers,
+    select_splitter_and_joiner,
+)
+from polymath.permissions import is_preapproved
+from polymath.project_runtime import project_provenance_lines, resolve_project
+from polymath.slash_commands import get_all_commands
+from polymath.subagents import get_subagents
+from polymath.ui_state import CompletionSummary, RunStatus, prompt_toolbar, render_completion_summary, render_run_status
+
+
+console = Console(force_terminal=True, highlight=False)
+
+
+class _SuppressEcho:
+    """
+    Context manager that disables terminal echo while the pipeline runs.
+    Keystrokes the user types are still buffered and appear cleanly in
+    the next prompt — they just don't echo mid-stream.
+    No-ops silently on non-TTY outputs (pipes, tests).
+    """
+    def __enter__(self):
+        self._old = None
+        try:
+            self._fd = sys.stdin.fileno()
+            self._old = termios.tcgetattr(self._fd)
+            new = list(self._old)
+            new[3] = new[3] & ~termios.ECHO  # clear ECHO bit in lflags
+            termios.tcsetattr(self._fd, termios.TCSANOW, new)
+        except Exception:
+            pass
+        return self
+
+    def __exit__(self, *_):
+        if self._old is not None:
+            try:
+                termios.tcsetattr(self._fd, termios.TCSANOW, self._old)
+            except Exception:
+                pass
+
+PROMPT_STYLE = Style.from_dict({
+    "prompt": "bold cyan",
+})
+
+MODEL_COLORS = {
+    "claude":  "cyan",
+    "gemini":  "blue",
+    "openai":  "green",
+    "ollama":  "yellow",
+    "lmstudio": "magenta",
+}
+
+def _parse_force(text: str) -> tuple[str, str]:
+    """Returns (provider_override, cleaned_text)."""
+    m = re.match(r"^@(\w+)\s+(.*)", text, re.DOTALL)
+    if m:
+        return m.group(1).lower(), m.group(2).strip()
+    return "", text
+
+
+def _parse_flags(text: str) -> tuple[bool, bool, bool, bool, bool, bool, str]:
+    """Returns (cheap, fast, verify, simplify, ensemble, fanout, cleaned_text)."""
+    cheap    = "--cheap"    in text
+    fast     = "--fast"     in text
+    verify   = "--verify"   in text
+    simplify = "--simplify" in text
+    ensemble = "--ensemble" in text
+    fanout   = "--fanout"   in text
+    text = (text
+        .replace("--cheap", "")
+        .replace("--fast", "")
+        .replace("--verify", "")
+        .replace("--simplify", "")
+        .replace("--ensemble", "")
+        .replace("--fanout", "")
+        .strip())
+    return cheap, fast, verify, simplify, ensemble, fanout, text
+
+
+def _notify(title: str, message: str) -> None:
+    """Fire an OS notification. Silent no-op if notifications are unavailable."""
+    import shutil
+    try:
+        if sys.platform == "darwin":
+            # macOS
+            subprocess.run(
+                ["osascript", "-e",
+                 f'display notification "{message}" with title "{title}"'],
+                capture_output=True, timeout=3,
+            )
+        elif shutil.which("notify-send"):
+            # Linux (libnotify)
+            subprocess.run(
+                ["notify-send", title, message],
+                capture_output=True, timeout=3,
+            )
+    except Exception:
+        pass
+
+
+def _expand_context_mentions(text: str, project: str) -> tuple[str, list[str]]:
+    """
+    Expand @contextname mentions in user message.
+    e.g. "@rules check this" → injects rules.md content inline.
+    Returns (expanded_text, list_of_injected_names).
+    """
+    if not project or "@" not in text:
+        return text, []
+    from polymath.context_manager import read_context, CONTEXT_FILES
+    injected = []
+    for ctx_name in CONTEXT_FILES:
+        pattern = re.compile(rf"@{re.escape(ctx_name)}\b", re.IGNORECASE)
+        if pattern.search(text):
+            content = read_context(project, ctx_name)
+            if content:
+                text = pattern.sub(f"\n[{ctx_name.upper()} CONTEXT]\n{content}\n", text)
+                injected.append(ctx_name)
+    return text, injected
+
+
+def _active_polymath_sessions() -> int:
+    """Count other polymath processes currently running (excluding this one)."""
+    try:
+        result = subprocess.run(
+            ["pgrep", "-f", "polymath"],
+            capture_output=True, text=True, timeout=3,
+        )
+        pids = [p for p in result.stdout.strip().splitlines() if p.strip()]
+        return max(0, len(pids) - 1)  # subtract self
+    except Exception:
+        return 0
+
+
+async def _run_ensemble_flow(
+    *,
+    console,
+    text: str,
+    session_id: str,
+    active_project: str,
+    registry: list,
+    cfg: dict,
+    ensemble_warned: bool,
+) -> None:
+    """Run the same prompt across N available models in parallel + merge."""
+    from rich.panel import Panel
+
+    from polymath.context_store import add_message
+    from polymath.router import classify_task
+
+    workers, merger = select_ensemble_workers(registry, cfg, max_workers=3)
+    if not workers:
+        console.print("[red]No models available for ensemble.[/red]")
+        return
+    if len(workers) < 2:
+        console.print(
+            f"[yellow]Only one model available ({workers[0].model.display_name}); "
+            f"running it normally — no merge.[/yellow]"
+        )
+
+    if not ensemble_warned:
+        names = ", ".join(w.model.display_name for w in workers)
+        console.print(
+            f"[yellow]Ensemble mode: calling {len(workers)} models in parallel "
+            f"({names}) → ~{len(workers)}x token cost.[/yellow]"
+        )
+
+    add_message(session_id, "user", text, step="ensemble")
+
+    ticker = {"started": 0, "done": 0}
+
+    def started(name: str) -> None:
+        ticker["started"] += 1
+        console.print(f"[dim]⋯ worker started: {name} ({ticker['started']}/{len(workers)})[/dim]")
+
+    def done(result):
+        ticker["done"] += 1
+        if result.ok:
+            console.print(
+                f"[green]✓[/green] [dim]{result.display_name} "
+                f"({ticker['done']}/{len(workers)}) — {len(result.output)} chars[/dim]"
+            )
+        else:
+            console.print(
+                f"[red]✗[/red] [dim]{result.display_name}: {result.error.splitlines()[0][:80]}[/dim]"
+            )
+
+    result = await run_ensemble(
+        workers=workers,
+        user_input=text,
+        task_type=classify_task(text),
+        active_project=active_project,
+        cfg=cfg,
+        merger=merger if len(workers) >= 2 else None,
+        on_worker_started=started,
+        on_worker_done=done,
+    )
+
+    successful = result.successful
+    if not successful:
+        console.print("[red]All ensemble workers failed.[/red]")
+        return
+
+    console.print()
+    if result.merged:
+        title = f"[bold]Merged ({result.merger_model})[/bold]" if result.merger_model else "[bold]Result[/bold]"
+        console.print(Panel(result.merged, title=title, border_style="cyan"))
+        if result.disagreement_notes:
+            console.print(Panel(
+                result.disagreement_notes,
+                title="[bold yellow]Disagreements[/bold yellow]",
+                border_style="yellow",
+            ))
+    for w in successful:
+        console.print(Panel(
+            w.output,
+            title=f"[dim]{w.display_name}[/dim]",
+            border_style="dim",
+        ))
+
+    add_message(
+        session_id, "assistant",
+        result.merged or successful[0].output,
+        model="ensemble",
+        step="ensemble",
+    )
+
+
+async def _run_fanout_flow(
+    *,
+    console,
+    text: str,
+    session_id: str,
+    active_project: str,
+    registry: list,
+    cfg: dict,
+    profile: str,
+) -> None:
+    """Split into independent subtasks → run in parallel on best-fit specialists → join."""
+    from rich.panel import Panel
+
+    from polymath.context_store import add_message
+    from polymath.model_policy import resolve_models
+    from polymath.router import classify_task
+
+    splitter_pair, joiner_pair = select_splitter_and_joiner(registry, cfg, profile)
+    if not splitter_pair or not joiner_pair:
+        console.print("[red]Fanout needs at least one available model.[/red]")
+        return
+
+    # Get a quick plan first — splitter uses it as context
+    resolution = await resolve_models(
+        registry=registry, cfg=cfg, session_id=session_id,
+        user_input=text, active_project=active_project,
+        task_type=classify_task(text), profile=profile, is_ask=True,
+    )
+    plan = ""
+    if resolution.primary_adapter and resolution.primary_info:
+        try:
+            from polymath.adapters.base import Message
+            plan_resp = await resolution.primary_adapter.complete(
+                messages=[Message(role="user", content=f"Outline a step-by-step plan for: {text}")],
+                model_id=resolution.primary_info.id,
+                system="Output a numbered plan only.",
+                temperature=0.3,
+            )
+            plan = plan_resp if isinstance(plan_resp, str) else getattr(plan_resp, "content", "")
+        except Exception:
+            pass
+
+    add_message(session_id, "user", text, step="fanout")
+    console.print(f"[dim]Splitting task across specialists…[/dim]")
+
+    splitter_info, splitter_adapter = splitter_pair
+    joiner_info, joiner_adapter = joiner_pair
+
+    def on_split(subtasks):
+        if len(subtasks) <= 1:
+            console.print(f"[yellow]Splitter returned {len(subtasks)} subtask — fanout skipped.[/yellow]")
+            return
+        console.print(f"[cyan]Split into {len(subtasks)} subtasks:[/cyan]")
+        for st in subtasks:
+            console.print(f"  [bold]{st.id}[/bold] ({st.task_type.value}): {st.description[:80]}")
+
+    def on_started(subtask, model):
+        console.print(f"[dim]⋯ {subtask.id} → {model.display_name}[/dim]")
+
+    def on_done(result):
+        if result.ok:
+            console.print(f"[green]✓[/green] [dim]{result.subtask.id} ({result.model_display}, {len(result.output)} chars)[/dim]")
+        else:
+            console.print(f"[red]✗[/red] [dim]{result.subtask.id}: {result.error.splitlines()[0][:80]}[/dim]")
+
+    result = await run_fanout(
+        task=text,
+        plan=plan,
+        registry=registry,
+        cfg=cfg,
+        splitter_adapter=splitter_adapter,
+        splitter_model=splitter_info,
+        joiner_adapter=joiner_adapter,
+        joiner_model=joiner_info,
+        profile=profile,
+        on_split=on_split,
+        on_subtask_started=on_started,
+        on_subtask_done=on_done,
+    )
+
+    if result.skipped_reason:
+        console.print(f"[yellow]Fanout skipped: {result.skipped_reason}[/yellow]")
+        return
+
+    console.print()
+    console.print(Panel(
+        result.joined,
+        title=f"[bold]Joined ({result.join_model})[/bold]",
+        border_style="cyan",
+    ))
+    for r in result.successful:
+        console.print(Panel(
+            r.output,
+            title=f"[dim]{r.subtask.id} · {r.model_display}[/dim]",
+            border_style="dim",
+        ))
+
+    add_message(
+        session_id, "assistant", result.joined,
+        model=f"fanout/{result.join_model}", step="fanout",
+    )
+
+
+def _print_usage_bar(usage: dict) -> None:
+    """Print right-aligned per-model token usage after each output."""
+    def _fmt(n: int) -> str:
+        return f"{n/1000:.1f}k" if n >= 1000 else str(n)
+    parts = []
+    for name, values in usage.items():
+        i, o = values[:2]
+        if not i and not o:
+            continue
+        extra = ""
+        if len(values) >= 3 and values[2]:
+            remaining = max(values[2] - i, 0)
+            extra = f"  | ctx {_fmt(remaining)} left"
+        parts.append(f"{name}: {_fmt(i)}↑ {_fmt(o)}↓{extra}")
+    if not parts:
+        return
+    text = "  ·  ".join(parts)
+    width = console.width or 100
+    console.print(text.rjust(width), style="dim")
+
+
+def _print_startup_header() -> None:
+    logo = "\n".join([
+        "[bold #7FF7E8]██████╗  ██████╗ ██╗  ██╗   ██╗███╗   ███╗ █████╗ ████████╗██╗  ██╗[/bold #7FF7E8]",
+        "[bold #67EBDD]██╔══██╗██╔═══██╗██║  ╚██╗ ██╔╝████╗ ████║██╔══██╗╚══██╔══╝██║  ██║[/bold #67EBDD]",
+        "[bold #52DCCD]██████╔╝██║   ██║██║   ╚████╔╝ ██╔████╔██║███████║   ██║   ███████║[/bold #52DCCD]",
+        "[bold #43CFC1]██╔═══╝ ██║   ██║██║    ╚██╔╝  ██║╚██╔╝██║██╔══██║   ██║   ██╔══██║[/bold #43CFC1]",
+        "[bold #35C1B4]██║     ╚██████╔╝███████╗██║   ██║ ╚═╝ ██║██║  ██║   ██║   ██║  ██║[/bold #35C1B4]",
+        "[bold #28B3A7]╚═╝      ╚═════╝ ╚══════╝╚═╝   ╚═╝     ╚═╝╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝[/bold #28B3A7]",
+    ])
+    console.print(logo)
+    console.print("[#8CF5EA]multi-model terminal orchestrator[/#8CF5EA]")
+    console.print("[dim]one conversation surface • many models behind it[/dim]")
+    console.print()
+
+
+async def run_session(session_id: str, cfg: dict, active_project: str = "") -> None:
+    import asyncio as _asyncio
+    registry = detect()
+    profile   = cfg.get("priority_profile", "quality-first")
+    output_policy = OutputPolicy()
+    run_controller = RunController(output_policy=output_policy)
+    history_file = CONFIG_DIR / "history.txt"
+    _queued_inputs: deque[str | None] = deque()
+    _queue_ready = _asyncio.Event()
+    _proc = {"active": False}  # mutable dict for closure access in _input_reader
+
+    bindings = KeyBindings()
+
+    @bindings.add("up")
+    def _edit_queued_or_history(event) -> None:
+        buf = event.app.current_buffer
+        if _queued_inputs and not buf.text:
+            queued = _queued_inputs.pop()
+            if not _queued_inputs:
+                _queue_ready.clear()
+            if queued is not None:
+                buf.text = queued
+                buf.cursor_position = len(queued)
+            return
+        buf.auto_up(count=1)
+
+    @bindings.add("down")
+    def _next_history(event) -> None:
+        event.app.current_buffer.auto_down(count=1)
+
+    project_state: Project = resolve_project(active_project)
+
+    def _toolbar() -> ANSI:
+        return ANSI(prompt_toolbar(project_state, _queued_inputs, _proc["active"], session_id))
+
+    # Main prompt session — used ONLY by the background input reader
+    prompt_session = PromptSession(
+        history=FileHistory(str(history_file)),
+        style=PROMPT_STYLE,
+        key_bindings=bindings,
+        completer=build_repl_completer([]),
+        complete_while_typing=True,
+        bottom_toolbar=_toolbar,
+    )
+    # ── Load local .polymath/ project config ──────────────────────────────────
+    local_project = project_state.local_project
+    if local_project and not active_project:
+        active_project = project_state.name
+        console.print(f"[dim]Found .polymath/ — project: [bold]{active_project}[/bold][/dim]")
+
+    # ── Load slash commands and subagents ─────────────────────────────────────
+    _cmds = get_all_commands(local_project.commands_dir if local_project else None)
+    _subs = get_subagents(local_project.subagents_dir if local_project else None)
+    prompt_session.completer = build_repl_completer(list(_cmds.keys()))
+
+    _print_startup_header()
+    proj_label = f"  •  project: [bold]{active_project}[/bold]" if active_project else ""
+    available = [m for m in registry if m.available]
+    model_label = (
+        f"  •  [bold]{available[0].display_name}[/bold] (1 model — /setup to add more)"
+        if len(available) == 1
+        else f"  •  {len(available)} models"
+    )
+    console.print(f"[dim]profile: {profile}{proj_label}{model_label}[/dim]")
+    parallel = _active_polymath_sessions()
+    parallel_label = f"  •  [dim]{parallel} other session{'s' if parallel != 1 else ''} running[/dim]" if parallel > 0 else ""
+    console.print(f"[dim]Type /help for commands, /exit to quit{parallel_label}[/dim]\n")
+    for line in project_provenance_lines(project_state):
+        console.print(f"[dim]{line}[/dim]")
+    console.print()
+
+    # Track last pipeline output for slash commands
+    _last_result_output: str = ""
+
+    async def _input_reader() -> None:
+        """Background task: always shows a prompt and queues submitted commands."""
+        while True:
+            q = len(_queued_inputs)
+            proc_str = " ⋯" if _proc["active"] else ""
+            q_str = f" [{q}↑]" if q > 0 else ""
+            try:
+                raw = await prompt_session.prompt_async(
+                    f"polymath{proc_str}{q_str} > "
+                )
+                _queued_inputs.append(raw.strip() if raw else "")
+                _queue_ready.set()
+            except (EOFError, KeyboardInterrupt):
+                _queued_inputs.append(None)  # sentinel → exit
+                _queue_ready.set()
+                return
+
+    # ── patch_stdout: all console output renders ABOVE the prompt line ────────
+    with patch_stdout():
+
+      # ── Smart resume ────────────────────────────────────────────────────
+      if active_project:
+        last = get_last_session_for_project(active_project)
+        if last and last["id"] != session_id:
+            if was_recent(last, hours=24):
+                ago = time_ago(last)
+                console.print(
+                    f'[yellow]Resume "[bold]{last["title"]}[/bold]" from {ago}?[/yellow] '
+                    f'[dim](y / n / list)[/dim]'
+                )
+                try:
+                    ans = (await prompt_session.prompt_async("  > ")).strip().lower()
+                    if ans == "y":
+                        session_id = last["id"]
+                        console.print(f"[dim]Resumed: {last['title']}[/dim]\n")
+                    elif ans == "list":
+                        sid = await _pick_session_interactive(active_project, prompt_session)
+                        if sid:
+                            session_id = sid
+                except (EOFError, KeyboardInterrupt):
+                    pass
+            else:
+                recent = get_recent_sessions(project=active_project, limit=5)
+                if len(recent) > 1:
+                    console.print(f"[dim]{len(recent)} previous sessions — /sessions to browse[/dim]\n")
+
+      # ── First-run memory migration prompt ──────────────────────────────────
+      if active_project:
+          try:
+              from polymath.memory.migrate import estimate, migrate_project
+              from polymath.memory.store import MemoryStore
+              _store = MemoryStore(active_project)
+              if _store.stats()["total"] == 0:
+                  _est = estimate(active_project)
+                  if _est["chunks"] > 0:
+                      console.print(
+                          f"[yellow]Found {_est['files']} context files (~{_est['chunks']} chunks) "
+                          f"not yet indexed for memory.[/yellow]"
+                      )
+                      console.print(
+                          "[dim]Migrate to chunked memory now? "
+                          "Free Gemini embedding tier (or OpenAI fallback). "
+                          "[bold](y / n)[/bold][/dim]"
+                      )
+                      try:
+                          _ans = (await prompt_session.prompt_async("  > ")).strip().lower()
+                          if _ans == "y":
+                              console.print("[dim]Indexing…[/dim]")
+                              _result = await migrate_project(active_project, cfg)
+                              if _result.error:
+                                  console.print(f"[red]Migration failed: {_result.error}[/red]")
+                                  console.print("[dim]You can retry later with /memory rebuild.[/dim]\n")
+                              else:
+                                  console.print(
+                                      f"[green]✓ Indexed {_result.chunks_indexed} chunks "
+                                      f"({_result.embed_provider}/{_result.embed_model}).[/green]\n"
+                                  )
+                          else:
+                              console.print("[dim]Skipped. Run /memory rebuild anytime.[/dim]\n")
+                      except (EOFError, KeyboardInterrupt):
+                          pass
+          except Exception:
+              pass
+
+      # ── Start background input reader ──────────────────────────────────────
+      _input_task = _asyncio.ensure_future(_input_reader())
+
+      async def _inline_prompt(prompt: str) -> str:
+        nonlocal _input_task
+        _input_task.cancel()
+        try:
+            await _input_task
+        except _asyncio.CancelledError:
+            pass
+        except Exception:
+            pass
+        try:
+            return (await prompt_session.prompt_async(prompt)).strip()
+        finally:
+            _input_task = _asyncio.ensure_future(_input_reader())
+
+      async def _command_permission(request: PermissionRequest) -> bool:
+        if is_preapproved(request, local_project):
+            return True
+        console.print(f"\n[bold yellow]Permission needed:[/bold yellow] {request.action}")
+        answer = await _inline_prompt("permission > ")
+        return answer.strip().lower() in ("y", "yes")
+
+      while True:
+        project_state = resolve_project(active_project)
+        local_project = project_state.local_project
+        # Get next command — typed now OR queued while we were processing
+        while not _queued_inputs:
+            await _queue_ready.wait()
+        raw = _queued_inputs.popleft()
+        if not _queued_inputs:
+            _queue_ready.clear()
+        if raw is None:
+            console.print("\n[dim]Goodbye.[/dim]")
+            break
+
+        text = raw
+        if not text:
+            continue
+
+        cmd_result = await handle_command(CommandServiceContext(
+            console=console,
+            text=text,
+            session_id=session_id,
+            active_project=active_project,
+            profile=profile,
+            cfg=cfg,
+            registry=registry,
+            local_project=local_project,
+            project_state=project_state,
+            cmds=_cmds,
+            subs=_subs,
+            queued_inputs=_queued_inputs,
+            last_output=_last_result_output,
+            prompt_session=prompt_session,
+            on_permission=_command_permission,
+            print_projects=_print_projects,
+            print_context_files=_print_context_files,
+            print_commands=_print_commands,
+            print_subagents=_print_subagents,
+            pick_session_interactive=_pick_session_interactive,
+            show_models=show_models,
+            run_wizard=run_wizard,
+        ))
+        if cmd_result.handled:
+            session_id = cmd_result.session_id or session_id
+            active_project = cmd_result.active_project
+            registry = cmd_result.registry or registry
+            local_project = cmd_result.local_project if cmd_result.local_project is not None else local_project
+            project_state = cmd_result.project_state or project_state
+            _cmds = cmd_result.cmds or _cmds
+            _subs = cmd_result.subs or _subs
+            if cmd_result.last_output is not None:
+                _last_result_output = cmd_result.last_output
+            if cmd_result.should_exit:
+                break
+            continue
+
+        # ── Parse flags & force-provider ──────────────────────────────────
+        explicit_ask = text.startswith("--ask ")
+        if explicit_ask:
+            text = text[6:].strip()
+
+        force_provider, text = _parse_force(text)
+        cheap, fast, verify, simplify, ensemble_flag, fanout_flag, text = _parse_flags(text)
+
+        if not text:
+            continue
+
+        # ── @context mention expansion ────────────────────────────────────
+        text, injected_ctx = _expand_context_mentions(text, active_project)
+        if injected_ctx:
+            console.print(f"[dim]@injected: {', '.join(injected_ctx)}[/dim]")
+
+        # ── Auto-name session from first message ───────────────────────────
+        session_info = get_session(session_id)
+        if session_info and session_info["title"].startswith("Session "):
+            auto_name_session(session_id, text)
+
+        # ── Classify + show processing indicator ──────────────────────────
+        task_type   = classify_task(text)
+        complexity  = classify_complexity(text)
+        decision = run_controller.decide(RunRequest(
+            text=text,
+            explicit_ask=explicit_ask,
+            task_type=task_type,
+            complexity=complexity,
+            verify=verify,
+            simplify=simplify,
+            profile=profile,
+            registry=registry,
+            ensemble=ensemble_flag or force_provider == "all",
+            fanout=fanout_flag,
+            force_provider=force_provider,
+        ))
+
+        if decision.strategy == ExecutionStrategy.STATE:
+            console.print()
+            console.print(decision.local_response)
+            _last_result_output = decision.local_response
+            continue
+
+        if decision.strategy == ExecutionStrategy.ENSEMBLE:
+            await _run_ensemble_flow(
+                console=console,
+                text=text,
+                session_id=session_id,
+                active_project=active_project,
+                registry=registry,
+                cfg=cfg,
+                ensemble_warned=cfg.setdefault("_ensemble_warned", False),
+            )
+            cfg["_ensemble_warned"] = True
+            continue
+
+        if decision.strategy == ExecutionStrategy.FANOUT:
+            await _run_fanout_flow(
+                console=console,
+                text=text,
+                session_id=session_id,
+                active_project=active_project,
+                registry=registry,
+                cfg=cfg,
+                profile=profile,
+            )
+            continue
+
+        is_ask = decision.strategy == ExecutionStrategy.CHAT
+
+        # ── Select models ─────────────────────────────────────────────────
+        model_resolution = await resolve_models(
+            registry=registry,
+            cfg=cfg,
+            session_id=session_id,
+            user_input=text,
+            active_project=active_project,
+            task_type=task_type,
+            profile=profile,
+            force_provider=force_provider if force_provider != "all" else "",
+            cheap=cheap,
+            fast=fast,
+            is_ask=is_ask,
+        )
+        primary_info = model_resolution.primary_info
+        primary_adapter = model_resolution.primary_adapter
+        reviewer_info = model_resolution.reviewer_info
+        reviewer_adapter = model_resolution.reviewer_adapter
+        summarizer_info = model_resolution.summarizer_info
+        summarizer_adapter = model_resolution.summarizer_adapter
+        estimated_prompt_tokens = model_resolution.estimated_prompt_tokens
+        if not primary_info or not primary_adapter:
+            console.print("[red]No models available. Run /setup to configure.[/red]")
+            continue
+
+        available_count = len([m for m in registry if m.available])
+        if not reviewer_info and not is_ask:
+            # Single model available — use it for review too, just warn the user
+            reviewer_info = primary_info
+            console.print(
+                f"[dim]only 1 model available — "
+                f"[bold]{primary_info.display_name}[/bold] will self-review. "
+                f"Add more models via /setup for cross-model review.[/dim]"
+            )
+
+        # Show which context files will be injected
+        if active_project:
+            ctx_files = TASK_CONTEXT_MAP.get(task_type, set())
+            if ctx_files:
+                console.print(f"[dim]context: {', '.join(sorted(ctx_files))}[/dim]")
+
+        current_primary = {"info": primary_info}
+        run_status = RunStatus(
+            phase="direct answer" if is_ask else f"{task_type.value} · {complexity.value}",
+            model=primary_info.display_name,
+            reviewer=reviewer_info.display_name if reviewer_info and reviewer_info.id != primary_info.id else "",
+            queue_count=len([q for q in _queued_inputs if q]),
+            context_line=(
+                f"primary context: ~{max(primary_info.context_window - estimated_prompt_tokens, 0)} "
+                f"tokens left / {primary_info.context_window}"
+            ),
+            note="[dim]starting run[/dim]",
+        )
+        last_status_signature = {"value": ""}
+
+        def render_status(force: bool = False) -> None:
+            signature = "|".join((
+                run_status.phase,
+                run_status.model,
+                run_status.reviewer,
+                str(run_status.queue_count),
+                run_status.context_line,
+                run_status.note,
+            ))
+            if not force and signature == last_status_signature["value"]:
+                return
+            last_status_signature["value"] = signature
+            console.print(render_run_status(run_status))
+
+        # ── UI callbacks ──────────────────────────────────────────────────
+        def on_step(step, content):
+            from polymath.pipeline import Step
+            info = current_primary["info"]
+            run_status.model = info.display_name
+            run_status.queue_count = len([q for q in _queued_inputs if q])
+            if step == Step.UNDERSTAND:
+                run_status.phase = "understand"
+                run_status.note = "[dim]building task understanding[/dim]"
+            elif step == Step.PLAN:
+                run_status.phase = "planning"
+                run_status.note = "[dim]drafting execution plan[/dim]"
+            elif step in (Step.CLARIFY_1, Step.CLARIFY_2):
+                run_status.phase = "clarifying"
+                run_status.note = "[dim]checking for missing information[/dim]"
+            elif step == Step.REASON:
+                run_status.phase = "reasoning"
+                run_status.note = "[dim]thinking through the next move[/dim]"
+            elif step == Step.ACT:
+                run_status.phase = "tool use"
+                run_status.note = f"[magenta]tool:[/magenta] {content}"
+            elif step == Step.OBSERVE:
+                run_status.phase = "tool observe"
+                run_status.note = "[dim]received tool output[/dim]"
+            elif step == Step.EXECUTE:
+                run_status.phase = "answering"
+                run_status.note = "[dim]streaming response[/dim]"
+            elif step == Step.REVIEW or step == Step.RE_REVIEW:
+                run_status.phase = "review"
+                if reviewer_info:
+                    run_status.reviewer = reviewer_info.display_name
+                run_status.note = "[dim]cross-checking with reviewer model[/dim]"
+            elif step == Step.CORRECTIONS:
+                run_status.phase = "corrections"
+                run_status.note = "[dim]applying reviewer feedback[/dim]"
+            elif step == Step.OUTPUT:
+                run_status.phase = "complete"
+                run_status.note = "[dim]finalizing output[/dim]"
+            render_status()
+
+        def on_token(token):
+            console.print(token, end="", highlight=False)
+
+        async def on_ask(question):
+            console.print(f"\n[bold yellow]?[/bold yellow] {question}")
+            return await _inline_prompt("clarify > ")
+
+        async def on_permission(request: PermissionRequest) -> bool:
+            if is_preapproved(request, local_project):
+                return True
+            console.print(f"\n[bold yellow]Permission needed:[/bold yellow] {request.action}")
+            answer = await _inline_prompt("permission > ")
+            return answer.strip().lower() in ("y", "yes")
+
+        async def on_plan_approval(plan: str) -> str:
+            console.print()
+            console.print(Panel(
+                Markdown(plan),
+                title="[bold cyan]Plan — approve to proceed[/bold cyan]",
+                border_style="cyan",
+            ))
+            console.print(
+                "[dim]y / proceed = execute  |  "
+                "refine: <feedback> = revise plan  |  "
+                "cancel = abort[/dim]"
+            )
+            answer = await _inline_prompt("plan > ")
+            if not answer or answer.lower() in ("y", "yes", "proceed"):
+                return "proceed"
+            if answer.lower() == "cancel":
+                return "cancel"
+            if answer.lower().startswith("refine:"):
+                return answer
+            return "proceed"
+
+        _proc["active"] = True
+        try:
+            render_status(force=True)
+            if is_ask:
+                exec_result = await run_ask_flow(
+                    text=text,
+                    session_id=session_id,
+                    active_project=active_project,
+                    task_type=task_type,
+                    primary_info=primary_info,
+                    primary_adapter=primary_adapter,
+                    summarizer_info=summarizer_info,
+                    summarizer_adapter=summarizer_adapter,
+                    profile=profile,
+                    cfg=cfg,
+                    registry=registry,
+                    print_line=lambda msg: (
+                        setattr(run_status, "note", msg.strip()),
+                        setattr(run_status, "queue_count", len([q for q in _queued_inputs if q])),
+                        render_status(),
+                    ),
+                    suppress_echo=_SuppressEcho,
+                    token_printer=lambda t: console.print(t, end="", highlight=False),
+                    on_model_switch=lambda info: (
+                        current_primary.__setitem__("info", info),
+                        setattr(run_status, "model", info.display_name),
+                        setattr(run_status, "note", f"[dim]switched to {info.display_name}[/dim]"),
+                        render_status(),
+                    ),
+                    attempt_ledger=decision.attempt_ledger,
+                    output_policy=output_policy,
+                )
+                console.print()
+                if exec_result.usage:
+                    _print_usage_bar(exec_result.usage)
+                console.print(render_completion_summary(CompletionSummary(
+                    session_id=session_id,
+                    primary_model=current_primary["info"].display_name,
+                    token_line="direct answer finished",
+                    queue_count=len([q for q in _queued_inputs if q]),
+                )))
+                continue
+
+            exec_result = await run_pipeline_flow(
+                text=text,
+                complexity=complexity,
+                task_type=task_type,
+                verify=verify,
+                simplify=simplify,
+                session_id=session_id,
+                active_project=active_project,
+                primary_info=primary_info,
+                primary_adapter=primary_adapter,
+                reviewer_info=reviewer_info,
+                reviewer_adapter=reviewer_adapter,
+                summarizer_info=summarizer_info,
+                summarizer_adapter=summarizer_adapter,
+                profile=profile,
+                cfg=cfg,
+                registry=registry,
+                subs=_subs,
+                callbacks=ExecutionCallbacks(
+                    on_step=on_step,
+                    on_token=on_token,
+                    on_ask=on_ask,
+                    on_permission=on_permission,
+                    on_plan_approval=on_plan_approval,
+                    on_model_switch=lambda info: (
+                        current_primary.__setitem__("info", info),
+                        setattr(run_status, "model", info.display_name),
+                        setattr(run_status, "note", f"[dim]switched to {info.display_name}[/dim]"),
+                        render_status(),
+                    ),
+                ),
+                print_line=lambda msg: (
+                    setattr(run_status, "note", msg.strip()),
+                    setattr(run_status, "queue_count", len([q for q in _queued_inputs if q])),
+                    render_status(),
+                ),
+                render_panel=lambda body, title: console.print(Panel(Markdown(body), title=f"[bold]{title}[/bold]", border_style="dim")),
+                suppress_echo=_SuppressEcho,
+                session_cost=session_cost,
+                attempt_ledger=decision.attempt_ledger,
+                output_policy=output_policy,
+            )
+            _last_result_output = exec_result.last_output or _last_result_output
+            if exec_result.usage:
+                _print_usage_bar(exec_result.usage)
+            if exec_result.summary_line:
+                console.print(exec_result.summary_line)
+            console.print(render_completion_summary(CompletionSummary(
+                session_id=session_id,
+                primary_model=current_primary["info"].display_name,
+                reviewer_model=reviewer_info.display_name if reviewer_info and reviewer_info.id != current_primary["info"].id else "",
+                token_line=exec_result.summary_line.replace("[dim]", "").replace("[/dim]", "") if exec_result.summary_line else "",
+                queue_count=len([q for q in _queued_inputs if q]),
+            )))
+            if exec_result.notify_message:
+                _notify("polymath", exec_result.notify_message)
+        except Exception as e:
+            console.print(f"\n[red]Error: {e}[/red]")
+            if os.environ.get("POLYMATH_DEBUG"):
+                import traceback
+                traceback.print_exc()
+            else:
+                console.print("[dim]Set POLYMATH_DEBUG=1 for a traceback.[/dim]")
+        finally:
+            _proc["active"] = False
+        continue
+
+      # ── Clean up input reader on exit ──────────────────────────────────────
+      _input_task.cancel()
+      try:
+          await _input_task
+      except (_asyncio.CancelledError, Exception):
+          pass
+
+
+async def _pick_session_interactive(project: str, prompt_session) -> str:
+    """Show numbered session list and return chosen session_id, or '' to skip."""
+    sessions = get_recent_sessions(project=project, limit=10)
+    if not sessions:
+        console.print("[dim]No previous sessions.[/dim]")
+        return ""
+
+    from rich.table import Table
+    from rich import box as rbox
+    table = Table(box=rbox.SIMPLE, show_header=True)
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Session name", style="cyan")
+    table.add_column("Last active")
+    for i, s in enumerate(sessions, 1):
+        table.add_row(str(i), s["title"], time_ago(s))
+    console.print(table)
+
+    try:
+        ans = (await prompt_session.prompt_async("  Resume # (or Enter to skip) > ")).strip()
+        if ans.isdigit():
+            idx = int(ans) - 1
+            if 0 <= idx < len(sessions):
+                chosen = sessions[idx]
+                console.print(f"[dim]Resumed: {chosen['title']}[/dim]\n")
+                return chosen["id"]
+    except (EOFError, KeyboardInterrupt):
+        pass
+    return ""
+
+
+async def run_ask(question: str, project: str, cfg: dict) -> None:
+    """One-shot ask from CLI — no REPL, no pipeline."""
+    registry = detect()
+    profile = cfg.get("priority_profile", "quality-first")
+    output_policy = OutputPolicy()
+    run_controller = RunController(output_policy=output_policy)
+
+    task_type = classify_task(question)
+    complexity = classify_complexity(question)
+    decision = run_controller.decide(RunRequest(
+        text=question,
+        explicit_ask=True,
+        task_type=task_type,
+        complexity=complexity,
+        verify=False,
+        simplify=False,
+        profile=profile,
+        registry=registry,
+    ))
+    if decision.strategy == ExecutionStrategy.STATE:
+        console.print(decision.local_response)
+        return
+    model_resolution = await resolve_models(
+        registry=registry,
+        cfg=cfg,
+        session_id="",
+        user_input=question,
+        active_project=project,
+        task_type=task_type,
+        profile=profile,
+        is_ask=True,
+    )
+    primary_info = model_resolution.primary_info
+    primary_adapter = model_resolution.primary_adapter
+    summarizer_info = model_resolution.summarizer_info
+    summarizer_adapter = model_resolution.summarizer_adapter
+    estimated_prompt_tokens = model_resolution.estimated_prompt_tokens
+    if not primary_info or not primary_adapter:
+        console.print("[red]No models available. Run polymath --setup[/red]")
+        return
+    available_count = len([m for m in registry if m.available])
+    if available_count == 1:
+        console.print(
+            f"[dim]only 1 model available — {primary_info.display_name}[/dim]"
+        )
+
+    # Use last session for project, or create a fresh one
+    if project:
+        last = get_last_session_for_project(project)
+        session_id = last["id"] if last else new_session_for_project(project)
+    else:
+        session_id = new_session()
+
+    session_info = get_session(session_id)
+    if session_info:
+        console.print(f"[dim]session: {session_info['title']}[/dim]")
+
+    color = MODEL_COLORS.get(primary_info.provider, "white")
+    console.print(f"[bold {color}]{primary_info.display_name}[/bold {color}]", end=" ")
+    console.print(
+        f"\n[dim]primary context: ~{max(primary_info.context_window - estimated_prompt_tokens, 0)} "
+        f"tokens left / {primary_info.context_window}[/dim]"
+    )
+
+    exec_result = await run_ask_flow(
+        text=question,
+        session_id=session_id,
+        active_project=project,
+        task_type=task_type,
+        primary_info=primary_info,
+        primary_adapter=primary_adapter,
+        summarizer_info=summarizer_info,
+        summarizer_adapter=summarizer_adapter,
+        profile=profile,
+        cfg=cfg,
+        registry=registry,
+        print_line=lambda msg: console.print(msg),
+        suppress_echo=_SuppressEcho,
+        token_printer=lambda t: console.print(t, end="", highlight=False),
+        attempt_ledger=decision.attempt_ledger,
+        output_policy=output_policy,
+    )
+    console.print()
+    if exec_result.usage:
+        _print_usage_bar(exec_result.usage)
+
+
+def _print_projects() -> None:
+    projects = list_projects()
+    if not projects:
+        console.print("[dim]No projects yet. Use /project new <name>[/dim]")
+        return
+    from rich.table import Table
+    from rich import box as rbox
+    table = Table(box=rbox.SIMPLE, show_header=True)
+    table.add_column("Name", style="cyan")
+    table.add_column("Description")
+    table.add_column("Created")
+    for p in projects:
+        table.add_row(p["name"], p.get("description", ""), p.get("created_at", "")[:10])
+    console.print(table)
+
+
+def _print_context_files(project: str) -> None:
+    files = list_context_files(project)
+    from rich.table import Table
+    from rich import box as rbox
+    table = Table(title=f"Context — {project}", box=rbox.SIMPLE)
+    table.add_column("File", style="cyan")
+    table.add_column("Description", style="dim")
+    table.add_column("Size", justify="right")
+    table.add_column("Preview")
+    for f in files:
+        size = f"[green]{f['size']}b[/green]" if f["size"] else "[dim]empty[/dim]"
+        table.add_row(f["name"], f["description"], size, f["preview"])
+    console.print(table)
+    console.print("[dim]/context show <name>  •  /context add <name> <entry>[/dim]")
+
+
+
+def _print_commands(cmds: dict) -> None:
+    from rich.table import Table
+    from rich import box as rbox
+    table = Table(box=rbox.SIMPLE, show_header=True, title="Slash Commands")
+    table.add_column("Command", style="cyan")
+    table.add_column("Description")
+    table.add_column("Source", style="dim")
+    for name, cmd in sorted(cmds.items()):
+        table.add_row(f"/{name}", cmd.description, cmd.source)
+    console.print(table)
+
+
+def _print_subagents(subs: dict) -> None:
+    from rich.table import Table
+    from rich import box as rbox
+    table = Table(box=rbox.SIMPLE, show_header=True, title="Subagents")
+    table.add_column("Name", style="cyan")
+    table.add_column("Description")
+    table.add_column("Trigger", style="dim")
+    table.add_column("Source", style="dim")
+    for name, sa in sorted(subs.items()):
+        triggers = ", ".join(t.value for t in sa.trigger_on) if sa.trigger_on else "explicit only"
+        table.add_row(name, sa.description, triggers, sa.source)
+    console.print(table)
+    console.print("[dim]Use --verify, --simplify, etc. to trigger. Run /subagents for full list.[/dim]")
+
+
+def main() -> None:
+    import argparse
+    parser = argparse.ArgumentParser(prog="polymath", description="Multi-model AI orchestrator")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # polymath ask "question"
+    ask_parser = subparsers.add_parser("ask", help="One-shot question, no REPL")
+    ask_parser.add_argument("question", nargs="+", help="The question to ask")
+    ask_parser.add_argument("--project", metavar="NAME", help="Detached local project context to use")
+
+    parser.add_argument("--setup",    action="store_true", help="Re-run setup wizard")
+    parser.add_argument("--models",   action="store_true", help="List available models")
+    parser.add_argument("--sessions", action="store_true", help="List sessions")
+    parser.add_argument("--session",  metavar="ID",        help="Resume session by ID")
+    parser.add_argument("--project",  metavar="NAME",      help="Start with detached local project")
+    args = parser.parse_args()
+
+    init_db()
+    cfg = load_config()
+    repo_project_state = resolve_project("")
+
+    # ── polymath ask "question" ────────────────────────────────────────────
+    if args.command == "ask":
+        question = " ".join(args.question)
+        project  = args.project or ""
+        if project and not get_project_meta(project):
+            console.print(f"[red]Detached local project not found: {project}[/red]")
+            console.print("[dim]Use /project new <name> in the REPL, or omit --project to use repo-backed .polymath/ context.[/dim]")
+            return
+        if not project and repo_project_state.shared and repo_project_state.name:
+            project = repo_project_state.name
+        asyncio.run(run_ask(question, project, cfg))
+        return
+
+    # ── Non-interactive flags ──────────────────────────────────────────────
+    if args.models:
+        show_models()
+        return
+
+    if args.sessions:
+        sessions = list_sessions()
+        if not sessions:
+            console.print("[dim]No sessions yet.[/dim]")
+        else:
+            from rich.table import Table
+            from rich import box as rbox
+            table = Table(box=rbox.SIMPLE, show_header=True)
+            table.add_column("ID", style="cyan")
+            table.add_column("Title")
+            table.add_column("Last active")
+            for s in sessions:
+                table.add_row(s["id"], s["title"], time_ago(s))
+            console.print(table)
+        return
+
+    if args.setup or not cfg.get("_setup_done"):
+        cfg = run_wizard(force=args.setup)
+
+    project = args.project or ""
+    if project and not get_project_meta(project):
+        console.print(f"[red]Detached local project not found: {project}[/red]")
+        console.print("[dim]Use /project new <name> in the REPL, or run without --project to use repo-backed .polymath/ context.[/dim]")
+        return
+    if not project and args.session:
+        session = get_session(args.session)
+        if session and (session.get("project") or "").strip():
+            project = (session.get("project") or "").strip()
+    if not project and repo_project_state.shared and repo_project_state.name:
+        project = repo_project_state.name
+    if project:
+        sid = args.session or new_session_for_project(project)
+    else:
+        sid = args.session or new_session()
+    asyncio.run(run_session(sid, cfg, active_project=project))
+
+
+if __name__ == "__main__":
+    main()