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

zwarm/cli/main.py

@@ -79,6 +79,7 @@ app = typer.Typer(
     [cyan]init[/]         Initialize zwarm (creates .zwarm/ with config)
     [cyan]reset[/]        Reset state and optionally config files
     [cyan]orchestrate[/]  Start orchestrator to delegate tasks to executors
+    [cyan]pilot[/]        Conversational orchestrator REPL (interactive)
     [cyan]exec[/]         Run a single executor directly (for testing)
     [cyan]status[/]       Show current state (sessions, tasks, events)
     [cyan]history[/]      Show event history log
@@ -121,16 +122,6 @@ Manage zwarm configurations.
 app.add_typer(configs_app, name="configs")
 
 
-class AdapterType(str, Enum):
-    codex_mcp = "codex_mcp"
-    claude_code = "claude_code"
-
-
-class ModeType(str, Enum):
-    sync = "sync"
-    async_ = "async"
-
-
 @app.command()
 def orchestrate(
     task: Annotated[Optional[str], typer.Option("--task", "-t", help="The task to accomplish")] = None,
@@ -227,6 +218,26 @@ def orchestrate(
         if orchestrator.instance_id and not instance:
             console.print(f"  [dim]Instance: {orchestrator.instance_id[:8]}[/]")
 
+        # Set up step callback for live progress display
+        def step_callback(step_num: int, tool_results: list) -> None:
+            """Print tool calls and results as they happen."""
+            if not tool_results:
+                return
+            for tool_info, result in tool_results:
+                name = tool_info.get("name", "?")
+                # Truncate args for display
+                args_str = str(tool_info.get("args", {}))
+                if len(args_str) > 80:
+                    args_str = args_str[:77] + "..."
+                # Truncate result for display
+                result_str = str(result)
+                if len(result_str) > 100:
+                    result_str = result_str[:97] + "..."
+                console.print(f"[dim]step {step_num}[/] → [cyan]{name}[/]({args_str})")
+                console.print(f"         └ {result_str}")
+
+        orchestrator._step_callback = step_callback
+
         # Run the orchestrator loop
         console.print("[bold]--- Orchestrator running ---[/]\n")
         result = orchestrator.run(task=task)
@@ -274,81 +285,195 @@ def orchestrate(
         sys.exit(1)
 
 
+class PilotLM(str, Enum):
+    """LM options for pilot mode."""
+    gpt5_mini = "gpt5-mini"      # GPT5MiniTester - fast, cheap, good for testing
+    gpt5 = "gpt5"                # GPT5Large - standard
+    gpt5_verbose = "gpt5-verbose"  # GPT5LargeVerbose - with extended thinking
+
+
 @app.command()
-def exec(
-    task: Annotated[str, typer.Option("--task", "-t", help="Task to execute")],
-    adapter: Annotated[AdapterType, typer.Option("--adapter", "-a", help="Executor adapter")] = AdapterType.codex_mcp,
-    mode: Annotated[ModeType, typer.Option("--mode", "-m", help="Execution mode")] = ModeType.sync,
+def pilot(
+    task: Annotated[Optional[str], typer.Option("--task", "-t", help="Initial task (optional)")] = None,
+    task_file: Annotated[Optional[Path], typer.Option("--task-file", "-f", help="Read task from file")] = None,
+    config: Annotated[Optional[Path], typer.Option("--config", "-c", help="Path to config YAML")] = None,
+    overrides: Annotated[Optional[list[str]], typer.Option("--set", help="Override config (key=value)")] = None,
     working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
-    model: Annotated[Optional[str], typer.Option("--model", help="Model override")] = None,
+    resume: Annotated[bool, typer.Option("--resume", help="Resume from previous state")] = False,
+    instance: Annotated[Optional[str], typer.Option("--instance", "-i", help="Instance ID (for isolation/resume)")] = None,
+    instance_name: Annotated[Optional[str], typer.Option("--name", "-n", help="Human-readable instance name")] = None,
+    model: Annotated[PilotLM, typer.Option("--model", "-m", help="LM to use")] = PilotLM.gpt5_verbose,
 ):
     """
-    Run a single executor directly (for testing).
+    Interactive conversational orchestrator REPL.
+
+    Like 'orchestrate' but conversational: give instructions, watch the
+    orchestrator work, course-correct in real-time, time-travel to checkpoints.
 
-    Useful for testing adapters without the full orchestrator loop.
+    [bold]Features:[/]
+        - Streaming display of orchestrator thinking and tool calls
+        - Turn-by-turn execution with checkpoints
+        - Time travel (:goto T1) to return to previous states
+        - Session visibility (:sessions) and state inspection (:state)
+
+    [bold]Commands:[/]
+        :help              Show help
+        :history [N|all]   Show turn checkpoints
+        :goto <turn|root>  Time travel (e.g., :goto T1)
+        :state             Show orchestrator state
+        :sessions          Show active executor sessions
+        :reasoning on|off  Toggle reasoning display
+        :quit              Exit
+
+    [bold]LM Options:[/]
+        gpt5-mini     GPT5MiniTester - fast/cheap, good for testing
+        gpt5          GPT5Large - standard model
+        gpt5-verbose  GPT5LargeVerbose - with extended thinking (default)
 
     [bold]Examples:[/]
-        [dim]# Test Codex[/]
-        $ zwarm exec --task "What is 2+2?"
+        [dim]# Start fresh, give instructions interactively[/]
+        $ zwarm pilot
+
+        [dim]# Start with an initial task[/]
+        $ zwarm pilot --task "Build user authentication"
 
-        [dim]# Test Claude Code[/]
-        $ zwarm exec -a claude_code --task "List files in current dir"
+        [dim]# Use faster model for testing[/]
+        $ zwarm pilot --model gpt5-mini
 
-        [dim]# Async mode[/]
-        $ zwarm exec --task "Build feature" --mode async
+        [dim]# Named instance[/]
+        $ zwarm pilot --name my-feature
+
+        [dim]# Resume a previous session[/]
+        $ zwarm pilot --resume --instance abc123
     """
-    from zwarm.adapters import get_adapter
+    from zwarm.cli.pilot import run_pilot, build_pilot_orchestrator
 
-    console.print(f"[bold]Running executor directly...[/]")
-    console.print(f"  Adapter: [cyan]{adapter.value}[/]")
-    console.print(f"  Mode: {mode.value}")
-    console.print(f"  Task: {task}")
+    # Resolve task (optional for pilot)
+    resolved_task = _resolve_task(task, task_file)
 
-    # Use isolated codex config if available
-    config_path = working_dir / ".zwarm" / "codex.toml"
-    if not config_path.exists():
-        config_path = None
+    # Validate resume requirements
+    if resume and not instance:
+        console.print("[red]Error:[/] --resume requires --instance to specify which session to resume")
+        console.print("  [dim]Use 'zwarm instances' to list available instances[/]")
+        raise typer.Exit(1)
 
+    console.print(f"[bold]{'Resuming' if resume else 'Starting'} pilot session...[/]")
+    console.print(f"  Working dir: {working_dir.absolute()}")
+    console.print(f"  Model: {model.value}")
+    if resolved_task:
+        console.print(f"  Initial task: {resolved_task[:60]}...")
+    if instance:
+        console.print(f"  Instance: {instance}" + (f" ({instance_name})" if instance_name else ""))
+    if resume:
+        console.print(f"  [yellow]Resuming from saved state...[/]")
+    console.print()
+
+    orchestrator = None
     try:
-        executor = get_adapter(adapter.value, model=model, config_path=config_path)
-    except ValueError as e:
-        console.print(f"[red]Error:[/] {e}")
+        orchestrator = build_pilot_orchestrator(
+            config_path=config,
+            working_dir=working_dir.absolute(),
+            overrides=list(overrides or []),
+            instance_id=instance,
+            instance_name=instance_name,
+            lm_choice=model.value,
+        )
+
+        # Show instance ID if auto-generated
+        if orchestrator.instance_id and not instance:
+            console.print(f"  [dim]Instance: {orchestrator.instance_id[:8]}[/]")
+
+        # Resume from saved state if requested
+        if resume:
+            orchestrator.load_state()
+            msg_count = len(orchestrator.messages)
+            console.print(f"  [green]✓[/] Resumed with {msg_count} messages")
+
+        # Run the pilot REPL
+        run_pilot(orchestrator, initial_task=resolved_task)
+
+        # Save state on exit
+        orchestrator.save_state()
+        console.print("\n[dim]State saved.[/]")
+
+    except KeyboardInterrupt:
+        console.print("\n\n[yellow]Interrupted.[/]")
+        if orchestrator:
+            orchestrator.save_state()
+            console.print("[dim]State saved.[/]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"\n[red]Error:[/] {e}")
+        import traceback
+        traceback.print_exc()
         sys.exit(1)
 
-    async def run():
-        try:
-            session = await executor.start_session(
-                task=task,
-                working_dir=working_dir.absolute(),
-                mode=mode.value,
-                model=model,
-            )
 
-            console.print(f"\n[green]Session started:[/] {session.id[:8]}")
+@app.command()
+def exec(
+    task: Annotated[str, typer.Option("--task", "-t", help="Task to execute")],
+    working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
+    model: Annotated[Optional[str], typer.Option("--model", help="Model override")] = None,
+    wait: Annotated[bool, typer.Option("--wait", help="Wait for completion and show result")] = False,
+):
+    """
+    Run a single Codex session directly (for testing).
+
+    Spawns a session using CodexSessionManager - same as interactive/pilot.
+    Web search is always enabled via .codex/config.toml (set up by `zwarm init`).
 
-            if mode == ModeType.sync:
-                response = session.messages[-1].content if session.messages else "(no response)"
-                console.print(f"\n[bold]Response:[/]\n{response}")
+    [bold]Examples:[/]
+        [dim]# Quick test[/]
+        $ zwarm exec --task "What is 2+2?" --wait
 
-                # Interactive loop for sync mode
-                while True:
-                    try:
-                        user_input = console.input("\n[dim]> (type message or 'exit')[/] ")
-                        if user_input.lower() == "exit" or not user_input:
-                            break
+        [dim]# Run in background[/]
+        $ zwarm exec --task "Build feature"
 
-                        response = await executor.send_message(session, user_input)
-                        console.print(f"\n[bold]Response:[/]\n{response}")
-                    except KeyboardInterrupt:
-                        break
-            else:
-                console.print("[dim]Async mode - session running in background.[/]")
-                console.print("Use 'zwarm status' to check progress.")
+        [dim]# Web search is always available[/]
+        $ zwarm exec --task "Find latest FastAPI docs" --wait
+    """
+    import time
+    from zwarm.sessions import CodexSessionManager, SessionStatus
 
-        finally:
-            await executor.cleanup()
+    console.print(f"[bold]Running Codex session...[/]")
+    console.print(f"  Task: {task[:60]}{'...' if len(task) > 60 else ''}")
+    if model:
+        console.print(f"  Model: {model}")
 
-    asyncio.run(run())
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    effective_model = model or "gpt-5.1-codex-mini"
+
+    session = manager.start_session(
+        task=task,
+        working_dir=working_dir.absolute(),
+        model=effective_model,
+    )
+
+    console.print(f"\n[green]Session started:[/] {session.short_id}")
+
+    if wait:
+        console.print("[dim]Waiting for completion...[/]")
+        while True:
+            time.sleep(2)
+            session = manager.get_session(session.id)
+            if session.status != SessionStatus.RUNNING:
+                break
+
+        if session.status == SessionStatus.COMPLETED:
+            console.print(f"\n[green]✓ Completed[/]")
+            # Show last assistant message
+            for msg in reversed(session.messages):
+                if msg.role == "assistant":
+                    console.print(f"\n[bold]Response:[/]\n{msg.content}")
+                    break
+        else:
+            console.print(f"\n[red]Status:[/] {session.status.value}")
+            if session.error:
+                console.print(f"[red]Error:[/] {session.error}")
+    else:
+        console.print("[dim]Running in background. Check with:[/]")
+        console.print(f"  zwarm sessions")
+        console.print(f"  zwarm session show {session.short_id}")
 
 
 @app.command()
@@ -633,8 +758,14 @@ def init(
     [bold]Creates:[/]
         [cyan].zwarm/[/]              State directory for sessions and events
         [cyan].zwarm/config.toml[/]   Runtime settings (weave, adapter, watchers)
+        [cyan].zwarm/codex.toml[/]    Codex CLI settings (model, web search, etc.)
         [cyan]zwarm.yaml[/]           Project config (optional, with --with-project)
 
+    [bold]Configuration relationship:[/]
+        config.toml   → Controls zwarm itself (tracing, which watchers run)
+        codex.toml    → Codex settings, parsed by zwarm and passed via -c overrides
+        zwarm.yaml    → Project-specific context injected into orchestrator
+
     [bold]Examples:[/]
         [dim]# Interactive setup[/]
         $ zwarm init
@@ -681,6 +812,9 @@ def init(
     create_project_config = with_project
     project_description = ""
     project_context = ""
+    # Codex settings
+    codex_model = "gpt-5.1-codex-mini"
+    codex_reasoning = "high"
 
     if not non_interactive:
         console.print("[bold]Configuration[/]\n")
@@ -699,6 +833,42 @@ def init(
             type=str,
         )
 
+        # Codex model settings
+        console.print("\n  [bold]Codex Model Settings[/] (.zwarm/codex.toml)")
+        console.print("  [dim]These control the underlying Codex CLI that runs executor sessions[/]\n")
+
+        console.print("  Available models:")
+        console.print("    [cyan]1[/] gpt-5.1-codex-mini  [dim]- Fast, cheap, good for most tasks (Recommended)[/]")
+        console.print("    [cyan]2[/] gpt-5.1-codex       [dim]- Balanced speed and capability[/]")
+        console.print("    [cyan]3[/] gpt-5.1-codex-max   [dim]- Most capable, 400k context, expensive[/]")
+
+        model_choice = typer.prompt(
+            "  Select model (1-3)",
+            default="1",
+            type=str,
+        )
+        model_map = {
+            "1": "gpt-5.1-codex-mini",
+            "2": "gpt-5.1-codex",
+            "3": "gpt-5.1-codex-max",
+        }
+        codex_model = model_map.get(model_choice, model_choice)
+        if model_choice not in model_map:
+            console.print(f"    [dim]Using custom model: {codex_model}[/]")
+
+        console.print("\n  Reasoning effort (how much the model \"thinks\" before responding):")
+        console.print("    [cyan]1[/] low     [dim]- Minimal reasoning, fastest responses[/]")
+        console.print("    [cyan]2[/] medium  [dim]- Balanced reasoning[/]")
+        console.print("    [cyan]3[/] high    [dim]- Maximum reasoning, best for complex tasks (Recommended)[/]")
+
+        reasoning_choice = typer.prompt(
+            "  Select reasoning effort (1-3)",
+            default="3",
+            type=str,
+        )
+        reasoning_map = {"1": "low", "2": "medium", "3": "high"}
+        codex_reasoning = reasoning_map.get(reasoning_choice, "high")
+
         # Watchers
         console.print("\n  [bold]Watchers[/] (trajectory aligners)")
         available_watchers = ["progress", "budget", "delegation", "delegation_reminder", "scope", "pattern", "quality"]
@@ -750,10 +920,37 @@ def init(
 
     # Create codex.toml for isolated codex configuration
     codex_toml_path = state_dir / "codex.toml"
-    if not codex_toml_path.exists():
-        codex_content = _generate_codex_toml()
+    write_codex_toml = True
+    if codex_toml_path.exists():
+        if not non_interactive:
+            overwrite_codex = typer.confirm("  .zwarm/codex.toml exists. Overwrite?", default=False)
+            if not overwrite_codex:
+                write_codex_toml = False
+                console.print("  [dim]Skipping codex.toml[/]")
+        else:
+            write_codex_toml = False  # Don't overwrite in non-interactive mode
+
+    if write_codex_toml:
+        codex_content = _generate_codex_toml(model=codex_model, reasoning_effort=codex_reasoning)
         codex_toml_path.write_text(codex_content)
-        console.print(f"  [green]✓[/] Created .zwarm/codex.toml (isolated codex config)")
+        console.print(f"  [green]✓[/] Created .zwarm/codex.toml")
+
+    # Create claude.toml for isolated Claude Code configuration
+    claude_toml_path = state_dir / "claude.toml"
+    write_claude_toml = True
+    if claude_toml_path.exists():
+        if not non_interactive:
+            overwrite_claude = typer.confirm("  .zwarm/claude.toml exists. Overwrite?", default=False)
+            if not overwrite_claude:
+                write_claude_toml = False
+                console.print("  [dim]Skipping claude.toml[/]")
+        else:
+            write_claude_toml = False  # Don't overwrite in non-interactive mode
+
+    if write_claude_toml:
+        claude_content = _generate_claude_toml(model="sonnet")
+        claude_toml_path.write_text(claude_content)
+        console.print(f"  [green]✓[/] Created .zwarm/claude.toml")
 
     # Create zwarm.yaml
     if create_project_config:
@@ -773,11 +970,23 @@ def init(
 
     # Summary
     console.print("\n[bold green]Done![/] zwarm is ready.\n")
+
+    # Explain config files
+    console.print("[bold]Configuration files:[/]")
+    console.print("  [cyan].zwarm/config.toml[/]  - Runtime settings (Weave tracing, watchers)")
+    console.print("  [cyan].zwarm/codex.toml[/]   - Codex CLI settings (model, web search, sandbox)")
+    if create_project_config:
+        console.print("  [cyan]zwarm.yaml[/]          - Project context and constraints")
+    console.print()
+    console.print("  [dim]Edit these files to customize behavior. Run 'zwarm init' again to reconfigure.[/]\n")
+
     console.print("[bold]Next steps:[/]")
     console.print("  [dim]# Run the orchestrator[/]")
     console.print("  $ zwarm orchestrate --task \"Your task here\"\n")
     console.print("  [dim]# Or test an executor directly[/]")
     console.print("  $ zwarm exec --task \"What is 2+2?\"\n")
+    console.print("  [dim]# Interactive session management[/]")
+    console.print("  $ zwarm interactive\n")
 
 
 def _generate_config_toml(
@@ -785,40 +994,87 @@ def _generate_config_toml(
     adapter: str = "codex_mcp",
     watchers: list[str] | None = None,
 ) -> str:
-    """Generate config.toml content."""
+    """Generate config.toml content with all options at their defaults."""
     watchers = watchers or []
 
     lines = [
         "# zwarm configuration",
         "# Generated by 'zwarm init'",
+        "# All values shown are defaults - uncomment and modify as needed",
         "",
+        "# ============================================================================",
+        "# Weave Integration (optional tracing/observability)",
+        "# ============================================================================",
         "[weave]",
     ]
 
     if weave_project:
         lines.append(f'project = "{weave_project}"')
     else:
-        lines.append("# project = \"your-entity/your-project\"  # Uncomment to enable Weave tracing")
+        lines.append('# project = "your-entity/your-project"  # Uncomment to enable Weave tracing')
 
     lines.extend([
+        "enabled = true",
         "",
+        "# ============================================================================",
+        "# Orchestrator Settings",
+        "# ============================================================================",
         "[orchestrator]",
-        "max_steps = 50",
+        '# lm = "gpt-5-mini"                    # LLM for orchestrator (gpt-5-mini, gpt-5, claude-sonnet-4)',
+        "max_steps = 50                         # Max steps for orchestrate command",
+        "max_steps_per_turn = 60                # Max steps per turn in pilot mode",
+        "parallel_delegations = 4               # Max concurrent delegations",
+        '# prompt = "path/to/prompt.yaml"       # Custom prompt file (optional)',
+        '# allowed_dirs = ["*"]                 # Directories agent can delegate to (default: working_dir only)',
+        "",
+        "# Context window compaction (prevents overflow on long tasks)",
+        "[orchestrator.compaction]",
+        "enabled = true",
+        "max_tokens = 100000                    # Trigger compaction above this",
+        "threshold_pct = 0.85                   # Compact when at this % of max_tokens",
+        "target_pct = 0.7                       # Target this % after compaction",
+        "keep_first_n = 2                       # Always keep first N messages (system + task)",
+        "keep_last_n = 10                       # Always keep last N messages (recent context)",
         "",
+        "# ============================================================================",
+        "# Executor Settings (codex agent configuration)",
+        "# ============================================================================",
         "[executor]",
-        f'adapter = "{adapter}"',
-        "# model = \"\"  # Optional model override",
+        f'adapter = "{adapter}"                  # codex_mcp | codex_exec | claude_code',
+        '# model = "gpt-5.1-codex-mini"         # Model for delegated sessions (uses codex.toml default if not set)',
+        'sandbox = "workspace-write"            # read-only | workspace-write | danger-full-access',
+        "timeout = 3600                         # Session timeout in seconds",
+        'reasoning_effort = "high"              # low | medium | high',
         "",
+        "# ============================================================================",
+        "# Watchers (automated monitoring and nudges)",
+        "# ============================================================================",
         "[watchers]",
-        f"enabled = {watchers}",
+        f"enabled = {str(bool(watchers)).lower()}",
+        'message_role = "user"                  # Role for nudge messages: user | assistant | system',
+        "",
+        "# Default watchers: progress, budget, delegation_reminder",
+        "# Uncomment below to customize:",
         "",
-        "# Watcher-specific configuration",
-        "# [watchers.budget]",
-        "# max_steps = 50",
+        "# [[watchers.watchers]]",
+        '# name = "progress"',
+        "# enabled = true",
+        "",
+        "# [[watchers.watchers]]",
+        '# name = "budget"',
+        "# enabled = true",
+        "# [watchers.watchers.config]",
+        "# max_sessions = 10",
         "# warn_at_percent = 80",
         "",
-        "# [watchers.pattern]",
-        "# patterns = [\"DROP TABLE\", \"rm -rf\"]",
+        "# [[watchers.watchers]]",
+        '# name = "delegation_reminder"',
+        "# enabled = true",
+        "",
+        "# ============================================================================",
+        "# State Directory",
+        "# ============================================================================",
+        '# state_dir = ".zwarm"                 # Where to store session data',
         "",
     ])
 
@@ -832,28 +1088,73 @@ def _generate_codex_toml(
     """
     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.
+    This file is parsed by zwarm and settings are passed to codex via -c overrides.
+    Each .zwarm directory has its own codex config, independent of ~/.codex/config.toml.
     """
     lines = [
         "# Codex configuration for zwarm",
-        "# This file isolates zwarm's codex settings from your global ~/.codex/config.toml",
+        "# zwarm parses this file and passes settings to codex via -c overrides",
+        "# Each .zwarm dir has its own config, independent of ~/.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",
+        "# DANGER MODE - bypasses all safety controls",
+        "# Set to true to use --dangerously-bypass-approvals-and-sandbox",
+        "full_danger = true",
         "",
-        "# You can override any codex setting here",
+        "# Web search - enables web_search tool for agents",
+        "[features]",
+        "web_search_request = true",
+        "",
+        "# Sandbox settings - network access required for web search",
+        "[sandbox_workspace_write]",
+        "network_access = true",
+        "",
+        "# Approval policy - 'never' means no human approval needed",
+        "# approval_policy = \"never\"",
+        "",
+        "# You can add any codex config key here",
         "# See: https://github.com/openai/codex#configuration",
         "",
     ]
     return "\n".join(lines)
 
 
+def _generate_claude_toml(
+    model: str = "sonnet",
+) -> str:
+    """
+    Generate claude.toml for isolated Claude Code configuration.
+
+    This file is parsed by zwarm and settings are passed to claude via CLI flags.
+    Each .zwarm directory has its own claude config.
+    """
+    lines = [
+        "# Claude Code configuration for zwarm",
+        "# zwarm parses this file and passes settings to claude via CLI flags",
+        "# Each .zwarm dir has its own config",
+        "# Generated by 'zwarm init'",
+        "",
+        "# Model settings",
+        f'model = "{model}"  # sonnet | opus | haiku',
+        "",
+        "# DANGER MODE - bypasses all permission checks",
+        "# Set to true to use --dangerously-skip-permissions",
+        "full_danger = true",
+        "",
+        "# Note: Claude Code uses different CLI flags than Codex",
+        "# Common options:",
+        "#   --model <model>         Model to use (sonnet, opus, haiku)",
+        "#   --add-dir <path>        Additional directories to allow",
+        "#   --allowed-tools <tools> Restrict available tools",
+        "",
+    ]
+    return "\n".join(lines)
+
+
 def _generate_zwarm_yaml(
     description: str = "",
     context: str = "",
@@ -1133,897 +1434,183 @@ def clean(
 def interactive(
     default_dir: Annotated[Path, typer.Option("--dir", "-d", help="Default working directory")] = Path("."),
     model: Annotated[Optional[str], typer.Option("--model", help="Default model override")] = None,
-    adapter: Annotated[str, typer.Option("--adapter", "-a", help="Executor adapter")] = "codex_mcp",
-    state_dir: Annotated[Path, typer.Option("--state-dir", help="State directory for persistence")] = Path(".zwarm"),
 ):
     """
-    Universal multi-agent CLI for commanding coding agents.
-
-    Spawn multiple agents across different directories, manage them interactively,
-    and view their outputs. You are the orchestrator.
+    Interactive REPL for session management.
 
-    This uses the SAME code path as `zwarm orchestrate` - the adapter layer.
-    Interactive is the human-in-the-loop version, orchestrate is the LLM version.
+    A clean, autocomplete-enabled interface for managing codex sessions.
+    Tab-complete session IDs, watch live output, and manage the session lifecycle.
 
     [bold]Commands:[/]
-        [cyan]spawn[/] "task" [opts]      Start a coding agent session (sync mode)
-        [cyan]async[/] "task" [opts]      Start async session (fire-and-forget)
-        [cyan]ls[/] / [cyan]list[/]               Dashboard of all sessions
-        [cyan]?[/] ID                    Quick peek (status + latest message)
-        [cyan]show[/] ID                  Full session details & history
-        [cyan]traj[/] ID                  Show trajectory (all steps taken)
-        [cyan]c[/] / [cyan]continue[/] ID "msg"   Continue a sync conversation
-        [cyan]kill[/] ID                  Stop a session (keeps in history)
-        [cyan]rm[/] ID                    Delete session entirely
-        [cyan]killall[/]                  Stop all running sessions
-        [cyan]clean[/]                    Remove old sessions (>7 days)
-        [cyan]q[/] / [cyan]quit[/]                Exit
-
-    [bold]Spawn Options:[/]
-        spawn "task" --dir ~/project --model gpt-5.1-codex-max --async
+        [cyan]spawn[/] "task"       Start a new session
+        [cyan]ls[/]                 Dashboard of all sessions
+        [cyan]peek[/] ID / [cyan]?[/] ID    Quick status check
+        [cyan]show[/] ID            Full session details
+        [cyan]traj[/] ID            Show trajectory (steps taken)
+        [cyan]watch[/] ID           Live follow session output
+        [cyan]c[/] ID "msg"         Continue conversation
+        [cyan]kill[/] ID | all      Stop session(s)
+        [cyan]rm[/] ID | all        Delete session(s)
 
     [bold]Examples:[/]
         $ zwarm interactive
-        > spawn "Build auth module" --dir ~/api
-        > spawn "Fix tests" --dir ~/api
-        > c abc123 "Now add error handling"
+        > spawn "Build auth module"
+        > watch abc123
+        > c abc123 "Now add tests"
         > ls
-        > ? abc123
     """
-    from zwarm.adapters import get_adapter, list_adapters
-    from zwarm.core.models import ConversationSession, SessionStatus, SessionMode
-    import argparse
+    from zwarm.cli.interactive import run_interactive
 
-    # Initialize adapter (same as orchestrator uses)
     default_model = model or "gpt-5.1-codex-mini"
-    default_adapter = adapter
-
-    # Config path for isolated codex configuration
-    codex_config_path = state_dir / "codex.toml"
-    if not codex_config_path.exists():
-        # Try relative to working dir
-        codex_config_path = default_dir / ".zwarm" / "codex.toml"
-    if not codex_config_path.exists():
-        codex_config_path = None  # Fall back to overrides
-
-    # Session tracking - same pattern as orchestrator
-    sessions: dict[str, ConversationSession] = {}
-    adapters_cache: dict[str, Any] = {}
-
-    def get_or_create_adapter(adapter_name: str, session_model: str | None = None) -> Any:
-        """Get or create an adapter instance with isolated config."""
-        cache_key = f"{adapter_name}:{session_model or default_model}"
-        if cache_key not in adapters_cache:
-            adapters_cache[cache_key] = get_adapter(
-                adapter_name,
-                model=session_model or default_model,
-                config_path=codex_config_path,
-            )
-        return adapters_cache[cache_key]
-
-    def find_session(query: str) -> tuple[ConversationSession | None, str | None]:
-        """Find session by full or partial ID."""
-        if query in sessions:
-            return sessions[query], query
-        for sid, session in sessions.items():
-            if sid.startswith(query):
-                return session, sid
-        return None, None
-
-    console.print("\n[bold cyan]zwarm interactive[/] - Multi-Agent Command Center\n")
-    console.print(f"  Working dir: {default_dir.absolute()}")
-    console.print(f"  Model: [cyan]{default_model}[/]")
-    console.print(f"  Adapter: [cyan]{default_adapter}[/]")
-    if codex_config_path:
-        console.print(f"  Config: [green]{codex_config_path}[/] (isolated)")
-    else:
-        console.print(f"  Config: [yellow]using fallback overrides[/] (run 'zwarm init' for isolation)")
-    console.print(f"  Available: {', '.join(list_adapters())}")
-    console.print("\n  Type [cyan]help[/] for commands, [cyan]quit[/] to exit.\n")
-
-    def show_help():
-        help_table = Table(show_header=False, box=None, padding=(0, 2))
-        help_table.add_column("Command", style="cyan", width=35)
-        help_table.add_column("Description")
-        help_table.add_row('spawn "task" [options]', "Start session (waits for completion)")
-        help_table.add_row("  --dir PATH", "Working directory")
-        help_table.add_row("  --model NAME", "Model override")
-        help_table.add_row("  --async", "Background mode (don't wait)")
-        help_table.add_row("", "")
-        help_table.add_row("ls / list", "Dashboard of all sessions")
-        help_table.add_row("? ID / peek ID", "Quick peek (status + latest message)")
-        help_table.add_row("show ID", "Full session details & messages")
-        help_table.add_row("traj ID [--full]", "Show trajectory (all steps taken)")
-        help_table.add_row('c ID "msg"', "Continue conversation (wait for response)")
-        help_table.add_row('ca ID "msg"', "Continue async (fire-and-forget)")
-        help_table.add_row("check ID", "Check session status")
-        help_table.add_row("kill ID", "Stop a running session")
-        help_table.add_row("rm ID", "Delete session entirely")
-        help_table.add_row("killall", "Stop all running sessions")
-        help_table.add_row("clean", "Remove old completed sessions")
-        help_table.add_row("q / quit", "Exit")
-        console.print(help_table)
-
-    def show_sessions():
-        """List all sessions from CodexSessionManager (same as orchestrator)."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-        from datetime import datetime
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        all_sessions = manager.list_sessions()
-
-        if not all_sessions:
-            console.print("  [dim]No sessions. Use 'spawn \"task\"' to start one.[/]")
-            return
-
-        # Status summary
-        running = sum(1 for s in all_sessions if s.status == SessStatus.RUNNING)
-        completed = sum(1 for s in all_sessions if s.status == SessStatus.COMPLETED)
-        failed = sum(1 for s in all_sessions if s.status == SessStatus.FAILED)
-        killed = sum(1 for s in all_sessions if s.status == SessStatus.KILLED)
-
-        summary_parts = []
-        if running:
-            summary_parts.append(f"[yellow]{running} running[/]")
-        if completed:
-            summary_parts.append(f"[green]{completed} done[/]")
-        if failed:
-            summary_parts.append(f"[red]{failed} failed[/]")
-        if killed:
-            summary_parts.append(f"[dim]{killed} killed[/]")
-        if summary_parts:
-            console.print(" | ".join(summary_parts))
-            console.print()
-
-        def time_ago(iso_str: str) -> str:
-            """Convert ISO timestamp to human-readable 'X ago' format."""
-            try:
-                dt = datetime.fromisoformat(iso_str)
-                delta = datetime.now() - dt
-                secs = delta.total_seconds()
-                if secs < 60:
-                    return f"{int(secs)}s"
-                elif secs < 3600:
-                    return f"{int(secs/60)}m"
-                elif secs < 86400:
-                    return f"{secs/3600:.1f}h"
-                else:
-                    return f"{secs/86400:.1f}d"
-            except:
-                return "?"
-
-        table = Table(box=None, show_header=True, header_style="bold dim")
-        table.add_column("ID", style="cyan", width=10)
-        table.add_column("", width=2)  # Status icon
-        table.add_column("T", width=2)  # Turn
-        table.add_column("Task", max_width=30)
-        table.add_column("Updated", justify="right", width=8)
-        table.add_column("Last Message", max_width=40)
-
-        status_icons = {
-            "running": "[yellow]●[/]",
-            "completed": "[green]✓[/]",
-            "failed": "[red]✗[/]",
-            "killed": "[dim]○[/]",
-            "pending": "[dim]◌[/]",
-        }
-
-        for s in all_sessions:
-            icon = status_icons.get(s.status.value, "?")
-            task_preview = s.task[:27] + "..." if len(s.task) > 30 else s.task
-            updated = time_ago(s.updated_at)
-
-            # Get last assistant message preview
-            messages = manager.get_messages(s.id)
-            last_msg = ""
-            for msg in reversed(messages):
-                if msg.role == "assistant":
-                    last_msg = msg.content.replace("\n", " ")[:37]
-                    if len(msg.content) > 37:
-                        last_msg += "..."
-                    break
-
-            # Style the last message based on recency
-            if s.status == SessStatus.RUNNING:
-                last_msg_styled = f"[yellow]{last_msg or '(working...)'}[/]"
-                updated_styled = f"[yellow]{updated}[/]"
-            elif s.status == SessStatus.COMPLETED:
-                # Highlight if recently completed (< 60s)
-                try:
-                    dt = datetime.fromisoformat(s.updated_at)
-                    is_recent = (datetime.now() - dt).total_seconds() < 60
-                except:
-                    is_recent = False
-                if is_recent:
-                    last_msg_styled = f"[green bold]{last_msg or '(done)'}[/]"
-                    updated_styled = f"[green bold]{updated} ★[/]"
-                else:
-                    last_msg_styled = f"[green]{last_msg or '(done)'}[/]"
-                    updated_styled = f"[dim]{updated}[/]"
-            elif s.status == SessStatus.FAILED:
-                last_msg_styled = f"[red]{s.error[:37] if s.error else '(failed)'}...[/]"
-                updated_styled = f"[red]{updated}[/]"
-            else:
-                last_msg_styled = f"[dim]{last_msg or '-'}[/]"
-                updated_styled = f"[dim]{updated}[/]"
-
-            table.add_row(
-                s.short_id,
-                icon,
-                str(s.turn),
-                task_preview,
-                updated_styled,
-                last_msg_styled,
-            )
-
-        console.print(table)
-
-    def parse_spawn_args(args: list[str]) -> dict:
-        """Parse spawn command arguments."""
-        parser = argparse.ArgumentParser(add_help=False)
-        parser.add_argument("task", nargs="*")
-        parser.add_argument("--dir", "-d", type=Path, default=None)
-        parser.add_argument("--model", "-m", default=None)
-        parser.add_argument("--async", dest="async_mode", action="store_true", default=False)
+    run_interactive(working_dir=default_dir.absolute(), model=default_model)
 
-        try:
-            parsed, _ = parser.parse_known_args(args)
-            return {
-                "task": " ".join(parsed.task) if parsed.task else "",
-                "dir": parsed.dir,
-                "model": parsed.model,
-                "async_mode": parsed.async_mode,
-            }
-        except SystemExit:
-            return {"error": "Invalid spawn arguments"}
-
-    def do_spawn(args: list[str]):
-        """Spawn a new coding agent session using CodexSessionManager (same as orchestrator)."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-        import time
-
-        parsed = parse_spawn_args(args)
-
-        if "error" in parsed:
-            console.print(f"  [red]{parsed['error']}[/]")
-            console.print("  [dim]Usage: spawn \"task\" [--dir PATH] [--model NAME] [--async][/]")
-            return
-
-        if not parsed["task"]:
-            console.print("  [red]Task required[/]")
-            console.print("  [dim]Usage: spawn \"task\" [--dir PATH] [--model NAME] [--async][/]")
-            return
-
-        task = parsed["task"]
-        work_dir = (parsed["dir"] or default_dir).absolute()
-        session_model = parsed["model"] or default_model
-        is_async = parsed.get("async_mode", False)
-
-        if not work_dir.exists():
-            console.print(f"  [red]Directory not found:[/] {work_dir}")
-            return
-
-        mode_str = "async" if is_async else "sync"
-        console.print(f"\n[dim]Spawning {mode_str} session...[/]")
-        console.print(f"  [dim]Dir: {work_dir}[/]")
-        console.print(f"  [dim]Model: {session_model}[/]")
 
-        try:
-            # Use CodexSessionManager - SAME as orchestrator's delegate()
-            manager = CodexSessionManager(work_dir / ".zwarm")
-            session = manager.start_session(
-                task=task,
-                working_dir=work_dir,
-                model=session_model,
-                sandbox="workspace-write",
-                source="user",
-                adapter="codex",
-            )
-
-            console.print(f"\n[green]✓[/] Session: [cyan]{session.short_id}[/]")
-            console.print(f"  [dim]PID: {session.pid}[/]")
-
-            # For sync mode, wait for completion and show response
-            if not is_async:
-                console.print(f"\n[dim]Waiting for completion...[/]")
-                timeout = 300.0
-                start = time.time()
-                while time.time() - start < timeout:
-                    # get_session() auto-updates status based on output completion
-                    session = manager.get_session(session.id)
-                    if session.status != SessStatus.RUNNING:
-                        break
-                    time.sleep(1.0)
-
-                # Get all assistant responses
-                messages = manager.get_messages(session.id)
-                assistant_msgs = [m for m in messages if m.role == "assistant"]
-                if assistant_msgs:
-                    console.print(f"\n[bold]Response ({len(assistant_msgs)} message{'s' if len(assistant_msgs) > 1 else ''}):[/]")
-                    for msg in assistant_msgs:
-                        preview = msg.content[:300]
-                        if len(msg.content) > 300:
-                            preview += "..."
-                        console.print(preview)
-                        if len(assistant_msgs) > 1:
-                            console.print()  # Blank line between multiple messages
-
-            console.print(f"\n[dim]Use 'show {session.short_id}' to see full details[/]")
-            console.print(f"[dim]Use 'c {session.short_id} \"message\"' to continue[/]")
-
-        except Exception as e:
-            console.print(f"  [red]Error:[/] {e}")
-            import traceback
-            console.print(f"  [dim]{traceback.format_exc()}[/]")
-
-    def do_orchestrate(args: list[str]):
-        """Spawn an orchestrator agent that delegates to sub-sessions."""
-        parsed = parse_spawn_args(args)
-
-        if "error" in parsed:
-            console.print(f"  [red]{parsed['error']}[/]")
-            console.print("  [dim]Usage: orchestrate \"task\" [--dir PATH][/]")
-            return
-
-        if not parsed["task"]:
-            console.print("  [red]Task required[/]")
-            console.print("  [dim]Usage: orchestrate \"task\" [--dir PATH][/]")
-            return
-
-        task = parsed["task"]
-        work_dir = (parsed["dir"] or default_dir).absolute()
-
-        if not work_dir.exists():
-            console.print(f"  [red]Directory not found:[/] {work_dir}")
-            return
-
-        console.print(f"\n[dim]Starting orchestrator...[/]")
-        console.print(f"  [dim]Dir: {work_dir}[/]")
-        console.print(f"  [dim]Task: {task[:60]}{'...' if len(task) > 60 else ''}[/]")
+@app.command()
+def sessions(
+    working_dir: Annotated[Path, typer.Option("--dir", "-d", help="Working directory")] = Path("."),
+    clean: Annotated[bool, typer.Option("--clean", "-c", help="Delete all non-running sessions")] = False,
+    kill_all: Annotated[bool, typer.Option("--kill-all", "-k", help="Kill all running sessions")] = False,
+    rm: Annotated[Optional[str], typer.Option("--rm", help="Delete specific session ID")] = None,
+    kill: Annotated[Optional[str], typer.Option("--kill", help="Kill specific session ID")] = None,
+):
+    """
+    Quick session management.
 
-        import subprocess
-        from uuid import uuid4
+    By default, lists all sessions. Use flags for quick actions:
 
-        # Generate instance ID for tracking
-        instance_id = str(uuid4())[:8]
+    [bold]Examples:[/]
+        [dim]# List all sessions[/]
+        $ zwarm sessions
 
-        # 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,
-        ]
+        [dim]# Delete all completed/failed sessions[/]
+        $ zwarm sessions --clean
+        $ zwarm sessions -c
 
-        # 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"
+        [dim]# Kill all running sessions[/]
+        $ zwarm sessions --kill-all
+        $ zwarm sessions -k
 
-        try:
-            with open(log_file, "w") as f:
-                proc = subprocess.Popen(
-                    cmd,
-                    cwd=work_dir,
-                    stdout=f,
-                    stderr=subprocess.STDOUT,
-                    start_new_session=True,
-                )
+        [dim]# Delete a specific session[/]
+        $ zwarm sessions --rm abc123
 
-            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 starting orchestrator:[/] {e}")
-
-    def do_peek(session_id: str):
-        """Quick peek at session - just status + latest message (for fast polling)."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
+        [dim]# Kill a specific session[/]
+        $ zwarm sessions --kill abc123
+    """
+    from zwarm.sessions import CodexSessionManager, SessionStatus
+    from zwarm.core.costs import estimate_session_cost, format_cost
 
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
+    manager = CodexSessionManager(working_dir / ".zwarm")
 
+    # Handle --kill (specific session)
+    if kill:
+        session = manager.get_session(kill)
         if not session:
-            console.print(f"  [red]Not found:[/] {session_id}")
-            return
-
-        # Status icon
-        icon = {
-            "running": "[yellow]●[/]",
-            "completed": "[green]✓[/]",
-            "failed": "[red]✗[/]",
-            "killed": "[dim]○[/]",
-        }.get(session.status.value, "?")
-
-        # Get latest assistant message
-        messages = manager.get_messages(session.id)
-        latest = None
-        for msg in reversed(messages):
-            if msg.role == "assistant":
-                latest = msg.content.replace("\n", " ")
-                break
-
-        if session.status == SessStatus.RUNNING:
-            console.print(f"{icon} [cyan]{session.short_id}[/] [yellow](running...)[/]")
-        elif latest:
-            # Truncate for one-liner
-            preview = latest[:120] + "..." if len(latest) > 120 else latest
-            console.print(f"{icon} [cyan]{session.short_id}[/] {preview}")
-        elif session.status == SessStatus.FAILED:
-            error = (session.error or "unknown")[:80]
-            console.print(f"{icon} [cyan]{session.short_id}[/] [red]{error}[/]")
+            console.print(f"[red]Session not found:[/] {kill}")
+            raise typer.Exit(1)
+        if manager.kill_session(session.id):
+            console.print(f"[green]✓[/] Killed {session.short_id}")
         else:
-            console.print(f"{icon} [cyan]{session.short_id}[/] [dim](no response)[/]")
-
-    def do_show(session_id: str):
-        """Show full session details and messages using CodexSessionManager."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
-
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            console.print(f"  [dim]Use 'ls' to see available sessions[/]")
-            return
-
-        # Status styling
-        status_display = {
-            "running": "[yellow]● running[/]",
-            "completed": "[green]✓ completed[/]",
-            "failed": "[red]✗ failed[/]",
-            "killed": "[dim]○ killed[/]",
-            "pending": "[dim]◌ pending[/]",
-        }.get(session.status.value, str(session.status.value))
-
-        console.print()
-        console.print(f"[bold cyan]Session {session.short_id}[/]  {status_display}")
-        console.print(f"[dim]Adapter:[/] {session.adapter}  [dim]│[/]  [dim]Model:[/] {session.model}")
-        console.print(f"[dim]Task:[/] {session.task}")
-        console.print(f"[dim]Dir:[/] {session.working_dir}  [dim]│[/]  [dim]Turn:[/] {session.turn}")
-        console.print(f"[dim]Source:[/] {session.source_display}  [dim]│[/]  [dim]Runtime:[/] {session.runtime}")
-        if session.pid:
-            console.print(f"[dim]PID:[/] {session.pid}")
-
-        # Show log file path
-        log_path = default_dir / ".zwarm" / "sessions" / session.id / "turns" / f"turn_{session.turn}.jsonl"
-        console.print(f"[dim]Log:[/] {log_path}")
-        console.print()
-
-        # Get messages from manager
-        messages = manager.get_messages(session.id)
-
-        if not messages:
-            if session.is_running:
-                console.print("[yellow]Session is still running...[/]")
-            else:
-                console.print("[dim]No messages captured.[/]")
-            return
-
-        # Display messages
-        for msg in messages:
-            if msg.role == "user":
-                console.print(Panel(msg.content, title="[bold blue]User[/]", border_style="blue"))
-            elif msg.role == "assistant":
-                content = msg.content
-                if len(content) > 2000:
-                    content = content[:2000] + "\n\n[dim]... (truncated)[/]"
-                console.print(Panel(content, title="[bold green]Assistant[/]", border_style="green"))
-            elif msg.role == "tool":
-                console.print(f"  [dim]Tool: {msg.content[:100]}[/]")
-
-        console.print()
-        if session.token_usage:
-            tokens = session.token_usage
-            console.print(f"[dim]Tokens: {tokens.get('input_tokens', 0):,} in / {tokens.get('output_tokens', 0):,} out[/]")
-
-        if session.error:
-            console.print(f"[red]Error:[/] {session.error}")
-
-    def do_trajectory(session_id: str, full: bool = False):
-        """Show the full trajectory of a session - all steps in order."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
-
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            return
-
-        trajectory = manager.get_trajectory(session_id, full=full)
-
-        if not trajectory:
-            console.print("[dim]No trajectory data available.[/]")
-            return
-
-        mode = "[bold](full)[/] " if full else ""
-        console.print(f"\n[bold cyan]Trajectory: {session.short_id}[/] {mode}({len(trajectory)} steps)")
-        console.print(f"[dim]Task: {session.task[:60]}{'...' if len(session.task) > 60 else ''}[/]")
-        console.print()
-
-        # Display each step
-        for step in trajectory:
-            turn = step.get("turn", 1)
-            step_num = step.get("step", 0)
-            step_type = step.get("type", "unknown")
-
-            prefix = f"[dim]T{turn}.{step_num:02d}[/]"
-
-            if step_type == "reasoning":
-                if full and step.get("full_text"):
-                    console.print(f"{prefix} [yellow]thinking:[/]")
-                    console.print(f"       {step['full_text']}")
-                else:
-                    summary = step.get("summary", "")
-                    console.print(f"{prefix} [yellow]thinking:[/] {summary}")
-
-            elif step_type == "command":
-                cmd = step.get("command", "")
-                output = step.get("output", "")
-                exit_code = step.get("exit_code", "?")
-                # Show command
-                console.print(f"{prefix} [cyan]$ {cmd}[/]")
-                if output:
-                    if full:
-                        # Show all output
-                        for line in output.split("\n"):
-                            console.print(f"       [dim]{line}[/]")
-                    else:
-                        # Indent output, max 5 lines
-                        for line in output.split("\n")[:5]:
-                            console.print(f"       [dim]{line}[/]")
-                        if output.count("\n") > 5:
-                            console.print(f"       [dim]... ({output.count(chr(10))} lines)[/]")
-                if exit_code != 0 and exit_code is not None:
-                    console.print(f"       [red]exit: {exit_code}[/]")
-
-            elif step_type == "tool_call":
-                tool = step.get("tool", "unknown")
-                if full and step.get("full_args"):
-                    import json
-                    console.print(f"{prefix} [magenta]tool:[/] {tool}")
-                    console.print(f"       {json.dumps(step['full_args'], indent=2)}")
-                else:
-                    args = step.get("args_preview", "")
-                    console.print(f"{prefix} [magenta]tool:[/] {tool}({args})")
-
-            elif step_type == "tool_output":
-                output = step.get("output", "")
-                if not full:
-                    output = output[:100]
-                console.print(f"{prefix} [dim]→ {output}[/]")
-
-            elif step_type == "message":
-                if full and step.get("full_text"):
-                    console.print(f"{prefix} [green]response:[/]")
-                    console.print(f"       {step['full_text']}")
-                else:
-                    summary = step.get("summary", "")
-                    full_len = step.get("full_length", 0)
-                    console.print(f"{prefix} [green]response:[/] {summary}")
-                    if full_len > 200:
-                        console.print(f"       [dim]({full_len} chars total)[/]")
-
-        console.print()
-
-    def do_continue(session_id: str, message: str, wait: bool = True):
-        """
-        Continue a conversation using CodexSessionManager.inject_message().
-
-        Works for both sync and async sessions:
-        - If session was sync (or wait=True): wait for response
-        - If session was async (or wait=False): fire-and-forget, check later with '?'
-        """
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-        import time
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
-
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            console.print(f"  [dim]Use 'ls' to see available sessions[/]")
-            return
-
-        if session.status == SessStatus.RUNNING:
-            console.print("[yellow]Session is still running.[/]")
-            console.print("[dim]Wait for it to complete, or use '?' to check progress.[/]")
-            return
-
-        if session.status == SessStatus.KILLED:
-            console.print("[yellow]Session was killed.[/]")
-            console.print("[dim]Start a new session with 'spawn'.[/]")
-            return
-
-        # Determine if we should wait based on session source
-        # Sessions from 'user' with --async flag have source='user'
-        # We'll use wait parameter to control this
-        should_wait = wait
-
-        console.print(f"\n[dim]Sending message to {session.short_id}...[/]")
-
-        try:
-            # Inject message - spawns new background process
-            updated_session = manager.inject_message(session.id, message)
-
-            if not updated_session:
-                console.print(f"  [red]Failed to inject message[/]")
-                return
-
-            console.print(f"[green]✓[/] Message sent (turn {updated_session.turn})")
-
-            if should_wait:
-                # Sync mode: wait for completion
-                console.print(f"[dim]Waiting for response...[/]")
-                timeout = 300.0
-                start = time.time()
-                while time.time() - start < timeout:
-                    # get_session() auto-updates status based on output completion
-                    session = manager.get_session(session.id)
-                    if session.status != SessStatus.RUNNING:
-                        break
-                    time.sleep(1.0)
-
-                # Get the response (last assistant message)
-                messages = manager.get_messages(session.id)
-                response = ""
-                for msg in reversed(messages):
-                    if msg.role == "assistant":
-                        response = msg.content
-                        break
-
-                console.print(f"\n[bold]Response:[/]")
-                if len(response) > 500:
-                    console.print(response[:500] + "...")
-                    console.print(f"\n[dim]Use 'show {session.short_id}' to see full response[/]")
-                else:
-                    console.print(response or "(no response captured)")
-            else:
-                # Async mode: return immediately
-                console.print(f"[dim]Running in background (PID: {updated_session.pid})[/]")
-                console.print(f"[dim]Use '? {session.short_id}' to check progress[/]")
-
-        except Exception as e:
-            console.print(f"  [red]Error:[/] {e}")
-            import traceback
-            console.print(f"  [dim]{traceback.format_exc()}[/]")
-
-    def do_check(session_id: str):
-        """Check status of a session using CodexSessionManager (same as orchestrator)."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
-
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            console.print(f"  [dim]Use 'ls' to see available sessions[/]")
-            return
-
-        status_icon = {
-            "running": "●",
-            "completed": "✓",
-            "failed": "✗",
-            "killed": "○",
-            "pending": "◌",
-        }.get(session.status.value, "?")
-
-        console.print(f"\n[bold]Session {session.short_id}[/]: {status_icon} {session.status.value}")
-        console.print(f"  [dim]Task: {session.task[:60]}{'...' if len(session.task) > 60 else ''}[/]")
-        console.print(f"  [dim]Turn: {session.turn} | Runtime: {session.runtime}[/]")
-
-        if session.status.value == "completed":
-            messages = manager.get_messages(session.id)
-            for msg in reversed(messages):
-                if msg.role == "assistant":
-                    console.print(f"\n[bold]Response:[/]")
-                    if len(msg.content) > 500:
-                        console.print(msg.content[:500] + "...")
-                    else:
-                        console.print(msg.content)
-                    break
-        elif session.status.value == "failed":
-            console.print(f"[red]Error:[/] {session.error or 'Unknown error'}")
-        elif session.status.value == "running":
-            console.print("[dim]Session is still running...[/]")
-            console.print(f"  [dim]PID: {session.pid}[/]")
-
-    def do_kill(session_id: str):
-        """Kill a running session using CodexSessionManager (same as orchestrator)."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
+            console.print(f"[yellow]Session not running or already stopped[/]")
+        return
 
+    # Handle --rm (specific session)
+    if rm:
+        session = manager.get_session(rm)
         if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
-            return
-
-        if not session.is_running:
-            console.print(f"[yellow]Session {session.short_id} is not running ({session.status.value}).[/]")
-            return
-
-        try:
-            killed = manager.kill_session(session.id)
-            if killed:
-                console.print(f"[green]✓[/] Stopped session {session.short_id}")
-            else:
-                console.print(f"[red]Failed to stop session[/]")
-        except Exception as e:
-            console.print(f"[red]Failed to stop session:[/] {e}")
-
-    def do_killall():
-        """Kill all running sessions using CodexSessionManager."""
-        from zwarm.sessions import CodexSessionManager, SessionStatus as SessStatus
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        running_sessions = manager.list_sessions(status=SessStatus.RUNNING)
+            console.print(f"[red]Session not found:[/] {rm}")
+            raise typer.Exit(1)
+        if manager.delete_session(session.id):
+            console.print(f"[green]✓[/] Deleted {session.short_id}")
+        else:
+            console.print(f"[red]Failed to delete[/]")
+        return
 
-        if not running_sessions:
-            console.print("[dim]No running sessions to kill.[/]")
+    # Handle --kill-all
+    if kill_all:
+        running = manager.list_sessions(status=SessionStatus.RUNNING)
+        if not running:
+            console.print("[dim]No running sessions[/]")
             return
-
         killed = 0
-        for session in running_sessions:
-            try:
-                if manager.kill_session(session.id):
-                    killed += 1
-            except Exception as e:
-                console.print(f"[red]Failed to stop {session.short_id}:[/] {e}")
-
-        console.print(f"[green]✓[/] Killed {killed} sessions")
-
-    def do_clean():
-        """Remove old completed/failed sessions from disk."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        cleaned = manager.cleanup_completed(keep_days=7)
-        console.print(f"[green]✓[/] Cleaned {cleaned} old sessions")
-
-    def do_delete(session_id: str):
-        """Delete a session entirely (removes from disk and ls)."""
-        from zwarm.sessions import CodexSessionManager
-
-        manager = CodexSessionManager(default_dir / ".zwarm")
-        session = manager.get_session(session_id)
+        for s in running:
+            if manager.kill_session(s.id):
+                console.print(f"  [green]✓[/] Killed {s.short_id}")
+                killed += 1
+        console.print(f"\n[green]Killed {killed} session(s)[/]")
+        return
 
-        if not session:
-            console.print(f"  [red]Session not found:[/] {session_id}")
+    # Handle --clean
+    if clean:
+        all_sessions = manager.list_sessions()
+        to_delete = [s for s in all_sessions if s.status != SessionStatus.RUNNING]
+        if not to_delete:
+            console.print("[dim]Nothing to clean[/]")
             return
+        deleted = 0
+        for s in to_delete:
+            if manager.delete_session(s.id):
+                deleted += 1
+        console.print(f"[green]✓[/] Deleted {deleted} session(s)")
+        return
 
-        if manager.delete_session(session.id):
-            console.print(f"[green]✓[/] Deleted session {session.short_id}")
-        else:
-            console.print(f"[red]Failed to delete session[/]")
-
-    # REPL loop
-    import shlex
-
-    while True:
-        try:
-            raw_input = console.input("[bold cyan]>[/] ").strip()
-            if not raw_input:
-                continue
-
-            # Parse command
-            try:
-                parts = shlex.split(raw_input)
-            except ValueError:
-                parts = raw_input.split()
-
-            cmd = parts[0].lower()
-            args = parts[1:]
-
-            if cmd in ("q", "quit", "exit"):
-                active = [s for s in sessions.values() if s.status == SessionStatus.ACTIVE]
-                if active:
-                    console.print(f"  [yellow]Warning:[/] {len(active)} sessions still active")
-                    console.print("  [dim]Use 'killall' first, or they'll continue in background[/]")
-
-                # Cleanup adapters
-                for adapter_instance in adapters_cache.values():
-                    try:
-                        asyncio.run(adapter_instance.cleanup())
-                    except Exception:
-                        pass
-
-                console.print("\n[dim]Goodbye![/]\n")
-                break
-
-            elif cmd in ("h", "help"):
-                show_help()
-
-            elif cmd in ("ls", "list"):
-                show_sessions()
-
-            elif cmd == "spawn":
-                do_spawn(args)
-
-            elif cmd == "async":
-                # Async spawn shorthand
-                do_spawn(args + ["--async"])
-
-            elif cmd == "orchestrate":
-                do_orchestrate(args)
-
-            elif cmd in ("?", "peek"):
-                if not args:
-                    console.print("  [red]Usage:[/] ? SESSION_ID")
-                else:
-                    do_peek(args[0])
-
-            elif cmd in ("show", "check"):
-                if not args:
-                    console.print("  [red]Usage:[/] show SESSION_ID")
-                else:
-                    do_show(args[0])
-
-            elif cmd in ("traj", "trajectory"):
-                if not args:
-                    console.print("  [red]Usage:[/] traj SESSION_ID [--full]")
-                else:
-                    full_mode = "--full" in args
-                    session_arg = [a for a in args if a != "--full"]
-                    if session_arg:
-                        do_trajectory(session_arg[0], full=full_mode)
-                    else:
-                        console.print("  [red]Usage:[/] traj SESSION_ID [--full]")
-
-            elif cmd in ("c", "continue"):
-                # Sync continue - waits for response
-                if len(args) < 2:
-                    console.print("  [red]Usage:[/] c SESSION_ID \"message\"")
-                else:
-                    do_continue(args[0], " ".join(args[1:]), wait=True)
+    # Default: list all sessions
+    all_sessions = manager.list_sessions()
 
-            elif cmd in ("ca", "async"):
-                # Async continue - fire and forget
-                if len(args) < 2:
-                    console.print("  [red]Usage:[/] ca SESSION_ID \"message\"")
-                    console.print("  [dim]Sends message and returns immediately (check with '?')[/]")
-                else:
-                    do_continue(args[0], " ".join(args[1:]), wait=False)
+    if not all_sessions:
+        console.print("[dim]No sessions found.[/]")
+        console.print("[dim]Start one with:[/]  zwarm session start \"your task\"")
+        return
 
-            elif cmd == "check":
-                if not args:
-                    console.print("  [red]Usage:[/] check SESSION_ID")
-                else:
-                    do_check(args[0])
+    # Summary counts
+    running = sum(1 for s in all_sessions if s.status == SessionStatus.RUNNING)
+    completed = sum(1 for s in all_sessions if s.status == SessionStatus.COMPLETED)
+    failed = sum(1 for s in all_sessions if s.status == SessionStatus.FAILED)
+    killed_count = sum(1 for s in all_sessions if s.status == SessionStatus.KILLED)
+
+    parts = []
+    if running:
+        parts.append(f"[yellow]⟳ {running} running[/]")
+    if completed:
+        parts.append(f"[green]✓ {completed} completed[/]")
+    if failed:
+        parts.append(f"[red]✗ {failed} failed[/]")
+    if killed_count:
+        parts.append(f"[dim]⊘ {killed_count} killed[/]")
+
+    console.print(" │ ".join(parts))
+    console.print()
 
-            elif cmd == "kill":
-                if not args:
-                    console.print("  [red]Usage:[/] kill SESSION_ID")
-                else:
-                    do_kill(args[0])
+    # Table
+    table = Table(box=None, show_header=True, header_style="bold dim")
+    table.add_column("ID", style="cyan")
+    table.add_column("", width=2)
+    table.add_column("Task", max_width=45)
+    table.add_column("Tokens", justify="right", style="dim")
+    table.add_column("Cost", justify="right", style="dim")
 
-            elif cmd == "killall":
-                do_killall()
+    status_icons = {
+        SessionStatus.RUNNING: "[yellow]⟳[/]",
+        SessionStatus.COMPLETED: "[green]✓[/]",
+        SessionStatus.FAILED: "[red]✗[/]",
+        SessionStatus.KILLED: "[dim]⊘[/]",
+        SessionStatus.PENDING: "[dim]○[/]",
+    }
 
-            elif cmd == "clean":
-                do_clean()
+    for session in all_sessions:
+        icon = status_icons.get(session.status, "?")
+        task = session.task[:42] + "..." if len(session.task) > 45 else session.task
+        tokens = session.token_usage.get("total_tokens", 0)
+        tokens_str = f"{tokens:,}" if tokens else "-"
 
-            elif cmd in ("rm", "delete", "remove"):
-                if not args:
-                    console.print("  [red]Usage:[/] rm SESSION_ID")
-                else:
-                    do_delete(args[0])
+        # Cost estimate
+        cost_info = estimate_session_cost(session.model, session.token_usage)
+        cost_str = format_cost(cost_info.get("cost"))
 
-            else:
-                console.print(f"  [yellow]Unknown command:[/] {cmd}")
-                console.print("  [dim]Type 'help' for available commands[/]")
+        table.add_row(session.short_id, icon, task, tokens_str, cost_str)
 
-        except KeyboardInterrupt:
-            console.print("\n[dim](Ctrl+C to exit, or type 'quit')[/]")
-        except EOFError:
-            console.print("\n[dim]Goodbye![/]\n")
-            break
-        except Exception as e:
-            console.print(f"  [red]Error:[/] {e}")
+    console.print(table)
+    console.print()
+    console.print("[dim]Quick actions:  --clean (-c) delete old  │  --kill-all (-k) stop running[/]")
 
 
 # =============================================================================
@@ -2074,6 +1661,7 @@ def session_start(
     Start a new Codex session in the background.
 
     The session runs independently and you can check on it later.
+    Web search is always enabled via .codex/config.toml (set up by `zwarm init`).
 
     [bold]Examples:[/]
         [dim]# Simple task[/]
@@ -2081,6 +1669,9 @@ def session_start(
 
         [dim]# With specific model[/]
         $ zwarm session start "Refactor the API" --model gpt-5.1-codex-max
+
+        [dim]# Web search is always available[/]
+        $ zwarm session start "Research latest OAuth2 best practices"
     """
     from zwarm.sessions import CodexSessionManager