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

zwarm/adapters/codex_mcp.py

@@ -44,6 +44,7 @@ class MCPClient:
 
     def __init__(self):
         self._proc: subprocess.Popen | None = None
+        self._proc_pid: int | None = None  # Track PID to detect restarts
         self._request_id = 0
         self._initialized = False
         self._stderr_thread: threading.Thread | None = None
@@ -51,14 +52,24 @@ class MCPClient:
         self._stderr_lines: list[str] = []
         self._stdout_queue: queue.Queue[str | None] = queue.Queue()
         self._lock = threading.Lock()  # Protect writes only
+        self._start_count = 0  # Track how many times we've started
 
     def start(self) -> None:
         """Start the MCP server process."""
         with self._lock:
             if self._proc is not None and self._proc.poll() is None:
+                logger.debug(f"MCP server already running (pid={self._proc.pid}, start_count={self._start_count})")
                 return  # Already running
 
-            logger.info("Starting codex mcp-server...")
+            # Check if this is a restart (previous server died)
+            if self._proc_pid is not None:
+                logger.warning(
+                    f"MCP server restart detected! Previous pid={self._proc_pid}, "
+                    f"start_count={self._start_count}. All conversation state will be lost."
+                )
+
+            self._start_count += 1
+            logger.info(f"Starting codex mcp-server... (start_count={self._start_count})")
             self._proc = subprocess.Popen(
                 ["codex", "mcp-server"],
                 stdin=subprocess.PIPE,
@@ -66,6 +77,7 @@ class MCPClient:
                 stderr=subprocess.PIPE,
                 text=False,  # Binary mode for explicit encoding control
             )
+            self._proc_pid = self._proc.pid
             self._initialized = False
             self._stderr_lines = []
             self._stdout_queue = queue.Queue()  # Fresh queue
@@ -251,11 +263,13 @@ class MCPClient:
         # Collect streaming events until final result
         # Reader thread queues lines, we pull from queue with timeout
         session_id = None
+        conversation_id = None  # Track conversation ID separately
         agent_messages: list[str] = []
         streaming_text: list[str] = []  # Accumulate streaming delta text
         final_result = None
         token_usage: dict[str, Any] = {}  # Track token usage
         start_time = time.time()
+        all_events: list[dict] = []  # Keep ALL events for debugging
 
         for event_count in range(1000):  # Safety limit on events
             self._check_alive()
@@ -278,6 +292,7 @@ class MCPClient:
 
             try:
                 event = json.loads(line)
+                all_events.append(event)  # Keep for debugging
             except json.JSONDecodeError as e:
                 logger.warning(f"Invalid JSON from MCP: {line[:100]}... - {e}")
                 continue
@@ -286,7 +301,10 @@ class MCPClient:
             if event.get("id") == request_id:
                 if "result" in event:
                     final_result = event["result"]
-                    logger.debug(f"Got final result after {event_count} events")
+                    # Extract conversation ID from final result
+                    if isinstance(final_result, dict):
+                        conversation_id = final_result.get("conversationId") or final_result.get("conversation_id")
+                    logger.debug(f"Got final result after {event_count} events, conversation_id={conversation_id}")
                     break
                 elif "error" in event:
                     error = event["error"]
@@ -309,6 +327,9 @@ class MCPClient:
                     item = msg.get("item", {})
                     item_type = item.get("type")
 
+                    # Log ALL item_completed events to help debug
+                    logger.debug(f"item_completed: type={item_type}, keys={list(item.keys())}")
+
                     # Agent text responses - codex uses "AgentMessage" type
                     if item_type == "AgentMessage":
                         content = item.get("content", [])
@@ -318,6 +339,19 @@ class MCPClient:
                             elif isinstance(block, str):
                                 agent_messages.append(block)
 
+                    # Also check for "agent_message" (lowercase) variant
+                    elif item_type == "agent_message":
+                        text = item.get("text", "") or item.get("message", "")
+                        if text:
+                            agent_messages.append(text)
+                        # Also check content array
+                        content = item.get("content", [])
+                        for block in content:
+                            if isinstance(block, dict) and block.get("text"):
+                                agent_messages.append(block["text"])
+                            elif isinstance(block, str):
+                                agent_messages.append(block)
+
                     # Legacy format check
                     elif item_type == "message" and item.get("role") == "assistant":
                         content = item.get("content", [])
@@ -327,6 +361,21 @@ class MCPClient:
                             elif isinstance(block, str):
                                 agent_messages.append(block)
 
+                    # Generic message type - check for text/content
+                    elif item_type == "message":
+                        text = item.get("text", "")
+                        if text:
+                            agent_messages.append(text)
+                        content = item.get("content", [])
+                        if isinstance(content, str):
+                            agent_messages.append(content)
+                        elif isinstance(content, list):
+                            for block in content:
+                                if isinstance(block, dict) and block.get("text"):
+                                    agent_messages.append(block["text"])
+                                elif isinstance(block, str):
+                                    agent_messages.append(block)
+
                     # Function call outputs (for context)
                     elif item_type == "function_call_output":
                         output = item.get("output", "")
@@ -334,8 +383,8 @@ class MCPClient:
                             agent_messages.append(f"[Tool output]: {output[:500]}")
 
                     # Log other item types we're not handling
-                    elif item_type not in ("function_call", "tool_call", "UserMessage"):
-                        logger.debug(f"Unhandled item_completed type: {item_type}, keys: {list(item.keys())}")
+                    elif item_type not in ("function_call", "tool_call", "UserMessage", "user_message"):
+                        logger.debug(f"Unhandled item_completed type: {item_type}, item={item}")
 
                 elif msg_type == "agent_message":
                     # Direct agent message event
@@ -406,28 +455,50 @@ class MCPClient:
                 agent_messages.append(full_streaming)
                 logger.debug(f"Captured {len(streaming_text)} streaming chunks ({len(full_streaming)} chars)")
 
-        # Build result
-        result = {
-            "conversationId": session_id,
-            "messages": agent_messages,
-            "output": "\n".join(agent_messages) if agent_messages else "",
-            "usage": token_usage,  # Token usage for cost tracking
-        }
-
-        # Merge final result and try to extract content if no messages
-        if final_result:
-            result.update(final_result)
-            if not agent_messages and "content" in final_result:
+        # Try to extract content from final_result if we have no messages
+        if final_result and not agent_messages:
+            if "content" in final_result:
                 content = final_result["content"]
                 if isinstance(content, list):
                     for block in content:
                         if isinstance(block, dict) and block.get("text"):
                             agent_messages.append(block["text"])
-                    if agent_messages:
-                        result["messages"] = agent_messages
-                        result["output"] = "\n".join(agent_messages)
+                        elif isinstance(block, str):
+                            agent_messages.append(block)
+                elif isinstance(content, str):
+                    agent_messages.append(content)
+            # Also check for text field
+            if not agent_messages and "text" in final_result:
+                agent_messages.append(final_result["text"])
+
+        # Build result - prefer conversation_id from final result, fallback to session_id from events
+        effective_conversation_id = conversation_id or session_id
+        result = {
+            "conversationId": effective_conversation_id,
+            "messages": agent_messages,
+            "output": "\n".join(agent_messages) if agent_messages else "",
+            "usage": token_usage,  # Token usage for cost tracking
+        }
 
-        logger.debug(f"MCP call complete: {len(agent_messages)} messages, session={session_id}")
+        # Log detailed debug info if we didn't capture any messages
+        if not agent_messages:
+            event_types = [e.get("method") or f"id:{e.get('id')}" for e in all_events[:20]]
+            logger.warning(
+                f"MCP call returned no messages. "
+                f"conversation_id={effective_conversation_id}, "
+                f"session_id={session_id}, "
+                f"event_count={len(all_events)}, "
+                f"event_types={event_types}, "
+                f"final_result_keys={list(final_result.keys()) if final_result else 'None'}"
+            )
+            # Log codex/event details for debugging
+            codex_events = [e for e in all_events if e.get("method") == "codex/event"]
+            if codex_events:
+                for ce in codex_events[-5:]:  # Last 5 codex events
+                    msg = ce.get("params", {}).get("msg", {})
+                    logger.debug(f"  codex/event: type={msg.get('type')}, keys={list(msg.keys())}")
+
+        logger.debug(f"MCP call complete: {len(agent_messages)} messages, conversation_id={effective_conversation_id}")
         return result
 
     def close(self) -> None:
@@ -521,14 +592,35 @@ class CodexMCPAdapter(ExecutorAdapter):
         if model:
             args["model"] = model
 
+        logger.info(f"Calling codex with task_len={len(task)}, cwd={cwd}, model={model or 'default'}")
+
         result = client.call_tool("codex", args)
 
-        # Track usage
+        # Log the result structure
+        conversation_id = result.get("conversationId")
+        messages_count = len(result.get("messages", []))
+        output_len = len(result.get("output", ""))
         usage = result.get("usage", {})
+
+        logger.info(
+            f"codex result: conversation_id={conversation_id}, "
+            f"messages_count={messages_count}, output_len={output_len}, "
+            f"usage={usage.get('total_tokens', 0)} tokens"
+        )
+
+        # Warn if we got a conversation ID but no messages (agent did work but we lost output)
+        if conversation_id and not messages_count and not output_len:
+            logger.warning(
+                f"codex returned conversation_id={conversation_id} but NO messages/output! "
+                f"The agent processed {usage.get('total_tokens', 0)} tokens but we didn't capture the response. "
+                f"This may indicate an issue with event parsing."
+            )
+
+        # Track usage
         self._accumulate_usage(usage)
 
         return {
-            "conversation_id": result.get("conversationId"),
+            "conversation_id": conversation_id,
             "response": self._extract_response(result),
             "raw_messages": result.get("messages", []),
             "usage": usage,
@@ -549,13 +641,22 @@ class CodexMCPAdapter(ExecutorAdapter):
         """
         client = self._ensure_client()
 
-        logger.debug(f"Calling codex-reply with conversation_id={conversation_id}")
+        logger.info(f"Calling codex-reply with conversation_id={conversation_id}, message_len={len(message)}")
+        logger.debug(f"MCP client alive: {client.is_alive}, initialized: {client._initialized}")
 
         result = client.call_tool("codex-reply", {
             "conversationId": conversation_id,
             "prompt": message,
         })
 
+        # Log the full result structure for debugging
+        logger.info(
+            f"codex-reply result: conversationId={result.get('conversationId')}, "
+            f"messages_count={len(result.get('messages', []))}, "
+            f"output_len={len(result.get('output', ''))}, "
+            f"usage={result.get('usage', {}).get('total_tokens', 0)} tokens"
+        )
+
         # Check for conversation loss - MCP returns empty result when session not found
         if not result.get("messages") and not result.get("output"):
             logger.error(

zwarm/cli/main.py

@@ -672,7 +672,7 @@ def init(
     # Gather settings
     weave_project = ""
     adapter = "codex_mcp"
-    watchers_enabled = ["progress", "budget", "delegation"]
+    watchers_enabled = ["progress", "budget", "delegation", "delegation_reminder"]
     create_project_config = with_project
     project_description = ""
     project_context = ""
@@ -696,10 +696,10 @@ def init(
 
         # Watchers
         console.print("\n  [bold]Watchers[/] (trajectory aligners)")
-        available_watchers = ["progress", "budget", "delegation", "scope", "pattern", "quality"]
+        available_watchers = ["progress", "budget", "delegation", "delegation_reminder", "scope", "pattern", "quality"]
         watchers_enabled = []
         for w in available_watchers:
-            default = w in ["progress", "budget", "delegation"]
+            default = w in ["progress", "budget", "delegation", "delegation_reminder"]
             if typer.confirm(f"    Enable {w}?", default=default):
                 watchers_enabled.append(w)
 

zwarm/core/config.py

@@ -86,7 +86,13 @@ class WatchersConfig:
     watchers: list[WatcherConfigItem] = field(default_factory=lambda: [
         WatcherConfigItem(name="progress"),
         WatcherConfigItem(name="budget"),
+        WatcherConfigItem(name="delegation_reminder"),
     ])
+    # Role for watcher nudge messages: "user" | "assistant" | "system"
+    # "user" (default) - Appears as if user sent the message, strong nudge
+    # "assistant" - Appears as previous assistant thought, softer nudge
+    # "system" - Appears as system instruction, authoritative
+    message_role: str = "user"
 
 
 @dataclass
@@ -122,13 +128,14 @@ class ZwarmConfig:
                 ],
             )
         else:
-            # Full format: watchers: {enabled: true, watchers: [...]}
+            # Full format: watchers: {enabled: true, watchers: [...], message_role: "user"}
             watchers_config = WatchersConfig(
                 enabled=watchers_data.get("enabled", True),
                 watchers=[
                     WatcherConfigItem(name=w) if isinstance(w, str) else WatcherConfigItem(**w)
                     for w in watchers_data.get("watchers", [])
                 ] or WatchersConfig().watchers,
+                message_role=watchers_data.get("message_role", "user"),
             )
 
         # Build orchestrator config with nested compaction
@@ -180,6 +187,7 @@ class ZwarmConfig:
                     {"name": w.name, "enabled": w.enabled, "config": w.config}
                     for w in self.watchers.watchers
                 ],
+                "message_role": self.watchers.message_role,
             },
             "state_dir": self.state_dir,
         }

zwarm/orchestrator.py

@@ -352,10 +352,15 @@ Review what was accomplished in the previous session and delegate new tasks as n
 
         # Handle watcher result
         if result.action == WatcherAction.NUDGE and result.guidance:
-            # Inject guidance as a system message
+            # Inject guidance as a message with configurable role
+            message_role = self.config.watchers.message_role
+            # Validate role (default to user if invalid)
+            if message_role not in ("user", "assistant", "system"):
+                message_role = "user"
+
             self.messages.append(
                 {
-                    "role": "user",
+                    "role": message_role,
                     "content": f"[WATCHER: {result.metadata.get('triggered_by', 'unknown')}] {result.guidance}",
                 }
             )

zwarm/prompts/orchestrator.py

@@ -43,6 +43,24 @@ Your primary tools are for delegation and verification:
 
 ---
 
+# Watchers
+
+Your execution is monitored by "watchers" - automated systems that observe your trajectory and provide guidance when you may be going off course. Watchers are designed to help you stay aligned with best practices and catch common pitfalls.
+
+When you see a message prefixed with `[WATCHER: ...]`, pay attention. These are interventions from the watcher system indicating that your current approach may need adjustment. Watchers might notice:
+
+- You're doing direct work (bash commands) when you should be delegating to executors
+- You're spinning or repeating the same actions without making progress
+- You're approaching resource limits (steps, sessions)
+- You're drifting from the original task scope
+- You're making changes without corresponding tests
+
+Watcher guidance is not optional advice - treat it as an important course correction. If a watcher tells you to delegate instead of doing work directly, delegate. If a watcher says you're stuck, step back and try a different approach. If a watcher warns about budget limits, prioritize and wrap up.
+
+The watchers are on your side. They exist to help you succeed, not to criticize. Heed their guidance promptly.
+
+---
+
 # Sync vs Async: Choosing the Right Mode
 
 The mode you choose for delegation significantly affects how work proceeds.

zwarm/watchers/builtin.py

@@ -340,3 +340,85 @@ class QualityWatcher(Watcher):
                 )
 
         return WatcherResult.ok()
+
+
+@register_watcher("delegation_reminder")
+class DelegationReminderWatcher(Watcher):
+    """
+    Reminds the orchestrator to delegate work instead of doing it directly.
+
+    Counts consecutive non-delegation tool calls (bash commands that aren't
+    delegation-related). When the count exceeds a threshold, nudges the
+    orchestrator to consider delegating to executors instead.
+
+    This is a softer reminder than the DelegationWatcher - it doesn't detect
+    specific code-writing patterns, just notices when the orchestrator seems
+    to be doing a lot of direct work that could potentially be delegated.
+    """
+
+    name = "delegation_reminder"
+    description = "Reminds orchestrator to delegate after many direct tool calls"
+
+    # Tools that count as delegation-related (don't count against threshold)
+    DELEGATION_TOOLS = {
+        "delegate",
+        "converse",
+        "check_session",
+        "end_session",
+        "list_sessions",
+        "chat",  # Talking to user is not direct work
+    }
+
+    async def observe(self, ctx: WatcherContext) -> WatcherResult:
+        config = self.config
+        threshold = config.get("threshold", 10)  # Max consecutive non-delegation calls
+        lookback = config.get("lookback", 30)  # How many messages to check
+
+        # Count consecutive non-delegation tool calls from the end
+        consecutive_non_delegation = 0
+
+        # Look through recent messages in reverse order
+        for msg in reversed(ctx.messages[-lookback:]):
+            if msg.get("role") != "assistant":
+                continue
+
+            tool_calls = msg.get("tool_calls", [])
+            if not tool_calls:
+                # Text-only response doesn't reset counter, but doesn't add to it
+                continue
+
+            # Check each tool call in this message
+            has_delegation = False
+            has_non_delegation = False
+
+            for tc in tool_calls:
+                func = tc.get("function", {})
+                name = func.get("name", "")
+
+                if name in self.DELEGATION_TOOLS:
+                    has_delegation = True
+                elif name:  # Any other tool call
+                    has_non_delegation = True
+
+            if has_delegation:
+                # Found a delegation tool - stop counting
+                break
+            elif has_non_delegation:
+                # Add to consecutive count (one per message, not per tool call)
+                consecutive_non_delegation += 1
+
+        # Check if threshold exceeded
+        if consecutive_non_delegation >= threshold:
+            return WatcherResult.nudge(
+                guidance=(
+                    f"You've made {consecutive_non_delegation} consecutive direct tool calls "
+                    "without delegating to an executor. Remember: as the orchestrator, your role "
+                    "is to delegate coding work to executors, not do it yourself via bash. "
+                    "Consider whether the work you're doing could be delegated to an executor "
+                    "using delegate(). Executors can write code, run tests, and handle complex "
+                    "file operations more effectively than direct bash commands."
+                ),
+                reason=f"Consecutive non-delegation calls: {consecutive_non_delegation}",
+            )
+
+        return WatcherResult.ok()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwarm
-Version: 1.3.2
+Version: 1.3.5
 Summary: Multi-Agent CLI Orchestration Research Platform
 Requires-Python: <3.14,>=3.13
 Requires-Dist: python-dotenv>=1.0.0
@@ -136,12 +136,17 @@ state_dir: .zwarm             # State directory for sessions/events
 
 watchers:
   enabled: true
+  message_role: user            # Role for nudge messages: user | assistant | system
   watchers:
     - name: progress
     - name: budget
       config:
         max_steps: 50
         max_sessions: 10
+    - name: delegation_reminder
+      config:
+        threshold: 10           # Nudge after N consecutive non-delegation calls
+        lookback: 30            # How many messages to check
     - name: scope
       config:
         keywords: []
@@ -217,28 +222,38 @@ Watchers are composable guardrails that monitor agent behavior and can intervene
 | `pattern` | Custom regex pattern matching |
 | `quality` | Code quality checks |
 | `delegation` | Ensures orchestrator delegates instead of writing code directly |
+| `delegation_reminder` | Nudges after many consecutive non-delegation tool calls (default: 10) |
 
 ### Enabling Watchers
 
 ```yaml
 # config.yaml
 watchers:
-  enabled:
-    - progress
-    - budget
-    - scope
-  config:
-    progress:
-      stuck_threshold: 5      # Flag after 5 similar steps
-    budget:
-      max_steps: 50
-      max_sessions: 10
-    scope:
-      keywords:
-        - "refactor"
-        - "rewrite"
+  enabled: true
+  message_role: user              # How nudges appear: user | assistant | system
+  watchers:
+    - name: progress
+      config:
+        max_same_calls: 3         # Flag after 3 identical tool calls
+    - name: budget
+      config:
+        max_steps: 50
+        max_sessions: 10
+    - name: delegation_reminder
+      config:
+        threshold: 10             # Nudge after 10 non-delegation calls
+    - name: scope
+      config:
+        avoid_keywords:
+          - "refactor everything"
+          - "rewrite"
 ```
 
+The `message_role` setting controls how watcher nudges are injected:
+- `user` (default): Appears as a user message - strong nudge, agent must respond
+- `assistant`: Appears as a previous assistant thought - softer, agent can continue
+- `system`: Appears as system instruction - authoritative guidance
+
 ### Watcher Actions
 
 Watchers can return different actions:

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

@@ -1,18 +1,18 @@
 zwarm/__init__.py,sha256=3i3LMjHwIzE-LFIS2aUrwv3EZmpkvVMe-xj1h97rcSM,837
-zwarm/orchestrator.py,sha256=wCvK4RVBDC6T_vrJSJBhPfaDpTorwLAXpOUYHDjowrs,21112
+zwarm/orchestrator.py,sha256=38PKWwT79U0VY9aqZe5atf9C5EAFGgMXE7PXPX5QJ0w,21359
 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=olgR8mfgjn0cbrD8Gc11DX4yVzWXqE64fQHsMAq_xAQ,32771
+zwarm/adapters/codex_mcp.py,sha256=qX6blFC_rZwl3JaS9TLIG1yxIvWhgX42Goq2DdcJjbU,38474
 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=9kHUw897580fQtBii1BqoJrUBYMaKmYjC6CM4AuOsdQ,59013
+zwarm/cli/main.py,sha256=GstswIKfmwD1thNBfP0vOzKHaOq3PjRuu3PYe5rLVnc,59082
 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/config.py,sha256=7mzxrWvHmTjwiUWAoE4NYS_1yWj85-vWkpT6X6kiMIg,11579
 zwarm/core/environment.py,sha256=HVDpDZEpDSfyh9-wHZMzMKVUPKvioBkPVWeiME2JmFo,5435
 zwarm/core/models.py,sha256=PrC3okRBVJxISUa1Fax4KkagqLT6Xub-kTxC9drN0sY,10083
 zwarm/core/state.py,sha256=MzrvODKEiJovI7YI1jajW4uukineZ3ezmW5oQinMgjg,11563
@@ -20,16 +20,16 @@ zwarm/core/test_compact.py,sha256=WSdjCB5t4YMcknsrkmJIUsVOPY28s4y9GnDmu3Z4BFw,11
 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/prompts/orchestrator.py,sha256=af5547L2g6HwGz-PxlKCAXJzqXEdjcwSAIdVH7_4LSk,15412
 zwarm/tools/__init__.py,sha256=FpqxwXJA6-fQ7C-oLj30jjK_0qqcE7MbI0dQuaB56kU,290
 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/builtin.py,sha256=k1pCnQBEmLHeuCo8t6UXoenJUpfWY7AuGt_aEk8syew,15828
 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.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,,
+zwarm-1.3.5.dist-info/METADATA,sha256=9boM7ysJGr-hfN_0YrNZfWD_Lwi8B9iF-BJWorrmNXs,16114
+zwarm-1.3.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+zwarm-1.3.5.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
+zwarm-1.3.5.dist-info/RECORD,,