zwarm 1.3.10__py3-none-any.whl → 2.0.0__py3-none-any.whl

zwarm/cli/main.py

@@ -304,8 +304,13 @@ def exec(
     console.print(f"  Mode: {mode.value}")
     console.print(f"  Task: {task}")
 
+    # Use isolated codex config if available
+    config_path = working_dir / ".zwarm" / "codex.toml"
+    if not config_path.exists():
+        config_path = None
+
     try:
-        executor = get_adapter(adapter.value, model=model)
+        executor = get_adapter(adapter.value, model=model, config_path=config_path)
     except ValueError as e:
         console.print(f"[red]Error:[/] {e}")
         sys.exit(1)
@@ -743,6 +748,13 @@ def init(
         config_toml_path.write_text(toml_content)
         console.print(f"  [green]✓[/] Created .zwarm/config.toml")
 
+    # 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()
+        codex_toml_path.write_text(codex_content)
+        console.print(f"  [green]✓[/] Created .zwarm/codex.toml (isolated codex config)")
+
     # Create zwarm.yaml
     if create_project_config:
         if zwarm_yaml_path.exists() and not non_interactive:
@@ -813,6 +825,35 @@ def _generate_config_toml(
     return "\n".join(lines)
 
 
+def _generate_codex_toml(
+    model: str = "gpt-5.1-codex-mini",
+    reasoning_effort: str = "high",
+) -> str:
+    """
+    Generate codex.toml for isolated codex configuration.
+
+    This file is used by zwarm instead of ~/.codex/config.toml to ensure
+    consistent behavior across different environments.
+    """
+    lines = [
+        "# Codex configuration for zwarm",
+        "# This file isolates zwarm's codex settings from your global ~/.codex/config.toml",
+        "# Generated by 'zwarm init'",
+        "",
+        "# Model settings",
+        f'model = "{model}"',
+        f'model_reasoning_effort = "{reasoning_effort}"  # low | medium | high',
+        "",
+        "# Approval settings - zwarm manages these automatically",
+        "# disable_response_storage = false",
+        "",
+        "# You can override any codex setting here",
+        "# See: https://github.com/openai/codex#configuration",
+        "",
+    ]
+    return "\n".join(lines)
+
+
 def _generate_zwarm_yaml(
     description: str = "",
     context: str = "",
@@ -1092,6 +1133,7 @@ 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"),
 ):
     """
@@ -1100,79 +1142,121 @@ def interactive(
     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.
+
     [bold]Commands:[/]
-        [cyan]spawn[/] "task" [opts]      Start a coding agent session
-        [cyan]orchestrate[/] "task"       Start an orchestrator agent
+        [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]?[/] / [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]?[/] ID                    Quick peek (status + latest message)
+        [cyan]show[/] ID                  Full session details & history
+        [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
+        spawn "task" --dir ~/project --model gpt-5.1-codex-max --async
 
     [bold]Examples:[/]
         $ zwarm interactive
         > spawn "Build auth module" --dir ~/api
         > spawn "Fix tests" --dir ~/api
-        > orchestrate "Refactor the entire API layer"
+        > c abc123 "Now add error handling"
         > ls
         > ? abc123
     """
-    from zwarm.sessions import CodexSessionManager, SessionStatus
+    from zwarm.adapters import get_adapter, list_adapters
+    from zwarm.core.models import ConversationSession, SessionStatus, SessionMode
     import argparse
-    import subprocess as sp
 
-    # Initialize session manager
-    manager = CodexSessionManager(state_dir)
+    # 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"  Sessions: {state_dir / 'sessions'}")
+    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 a coding agent")
+        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('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("ls / list", "Dashboard of all sessions")
+        help_table.add_row("? / show ID", "Show session details & messages")
+        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("killall", "Stop all running sessions")
-        help_table.add_row("clean", "Remove completed sessions")
+        help_table.add_row("clean", "Remove old completed sessions")
         help_table.add_row("q / quit", "Exit")
         console.print(help_table)
 
-    def show_sessions(show_all: bool = False):
-        sessions = manager.list_sessions()
+    def show_sessions():
+        """List all sessions from CodexSessionManager (same as orchestrator)."""
+        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
+        from datetime import datetime
 
-        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]
+        manager = CodexSessionManager(default_dir / ".zwarm")
+        all_sessions = manager.list_sessions()
 
-        if not sessions:
+        if not all_sessions:
             console.print("  [dim]No sessions. Use 'spawn \"task\"' to start one.[/]")
             return
 
         # 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)
+        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:
@@ -1181,48 +1265,91 @@ def interactive(
             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("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)
+        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 = {
-            SessionStatus.RUNNING: "[yellow]⟳[/]",
-            SessionStatus.COMPLETED: "[green]✓[/]",
-            SessionStatus.FAILED: "[red]✗[/]",
-            SessionStatus.KILLED: "[dim]⊘[/]",
-            SessionStatus.PENDING: "[dim]○[/]",
+            "running": "[yellow]●[/]",
+            "completed": "[green]✓[/]",
+            "failed": "[red]✗[/]",
+            "killed": "[dim]○[/]",
+            "pending": "[dim]◌[/]",
         }
 
-        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}[/]"
+        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:
-                source_styled = f"[dim]{source}[/]"
+                last_msg_styled = f"[dim]{last_msg or '-'}[/]"
+                updated_styled = f"[dim]{updated}[/]"
 
             table.add_row(
                 s.short_id,
                 icon,
-                source_styled,
+                str(s.turn),
                 task_preview,
-                s.runtime,
-                tokens_str,
+                updated_styled,
+                last_msg_styled,
             )
 
         console.print(table)
@@ -1233,6 +1360,7 @@ def interactive(
         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)
@@ -1240,48 +1368,80 @@ def interactive(
                 "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."""
+        """Spawn a new coding agent session using CodexSessionManager (same as orchestrator)."""
+        from zwarm.sessions import CodexSessionManager
+        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][/]")
+            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][/]")
+            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
 
-        console.print(f"\n[dim]Spawning session...[/]")
+        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"  PID: {session.pid}")
-            console.print(f"\n[dim]Use '? {session.short_id}' to check status[/]")
+            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:
+                    session = manager.get_session(session.id)
+                    if not session.is_running:
+                        break
+                    time.sleep(1.0)
+
+                # Get the response
+                messages = manager.get_messages(session.id)
+                for msg in messages:
+                    if msg.role == "assistant":
+                        response_preview = msg.content[:300]
+                        if len(msg.content) > 300:
+                            response_preview += "..."
+                        console.print(f"\n[bold]Response:[/]\n{response_preview}")
+                        break
+
+            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}")
@@ -1351,34 +1511,81 @@ def interactive(
         except Exception as e:
             console.print(f"  [red]Error starting orchestrator:[/] {e}")
 
-    def do_show(session_id: str):
-        """Show session details and messages."""
+    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
+
+        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"  [red]Not found:[/] {session_id}")
             return
 
-        # Get messages
+        # 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}[/]")
+        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[/]",
+            "running": "[yellow]● running[/]",
             "completed": "[green]✓ completed[/]",
             "failed": "[red]✗ failed[/]",
-            "killed": "[dim]⊘ killed[/]",
-            "pending": "[dim]○ pending[/]",
-        }.get(session.status.value, session.status.value)
+            "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]Source:[/] {session.source_display}  [dim]│[/]  [dim]Model:[/] {session.model}")
+        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]Runtime:[/] {session.runtime}")
+        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}")
         console.print()
 
+        # Get messages from manager
+        messages = manager.get_messages(session.id)
+
         if not messages:
-            if session.status == SessionStatus.RUNNING:
+            if session.is_running:
                 console.print("[yellow]Session is still running...[/]")
             else:
                 console.print("[dim]No messages captured.[/]")
@@ -1394,10 +1601,7 @@ def interactive(
                     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(f"  [dim]Tool: {msg.content[:100]}[/]")
 
         console.print()
         if session.token_usage:
@@ -1407,89 +1611,195 @@ def interactive(
         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."""
+    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 == SessionStatus.RUNNING:
+        if session.status == SessStatus.RUNNING:
             console.print("[yellow]Session is still running.[/]")
-            console.print("[dim]Wait for it to complete, then continue.[/]")
+            console.print("[dim]Wait for it to complete, or use '?' to check progress.[/]")
             return
 
-        console.print(f"\n[dim]Injecting message into {session.short_id}...[/]")
+        if session.status == SessStatus.KILLED:
+            console.print("[yellow]Session was killed.[/]")
+            console.print("[dim]Start a new session with 'spawn'.[/]")
+            return
 
-        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.[/]")
+        # 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:
+                    session = manager.get_session(session.id)
+                    if not session.is_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[/]")
 
-    def do_logs(session_id: str, follow: bool = False):
-        """Show raw JSONL logs for a session."""
+        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
 
-        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.[/]")
+        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."""
+        """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)
+
         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.[/]")
+            console.print(f"[yellow]Session {session.short_id} is not running ({session.status.value}).[/]")
             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[/]")
+        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."""
-        sessions = manager.list_sessions(status=SessionStatus.RUNNING)
+        """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)
+
+        if not running_sessions:
+            console.print("[dim]No running sessions to kill.[/]")
+            return
+
         killed = 0
-        for session in sessions:
-            if manager.kill_session(session.id):
-                killed += 1
+        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 completed sessions."""
-        cleaned = manager.cleanup_completed(keep_days=0)
-        console.print(f"[green]✓[/] Cleaned {cleaned} sessions")
+        """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)
+
+        if not session:
+            console.print(f"  [red]Session not found:[/] {session_id}")
+            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
@@ -1510,10 +1820,18 @@ def interactive(
             args = parts[1:]
 
             if cmd in ("q", "quit", "exit"):
-                running = manager.list_sessions(status=SessionStatus.RUNNING)
-                if running:
-                    console.print(f"  [yellow]Warning:[/] {len(running)} sessions still running")
+                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
 
@@ -1521,34 +1839,50 @@ def interactive(
                 show_help()
 
             elif cmd in ("ls", "list"):
-                show_all = "--all" in args or "-a" in args
-                show_sessions(show_all)
+                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 ("?", "show"):
+            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 ("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:]))
+                    do_continue(args[0], " ".join(args[1:]), wait=True)
+
+            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)
 
-            elif cmd == "logs":
+            elif cmd == "check":
                 if not args:
-                    console.print("  [red]Usage:[/] logs SESSION_ID [-f]")
+                    console.print("  [red]Usage:[/] check SESSION_ID")
                 else:
-                    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)
+                    do_check(args[0])
 
             elif cmd == "kill":
                 if not args:
@@ -1562,6 +1896,12 @@ def interactive(
             elif cmd == "clean":
                 do_clean()
 
+            elif cmd in ("rm", "delete", "remove"):
+                if not args:
+                    console.print("  [red]Usage:[/] rm SESSION_ID")
+                else:
+                    do_delete(args[0])
+
             else:
                 console.print(f"  [yellow]Unknown command:[/] {cmd}")
                 console.print("  [dim]Type 'help' for available commands[/]")