zwarm 3.4.0__py3-none-any.whl → 3.7.0__py3-none-any.whl

zwarm/cli/interactive.py

@@ -153,22 +153,28 @@ STATUS_ICONS = {
 def cmd_help():
     """Show help."""
     table = Table(show_header=False, box=None, padding=(0, 2))
-    table.add_column("Command", style="cyan", width=30)
+    table.add_column("Command", style="cyan", width=35)
     table.add_column("Description")
 
     table.add_row("[bold]Session Lifecycle[/]", "")
-    table.add_row('spawn "task" [--dir PATH] [--model M]', "Start new session")
+    table.add_row('spawn "task" [--model M] [--adapter A]', "Start new session")
     table.add_row('c ID "message"', "Continue conversation")
     table.add_row("kill ID | all", "Stop session(s)")
     table.add_row("rm ID | all", "Delete session(s)")
     table.add_row("", "")
     table.add_row("[bold]Viewing[/]", "")
     table.add_row("ls", "Dashboard of all sessions")
-    table.add_row("? ID  /  peek ID", "Quick peek (status + latest)")
-    table.add_row("show ID", "Full session details")
-    table.add_row("traj ID [--full]", "Show trajectory (steps taken)")
+    table.add_row("? ID  /  peek ID", "Quick peek (status + latest preview)")
+    table.add_row("show ID [-v]", "Full response from agent (-v: verbose)")
+    table.add_row("traj ID [--full]", "Trajectory (--full: all data)")
     table.add_row("watch ID", "Live follow session output")
     table.add_row("", "")
+    table.add_row("[bold]Configuration[/]", "")
+    table.add_row("models", "List available models and adapters")
+    table.add_row("", "")
+    table.add_row("[bold]Shell[/]", "")
+    table.add_row("!<command>", "Run shell command (e.g., !ls, !git status)")
+    table.add_row("", "")
     table.add_row("[bold]Meta[/]", "")
     table.add_row("help", "Show this help")
     table.add_row("quit", "Exit")
@@ -176,6 +182,37 @@ def cmd_help():
     console.print(table)
 
 
+def cmd_models():
+    """Show available models."""
+    from zwarm.core.registry import list_models, list_adapters
+
+    table = Table(title="Available Models", box=None)
+    table.add_column("Adapter", style="cyan")
+    table.add_column("Model", style="green")
+    table.add_column("Aliases", style="dim")
+    table.add_column("Price ($/1M)", justify="right")
+    table.add_column("Description")
+
+    for adapter in list_adapters():
+        first = True
+        for model in list_models(adapter):
+            default_mark = " *" if model.is_default else ""
+            price = f"{model.input_per_million:.2f}/{model.output_per_million:.2f}"
+            aliases = ", ".join(model.aliases)
+            table.add_row(
+                adapter if first else "",
+                f"{model.canonical}{default_mark}",
+                aliases,
+                price,
+                model.description,
+            )
+            first = False
+
+    console.print(table)
+    console.print("\n[dim]* = default for adapter. Price = input/output per 1M tokens.[/]")
+    console.print("[dim]Use --model <name> or --adapter <adapter> with spawn.[/]")
+
+
 def cmd_ls(manager):
     """List all sessions."""
     from zwarm.sessions import SessionStatus
@@ -221,23 +258,35 @@ def cmd_ls(manager):
     table = Table(box=None, show_header=True, header_style="bold dim")
     table.add_column("ID", style="cyan", width=10)
     table.add_column("", width=2)
+    table.add_column("Model", width=12)
     table.add_column("T", width=2)
-    table.add_column("Task", max_width=30)
+    table.add_column("Task", max_width=26)
     table.add_column("Updated", justify="right", width=8)
-    table.add_column("Last Message", max_width=40)
+    table.add_column("Last Message", max_width=36)
 
     for s in sessions:
         icon = STATUS_ICONS.get(s.status.value, "?")
-        task_preview = s.task[:27] + "..." if len(s.task) > 30 else s.task
+        task_preview = s.task[:23] + "..." if len(s.task) > 26 else s.task
         updated = time_ago(s.updated_at)
 
+        # Short model name (e.g., "gpt-5.1-codex-mini" -> "codex-mini")
+        model_short = s.model or "?"
+        if "codex" in model_short.lower():
+            # Extract codex variant: gpt-5.1-codex-mini -> codex-mini
+            parts = model_short.split("-")
+            codex_idx = next((i for i, p in enumerate(parts) if "codex" in p.lower()), -1)
+            if codex_idx >= 0:
+                model_short = "-".join(parts[codex_idx:])
+        elif len(model_short) > 12:
+            model_short = model_short[:10] + ".."
+
         # Get last assistant message
         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 = msg.content.replace("\n", " ")[:33]
+                if len(msg.content) > 33:
                     last_msg += "..."
                 break
 
@@ -258,14 +307,110 @@ def cmd_ls(manager):
                 last_msg_styled = f"[green]{last_msg or '(done)'}[/]"
                 updated_styled = f"[dim]{updated}[/]"
         elif s.status == SessionStatus.FAILED:
-            err = s.error[:37] if s.error else "(failed)"
+            err = s.error[:33] if s.error else "(failed)"
             last_msg_styled = f"[red]{err}...[/]"
             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)
+        table.add_row(s.short_id, icon, f"[dim]{model_short}[/]", str(s.turn), task_preview, updated_styled, last_msg_styled)
+
+    console.print(table)
+
+
+def cmd_ls_multi(sessions: list, managers: dict | None = None):
+    """
+    List sessions from multiple managers.
+
+    Args:
+        sessions: List of Session objects
+        managers: Optional dict of adapter -> manager for getting messages
+    """
+    from zwarm.sessions import SessionStatus
+    from zwarm.core.costs import estimate_session_cost, format_cost
+
+    if not sessions:
+        console.print("  [dim]No sessions. Use 'spawn \"task\"' to start one.[/]")
+        return
+
+    # Summary counts
+    running = sum(1 for s in sessions if s.status == SessionStatus.RUNNING)
+    completed = sum(1 for s in sessions if s.status == SessionStatus.COMPLETED)
+    failed = sum(1 for s in sessions if s.status == SessionStatus.FAILED)
+    killed = sum(1 for s in sessions if s.status == SessionStatus.KILLED)
+
+    # Total cost and tokens
+    total_cost = 0.0
+    total_tokens = 0
+    for s in sessions:
+        cost_info = estimate_session_cost(s.model, s.token_usage)
+        if cost_info["cost"] is not None:
+            total_cost += cost_info["cost"]
+        total_tokens += s.token_usage.get("total_tokens", 0)
+
+    parts = []
+    if running:
+        parts.append(f"[yellow]{running} running[/]")
+    if completed:
+        parts.append(f"[green]{completed} done[/]")
+    if failed:
+        parts.append(f"[red]{failed} failed[/]")
+    if killed:
+        parts.append(f"[dim]{killed} killed[/]")
+    parts.append(f"[cyan]{total_tokens:,} tokens[/]")
+    parts.append(f"[green]{format_cost(total_cost)}[/]")
+    if parts:
+        console.print(" | ".join(parts))
+        console.print()
+
+    # Table
+    table = Table(box=None, show_header=True, header_style="bold dim")
+    table.add_column("ID", style="cyan", width=10)
+    table.add_column("", width=2)
+    table.add_column("Adapter", width=7)
+    table.add_column("Model", width=12)
+    table.add_column("T", width=2)
+    table.add_column("Task", max_width=24)
+    table.add_column("Updated", justify="right", width=8)
+
+    for s in sessions:
+        icon = STATUS_ICONS.get(s.status.value, "?")
+        task_preview = s.task[:21] + "..." if len(s.task) > 24 else s.task
+        updated = time_ago(s.updated_at)
+
+        # Short model name
+        model_short = s.model or "?"
+        if "codex" in model_short.lower():
+            parts = model_short.split("-")
+            codex_idx = next((i for i, p in enumerate(parts) if "codex" in p.lower()), -1)
+            if codex_idx >= 0:
+                model_short = "-".join(parts[codex_idx:])
+        elif len(model_short) > 12:
+            model_short = model_short[:10] + ".."
+
+        # Adapter short name
+        adapter_short = getattr(s, "adapter", "?")[:7]
+
+        # Style based on status
+        if s.status == SessionStatus.RUNNING:
+            updated_styled = f"[yellow]{updated}[/]"
+        elif s.status == SessionStatus.COMPLETED:
+            try:
+                dt = datetime.fromisoformat(s.updated_at)
+                is_recent = (datetime.now() - dt).total_seconds() < 60
+            except Exception:
+                is_recent = False
+            if is_recent:
+                updated_styled = f"[green bold]{updated} ★[/]"
+            else:
+                updated_styled = f"[dim]{updated}[/]"
+        elif s.status == SessionStatus.FAILED:
+            updated_styled = f"[red]{updated}[/]"
+        else:
+            updated_styled = f"[dim]{updated}[/]"
+
+        table.add_row(s.short_id, icon, f"[dim]{adapter_short}[/]", f"[dim]{model_short}[/]", str(s.turn), task_preview, updated_styled)
 
     console.print(table)
 
@@ -280,7 +425,7 @@ def cmd_peek(manager, session_id: str):
     icon = STATUS_ICONS.get(session.status.value, "?")
     console.print(f"\n{icon} [cyan]{session.short_id}[/] ({session.status.value})")
     console.print(f"  [dim]Task:[/] {session.task[:60]}...")
-    console.print(f"  [dim]Turn:[/] {session.turn} | [dim]Updated:[/] {time_ago(session.updated_at)}")
+    console.print(f"  [dim]Model:[/] {session.model} | [dim]Turn:[/] {session.turn} | [dim]Updated:[/] {time_ago(session.updated_at)}")
 
     # Latest message
     messages = manager.get_messages(session.id)
@@ -294,8 +439,15 @@ def cmd_peek(manager, session_id: str):
     console.print()
 
 
-def cmd_show(manager, session_id: str):
-    """Full session details with messages."""
+def cmd_show(manager, session_id: str, verbose: bool = False):
+    """
+    Full session details with messages.
+
+    Args:
+        manager: Session manager
+        session_id: Session to show
+        verbose: If True, show everything including full system messages
+    """
     from zwarm.core.costs import estimate_session_cost
 
     session = manager.get_session(session_id)
@@ -306,8 +458,8 @@ def cmd_show(manager, session_id: str):
     # Header
     icon = STATUS_ICONS.get(session.status.value, "?")
     console.print(f"\n{icon} [bold cyan]{session.short_id}[/] - {session.status.value}")
-    console.print(f"  [dim]Task:[/] {session.task}")
-    console.print(f"  [dim]Turn:[/] {session.turn} | [dim]Runtime:[/] {session.runtime}")
+    console.print(f"  [dim]Task:[/] {session.task[:100]}..." if len(session.task) > 100 else f"  [dim]Task:[/] {session.task}")
+    console.print(f"  [dim]Model:[/] {session.model} | [dim]Turn:[/] {session.turn} | [dim]Runtime:[/] {session.runtime}")
 
     # Token usage with cost estimate
     usage = session.token_usage
@@ -323,28 +475,40 @@ def cmd_show(manager, session_id: str):
     if session.error:
         console.print(f"  [red]Error:[/] {session.error}")
 
-    # Messages
+    # Messages - show FULL assistant response (that's the point of show)
     messages = manager.get_messages(session.id)
     if messages:
         console.print(f"\n[bold]Messages ({len(messages)}):[/]")
         for msg in messages:
             role = msg.role
-            content = msg.content[:200]
-            if len(msg.content) > 200:
-                content += "..."
+            content = msg.content
 
             if role == "user":
+                # User messages (task) can be truncated unless verbose
+                if not verbose and len(content) > 200:
+                    content = content[:200] + "..."
                 console.print(f"  [blue]USER:[/] {content}")
             elif role == "assistant":
+                # FULL assistant response - this is what users need to see
                 console.print(f"  [green]ASSISTANT:[/] {content}")
             else:
-                console.print(f"  [dim]{role.upper()}:[/] {content[:100]}")
+                # System/other messages truncated unless verbose
+                if not verbose and len(content) > 100:
+                    content = content[:100] + "..."
+                console.print(f"  [dim]{role.upper()}:[/] {content}")
 
     console.print()
 
 
 def cmd_traj(manager, session_id: str, full: bool = False):
-    """Show session trajectory."""
+    """
+    Show session trajectory.
+
+    Args:
+        manager: Session manager
+        session_id: Session to show trajectory for
+        full: If True, show full untruncated content for all steps
+    """
     session = manager.get_session(session_id)
     if not session:
         console.print(f"  [red]Session not found:[/] {session_id}")
@@ -352,7 +516,8 @@ def cmd_traj(manager, session_id: str, full: bool = False):
 
     trajectory = manager.get_trajectory(session_id, full=full)
 
-    console.print(f"\n[bold]Trajectory for {session.short_id}[/] ({len(trajectory)} steps)")
+    mode_str = "[bold green](FULL)[/]" if full else "[dim](summary - use --full for complete)[/]"
+    console.print(f"\n[bold]Trajectory for {session.short_id}[/] ({len(trajectory)} steps) {mode_str}")
     console.print(f"  [dim]Task:[/] {session.task[:60]}...")
     console.print()
 
@@ -363,33 +528,63 @@ def cmd_traj(manager, session_id: str, full: bool = False):
             text = step.get("full_text") if full else step.get("summary", "")
             console.print(f"  [dim]{i+1}.[/] [magenta]💭 thinking[/]")
             if text:
-                console.print(f"     {text[:150]}{'...' if len(text) > 150 else ''}")
+                if full:
+                    # Full mode: show everything, handle multiline
+                    for line in text.split("\n"):
+                        console.print(f"     {line}")
+                else:
+                    console.print(f"     {text[:150]}{'...' if len(text) > 150 else ''}")
 
         elif step_type == "command":
             cmd = step.get("command", "")
             output = step.get("output", "")
             exit_code = step.get("exit_code", 0)
             console.print(f"  [dim]{i+1}.[/] [yellow]$ {cmd}[/]")
-            if output and (full or len(output) < 100):
-                console.print(f"     {output[:200]}")
+            if output:
+                if full:
+                    # Full mode: show complete output
+                    for line in output.split("\n")[:50]:  # Cap at 50 lines for sanity
+                        console.print(f"     {line}")
+                    if output.count("\n") > 50:
+                        console.print(f"     [dim]... ({output.count(chr(10)) - 50} more lines)[/]")
+                else:
+                    console.print(f"     {output[:100]}{'...' if len(output) > 100 else ''}")
             if exit_code and exit_code != 0:
                 console.print(f"     [red](exit: {exit_code})[/]")
 
         elif step_type == "tool_call":
             tool = step.get("tool", "unknown")
-            args_preview = step.get("args_preview", "")
-            console.print(f"  [dim]{i+1}.[/] [cyan]🔧 {tool}[/]({args_preview})")
+            if full and step.get("full_args"):
+                import json
+                args_str = json.dumps(step["full_args"], indent=2)
+                console.print(f"  [dim]{i+1}.[/] [cyan]🔧 {tool}[/]")
+                for line in args_str.split("\n"):
+                    console.print(f"     {line}")
+            else:
+                args_preview = step.get("args_preview", "")
+                console.print(f"  [dim]{i+1}.[/] [cyan]🔧 {tool}[/]({args_preview})")
 
         elif step_type == "tool_output":
             output = step.get("output", "")
-            preview = output[:100] if not full else output[:300]
-            console.print(f"     [dim]→ {preview}[/]")
+            if full:
+                # Full mode: show complete output
+                for line in output.split("\n")[:30]:
+                    console.print(f"     [dim]→ {line}[/]")
+                if output.count("\n") > 30:
+                    console.print(f"     [dim]... ({output.count(chr(10)) - 30} more lines)[/]")
+            else:
+                console.print(f"     [dim]→ {output[:100]}{'...' if len(output) > 100 else ''}[/]")
 
         elif step_type == "message":
             text = step.get("full_text") if full else step.get("summary", "")
             console.print(f"  [dim]{i+1}.[/] [green]💬 response[/]")
             if text:
-                console.print(f"     {text[:150]}{'...' if len(text) > 150 else ''}")
+                if full:
+                    # Full mode: show everything
+                    for line in text.split("\n"):
+                        console.print(f"     {line}")
+                else:
+                    console.print(f"     {text[:150]}{'...' if len(text) > 150 else ''}")
 
     console.print()
 
@@ -409,6 +604,7 @@ def cmd_watch(manager, session_id: str):
 
     console.print(f"\n[bold]Watching {session.short_id}[/]...")
     console.print(f"  [dim]Task:[/] {session.task[:60]}...")
+    console.print(f"  [dim]Model:[/] {session.model}")
     console.print(f"  [dim]Press Ctrl+C to stop watching[/]\n")
 
     seen_steps = 0
@@ -471,20 +667,52 @@ def cmd_watch(manager, session_id: str):
     console.print()
 
 
-def cmd_spawn(manager, task: str, working_dir: Path, model: str):
-    """Spawn a new session."""
+def cmd_spawn(managers: dict, task: str, working_dir: Path, model: str, adapter: str | None = None):
+    """
+    Spawn a new session.
+
+    Args:
+        managers: Dict of adapter name -> session manager
+        task: Task description
+        working_dir: Working directory
+        model: Model name or alias
+        adapter: Adapter override (auto-detected from model if None)
+    """
+    from zwarm.core.registry import get_adapter_for_model, get_default_model, resolve_model
+
+    # Auto-detect adapter from model if not specified
+    if adapter is None:
+        detected = get_adapter_for_model(model)
+        if detected:
+            adapter = detected
+        else:
+            # Default to codex if model not recognized
+            adapter = "codex"
+
+    # Resolve model alias to canonical name if needed
+    model_info = resolve_model(model)
+    effective_model = model_info.canonical if model_info else model
+
+    # Get the right manager
+    if adapter not in managers:
+        console.print(f"  [red]Unknown adapter:[/] {adapter}")
+        console.print(f"  [dim]Available: {', '.join(managers.keys())}[/]")
+        return
+
+    manager = managers[adapter]
+
     console.print(f"\n[dim]Spawning session...[/]")
+    console.print(f"  [dim]Adapter:[/] {adapter}")
+    console.print(f"  [dim]Model:[/] {effective_model}")
     console.print(f"  [dim]Dir:[/] {working_dir}")
-    console.print(f"  [dim]Model:[/] {model}")
 
     try:
         session = manager.start_session(
             task=task,
             working_dir=working_dir,
-            model=model,
+            model=effective_model,
             sandbox="workspace-write",
             source="user",
-            adapter="codex",
         )
 
         console.print(f"\n[green]✓[/] Session: [cyan]{session.short_id}[/]")
@@ -613,13 +841,34 @@ def run_interactive(
         working_dir: Default working directory for sessions
         model: Default model for sessions
     """
-    from zwarm.sessions import CodexSessionManager
+    from zwarm.sessions import get_session_manager
+    from zwarm.core.registry import get_adapter_for_model, list_adapters
 
-    manager = CodexSessionManager(working_dir / ".zwarm")
+    # Initialize managers for all adapters
+    state_dir = working_dir / ".zwarm"
+    managers = {}
+    for adapter in list_adapters():
+        try:
+            managers[adapter] = get_session_manager(adapter, str(state_dir))
+        except Exception:
+            pass  # Adapter not available
+
+    if not managers:
+        console.print("[red]No adapters available. Run 'zwarm init' first.[/]")
+        return
+
+    # Primary manager for listing (aggregates across all adapters)
+    primary_adapter = get_adapter_for_model(model) or "codex"
+    if primary_adapter not in managers:
+        primary_adapter = list(managers.keys())[0]
 
     # Setup prompt with autocomplete
     def get_sessions():
-        return manager.list_sessions()
+        # Aggregate sessions from all managers
+        all_sessions = []
+        for mgr in managers.values():
+            all_sessions.extend(mgr.list_sessions())
+        return all_sessions
 
     completer = SessionCompleter(get_sessions)
     style = Style.from_dict({
@@ -637,7 +886,8 @@ def run_interactive(
     console.print("\n[bold cyan]zwarm interactive[/] - Session Manager\n")
     console.print(f"  [dim]Dir:[/] {working_dir.absolute()}")
     console.print(f"  [dim]Model:[/] {model}")
-    console.print(f"\n  Type [cyan]help[/] for commands, [cyan]quit[/] to exit.")
+    console.print(f"  [dim]Adapters:[/] {', '.join(managers.keys())}")
+    console.print(f"\n  Type [cyan]help[/] for commands, [cyan]models[/] to see available models.")
     console.print(f"  [dim]Tab to autocomplete session IDs[/]\n")
 
     # REPL
@@ -647,6 +897,29 @@ def run_interactive(
             if not raw:
                 continue
 
+            # Bang command: !cmd runs shell command
+            if raw.startswith("!"):
+                import subprocess
+                shell_cmd = raw[1:].strip()
+                if shell_cmd:
+                    try:
+                        result = subprocess.run(
+                            shell_cmd,
+                            shell=True,
+                            cwd=working_dir,
+                            capture_output=True,
+                            text=True,
+                        )
+                        if result.stdout:
+                            console.print(result.stdout.rstrip())
+                        if result.stderr:
+                            console.print(f"[red]{result.stderr.rstrip()}[/]")
+                        if result.returncode != 0:
+                            console.print(f"[dim](exit code: {result.returncode})[/]")
+                    except Exception as e:
+                        console.print(f"[red]Error:[/] {e}")
+                continue
+
             try:
                 parts = shlex.split(raw)
             except ValueError:
@@ -655,6 +928,26 @@ def run_interactive(
             cmd = parts[0].lower()
             args = parts[1:]
 
+            # Helper to find session and return the correct manager for its adapter
+            def find_session(sid: str):
+                # First, find the session (any manager can load it)
+                session = None
+                for mgr in managers.values():
+                    session = mgr.get_session(sid)
+                    if session:
+                        break
+
+                if not session:
+                    return None, None
+
+                # Return the manager that matches the session's adapter
+                adapter = getattr(session, "adapter", "codex")
+                if adapter in managers:
+                    return managers[adapter], session
+                else:
+                    # Fallback to whichever manager found it
+                    return mgr, session
+
             # Dispatch
             if cmd in ("q", "quit", "exit"):
                 console.print("\n[dim]Goodbye![/]\n")
@@ -663,20 +956,45 @@ def run_interactive(
             elif cmd in ("h", "help"):
                 cmd_help()
 
+            elif cmd == "models":
+                cmd_models()
+
             elif cmd in ("ls", "list"):
-                cmd_ls(manager)
+                # Aggregate sessions from all managers
+                from zwarm.sessions import SessionStatus
+                from zwarm.core.costs import estimate_session_cost, format_cost
+
+                all_sessions = []
+                for mgr in managers.values():
+                    all_sessions.extend(mgr.list_sessions())
+
+                if not all_sessions:
+                    console.print("  [dim]No sessions. Use 'spawn \"task\"' to start one.[/]")
+                else:
+                    # Use first manager's cmd_ls logic but with aggregated sessions
+                    cmd_ls_multi(all_sessions, managers)
 
             elif cmd in ("?", "peek"):
                 if not args:
                     console.print("  [red]Usage:[/] peek ID")
                 else:
-                    cmd_peek(manager, args[0])
+                    mgr, _ = find_session(args[0])
+                    if mgr:
+                        cmd_peek(mgr, args[0])
+                    else:
+                        console.print(f"  [red]Session not found:[/] {args[0]}")
 
             elif cmd == "show":
                 if not args:
-                    console.print("  [red]Usage:[/] show ID")
+                    console.print("  [red]Usage:[/] show ID [-v]")
                 else:
-                    cmd_show(manager, args[0])
+                    verbose = "-v" in args or "--verbose" in args
+                    sid = [a for a in args if not a.startswith("-")][0]
+                    mgr, _ = find_session(sid)
+                    if mgr:
+                        cmd_show(mgr, sid, verbose=verbose)
+                    else:
+                        console.print(f"  [red]Session not found:[/] {sid}")
 
             elif cmd in ("traj", "trajectory"):
                 if not args:
@@ -684,22 +1002,31 @@ def run_interactive(
                 else:
                     full = "--full" in args
                     sid = [a for a in args if not a.startswith("-")][0]
-                    cmd_traj(manager, sid, full=full)
+                    mgr, _ = find_session(sid)
+                    if mgr:
+                        cmd_traj(mgr, sid, full=full)
+                    else:
+                        console.print(f"  [red]Session not found:[/] {sid}")
 
             elif cmd == "watch":
                 if not args:
                     console.print("  [red]Usage:[/] watch ID")
                 else:
-                    cmd_watch(manager, args[0])
+                    mgr, _ = find_session(args[0])
+                    if mgr:
+                        cmd_watch(mgr, args[0])
+                    else:
+                        console.print(f"  [red]Session not found:[/] {args[0]}")
 
             elif cmd == "spawn":
                 if not args:
-                    console.print("  [red]Usage:[/] spawn \"task\" [--dir PATH] [--search]")
+                    console.print("  [red]Usage:[/] spawn \"task\" [--model M] [--adapter A]")
                 else:
                     # Parse spawn args
                     task_parts = []
                     spawn_dir = working_dir
                     spawn_model = model
+                    spawn_adapter = None
                     i = 0
                     while i < len(args):
                         if args[i] in ("--dir", "-d") and i + 1 < len(args):
@@ -708,13 +1035,16 @@ def run_interactive(
                         elif args[i] in ("--model", "-m") and i + 1 < len(args):
                             spawn_model = args[i + 1]
                             i += 2
+                        elif args[i] in ("--adapter", "-a") and i + 1 < len(args):
+                            spawn_adapter = args[i + 1]
+                            i += 2
                         else:
                             task_parts.append(args[i])
                             i += 1
 
                     task = " ".join(task_parts)
                     if task:
-                        cmd_spawn(manager, task, spawn_dir, spawn_model)
+                        cmd_spawn(managers, task, spawn_dir, spawn_model, spawn_adapter)
                     else:
                         console.print("  [red]Task required[/]")
 
@@ -722,19 +1052,57 @@ def run_interactive(
                 if len(args) < 2:
                     console.print("  [red]Usage:[/] c ID \"message\"")
                 else:
-                    cmd_continue(manager, args[0], " ".join(args[1:]))
+                    mgr, _ = find_session(args[0])
+                    if mgr:
+                        cmd_continue(mgr, args[0], " ".join(args[1:]))
+                    else:
+                        console.print(f"  [red]Session not found:[/] {args[0]}")
 
             elif cmd == "kill":
                 if not args:
                     console.print("  [red]Usage:[/] kill ID | all")
+                elif args[0].lower() == "all":
+                    # Kill all running across all managers
+                    killed = 0
+                    for mgr in managers.values():
+                        from zwarm.sessions import SessionStatus
+                        for s in mgr.list_sessions(status=SessionStatus.RUNNING):
+                            if mgr.kill_session(s.id):
+                                killed += 1
+                                console.print(f"  [green]✓[/] Killed {s.short_id}")
+                    if killed:
+                        console.print(f"\n[green]Killed {killed} session(s)[/]")
+                    else:
+                        console.print("  [dim]No running sessions[/]")
                 else:
-                    cmd_kill(manager, args[0])
+                    mgr, _ = find_session(args[0])
+                    if mgr:
+                        cmd_kill(mgr, args[0])
+                    else:
+                        console.print(f"  [red]Session not found:[/] {args[0]}")
 
             elif cmd in ("rm", "delete"):
                 if not args:
                     console.print("  [red]Usage:[/] rm ID | all")
+                elif args[0].lower() == "all":
+                    # Delete all non-running across all managers
+                    deleted = 0
+                    for mgr in managers.values():
+                        from zwarm.sessions import SessionStatus
+                        for s in mgr.list_sessions():
+                            if s.status != SessionStatus.RUNNING:
+                                if mgr.delete_session(s.id):
+                                    deleted += 1
+                    if deleted:
+                        console.print(f"[green]✓[/] Deleted {deleted} session(s)")
+                    else:
+                        console.print("  [dim]Nothing to delete[/]")
                 else:
-                    cmd_rm(manager, args[0])
+                    mgr, _ = find_session(args[0])
+                    if mgr:
+                        cmd_rm(mgr, args[0])
+                    else:
+                        console.print(f"  [red]Session not found:[/] {args[0]}")
 
             else:
                 console.print(f"  [yellow]Unknown command:[/] {cmd}")