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

zwarm/sessions/manager.py

@@ -6,6 +6,7 @@ Architecture:
 - Output is streamed to .zwarm/sessions/<session_id>/output.jsonl
 - Session metadata stored in meta.json
 - Can inject follow-up messages by starting new turns with context
+- Config is read from .zwarm/codex.toml and passed via -c overrides
 """
 
 from __future__ import annotations
@@ -15,6 +16,7 @@ import os
 import signal
 import subprocess
 import time
+import tomllib
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
@@ -25,16 +27,18 @@ from uuid import uuid4
 
 class SessionStatus(str, Enum):
     """Status of a codex session."""
-    PENDING = "pending"      # Created but not started
-    RUNNING = "running"      # Process is running
+
+    PENDING = "pending"  # Created but not started
+    RUNNING = "running"  # Process is running
     COMPLETED = "completed"  # Process exited successfully
-    FAILED = "failed"        # Process exited with error
-    KILLED = "killed"        # Manually killed
+    FAILED = "failed"  # Process exited with error
+    KILLED = "killed"  # Manually killed
 
 
 @dataclass
 class SessionMessage:
     """A message in a session's history."""
+
     role: str  # "user", "assistant", "system", "tool"
     content: str
     timestamp: str = ""
@@ -61,6 +65,7 @@ class SessionMessage:
 @dataclass
 class CodexSession:
     """A managed Codex session."""
+
     id: str
     task: str
     status: SessionStatus
@@ -180,6 +185,48 @@ class CodexSessionManager:
         self.sessions_dir = self.state_dir / "sessions"
         self.sessions_dir.mkdir(parents=True, exist_ok=True)
 
+    def _load_codex_config(self) -> dict[str, Any]:
+        """
+        Load codex.toml from state_dir.
+
+        Returns parsed TOML as dict, or empty dict if not found.
+        """
+        codex_toml = self.state_dir / "codex.toml"
+        if not codex_toml.exists():
+            return {}
+        try:
+            with open(codex_toml, "rb") as f:
+                return tomllib.load(f)
+        except Exception:
+            return {}
+
+    def _build_codex_overrides(self, config: dict[str, Any]) -> list[str]:
+        """
+        Convert codex.toml config to -c override flags.
+
+        Handles nested sections like [features] and [sandbox_workspace_write].
+
+        Returns list of ["-c", "key=value", "-c", "key2=value2", ...]
+        """
+        overrides = []
+
+        def add_override(key: str, value: Any):
+            """Add a -c override for a key=value pair."""
+            if isinstance(value, bool):
+                value = "true" if value else "false"
+            overrides.extend(["-c", f"{key}={value}"])
+
+        for key, value in config.items():
+            if isinstance(value, dict):
+                # Nested section like [features] or [sandbox_workspace_write]
+                for subkey, subvalue in value.items():
+                    add_override(f"{key}.{subkey}", subvalue)
+            else:
+                # Top-level key
+                add_override(key, value)
+
+        return overrides
+
     def _session_dir(self, session_id: str) -> Path:
         """Get the directory for a session."""
         return self.sessions_dir / session_id
@@ -228,7 +275,10 @@ class CodexSessionManager:
                 # Update status if process died OR output indicates completion
                 # (output check is more reliable than PID check due to PID reuse)
                 if session.status == SessionStatus.RUNNING:
-                    if self._is_output_complete(session.id, session.turn) or not session.is_running:
+                    if (
+                        self._is_output_complete(session.id, session.turn)
+                        or not session.is_running
+                    ):
                         self._update_session_status(session)
 
                 if status is None or session.status == status:
@@ -244,7 +294,10 @@ class CodexSessionManager:
         session = self._load_session(session_id)
         if session:
             if session.status == SessionStatus.RUNNING:
-                if self._is_output_complete(session.id, session.turn) or not session.is_running:
+                if (
+                    self._is_output_complete(session.id, session.turn)
+                    or not session.is_running
+                ):
                     self._update_session_status(session)
             return session
 
@@ -254,7 +307,10 @@ class CodexSessionManager:
                 session = self._load_session(session_dir.name)
                 if session:
                     if session.status == SessionStatus.RUNNING:
-                        if self._is_output_complete(session.id, session.turn) or not session.is_running:
+                        if (
+                            self._is_output_complete(session.id, session.turn)
+                            or not session.is_running
+                        ):
                             self._update_session_status(session)
                     return session
 
@@ -280,7 +336,12 @@ class CodexSessionManager:
                     event = json.loads(line)
                     event_type = event.get("type", "")
                     # Check for any completion marker
-                    if event_type in ("turn.completed", "task.completed", "completed", "done"):
+                    if event_type in (
+                        "turn.completed",
+                        "task.completed",
+                        "completed",
+                        "done",
+                    ):
                         return True
                     # Also check for error as a form of completion
                     if event_type == "error":
@@ -325,7 +386,7 @@ class CodexSessionManager:
         self,
         task: str,
         working_dir: Path | None = None,
-        model: str = "gpt-5.1-codex-mini",
+        model: str | None = None,
         sandbox: str = "workspace-write",
         source: str = "user",
         adapter: str = "codex",
@@ -336,18 +397,31 @@ class CodexSessionManager:
         Args:
             task: The task description
             working_dir: Working directory for codex (default: cwd)
-            model: Model to use
-            sandbox: Sandbox mode
+            model: Model override (default: from codex.toml or gpt-5.1-codex-mini)
+            sandbox: Sandbox mode (ignored if full_danger=true in codex.toml)
             source: Who spawned this session ("user" or "orchestrator:<id>")
             adapter: Which adapter to use ("codex", "claude_code")
 
         Returns:
             The created session
+
+        Note:
+            Settings are read from .zwarm/codex.toml and passed via -c overrides.
+            Run `zwarm init` to set up the config.
         """
         session_id = str(uuid4())
         working_dir = working_dir or Path.cwd()
         now = datetime.now().isoformat()
 
+        # Load codex config from .zwarm/codex.toml
+        codex_config = self._load_codex_config()
+
+        # Get model from config or use default
+        effective_model = model or codex_config.get("model", "gpt-5.1-codex-mini")
+
+        # Check if full_danger mode is enabled
+        full_danger = codex_config.get("full_danger", False)
+
         session = CodexSession(
             id=session_id,
             task=task,
@@ -355,7 +429,7 @@ class CodexSessionManager:
             working_dir=working_dir,
             created_at=now,
             updated_at=now,
-            model=model,
+            model=effective_model,
             turn=1,
             messages=[SessionMessage(role="user", content=task, timestamp=now)],
             source=source,
@@ -366,22 +440,28 @@ class CodexSessionManager:
         session_dir = self._session_dir(session_id)
         session_dir.mkdir(parents=True, exist_ok=True)
 
-        # Build command
-        cmd = [
-            "codex", "exec",
+        # Build command with -c overrides from codex.toml
+        # This ensures each .zwarm dir has its own codex config
+        cmd = ["codex"]
+
+        # Add -c overrides from codex.toml (excluding special keys we handle separately)
+        config_for_overrides = {k: v for k, v in codex_config.items() if k not in ("model", "full_danger")}
+        cmd.extend(self._build_codex_overrides(config_for_overrides))
+
+        # Add exec command and flags
+        cmd.extend([
+            "exec",
             "--json",
-            "--full-auto",
             "--skip-git-repo-check",
-            "--model", model,
-            "-C", str(working_dir.absolute()),
-        ]
-
-        # Add sandbox mode
-        if sandbox == "danger-full-access":
+            "--model",
+            effective_model,
+            "-C",
+            str(working_dir.absolute()),
+        ])
+
+        # Full danger mode bypasses all safety controls
+        if full_danger:
             cmd.append("--dangerously-bypass-approvals-and-sandbox")
-        elif sandbox == "workspace-write":
-            # Default codex behavior
-            pass
 
         cmd.extend(["--", task])
 
@@ -449,18 +529,29 @@ Continue from where you left off, addressing the user's new message."""
         # Start new turn
         session.turn += 1
         now = datetime.now().isoformat()
-        session.messages.append(SessionMessage(role="user", content=message, timestamp=now))
+        session.messages.append(
+            SessionMessage(role="user", content=message, timestamp=now)
+        )
 
         # Build command
-        cmd = [
-            "codex", "exec",
-            "--json",
-            "--full-auto",
-            "--skip-git-repo-check",
-            "--model", session.model,
-            "-C", str(session.working_dir.absolute()),
-            "--", augmented_task,
-        ]
+        # Note: --search is a global flag that must come before 'exec'
+        cmd = ["codex"]
+        if session.web_search:
+            cmd.append("--search")
+        cmd.extend(
+            [
+                "exec",
+                "--json",
+                "--full-auto",
+                "--skip-git-repo-check",
+                "--model",
+                session.model,
+                "-C",
+                str(session.working_dir.absolute()),
+                "--",
+                augmented_task,
+            ]
+        )
 
         # Start process
         output_path = self._output_path(session.id, session.turn)
@@ -578,7 +669,9 @@ Continue from where you left off, addressing the user's new message."""
 
         return all_messages
 
-    def _parse_output(self, output_path: Path) -> tuple[list[SessionMessage], dict[str, int], str | None]:
+    def _parse_output(
+        self, output_path: Path
+    ) -> tuple[list[SessionMessage], dict[str, int], str | None]:
         """
         Parse JSONL output from codex exec.
 
@@ -612,11 +705,13 @@ Continue from where you left off, addressing the user's new message."""
                 if item_type == "agent_message":
                     text = item.get("text", "")
                     if text:
-                        messages.append(SessionMessage(
-                            role="assistant",
-                            content=text,
-                            timestamp=datetime.now().isoformat(),
-                        ))
+                        messages.append(
+                            SessionMessage(
+                                role="assistant",
+                                content=text,
+                                timestamp=datetime.now().isoformat(),
+                            )
+                        )
 
                 elif item_type == "reasoning":
                     # Could optionally capture reasoning
@@ -625,19 +720,23 @@ Continue from where you left off, addressing the user's new message."""
                 elif item_type == "function_call":
                     # Track tool calls
                     func_name = item.get("name", "unknown")
-                    messages.append(SessionMessage(
-                        role="tool",
-                        content=f"[Calling: {func_name}]",
-                        metadata={"function": func_name},
-                    ))
+                    messages.append(
+                        SessionMessage(
+                            role="tool",
+                            content=f"[Calling: {func_name}]",
+                            metadata={"function": func_name},
+                        )
+                    )
 
                 elif item_type == "function_call_output":
                     output = item.get("output", "")
                     if output and len(output) < 500:
-                        messages.append(SessionMessage(
-                            role="tool",
-                            content=f"[Output]: {output[:500]}",
-                        ))
+                        messages.append(
+                            SessionMessage(
+                                role="tool",
+                                content=f"[Output]: {output[:500]}",
+                            )
+                        )
 
             elif event_type == "turn.completed":
                 turn_usage = event.get("usage", {})
@@ -645,14 +744,18 @@ Continue from where you left off, addressing the user's new message."""
                     usage[key] = usage.get(key, 0) + value
                 # Compute total_tokens if not present
                 if "total_tokens" not in usage:
-                    usage["total_tokens"] = usage.get("input_tokens", 0) + usage.get("output_tokens", 0)
+                    usage["total_tokens"] = usage.get("input_tokens", 0) + usage.get(
+                        "output_tokens", 0
+                    )
 
             elif event_type == "error":
                 error = event.get("message", str(event))
 
         return messages, usage, error
 
-    def get_trajectory(self, session_id: str, full: bool = False, max_output_len: int = 200) -> list[dict]:
+    def get_trajectory(
+        self, session_id: str, full: bool = False, max_output_len: int = 200
+    ) -> list[dict]:
         """
         Get the full trajectory of a session - all steps in order.
 
@@ -699,13 +802,16 @@ Continue from where you left off, addressing the user's new message."""
                     if item_type == "reasoning":
                         text = item.get("text", "")
                         summary_len = max_output_len if full else 100
-                        trajectory.append({
-                            "turn": turn,
-                            "step": step_num,
-                            "type": "reasoning",
-                            "summary": text[:summary_len] + ("..." if len(text) > summary_len else ""),
-                            "full_text": text if full else None,
-                        })
+                        trajectory.append(
+                            {
+                                "turn": turn,
+                                "step": step_num,
+                                "type": "reasoning",
+                                "summary": text[:summary_len]
+                                + ("..." if len(text) > summary_len else ""),
+                                "full_text": text if full else None,
+                            }
+                        )
 
                     elif item_type == "command_execution":
                         cmd = item.get("command", "")
@@ -715,52 +821,62 @@ Continue from where you left off, addressing the user's new message."""
                         output_preview = output[:max_output_len]
                         if len(output) > max_output_len:
                             output_preview += "..."
-                        trajectory.append({
-                            "turn": turn,
-                            "step": step_num,
-                            "type": "command",
-                            "command": cmd,
-                            "output": output_preview.strip(),
-                            "exit_code": exit_code,
-                        })
+                        trajectory.append(
+                            {
+                                "turn": turn,
+                                "step": step_num,
+                                "type": "command",
+                                "command": cmd,
+                                "output": output_preview.strip(),
+                                "exit_code": exit_code,
+                            }
+                        )
 
                     elif item_type == "function_call":
                         func_name = item.get("name", "unknown")
                         args = item.get("arguments", {})
                         args_str = str(args)
                         args_len = max_output_len if full else 100
-                        trajectory.append({
-                            "turn": turn,
-                            "step": step_num,
-                            "type": "tool_call",
-                            "tool": func_name,
-                            "args_preview": args_str[:args_len] + ("..." if len(args_str) > args_len else ""),
-                            "full_args": args if full else None,
-                        })
+                        trajectory.append(
+                            {
+                                "turn": turn,
+                                "step": step_num,
+                                "type": "tool_call",
+                                "tool": func_name,
+                                "args_preview": args_str[:args_len]
+                                + ("..." if len(args_str) > args_len else ""),
+                                "full_args": args if full else None,
+                            }
+                        )
 
                     elif item_type == "function_call_output":
                         output = item.get("output", "")
                         output_preview = output[:max_output_len]
                         if len(output) > max_output_len:
                             output_preview += "..."
-                        trajectory.append({
-                            "turn": turn,
-                            "step": step_num,
-                            "type": "tool_output",
-                            "output": output_preview,
-                        })
+                        trajectory.append(
+                            {
+                                "turn": turn,
+                                "step": step_num,
+                                "type": "tool_output",
+                                "output": output_preview,
+                            }
+                        )
 
                     elif item_type == "agent_message":
                         text = item.get("text", "")
                         summary_len = max_output_len if full else 200
-                        trajectory.append({
-                            "turn": turn,
-                            "step": step_num,
-                            "type": "message",
-                            "summary": text[:summary_len] + ("..." if len(text) > summary_len else ""),
-                            "full_text": text if full else None,
-                            "full_length": len(text),
-                        })
+                        trajectory.append(
+                            {
+                                "turn": turn,
+                                "step": step_num,
+                                "type": "message",
+                                "summary": text[:summary_len]
+                                + ("..." if len(text) > summary_len else ""),
+                                "full_text": text if full else None,
+                                "full_length": len(text),
+                            }
+                        )
 
         return trajectory
 
@@ -781,7 +897,11 @@ Continue from where you left off, addressing the user's new message."""
         cleaned = 0
 
         for session in self.list_sessions():
-            if session.status in (SessionStatus.COMPLETED, SessionStatus.FAILED, SessionStatus.KILLED):
+            if session.status in (
+                SessionStatus.COMPLETED,
+                SessionStatus.FAILED,
+                SessionStatus.KILLED,
+            ):
                 created = datetime.fromisoformat(session.created_at)
                 if created < cutoff:
                     session_dir = self._session_dir(session.id)

zwarm/tools/delegation.py

@@ -136,6 +136,8 @@ def delegate(
     This spawns a codex session - the exact same way `zwarm interactive` does.
     All sessions run async - you get a session_id immediately and poll for results.
 
+    Web search is always enabled via .codex/config.toml (set up by `zwarm init`).
+
     Workflow pattern:
         1. delegate(task="Add logout button") -> session_id
         2. sleep(30) -> give it time
@@ -155,6 +157,9 @@ def delegate(
         delegate(task="Add a logout button to the navbar")
         sleep(30)
         peek_session(session_id)  # Check progress
+
+    Example with web search (always available):
+        delegate(task="Find the latest FastAPI docs and add OAuth2 auth")
     """
     # Validate working directory
     effective_dir, dir_error = _validate_working_dir(
@@ -180,7 +185,7 @@ def delegate(
     sandbox = self.config.executor.sandbox or "workspace-write"
 
     # Start the session using CodexSessionManager
-    # This is the SAME method that `zwarm interactive` uses
+    # Web search is enabled via .codex/config.toml (symlink to .zwarm/config.toml)
     session = manager.start_session(
         task=task,
         working_dir=effective_dir,

{zwarm-3.2.1.dist-info → zwarm-3.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwarm
-Version: 3.2.1
+Version: 3.4.0
 Summary: Multi-Agent CLI Orchestration Research Platform
 Requires-Python: <3.14,>=3.13
 Requires-Dist: prompt-toolkit>=3.0.52
@@ -161,7 +161,7 @@ zwarm interactive
 
 | Command | Description |
 |---------|-------------|
-| `spawn "task"` | Start a new session |
+| `spawn "task" [--search]` | Start a new session (--search enables web) |
 | `ls` | Dashboard of all sessions (with costs) |
 | `? ID` / `peek ID` | Quick status check |
 | `show ID` | Full session details |
@@ -225,7 +225,7 @@ The orchestrator LLM has access to:
 
 | Tool | Description |
 |------|-------------|
-| `delegate(task)` | Start a new coding session |
+| `delegate(task, web_search=False)` | Start a new coding session |
 | `converse(id, msg)` | Continue a session |
 | `check_session(id)` | Get full session details |
 | `peek_session(id)` | Quick status check |
@@ -235,6 +235,8 @@ The orchestrator LLM has access to:
 
 **Async-first**: All sessions run in the background. The orchestrator uses `sleep()` to wait, then checks on progress.
 
+**Web Search**: Pass `web_search=True` to `delegate()` for tasks needing current info (API docs, latest releases, etc.).
+
 ### Watchers
 
 Watchers monitor the orchestrator and intervene when needed:
@@ -317,6 +319,7 @@ max_steps = 50
 
 [executor]
 adapter = "codex_mcp"
+web_search = false  # Enable web search for all delegated sessions
 
 [watchers]
 enabled = ["progress", "budget", "delegation", "delegation_reminder"]

{zwarm-3.2.1.dist-info → zwarm-3.4.0.dist-info}/RECORD

@@ -1,35 +1,28 @@
 zwarm/__init__.py,sha256=3i3LMjHwIzE-LFIS2aUrwv3EZmpkvVMe-xj1h97rcSM,837
-zwarm/orchestrator.py,sha256=JGRGuJP05Nf5QibuWytjQAC_NuGGaGUR3G-tLq4SVxY,23624
+zwarm/orchestrator.py,sha256=1IitiuhlCRGd512p3ObwiwI8c2zDzq1yzLTs_y6Mv_o,22803
 zwarm/test_orchestrator_watchers.py,sha256=QpoaehPU7ekT4XshbTOWnJ2H0wRveV3QOZjxbgyJJLY,807
-zwarm/adapters/__init__.py,sha256=O0b-SfZpb6txeNqFkXZ2aaf34yLFYreznyrAV25jF_Q,656
-zwarm/adapters/base.py,sha256=fZlQviTgVvOcwnxduTla6WuM6FzQJ_yoHMW5SxwVgQg,2527
-zwarm/adapters/claude_code.py,sha256=vAjsjD-_JjARmC4_FBSILQZmQCBrk_oNHo18a9ubuqk,11481
-zwarm/adapters/codex_mcp.py,sha256=EhdkM3gj5hc01AcM1ERhtfZbydK390yN4Pg3dawKIGU,48791
-zwarm/adapters/registry.py,sha256=EdyHECaNA5Kv1od64pYFBJyA_r_6I1r_eJTNP1XYLr4,1781
-zwarm/adapters/test_codex_mcp.py,sha256=0qhVzxn_KF-XUS30gXSJKwMdR3kWGsDY9iPk1Ihqn3w,10698
-zwarm/adapters/test_registry.py,sha256=otxcVDONwFCMisyANToF3iy7Y8dSbCL8bTmZNhxNuF4,2383
 zwarm/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zwarm/cli/interactive.py,sha256=0-KFo8tCHdlycgzprW2QCJaN5IKAo2CS3t3n6Mhfd4Q,25893
-zwarm/cli/main.py,sha256=bekPGLv6YbWOs8npbcurneC-i6H0GhMsKso2R5Uf3vU,70220
-zwarm/cli/pilot.py,sha256=ev6UfniLJKDR_GMSEA8JjWdTbtfRK0MLGk3VBCXpwTg,38011
+zwarm/cli/interactive.py,sha256=S9oi0gvfb7v4kRZvAb686zDTAqElv6dD_oqjcFNPXzM,25911
+zwarm/cli/main.py,sha256=ejJWQ6izr49dLgT35Kx0llWBW-QTBNs4_o19ntBeye0,71490
+zwarm/cli/pilot.py,sha256=QP3y_9utmvRVs-Hp4orc28ZnvN9hvdOhgOD-YV4Cs-s,40265
 zwarm/core/__init__.py,sha256=nEdpEHMFo0gEEKgX-eKHabyOdrOI6UXfWqLu3FfZDao,376
 zwarm/core/checkpoints.py,sha256=D6sXCMB7Sa1kchQ9_lQx_rabwc5-_7jbuynWgA1nkNY,6560
 zwarm/core/compact.py,sha256=Y8C7Gs-5-WOU43WRvQ863Qzd5xtuEqR6Aw3r2p8_-i8,10907
-zwarm/core/config.py,sha256=331i4io9uEnloFwUMjTPJ5_lQFKJR1nhTpA4SPfSpiI,11748
+zwarm/core/config.py,sha256=m3Vm6U_BNtEDu_cz2d6E3p_RNQfRHWaq-946mDru9-8,12656
 zwarm/core/costs.py,sha256=pLyixKn9hbDvtzQofOqajeK3XxOpoHPpA8nw8QM7j3g,5403
 zwarm/core/environment.py,sha256=zrgh0N3Ng4HI2F1gCYkcQVGzjQPKiIFWuRe1OPRuRn0,6558
 zwarm/core/models.py,sha256=PrC3okRBVJxISUa1Fax4KkagqLT6Xub-kTxC9drN0sY,10083
 zwarm/core/state.py,sha256=MzrvODKEiJovI7YI1jajW4uukineZ3ezmW5oQinMgjg,11563
 zwarm/core/test_compact.py,sha256=WSdjCB5t4YMcknsrkmJIUsVOPY28s4y9GnDmu3Z4BFw,11878
-zwarm/core/test_config.py,sha256=26ozyiFOdjFF2c9Q-HDfFM6GOLfgw_5FZ55nTDMNYA8,4888
+zwarm/core/test_config.py,sha256=bXXd3OHhK-ndC7wAxePWIdpu73s4O1eScxi3xDzrZwA,4828
 zwarm/core/test_models.py,sha256=sWTIhMZvuLP5AooGR6y8OR2EyWydqVfhmGrE7NPBBnk,8450
 zwarm/prompts/__init__.py,sha256=DI307o712F8qQyDt5vwnFgpVBrxpKwjhr0MaBHLzr9E,334
 zwarm/prompts/orchestrator.py,sha256=AkVbEpT91QbYFjUYOzm0d37wXrpm0esLBD1MG_W-3FI,15367
 zwarm/prompts/pilot.py,sha256=BcaV04-43FZyrtmoqCbA7DqnTlQ330TcDp9wNGhRojo,5586
 zwarm/sessions/__init__.py,sha256=jRibY8IfmNcnkgNmrgK2T81oa1w71wP_KQp9A1hPL7Q,568
-zwarm/sessions/manager.py,sha256=Aq7Wh-WW7ZMP8LgGa3g70wfGg6E2GYjJOBucy6HUfGc,27700
+zwarm/sessions/manager.py,sha256=bLxwFA9D4EBW3wCC6OqolKcBiZtv8igz0Z7ZGA7EcVc,31559
 zwarm/tools/__init__.py,sha256=FpqxwXJA6-fQ7C-oLj30jjK_0qqcE7MbI0dQuaB56kU,290
-zwarm/tools/delegation.py,sha256=lw4jJk1zVpgPhuvkUVfjUWFFMJotpJXXVY1YfqiP_Iw,21468
+zwarm/tools/delegation.py,sha256=wXKIb7eCL23c5NUwWi1G6JNg1PyXnwW-TNn7NrqchaE,21697
 zwarm/watchers/__init__.py,sha256=a96s7X6ruYkF2ItWWOZ3Q5QUOMOoeCW4Vz8XXcYLXPM,956
 zwarm/watchers/base.py,sha256=r1GoPlj06nOT2xp4fghfSjxbRyFFFQUB6HpZbEyO2OY,3834
 zwarm/watchers/builtin.py,sha256=IL5QwwKOIqWEfJ_uQWb321Px4i5OLtI_vnWQMudqKoA,19064
@@ -37,7 +30,7 @@ zwarm/watchers/llm_watcher.py,sha256=yJGpE3BGKNZX3qgPsiNtJ5d3UJpiTT1V-A-Rh4AiMYM
 zwarm/watchers/manager.py,sha256=XZjBVeHjgCUlkTUeHqdvBvHoBC862U1ik0fG6nlRGog,5587
 zwarm/watchers/registry.py,sha256=A9iBIVIFNtO7KPX0kLpUaP8dAK7ozqWLA44ocJGnOw4,1219
 zwarm/watchers/test_watchers.py,sha256=zOsxumBqKfR5ZVGxrNlxz6KcWjkcdp0QhW9WB0_20zM,7855
-zwarm-3.2.1.dist-info/METADATA,sha256=JkWHnaILTCMmy_n6Xam4uLXuRU5XFDPSiOOzleaYQvg,9429
-zwarm-3.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-zwarm-3.2.1.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
-zwarm-3.2.1.dist-info/RECORD,,
+zwarm-3.4.0.dist-info/METADATA,sha256=sw3IPlN6M89rjJ3GQIH_Pyyyn_AAdw64DaqjgqtDT0E,9670
+zwarm-3.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+zwarm-3.4.0.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
+zwarm-3.4.0.dist-info/RECORD,,

zwarm/adapters/__init__.py

@@ -1,21 +0,0 @@
-"""
-Adapters: Executor wrappers for CLI coding agents.
-
-Adapters provide a unified interface to different coding CLIs (Codex, Claude Code).
-Use the registry to discover and instantiate adapters by name.
-"""
-
-from zwarm.adapters.base import ExecutorAdapter
-from zwarm.adapters.registry import register_adapter, get_adapter, list_adapters, adapter_exists
-
-# Import built-in adapters to register them
-from zwarm.adapters import codex_mcp as _codex_mcp  # noqa: F401
-from zwarm.adapters import claude_code as _claude_code  # noqa: F401
-
-__all__ = [
-    "ExecutorAdapter",
-    "register_adapter",
-    "get_adapter",
-    "list_adapters",
-    "adapter_exists",
-]