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

zwarm/adapters/codex_mcp.py

@@ -549,20 +549,33 @@ class CodexMCPAdapter(ExecutorAdapter):
         """
         client = self._ensure_client()
 
+        logger.debug(f"Calling codex-reply with conversation_id={conversation_id}")
+
         result = client.call_tool("codex-reply", {
             "conversationId": conversation_id,
             "prompt": message,
         })
 
+        # Check for conversation loss - MCP returns empty result when session not found
+        if not result.get("messages") and not result.get("output"):
+            logger.error(
+                f"codex-reply returned empty result for conversation_id={conversation_id}. "
+                f"The MCP server may have lost the conversation state. Result: {result}"
+            )
+
         # Track usage
         usage = result.get("usage", {})
         self._accumulate_usage(usage)
 
+        response = self._extract_response(result)
+        logger.debug(f"codex-reply response length: {len(response)} chars")
+
         return {
-            "response": self._extract_response(result),
+            "response": response,
             "raw_messages": result.get("messages", []),
             "usage": usage,
             "total_usage": self.total_usage,
+            "conversation_lost": not result.get("messages") and not result.get("output"),
         }
 
     @weave.op()
@@ -598,6 +611,13 @@ class CodexMCPAdapter(ExecutorAdapter):
             session.conversation_id = result["conversation_id"]
             if session.conversation_id:
                 self._sessions[session.id] = session.conversation_id
+                logger.debug(f"Session {session.id[:8]} mapped to conversation {session.conversation_id}")
+            else:
+                # This is bad - we won't be able to continue this conversation
+                logger.warning(
+                    f"Session {session.id[:8]} started but MCP didn't return a conversation ID. "
+                    "Further converse() calls will fail."
+                )
 
             session.add_message("user", task)
             session.add_message("assistant", result["response"])
@@ -652,6 +672,16 @@ class CodexMCPAdapter(ExecutorAdapter):
         )
 
         response_text = result["response"]
+
+        # Check if conversation was lost
+        if result.get("conversation_lost"):
+            logger.warning(
+                f"Conversation {session.conversation_id} was lost. "
+                f"Session {session.id} will be marked as needing re-delegation."
+            )
+            # Mark the session as having a lost conversation so orchestrator can handle it
+            session.conversation_id = None  # Clear the stale ID
+
         session.add_message("user", message)
         session.add_message("assistant", response_text)
 
@@ -797,6 +827,15 @@ class CodexMCPAdapter(ExecutorAdapter):
 
     def _extract_response(self, result: dict) -> str:
         """Extract response text from MCP result."""
+        # Check for error indicators - empty result suggests lost conversation
+        if (
+            result.get("conversationId") is None
+            and not result.get("messages")
+            and not result.get("output")
+        ):
+            logger.warning(f"MCP returned empty result - conversation may be lost: {result}")
+            return "[ERROR] Conversation lost - the MCP server no longer has this session. Please re-delegate the task."
+
         # First check for our collected output
         if result.get("output"):
             return result["output"]
@@ -823,5 +862,6 @@ class CodexMCPAdapter(ExecutorAdapter):
         if "text" in result:
             return result["text"]
 
-        # Fallback: stringify the result
+        # Fallback: stringify the result (but log it as unexpected)
+        logger.warning(f"Unexpected MCP result format, returning raw: {list(result.keys())}")
         return json.dumps(result, indent=2)

zwarm/cli/main.py

@@ -141,6 +141,8 @@ def orchestrate(
     resume: Annotated[bool, typer.Option("--resume", help="Resume from previous state")] = False,
     max_steps: Annotated[Optional[int], typer.Option("--max-steps", help="Maximum orchestrator steps")] = None,
     verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Show detailed output")] = False,
+    instance: Annotated[Optional[str], typer.Option("--instance", "-i", help="Instance ID (for isolation/resume)")] = None,
+    instance_name: Annotated[Optional[str], typer.Option("--name", "-n", help="Human-readable instance name")] = None,
 ):
     """
     Start an orchestrator session.
@@ -149,6 +151,9 @@ def orchestrate(
     (Codex, Claude Code). It can have sync conversations or fire-and-forget
     async delegations.
 
+    Each run creates an isolated instance to prevent conflicts when running
+    multiple orchestrators in the same directory.
+
     [bold]Examples:[/]
         [dim]# Simple task[/]
         $ zwarm orchestrate --task "Add a logout button to the navbar"
@@ -166,8 +171,14 @@ def orchestrate(
         [dim]# Override settings[/]
         $ zwarm orchestrate --task "Fix bug" --set executor.adapter=claude_code
 
-        [dim]# Resume interrupted session[/]
-        $ zwarm orchestrate --task "Continue work" --resume
+        [dim]# Named instance (easier to track)[/]
+        $ zwarm orchestrate --task "Add tests" --name test-work
+
+        [dim]# Resume a specific instance[/]
+        $ zwarm orchestrate --resume --instance abc123
+
+        [dim]# List all instances[/]
+        $ zwarm instances
     """
     from zwarm.orchestrator import build_orchestrator
 
@@ -187,6 +198,8 @@ def orchestrate(
     console.print(f"[bold]Starting orchestrator...[/]")
     console.print(f"  Task: {task}")
     console.print(f"  Working dir: {working_dir.absolute()}")
+    if instance:
+        console.print(f"  Instance: {instance}" + (f" ({instance_name})" if instance_name else ""))
     console.print()
 
     # Output handler to show orchestrator messages
@@ -203,11 +216,17 @@ def orchestrate(
             overrides=override_list,
             resume=resume,
             output_handler=output_handler,
+            instance_id=instance,
+            instance_name=instance_name,
         )
 
         if resume:
             console.print("  [dim]Resuming from previous state...[/]")
 
+        # Show instance ID if auto-generated
+        if orchestrator.instance_id and not instance:
+            console.print(f"  [dim]Instance: {orchestrator.instance_id[:8]}[/]")
+
         # Run the orchestrator loop
         console.print("[bold]--- Orchestrator running ---[/]\n")
         result = orchestrator.run(task=task)
@@ -223,16 +242,35 @@ def orchestrate(
         # Save state for potential resume
         orchestrator.save_state()
 
+        # Update instance status
+        if orchestrator.instance_id:
+            from zwarm.core.state import update_instance_status
+            update_instance_status(
+                orchestrator.instance_id,
+                "completed",
+                working_dir / ".zwarm",
+            )
+            console.print(f"  [dim]Instance {orchestrator.instance_id[:8]} marked completed[/]")
+
     except KeyboardInterrupt:
         console.print("\n\n[yellow]Interrupted.[/]")
         if orchestrator:
             orchestrator.save_state()
             console.print("[dim]State saved. Use --resume to continue.[/]")
+            # Keep instance as "active" so it can be resumed
         sys.exit(1)
     except Exception as e:
         console.print(f"\n[red]Error:[/] {e}")
         if verbose:
             console.print_exception()
+        # Update instance status to failed
+        if orchestrator and orchestrator.instance_id:
+            from zwarm.core.state import update_instance_status
+            update_instance_status(
+                orchestrator.instance_id,
+                "failed",
+                working_dir / ".zwarm",
+            )
         sys.exit(1)
 
 
@@ -384,6 +422,63 @@ def status(
         console.print("  [dim](none)[/]")
 
 
+@app.command()
+def instances(
+    working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
+    all_instances: Annotated[bool, typer.Option("--all", "-a", help="Show all instances (including completed)")] = False,
+):
+    """
+    List all orchestrator instances.
+
+    Shows instances that have been run in this directory. Use --all to include
+    completed instances.
+
+    [bold]Examples:[/]
+        [dim]# List active instances[/]
+        $ zwarm instances
+
+        [dim]# List all instances[/]
+        $ zwarm instances --all
+    """
+    from zwarm.core.state import list_instances as get_instances
+
+    state_dir = working_dir / ".zwarm"
+    all_inst = get_instances(state_dir)
+
+    if not all_inst:
+        console.print("[dim]No instances found.[/]")
+        console.print("[dim]Run 'zwarm orchestrate' to start a new instance.[/]")
+        return
+
+    # Filter if not showing all
+    if not all_instances:
+        all_inst = [i for i in all_inst if i.get("status") == "active"]
+
+    if not all_inst:
+        console.print("[dim]No active instances. Use --all to see completed ones.[/]")
+        return
+
+    console.print(f"[bold]Instances[/] ({len(all_inst)} total)\n")
+
+    for inst in all_inst:
+        status = inst.get("status", "unknown")
+        status_icon = {"active": "[green]●[/]", "completed": "[dim]✓[/]", "failed": "[red]✗[/]"}.get(status, "[dim]?[/]")
+
+        inst_id = inst.get("id", "unknown")[:8]
+        name = inst.get("name", "")
+        task = (inst.get("task") or "")[:60]
+        updated = inst.get("updated_at", "")[:19] if inst.get("updated_at") else ""
+
+        console.print(f"  {status_icon} [bold]{inst_id}[/]" + (f" ({name})" if name and name != inst_id else ""))
+        if task:
+            console.print(f"      [dim]{task}[/]")
+        if updated:
+            console.print(f"      [dim]Updated: {updated}[/]")
+        console.print()
+
+    console.print("[dim]Use --instance <id> with 'orchestrate --resume' to resume an instance.[/]")
+
+
 @app.command()
 def history(
     working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),

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

@@ -52,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=[
@@ -77,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
@@ -215,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)"
 
@@ -228,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)
@@ -521,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.
@@ -532,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,
@@ -545,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)
 
@@ -565,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

@@ -194,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,
@@ -204,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,
@@ -263,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:
@@ -288,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,
@@ -298,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.2.1.dist-info → zwarm-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwarm
-Version: 1.2.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

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

@@ -1,35 +1,35 @@
 zwarm/__init__.py,sha256=3i3LMjHwIzE-LFIS2aUrwv3EZmpkvVMe-xj1h97rcSM,837
-zwarm/orchestrator.py,sha256=3Ix07GCnt7GHoBg2TwFmDaH9TAk6dT5BhuCaLiQQFCw,19430
+zwarm/orchestrator.py,sha256=wCvK4RVBDC6T_vrJSJBhPfaDpTorwLAXpOUYHDjowrs,21112
 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=f6ScDWWryA6AVWxBNMuvw3FO0a3WAJbeTq4Ij0AR50k,30694
+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=TE4qIWu11sEKqt2Npy3bNmB0F7IgsSylpupkrP_OoRI,55291
+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=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=eoImpOcTpPcI8wZTP57PinQ5FzvnYM-qWBEc_xyuUU4,14006
+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.2.1.dist-info/METADATA,sha256=G8rZQVHQOPXt7_bOUdL9wEtp6xyXqpzYoCQLx82ay24,15174
-zwarm-1.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-zwarm-1.2.1.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
-zwarm-1.2.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,,