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

zwarm/tools/delegation.py

@@ -2,13 +2,17 @@
 Delegation tools for the orchestrator.
 
 These are the core tools that orchestrators use to delegate work to executors.
-They use the SAME CodexSessionManager that `zwarm interactive` uses - no special
+They use the same session managers that `zwarm interactive` uses - no special
 MCP integration, no separate code path.
 
 The orchestrator LLM has access to the exact same tools a human would use.
 
+Supports multiple adapters:
+- codex: OpenAI's Codex CLI (default)
+- claude: Anthropic's Claude Code CLI
+
 Tools:
-- delegate: Start a new codex session
+- delegate: Start a new session (with adapter selection)
 - converse: Continue a conversation (inject follow-up message)
 - check_session: Check status of a session
 - end_session: End/kill a session
@@ -26,24 +30,53 @@ from wbal.helper import weaveTool
 if TYPE_CHECKING:
     from zwarm.orchestrator import Orchestrator
 
+# Available adapters
+ADAPTERS = ["codex", "claude"]
+
 
 def _get_session_manager(orchestrator: "Orchestrator"):
     """
-    Get the CodexSessionManager - the SINGLE source of truth for sessions.
+    Get the default session manager for list/get operations.
 
-    Both `zwarm interactive` and `zwarm orchestrate` use the same session manager.
-    The orchestrator is just another user that happens to be an LLM.
-
-    The session manager is created eagerly in Orchestrator.model_post_init()
-    and shared with the environment for observe() visibility.
+    Uses CodexSessionManager as the default since all adapters share
+    the same .zwarm/sessions/ directory structure.
     """
-    # Should already exist from model_post_init, but create if not
     if not hasattr(orchestrator, "_session_manager") or orchestrator._session_manager is None:
         from zwarm.sessions import CodexSessionManager
         orchestrator._session_manager = CodexSessionManager(orchestrator.working_dir / ".zwarm")
     return orchestrator._session_manager
 
 
+def _get_adapter_manager(orchestrator: "Orchestrator", adapter: str):
+    """
+    Get the session manager for a specific adapter.
+
+    Each adapter has its own manager for start_session/inject_message,
+    but they all share the same .zwarm/sessions/ directory.
+
+    Args:
+        orchestrator: The orchestrator instance
+        adapter: Adapter name ("codex" or "claude")
+
+    Returns:
+        Session manager for the specified adapter
+    """
+    # Initialize adapter managers dict if needed
+    if not hasattr(orchestrator, "_adapter_managers"):
+        orchestrator._adapter_managers = {}
+
+    # Return cached manager if exists
+    if adapter in orchestrator._adapter_managers:
+        return orchestrator._adapter_managers[adapter]
+
+    # Create new manager for this adapter
+    from zwarm.sessions import get_session_manager
+    manager = get_session_manager(adapter, str(orchestrator.working_dir / ".zwarm"))
+    orchestrator._adapter_managers[adapter] = manager
+
+    return manager
+
+
 def _truncate(text: str, max_len: int = 200) -> str:
     """Truncate text with ellipsis."""
     if len(text) <= max_len:
@@ -53,7 +86,8 @@ def _truncate(text: str, max_len: int = 200) -> str:
 
 def _format_session_header(session) -> str:
     """Format a nice session header."""
-    return f"[{session.short_id}] codex ({session.status.value})"
+    adapter = getattr(session, "adapter", "codex")
+    return f"[{session.short_id}] {adapter} ({session.status.value})"
 
 
 def _get_total_tokens(session) -> int:
@@ -129,11 +163,15 @@ def delegate(
     task: str,
     model: str | None = None,
     working_dir: str | None = None,
+    adapter: str = "codex",
 ) -> dict[str, Any]:
     """
-    Delegate work to a Codex agent.
+    Delegate work to an executor agent.
+
+    Supports multiple adapters:
+    - codex: OpenAI's Codex CLI (default, fast, good for code tasks)
+    - claude: Claude Code CLI (powerful, good for complex reasoning)
 
-    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.
 
     Workflow pattern:
@@ -145,17 +183,27 @@ def delegate(
 
     Args:
         task: Clear description of what to do. Be specific about requirements.
-        model: Model override (default: gpt-5.1-codex-mini).
-        working_dir: Directory for codex to work in (default: orchestrator's dir).
+        model: Model override (codex: gpt-5.1-codex-mini, claude: sonnet).
+        working_dir: Directory for executor to work in (default: orchestrator's dir).
+        adapter: Which executor to use - "codex" (default) or "claude".
 
     Returns:
-        {session_id, status: "running", task, hint}
+        {session_id, status: "running", task, adapter, hint}
 
-    Example:
+    Example with codex (default):
         delegate(task="Add a logout button to the navbar")
-        sleep(30)
-        peek_session(session_id)  # Check progress
+
+    Example with claude for complex tasks:
+        delegate(task="Refactor the auth system to use OAuth2", adapter="claude")
     """
+    # Validate adapter
+    if adapter not in ADAPTERS:
+        return {
+            "success": False,
+            "error": f"Unknown adapter: {adapter}. Available: {ADAPTERS}",
+            "hint": f"Use one of: {ADAPTERS}",
+        }
+
     # Validate working directory
     effective_dir, dir_error = _validate_working_dir(
         working_dir,
@@ -170,24 +218,28 @@ def delegate(
             "hint": "Use the default working directory or ask user to update allowed_dirs config",
         }
 
-    # Get the session manager (same one zwarm interactive uses)
-    manager = _get_session_manager(self)
+    # Get the session manager for this adapter
+    manager = _get_adapter_manager(self, adapter)
 
-    # Determine model
-    effective_model = model or self.config.executor.model or "gpt-5.1-codex-mini"
+    # Determine model (defaults vary by adapter)
+    if model:
+        effective_model = model
+    elif self.config.executor.model:
+        effective_model = self.config.executor.model
+    else:
+        # Use adapter-specific defaults
+        effective_model = manager.default_model
 
     # Determine sandbox mode
     sandbox = self.config.executor.sandbox or "workspace-write"
 
-    # Start the session using CodexSessionManager
-    # This is the SAME method that `zwarm interactive` uses
+    # Start the session
     session = manager.start_session(
         task=task,
         working_dir=effective_dir,
         model=effective_model,
         sandbox=sandbox,
         source=f"orchestrator:{self.instance_id or 'default'}",
-        adapter="codex",
     )
 
     # Return immediately - session runs in background
@@ -197,6 +249,8 @@ def delegate(
         "session_id": session.id,
         "status": "running",
         "task": _truncate(task, 100),
+        "adapter": adapter,
+        "model": effective_model,
         "hint": "Use sleep() then check_session(session_id) to monitor progress",
     }
 
@@ -208,15 +262,18 @@ def converse(
     message: str,
 ) -> dict[str, Any]:
     """
-    Continue a conversation with a codex session.
+    Continue a conversation with a session.
 
     This injects a follow-up message into the session, providing the
     conversation history as context. Like chatting with a developer.
     Returns immediately - use sleep() + check_session() to poll for the response.
 
+    Works with any adapter (codex or claude) - automatically uses the
+    correct adapter based on the session's original adapter.
+
     Args:
         session_id: The session to continue (from delegate() result).
-        message: Your next message to codex.
+        message: Your next message.
 
     Returns:
         {session_id, turn, status: "running"}
@@ -226,10 +283,10 @@ def converse(
         sleep(30)
         check_session(session_id)  # Get response
     """
-    manager = _get_session_manager(self)
+    # First get session to determine adapter
+    default_manager = _get_session_manager(self)
+    session = default_manager.get_session(session_id)
 
-    # Get current session
-    session = manager.get_session(session_id)
     if not session:
         return {
             "success": False,
@@ -253,8 +310,12 @@ def converse(
             "hint": "Start a new session with delegate()",
         }
 
+    # Get the correct adapter manager for this session
+    adapter = getattr(session, "adapter", "codex")
+    manager = _get_adapter_manager(self, adapter)
+
     # Inject the follow-up message
-    # This uses CodexSessionManager.inject_message() which:
+    # This uses the adapter's inject_message() which:
     # 1. Builds context from previous messages
     # 2. Starts a new turn with the context + new message (background process)
     updated_session = manager.inject_message(session_id, message)
@@ -273,6 +334,7 @@ def converse(
         "session_id": session_id,
         "turn": updated_session.turn,
         "status": "running",
+        "adapter": adapter,
         "you_said": _truncate(message, 100),
         "hint": "Use sleep() then check_session(session_id) to see the response",
     }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwarm
-Version: 3.2.1
+Version: 3.6.0
 Summary: Multi-Agent CLI Orchestration Research Platform
 Requires-Python: <3.14,>=3.13
 Requires-Dist: prompt-toolkit>=3.0.52
@@ -13,26 +13,30 @@ Description-Content-Type: text/markdown
 
 # zwarm
 
-Multi-agent CLI for orchestrating coding agents. Spawn, manage, and converse with multiple Codex sessions in parallel.
+Multi-agent CLI for orchestrating coding agents. Spawn, manage, and converse with multiple coding agent sessions in parallel.
+
+**Supports both [Codex CLI](https://github.com/openai/codex) and [Claude Code CLI](https://claude.com/claude-code).**
 
 ## Installation
 
 ```bash
-# From the workspace
-cd /path/to/labs
-uv sync
+# From PyPI
+pip install zwarm
 
-# Or install directly
-uv pip install -e ./zwarm
+# Or with uv
+uv pip install zwarm
 ```
 
 **Requirements:**
 - Python 3.13+
-- `codex` CLI installed and authenticated
+- At least one of:
+  - `codex` CLI installed and authenticated (OpenAI)
+  - `claude` CLI installed and authenticated (Anthropic)
 
 **Environment:**
 ```bash
 export OPENAI_API_KEY="sk-..."        # Required for Codex
+export ANTHROPIC_API_KEY="sk-..."     # Required for Claude
 export WEAVE_PROJECT="entity/zwarm"   # Optional: Weave tracing
 ```
 
@@ -78,6 +82,19 @@ zwarm interactive
 
 ---
 
+## Multi-Adapter Support
+
+zwarm supports multiple executor backends:
+
+| Adapter | CLI | Models | Config |
+|---------|-----|--------|--------|
+| **Codex** | `codex` | gpt-5.1-codex-mini, etc. | `.zwarm/codex.toml` |
+| **Claude** | `claude` | sonnet, opus, haiku | `.zwarm/claude.toml` |
+
+You can mix adapters in the same session - for example, use Claude Opus for complex reasoning tasks and Codex Mini for quick edits.
+
+---
+
 ## Pilot Mode
 
 **You chat with an LLM that delegates to coding agents.** Best of both worlds - LLM intelligence with human oversight.
@@ -85,12 +102,14 @@ zwarm interactive
 ```bash
 zwarm pilot
 zwarm pilot --task "Add user authentication"
+zwarm pilot --resume  # Resume previous session
 ```
 
 ### Features
 
 - **Conversational**: Chat naturally, the LLM handles delegation
 - **Checkpoints**: Every turn is saved, time-travel with `:goto`
+- **Resume**: Continue where you left off with `--resume`
 - **Multiline input**: Use `"""` for pasting large prompts
 - **Status bar**: See token usage, cost estimates, context window
 
@@ -103,7 +122,8 @@ zwarm pilot --task "Add user authentication"
 | `:history` | Show turn checkpoints |
 | `:goto T3` | Jump back to turn 3 |
 | `:sessions` | List executor sessions |
-| `:quit` | Exit |
+| `:save` | Save current state |
+| `:quit` | Exit (auto-saves) |
 
 ### Example
 
@@ -161,8 +181,8 @@ zwarm interactive
 
 | Command | Description |
 |---------|-------------|
-| `spawn "task"` | Start a new session |
-| `ls` | Dashboard of all sessions (with costs) |
+| `spawn "task" [--search]` | Start a new session (--search enables web) |
+| `ls` | Dashboard of all sessions (with costs, models) |
 | `? ID` / `peek ID` | Quick status check |
 | `show ID` | Full session details |
 | `traj ID` | Show trajectory (steps taken) |
@@ -170,6 +190,7 @@ zwarm interactive
 | `c ID "msg"` | Continue conversation |
 | `kill ID \| all` | Stop session(s) |
 | `rm ID \| all` | Delete session(s) |
+| `!command` | Run shell command (e.g., `!git status`) |
 | `help` | Show all commands |
 | `quit` | Exit |
 
@@ -188,9 +209,9 @@ $ zwarm interactive
 > ls
 ⟳ 2 running
 
-ID       │    │ Task                          │ Tokens  │ Cost
-abc123   │ ⟳  │ Add tests for the auth...     │ 5,234   │ $0.052
-def456   │ ⟳  │ Fix type errors in utils...   │ 2,100   │ $0.021
+ID       │    │ Task                          │ Model        │ Tokens  │ Cost
+abc123   │ ⟳  │ Add tests for the auth...     │ codex-mini   │ 5,234   │ $0.052
+def456   │ ⟳  │ Fix type errors in utils...   │ codex-mini   │ 2,100   │ $0.021
 
 > watch abc123
 Watching abc123... (Ctrl+C to stop)
@@ -201,6 +222,11 @@ Watching abc123... (Ctrl+C to stop)
 > c abc123 "Also add edge case tests"
 ✓ Injected message, session running
 
+> !git status
+On branch main
+Changes not staged for commit:
+  ...
+
 > kill all
   ✓ Killed abc123
   ✓ Killed def456
@@ -225,7 +251,7 @@ The orchestrator LLM has access to:
 
 | Tool | Description |
 |------|-------------|
-| `delegate(task)` | Start a new coding session |
+| `delegate(task, adapter="codex")` | 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 +261,10 @@ The orchestrator LLM has access to:
 
 **Async-first**: All sessions run in the background. The orchestrator uses `sleep()` to wait, then checks on progress.
 
+**Multi-adapter**: Pass `adapter="claude"` or `adapter="codex"` to `delegate()` to choose the backend.
+
+**Web Search**: Enable `web_search=True` in config for tasks needing current info (API docs, latest releases, etc.).
+
 ### Watchers
 
 Watchers monitor the orchestrator and intervene when needed:
@@ -283,9 +313,9 @@ spawn → running → completed/failed/killed
 
 ```
 .zwarm/sessions/<uuid>/
-├── meta.json           # Status, task, model, tokens, cost
+├── meta.json           # Status, task, model, adapter, tokens, cost
 └── turns/
-    ├── turn_1.jsonl    # Raw codex output for turn 1
+    ├── turn_1.jsonl    # Raw executor output for turn 1
     ├── turn_2.jsonl    # Output after continue
     └── ...
 ```
@@ -303,6 +333,7 @@ zwarm init
 This creates:
 - `.zwarm/config.toml` - Runtime settings (Weave, watchers)
 - `.zwarm/codex.toml` - Codex CLI settings (model, reasoning)
+- `.zwarm/claude.toml` - Claude CLI settings (model, permissions)
 - `zwarm.yaml` - Project context (optional, with `--with-project`)
 
 ### Config Files
@@ -316,7 +347,10 @@ project = "your-entity/zwarm"
 max_steps = 50
 
 [executor]
-adapter = "codex_mcp"
+web_search = false  # Enable web search for all delegated sessions
+
+[pilot]
+max_steps_per_turn = 25
 
 [watchers]
 enabled = ["progress", "budget", "delegation", "delegation_reminder"]
@@ -326,6 +360,13 @@ enabled = ["progress", "budget", "delegation", "delegation_reminder"]
 ```toml
 model = "gpt-5.1-codex-mini"
 model_reasoning_effort = "high"  # low | medium | high
+full_auto = true
+```
+
+**`.zwarm/claude.toml`** - Controls the Claude Code CLI:
+```toml
+model = "sonnet"  # sonnet | opus | haiku
+full_danger = true  # Skip permission prompts
 ```
 
 **`zwarm.yaml`** - Project-specific context:
@@ -352,6 +393,7 @@ zwarm init --yes        # Quick setup with defaults
 
 # Interfaces
 zwarm pilot             # Conversational LLM guidance (recommended)
+zwarm pilot --resume    # Resume previous session
 zwarm interactive       # Direct session control REPL
 zwarm orchestrate       # Fully autonomous LLM
 
@@ -374,13 +416,15 @@ zwarm reset             # Reset .zwarm/ state
 zwarm/
 ├── src/zwarm/
 │   ├── sessions/           # Session substrate
-│   │   └── manager.py      # CodexSessionManager (ground truth)
+│   │   ├── base.py         # BaseSessionManager (ABC)
+│   │   ├── manager.py      # CodexSessionManager
+│   │   └── claude.py       # ClaudeSessionManager
 │   ├── cli/
 │   │   ├── main.py         # CLI commands
 │   │   ├── pilot.py        # Pilot REPL
 │   │   └── interactive.py  # Interactive REPL
 │   ├── tools/
-│   │   └── delegation.py   # Orchestrator tools
+│   │   └── delegation.py   # Orchestrator tools (multi-adapter)
 │   ├── core/
 │   │   ├── config.py       # Configuration
 │   │   ├── checkpoints.py  # Time-travel primitives
@@ -389,5 +433,13 @@ zwarm/
 │   ├── watchers/           # Trajectory alignment
 │   ├── prompts/            # System prompts
 │   └── orchestrator.py     # Orchestrator agent
-└── STATE.md                # Current project state
+└── docs/
+    ├── CONCEPTS.md         # Architecture diagrams
+    └── INTERNALS.md        # Developer documentation
 ```
+
+---
+
+## License
+
+MIT

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

@@ -1,35 +1,31 @@
 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=zNxaU7U3PwHyx04-aiGqxyxwCsKhX-0jG0tzMlvrV24,39031
+zwarm/cli/main.py,sha256=vQGgbAkg_8ei5UTF-IvTtRv3Vxb85NNApVECwT1ghlg,77443
+zwarm/cli/pilot.py,sha256=my0j6-YpWRTFZ8tMrsh2wtJ2n9BP58JokvP7K8ssl7Q,42403
 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/costs.py,sha256=pLyixKn9hbDvtzQofOqajeK3XxOpoHPpA8nw8QM7j3g,5403
+zwarm/core/config.py,sha256=m3Vm6U_BNtEDu_cz2d6E3p_RNQfRHWaq-946mDru9-8,12656
+zwarm/core/costs.py,sha256=Z-5o-ZQWRCfFv0mTHev4Ke1AzyXKhXWO6ss7S8eBX9U,1485
 zwarm/core/environment.py,sha256=zrgh0N3Ng4HI2F1gCYkcQVGzjQPKiIFWuRe1OPRuRn0,6558
 zwarm/core/models.py,sha256=PrC3okRBVJxISUa1Fax4KkagqLT6Xub-kTxC9drN0sY,10083
+zwarm/core/registry.py,sha256=-3mwW4MZ8LKM9SuNBR-r5KWFcQx5F7gqnKfghikxzAI,9484
 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/__init__.py,sha256=5fPkl6JRS_GwPn9hi5iv3dzIpGWu_yghPtvPZdujhnM,1728
+zwarm/sessions/base.py,sha256=UA5E39xDx5q4qX2rUcvhSX7cfrCEqTS3F9Tj-ubmrJA,16538
+zwarm/sessions/claude.py,sha256=hBP_TpNFJjR29IRGJFB3rlG7Z9uWEYSbBGV61tpIr00,16672
+zwarm/sessions/manager.py,sha256=Vq5PePzKfy658EVG24SFsUMXQc1OGgOm8vdOX_WPMF8,18530
 zwarm/tools/__init__.py,sha256=FpqxwXJA6-fQ7C-oLj30jjK_0qqcE7MbI0dQuaB56kU,290
-zwarm/tools/delegation.py,sha256=lw4jJk1zVpgPhuvkUVfjUWFFMJotpJXXVY1YfqiP_Iw,21468
+zwarm/tools/delegation.py,sha256=FM8CIqm3ic6mHjVmY1DkOpTdMIYi21TniMclhdtPRn4,23424
 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 +33,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.6.0.dist-info/METADATA,sha256=5nkx2jC93DRcLohSvGdZk-W1XWeOc1DModIazvr0gwI,11311
+zwarm-3.6.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+zwarm-3.6.0.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
+zwarm-3.6.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",
-]

zwarm/adapters/base.py

@@ -1,109 +0,0 @@
-"""
-Base adapter protocol for executor agents.
-
-All CLI coding agent adapters (codex, claude-code, gemini) implement this protocol.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Literal
-
-from zwarm.core.models import ConversationSession, SessionMode
-
-
-class ExecutorAdapter(ABC):
-    """
-    Abstract base class for CLI coding agent adapters.
-
-    Adapters handle the mechanics of:
-    - Starting sessions (sync or async)
-    - Sending messages in sync mode
-    - Checking status in async mode
-    - Stopping sessions
-    """
-
-    name: str = "base"
-
-    @abstractmethod
-    async def start_session(
-        self,
-        task: str,
-        working_dir: Path,
-        mode: Literal["sync", "async"] = "sync",
-        model: str | None = None,
-        **kwargs,
-    ) -> ConversationSession:
-        """
-        Start a new session with the executor.
-
-        Args:
-            task: The task description/prompt
-            working_dir: Directory to work in
-            mode: "sync" for conversational, "async" for fire-and-forget
-            model: Optional model override
-            **kwargs: Adapter-specific options
-
-        Returns:
-            A ConversationSession with initial response (if sync)
-        """
-        ...
-
-    @abstractmethod
-    async def send_message(
-        self,
-        session: ConversationSession,
-        message: str,
-    ) -> str:
-        """
-        Send a message to a sync session and get response.
-
-        Args:
-            session: The active session
-            message: Message to send
-
-        Returns:
-            The agent's response
-
-        Raises:
-            ValueError: If session is not in sync mode or not active
-        """
-        ...
-
-    @abstractmethod
-    async def check_status(
-        self,
-        session: ConversationSession,
-    ) -> dict:
-        """
-        Check the status of an async session.
-
-        Args:
-            session: The session to check
-
-        Returns:
-            Status dict with at least {"status": "running"|"completed"|"failed"}
-        """
-        ...
-
-    @abstractmethod
-    async def stop(
-        self,
-        session: ConversationSession,
-    ) -> None:
-        """
-        Stop/kill a session.
-
-        Args:
-            session: The session to stop
-        """
-        ...
-
-    async def cleanup(self) -> None:
-        """
-        Clean up adapter resources (e.g., MCP server).
-
-        Called when the orchestrator shuts down.
-        """
-        pass