zwarm 1.1.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

zwarm/core/config.py

@@ -62,6 +62,12 @@ class OrchestratorConfig:
     sync_first: bool = True  # prefer sync mode by default
     compaction: CompactionConfig = field(default_factory=CompactionConfig)
 
+    # Directory restrictions for agent delegations
+    # None = only working_dir allowed (most restrictive, default)
+    # ["*"] = any directory allowed (dangerous)
+    # ["/path/a", "/path/b"] = only these directories allowed
+    allowed_dirs: list[str] | None = None
+
 
 @dataclass
 class WatcherConfigItem:
@@ -188,9 +194,24 @@ def load_env(path: Path | None = None) -> None:
 
 
 def load_toml_config(path: Path | None = None) -> dict[str, Any]:
-    """Load config.toml file."""
+    """
+    Load config.toml file.
+
+    Search order:
+    1. Explicit path (if provided)
+    2. .zwarm/config.toml (new standard location)
+    3. config.toml (legacy location for backwards compat)
+    """
     if path is None:
-        path = Path.cwd() / "config.toml"
+        # Try new location first
+        new_path = Path.cwd() / ".zwarm" / "config.toml"
+        legacy_path = Path.cwd() / "config.toml"
+        if new_path.exists():
+            path = new_path
+        elif legacy_path.exists():
+            path = legacy_path
+        else:
+            return {}
     if not path.exists():
         return {}
     with open(path, "rb") as f:

zwarm/core/state.py

@@ -1,16 +1,25 @@
 """
 Flat-file state management for zwarm.
 
-State structure:
+State structure (with instance isolation):
 .zwarm/
-├── state.json              # Current state (sessions, tasks)
-├── events.jsonl            # Append-only event log
-├── sessions/
-│   └── <session-id>/
-│       ├── messages.json   # Full conversation history
-│       └── output.log      # Agent stdout/stderr
-└── orchestrator/
-    └── messages.json       # Orchestrator's message history (for resume)
+├── instances.json              # Registry of all instances
+└── instances/
+    └── <instance-id>/
+        ├── state.json          # Current state (sessions, tasks)
+        ├── events.jsonl        # Append-only event log
+        ├── sessions/
+        │   └── <session-id>/
+        │       ├── messages.json
+        │       └── output.log
+        └── orchestrator/
+            └── messages.json   # Orchestrator's message history (for resume)
+
+Legacy structure (single instance, for backwards compat):
+.zwarm/
+├── state.json
+├── events.jsonl
+└── ...
 """
 
 from __future__ import annotations
@@ -19,10 +28,116 @@ import json
 from datetime import datetime
 from pathlib import Path
 from typing import Any
+from uuid import uuid4
 
 from .models import ConversationSession, Event, Task
 
 
+# --- Instance Registry ---
+
+def get_instances_registry_path(base_dir: Path | str = ".zwarm") -> Path:
+    """Get path to the instances registry file."""
+    return Path(base_dir) / "instances.json"
+
+
+def list_instances(base_dir: Path | str = ".zwarm") -> list[dict[str, Any]]:
+    """List all registered instances."""
+    registry_path = get_instances_registry_path(base_dir)
+    if not registry_path.exists():
+        return []
+    try:
+        return json.loads(registry_path.read_text()).get("instances", [])
+    except (json.JSONDecodeError, KeyError):
+        return []
+
+
+def register_instance(
+    instance_id: str,
+    name: str | None = None,
+    task: str | None = None,
+    base_dir: Path | str = ".zwarm",
+) -> None:
+    """Register an instance in the global registry."""
+    base = Path(base_dir)
+    base.mkdir(parents=True, exist_ok=True)
+
+    registry_path = get_instances_registry_path(base_dir)
+
+    # Load existing registry
+    if registry_path.exists():
+        try:
+            registry = json.loads(registry_path.read_text())
+        except json.JSONDecodeError:
+            registry = {"instances": []}
+    else:
+        registry = {"instances": []}
+
+    # Check if instance already registered
+    existing_ids = {inst["id"] for inst in registry["instances"]}
+    if instance_id in existing_ids:
+        # Update existing entry
+        for inst in registry["instances"]:
+            if inst["id"] == instance_id:
+                inst["updated_at"] = datetime.now().isoformat()
+                inst["status"] = "active"
+                if name:
+                    inst["name"] = name
+                if task:
+                    inst["task"] = task[:100]  # Truncate
+                break
+    else:
+        # Add new entry
+        registry["instances"].append({
+            "id": instance_id,
+            "name": name or instance_id[:8],
+            "task": (task[:100] if task else None),
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            "status": "active",
+        })
+
+    registry_path.write_text(json.dumps(registry, indent=2))
+
+
+def update_instance_status(
+    instance_id: str,
+    status: str,
+    base_dir: Path | str = ".zwarm",
+) -> None:
+    """Update an instance's status in the registry."""
+    registry_path = get_instances_registry_path(base_dir)
+    if not registry_path.exists():
+        return
+
+    try:
+        registry = json.loads(registry_path.read_text())
+    except json.JSONDecodeError:
+        return
+
+    for inst in registry.get("instances", []):
+        if inst["id"] == instance_id:
+            inst["status"] = status
+            inst["updated_at"] = datetime.now().isoformat()
+            break
+
+    registry_path.write_text(json.dumps(registry, indent=2))
+
+
+def get_instance_state_dir(
+    instance_id: str | None = None,
+    base_dir: Path | str = ".zwarm",
+) -> Path:
+    """
+    Get the state directory for an instance.
+
+    If instance_id is None, returns the legacy path for backwards compat.
+    """
+    base = Path(base_dir)
+    if instance_id is None:
+        return base  # Legacy: .zwarm/
+    return base / "instances" / instance_id
+
+
 def _json_serializer(obj: Any) -> Any:
     """Custom JSON serializer for non-standard types."""
     # Handle pydantic models
@@ -42,15 +157,31 @@ class StateManager:
     """
     Manages flat-file state for zwarm.
 
-    All state is stored as JSON files in a directory (default: .zwarm/).
+    All state is stored as JSON files in a directory.
+    With instance isolation: .zwarm/instances/<instance-id>/
+    Legacy (no instance): .zwarm/
+
     This enables:
     - Git-backed history
     - Easy debugging (just read the files)
     - Resume from previous state
+    - Multiple concurrent orchestrators (with instance isolation)
     """
 
-    def __init__(self, state_dir: Path | str = ".zwarm"):
-        self.state_dir = Path(state_dir)
+    def __init__(
+        self,
+        state_dir: Path | str = ".zwarm",
+        instance_id: str | None = None,
+    ):
+        self.base_dir = Path(state_dir)
+        self.instance_id = instance_id
+
+        # Resolve actual state directory
+        if instance_id:
+            self.state_dir = get_instance_state_dir(instance_id, self.base_dir)
+        else:
+            self.state_dir = self.base_dir
+
         self._sessions: dict[str, ConversationSession] = {}
         self._tasks: dict[str, Task] = {}
         self._orchestrator_messages: list[dict[str, Any]] = []

zwarm/orchestrator.py

@@ -21,9 +21,7 @@ from pydantic import Field, PrivateAttr
 from wbal.agents.yaml_agent import YamlAgent
 from wbal.helper import TOOL_CALL_TYPE, format_openai_tool_response
 
-from zwarm.adapters.base import ExecutorAdapter
-from zwarm.adapters.claude_code import ClaudeCodeAdapter
-from zwarm.adapters.codex_mcp import CodexMCPAdapter
+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
@@ -54,6 +52,10 @@ class Orchestrator(YamlAgent):
     config: ZwarmConfig = Field(default_factory=ZwarmConfig)
     working_dir: Path = Field(default_factory=Path.cwd)
 
+    # Instance identification (for multi-orchestrator isolation)
+    instance_id: str | None = Field(default=None)
+    instance_name: str | None = Field(default=None)
+
     # Load tools from modules (delegation + bash for verification)
     agent_tool_modules: list[str] = Field(
         default=[
@@ -79,11 +81,25 @@ class Orchestrator(YamlAgent):
         """Initialize state and adapters after model creation."""
         super().model_post_init(__context)
 
-        # Initialize state manager
-        self._state = StateManager(self.working_dir / self.config.state_dir)
+        # Initialize state manager with instance isolation
+        base_state_dir = self.working_dir / self.config.state_dir
+        self._state = StateManager(
+            state_dir=base_state_dir,
+            instance_id=self.instance_id,
+        )
         self._state.init()
         self._state.load()
 
+        # Register instance if using instance isolation
+        if self.instance_id:
+            from zwarm.core.state import register_instance
+            register_instance(
+                instance_id=self.instance_id,
+                name=self.instance_name,
+                task=None,  # Will be updated when task is set
+                base_dir=base_state_dir,
+            )
+
         # Load existing sessions
         for session in self._state.list_sessions():
             self._sessions[session.id] = session
@@ -123,16 +139,11 @@ class Orchestrator(YamlAgent):
         return self._state
 
     def _get_adapter(self, name: str) -> ExecutorAdapter:
-        """Get or create an adapter by name."""
+        """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
-            if name == "codex_mcp":
-                self._adapters[name] = CodexMCPAdapter(model=model)
-            elif name == "claude_code":
-                self._adapters[name] = ClaudeCodeAdapter(model=model)
-            else:
-                raise ValueError(f"Unknown adapter: {name}")
+            self._adapters[name] = get_adapter(name, model=model)
         return self._adapters[name]
 
     def get_executor_usage(self) -> dict[str, int]:
@@ -222,12 +233,18 @@ class Orchestrator(YamlAgent):
         if not self._resumed:
             return
 
-        # Build list of old sessions
+        # Build list of old sessions and INVALIDATE their conversation IDs
+        # The MCP server was restarted, so all conversation IDs are now stale
         old_sessions = []
+        invalidated_count = 0
         for sid, session in self._sessions.items():
             old_sessions.append(
                 f"  - {sid[:8]}... ({session.adapter}, {session.status.value})"
             )
+            # Clear stale conversation_id to prevent converse() from trying to use it
+            if session.conversation_id:
+                session.conversation_id = None
+                invalidated_count += 1
 
         session_info = "\n".join(old_sessions) if old_sessions else "  (none)"
 
@@ -235,14 +252,14 @@ class Orchestrator(YamlAgent):
             "role": "user",
             "content": f"""[SYSTEM NOTICE] You have been resumed from a previous session.
 
-IMPORTANT: Your previous executor sessions are NO LONGER ACTIVE. The MCP connections and subprocess handles were lost when the previous session ended.
+CRITICAL: Your previous executor sessions are NO LONGER USABLE. The MCP server was restarted, so all conversation state was lost. {invalidated_count} conversation ID(s) have been invalidated.
 
-Previous sessions (now stale):
+Previous sessions (conversation IDs cleared):
 {session_info}
 
-You must start NEW sessions with delegate() if you need to continue work. Do NOT try to use converse() or check_session() with the old session IDs - they will fail.
+You MUST start NEW sessions with delegate() to continue any work. The converse() tool will fail on these old sessions because they have no active conversation.
 
-Continue with your task from where you left off.""",
+Review what was accomplished in the previous session and delegate new tasks as needed.""",
         }
 
         self.messages.append(resume_msg)
@@ -528,6 +545,8 @@ def build_orchestrator(
     overrides: list[str] | None = None,
     resume: bool = False,
     output_handler: Callable[[str], None] | None = None,
+    instance_id: str | None = None,
+    instance_name: str | None = None,
 ) -> Orchestrator:
     """
     Build an orchestrator from configuration.
@@ -539,10 +558,14 @@ def build_orchestrator(
         overrides: CLI overrides (--set key=value)
         resume: Whether to resume from previous state
         output_handler: Function to handle orchestrator output
+        instance_id: Unique ID for this instance (enables multi-orchestrator isolation)
+        instance_name: Human-readable name for this instance
 
     Returns:
         Configured Orchestrator instance
     """
+    from uuid import uuid4
+
     # Load configuration
     config = load_config(
         config_path=config_path,
@@ -552,6 +575,11 @@ def build_orchestrator(
     # 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:
+        instance_id = str(uuid4())
+
     # Build system prompt
     system_prompt = _build_system_prompt(config, working_dir)
 
@@ -572,6 +600,8 @@ def build_orchestrator(
         system_prompt=system_prompt,
         maxSteps=config.orchestrator.max_steps,
         env=env,
+        instance_id=instance_id,
+        instance_name=instance_name,
     )
 
     # Resume if requested

zwarm/tools/delegation.py

@@ -11,6 +11,7 @@ These are the core tools that orchestrators use to delegate work to executors:
 from __future__ import annotations
 
 import asyncio
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
 from wbal.helper import weaveTool
@@ -31,6 +32,65 @@ def _format_session_header(session_id: str, adapter: str, mode: str) -> str:
     return f"[{session_id[:8]}] {adapter} ({mode})"
 
 
+def _validate_working_dir(
+    requested_dir: Path | str | None,
+    default_dir: Path,
+    allowed_dirs: list[str] | None,
+) -> tuple[Path, str | None]:
+    """
+    Validate requested working directory against allowed_dirs config.
+
+    Args:
+        requested_dir: Directory requested by the agent (or None for default)
+        default_dir: The orchestrator's working directory
+        allowed_dirs: Config setting - None means only default allowed,
+                     ["*"] means any, or list of allowed paths
+
+    Returns:
+        (validated_path, error_message) - error is None if valid
+    """
+    if requested_dir is None:
+        return default_dir, None
+
+    requested = Path(requested_dir).resolve()
+
+    # Check if directory exists
+    if not requested.exists():
+        return default_dir, f"Directory does not exist: {requested}"
+
+    if not requested.is_dir():
+        return default_dir, f"Not a directory: {requested}"
+
+    # If allowed_dirs is None, only default is allowed
+    if allowed_dirs is None:
+        if requested == default_dir.resolve():
+            return requested, None
+        return default_dir, (
+            f"Directory not allowed: {requested}. "
+            f"Agent can only delegate to working directory ({default_dir}). "
+            "Set orchestrator.allowed_dirs in config to allow other directories."
+        )
+
+    # If ["*"], any directory is allowed
+    if allowed_dirs == ["*"]:
+        return requested, None
+
+    # Check against allowed list
+    for allowed in allowed_dirs:
+        allowed_path = Path(allowed).resolve()
+        # Allow if requested is the allowed path or a subdirectory of it
+        try:
+            requested.relative_to(allowed_path)
+            return requested, None
+        except ValueError:
+            continue
+
+    return default_dir, (
+        f"Directory not allowed: {requested}. "
+        f"Allowed directories: {allowed_dirs}"
+    )
+
+
 @weaveTool
 def delegate(
     self: "Orchestrator",
@@ -38,6 +98,7 @@ def delegate(
     mode: Literal["sync", "async"] = "sync",
     adapter: str | None = None,
     model: str | None = None,
+    working_dir: str | None = None,
 ) -> dict[str, Any]:
     """
     Delegate work to an executor agent.
@@ -57,6 +118,8 @@ def delegate(
         mode: "sync" for conversational, "async" for fire-and-forget.
         adapter: Which executor adapter to use (default: config setting).
         model: Model override for the executor.
+        working_dir: Directory for the executor to work in (default: orchestrator's dir).
+                    NOTE: May be restricted by orchestrator.allowed_dirs config.
 
     Returns:
         {session_id, status, response (if sync)}
@@ -65,6 +128,20 @@ def delegate(
         delegate(task="Add a logout button to the navbar", mode="sync")
         # Then use converse() to refine: "Also add a confirmation dialog"
     """
+    # Validate working directory against allowed_dirs config
+    effective_dir, dir_error = _validate_working_dir(
+        working_dir,
+        self.working_dir,
+        self.config.orchestrator.allowed_dirs,
+    )
+
+    if dir_error:
+        return {
+            "success": False,
+            "error": dir_error,
+            "hint": "Use the default working directory or ask user to update allowed_dirs config",
+        }
+
     # Get adapter (use default from config if not specified)
     adapter_name = adapter or self.config.executor.adapter
     executor = self._get_adapter(adapter_name)
@@ -73,7 +150,7 @@ def delegate(
     session = asyncio.run(
         executor.start_session(
             task=task,
-            working_dir=self.working_dir,
+            working_dir=effective_dir,
             mode=mode,
             model=model or self.config.executor.model,
             sandbox=self.config.executor.sandbox,
@@ -117,7 +194,7 @@ def delegate(
     header = _format_session_header(session.id, adapter_name, mode)
 
     if mode == "sync":
-        return {
+        result = {
             "success": True,
             "session": header,
             "session_id": session.id,
@@ -127,6 +204,14 @@ def delegate(
             "tokens": session.token_usage.get("total_tokens", 0),
             "hint": "Use converse(session_id, message) to continue this conversation",
         }
+        # Warn if no conversation ID - converse() won't work
+        if not session.conversation_id:
+            result["warning"] = "no_conversation_id"
+            result["hint"] = (
+                "WARNING: MCP didn't return a conversation ID. "
+                "You cannot use converse() - send all instructions upfront or use async mode."
+            )
+        return result
     else:
         return {
             "success": True,
@@ -186,6 +271,18 @@ def converse(
             "hint": "Start a new session with delegate()",
         }
 
+    # Check for stale/missing conversation_id (common after resume)
+    if not session.conversation_id:
+        return {
+            "success": False,
+            "error": "Session has no conversation ID (likely stale after resume)",
+            "hint": (
+                "This session's conversation was lost (MCP server restarted). "
+                "Use end_session() to close it, then delegate() a new task."
+            ),
+            "session_id": session_id,
+        }
+
     # Get adapter and send message
     executor = self._get_adapter(session.adapter)
     try:
@@ -211,7 +308,13 @@ def converse(
     turn = len([m for m in session.messages if m.role == "user"])
     header = _format_session_header(session.id, session.adapter, session.mode.value)
 
-    return {
+    # Check for conversation loss (indicated by error in response)
+    conversation_lost = (
+        "[ERROR] Conversation lost" in response
+        or session.conversation_id is None
+    )
+
+    result = {
         "success": True,
         "session": header,
         "session_id": session_id,
@@ -221,6 +324,15 @@ def converse(
         "tokens": session.token_usage.get("total_tokens", 0),
     }
 
+    if conversation_lost:
+        result["warning"] = "conversation_lost"
+        result["hint"] = (
+            "The MCP server lost this conversation. You should end_session() "
+            "and delegate() a new task with the full context."
+        )
+
+    return result
+
 
 @weaveTool
 def check_session(

{zwarm-1.1.1.dist-info → zwarm-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwarm
-Version: 1.1.1
+Version: 1.3.2
 Summary: Multi-Agent CLI Orchestration Research Platform
 Requires-Python: <3.14,>=3.13
 Requires-Dist: python-dotenv>=1.0.0
@@ -76,10 +76,11 @@ echo "Fix the bug in auth.py" | zwarm orchestrate
 
 zwarm looks for configuration in this order:
 1. `--config` flag (YAML file)
-2. `config.toml` in working directory
-3. Default settings
+2. `.zwarm/config.toml` (created by `zwarm init`)
+3. `config.toml` in working directory (legacy, for backwards compat)
+4. Default settings
 
-### Minimal config.toml
+### Minimal .zwarm/config.toml
 
 ```toml
 [weave]
@@ -430,10 +431,11 @@ zwarm clean --events
 
 ### State Management
 
-All state is stored in flat files under `.zwarm/`:
+All state and config is stored in flat files under `.zwarm/`:
 
 ```
 .zwarm/
+├── config.toml             # Runtime settings (weave, adapter, watchers)
 ├── state.json              # Current state
 ├── events.jsonl            # Append-only event log
 ├── sessions/

{zwarm-1.1.1.dist-info → zwarm-1.3.2.dist-info}/RECORD

@@ -1,33 +1,35 @@
 zwarm/__init__.py,sha256=3i3LMjHwIzE-LFIS2aUrwv3EZmpkvVMe-xj1h97rcSM,837
-zwarm/orchestrator.py,sha256=O3HGjMenQE-HF5xo0WQNMAHRS_vLsUrFfVp6oI_WpKU,19732
+zwarm/orchestrator.py,sha256=wCvK4RVBDC6T_vrJSJBhPfaDpTorwLAXpOUYHDjowrs,21112
 zwarm/test_orchestrator_watchers.py,sha256=QpoaehPU7ekT4XshbTOWnJ2H0wRveV3QOZjxbgyJJLY,807
-zwarm/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zwarm/adapters/__init__.py,sha256=O0b-SfZpb6txeNqFkXZ2aaf34yLFYreznyrAV25jF_Q,656
 zwarm/adapters/base.py,sha256=fZlQviTgVvOcwnxduTla6WuM6FzQJ_yoHMW5SxwVgQg,2527
-zwarm/adapters/claude_code.py,sha256=Z6f_jydiIUuZiR8fNipvvlcv16rP4BK6jNtkUaH3M4c,11368
-zwarm/adapters/codex_mcp.py,sha256=Wp4PExZlhqfLV5CHxBqmIBOm-pH7k8cJy93fyxRbCgw,27495
-zwarm/adapters/test_codex_mcp.py,sha256=vodQF5VUrM_F1GygUADtXYrA0kvAc7dWpT_Ff-Uoo0A,8383
+zwarm/adapters/claude_code.py,sha256=vAjsjD-_JjARmC4_FBSILQZmQCBrk_oNHo18a9ubuqk,11481
+zwarm/adapters/codex_mcp.py,sha256=olgR8mfgjn0cbrD8Gc11DX4yVzWXqE64fQHsMAq_xAQ,32771
+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/main.py,sha256=dU_8XLIYzcxikl_MgT6BmChNbqYq94dJ4Ra5STzm_KI,33109
+zwarm/cli/main.py,sha256=9kHUw897580fQtBii1BqoJrUBYMaKmYjC6CM4AuOsdQ,59013
 zwarm/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zwarm/core/compact.py,sha256=Y8C7Gs-5-WOU43WRvQ863Qzd5xtuEqR6Aw3r2p8_-i8,10907
-zwarm/core/config.py,sha256=H8XFsWeEehZnUsMf7nsM_YqjljFYaC43DLs8Xw4sOuQ,10360
+zwarm/core/config.py,sha256=J-TAwIQFLY4x_G9qdvP_16DAYndqg_zhakCW5TLEMN4,11059
 zwarm/core/environment.py,sha256=HVDpDZEpDSfyh9-wHZMzMKVUPKvioBkPVWeiME2JmFo,5435
 zwarm/core/models.py,sha256=PrC3okRBVJxISUa1Fax4KkagqLT6Xub-kTxC9drN0sY,10083
-zwarm/core/state.py,sha256=wMryIvXP-VDLh2b76A5taeL_9dm5k4jk4HnvHWgLqGE,7658
+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_models.py,sha256=sWTIhMZvuLP5AooGR6y8OR2EyWydqVfhmGrE7NPBBnk,8450
 zwarm/prompts/__init__.py,sha256=FiaIOniLrIyfD3_osxT6I7FfyKjtctbf8jNs5QTPs_s,213
 zwarm/prompts/orchestrator.py,sha256=R-ym3nlspYNspf085Qwwfi96Yh3K6-Csb6vfBg29K2c,14228
 zwarm/tools/__init__.py,sha256=FpqxwXJA6-fQ7C-oLj30jjK_0qqcE7MbI0dQuaB56kU,290
-zwarm/tools/delegation.py,sha256=wf43jxmGvEy_c8jVx301YQvslIS2F80Qnq4Py2feVvg,11435
+zwarm/tools/delegation.py,sha256=PeB0W7x2TcGCZ9rGBYDlIIFr7AT1TOdc1SLe7BKCUoM,15332
 zwarm/watchers/__init__.py,sha256=yYGTbhuImQLESUdtfrYbHYBJNvCNX3B-Ei-vY5BizX8,760
 zwarm/watchers/base.py,sha256=r1GoPlj06nOT2xp4fghfSjxbRyFFFQUB6HpZbEyO2OY,3834
 zwarm/watchers/builtin.py,sha256=52hyRREYYDsSuG-YKElXViSTyMmGySZaFreHc0pz-A4,12482
 zwarm/watchers/manager.py,sha256=XZjBVeHjgCUlkTUeHqdvBvHoBC862U1ik0fG6nlRGog,5587
 zwarm/watchers/registry.py,sha256=A9iBIVIFNtO7KPX0kLpUaP8dAK7ozqWLA44ocJGnOw4,1219
 zwarm/watchers/test_watchers.py,sha256=zOsxumBqKfR5ZVGxrNlxz6KcWjkcdp0QhW9WB0_20zM,7855
-zwarm-1.1.1.dist-info/METADATA,sha256=9GoAYbxRjMSdbHIwrZPS_zdrrDSz7-Avnwy_8AqNEBM,14995
-zwarm-1.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-zwarm-1.1.1.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
-zwarm-1.1.1.dist-info/RECORD,,
+zwarm-1.3.2.dist-info/METADATA,sha256=Xf0dFQrOuhMhlbVQsRWw1uh65uCIVWMB-Hv99-rZ7Xc,15174
+zwarm-1.3.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+zwarm-1.3.2.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
+zwarm-1.3.2.dist-info/RECORD,,