polymath-agent 0.4.0__py3-none-any.whl

polymath/command_service.py

@@ -0,0 +1,572 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable
+
+from rich.markdown import Markdown
+from rich.panel import Panel
+
+from polymath.command_registry import build_repl_completer
+from polymath.domain import PermissionRequest
+from polymath.context_manager import append_context, get_project_meta, list_context_files, read_context, write_context
+from polymath.context_store import (
+    delete_session,
+    get_last_session_for_project,
+    get_session,
+    new_session,
+    new_session_for_project,
+    set_session_project,
+)
+from polymath.detector import detect, invalidate_cache, list_gemini_accounts, switch_gemini_account
+from polymath.model_policy import resolve_models
+from polymath.project_runtime import project_provenance_lines, resolve_project
+from polymath.slash_commands import get_all_commands, run_command as run_slash_cmd
+from polymath.subagents import get_subagents
+from polymath.ui_state import render_queue_table
+
+
+@dataclass
+class CommandServiceContext:
+    console: Any
+    text: str
+    session_id: str
+    active_project: str
+    profile: str
+    cfg: dict
+    registry: list[Any]
+    local_project: Any
+    project_state: Any
+    cmds: dict[str, Any]
+    subs: dict[str, Any]
+    queued_inputs: Any
+    last_output: str
+    prompt_session: Any
+    on_permission: Callable[[PermissionRequest], Awaitable[bool] | bool]
+    print_projects: Callable[[], None]
+    print_context_files: Callable[[str], None]
+    print_commands: Callable[[dict[str, Any]], None]
+    print_subagents: Callable[[dict[str, Any]], None]
+    pick_session_interactive: Callable[[str, Any], Awaitable[str]]
+    show_models: Callable[[], None]
+    run_wizard: Callable[..., dict]
+
+
+@dataclass
+class CommandServiceResult:
+    handled: bool = False
+    should_exit: bool = False
+    session_id: str = ""
+    active_project: str = ""
+    registry: list[Any] | None = None
+    local_project: Any = None
+    project_state: Any = None
+    cmds: dict[str, Any] | None = None
+    subs: dict[str, Any] | None = None
+    last_output: str | None = None
+
+
+async def handle_command(ctx: CommandServiceContext) -> CommandServiceResult:
+    text = ctx.text
+    result = CommandServiceResult(
+        handled=True,
+        session_id=ctx.session_id,
+        active_project=ctx.active_project,
+        registry=ctx.registry,
+        local_project=ctx.local_project,
+        project_state=ctx.project_state,
+        cmds=ctx.cmds,
+        subs=ctx.subs,
+        last_output=ctx.last_output,
+    )
+
+    if text == "/exit":
+        ctx.console.print("[dim]Goodbye.[/dim]")
+        result.should_exit = True
+        return result
+    if text == "/models":
+        ctx.show_models()
+        return result
+    if text == "/sessions":
+        sid = await ctx.pick_session_interactive(ctx.active_project, ctx.prompt_session)
+        if sid:
+            session = get_session(sid)
+            if session:
+                result.session_id = sid
+                session_project = (session.get("project") or "").strip()
+                if session_project:
+                    result.active_project = session_project
+                result.project_state = resolve_project(result.active_project)
+                result.local_project = result.project_state.local_project
+                result.cmds = get_all_commands(result.local_project.commands_dir if result.local_project else None)
+                result.subs = get_subagents(result.local_project.subagents_dir if result.local_project else None)
+                ctx.prompt_session.completer = build_repl_completer(list(result.cmds.keys()))
+        return result
+    if text == "/new":
+        result.session_id = new_session_for_project(ctx.active_project) if ctx.active_project else new_session()
+        ctx.console.print(f"[dim]New session: {result.session_id}[/dim]")
+        return result
+    if text.startswith("/session delete "):
+        sid = text[16:].strip()
+        if delete_session(sid):
+            ctx.console.print(f"[dim]Deleted session: {sid}[/dim]")
+            if result.session_id == sid:
+                result.session_id = new_session_for_project(ctx.active_project) if ctx.active_project else new_session()
+                ctx.console.print(f"[dim]Started new session: {result.session_id}[/dim]")
+        else:
+            ctx.console.print(f"[red]Session not found: {sid}[/red]")
+        return result
+    if text.startswith("/session "):
+        sid = text[9:].strip()
+        session = get_session(sid)
+        if session:
+            result.session_id = sid
+            session_project = (session.get("project") or "").strip()
+            if session_project:
+                result.active_project = session_project
+            result.project_state = resolve_project(result.active_project)
+            result.local_project = result.project_state.local_project
+            result.cmds = get_all_commands(result.local_project.commands_dir if result.local_project else None)
+            result.subs = get_subagents(result.local_project.subagents_dir if result.local_project else None)
+            ctx.prompt_session.completer = build_repl_completer(list(result.cmds.keys()))
+            ctx.console.print(f"[dim]Resumed session: {sid} — {session['title']}[/dim]")
+        else:
+            ctx.console.print(f"[red]Session not found: {sid}[/red]")
+        return result
+    if text == "/help":
+        import polymath.main as main_mod
+        ctx.console.print(Markdown(main_mod.__doc__))
+        return result
+    if text == "/state":
+        ctx.console.print(f"[dim]session:[/dim] [bold]{ctx.session_id}[/bold]")
+        ctx.console.print(f"[dim]project:[/dim] [bold]{ctx.project_state.name or '-'}[/bold] ({ctx.project_state.source})")
+        for line in project_provenance_lines(ctx.project_state):
+            ctx.console.print(f"[dim]{line}[/dim]")
+        if ctx.active_project:
+            ctx_files = list_context_files(ctx.active_project)
+            loaded = [c["name"] for c in ctx_files if c["size"] > 0]
+            ctx.console.print(f"[dim]context files:[/dim] {', '.join(loaded) if loaded else '(empty)'}")
+        cmd_sources = ", ".join(f"/{name}:{cmd.source}" for name, cmd in sorted(ctx.cmds.items()))
+        sub_sources = ", ".join(f"{name}:{cfg.source}" for name, cfg in sorted(ctx.subs.items()))
+        ctx.console.print(f"[dim]commands:[/dim] {cmd_sources if cmd_sources else '(none)'}")
+        ctx.console.print(f"[dim]subagents:[/dim] {sub_sources if sub_sources else '(none)'}")
+        if ctx.local_project:
+            allowed = ctx.local_project.settings.allowed_tools or []
+            ctx.console.print(f"[dim]allowed tools:[/dim] {', '.join(allowed) if allowed else '(prompt for all)'}")
+        return result
+    if text == "/queue":
+        queued_only = [q for q in ctx.queued_inputs if q]
+        if not queued_only:
+            ctx.console.print("[dim]Queue is empty.[/dim]")
+        else:
+            ctx.console.print(render_queue_table(queued_only))
+        return result
+    if text.startswith("/queue drop "):
+        idx_str = text[12:].strip()
+        queued_positions = [i for i, item in enumerate(ctx.queued_inputs) if item]
+        if idx_str.isdigit():
+            idx = int(idx_str) - 1
+            if 0 <= idx < len(queued_positions):
+                del ctx.queued_inputs[queued_positions[idx]]
+                ctx.console.print(f"[dim]Dropped queued command #{idx + 1}[/dim]")
+            else:
+                ctx.console.print("[red]Queue index out of range.[/red]")
+        else:
+            ctx.console.print("[dim]Usage: /queue drop <n>[/dim]")
+        return result
+    if text.startswith("/queue move "):
+        parts = text.split()
+        queued_positions = [i for i, item in enumerate(ctx.queued_inputs) if item]
+        if len(parts) == 4 and parts[2].isdigit() and parts[3].isdigit():
+            src = int(parts[2]) - 1
+            dst = int(parts[3]) - 1
+            if 0 <= src < len(queued_positions) and 0 <= dst < len(queued_positions):
+                queue_list = list(ctx.queued_inputs)
+                item = queue_list.pop(queued_positions[src])
+                queued_without_item = [i for i, value in enumerate(queue_list) if value]
+                insert_at = len(queue_list) if dst >= len(queued_without_item) else queued_without_item[dst]
+                queue_list.insert(insert_at, item)
+                ctx.queued_inputs.clear()
+                ctx.queued_inputs.extend(queue_list)
+                ctx.console.print(f"[dim]Moved queued command {src + 1} -> {dst + 1}[/dim]")
+            else:
+                ctx.console.print("[red]Queue indices out of range.[/red]")
+        else:
+            ctx.console.print("[dim]Usage: /queue move <from> <to>[/dim]")
+        return result
+    if text.startswith("/setup"):
+        ctx.run_wizard(force=True)
+        result.registry = detect()
+        return result
+    if text == "/project list":
+        if ctx.project_state.shared:
+            ctx.console.print("[dim]Repo-first mode: current git repo is the primary project.[/dim]")
+        ctx.print_projects()
+        return result
+    if text.startswith("/project new "):
+        pname = text[13:].strip()
+        if pname:
+            from polymath.context_manager import create_project
+            create_project(pname)
+            result.active_project = pname
+            result.session_id = new_session_for_project(pname)
+            result.project_state = resolve_project(result.active_project)
+            result.local_project = result.project_state.local_project
+            result.cmds = get_all_commands(result.local_project.commands_dir if result.local_project else None)
+            result.subs = get_subagents(result.local_project.subagents_dir if result.local_project else None)
+            ctx.prompt_session.completer = build_repl_completer(list(result.cmds.keys()))
+            ctx.console.print(f"[green]Created detached local project:[/green] {pname}")
+            ctx.console.print("[dim]Repo-first mode still prefers .polymath/ in the current git repo when present.[/dim]")
+        return result
+    if text.startswith("/project use "):
+        pname = text[13:].strip()
+        meta = get_project_meta(pname)
+        if meta:
+            result.active_project = pname
+            last = get_last_session_for_project(pname)
+            if last:
+                result.session_id = last["id"]
+                ctx.console.print(f"[dim]Switched to detached local project: [bold]{pname}[/bold] • resumed {last['title']}[/dim]")
+            else:
+                result.session_id = new_session_for_project(pname)
+                ctx.console.print(f"[dim]Switched to detached local project: [bold]{pname}[/bold] • started new session[/dim]")
+            result.project_state = resolve_project(result.active_project)
+            result.local_project = result.project_state.local_project
+            result.cmds = get_all_commands(result.local_project.commands_dir if result.local_project else None)
+            result.subs = get_subagents(result.local_project.subagents_dir if result.local_project else None)
+            ctx.prompt_session.completer = build_repl_completer(list(result.cmds.keys()))
+        else:
+            ctx.console.print(f"[red]Project not found: {pname}[/red]")
+        return result
+    if text == "/project":
+        if ctx.project_state.shared:
+            ctx.console.print(f"[dim]Repo project: [bold]{ctx.project_state.name}[/bold][/dim]")
+            for line in project_provenance_lines(ctx.project_state):
+                ctx.console.print(f"[dim]{line}[/dim]")
+        elif ctx.active_project:
+            ctx.console.print(f"[dim]Detached local project: [bold]{ctx.active_project}[/bold][/dim]")
+            ctx.print_context_files(ctx.active_project)
+        else:
+            ctx.console.print("[dim]No active project. Preferred flow: run /project init inside a git repo.[/dim]")
+        return result
+    if text == "/context":
+        if not ctx.active_project:
+            ctx.console.print("[red]No active project. Preferred flow: /project init in a repo.[/red]")
+        else:
+            ctx.print_context_files(ctx.active_project)
+        return result
+    if text.startswith("/context show "):
+        ctx_name = text[14:].strip()
+        if not ctx.active_project:
+            ctx.console.print("[red]No active project.[/red]")
+        else:
+            content = read_context(ctx.active_project, ctx_name)
+            ctx.console.print(Panel(content or "(empty)", title=f"[bold]{ctx_name}[/bold]"))
+        return result
+    if text.startswith("/context add "):
+        parts = text[13:].strip().split(" ", 1)
+        if len(parts) == 2 and ctx.active_project:
+            ctx_name, entry = parts
+            append_context(ctx.active_project, ctx_name, entry)
+            ctx.console.print(f"[green]Added to {ctx_name}[/green]")
+            await _sync_memory_quiet(ctx, ctx_name)
+        else:
+            ctx.console.print("[dim]Usage: /context add <type> <entry>[/dim]")
+        return result
+    if text.startswith("/context edit "):
+        ctx_name = text[14:].strip()
+        if not ctx.active_project:
+            ctx.console.print("[red]No active project.[/red]")
+            return result
+        from polymath.context_manager import context_dir
+        import os
+        import subprocess as sp
+        editor = os.environ.get("EDITOR", "")
+        ctx_path = context_dir(ctx.active_project) / f"{ctx_name}.md"
+        if editor:
+            sp.run([editor, str(ctx_path)])
+            ctx.console.print("[green]Saved.[/green]")
+            await _sync_memory_quiet(ctx, ctx_name)
+        else:
+            current = read_context(ctx.active_project, ctx_name)
+            ctx.console.print(Panel(current or "(empty)", title=f"[bold]{ctx_name}[/bold] — current content"))
+            ctx.console.print("[dim]Paste new content, then type ### on its own line to save.[/dim]")
+            lines = []
+            while True:
+                line = await ctx.prompt_session.prompt_async("")
+                if line.strip() == "###":
+                    break
+                lines.append(line)
+            if lines:
+                write_context(ctx.active_project, ctx_name, "\n".join(lines) + "\n")
+                ctx.console.print(f"[green]Saved {ctx_name}.[/green]")
+                await _sync_memory_quiet(ctx, ctx_name)
+        return result
+    if text == "/project init":
+        from polymath.project_config import init_local_project
+        from polymath.slash_commands import get_all_commands
+        from polymath.subagents import get_subagents
+        lp = init_local_project()
+        ctx.console.print(f"[green]Created .polymath/ in {lp.root.parent}[/green]")
+        result.local_project = lp
+        result.active_project = lp.root.parent.name
+        if get_session(result.session_id) and result.active_project:
+            set_session_project(result.session_id, result.active_project)
+        result.project_state = resolve_project(result.active_project)
+        result.cmds = get_all_commands(lp.commands_dir)
+        result.subs = get_subagents(lp.subagents_dir)
+        ctx.prompt_session.completer = build_repl_completer(list(result.cmds.keys()))
+        return result
+    if text == "/commands":
+        ctx.print_commands(ctx.cmds)
+        return result
+    if text == "/parallel":
+        import polymath.main as main_mod
+        n = main_mod._active_polymath_sessions()
+        if n == 0:
+            ctx.console.print("[dim]No other polymath sessions running.[/dim]")
+        else:
+            ctx.console.print(f"[cyan]{n} other polymath session{'s' if n != 1 else ''} running.[/cyan]")
+        return result
+    if text == "/subagents":
+        ctx.print_subagents(ctx.subs)
+        return result
+    if text.startswith("/accounts"):
+        acct_args = text[9:].strip()
+        gemini_accts = list_gemini_accounts()
+        if acct_args.startswith("switch "):
+            switch_target = acct_args[7:].strip()
+            if switch_target.lower() == "claude":
+                ctx.console.print("[yellow]Claude Code supports one account at a time.[/yellow]")
+                invalidate_cache()
+                result.registry = detect(force=True)
+            elif switch_target.lower() == "openai":
+                ctx.console.print("[yellow]Codex supports one account at a time.[/yellow]")
+                invalidate_cache()
+                result.registry = detect(force=True)
+            elif switch_target.lower().startswith("gemini"):
+                email = switch_target[6:].strip()
+                if email and switch_gemini_account(email):
+                    ctx.console.print(f"[green]Switched Gemini account to {email}.[/green]")
+                    result.registry = detect(force=True)
+                else:
+                    ctx.console.print(f"[red]Unknown Gemini account: {email}[/red]")
+        else:
+            from rich.table import Table
+            tbl = Table(title="Authenticated Accounts", show_header=True, header_style="bold cyan")
+            tbl.add_column("Provider", style="cyan")
+            tbl.add_column("Account", style="white")
+            tbl.add_column("Status", style="dim")
+            tbl.add_column("Switch", style="dim")
+            claude_avail = any(m.provider == "claude" and m.available for m in ctx.registry)
+            tbl.add_row("claude", "keychain / env", "[green]active[/green]" if claude_avail else "[dim]not detected[/dim]", "/accounts switch claude")
+            if gemini_accts["active"]:
+                tbl.add_row("gemini", gemini_accts["active"], "[green]active[/green]", "—")
+            for old_acct in gemini_accts["old"]:
+                tbl.add_row("gemini", old_acct, "[dim]available[/dim]", f"/accounts switch gemini {old_acct}")
+            oai_avail = any(m.provider == "openai" and m.available for m in ctx.registry)
+            tbl.add_row("openai", "codex auth", "[green]active[/green]" if oai_avail else "[dim]not detected[/dim]", "/accounts switch openai")
+            ctx.console.print(tbl)
+        return result
+
+    if text.startswith("/memory"):
+        await _handle_memory(ctx, text)
+        return result
+
+    if text.startswith("/") and not any(text.startswith(p) for p in (
+        "/exit", "/models", "/sessions", "/session", "/new", "/project",
+        "/context", "/setup", "/help", "/commands", "/subagents", "/artifact",
+        "/parallel", "/accounts", "/state", "/queue", "/memory",
+    )):
+        parts = text[1:].split(None, 1)
+        cmd_name = parts[0].lower()
+        cmd_args = parts[1] if len(parts) > 1 else ""
+        if cmd_name not in ctx.cmds:
+            ctx.console.print(f"[red]Unknown command: /{cmd_name}  (use /commands to list)[/red]")
+            return result
+        from polymath.router import classify_task
+        model_resolution = await resolve_models(
+            registry=ctx.registry,
+            cfg=ctx.cfg,
+            session_id=ctx.session_id,
+            user_input=cmd_args or ctx.last_output or cmd_name,
+            active_project=ctx.active_project,
+            task_type=classify_task(cmd_args or ctx.last_output),
+            profile=ctx.profile,
+            is_ask=True,
+        )
+        pi = model_resolution.primary_info
+        pa = model_resolution.primary_adapter
+        if not pi or not pa:
+            ctx.console.print("[red]No models available for slash command.[/red]")
+            return result
+        output = await run_slash_cmd(
+            cmd=ctx.cmds[cmd_name],
+            session_id=ctx.session_id,
+            primary_adapter=pa,
+            primary_model=pi,
+            last_output=ctx.last_output,
+            on_token=lambda t: ctx.console.print(t, end="", highlight=False),
+            on_permission=ctx.on_permission,
+            active_project=ctx.active_project,
+            cmd_args=cmd_args,
+        )
+        ctx.console.print()
+        if output:
+            ctx.console.print(Panel(output, title=f"[bold]/{cmd_name}[/bold]", border_style="dim"))
+        result.last_output = output
+        return result
+
+    result.handled = False
+    return result
+
+
+async def _sync_memory_quiet(ctx: CommandServiceContext, ctx_name: str) -> None:
+    """Re-index a context file after edit. Quiet on missing embedder."""
+    if not ctx.active_project:
+        return
+    from polymath.memory.store import MemoryStore
+    if MemoryStore(ctx.active_project).stats()["total"] == 0:
+        return  # memory not initialized yet; user will run /memory rebuild
+    from polymath.memory.sync import sync_source
+    res = await sync_source(ctx.active_project, ctx_name, ctx.cfg)
+    if res.error:
+        ctx.console.print(f"[dim](memory sync skipped: {res.error.splitlines()[0]})[/dim]")
+    elif res.indexed:
+        ctx.console.print(f"[dim](memory: re-indexed {res.indexed} chunks)[/dim]")
+
+
+async def _handle_memory(ctx: CommandServiceContext, text: str) -> None:
+    """Handle /memory subcommands. Operates on ctx.active_project."""
+    from rich.table import Table
+
+    from polymath.memory.migrate import estimate, migrate_project
+    from polymath.memory.retriever import retrieve
+    from polymath.memory.store import MemoryStore
+    from polymath.memory.writer import preview as writeback_preview
+
+    if not ctx.active_project:
+        ctx.console.print("[yellow]No active project. Use /project use <name> first.[/yellow]")
+        return
+
+    args = text[len("/memory"):].strip()
+
+    if args in ("", "show"):
+        store = MemoryStore(ctx.active_project)
+        stats = store.stats()
+        manifest = stats["manifest"]
+        if stats["total"] == 0:
+            est = estimate(ctx.active_project)
+            ctx.console.print(
+                f"[dim]No memory yet for [bold]{ctx.active_project}[/bold]. "
+                f"{est['files']} context file(s), ~{est['chunks']} chunks ready to index.[/dim]"
+            )
+            ctx.console.print("[dim]Run [bold]/memory rebuild[/bold] to index.[/dim]")
+            return
+        tbl = Table(title=f"Memory — {ctx.active_project}", show_header=True, header_style="bold cyan")
+        tbl.add_column("Type", style="cyan")
+        tbl.add_column("Confirmed", justify="right")
+        tbl.add_column("Candidate", justify="right")
+        for type_name, counts in stats["by_type"].items():
+            tbl.add_row(type_name, str(counts.get("confirmed", 0)), str(counts.get("candidate", 0)))
+        ctx.console.print(tbl)
+        provider = manifest.get("embed_provider", "?")
+        model = manifest.get("embed_model", "?")
+        dim = manifest.get("embed_dim", "?")
+        last = manifest.get("last_writeback_at") or manifest.get("updated_at") or "—"
+        ctx.console.print(f"[dim]Embedder: {provider} · {model} ({dim}d) · last write: {last}[/dim]")
+        ctx.console.print(f"[dim]Location: {store.location.root}[/dim]")
+        return
+
+    if args == "rebuild":
+        ctx.console.print("[dim]Re-chunking and re-embedding all context files…[/dim]")
+        result = await migrate_project(ctx.active_project, ctx.cfg)
+        if result.error:
+            ctx.console.print(f"[red]Rebuild failed: {result.error}[/red]")
+            return
+        ctx.console.print(
+            f"[green]Indexed {result.chunks_indexed} chunks across {result.files_processed} files "
+            f"using {result.embed_provider} / {result.embed_model}.[/green]"
+        )
+        return
+
+    if args.startswith("search "):
+        query = args[len("search "):].strip()
+        if not query:
+            ctx.console.print("[yellow]Usage: /memory search <query>[/yellow]")
+            return
+        from polymath.config import TaskType
+        res = await retrieve(ctx.active_project, query, TaskType.GENERAL, ctx.cfg, k=8)
+        if not res.used_memory:
+            ctx.console.print(f"[yellow]Memory unavailable: {res.fallback_reason}[/yellow]")
+            return
+        if not res.chunks:
+            ctx.console.print("[dim]No matches.[/dim]")
+            return
+        for chunk in res.chunks:
+            heading = " > ".join(chunk.heading_path) if chunk.heading_path else "(top)"
+            tag = "[green]✓[/green]" if chunk.status == "confirmed" else "[yellow]?[/yellow]"
+            ctx.console.print(f"{tag} [bold]{chunk.type}[/bold] · {heading} · {chunk.id}")
+            preview_text = chunk.content.replace("\n", " ")[:160]
+            ctx.console.print(f"   [dim]{preview_text}…[/dim]")
+        return
+
+    if args.startswith("confirm "):
+        chunk_id = args[len("confirm "):].strip()
+        store = MemoryStore(ctx.active_project)
+        if store.update_status(chunk_id, "confirmed"):
+            ctx.console.print(f"[green]Promoted {chunk_id} to confirmed.[/green]")
+        else:
+            ctx.console.print(f"[red]Chunk {chunk_id} not found.[/red]")
+        return
+
+    if args == "test":
+        from polymath.memory.embedder import Embedder, EmbedderUnavailable
+        ctx.console.print("[dim]Testing embedder…[/dim]")
+        embedder = Embedder(ctx.cfg)
+        try:
+            res = await embedder.embed(["polymath memory smoke test"])
+        except EmbedderUnavailable as e:
+            ctx.console.print(f"[red]Embedder unavailable.[/red]\n[dim]{e}[/dim]")
+            return
+        sample = ", ".join(f"{v:.4f}" for v in res.vectors[0][:4])
+        ctx.console.print(
+            f"[green]✓ {res.provider} / {res.model} ({res.dim}d)[/green]"
+        )
+        ctx.console.print(f"[dim]first 4 dims: [{sample}, …][/dim]")
+        return
+
+    if args == "diff":
+        from polymath.router import classify_task
+        model_resolution = await resolve_models(
+            registry=ctx.registry,
+            cfg=ctx.cfg,
+            session_id=ctx.session_id,
+            user_input="memory writeback preview",
+            active_project=ctx.active_project,
+            task_type=classify_task(""),
+            profile=ctx.profile,
+            is_ask=True,
+        )
+        pi = model_resolution.primary_info
+        pa = model_resolution.primary_adapter
+        if not pi or not pa:
+            ctx.console.print("[red]No models available.[/red]")
+            return
+        candidates = await writeback_preview(
+            session_id=ctx.session_id,
+            project=ctx.active_project,
+            primary_adapter=pa,
+            primary_model_id=pi.id,
+            cfg=ctx.cfg,
+        )
+        if not candidates:
+            ctx.console.print("[dim]Nothing extractable from this session yet.[/dim]")
+            return
+        ctx.console.print(f"[cyan]Would extract {len(candidates)} candidate chunks:[/cyan]")
+        for c in candidates:
+            ctx.console.print(f"  [bold]{c['type']}[/bold]: {c['content']}")
+        return
+
+    ctx.console.print(
+        "[yellow]Usage: /memory [show|rebuild|search <q>|confirm <id>|diff|test][/yellow]"
+    )

polymath/compressor.py

@@ -0,0 +1,90 @@
+"""
+Smart context windowing.
+- Always send the last N messages verbatim.
+- Everything older is compressed into a cached summary.
+- Summary is regenerated only when new messages push old ones out of the window.
+"""
+from __future__ import annotations
+
+from polymath.adapters.base import BaseAdapter, Message
+from polymath.context_store import (
+    get_messages, get_summary, last_message_id, save_summary
+)
+
+
+TOKEN_BUDGET = 3000   # approximate tokens to include verbatim
+SUMMARY_TOKENS = 300
+
+
+async def build_context(
+    session_id: str,
+    window: int = 0,   # kept for backward compatibility but ignored
+    summarizer: BaseAdapter | None = None,
+    summarizer_model: str = "",
+) -> list[Message]:
+    """
+    Returns a message list ready to send to any model:
+      [summary_as_system_msg?] + [recent messages within TOKEN_BUDGET]
+    """
+    all_msgs = get_messages(session_id)
+
+    # Walk backwards accumulating tokens until budget is exceeded
+    budget = TOKEN_BUDGET
+    cutoff = len(all_msgs)
+    for i in range(len(all_msgs) - 1, -1, -1):
+        tokens = len(all_msgs[i].content) // 4
+        if budget - tokens < 0:
+            break
+        budget -= tokens
+        cutoff = i
+
+    if cutoff == 0:
+        return all_msgs
+
+    recent = all_msgs[cutoff:]
+    old = all_msgs[:cutoff]
+
+    summary_rec = get_summary(session_id)
+    last_id = last_message_id(session_id)
+    through_id = last_id - window  # approximate
+
+    # Regenerate summary only if there are new old messages since last summary
+    if summary_rec and summary_rec.get("summarized_through", 0) >= through_id:
+        summary_text = summary_rec["summary"]
+    elif summarizer and summarizer_model:
+        summary_text = await _summarize(old, summarizer, summarizer_model)
+        save_summary(session_id, summary_text, through_id)
+    else:
+        # Fallback: simple concatenation truncated
+        combined = " | ".join(f"{m.role}: {m.content[:80]}" for m in old)
+        summary_text = f"[Earlier context] {combined}"
+
+    summary_msg = Message(
+        role="user",
+        content=f"[Context summary from earlier in this conversation]\n{summary_text}",
+        model="system",
+        step="summary",
+    )
+    # Insert summary as the first message so recent context follows naturally
+    return [summary_msg] + recent
+
+
+async def _summarize(
+    messages: list[Message],
+    adapter: BaseAdapter,
+    model_id: str,
+) -> str:
+    prompt_parts = [f"{m.role.upper()}: {m.content}" for m in messages]
+    prompt = (
+        "Summarize the following conversation in 2-3 sentences, preserving key facts, "
+        "decisions, and any code/output produced. Be concise.\n\n"
+        + "\n".join(prompt_parts)
+    )
+    summary = await adapter.complete(
+        messages=[Message(role="user", content=prompt)],
+        model_id=model_id,
+        system="You are a concise summarizer. Output only the summary, no preamble.",
+        temperature=0.3,
+        max_tokens=SUMMARY_TOKENS,
+    )
+    return summary.strip()