zwarm 1.3.5__py3-none-any.whl → 1.3.9__py3-none-any.whl

zwarm/cli/main.py

@@ -1090,7 +1090,6 @@ def clean(
 
 @app.command()
 def interactive(
-    default_adapter: Annotated[AdapterType, typer.Option("--adapter", "-a", help="Default executor adapter")] = AdapterType.codex_mcp,
     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,
     state_dir: Annotated[Path, typer.Option("--state-dir", help="State directory for persistence")] = Path(".zwarm"),
@@ -1098,156 +1097,132 @@ def interactive(
     """
     Universal multi-agent CLI for commanding coding agents.
 
-    Spawn multiple agents (Codex, Claude Code) across different directories,
-    manage them interactively, and view their outputs. You are the orchestrator.
+    Spawn multiple agents across different directories, manage them interactively,
+    and view their outputs. You are the orchestrator.
 
     [bold]Commands:[/]
-        [cyan]spawn[/] "task" [opts]      Start a session (see spawn --help)
+        [cyan]spawn[/] "task" [opts]      Start a coding agent session
+        [cyan]orchestrate[/] "task"       Start an orchestrator agent
         [cyan]ls[/] / [cyan]list[/]               Dashboard of all sessions
-        [cyan]?[/] / [cyan]check[/] ID            Check session status & response
-        [cyan]c[/] / [cyan]converse[/] ID "msg"   Continue sync conversation
-        [cyan]view[/] ID                  Open session output in $EDITOR
+        [cyan]?[/] / [cyan]show[/] ID             Check session status & response
+        [cyan]c[/] / [cyan]continue[/] ID "msg"   Continue a completed session
+        [cyan]logs[/] ID                  Show raw JSONL output
         [cyan]kill[/] ID                  Stop a session
         [cyan]killall[/]                  Stop all running sessions
-        [cyan]refresh[/]                  Poll all async sessions
         [cyan]q[/] / [cyan]quit[/]                Exit
 
     [bold]Spawn Options:[/]
-        spawn "task" --dir ~/project --adapter claude_code --async
+        spawn "task" --dir ~/project --model gpt-5.1-codex-max
 
     [bold]Examples:[/]
         $ zwarm interactive
-        > spawn "Build auth module" --dir ~/api --async
-        > spawn "Fix tests" --dir ~/api --async
-        > spawn "Add docs" --dir ~/docs
+        > spawn "Build auth module" --dir ~/api
+        > spawn "Fix tests" --dir ~/api
+        > orchestrate "Refactor the entire API layer"
         > ls
         > ? abc123
-        > view abc123
     """
-    from zwarm.adapters import get_adapter, list_adapters
-    from zwarm.core.models import ConversationSession
+    from zwarm.sessions import CodexSessionManager, SessionStatus
     import argparse
-    import tempfile
     import subprocess as sp
 
-    console.print("\n[bold cyan]zwarm interactive[/] - Universal Multi-Agent CLI\n")
-    console.print(f"  Default adapter: [cyan]{default_adapter.value}[/]")
-    console.print(f"  Default dir: {default_dir.absolute()}")
-    console.print(f"  Available adapters: {', '.join(list_adapters())}")
-    console.print("\n  Type [cyan]help[/] for commands, [cyan]quit[/] to exit.\n")
+    # Initialize session manager
+    manager = CodexSessionManager(state_dir)
+    default_model = model or "gpt-5.1-codex-mini"
 
-    # Adapter cache (lazy-loaded per adapter type)
-    adapters: dict[str, Any] = {}
-
-    def get_or_create_adapter(adapter_name: str, adapter_model: str | None = None) -> Any:
-        """Get cached adapter or create new one."""
-        key = f"{adapter_name}:{adapter_model or 'default'}"
-        if key not in adapters:
-            adapters[key] = get_adapter(adapter_name, model=adapter_model)
-        return adapters[key]
-
-    # Session tracking with metadata
-    sessions: dict[str, ConversationSession] = {}
-    session_dirs: dict[str, Path] = {}  # session_id -> working_dir
-    session_adapters: dict[str, str] = {}  # session_id -> adapter_name
-
-    # Persistence directory
-    interactive_state_dir = state_dir / "interactive"
-    interactive_state_dir.mkdir(parents=True, exist_ok=True)
-
-    def short_id(session_id: str) -> str:
-        """Get short display ID."""
-        return session_id[:8]
-
-    def find_session(query: str) -> tuple[ConversationSession | None, str | None]:
-        """Find session by full or partial ID. Returns (session, full_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
-
-    def save_session_output(session: ConversationSession) -> Path:
-        """Save session output to file for viewing."""
-        session_dir = interactive_state_dir / short_id(session.id)
-        session_dir.mkdir(exist_ok=True)
-
-        output_file = session_dir / "output.txt"
-        with open(output_file, "w") as f:
-            f.write(f"Session: {session.id}\n")
-            f.write(f"Task: {session.task_description}\n")
-            f.write(f"Adapter: {session.adapter}\n")
-            f.write(f"Model: {session.model}\n")
-            f.write(f"Status: {session.status.value}\n")
-            f.write(f"Mode: {session.mode.value}\n")
-            f.write(f"Working Dir: {session.working_dir}\n")
-            f.write(f"Tokens: {session.token_usage}\n")
-            f.write("\n" + "="*60 + "\n\n")
-
-            for msg in session.messages:
-                f.write(f"[{msg.role.upper()}]\n")
-                f.write(msg.content)
-                f.write("\n\n" + "-"*40 + "\n\n")
-
-        return output_file
+    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"  Sessions: {state_dir / 'sessions'}")
+    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 new session")
-        help_table.add_row("  --dir PATH", "Working directory for this session")
-        help_table.add_row("  --adapter NAME", f"Adapter ({', '.join(list_adapters())})")
-        help_table.add_row("  --async / -a", "Fire-and-forget mode")
+        help_table.add_row('spawn "task" [options]', "Start a coding agent")
+        help_table.add_row("  --dir PATH", "Working directory")
         help_table.add_row("  --model NAME", "Model override")
         help_table.add_row("", "")
-        help_table.add_row("ls / list", "Dashboard of all sessions")
-        help_table.add_row("? / check ID", "Check session status & messages")
-        help_table.add_row("c / converse ID \"msg\"", "Continue sync conversation")
-        help_table.add_row("view ID", "Open session output in $EDITOR")
-        help_table.add_row("raw ID", "Show raw session JSON")
-        help_table.add_row("kill ID", "Stop a session")
+        help_table.add_row('orchestrate "task" [options]', "Start an orchestrator agent")
+        help_table.add_row("  --dir PATH", "Working directory")
+        help_table.add_row("", "")
+        help_table.add_row("ls / list [--all]", "Dashboard of sessions")
+        help_table.add_row("? / show ID", "Show session messages")
+        help_table.add_row("c / continue ID \"msg\"", "Continue a completed session")
+        help_table.add_row("logs ID [-f]", "Show raw JSONL output")
+        help_table.add_row("kill ID", "Stop a running session")
         help_table.add_row("killall", "Stop all running sessions")
-        help_table.add_row("refresh", "Poll all async sessions for updates")
-        help_table.add_row("q / quit", "Exit interactive mode")
+        help_table.add_row("clean", "Remove completed sessions")
+        help_table.add_row("q / quit", "Exit")
         console.print(help_table)
 
-    def show_sessions():
+    def show_sessions(show_all: bool = False):
+        sessions = manager.list_sessions()
+
+        if not show_all:
+            # Show running + recent completed
+            sessions = [s for s in sessions if s.status == SessionStatus.RUNNING or s.status == SessionStatus.COMPLETED][:20]
+
         if not sessions:
-            console.print("  [dim]No sessions yet. Use 'spawn \"task\"' to start one.[/]")
+            console.print("  [dim]No sessions. Use 'spawn \"task\"' to start one.[/]")
             return
 
-        table = Table(title="Sessions Dashboard", show_header=True)
+        # Status summary
+        all_sessions = manager.list_sessions()
+        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)
+
+        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 summary_parts:
+            console.print(" | ".join(summary_parts))
+            console.print()
+
+        table = Table(box=None, show_header=True, header_style="bold dim")
         table.add_column("ID", style="cyan", width=10)
-        table.add_column("Status", width=12)
-        table.add_column("Adapter", width=12)
-        table.add_column("Dir", width=20)
-        table.add_column("Tokens", width=8, justify="right")
-        table.add_column("Task", width=35)
-
-        for sid, s in sessions.items():
-            status_icons = {
-                "active": "[green]● active[/]",
-                "completed": "[dim]✓ done[/]",
-                "failed": "[red]✗ failed[/]",
-            }
-            status = status_icons.get(s.status.value, f"? {s.status.value}")
+        table.add_column("", width=2)  # Status icon
+        table.add_column("Source", width=10)
+        table.add_column("Task", max_width=40)
+        table.add_column("Runtime", justify="right", style="dim", width=8)
+        table.add_column("Tokens", justify="right", style="dim", width=8)
+
+        status_icons = {
+            SessionStatus.RUNNING: "[yellow]⟳[/]",
+            SessionStatus.COMPLETED: "[green]✓[/]",
+            SessionStatus.FAILED: "[red]✗[/]",
+            SessionStatus.KILLED: "[dim]⊘[/]",
+            SessionStatus.PENDING: "[dim]○[/]",
+        }
 
-            # Add mode indicator
-            if s.mode.value == "async" and s.status.value == "active":
-                status = "[yellow]⟳ running[/]"
-
-            work_dir = session_dirs.get(sid, s.working_dir)
-            dir_display = str(work_dir.name) if work_dir else "."
+        for s in sessions:
+            icon = status_icons.get(s.status, "?")
+            task_preview = s.task[:37] + "..." if len(s.task) > 40 else s.task
+            tokens = s.token_usage.get("total_tokens", 0)
+            tokens_str = f"{tokens:,}" if tokens else "-"
+
+            # Source display with styling
+            source = s.source_display
+            if source == "you":
+                source_styled = "[blue]you[/]"
+            elif source.startswith("orch:"):
+                source_styled = f"[magenta]{source}[/]"
+            else:
+                source_styled = f"[dim]{source}[/]"
 
             table.add_row(
-                short_id(sid),
-                status,
-                s.adapter,
-                dir_display,
-                str(s.token_usage.get("total_tokens", 0)),
-                s.task_description[:32] + "..." if len(s.task_description) > 32 else s.task_description,
+                s.short_id,
+                icon,
+                source_styled,
+                task_preview,
+                s.runtime,
+                tokens_str,
             )
 
         console.print(table)
@@ -1257,240 +1232,264 @@ def interactive(
         parser = argparse.ArgumentParser(add_help=False)
         parser.add_argument("task", nargs="*")
         parser.add_argument("--dir", "-d", type=Path, default=None)
-        parser.add_argument("--adapter", default=None)
         parser.add_argument("--model", "-m", default=None)
-        parser.add_argument("--async", "-a", dest="is_async", action="store_true")
 
         try:
             parsed, _ = parser.parse_known_args(args)
             return {
                 "task": " ".join(parsed.task) if parsed.task else "",
                 "dir": parsed.dir,
-                "adapter": parsed.adapter,
                 "model": parsed.model,
-                "is_async": parsed.is_async,
             }
         except SystemExit:
             return {"error": "Invalid spawn arguments"}
 
     def do_spawn(args: list[str]):
-        """Spawn a new session with optional per-session config."""
+        """Spawn a new coding agent session."""
         parsed = parse_spawn_args(args)
 
         if "error" in parsed:
             console.print(f"  [red]{parsed['error']}[/]")
-            console.print("  [dim]Usage: spawn \"task\" [--dir PATH] [--adapter NAME] [--async][/]")
+            console.print("  [dim]Usage: spawn \"task\" [--dir PATH] [--model NAME][/]")
             return
 
         if not parsed["task"]:
             console.print("  [red]Task required[/]")
-            console.print("  [dim]Usage: spawn \"task\" [--dir PATH] [--adapter NAME] [--async][/]")
+            console.print("  [dim]Usage: spawn \"task\" [--dir PATH] [--model NAME][/]")
             return
 
         task = parsed["task"]
         work_dir = (parsed["dir"] or default_dir).absolute()
-        adapter_name = parsed["adapter"] or default_adapter.value
-        adapter_model = parsed["model"] or model
-        mode = "async" if parsed["is_async"] else "sync"
+        session_model = parsed["model"] or default_model
 
-        # Validate directory exists
         if not work_dir.exists():
             console.print(f"  [red]Directory not found:[/] {work_dir}")
             return
 
-        console.print(f"\n[dim]Spawning {mode} session...[/]")
+        console.print(f"\n[dim]Spawning session...[/]")
         console.print(f"  [dim]Dir: {work_dir}[/]")
-        console.print(f"  [dim]Adapter: {adapter_name}[/]")
+        console.print(f"  [dim]Model: {session_model}[/]")
 
         try:
-            executor = get_or_create_adapter(adapter_name, adapter_model)
-            session = asyncio.run(
-                executor.start_session(
-                    task=task,
-                    working_dir=work_dir,
-                    mode=mode,
-                    model=adapter_model,
-                )
+            session = manager.start_session(
+                task=task,
+                working_dir=work_dir,
+                model=session_model,
+                source="user",
+                adapter="codex",
             )
 
-            sessions[session.id] = session
-            session_dirs[session.id] = work_dir
-            session_adapters[session.id] = adapter_name
-
-            console.print(f"  [green]✓[/] Session: [cyan]{short_id(session.id)}[/]")
-            console.print(f"  Tokens: {session.token_usage.get('total_tokens', 0)}")
-
-            if mode == "sync" and session.messages:
-                for msg in session.messages:
-                    if msg.role == "assistant":
-                        console.print(f"\n[bold]Response:[/]")
-                        content = msg.content[:2000] + ("..." if len(msg.content) > 2000 else "")
-                        console.print(Panel(content, border_style="green"))
-            else:
-                console.print(f"  [dim]Async session started. Use '? {short_id(session.id)}' to check status.[/]")
-
-            # Save output for viewing
-            save_session_output(session)
+            console.print(f"\n[green]✓[/] Session: [cyan]{session.short_id}[/]")
+            console.print(f"  PID: {session.pid}")
+            console.print(f"\n[dim]Use '? {session.short_id}' to check status[/]")
 
         except Exception as e:
             console.print(f"  [red]Error:[/] {e}")
             import traceback
             console.print(f"  [dim]{traceback.format_exc()}[/]")
 
-    def do_converse(session_id: str, message: str):
-        session, sid = find_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[/]")
+    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 session.mode.value != "sync":
-            console.print(f"  [yellow]Warning:[/] Session is async, can't converse")
+        if not parsed["task"]:
+            console.print("  [red]Task required[/]")
+            console.print("  [dim]Usage: orchestrate \"task\" [--dir PATH][/]")
             return
 
-        if session.status.value != "active":
-            console.print(f"  [yellow]Warning:[/] Session is {session.status.value}")
+        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]Sending message to {short_id(session.id)}...[/]")
+        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 ''}[/]")
+
+        import subprocess
+        from uuid import uuid4
+
+        # Generate instance ID for tracking
+        instance_id = str(uuid4())[:8]
+
+        # 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,
+        ]
+
+        # 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"
 
         try:
-            adapter_name = session_adapters.get(sid, default_adapter.value)
-            executor = get_or_create_adapter(adapter_name)
-            response = asyncio.run(executor.send_message(session, message))
-            console.print(f"  [green]✓[/] Response received")
-            console.print(f"  Tokens: {session.token_usage.get('total_tokens', 0)}")
-            console.print(f"\n[bold]Response:[/]")
-            console.print(Panel(response[:2000] + ("..." if len(response) > 2000 else ""), border_style="green"))
+            with open(log_file, "w") as f:
+                proc = subprocess.Popen(
+                    cmd,
+                    cwd=work_dir,
+                    stdout=f,
+                    stderr=subprocess.STDOUT,
+                    start_new_session=True,
+                )
 
-            # Update saved output
-            save_session_output(session)
+            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[/]")
 
         except Exception as e:
-            console.print(f"  [red]Error:[/] {e}")
+            console.print(f"  [red]Error starting orchestrator:[/] {e}")
 
-    def do_check(session_id: str):
-        session, sid = find_session(session_id)
+    def do_show(session_id: str):
+        """Show session details and messages."""
+        session = manager.get_session(session_id)
         if not session:
             console.print(f"  [red]Session not found:[/] {session_id}")
             return
 
-        work_dir = session_dirs.get(sid, session.working_dir)
+        # Get messages
+        messages = manager.get_messages(session.id)
 
-        console.print(f"\n[bold]Session {short_id(session.id)}[/]")
-        console.print(f"  Status: {session.status.value}")
-        console.print(f"  Mode: {session.mode.value}")
-        console.print(f"  Adapter: {session.adapter}")
-        console.print(f"  Model: {session.model}")
-        console.print(f"  Directory: {work_dir}")
-        console.print(f"  Messages: {len(session.messages)}")
-        console.print(f"  Tokens: {session.token_usage}")
-        console.print(f"  Task: {session.task_description}")
+        # Status styling
+        status_display = {
+            "running": "[yellow]⟳ running[/]",
+            "completed": "[green]✓ completed[/]",
+            "failed": "[red]✗ failed[/]",
+            "killed": "[dim]⊘ killed[/]",
+            "pending": "[dim]○ pending[/]",
+        }.get(session.status.value, session.status.value)
 
-        if session.mode.value == "async" and session.status.value == "active":
-            try:
-                adapter_name = session_adapters.get(sid, default_adapter.value)
-                executor = get_or_create_adapter(adapter_name)
-                status = asyncio.run(executor.check_status(session))
-                console.print(f"\n[bold]Async status:[/]")
-                for k, v in status.items():
-                    if k != "events":  # Skip verbose events
-                        val_str = str(v)[:200] + "..." if len(str(v)) > 200 else str(v)
-                        console.print(f"  {k}: {val_str}")
-
-                # Update saved output after status check
-                save_session_output(session)
-
-            except Exception as e:
-                console.print(f"  [red]Status check error:[/] {e}")
-
-        # Show messages
-        if session.messages:
-            console.print(f"\n[bold]Messages:[/]")
-            for i, msg in enumerate(session.messages):
-                role_color = {"user": "blue", "assistant": "green", "system": "yellow"}.get(msg.role, "white")
-                content_preview = msg.content[:500] + "..." if len(msg.content) > 500 else msg.content
-                console.print(f"  [{role_color}]{msg.role}[/]: {content_preview}")
-
-    def do_view(session_id: str):
-        """Open session output in $EDITOR."""
-        session, sid = find_session(session_id)
+        console.print()
+        console.print(f"[bold cyan]Session {session.short_id}[/]  {status_display}")
+        console.print(f"[dim]Source:[/] {session.source_display}  [dim]│[/]  [dim]Model:[/] {session.model}")
+        console.print(f"[dim]Task:[/] {session.task}")
+        console.print(f"[dim]Dir:[/] {session.working_dir}  [dim]│[/]  [dim]Runtime:[/] {session.runtime}")
+        console.print()
+
+        if not messages:
+            if session.status == SessionStatus.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":
+                if msg.content.startswith("[Calling:"):
+                    console.print(f"  [dim]⚙[/] {msg.content}")
+                else:
+                    console.print(f"    [dim]└─ {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_continue(session_id: str, message: str):
+        """Continue a completed session with a follow-up message."""
+        session = manager.get_session(session_id)
         if not session:
             console.print(f"  [red]Session not found:[/] {session_id}")
             return
 
-        output_file = save_session_output(session)
-        editor = os.environ.get("EDITOR", "less")
+        if session.status == SessionStatus.RUNNING:
+            console.print("[yellow]Session is still running.[/]")
+            console.print("[dim]Wait for it to complete, then continue.[/]")
+            return
 
-        console.print(f"  [dim]Opening {output_file} in {editor}...[/]")
-        try:
-            sp.run([editor, str(output_file)])
-        except Exception as e:
-            console.print(f"  [red]Error opening editor:[/] {e}")
-            console.print(f"  [dim]File saved at: {output_file}[/]")
+        console.print(f"\n[dim]Injecting message into {session.short_id}...[/]")
+
+        updated = manager.inject_message(session.id, message)
+        if updated:
+            console.print(f"[green]✓[/] Turn {updated.turn} started")
+            console.print(f"  PID: {updated.pid}")
+            console.print(f"\n[dim]Use '? {session.short_id}' to check status[/]")
+        else:
+            console.print("[red]Failed to inject message.[/]")
 
-    def do_raw(session_id: str):
-        """Show raw session data for debugging."""
-        session, _ = find_session(session_id)
+    def do_logs(session_id: str, follow: bool = False):
+        """Show raw JSONL logs for a session."""
+        session = manager.get_session(session_id)
         if not session:
             console.print(f"  [red]Session not found:[/] {session_id}")
             return
 
-        import json
-        console.print(f"\n[bold]Raw session data for {short_id(session.id)}:[/]")
-        console.print(json.dumps(session.to_dict(), indent=2, default=str))
+        if follow and session.status == SessionStatus.RUNNING:
+            import time
+            output_path = manager._output_path(session.id, session.turn)
+            console.print(f"[dim]Following {output_path}... (Ctrl+C to stop)[/]\n")
+
+            try:
+                with open(output_path, "r") as f:
+                    for line in f:
+                        console.print(line.rstrip())
+                    while session.is_running:
+                        line = f.readline()
+                        if line:
+                            console.print(line.rstrip())
+                        else:
+                            time.sleep(0.5)
+                            session = manager.get_session(session_id)
+            except KeyboardInterrupt:
+                console.print("\n[dim]Stopped.[/]")
+        else:
+            output = manager.get_output(session.id)
+            if output:
+                console.print(output)
+            else:
+                console.print("[dim]No output yet.[/]")
 
     def do_kill(session_id: str):
-        session, sid = find_session(session_id)
+        """Kill a running session."""
+        session = manager.get_session(session_id)
         if not session:
             console.print(f"  [red]Session not found:[/] {session_id}")
             return
 
-        try:
-            adapter_name = session_adapters.get(sid, default_adapter.value)
-            executor = get_or_create_adapter(adapter_name)
-            asyncio.run(executor.stop(session))
-            console.print(f"  [green]✓[/] Session {short_id(session.id)} killed")
-            save_session_output(session)
-        except Exception as e:
-            console.print(f"  [red]Error:[/] {e}")
+        if not session.is_running:
+            console.print(f"[yellow]Session {session.short_id} is not running.[/]")
+            return
+
+        if manager.kill_session(session.id):
+            console.print(f"[green]✓[/] Killed session {session.short_id}")
+        else:
+            console.print(f"[red]Failed to kill session[/]")
 
     def do_killall():
         """Kill all running sessions."""
+        sessions = manager.list_sessions(status=SessionStatus.RUNNING)
         killed = 0
-        for sid, session in sessions.items():
-            if session.status.value == "active":
-                try:
-                    adapter_name = session_adapters.get(sid, default_adapter.value)
-                    executor = get_or_create_adapter(adapter_name)
-                    asyncio.run(executor.stop(session))
-                    killed += 1
-                except Exception:
-                    pass
-        console.print(f"  [green]✓[/] Killed {killed} sessions")
-
-    def do_refresh():
-        """Poll all async sessions for status updates."""
-        updated = 0
-        for sid, session in sessions.items():
-            if session.mode.value == "async" and session.status.value == "active":
-                try:
-                    adapter_name = session_adapters.get(sid, default_adapter.value)
-                    executor = get_or_create_adapter(adapter_name)
-                    status = asyncio.run(executor.check_status(session))
-                    save_session_output(session)
-                    updated += 1
-
-                    if status.get("status") in ("completed", "failed"):
-                        icon = "[green]✓[/]" if status["status"] == "completed" else "[red]✗[/]"
-                        console.print(f"  {icon} {short_id(sid)}: {status['status']}")
-                except Exception as e:
-                    console.print(f"  [red]✗[/] {short_id(sid)}: {e}")
-
-        if updated == 0:
-            console.print("  [dim]No async sessions to refresh[/]")
-        else:
-            console.print(f"  [dim]Refreshed {updated} sessions[/]")
+        for session in sessions:
+            if manager.kill_session(session.id):
+                killed += 1
+        console.print(f"[green]✓[/] Killed {killed} sessions")
+
+    def do_clean():
+        """Remove completed sessions."""
+        cleaned = manager.cleanup_completed(keep_days=0)
+        console.print(f"[green]✓[/] Cleaned {cleaned} sessions")
 
     # REPL loop
     import shlex
@@ -1505,15 +1504,13 @@ def interactive(
             try:
                 parts = shlex.split(raw_input)
             except ValueError:
-                # Handle unclosed quotes
                 parts = raw_input.split()
 
             cmd = parts[0].lower()
             args = parts[1:]
 
             if cmd in ("q", "quit", "exit"):
-                # Offer to kill running sessions
-                running = [s for s in sessions.values() if s.status.value == "active"]
+                running = manager.list_sessions(status=SessionStatus.RUNNING)
                 if running:
                     console.print(f"  [yellow]Warning:[/] {len(running)} sessions still running")
                     console.print("  [dim]Use 'killall' first, or they'll continue in background[/]")
@@ -1524,47 +1521,34 @@ def interactive(
                 show_help()
 
             elif cmd in ("ls", "list"):
-                show_sessions()
+                show_all = "--all" in args or "-a" in args
+                show_sessions(show_all)
 
             elif cmd == "spawn":
                 do_spawn(args)
 
-            # Keep old shortcuts for convenience
-            elif cmd in ("d", "delegate"):
-                if not args:
-                    console.print("  [red]Usage:[/] d \"task\" or spawn \"task\" [options]")
-                else:
-                    do_spawn(args)  # Sync by default
+            elif cmd == "orchestrate":
+                do_orchestrate(args)
 
-            elif cmd in ("a", "async"):
+            elif cmd in ("?", "show"):
                 if not args:
-                    console.print("  [red]Usage:[/] a \"task\" or spawn \"task\" --async")
+                    console.print("  [red]Usage:[/] ? SESSION_ID")
                 else:
-                    do_spawn(args + ["--async"])
+                    do_show(args[0])
 
-            elif cmd in ("c", "converse"):
+            elif cmd in ("c", "continue"):
                 if len(args) < 2:
                     console.print("  [red]Usage:[/] c SESSION_ID \"message\"")
                 else:
-                    do_converse(args[0], " ".join(args[1:]))
+                    do_continue(args[0], " ".join(args[1:]))
 
-            elif cmd in ("?", "check"):
+            elif cmd == "logs":
                 if not args:
-                    console.print("  [red]Usage:[/] ? SESSION_ID")
+                    console.print("  [red]Usage:[/] logs SESSION_ID [-f]")
                 else:
-                    do_check(args[0])
-
-            elif cmd == "view":
-                if not args:
-                    console.print("  [red]Usage:[/] view SESSION_ID")
-                else:
-                    do_view(args[0])
-
-            elif cmd == "raw":
-                if not args:
-                    console.print("  [red]Usage:[/] raw SESSION_ID")
-                else:
-                    do_raw(args[0])
+                    follow = "-f" in args or "--follow" in args
+                    session_id = [a for a in args if not a.startswith("-")][0]
+                    do_logs(session_id, follow)
 
             elif cmd == "kill":
                 if not args:
@@ -1575,15 +1559,8 @@ def interactive(
             elif cmd == "killall":
                 do_killall()
 
-            elif cmd == "refresh":
-                do_refresh()
-
-            elif cmd in ("e", "end"):
-                # Alias for kill
-                if not args:
-                    console.print("  [red]Usage:[/] kill SESSION_ID")
-                else:
-                    do_kill(args[0])
+            elif cmd == "clean":
+                do_clean()
 
             else:
                 console.print(f"  [yellow]Unknown command:[/] {cmd}")
@@ -1598,6 +1575,454 @@ def interactive(
             console.print(f"  [red]Error:[/] {e}")
 
 
+# =============================================================================
+# Session Manager Commands (background Codex processes)
+# =============================================================================
+
+session_app = typer.Typer(
+    name="session",
+    help="""
+[bold cyan]Codex Session Manager[/]
+
+Manage background Codex sessions. Run multiple codex tasks in parallel,
+monitor their progress, and inject follow-up messages.
+
+[bold]COMMANDS[/]
+    [cyan]start[/]    Start a new session in the background
+    [cyan]ls[/]       List all sessions
+    [cyan]show[/]     Show messages for a session
+    [cyan]logs[/]     Show raw JSONL output
+    [cyan]inject[/]   Inject a follow-up message
+    [cyan]kill[/]     Kill a running session
+    [cyan]clean[/]    Remove old completed sessions
+
+[bold]EXAMPLES[/]
+    [dim]# Start a background session[/]
+    $ zwarm session start "Add tests for auth module"
+
+    [dim]# List all sessions[/]
+    $ zwarm session ls
+
+    [dim]# View session messages[/]
+    $ zwarm session show abc123
+
+    [dim]# Continue a completed session[/]
+    $ zwarm session inject abc123 "Also add edge case tests"
+""",
+)
+app.add_typer(session_app, name="session")
+
+
+@session_app.command("start")
+def session_start(
+    task: Annotated[str, typer.Argument(help="Task description")],
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+    model: Annotated[str, typer.Option("--model", "-m", help="Model to use")] = "gpt-5.1-codex-mini",
+):
+    """
+    Start a new Codex session in the background.
+
+    The session runs independently and you can check on it later.
+
+    [bold]Examples:[/]
+        [dim]# Simple task[/]
+        $ zwarm session start "Fix the bug in auth.py"
+
+        [dim]# With specific model[/]
+        $ zwarm session start "Refactor the API" --model gpt-5.1-codex-max
+    """
+    from zwarm.sessions import CodexSessionManager
+
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    session = manager.start_session(
+        task=task,
+        working_dir=working_dir,
+        model=model,
+    )
+
+    console.print()
+    console.print(f"[green]✓ Session started[/]  [bold cyan]{session.short_id}[/]")
+    console.print()
+    console.print(f"  [dim]Task:[/]  {task[:70]}{'...' if len(task) > 70 else ''}")
+    console.print(f"  [dim]Model:[/] {model}")
+    console.print(f"  [dim]PID:[/]   {session.pid}")
+    console.print()
+    console.print("[dim]Commands:[/]")
+    console.print(f"  [cyan]zwarm session ls[/]           [dim]List all sessions[/]")
+    console.print(f"  [cyan]zwarm session show {session.short_id}[/]  [dim]View messages[/]")
+    console.print(f"  [cyan]zwarm session logs {session.short_id} -f[/]  [dim]Follow live output[/]")
+
+
+@session_app.command("ls")
+def session_list(
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+    all_sessions: Annotated[bool, typer.Option("--all", "-a", help="Show all sessions including completed")] = False,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+):
+    """
+    List all sessions.
+
+    Shows running sessions by default. Use --all to include completed.
+
+    [bold]Examples:[/]
+        $ zwarm session ls
+        $ zwarm session ls --all
+    """
+    from zwarm.sessions import CodexSessionManager, SessionStatus
+
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    sessions = manager.list_sessions()
+
+    if not all_sessions:
+        sessions = [s for s in sessions if s.status == SessionStatus.RUNNING]
+
+    if json_output:
+        import json
+        console.print(json.dumps([s.to_dict() for s in sessions], indent=2))
+        return
+
+    if not sessions:
+        if all_sessions:
+            console.print("[dim]No sessions found.[/]")
+        else:
+            console.print("[dim]No running sessions.[/]")
+            console.print("[dim]Use --all to see completed sessions, or start one with:[/]")
+            console.print("  zwarm session start \"your task here\"")
+        return
+
+    # Show status summary
+    running_count = sum(1 for s in sessions if s.status == SessionStatus.RUNNING)
+    completed_count = sum(1 for s in sessions if s.status == SessionStatus.COMPLETED)
+    failed_count = sum(1 for s in sessions if s.status == SessionStatus.FAILED)
+
+    summary_parts = []
+    if running_count:
+        summary_parts.append(f"[yellow]⟳ {running_count} running[/]")
+    if completed_count:
+        summary_parts.append(f"[green]✓ {completed_count} completed[/]")
+    if failed_count:
+        summary_parts.append(f"[red]✗ {failed_count} failed[/]")
+
+    if summary_parts:
+        console.print(" │ ".join(summary_parts))
+        console.print()
+
+    # Build table
+    table = Table(box=None, show_header=True, header_style="bold dim")
+    table.add_column("ID", style="cyan")
+    table.add_column("", width=2)  # Status icon
+    table.add_column("Task", max_width=50)
+    table.add_column("Runtime", justify="right", style="dim")
+    table.add_column("Tokens", justify="right", style="dim")
+
+    status_icons = {
+        SessionStatus.RUNNING: "[yellow]⟳[/]",
+        SessionStatus.COMPLETED: "[green]✓[/]",
+        SessionStatus.FAILED: "[red]✗[/]",
+        SessionStatus.KILLED: "[dim]⊘[/]",
+        SessionStatus.PENDING: "[dim]○[/]",
+    }
+
+    for session in sessions:
+        status_icon = status_icons.get(session.status, "?")
+        task_preview = session.task[:47] + "..." if len(session.task) > 50 else session.task
+        tokens = session.token_usage.get("total_tokens", 0)
+        tokens_str = f"{tokens:,}" if tokens else "-"
+
+        table.add_row(
+            session.short_id,
+            status_icon,
+            task_preview,
+            session.runtime,
+            tokens_str,
+        )
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+@session_app.command("show")
+def session_show(
+    session_id: Annotated[str, typer.Argument(help="Session ID (or prefix)")],
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+    raw: Annotated[bool, typer.Option("--raw", "-r", help="Show raw messages without formatting")] = False,
+):
+    """
+    Show messages for a session.
+
+    Displays the conversation history with nice formatting.
+
+    [bold]Examples:[/]
+        $ zwarm session show abc123
+        $ zwarm session show abc123 --raw
+    """
+    from zwarm.sessions import CodexSessionManager
+
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    session = manager.get_session(session_id)
+
+    if not session:
+        console.print(f"[red]Session not found:[/] {session_id}")
+        raise typer.Exit(1)
+
+    # Get messages
+    messages = manager.get_messages(session.id)
+
+    # Status styling
+    status_display = {
+        "running": "[yellow]⟳ running[/]",
+        "completed": "[green]✓ completed[/]",
+        "failed": "[red]✗ failed[/]",
+        "killed": "[dim]⊘ killed[/]",
+        "pending": "[dim]○ pending[/]",
+    }.get(session.status.value, session.status.value)
+
+    console.print()
+    console.print(f"[bold cyan]Session {session.short_id}[/]  {status_display}")
+    console.print(f"[dim]Task:[/] {session.task}")
+    console.print(f"[dim]Model:[/] {session.model}  [dim]│[/]  [dim]Turn:[/] {session.turn}  [dim]│[/]  [dim]Runtime:[/] {session.runtime}")
+    console.print()
+
+    if not messages:
+        if session.status.value == "running":
+            console.print("[yellow]Session is still running...[/]")
+            console.print("[dim]Check back later for output.[/]")
+        else:
+            console.print("[dim]No messages captured.[/]")
+        return
+
+    # Display messages
+    for msg in messages:
+        if msg.role == "user":
+            if raw:
+                console.print(f"[bold blue]USER:[/] {msg.content}")
+            else:
+                console.print(Panel(msg.content, title="[bold blue]User[/]", border_style="blue"))
+
+        elif msg.role == "assistant":
+            if raw:
+                console.print(f"[bold green]ASSISTANT:[/] {msg.content}")
+            else:
+                # Truncate very long messages
+                content = msg.content
+                if len(content) > 2000:
+                    content = content[:2000] + "\n\n[dim]... (truncated, use --raw for full output)[/]"
+                console.print(Panel(content, title="[bold green]Assistant[/]", border_style="green"))
+
+        elif msg.role == "tool":
+            if raw:
+                console.print(f"[dim]TOOL: {msg.content}[/]")
+            else:
+                # Extract function name if present
+                content = msg.content
+                if content.startswith("[Calling:"):
+                    console.print(f"  [dim]⚙[/] {content}")
+                elif content.startswith("[Output]"):
+                    console.print(f"    [dim]└─ {content[9:]}[/]")  # Skip "[Output]:"
+                else:
+                    console.print(f"  [dim]{content}[/]")
+
+    console.print()
+
+    # Show token usage
+    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[/]")
+
+    # Show error if any
+    if session.error:
+        console.print(f"[red]Error:[/] {session.error}")
+
+    # Helpful tip
+    console.print()
+    if session.status.value == "running":
+        console.print(f"[dim]Tip: Use 'zwarm session logs {session.short_id} --follow' to watch live output[/]")
+    elif session.status.value == "completed":
+        console.print(f"[dim]Tip: Use 'zwarm session inject {session.short_id} \"your message\"' to continue the conversation[/]")
+
+
+@session_app.command("logs")
+def session_logs(
+    session_id: Annotated[str, typer.Argument(help="Session ID (or prefix)")],
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+    turn: Annotated[Optional[int], typer.Option("--turn", "-t", help="Specific turn number")] = None,
+    follow: Annotated[bool, typer.Option("--follow", "-f", help="Follow output (like tail -f)")] = False,
+):
+    """
+    Show raw JSONL logs for a session.
+
+    [bold]Examples:[/]
+        $ zwarm session logs abc123
+        $ zwarm session logs abc123 --follow
+    """
+    from zwarm.sessions import CodexSessionManager
+
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    session = manager.get_session(session_id)
+
+    if not session:
+        console.print(f"[red]Session not found:[/] {session_id}")
+        raise typer.Exit(1)
+
+    if follow and session.status.value == "running":
+        # Follow mode - tail the file
+        import time
+        output_path = manager._output_path(session.id, turn or session.turn)
+
+        console.print(f"[dim]Following {output_path}... (Ctrl+C to stop)[/]")
+        console.print()
+
+        try:
+            with open(output_path, "r") as f:
+                # Print existing content
+                for line in f:
+                    console.print(line.rstrip())
+
+                # Follow new content
+                while session.is_running:
+                    line = f.readline()
+                    if line:
+                        console.print(line.rstrip())
+                    else:
+                        time.sleep(0.5)
+                        # Refresh session status
+                        session = manager.get_session(session_id)
+
+        except KeyboardInterrupt:
+            console.print("\n[dim]Stopped following.[/]")
+
+    else:
+        # Just print the output
+        output = manager.get_output(session.id, turn)
+        if output:
+            console.print(output)
+        else:
+            console.print("[dim]No output yet.[/]")
+
+
+@session_app.command("inject")
+def session_inject(
+    session_id: Annotated[str, typer.Argument(help="Session ID (or prefix)")],
+    message: Annotated[str, typer.Argument(help="Follow-up message to inject")],
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+):
+    """
+    Inject a follow-up message into a completed session.
+
+    This continues the conversation with context from the previous turn.
+    Can only be used on completed (not running) sessions.
+
+    [bold]Examples:[/]
+        $ zwarm session inject abc123 "Also add edge case tests"
+        $ zwarm session inject abc123 "Good, now refactor the code"
+    """
+    from zwarm.sessions import CodexSessionManager, SessionStatus
+
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    session = manager.get_session(session_id)
+
+    if not session:
+        console.print(f"[red]Session not found:[/] {session_id}")
+        raise typer.Exit(1)
+
+    if session.status == SessionStatus.RUNNING:
+        console.print("[yellow]Session is still running.[/]")
+        console.print("[dim]Wait for it to complete, then inject a follow-up.[/]")
+        raise typer.Exit(1)
+
+    # Inject the message
+    updated_session = manager.inject_message(session.id, message)
+
+    if not updated_session:
+        console.print("[red]Failed to inject message.[/]")
+        raise typer.Exit(1)
+
+    console.print()
+    console.print(f"[green]✓ Message injected[/]  Turn {updated_session.turn} started")
+    console.print()
+    console.print(f"  [dim]Message:[/] {message[:70]}{'...' if len(message) > 70 else ''}")
+    console.print(f"  [dim]PID:[/]     {updated_session.pid}")
+    console.print()
+    console.print("[dim]Commands:[/]")
+    console.print(f"  [cyan]zwarm session show {session.short_id}[/]  [dim]View messages[/]")
+    console.print(f"  [cyan]zwarm session logs {session.short_id} -f[/]  [dim]Follow live output[/]")
+
+
+@session_app.command("kill")
+def session_kill(
+    session_id: Annotated[str, typer.Argument(help="Session ID (or prefix)")],
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+):
+    """
+    Kill a running session.
+
+    [bold]Examples:[/]
+        $ zwarm session kill abc123
+    """
+    from zwarm.sessions import CodexSessionManager
+
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    session = manager.get_session(session_id)
+
+    if not session:
+        console.print(f"[red]Session not found:[/] {session_id}")
+        raise typer.Exit(1)
+
+    if not session.is_running:
+        console.print(f"[yellow]Session {session.short_id} is not running.[/]")
+        console.print(f"  [dim]Status:[/] {session.status.value}")
+        return
+
+    killed = manager.kill_session(session.id)
+
+    if killed:
+        console.print(f"[green]Killed session {session.short_id}[/]")
+    else:
+        console.print(f"[red]Failed to kill session {session.short_id}[/]")
+
+
+@session_app.command("clean")
+def session_clean(
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+    keep_days: Annotated[int, typer.Option("--keep-days", "-k", help="Keep sessions newer than N days")] = 7,
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation")] = False,
+):
+    """
+    Remove old completed sessions.
+
+    [bold]Examples:[/]
+        $ zwarm session clean
+        $ zwarm session clean --keep-days 1
+    """
+    from zwarm.sessions import CodexSessionManager, SessionStatus
+
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    sessions = manager.list_sessions()
+
+    # Count cleanable sessions
+    cleanable = [s for s in sessions if s.status in (SessionStatus.COMPLETED, SessionStatus.FAILED, SessionStatus.KILLED)]
+
+    if not cleanable:
+        console.print("[dim]No sessions to clean.[/]")
+        return
+
+    console.print(f"Found {len(cleanable)} completed/failed sessions.")
+
+    if not yes:
+        confirm = typer.confirm(f"Remove sessions older than {keep_days} days?")
+        if not confirm:
+            console.print("[dim]Cancelled.[/]")
+            return
+
+    cleaned = manager.cleanup_completed(keep_days)
+    console.print(f"[green]Cleaned {cleaned} sessions.[/]")
+
+
+# =============================================================================
+# Main callback and entry point
+# =============================================================================
+
 @app.callback(invoke_without_command=True)
 def main_callback(
     ctx: typer.Context,