zwarm 2.3__py3-none-any.whl → 3.0__py3-none-any.whl

zwarm/tools/delegation.py

@@ -33,8 +33,12 @@ def _get_session_manager(orchestrator: "Orchestrator"):
 
     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.
     """
-    if not hasattr(orchestrator, "_session_manager"):
+    # 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
@@ -154,7 +158,7 @@ def _validate_working_dir(
 def delegate(
     self: "Orchestrator",
     task: str,
-    mode: Literal["sync", "async"] = "sync",
+    mode: Literal["sync", "async"] = "async",
     model: str | None = None,
     working_dir: str | None = None,
 ) -> dict[str, Any]:
@@ -162,28 +166,34 @@ def delegate(
     Delegate work to a Codex agent.
 
     This spawns a codex session - the exact same way `zwarm interactive` does.
-    Two modes available:
 
-    **sync** (default): Wait for codex to complete, then return the response.
-    Best for: most tasks - you get the full response immediately.
+    **NOTE: All sessions run async.** The mode parameter is ignored - sessions
+    always return immediately. Use sleep() + peek_session() to poll for completion.
 
-    **async**: Fire-and-forget execution.
-    Check progress later with check_session().
-    Best for: long-running tasks, parallel work.
+    Async workflow pattern:
+        1. delegate(task="Add logout button") -> session_id
+        2. sleep(30) -> give it time
+        3. peek_session(session_id) -> check if done
+        4. Repeat 2-3 if still running
+        5. check_session(session_id) -> get full results
 
     Args:
         task: Clear description of what to do. Be specific about requirements.
-        mode: "sync" to wait for completion, "async" for fire-and-forget.
+        mode: IGNORED - always async. (Legacy parameter, will be removed.)
         model: Model override (default: gpt-5.1-codex-mini).
         working_dir: Directory for codex to work in (default: orchestrator's dir).
 
     Returns:
-        {session_id, status, response (if sync)}
+        {session_id, status: "running", task, hint}
 
     Example:
-        delegate(task="Add a logout button to the navbar", mode="sync")
-        # Then use converse() to refine: "Also add a confirmation dialog"
+        delegate(task="Add a logout button to the navbar")
+        sleep(30)
+        peek_session(session_id)  # Check progress
     """
+    # Force async mode - sync is deprecated
+    # TODO: Remove sync codepath entirely (see STATE.md)
+    mode = "async"
     # Validate working directory
     effective_dir, dir_error = _validate_working_dir(
         working_dir,
@@ -293,7 +303,7 @@ def converse(
     self: "Orchestrator",
     session_id: str,
     message: str,
-    wait: bool = True,
+    wait: bool = False,
 ) -> dict[str, Any]:
     """
     Continue a conversation with a codex session.
@@ -301,29 +311,26 @@ def converse(
     This injects a follow-up message into the session, providing the
     conversation history as context. Like chatting with a developer.
 
-    Two modes:
-    - **wait=True** (default): Wait for codex to respond before returning.
-    - **wait=False**: Fire-and-forget. Message sent, codex runs in background.
-      Use check_session() later to see the response.
+    **NOTE: Always runs async.** The wait parameter is ignored - messages
+    are sent and return immediately. Use sleep() + check_session() to poll.
 
     Args:
         session_id: The session to continue (from delegate() result).
         message: Your next message to codex.
-        wait: If True, wait for response. If False, return immediately.
+        wait: IGNORED - always async. (Legacy parameter, will be removed.)
 
     Returns:
-        {session_id, response (if wait=True), turn}
-
-    Example (sync):
-        result = delegate(task="Add user authentication")
-        converse(session_id=result["session_id"], message="Use JWT")
-        # Returns with response
+        {session_id, turn, status: "running"}
 
-    Example (async - managing multiple sessions):
-        converse(session_id="abc123", message="Add tests", wait=False)
-        converse(session_id="def456", message="Fix bug", wait=False)
-        # Both running in parallel, check later with check_session()
+    Example:
+        converse(session_id="abc123", message="Add tests")
+        sleep(30)
+        check_session(session_id)  # Get response
     """
+    # Force async mode - sync is deprecated
+    # TODO: Remove sync codepath entirely (see STATE.md)
+    wait = False
+
     manager = _get_session_manager(self)
 
     # Get current session
@@ -517,6 +524,81 @@ def peek_session(
     }
 
 
+@weaveTool
+def get_trajectory(
+    self: "Orchestrator",
+    session_id: str,
+    full: bool = False,
+) -> dict[str, Any]:
+    """
+    Get the full trajectory of a session - all steps the agent took.
+
+    Shows reasoning, commands, tool calls, and responses in order.
+    Useful for understanding HOW the agent completed a task, not just
+    the final result.
+
+    Args:
+        session_id: The session to get trajectory for.
+        full: If True, include full untruncated content (default: False for summary view).
+
+    Returns:
+        {steps: [...], step_count}
+    """
+    manager = _get_session_manager(self)
+
+    session = manager.get_session(session_id)
+    if not session:
+        return {"success": False, "error": f"Unknown session: {session_id}"}
+
+    trajectory = manager.get_trajectory(session_id, full=full)
+
+    # Format steps for easy reading
+    formatted_steps = []
+    for step in trajectory:
+        step_type = step.get("type", "unknown")
+
+        if step_type == "reasoning":
+            text = step.get("full_text") if full else step.get("summary", "")
+            formatted_steps.append(f"[thinking] {text}")
+        elif step_type == "command":
+            cmd = step.get("command", "")
+            output = step.get("output", "")
+            exit_code = step.get("exit_code")
+            step_str = f"[command] $ {cmd}"
+            if output:
+                if full:
+                    step_str += f"\n  → {output}"
+                else:
+                    step_str += f"\n  → {output[:100]}{'...' if len(output) > 100 else ''}"
+            if exit_code and exit_code != 0:
+                step_str += f" (exit: {exit_code})"
+            formatted_steps.append(step_str)
+        elif step_type == "tool_call":
+            if full and step.get("full_args"):
+                import json
+                args_str = json.dumps(step["full_args"], indent=2)
+                formatted_steps.append(f"[tool] {step.get('tool', 'unknown')}\n  {args_str}")
+            else:
+                formatted_steps.append(f"[tool] {step.get('tool', 'unknown')}({step.get('args_preview', '')})")
+        elif step_type == "tool_output":
+            output = step.get("output", "")
+            if not full:
+                output = output[:100]
+            formatted_steps.append(f"[result] {output}")
+        elif step_type == "message":
+            text = step.get("full_text") if full else step.get("summary", "")
+            formatted_steps.append(f"[response] {text}")
+
+    return {
+        "success": True,
+        "session_id": session.short_id,
+        "task": _truncate(session.task, 80),
+        "step_count": len(trajectory),
+        "steps": formatted_steps,
+        "mode": "full" if full else "summary",
+    }
+
+
 @weaveTool
 def end_session(
     self: "Orchestrator",
@@ -703,3 +785,44 @@ def list_sessions(
         "filter": status or "all",
         "hint": "Sessions with needs_attention=True have new responses to review" if needs_attention_count else None,
     }
+
+
+@weaveTool
+def sleep(self, seconds: float) -> dict[str, Any]:
+    """
+    Sleep for a specified number of seconds.
+
+    Use this when you've started async sessions (wait=False) and want to
+    give them time to complete before checking their status. This lets you
+    manage your own polling loop:
+
+    1. delegate(task, wait=False) -> start background work
+    2. sleep(10) -> wait a bit
+    3. peek_session(id) -> check if done
+    4. Repeat 2-3 if still running
+
+    Args:
+        seconds: Number of seconds to sleep (max 300 = 5 minutes)
+
+    Returns:
+        Dict with success status and actual sleep duration
+    """
+    # Cap at 5 minutes to prevent accidental long hangs
+    max_sleep = 300.0
+    actual_seconds = min(float(seconds), max_sleep)
+
+    if actual_seconds <= 0:
+        return {
+            "success": False,
+            "error": "Sleep duration must be positive",
+            "requested": seconds,
+        }
+
+    time.sleep(actual_seconds)
+
+    return {
+        "success": True,
+        "slept_seconds": actual_seconds,
+        "capped": actual_seconds < seconds,
+        "max_allowed": max_sleep if actual_seconds < seconds else None,
+    }

zwarm/watchers/__init__.py

@@ -11,6 +11,10 @@ from zwarm.watchers.manager import WatcherManager, WatcherConfig, build_watcher_
 
 # Import built-in watchers to register them
 from zwarm.watchers import builtin as _builtin  # noqa: F401
+from zwarm.watchers import llm_watcher as _llm_watcher  # noqa: F401
+
+# Export trajectory compression utility
+from zwarm.watchers.llm_watcher import compress_trajectory
 
 __all__ = [
     "Watcher",
@@ -23,4 +27,5 @@ __all__ = [
     "get_watcher",
     "list_watchers",
     "build_watcher_manager",
+    "compress_trajectory",
 ]

zwarm/watchers/llm_watcher.py

@@ -0,0 +1,319 @@
+"""
+LLM-based watcher for nuanced trajectory analysis.
+
+Unlike rule-based watchers, this watcher uses a language model to assess
+the orchestrator's trajectory and provide context-aware guidance.
+
+The watcher compresses the full message history into a compact trajectory
+representation (similar to what Codex shows in its UI) to minimize token
+usage while preserving the "shape" of the agent's behavior.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from zwarm.watchers.base import Watcher, WatcherContext, WatcherResult
+from zwarm.watchers.registry import register_watcher
+
+logger = logging.getLogger(__name__)
+
+
+def _get_field(item: Any, name: str, default: Any = None) -> Any:
+    """Get field from dict or object."""
+    if isinstance(item, dict):
+        return item.get(name, default)
+    return getattr(item, name, default)
+
+
+def _extract_tool_call_summary(tc: Any) -> str:
+    """Extract a compact summary of a tool call."""
+    if isinstance(tc, dict):
+        func = tc.get("function", tc)
+        name = func.get("name", tc.get("name", "?"))
+        args = func.get("arguments", tc.get("arguments", ""))
+    else:
+        name = getattr(tc, "name", "?")
+        args = getattr(tc, "arguments", "")
+
+    # Parse args if JSON string
+    if isinstance(args, str):
+        try:
+            args = json.loads(args)
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+    # Create compact arg summary
+    if isinstance(args, dict):
+        # Show key args based on tool type
+        if name == "delegate":
+            task = args.get("task", "")[:50]
+            mode = args.get("mode", "sync")
+            return f"delegate({mode}): {task}..."
+        elif name == "converse":
+            msg = args.get("message", "")[:40]
+            return f"converse: {msg}..."
+        elif name == "bash":
+            cmd = args.get("command", "")[:60]
+            return f"$ {cmd}"
+        elif name in ("check_session", "peek_session", "end_session"):
+            sid = args.get("session_id", "")[:8]
+            return f"{name}({sid})"
+        elif name == "list_sessions":
+            return "list_sessions()"
+        else:
+            # Generic: show first arg
+            first_val = next(iter(args.values()), "") if args else ""
+            if isinstance(first_val, str) and len(first_val) > 30:
+                first_val = first_val[:30] + "..."
+            return f"{name}({first_val})"
+    else:
+        return f"{name}({str(args)[:30]})"
+
+
+def compress_trajectory(messages: list[dict[str, Any]], max_steps: int = 50) -> str:
+    """
+    Compress full message history into a compact trajectory representation.
+
+    Output format (similar to Codex UI):
+    ```
+    [1] thinking: "preparing to inspect the codebase"
+        → delegate(sync): Add authentication to...
+    [2] thinking: "checking session status"
+        → check_session(abc123)
+    [3] thinking: "session completed, verifying"
+        → $ pytest tests/
+    ```
+
+    Args:
+        messages: Full message history from orchestrator
+        max_steps: Maximum steps to include (most recent)
+
+    Returns:
+        Compact trajectory string
+    """
+    steps = []
+    step_num = 0
+
+    for msg in messages:
+        role = _get_field(msg, "role", "")
+
+        if role == "system":
+            continue  # Skip system messages
+
+        if role == "assistant":
+            step_num += 1
+            content = _get_field(msg, "content", "")
+            tool_calls = _get_field(msg, "tool_calls", [])
+
+            # Extract thinking/reasoning summary
+            thinking = ""
+            if content:
+                # Take first line or first 80 chars as "thinking"
+                first_line = content.split("\n")[0].strip()
+                if len(first_line) > 80:
+                    thinking = first_line[:80] + "..."
+                else:
+                    thinking = first_line
+
+            # Extract tool calls
+            actions = []
+            if tool_calls:
+                for tc in tool_calls[:3]:  # Max 3 tool calls per step
+                    actions.append(_extract_tool_call_summary(tc))
+                if len(tool_calls) > 3:
+                    actions.append(f"... +{len(tool_calls) - 3} more")
+
+            # Format step
+            step_lines = [f"[{step_num}]"]
+            if thinking:
+                step_lines[0] += f' thinking: "{thinking}"'
+            for action in actions:
+                step_lines.append(f"    → {action}")
+
+            steps.append("\n".join(step_lines))
+
+        elif role == "tool":
+            # Tool results - just note if error
+            content = str(_get_field(msg, "content", ""))
+            if "error" in content.lower() or "failed" in content.lower():
+                steps.append(f"    ⚠ tool returned error")
+
+        elif role == "user" and step_num > 0:
+            # User message mid-conversation (watcher nudge, etc.)
+            content = _get_field(msg, "content", "")
+            if content and "[WATCHER" in content:
+                steps.append(f"    📍 watcher nudge")
+            elif content:
+                preview = content[:50].replace("\n", " ")
+                steps.append(f"    💬 user: {preview}...")
+
+    # Take most recent steps
+    if len(steps) > max_steps:
+        steps = ["... (earlier steps omitted)"] + steps[-max_steps:]
+
+    return "\n".join(steps)
+
+
+def _build_watcher_prompt(
+    trajectory: str,
+    task: str,
+    step: int,
+    max_steps: int,
+    session_summary: str,
+) -> str:
+    """Build the prompt for the LLM watcher."""
+    return f"""You are a trajectory watcher observing an orchestrator agent. Your job is to assess whether the agent is on track and provide guidance if needed.
+
+## Original Task
+{task}
+
+## Progress
+Step {step}/{max_steps}
+
+## Active Sessions
+{session_summary}
+
+## Trajectory (recent steps)
+{trajectory}
+
+---
+
+Analyze this trajectory and respond with a JSON object:
+{{
+  "status": "ok" | "concern" | "problem",
+  "assessment": "Brief 1-2 sentence assessment of trajectory health",
+  "guidance": "If status is concern/problem, specific actionable guidance. Otherwise null."
+}}
+
+Things to watch for:
+- Is the agent making progress toward the task?
+- Is it spinning or repeating actions?
+- Is it going off on tangents unrelated to the task?
+- Is it delegating appropriately or trying to do everything directly?
+- Are sessions being completed or just started and abandoned?
+
+Be concise. Only flag real issues, not minor inefficiencies."""
+
+
+@register_watcher("llm")
+class LLMWatcher(Watcher):
+    """
+    LLM-based watcher for nuanced trajectory analysis.
+
+    Uses a language model to assess the orchestrator's trajectory
+    and provide context-aware guidance that rule-based watchers can't.
+
+    Config options:
+        model: Model to use (default: gpt-4o-mini)
+        threshold: How often to run (every N steps, default: 5)
+        temperature: LLM temperature (default: 0.3)
+    """
+
+    name = "llm"
+    description = "LLM-based trajectory analysis for nuanced guidance"
+
+    async def observe(self, ctx: WatcherContext) -> WatcherResult:
+        config = self.config
+        threshold = config.get("threshold", 5)
+        model = config.get("model", "gpt-4o-mini")
+        temperature = config.get("temperature", 0.3)
+
+        # Only run every N steps to save costs
+        if ctx.step % threshold != 0 or ctx.step == 0:
+            return WatcherResult.ok()
+
+        try:
+            # Compress trajectory
+            trajectory = compress_trajectory(ctx.messages)
+
+            # Build session summary
+            active = [s for s in ctx.sessions if s.get("status") == "running"]
+            completed = [s for s in ctx.sessions if s.get("status") == "completed"]
+            failed = [s for s in ctx.sessions if s.get("status") == "failed"]
+            session_summary = f"{len(active)} running, {len(completed)} completed, {len(failed)} failed"
+
+            # Build prompt
+            prompt = _build_watcher_prompt(
+                trajectory=trajectory,
+                task=ctx.task,
+                step=ctx.step,
+                max_steps=ctx.max_steps,
+                session_summary=session_summary,
+            )
+
+            # Call LLM
+            response = await self._call_llm(prompt, model, temperature)
+
+            # Parse response
+            result = self._parse_response(response)
+
+            if result["status"] == "ok":
+                return WatcherResult.ok()
+            elif result["status"] == "concern":
+                return WatcherResult.nudge(
+                    guidance=result.get("guidance", result["assessment"]),
+                    reason=f"LLM assessment: {result['assessment']}",
+                    metadata={"llm_response": result},
+                )
+            else:  # problem
+                return WatcherResult.nudge(
+                    guidance=result.get("guidance", result["assessment"]),
+                    reason=f"LLM detected problem: {result['assessment']}",
+                    priority=10,  # Higher priority for problems
+                    metadata={"llm_response": result},
+                )
+
+        except Exception as e:
+            logger.warning(f"LLM watcher failed: {e}")
+            return WatcherResult.ok()  # Don't block on watcher failure
+
+    async def _call_llm(self, prompt: str, model: str, temperature: float) -> str:
+        """Call the LLM using OpenAI Responses API."""
+        import openai
+
+        client = openai.AsyncOpenAI()
+
+        # Use Responses API (consistent with wbal)
+        response = await client.responses.create(
+            model=model,
+            input=[{"role": "user", "content": prompt}],
+            temperature=temperature,
+            text={"format": {"type": "json_object"}},
+        )
+
+        # Extract text from response
+        output_text = getattr(response, "output_text", None)
+        if output_text:
+            return output_text
+
+        # Fallback: look through output items
+        for item in getattr(response, "output", []):
+            if getattr(item, "type", None) == "message":
+                for content in getattr(item, "content", []):
+                    if getattr(content, "type", None) == "output_text":
+                        return getattr(content, "text", "{}")
+            # Also check for direct text attribute
+            text = getattr(item, "text", None)
+            if text:
+                return text
+
+        return "{}"
+
+    def _parse_response(self, response: str) -> dict[str, Any]:
+        """Parse LLM response JSON."""
+        try:
+            result = json.loads(response)
+            # Validate required fields
+            if "status" not in result:
+                result["status"] = "ok"
+            if "assessment" not in result:
+                result["assessment"] = "No assessment provided"
+            return result
+        except json.JSONDecodeError:
+            return {
+                "status": "ok",
+                "assessment": "Failed to parse LLM response",
+            }

{zwarm-2.3.dist-info → zwarm-3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwarm
-Version: 2.3
+Version: 3.0
 Summary: Multi-Agent CLI Orchestration Research Platform
 Requires-Python: <3.14,>=3.13
 Requires-Dist: python-dotenv>=1.0.0

{zwarm-2.3.dist-info → zwarm-3.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 zwarm/__init__.py,sha256=3i3LMjHwIzE-LFIS2aUrwv3EZmpkvVMe-xj1h97rcSM,837
-zwarm/orchestrator.py,sha256=IdOd7xNH6IKfvpajh6pOKh2nwTjopS2nQ8GYrj7OsSc,23307
+zwarm/orchestrator.py,sha256=JGRGuJP05Nf5QibuWytjQAC_NuGGaGUR3G-tLq4SVxY,23624
 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
@@ -9,29 +9,32 @@ zwarm/adapters/registry.py,sha256=EdyHECaNA5Kv1od64pYFBJyA_r_6I1r_eJTNP1XYLr4,17
 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=fQT9oP03zsru1_80WfVBdX48kdpLIVfEgS8eJQxRxUM,88668
+zwarm/cli/main.py,sha256=ztGb0jNHO6NkRT9Qg-4_gAg1U1lMNZUyjJDY5wQyZ-k,97634
+zwarm/cli/pilot.py,sha256=Gg0c2x-aUJuG2grpNWJd7f0K0NQna9cAOnjfiufDsHo,33035
 zwarm/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zwarm/core/compact.py,sha256=Y8C7Gs-5-WOU43WRvQ863Qzd5xtuEqR6Aw3r2p8_-i8,10907
 zwarm/core/config.py,sha256=331i4io9uEnloFwUMjTPJ5_lQFKJR1nhTpA4SPfSpiI,11748
-zwarm/core/environment.py,sha256=HVDpDZEpDSfyh9-wHZMzMKVUPKvioBkPVWeiME2JmFo,5435
+zwarm/core/environment.py,sha256=zrgh0N3Ng4HI2F1gCYkcQVGzjQPKiIFWuRe1OPRuRn0,6558
 zwarm/core/models.py,sha256=PrC3okRBVJxISUa1Fax4KkagqLT6Xub-kTxC9drN0sY,10083
 zwarm/core/state.py,sha256=MzrvODKEiJovI7YI1jajW4uukineZ3ezmW5oQinMgjg,11563
 zwarm/core/test_compact.py,sha256=WSdjCB5t4YMcknsrkmJIUsVOPY28s4y9GnDmu3Z4BFw,11878
 zwarm/core/test_config.py,sha256=26ozyiFOdjFF2c9Q-HDfFM6GOLfgw_5FZ55nTDMNYA8,4888
 zwarm/core/test_models.py,sha256=sWTIhMZvuLP5AooGR6y8OR2EyWydqVfhmGrE7NPBBnk,8450
-zwarm/prompts/__init__.py,sha256=FiaIOniLrIyfD3_osxT6I7FfyKjtctbf8jNs5QTPs_s,213
-zwarm/prompts/orchestrator.py,sha256=-VZ3B5t-2ALOTpdZyNZGSjjzaHiTufAuLzrTLgwg70M,15442
+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=XDwXXZKJwxgBXOl4Mf61_BCdYoKU7lpJHxE_7Lyzuy4,22946
+zwarm/sessions/manager.py,sha256=Aq7Wh-WW7ZMP8LgGa3g70wfGg6E2GYjJOBucy6HUfGc,27700
 zwarm/tools/__init__.py,sha256=FpqxwXJA6-fQ7C-oLj30jjK_0qqcE7MbI0dQuaB56kU,290
-zwarm/tools/delegation.py,sha256=FFfZvDnppbbqsTeoYUned6gjqwE9m1gkJ09jSkiiWps,22307
-zwarm/watchers/__init__.py,sha256=yYGTbhuImQLESUdtfrYbHYBJNvCNX3B-Ei-vY5BizX8,760
+zwarm/tools/delegation.py,sha256=LUf48Z2aXVvDxgScYMTwOICJ2jq0KB1DWmf6VA7BhXU,26442
+zwarm/watchers/__init__.py,sha256=a96s7X6ruYkF2ItWWOZ3Q5QUOMOoeCW4Vz8XXcYLXPM,956
 zwarm/watchers/base.py,sha256=r1GoPlj06nOT2xp4fghfSjxbRyFFFQUB6HpZbEyO2OY,3834
 zwarm/watchers/builtin.py,sha256=IL5QwwKOIqWEfJ_uQWb321Px4i5OLtI_vnWQMudqKoA,19064
+zwarm/watchers/llm_watcher.py,sha256=yJGpE3BGKNZX3qgPsiNtJ5d3UJpiTT1V-A-Rh4AiMYM,11029
 zwarm/watchers/manager.py,sha256=XZjBVeHjgCUlkTUeHqdvBvHoBC862U1ik0fG6nlRGog,5587
 zwarm/watchers/registry.py,sha256=A9iBIVIFNtO7KPX0kLpUaP8dAK7ozqWLA44ocJGnOw4,1219
 zwarm/watchers/test_watchers.py,sha256=zOsxumBqKfR5ZVGxrNlxz6KcWjkcdp0QhW9WB0_20zM,7855
-zwarm-2.3.dist-info/METADATA,sha256=fBqubqwFUeool8DcYfqk66WQsG42plPI27JLbrTpg3Q,7678
-zwarm-2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-zwarm-2.3.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
-zwarm-2.3.dist-info/RECORD,,
+zwarm-3.0.dist-info/METADATA,sha256=ZpFa_QdNIUBX2Ay0lAuT7fP_5WOSomtcF1dynknQOQA,7678
+zwarm-3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+zwarm-3.0.dist-info/entry_points.txt,sha256=u0OXq4q8d3yJ3EkUXwZfkS-Y8Lcy0F8cWrcQfoRxM6Q,46
+zwarm-3.0.dist-info/RECORD,,