zwarm 3.2.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

zwarm/cli/interactive.py

@@ -157,7 +157,7 @@ def cmd_help():
     table.add_column("Description")
 
     table.add_row("[bold]Session Lifecycle[/]", "")
-    table.add_row('spawn "task" [--dir PATH]', "Start new session")
+    table.add_row('spawn "task" [--dir PATH] [--model M]', "Start new session")
     table.add_row('c ID "message"', "Continue conversation")
     table.add_row("kill ID | all", "Stop session(s)")
     table.add_row("rm ID | all", "Delete session(s)")
@@ -694,7 +694,7 @@ def run_interactive(
 
             elif cmd == "spawn":
                 if not args:
-                    console.print("  [red]Usage:[/] spawn \"task\" [--dir PATH]")
+                    console.print("  [red]Usage:[/] spawn \"task\" [--dir PATH] [--search]")
                 else:
                     # Parse spawn args
                     task_parts = []

zwarm/cli/main.py

@@ -122,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,
@@ -384,78 +374,68 @@ def pilot(
 @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,
     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 executor directly (for testing).
+    Run a single Codex session directly (for testing).
 
-    Useful for testing adapters without the full orchestrator loop.
+    Spawns a session using CodexSessionManager - same as interactive/pilot.
+    Web search is always enabled via .codex/config.toml (set up by `zwarm init`).
 
     [bold]Examples:[/]
-        [dim]# Test Codex[/]
-        $ zwarm exec --task "What is 2+2?"
+        [dim]# Quick test[/]
+        $ zwarm exec --task "What is 2+2?" --wait
 
-        [dim]# Test Claude Code[/]
-        $ zwarm exec -a claude_code --task "List files in current dir"
+        [dim]# Run in background[/]
+        $ zwarm exec --task "Build feature"
 
-        [dim]# Async mode[/]
-        $ zwarm exec --task "Build feature" --mode async
+        [dim]# Web search is always available[/]
+        $ zwarm exec --task "Find latest FastAPI docs" --wait
     """
-    from zwarm.adapters import get_adapter
-
-    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}")
-
-    # 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, config_path=config_path)
-    except ValueError as e:
-        console.print(f"[red]Error:[/] {e}")
-        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]}")
-
-            if mode == ModeType.sync:
-                response = session.messages[-1].content if session.messages else "(no response)"
-                console.print(f"\n[bold]Response:[/]\n{response}")
+    import time
+    from zwarm.sessions import CodexSessionManager, SessionStatus
 
-                # 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
+    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}")
 
-                        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.")
+    manager = CodexSessionManager(working_dir / ".zwarm")
+    effective_model = model or "gpt-5.1-codex-mini"
 
-        finally:
-            await executor.cleanup()
+    session = manager.start_session(
+        task=task,
+        working_dir=working_dir.absolute(),
+        model=effective_model,
+    )
 
-    asyncio.run(run())
+    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()
@@ -740,12 +720,12 @@ def init(
     [bold]Creates:[/]
         [cyan].zwarm/[/]              State directory for sessions and events
         [cyan].zwarm/config.toml[/]   Runtime settings (weave, adapter, watchers)
-        [cyan].zwarm/codex.toml[/]    Codex CLI settings (model, reasoning effort)
+        [cyan].zwarm/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    → Controls the Codex CLI that runs executor sessions
+        codex.toml    → Codex settings, parsed by zwarm and passed via -c overrides
         zwarm.yaml    → Project-specific context injected into orchestrator
 
     [bold]Examples:[/]
@@ -939,7 +919,7 @@ def init(
     # Explain config files
     console.print("[bold]Configuration files:[/]")
     console.print("  [cyan].zwarm/config.toml[/]  - Runtime settings (Weave tracing, watchers)")
-    console.print("  [cyan].zwarm/codex.toml[/]   - Codex CLI settings (model, reasoning effort)")
+    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()
@@ -982,6 +962,7 @@ def _generate_config_toml(
         "[executor]",
         f'adapter = "{adapter}"',
         "# model = \"\"  # Optional model override",
+        "# web_search = false  # Enable web search for delegated sessions",
         "",
         "[watchers]",
         f"enabled = {watchers}",
@@ -1006,22 +987,35 @@ 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",
+        "",
+        "# Web search - enables web_search tool for agents",
+        "[features]",
+        "web_search_request = true",
         "",
-        "# You can override any codex setting here",
+        "# 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",
         "",
     ]
@@ -1534,6 +1528,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[/]
@@ -1541,6 +1536,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
 

zwarm/cli/pilot.py

@@ -186,10 +186,12 @@ def build_pilot_orchestrator(
     lm_class = lm_map.get(lm_choice, GPT5LargeVerbose)
     lm = lm_class()
 
-    # Load configuration
+    # Load configuration from working_dir (not cwd!)
+    # This ensures config.toml and .env are loaded from the project being worked on
     config = load_config(
         config_path=config_path,
         overrides=overrides,
+        working_dir=working_dir,
     )
 
     # Resolve working directory

zwarm/core/config.py

@@ -37,6 +37,7 @@ class ExecutorConfig:
     sandbox: str = "workspace-write"  # read-only | workspace-write | danger-full-access
     timeout: int = 3600
     reasoning_effort: str | None = "high"  # low | medium | high (default to high for compatibility)
+    # Note: web_search is always enabled via .codex/config.toml (set up by `zwarm init`)
 
 
 @dataclass
@@ -60,7 +61,6 @@ class OrchestratorConfig:
     tools: list[str] = field(default_factory=lambda: ["delegate", "converse", "check_session", "end_session", "bash"])
     max_steps: int = 50
     parallel_delegations: int = 4
-    sync_first: bool = True  # prefer sync mode by default
     compaction: CompactionConfig = field(default_factory=CompactionConfig)
 
     # Directory restrictions for agent delegations
@@ -173,7 +173,6 @@ class ZwarmConfig:
                 "tools": self.orchestrator.tools,
                 "max_steps": self.orchestrator.max_steps,
                 "parallel_delegations": self.orchestrator.parallel_delegations,
-                "sync_first": self.orchestrator.sync_first,
                 "compaction": {
                     "enabled": self.orchestrator.compaction.enabled,
                     "max_tokens": self.orchestrator.compaction.max_tokens,
@@ -195,15 +194,16 @@ class ZwarmConfig:
         }
 
 
-def load_env(path: Path | None = None) -> None:
+def load_env(path: Path | None = None, base_dir: Path | None = None) -> None:
     """Load .env file if it exists."""
     if path is None:
-        path = Path.cwd() / ".env"
+        base = base_dir or Path.cwd()
+        path = base / ".env"
     if path.exists():
         load_dotenv(path)
 
 
-def load_toml_config(path: Path | None = None) -> dict[str, Any]:
+def load_toml_config(path: Path | None = None, base_dir: Path | None = None) -> dict[str, Any]:
     """
     Load config.toml file.
 
@@ -211,11 +211,16 @@ def load_toml_config(path: Path | None = None) -> dict[str, Any]:
     1. Explicit path (if provided)
     2. .zwarm/config.toml (new standard location)
     3. config.toml (legacy location for backwards compat)
+
+    Args:
+        path: Explicit path to config.toml
+        base_dir: Base directory to search in (defaults to cwd)
     """
     if path is None:
+        base = base_dir or Path.cwd()
         # Try new location first
-        new_path = Path.cwd() / ".zwarm" / "config.toml"
-        legacy_path = Path.cwd() / "config.toml"
+        new_path = base / ".zwarm" / "config.toml"
+        legacy_path = base / "config.toml"
         if new_path.exists():
             path = new_path
         elif legacy_path.exists():
@@ -306,6 +311,7 @@ def load_config(
     toml_path: Path | None = None,
     env_path: Path | None = None,
     overrides: list[str] | None = None,
+    working_dir: Path | None = None,
 ) -> ZwarmConfig:
     """
     Load configuration with full precedence chain:
@@ -314,15 +320,24 @@ def load_config(
     3. YAML config file (if provided)
     4. CLI overrides (--set key=value)
     5. Environment variables (for secrets)
+
+    Args:
+        config_path: Path to YAML config file
+        toml_path: Explicit path to config.toml
+        env_path: Explicit path to .env file
+        overrides: CLI overrides (--set key=value)
+        working_dir: Working directory to search for config files (defaults to cwd).
+                    This is important when using --working-dir flag to ensure
+                    config is loaded from the project directory, not invoke directory.
     """
     # Load .env first (for secrets)
-    load_env(env_path)
+    load_env(env_path, base_dir=working_dir)
 
     # Start with defaults
     config_dict: dict[str, Any] = {}
 
     # Layer in config.toml
-    toml_config = load_toml_config(toml_path)
+    toml_config = load_toml_config(toml_path, base_dir=working_dir)
     if toml_config:
         config_dict = deep_merge(config_dict, toml_config)
 

zwarm/core/test_config.py

@@ -20,7 +20,6 @@ def test_default_config():
     assert config.executor.adapter == "codex_mcp"
     assert config.executor.sandbox == "workspace-write"
     assert config.orchestrator.lm == "gpt-5-mini"
-    assert config.orchestrator.sync_first is True
     assert config.state_dir == ".zwarm"
 
 
@@ -68,8 +67,8 @@ def test_apply_overrides():
     assert result["executor"]["adapter"] == "claude_code"
 
     # Override with boolean
-    result = apply_overrides(config, ["orchestrator.sync_first=false"])
-    assert result["orchestrator"]["sync_first"] is False
+    result = apply_overrides(config, ["executor.web_search=true"])
+    assert result["executor"]["web_search"] is True
 
     # Create new nested path
     result = apply_overrides(config, ["weave.project=my-project"])

zwarm/orchestrator.py

@@ -23,7 +23,6 @@ from wbal.helper import TOOL_CALL_TYPE, format_openai_tool_response
 from wbal.lm import LM as wbalLMGeneric
 from wbal.lm import GPT5LargeVerbose
 
-from zwarm.adapters import ExecutorAdapter, get_adapter
 from zwarm.core.compact import compact_messages, should_compact
 from zwarm.core.config import ZwarmConfig, load_config
 from zwarm.core.environment import OrchestratorEnv
@@ -72,7 +71,6 @@ class Orchestrator(YamlAgent):
     # State management
     _state: StateManager = PrivateAttr()
     _sessions: dict[str, ConversationSession] = PrivateAttr(default_factory=dict)
-    _adapters: dict[str, ExecutorAdapter] = PrivateAttr(default_factory=dict)
     _watcher_manager: WatcherManager | None = PrivateAttr(default=None)
     _resumed: bool = PrivateAttr(default=False)
     _total_tokens: int = PrivateAttr(default=0)  # Cumulative orchestrator tokens
@@ -85,7 +83,7 @@ class Orchestrator(YamlAgent):
     )
 
     def model_post_init(self, __context: Any) -> None:
-        """Initialize state and adapters after model creation."""
+        """Initialize state after model creation."""
         super().model_post_init(__context)
 
         # Initialize state manager with instance isolation
@@ -151,41 +149,6 @@ class Orchestrator(YamlAgent):
         """Access state manager."""
         return self._state
 
-    def _get_adapter(self, name: str) -> ExecutorAdapter:
-        """Get or create an adapter by name using the adapter registry."""
-        if name not in self._adapters:
-            # Get model from config (adapters have their own defaults if None)
-            model = self.config.executor.model
-
-            # Use isolated codex config if available
-            config_path = self.working_dir / self.config.state_dir / "codex.toml"
-            if not config_path.exists():
-                config_path = None  # Fallback to adapter defaults
-
-            self._adapters[name] = get_adapter(
-                name, model=model, config_path=config_path
-            )
-        return self._adapters[name]
-
-    def get_executor_usage(self) -> dict[str, int]:
-        """Get aggregated token usage across all executors."""
-        total = {
-            "input_tokens": 0,
-            "output_tokens": 0,
-            "total_tokens": 0,
-        }
-        for adapter in self._adapters.values():
-            if hasattr(adapter, "total_usage"):
-                usage = adapter.total_usage
-                for key in total:
-                    total[key] += usage.get(key, 0)
-        return total
-
-    @property
-    def executor_usage(self) -> dict[str, int]:
-        """Aggregated executor token usage (for Weave tracking)."""
-        return self.get_executor_usage()
-
     def save_state(self) -> None:
         """Save orchestrator state for resume."""
         self._state.save_orchestrator_messages(self.messages)
@@ -599,8 +562,7 @@ Review what was accomplished in the previous session and delegate new tasks as n
 
     async def cleanup(self) -> None:
         """Clean up resources."""
-        for adapter in self._adapters.values():
-            await adapter.cleanup()
+        pass  # Session cleanup handled by CodexSessionManager
 
 
 def build_orchestrator(
@@ -631,15 +593,17 @@ def build_orchestrator(
     """
     from uuid import uuid4
 
-    # Load configuration
+    # Resolve working directory first (needed for config loading)
+    working_dir = working_dir or Path.cwd()
+
+    # Load configuration from working_dir (not cwd!)
+    # This ensures config.toml and .env are loaded from the project being worked on
     config = load_config(
         config_path=config_path,
         overrides=overrides,
+        working_dir=working_dir,
     )
 
-    # Resolve working directory
-    working_dir = working_dir or Path.cwd()
-
     # Generate instance ID if not provided (enables isolation by default for new runs)
     # For resume, instance_id should be provided explicitly
     if instance_id is None and not resume: