zwarm 2.3.5__py3-none-any.whl → 3.2.1__py3-none-any.whl

zwarm/cli/main.py

@@ -79,6 +79,7 @@ app = typer.Typer(
     [cyan]init[/]         Initialize zwarm (creates .zwarm/ with config)
     [cyan]reset[/]        Reset state and optionally config files
     [cyan]orchestrate[/]  Start orchestrator to delegate tasks to executors
+    [cyan]pilot[/]        Conversational orchestrator REPL (interactive)
     [cyan]exec[/]         Run a single executor directly (for testing)
     [cyan]status[/]       Show current state (sessions, tasks, events)
     [cyan]history[/]      Show event history log
@@ -274,6 +275,112 @@ def orchestrate(
         sys.exit(1)
 
 
+class PilotLM(str, Enum):
+    """LM options for pilot mode."""
+    gpt5_mini = "gpt5-mini"      # GPT5MiniTester - fast, cheap, good for testing
+    gpt5 = "gpt5"                # GPT5Large - standard
+    gpt5_verbose = "gpt5-verbose"  # GPT5LargeVerbose - with extended thinking
+
+
+@app.command()
+def pilot(
+    task: Annotated[Optional[str], typer.Option("--task", "-t", help="Initial task (optional)")] = None,
+    task_file: Annotated[Optional[Path], typer.Option("--task-file", "-f", help="Read task from file")] = None,
+    config: Annotated[Optional[Path], typer.Option("--config", "-c", help="Path to config YAML")] = None,
+    overrides: Annotated[Optional[list[str]], typer.Option("--set", help="Override config (key=value)")] = None,
+    working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
+    instance: Annotated[Optional[str], typer.Option("--instance", "-i", help="Instance ID (for isolation)")] = None,
+    instance_name: Annotated[Optional[str], typer.Option("--name", "-n", help="Human-readable instance name")] = None,
+    model: Annotated[PilotLM, typer.Option("--model", "-m", help="LM to use")] = PilotLM.gpt5_verbose,
+):
+    """
+    Interactive conversational orchestrator REPL.
+
+    Like 'orchestrate' but conversational: give instructions, watch the
+    orchestrator work, course-correct in real-time, time-travel to checkpoints.
+
+    [bold]Features:[/]
+        - Streaming display of orchestrator thinking and tool calls
+        - Turn-by-turn execution with checkpoints
+        - Time travel (:goto T1) to return to previous states
+        - Session visibility (:sessions) and state inspection (:state)
+
+    [bold]Commands:[/]
+        :help              Show help
+        :history [N|all]   Show turn checkpoints
+        :goto <turn|root>  Time travel (e.g., :goto T1)
+        :state             Show orchestrator state
+        :sessions          Show active executor sessions
+        :reasoning on|off  Toggle reasoning display
+        :quit              Exit
+
+    [bold]LM Options:[/]
+        gpt5-mini     GPT5MiniTester - fast/cheap, good for testing
+        gpt5          GPT5Large - standard model
+        gpt5-verbose  GPT5LargeVerbose - with extended thinking (default)
+
+    [bold]Examples:[/]
+        [dim]# Start fresh, give instructions interactively[/]
+        $ zwarm pilot
+
+        [dim]# Start with an initial task[/]
+        $ zwarm pilot --task "Build user authentication"
+
+        [dim]# Use faster model for testing[/]
+        $ zwarm pilot --model gpt5-mini
+
+        [dim]# Named instance[/]
+        $ zwarm pilot --name my-feature
+    """
+    from zwarm.cli.pilot import run_pilot, build_pilot_orchestrator
+
+    # Resolve task (optional for pilot)
+    resolved_task = _resolve_task(task, task_file)
+
+    console.print(f"[bold]Starting pilot session...[/]")
+    console.print(f"  Working dir: {working_dir.absolute()}")
+    console.print(f"  Model: {model.value}")
+    if resolved_task:
+        console.print(f"  Initial task: {resolved_task[:60]}...")
+    if instance:
+        console.print(f"  Instance: {instance}" + (f" ({instance_name})" if instance_name else ""))
+    console.print()
+
+    orchestrator = None
+    try:
+        orchestrator = build_pilot_orchestrator(
+            config_path=config,
+            working_dir=working_dir.absolute(),
+            overrides=list(overrides or []),
+            instance_id=instance,
+            instance_name=instance_name,
+            lm_choice=model.value,
+        )
+
+        # Show instance ID if auto-generated
+        if orchestrator.instance_id and not instance:
+            console.print(f"  [dim]Instance: {orchestrator.instance_id[:8]}[/]")
+
+        # Run the pilot REPL
+        run_pilot(orchestrator, initial_task=resolved_task)
+
+        # Save state on exit
+        orchestrator.save_state()
+        console.print("\n[dim]State saved.[/]")
+
+    except KeyboardInterrupt:
+        console.print("\n\n[yellow]Interrupted.[/]")
+        if orchestrator:
+            orchestrator.save_state()
+            console.print("[dim]State saved.[/]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"\n[red]Error:[/] {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
 @app.command()
 def exec(
     task: Annotated[str, typer.Option("--task", "-t", help="Task to execute")],
@@ -633,8 +740,14 @@ def init(
     [bold]Creates:[/]
         [cyan].zwarm/[/]              State directory for sessions and events
         [cyan].zwarm/config.toml[/]   Runtime settings (weave, adapter, watchers)
+        [cyan].zwarm/codex.toml[/]    Codex CLI settings (model, reasoning effort)
         [cyan]zwarm.yaml[/]           Project config (optional, with --with-project)
 
+    [bold]Configuration relationship:[/]
+        config.toml   → Controls zwarm itself (tracing, which watchers run)
+        codex.toml    → Controls the Codex CLI that runs executor sessions
+        zwarm.yaml    → Project-specific context injected into orchestrator
+
     [bold]Examples:[/]
         [dim]# Interactive setup[/]
         $ zwarm init
@@ -681,6 +794,9 @@ def init(
     create_project_config = with_project
     project_description = ""
     project_context = ""
+    # Codex settings
+    codex_model = "gpt-5.1-codex-mini"
+    codex_reasoning = "high"
 
     if not non_interactive:
         console.print("[bold]Configuration[/]\n")
@@ -699,6 +815,42 @@ def init(
             type=str,
         )
 
+        # Codex model settings
+        console.print("\n  [bold]Codex Model Settings[/] (.zwarm/codex.toml)")
+        console.print("  [dim]These control the underlying Codex CLI that runs executor sessions[/]\n")
+
+        console.print("  Available models:")
+        console.print("    [cyan]1[/] gpt-5.1-codex-mini  [dim]- Fast, cheap, good for most tasks (Recommended)[/]")
+        console.print("    [cyan]2[/] gpt-5.1-codex       [dim]- Balanced speed and capability[/]")
+        console.print("    [cyan]3[/] gpt-5.1-codex-max   [dim]- Most capable, 400k context, expensive[/]")
+
+        model_choice = typer.prompt(
+            "  Select model (1-3)",
+            default="1",
+            type=str,
+        )
+        model_map = {
+            "1": "gpt-5.1-codex-mini",
+            "2": "gpt-5.1-codex",
+            "3": "gpt-5.1-codex-max",
+        }
+        codex_model = model_map.get(model_choice, model_choice)
+        if model_choice not in model_map:
+            console.print(f"    [dim]Using custom model: {codex_model}[/]")
+
+        console.print("\n  Reasoning effort (how much the model \"thinks\" before responding):")
+        console.print("    [cyan]1[/] low     [dim]- Minimal reasoning, fastest responses[/]")
+        console.print("    [cyan]2[/] medium  [dim]- Balanced reasoning[/]")
+        console.print("    [cyan]3[/] high    [dim]- Maximum reasoning, best for complex tasks (Recommended)[/]")
+
+        reasoning_choice = typer.prompt(
+            "  Select reasoning effort (1-3)",
+            default="3",
+            type=str,
+        )
+        reasoning_map = {"1": "low", "2": "medium", "3": "high"}
+        codex_reasoning = reasoning_map.get(reasoning_choice, "high")
+
         # Watchers
         console.print("\n  [bold]Watchers[/] (trajectory aligners)")
         available_watchers = ["progress", "budget", "delegation", "delegation_reminder", "scope", "pattern", "quality"]
@@ -750,10 +902,20 @@ def init(
 
     # Create codex.toml for isolated codex configuration
     codex_toml_path = state_dir / "codex.toml"
-    if not codex_toml_path.exists():
-        codex_content = _generate_codex_toml()
+    write_codex_toml = True
+    if codex_toml_path.exists():
+        if not non_interactive:
+            overwrite_codex = typer.confirm("  .zwarm/codex.toml exists. Overwrite?", default=False)
+            if not overwrite_codex:
+                write_codex_toml = False
+                console.print("  [dim]Skipping codex.toml[/]")
+        else:
+            write_codex_toml = False  # Don't overwrite in non-interactive mode
+
+    if write_codex_toml:
+        codex_content = _generate_codex_toml(model=codex_model, reasoning_effort=codex_reasoning)
         codex_toml_path.write_text(codex_content)
-        console.print(f"  [green]✓[/] Created .zwarm/codex.toml (isolated codex config)")
+        console.print(f"  [green]✓[/] Created .zwarm/codex.toml")
 
     # Create zwarm.yaml
     if create_project_config:
@@ -773,11 +935,23 @@ def init(
 
     # Summary
     console.print("\n[bold green]Done![/] zwarm is ready.\n")
+
+    # Explain config files
+    console.print("[bold]Configuration files:[/]")
+    console.print("  [cyan].zwarm/config.toml[/]  - Runtime settings (Weave tracing, watchers)")
+    console.print("  [cyan].zwarm/codex.toml[/]   - Codex CLI settings (model, reasoning effort)")
+    if create_project_config:
+        console.print("  [cyan]zwarm.yaml[/]          - Project context and constraints")
+    console.print()
+    console.print("  [dim]Edit these files to customize behavior. Run 'zwarm init' again to reconfigure.[/]\n")
+
     console.print("[bold]Next steps:[/]")
     console.print("  [dim]# Run the orchestrator[/]")
     console.print("  $ zwarm orchestrate --task \"Your task here\"\n")
     console.print("  [dim]# Or test an executor directly[/]")
     console.print("  $ zwarm exec --task \"What is 2+2?\"\n")
+    console.print("  [dim]# Interactive session management[/]")
+    console.print("  $ zwarm interactive\n")
 
 
 def _generate_config_toml(
@@ -1133,897 +1307,183 @@ def clean(
 def interactive(
     default_dir: Annotated[Path, typer.Option("--dir", "-d", help="Default working directory")] = Path("."),
     model: Annotated[Optional[str], typer.Option("--model", help="Default model override")] = None,
-    adapter: Annotated[str, typer.Option("--adapter", "-a", help="Executor adapter")] = "codex_mcp",
-    state_dir: Annotated[Path, typer.Option("--state-dir", help="State directory for persistence")] = Path(".zwarm"),
 ):
     """
-    Universal multi-agent CLI for commanding coding agents.
+    Interactive REPL for session management.
 
-    Spawn multiple agents across different directories, manage them interactively,
-    and view their outputs. You are the orchestrator.
-
-    This uses the SAME code path as `zwarm orchestrate` - the adapter layer.
-    Interactive is the human-in-the-loop version, orchestrate is the LLM version.
+    A clean, autocomplete-enabled interface for managing codex sessions.
+    Tab-complete session IDs, watch live output, and manage the session lifecycle.
 
     [bold]Commands:[/]
-        [cyan]spawn[/] "task" [opts]      Start a coding agent session (sync mode)
-        [cyan]async[/] "task" [opts]      Start async session (fire-and-forget)
-        [cyan]ls[/] / [cyan]list[/]               Dashboard of all sessions
-        [cyan]?[/] ID                    Quick peek (status + latest message)
-        [cyan]show[/] ID                  Full session details & history
-        [cyan]traj[/] ID                  Show trajectory (all steps taken)
-        [cyan]c[/] / [cyan]continue[/] ID "msg"   Continue a sync conversation
-        [cyan]kill[/] ID                  Stop a session (keeps in history)
-        [cyan]rm[/] ID                    Delete session entirely
-        [cyan]killall[/]                  Stop all running sessions
-        [cyan]clean[/]                    Remove old sessions (>7 days)
-        [cyan]q[/] / [cyan]quit[/]                Exit
-
-    [bold]Spawn Options:[/]
-        spawn "task" --dir ~/project --model gpt-5.1-codex-max --async
+        [cyan]spawn[/] "task"       Start a new session
+        [cyan]ls[/]                 Dashboard of all sessions
+        [cyan]peek[/] ID / [cyan]?[/] ID    Quick status check
+        [cyan]show[/] ID            Full session details
+        [cyan]traj[/] ID            Show trajectory (steps taken)
+        [cyan]watch[/] ID           Live follow session output
+        [cyan]c[/] ID "msg"         Continue conversation
+        [cyan]kill[/] ID | all      Stop session(s)
+        [cyan]rm[/] ID | all        Delete session(s)
 
     [bold]Examples:[/]
         $ zwarm interactive
-        > spawn "Build auth module" --dir ~/api
-        > spawn "Fix tests" --dir ~/api
-        > c abc123 "Now add error handling"
+        > spawn "Build auth module"
+        > watch abc123
+        > c abc123 "Now add tests"
         > ls
-        > ? abc123
     """
-    from zwarm.adapters import get_adapter, list_adapters
-    from zwarm.core.models import ConversationSession, SessionStatus, SessionMode
-    import argparse
+    from zwarm.cli.interactive import run_interactive
 
-    # Initialize adapter (same as orchestrator uses)
     default_model = model or "gpt-5.1-codex-mini"
-    default_adapter = adapter
-
-    # Config path for isolated codex configuration
-    codex_config_path = state_dir / "codex.toml"
-    if not codex_config_path.exists():
-        # Try relative to working dir
-        codex_config_path = default_dir / ".zwarm" / "codex.toml"
-    if not codex_config_path.exists():
-        codex_config_path = None  # Fall back to overrides
-
-    # Session tracking - same pattern as orchestrator
-    sessions: dict[str, ConversationSession] = {}
-    adapters_cache: dict[str, Any] = {}
-
-    def get_or_create_adapter(adapter_name: str, session_model: str | None = None) -> Any:
-        """Get or create an adapter instance with isolated config."""
-        cache_key = f"{adapter_name}:{session_model or default_model}"
-        if cache_key not in adapters_cache:
-            adapters_cache[cache_key] = get_adapter(
-                adapter_name,
-                model=session_model or default_model,
-                config_path=codex_config_path,
-            )
-        return adapters_cache[cache_key]
-
-    def find_session(query: str) -> tuple[ConversationSession | None, str | None]:
-        """Find session by full or partial ID."""
-        if query in sessions:
-            return sessions[query], query
-        for sid, session in sessions.items():
-            if sid.startswith(query):
-                return session, sid
-        return None, None
-
-    console.print("\n[bold cyan]zwarm interactive[/] - Multi-Agent Command Center\n")
-    console.print(f"  Working dir: {default_dir.absolute()}")
-    console.print(f"  Model: [cyan]{default_model}[/]")
-    console.print(f"  Adapter: [cyan]{default_adapter}[/]")
-    if codex_config_path:
-        console.print(f"  Config: [green]{codex_config_path}[/] (isolated)")
-    else:
-        console.print(f"  Config: [yellow]using fallback overrides[/] (run 'zwarm init' for isolation)")
-    console.print(f"  Available: {', '.join(list_adapters())}")
-    console.print("\n  Type [cyan]help[/] for commands, [cyan]quit[/] to exit.\n")
-
-    def show_help():
-        help_table = Table(show_header=False, box=None, padding=(0, 2))
-        help_table.add_column("Command", style="cyan", width=35)
-        help_table.add_column("Description")
-        help_table.add_row('spawn "task" [options]', "Start session (waits for completion)")
-        help_table.add_row("  --dir PATH", "Working directory")
-        help_table.add_row("  --model NAME", "Model override")
-        help_table.add_row("  --async", "Background mode (don't wait)")
-        help_table.add_row("", "")
-        help_table.add_row("ls / list", "Dashboard of all sessions")
-        help_table.add_row("? ID / peek ID", "Quick peek (status + latest message)")
-        help_table.add_row("show ID", "Full session details & messages")
-        help_table.add_row("traj ID [--full]", "Show trajectory (all steps taken)")
-        help_table.add_row('c ID "msg"', "Continue conversation (wait for response)")
-        help_table.add_row('ca ID "msg"', "Continue async (fire-and-forget)")
-        help_table.add_row("check ID", "Check session status")
-        help_table.add_row("kill ID", "Stop a running session")
-        help_table.add_row("rm ID", "Delete session entirely")
-        help_table.add_row("killall", "Stop all running sessions")
-        help_table.add_row("clean", "Remove old completed sessions")
-        help_table.add_row("q / quit", "Exit")
-        console.print(help_table)
-
-    def show_sessions():
-        """List all sessions from CodexSessionManager (same as orchestrator)."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-        from datetime import datetime
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        all_sessions = manager.list_sessions()
-
-        if not all_sessions:
-            console.print("  [dim]No sessions. Use 'spawn \"task\"' to start one.[/]")
-            return
-
-        # Status summary
-        running = sum(1 for s in all_sessions if s.status == SessStatus.RUNNING)
-        completed = sum(1 for s in all_sessions if s.status == SessStatus.COMPLETED)
-        failed = sum(1 for s in all_sessions if s.status == SessStatus.FAILED)
-        killed = sum(1 for s in all_sessions if s.status == SessStatus.KILLED)
-
-        summary_parts = []
-        if running:
-            summary_parts.append(f"[yellow]{running} running[/]")
-        if completed:
-            summary_parts.append(f"[green]{completed} done[/]")
-        if failed:
-            summary_parts.append(f"[red]{failed} failed[/]")
-        if killed:
-            summary_parts.append(f"[dim]{killed} killed[/]")
-        if summary_parts:
-            console.print(" | ".join(summary_parts))
-            console.print()
-
-        def time_ago(iso_str: str) -> str:
-            """Convert ISO timestamp to human-readable 'X ago' format."""
-            try:
-                dt = datetime.fromisoformat(iso_str)
-                delta = datetime.now() - dt
-                secs = delta.total_seconds()
-                if secs < 60:
-                    return f"{int(secs)}s"
-                elif secs < 3600:
-                    return f"{int(secs/60)}m"
-                elif secs < 86400:
-                    return f"{secs/3600:.1f}h"
-                else:
-                    return f"{secs/86400:.1f}d"
-            except:
-                return "?"
-
-        table = Table(box=None, show_header=True, header_style="bold dim")
-        table.add_column("ID", style="cyan", width=10)
-        table.add_column("", width=2)  # Status icon
-        table.add_column("T", width=2)  # Turn
-        table.add_column("Task", max_width=30)
-        table.add_column("Updated", justify="right", width=8)
-        table.add_column("Last Message", max_width=40)
-
-        status_icons = {
-            "running": "[yellow]●[/]",
-            "completed": "[green]✓[/]",
-            "failed": "[red]✗[/]",
-            "killed": "[dim]○[/]",
-            "pending": "[dim]◌[/]",
-        }
-
-        for s in all_sessions:
-            icon = status_icons.get(s.status.value, "?")
-            task_preview = s.task[:27] + "..." if len(s.task) > 30 else s.task
-            updated = time_ago(s.updated_at)
-
-            # Get last assistant message preview
-            messages = manager.get_messages(s.id)
-            last_msg = ""
-            for msg in reversed(messages):
-                if msg.role == "assistant":
-                    last_msg = msg.content.replace("\n", " ")[:37]
-                    if len(msg.content) > 37:
-                        last_msg += "..."
-                    break
-
-            # Style the last message based on recency
-            if s.status == SessStatus.RUNNING:
-                last_msg_styled = f"[yellow]{last_msg or '(working...)'}[/]"
-                updated_styled = f"[yellow]{updated}[/]"
-            elif s.status == SessStatus.COMPLETED:
-                # Highlight if recently completed (< 60s)
-                try:
-                    dt = datetime.fromisoformat(s.updated_at)
-                    is_recent = (datetime.now() - dt).total_seconds() < 60
-                except:
-                    is_recent = False
-                if is_recent:
-                    last_msg_styled = f"[green bold]{last_msg or '(done)'}[/]"
-                    updated_styled = f"[green bold]{updated} ★[/]"
-                else:
-                    last_msg_styled = f"[green]{last_msg or '(done)'}[/]"
-                    updated_styled = f"[dim]{updated}[/]"
-            elif s.status == SessStatus.FAILED:
-                last_msg_styled = f"[red]{s.error[:37] if s.error else '(failed)'}...[/]"
-                updated_styled = f"[red]{updated}[/]"
-            else:
-                last_msg_styled = f"[dim]{last_msg or '-'}[/]"
-                updated_styled = f"[dim]{updated}[/]"
-
-            table.add_row(
-                s.short_id,
-                icon,
-                str(s.turn),
-                task_preview,
-                updated_styled,
-                last_msg_styled,
-            )
-
-        console.print(table)
-
-    def parse_spawn_args(args: list[str]) -> dict:
-        """Parse spawn command arguments."""
-        parser = argparse.ArgumentParser(add_help=False)
-        parser.add_argument("task", nargs="*")
-        parser.add_argument("--dir", "-d", type=Path, default=None)
-        parser.add_argument("--model", "-m", default=None)
-        parser.add_argument("--async", dest="async_mode", action="store_true", default=False)
-
-        try:
-            parsed, _ = parser.parse_known_args(args)
-            return {
-                "task": " ".join(parsed.task) if parsed.task else "",
-                "dir": parsed.dir,
-                "model": parsed.model,
-                "async_mode": parsed.async_mode,
-            }
-        except SystemExit:
-            return {"error": "Invalid spawn arguments"}
-
-    def do_spawn(args: list[str]):
-        """Spawn a new coding agent session using CodexSessionManager (same as orchestrator)."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-        import time
-
-        parsed = parse_spawn_args(args)
-
-        if "error" in parsed:
-            console.print(f"  [red]{parsed['error']}[/]")
-            console.print("  [dim]Usage: spawn \"task\" [--dir PATH] [--model NAME] [--async][/]")
-            return
-
-        if not parsed["task"]:
-            console.print("  [red]Task required[/]")
-            console.print("  [dim]Usage: spawn \"task\" [--dir PATH] [--model NAME] [--async][/]")
-            return
-
-        task = parsed["task"]
-        work_dir = (parsed["dir"] or default_dir).absolute()
-        session_model = parsed["model"] or default_model
-        is_async = parsed.get("async_mode", False)
-
-        if not work_dir.exists():
-            console.print(f"  [red]Directory not found:[/] {work_dir}")
-            return
-
-        mode_str = "async" if is_async else "sync"
-        console.print(f"\n[dim]Spawning {mode_str} session...[/]")
-        console.print(f"  [dim]Dir: {work_dir}[/]")
-        console.print(f"  [dim]Model: {session_model}[/]")
-
-        try:
-            # Use CodexSessionManager - SAME as orchestrator's delegate()
-            manager = CodexSessionManager(work_dir / ".zwarm")
-            session = manager.start_session(
-                task=task,
-                working_dir=work_dir,
-                model=session_model,
-                sandbox="workspace-write",
-                source="user",
-                adapter="codex",
-            )
-
-            console.print(f"\n[green]✓[/] Session: [cyan]{session.short_id}[/]")
-            console.print(f"  [dim]PID: {session.pid}[/]")
-
-            # For sync mode, wait for completion and show response
-            if not is_async:
-                console.print(f"\n[dim]Waiting for completion...[/]")
-                timeout = 300.0
-                start = time.time()
-                while time.time() - start < timeout:
-                    # get_session() auto-updates status based on output completion
-                    session = manager.get_session(session.id)
-                    if session.status != SessStatus.RUNNING:
-                        break
-                    time.sleep(1.0)
-
-                # Get all assistant responses
-                messages = manager.get_messages(session.id)
-                assistant_msgs = [m for m in messages if m.role == "assistant"]
-                if assistant_msgs:
-                    console.print(f"\n[bold]Response ({len(assistant_msgs)} message{'s' if len(assistant_msgs) > 1 else ''}):[/]")
-                    for msg in assistant_msgs:
-                        preview = msg.content[:300]
-                        if len(msg.content) > 300:
-                            preview += "..."
-                        console.print(preview)
-                        if len(assistant_msgs) > 1:
-                            console.print()  # Blank line between multiple messages
-
-            console.print(f"\n[dim]Use 'show {session.short_id}' to see full details[/]")
-            console.print(f"[dim]Use 'c {session.short_id} \"message\"' to continue[/]")
-
-        except Exception as e:
-            console.print(f"  [red]Error:[/] {e}")
-            import traceback
-            console.print(f"  [dim]{traceback.format_exc()}[/]")
-
-    def do_orchestrate(args: list[str]):
-        """Spawn an orchestrator agent that delegates to sub-sessions."""
-        parsed = parse_spawn_args(args)
-
-        if "error" in parsed:
-            console.print(f"  [red]{parsed['error']}[/]")
-            console.print("  [dim]Usage: orchestrate \"task\" [--dir PATH][/]")
-            return
-
-        if not parsed["task"]:
-            console.print("  [red]Task required[/]")
-            console.print("  [dim]Usage: orchestrate \"task\" [--dir PATH][/]")
-            return
-
-        task = parsed["task"]
-        work_dir = (parsed["dir"] or default_dir).absolute()
-
-        if not work_dir.exists():
-            console.print(f"  [red]Directory not found:[/] {work_dir}")
-            return
-
-        console.print(f"\n[dim]Starting orchestrator...[/]")
-        console.print(f"  [dim]Dir: {work_dir}[/]")
-        console.print(f"  [dim]Task: {task[:60]}{'...' if len(task) > 60 else ''}[/]")
+    run_interactive(working_dir=default_dir.absolute(), model=default_model)
 
-        import subprocess
-        from uuid import uuid4
 
-        # Generate instance ID for tracking
-        instance_id = str(uuid4())[:8]
+@app.command()
+def sessions(
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+    clean: Annotated[bool, typer.Option("--clean", "-c", help="Delete all non-running sessions")] = False,
+    kill_all: Annotated[bool, typer.Option("--kill-all", "-k", help="Kill all running sessions")] = False,
+    rm: Annotated[Optional[str], typer.Option("--rm", help="Delete specific session ID")] = None,
+    kill: Annotated[Optional[str], typer.Option("--kill", help="Kill specific session ID")] = None,
+):
+    """
+    Quick session management.
 
-        # Build command to run orchestrator in background
-        cmd = [
-            sys.executable, "-m", "zwarm.cli.main", "orchestrate",
-            "--task", task,
-            "--working-dir", str(work_dir),
-            "--instance", instance_id,
-        ]
+    By default, lists all sessions. Use flags for quick actions:
 
-        # Create log file for orchestrator output
-        log_dir = state_dir / "orchestrators"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        log_file = log_dir / f"{instance_id}.log"
+    [bold]Examples:[/]
+        [dim]# List all sessions[/]
+        $ zwarm sessions
 
-        try:
-            with open(log_file, "w") as f:
-                proc = subprocess.Popen(
-                    cmd,
-                    cwd=work_dir,
-                    stdout=f,
-                    stderr=subprocess.STDOUT,
-                    start_new_session=True,
-                )
+        [dim]# Delete all completed/failed sessions[/]
+        $ zwarm sessions --clean
+        $ zwarm sessions -c
 
-            console.print(f"\n[green]✓[/] Orchestrator started: [magenta]{instance_id}[/]")
-            console.print(f"  PID: {proc.pid}")
-            console.print(f"  Log: {log_file}")
-            console.print(f"\n[dim]Delegated sessions will appear with source 'orch:{instance_id[:4]}'[/]")
-            console.print(f"[dim]Use 'ls' to monitor progress[/]")
+        [dim]# Kill all running sessions[/]
+        $ zwarm sessions --kill-all
+        $ zwarm sessions -k
 
-        except Exception as e:
-            console.print(f"  [red]Error starting orchestrator:[/] {e}")
+        [dim]# Delete a specific session[/]
+        $ zwarm sessions --rm abc123
 
-    def do_peek(session_id: str):
-        """Quick peek at session - just status + latest message (for fast polling)."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
+        [dim]# Kill a specific session[/]
+        $ zwarm sessions --kill abc123
+    """
+    from zwarm.sessions import CodexSessionManager, SessionStatus
+    from zwarm.core.costs import estimate_session_cost, format_cost
 
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
+    manager = CodexSessionManager(working_dir / ".zwarm")
 
+    # Handle --kill (specific session)
+    if kill:
+        session = manager.get_session(kill)
         if not session:
-            console.print(f"  [red]Not found:[/] {session_id}")
-            return
-
-        # Status icon
-        icon = {
-            "running": "[yellow]●[/]",
-            "completed": "[green]✓[/]",
-            "failed": "[red]✗[/]",
-            "killed": "[dim]○[/]",
-        }.get(session.status.value, "?")
-
-        # Get latest assistant message
-        messages = manager.get_messages(session.id)
-        latest = None
-        for msg in reversed(messages):
-            if msg.role == "assistant":
-                latest = msg.content.replace("\n", " ")
-                break
-
-        if session.status == SessStatus.RUNNING:
-            console.print(f"{icon} [cyan]{session.short_id}[/] [yellow](running...)[/]")
-        elif latest:
-            # Truncate for one-liner
-            preview = latest[:120] + "..." if len(latest) > 120 else latest
-            console.print(f"{icon} [cyan]{session.short_id}[/] {preview}")
-        elif session.status == SessStatus.FAILED:
-            error = (session.error or "unknown")[:80]
-            console.print(f"{icon} [cyan]{session.short_id}[/] [red]{error}[/]")
+            console.print(f"[red]Session not found:[/] {kill}")
+            raise typer.Exit(1)
+        if manager.kill_session(session.id):
+            console.print(f"[green]✓[/] Killed {session.short_id}")
         else:
-            console.print(f"{icon} [cyan]{session.short_id}[/] [dim](no response)[/]")
-
-    def do_show(session_id: str):
-        """Show full session details and messages using CodexSessionManager."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
-
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            console.print(f"  [dim]Use 'ls' to see available sessions[/]")
-            return
-
-        # Status styling
-        status_display = {
-            "running": "[yellow]● running[/]",
-            "completed": "[green]✓ completed[/]",
-            "failed": "[red]✗ failed[/]",
-            "killed": "[dim]○ killed[/]",
-            "pending": "[dim]◌ pending[/]",
-        }.get(session.status.value, str(session.status.value))
-
-        console.print()
-        console.print(f"[bold cyan]Session {session.short_id}[/]  {status_display}")
-        console.print(f"[dim]Adapter:[/] {session.adapter}  [dim]│[/]  [dim]Model:[/] {session.model}")
-        console.print(f"[dim]Task:[/] {session.task}")
-        console.print(f"[dim]Dir:[/] {session.working_dir}  [dim]│[/]  [dim]Turn:[/] {session.turn}")
-        console.print(f"[dim]Source:[/] {session.source_display}  [dim]│[/]  [dim]Runtime:[/] {session.runtime}")
-        if session.pid:
-            console.print(f"[dim]PID:[/] {session.pid}")
-
-        # Show log file path
-        log_path = default_dir / ".zwarm" / "sessions" / session.id / "turns" / f"turn_{session.turn}.jsonl"
-        console.print(f"[dim]Log:[/] {log_path}")
-        console.print()
-
-        # Get messages from manager
-        messages = manager.get_messages(session.id)
-
-        if not messages:
-            if session.is_running:
-                console.print("[yellow]Session is still running...[/]")
-            else:
-                console.print("[dim]No messages captured.[/]")
-            return
-
-        # Display messages
-        for msg in messages:
-            if msg.role == "user":
-                console.print(Panel(msg.content, title="[bold blue]User[/]", border_style="blue"))
-            elif msg.role == "assistant":
-                content = msg.content
-                if len(content) > 2000:
-                    content = content[:2000] + "\n\n[dim]... (truncated)[/]"
-                console.print(Panel(content, title="[bold green]Assistant[/]", border_style="green"))
-            elif msg.role == "tool":
-                console.print(f"  [dim]Tool: {msg.content[:100]}[/]")
-
-        console.print()
-        if session.token_usage:
-            tokens = session.token_usage
-            console.print(f"[dim]Tokens: {tokens.get('input_tokens', 0):,} in / {tokens.get('output_tokens', 0):,} out[/]")
-
-        if session.error:
-            console.print(f"[red]Error:[/] {session.error}")
-
-    def do_trajectory(session_id: str, full: bool = False):
-        """Show the full trajectory of a session - all steps in order."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
-
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            return
-
-        trajectory = manager.get_trajectory(session_id, full=full)
-
-        if not trajectory:
-            console.print("[dim]No trajectory data available.[/]")
-            return
-
-        mode = "[bold](full)[/] " if full else ""
-        console.print(f"\n[bold cyan]Trajectory: {session.short_id}[/] {mode}({len(trajectory)} steps)")
-        console.print(f"[dim]Task: {session.task[:60]}{'...' if len(session.task) > 60 else ''}[/]")
-        console.print()
-
-        # Display each step
-        for step in trajectory:
-            turn = step.get("turn", 1)
-            step_num = step.get("step", 0)
-            step_type = step.get("type", "unknown")
-
-            prefix = f"[dim]T{turn}.{step_num:02d}[/]"
-
-            if step_type == "reasoning":
-                if full and step.get("full_text"):
-                    console.print(f"{prefix} [yellow]thinking:[/]")
-                    console.print(f"       {step['full_text']}")
-                else:
-                    summary = step.get("summary", "")
-                    console.print(f"{prefix} [yellow]thinking:[/] {summary}")
-
-            elif step_type == "command":
-                cmd = step.get("command", "")
-                output = step.get("output", "")
-                exit_code = step.get("exit_code", "?")
-                # Show command
-                console.print(f"{prefix} [cyan]$ {cmd}[/]")
-                if output:
-                    if full:
-                        # Show all output
-                        for line in output.split("\n"):
-                            console.print(f"       [dim]{line}[/]")
-                    else:
-                        # Indent output, max 5 lines
-                        for line in output.split("\n")[:5]:
-                            console.print(f"       [dim]{line}[/]")
-                        if output.count("\n") > 5:
-                            console.print(f"       [dim]... ({output.count(chr(10))} lines)[/]")
-                if exit_code != 0 and exit_code is not None:
-                    console.print(f"       [red]exit: {exit_code}[/]")
-
-            elif step_type == "tool_call":
-                tool = step.get("tool", "unknown")
-                if full and step.get("full_args"):
-                    import json
-                    console.print(f"{prefix} [magenta]tool:[/] {tool}")
-                    console.print(f"       {json.dumps(step['full_args'], indent=2)}")
-                else:
-                    args = step.get("args_preview", "")
-                    console.print(f"{prefix} [magenta]tool:[/] {tool}({args})")
-
-            elif step_type == "tool_output":
-                output = step.get("output", "")
-                if not full:
-                    output = output[:100]
-                console.print(f"{prefix} [dim]→ {output}[/]")
-
-            elif step_type == "message":
-                if full and step.get("full_text"):
-                    console.print(f"{prefix} [green]response:[/]")
-                    console.print(f"       {step['full_text']}")
-                else:
-                    summary = step.get("summary", "")
-                    full_len = step.get("full_length", 0)
-                    console.print(f"{prefix} [green]response:[/] {summary}")
-                    if full_len > 200:
-                        console.print(f"       [dim]({full_len} chars total)[/]")
-
-        console.print()
-
-    def do_continue(session_id: str, message: str, wait: bool = True):
-        """
-        Continue a conversation using CodexSessionManager.inject_message().
-
-        Works for both sync and async sessions:
-        - If session was sync (or wait=True): wait for response
-        - If session was async (or wait=False): fire-and-forget, check later with '?'
-        """
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-        import time
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
-
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            console.print(f"  [dim]Use 'ls' to see available sessions[/]")
-            return
-
-        if session.status == SessStatus.RUNNING:
-            console.print("[yellow]Session is still running.[/]")
-            console.print("[dim]Wait for it to complete, or use '?' to check progress.[/]")
-            return
-
-        if session.status == SessStatus.KILLED:
-            console.print("[yellow]Session was killed.[/]")
-            console.print("[dim]Start a new session with 'spawn'.[/]")
-            return
-
-        # Determine if we should wait based on session source
-        # Sessions from 'user' with --async flag have source='user'
-        # We'll use wait parameter to control this
-        should_wait = wait
-
-        console.print(f"\n[dim]Sending message to {session.short_id}...[/]")
-
-        try:
-            # Inject message - spawns new background process
-            updated_session = manager.inject_message(session.id, message)
-
-            if not updated_session:
-                console.print(f"  [red]Failed to inject message[/]")
-                return
-
-            console.print(f"[green]✓[/] Message sent (turn {updated_session.turn})")
-
-            if should_wait:
-                # Sync mode: wait for completion
-                console.print(f"[dim]Waiting for response...[/]")
-                timeout = 300.0
-                start = time.time()
-                while time.time() - start < timeout:
-                    # get_session() auto-updates status based on output completion
-                    session = manager.get_session(session.id)
-                    if session.status != SessStatus.RUNNING:
-                        break
-                    time.sleep(1.0)
-
-                # Get the response (last assistant message)
-                messages = manager.get_messages(session.id)
-                response = ""
-                for msg in reversed(messages):
-                    if msg.role == "assistant":
-                        response = msg.content
-                        break
-
-                console.print(f"\n[bold]Response:[/]")
-                if len(response) > 500:
-                    console.print(response[:500] + "...")
-                    console.print(f"\n[dim]Use 'show {session.short_id}' to see full response[/]")
-                else:
-                    console.print(response or "(no response captured)")
-            else:
-                # Async mode: return immediately
-                console.print(f"[dim]Running in background (PID: {updated_session.pid})[/]")
-                console.print(f"[dim]Use '? {session.short_id}' to check progress[/]")
-
-        except Exception as e:
-            console.print(f"  [red]Error:[/] {e}")
-            import traceback
-            console.print(f"  [dim]{traceback.format_exc()}[/]")
-
-    def do_check(session_id: str):
-        """Check status of a session using CodexSessionManager (same as orchestrator)."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
-
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            console.print(f"  [dim]Use 'ls' to see available sessions[/]")
-            return
-
-        status_icon = {
-            "running": "●",
-            "completed": "✓",
-            "failed": "✗",
-            "killed": "○",
-            "pending": "◌",
-        }.get(session.status.value, "?")
-
-        console.print(f"\n[bold]Session {session.short_id}[/]: {status_icon} {session.status.value}")
-        console.print(f"  [dim]Task: {session.task[:60]}{'...' if len(session.task) > 60 else ''}[/]")
-        console.print(f"  [dim]Turn: {session.turn} | Runtime: {session.runtime}[/]")
-
-        if session.status.value == "completed":
-            messages = manager.get_messages(session.id)
-            for msg in reversed(messages):
-                if msg.role == "assistant":
-                    console.print(f"\n[bold]Response:[/]")
-                    if len(msg.content) > 500:
-                        console.print(msg.content[:500] + "...")
-                    else:
-                        console.print(msg.content)
-                    break
-        elif session.status.value == "failed":
-            console.print(f"[red]Error:[/] {session.error or 'Unknown error'}")
-        elif session.status.value == "running":
-            console.print("[dim]Session is still running...[/]")
-            console.print(f"  [dim]PID: {session.pid}[/]")
-
-    def do_kill(session_id: str):
-        """Kill a running session using CodexSessionManager (same as orchestrator)."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
+            console.print(f"[yellow]Session not running or already stopped[/]")
+        return
 
+    # Handle --rm (specific session)
+    if rm:
+        session = manager.get_session(rm)
         if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            return
-
-        if not session.is_running:
-            console.print(f"[yellow]Session {session.short_id} is not running ({session.status.value}).[/]")
-            return
-
-        try:
-            killed = manager.kill_session(session.id)
-            if killed:
-                console.print(f"[green]✓[/] Stopped session {session.short_id}")
-            else:
-                console.print(f"[red]Failed to stop session[/]")
-        except Exception as e:
-            console.print(f"[red]Failed to stop session:[/] {e}")
-
-    def do_killall():
-        """Kill all running sessions using CodexSessionManager."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        running_sessions = manager.list_sessions(status=SessStatus.RUNNING)
+            console.print(f"[red]Session not found:[/] {rm}")
+            raise typer.Exit(1)
+        if manager.delete_session(session.id):
+            console.print(f"[green]✓[/] Deleted {session.short_id}")
+        else:
+            console.print(f"[red]Failed to delete[/]")
+        return
 
-        if not running_sessions:
-            console.print("[dim]No running sessions to kill.[/]")
+    # Handle --kill-all
+    if kill_all:
+        running = manager.list_sessions(status=SessionStatus.RUNNING)
+        if not running:
+            console.print("[dim]No running sessions[/]")
             return
-
         killed = 0
-        for session in running_sessions:
-            try:
-                if manager.kill_session(session.id):
-                    killed += 1
-            except Exception as e:
-                console.print(f"[red]Failed to stop {session.short_id}:[/] {e}")
-
-        console.print(f"[green]✓[/] Killed {killed} sessions")
-
-    def do_clean():
-        """Remove old completed/failed sessions from disk."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        cleaned = manager.cleanup_completed(keep_days=7)
-        console.print(f"[green]✓[/] Cleaned {cleaned} old sessions")
-
-    def do_delete(session_id: str):
-        """Delete a session entirely (removes from disk and ls)."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
+        for s in running:
+            if manager.kill_session(s.id):
+                console.print(f"  [green]✓[/] Killed {s.short_id}")
+                killed += 1
+        console.print(f"\n[green]Killed {killed} session(s)[/]")
+        return
 
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
+    # Handle --clean
+    if clean:
+        all_sessions = manager.list_sessions()
+        to_delete = [s for s in all_sessions if s.status != SessionStatus.RUNNING]
+        if not to_delete:
+            console.print("[dim]Nothing to clean[/]")
             return
+        deleted = 0
+        for s in to_delete:
+            if manager.delete_session(s.id):
+                deleted += 1
+        console.print(f"[green]✓[/] Deleted {deleted} session(s)")
+        return
 
-        if manager.delete_session(session.id):
-            console.print(f"[green]✓[/] Deleted session {session.short_id}")
-        else:
-            console.print(f"[red]Failed to delete session[/]")
-
-    # REPL loop
-    import shlex
-
-    while True:
-        try:
-            raw_input = console.input("[bold cyan]>[/] ").strip()
-            if not raw_input:
-                continue
-
-            # Parse command
-            try:
-                parts = shlex.split(raw_input)
-            except ValueError:
-                parts = raw_input.split()
-
-            cmd = parts[0].lower()
-            args = parts[1:]
-
-            if cmd in ("q", "quit", "exit"):
-                active = [s for s in sessions.values() if s.status == SessionStatus.ACTIVE]
-                if active:
-                    console.print(f"  [yellow]Warning:[/] {len(active)} sessions still active")
-                    console.print("  [dim]Use 'killall' first, or they'll continue in background[/]")
-
-                # Cleanup adapters
-                for adapter_instance in adapters_cache.values():
-                    try:
-                        asyncio.run(adapter_instance.cleanup())
-                    except Exception:
-                        pass
-
-                console.print("\n[dim]Goodbye![/]\n")
-                break
-
-            elif cmd in ("h", "help"):
-                show_help()
-
-            elif cmd in ("ls", "list"):
-                show_sessions()
-
-            elif cmd == "spawn":
-                do_spawn(args)
-
-            elif cmd == "async":
-                # Async spawn shorthand
-                do_spawn(args + ["--async"])
-
-            elif cmd == "orchestrate":
-                do_orchestrate(args)
-
-            elif cmd in ("?", "peek"):
-                if not args:
-                    console.print("  [red]Usage:[/] ? SESSION_ID")
-                else:
-                    do_peek(args[0])
-
-            elif cmd in ("show", "check"):
-                if not args:
-                    console.print("  [red]Usage:[/] show SESSION_ID")
-                else:
-                    do_show(args[0])
-
-            elif cmd in ("traj", "trajectory"):
-                if not args:
-                    console.print("  [red]Usage:[/] traj SESSION_ID [--full]")
-                else:
-                    full_mode = "--full" in args
-                    session_arg = [a for a in args if a != "--full"]
-                    if session_arg:
-                        do_trajectory(session_arg[0], full=full_mode)
-                    else:
-                        console.print("  [red]Usage:[/] traj SESSION_ID [--full]")
-
-            elif cmd in ("c", "continue"):
-                # Sync continue - waits for response
-                if len(args) < 2:
-                    console.print("  [red]Usage:[/] c SESSION_ID \"message\"")
-                else:
-                    do_continue(args[0], " ".join(args[1:]), wait=True)
+    # Default: list all sessions
+    all_sessions = manager.list_sessions()
 
-            elif cmd in ("ca", "async"):
-                # Async continue - fire and forget
-                if len(args) < 2:
-                    console.print("  [red]Usage:[/] ca SESSION_ID \"message\"")
-                    console.print("  [dim]Sends message and returns immediately (check with '?')[/]")
-                else:
-                    do_continue(args[0], " ".join(args[1:]), wait=False)
+    if not all_sessions:
+        console.print("[dim]No sessions found.[/]")
+        console.print("[dim]Start one with:[/]  zwarm session start \"your task\"")
+        return
 
-            elif cmd == "check":
-                if not args:
-                    console.print("  [red]Usage:[/] check SESSION_ID")
-                else:
-                    do_check(args[0])
+    # Summary counts
+    running = sum(1 for s in all_sessions if s.status == SessionStatus.RUNNING)
+    completed = sum(1 for s in all_sessions if s.status == SessionStatus.COMPLETED)
+    failed = sum(1 for s in all_sessions if s.status == SessionStatus.FAILED)
+    killed_count = sum(1 for s in all_sessions if s.status == SessionStatus.KILLED)
+
+    parts = []
+    if running:
+        parts.append(f"[yellow]⟳ {running} running[/]")
+    if completed:
+        parts.append(f"[green]✓ {completed} completed[/]")
+    if failed:
+        parts.append(f"[red]✗ {failed} failed[/]")
+    if killed_count:
+        parts.append(f"[dim]⊘ {killed_count} killed[/]")
+
+    console.print(" │ ".join(parts))
+    console.print()
 
-            elif cmd == "kill":
-                if not args:
-                    console.print("  [red]Usage:[/] kill SESSION_ID")
-                else:
-                    do_kill(args[0])
+    # Table
+    table = Table(box=None, show_header=True, header_style="bold dim")
+    table.add_column("ID", style="cyan")
+    table.add_column("", width=2)
+    table.add_column("Task", max_width=45)
+    table.add_column("Tokens", justify="right", style="dim")
+    table.add_column("Cost", justify="right", style="dim")
 
-            elif cmd == "killall":
-                do_killall()
+    status_icons = {
+        SessionStatus.RUNNING: "[yellow]⟳[/]",
+        SessionStatus.COMPLETED: "[green]✓[/]",
+        SessionStatus.FAILED: "[red]✗[/]",
+        SessionStatus.KILLED: "[dim]⊘[/]",
+        SessionStatus.PENDING: "[dim]○[/]",
+    }
 
-            elif cmd == "clean":
-                do_clean()
+    for session in all_sessions:
+        icon = status_icons.get(session.status, "?")
+        task = session.task[:42] + "..." if len(session.task) > 45 else session.task
+        tokens = session.token_usage.get("total_tokens", 0)
+        tokens_str = f"{tokens:,}" if tokens else "-"
 
-            elif cmd in ("rm", "delete", "remove"):
-                if not args:
-                    console.print("  [red]Usage:[/] rm SESSION_ID")
-                else:
-                    do_delete(args[0])
+        # Cost estimate
+        cost_info = estimate_session_cost(session.model, session.token_usage)
+        cost_str = format_cost(cost_info.get("cost"))
 
-            else:
-                console.print(f"  [yellow]Unknown command:[/] {cmd}")
-                console.print("  [dim]Type 'help' for available commands[/]")
+        table.add_row(session.short_id, icon, task, tokens_str, cost_str)
 
-        except KeyboardInterrupt:
-            console.print("\n[dim](Ctrl+C to exit, or type 'quit')[/]")
-        except EOFError:
-            console.print("\n[dim]Goodbye![/]\n")
-            break
-        except Exception as e:
-            console.print(f"  [red]Error:[/] {e}")
+    console.print(table)
+    console.print()
+    console.print("[dim]Quick actions:  --clean (-c) delete old  │  --kill-all (-k) stop running[/]")
 
 
 # =============================================================================