zwarm 3.3.0__tar.gz → 3.4.0__tar.gz

{zwarm-3.3.0 → zwarm-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwarm
-Version: 3.3.0
+Version: 3.4.0
 Summary: Multi-Agent CLI Orchestration Research Platform
 Requires-Python: <3.14,>=3.13
 Requires-Dist: prompt-toolkit>=3.0.52

{zwarm-3.3.0 → zwarm-3.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "zwarm"
-version = "3.3.0"
+version = "3.4.0"
 description = "Multi-Agent CLI Orchestration Research Platform"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{zwarm-3.3.0 → zwarm-3.4.0}/src/zwarm/cli/interactive.py

@@ -307,7 +307,7 @@ def cmd_show(manager, session_id: str):
     icon = STATUS_ICONS.get(session.status.value, "?")
     console.print(f"\n{icon} [bold cyan]{session.short_id}[/] - {session.status.value}")
     console.print(f"  [dim]Task:[/] {session.task}")
-    console.print(f"  [dim]Turn:[/] {session.turn} | [dim]Runtime:[/] {session.runtime:.1f}s")
+    console.print(f"  [dim]Turn:[/] {session.turn} | [dim]Runtime:[/] {session.runtime}")
 
     # Token usage with cost estimate
     usage = session.token_usage

{zwarm-3.3.0 → zwarm-3.4.0}/src/zwarm/cli/main.py

@@ -218,6 +218,26 @@ def orchestrate(
         if orchestrator.instance_id and not instance:
             console.print(f"  [dim]Instance: {orchestrator.instance_id[:8]}[/]")
 
+        # Set up step callback for live progress display
+        def step_callback(step_num: int, tool_results: list) -> None:
+            """Print tool calls and results as they happen."""
+            if not tool_results:
+                return
+            for tool_info, result in tool_results:
+                name = tool_info.get("name", "?")
+                # Truncate args for display
+                args_str = str(tool_info.get("args", {}))
+                if len(args_str) > 80:
+                    args_str = args_str[:77] + "..."
+                # Truncate result for display
+                result_str = str(result)
+                if len(result_str) > 100:
+                    result_str = result_str[:97] + "..."
+                console.print(f"[dim]step {step_num}[/] → [cyan]{name}[/]({args_str})")
+                console.print(f"         └ {result_str}")
+
+        orchestrator._step_callback = step_callback
+
         # Run the orchestrator loop
         console.print("[bold]--- Orchestrator running ---[/]\n")
         result = orchestrator.run(task=task)

{zwarm-3.3.0 → zwarm-3.4.0}/src/zwarm/cli/pilot.py

@@ -594,6 +594,18 @@ def execute_step_with_events(
     """
     had_message = False
 
+    # Update environment with current progress before perceive
+    # This ensures the observation has fresh step/token counts
+    if hasattr(orchestrator, "env") and hasattr(orchestrator.env, "update_progress"):
+        total_tokens = getattr(orchestrator, "_total_tokens", 0)
+        executor_usage = orchestrator.get_executor_usage() if hasattr(orchestrator, "get_executor_usage") else {}
+        orchestrator.env.update_progress(
+            step_count=getattr(orchestrator, "_step_count", 0),
+            max_steps=getattr(orchestrator, "maxSteps", 50),
+            total_tokens=total_tokens,
+            executor_tokens=executor_usage.get("total_tokens", 0),
+        )
+
     # Execute perceive (updates environment observation)
     orchestrator.perceive()
 
@@ -649,7 +661,7 @@ def execute_step_with_events(
 def run_until_response(
     orchestrator: Any,
     renderer: EventRenderer,
-    max_steps: int = 20,
+    max_steps: int = 60,
 ) -> List[tuple]:
     """
     Run the orchestrator until it produces a message response.
@@ -657,7 +669,7 @@ def run_until_response(
     Keeps stepping while the agent only produces tool calls.
     Stops when:
     - Agent produces a text message (returns to user)
-    - Max steps reached
+    - Max steps reached (configurable via orchestrator.max_steps_per_turn)
     - Stop condition triggered
 
     This is wrapped as a weave.op to group all child calls per turn.
@@ -665,7 +677,7 @@ def run_until_response(
     Args:
         orchestrator: The orchestrator instance
         renderer: Event renderer for output
-        max_steps: Safety limit on steps per turn
+        max_steps: Safety limit on steps per turn (default: 60)
 
     Returns:
         All tool results from the turn
@@ -703,6 +715,9 @@ def run_until_response(
             if not results:
                 break
 
+        # Show session status at end of turn (if there are any sessions)
+        render_session_status(orchestrator, renderer)
+
         return all_results
 
     return _run_turn()
@@ -758,6 +773,38 @@ def get_sessions_snapshot(orchestrator: Any) -> Dict[str, Any]:
     return {"sessions": []}
 
 
+def render_session_status(orchestrator: Any, renderer: EventRenderer) -> None:
+    """
+    Render a compact session status line if there are active sessions.
+
+    Shows: "Sessions: 2 running, 1 done, 0 failed"
+    Only displays if there are any sessions.
+    """
+    if not hasattr(orchestrator, "_session_manager"):
+        return
+
+    sessions = orchestrator._session_manager.list_sessions()
+    if not sessions:
+        return
+
+    running = sum(1 for s in sessions if s.status.value == "running")
+    completed = sum(1 for s in sessions if s.status.value == "completed")
+    failed = sum(1 for s in sessions if s.status.value == "failed")
+
+    # Build status line with colors
+    parts = []
+    if running > 0:
+        parts.append(f"[cyan]{running} running[/]")
+    if completed > 0:
+        parts.append(f"[green]{completed} done[/]")
+    if failed > 0:
+        parts.append(f"[red]{failed} failed[/]")
+
+    if parts:
+        status_line = ", ".join(parts)
+        console.print(f"[dim]Sessions:[/] {status_line}")
+
+
 def run_pilot(
     orchestrator: Any,
     *,
@@ -814,7 +861,8 @@ def _run_pilot_repl(
         })
 
         renderer.reset_turn()
-        results = run_until_response(orchestrator, renderer)
+        max_steps = getattr(orchestrator.config.orchestrator, "max_steps_per_turn", 60)
+        results = run_until_response(orchestrator, renderer, max_steps=max_steps)
 
         # Record checkpoint
         state.record(
@@ -1103,8 +1151,9 @@ def _run_pilot_repl(
 
         # Execute steps until agent responds with a message
         renderer.reset_turn()
+        max_steps = getattr(orchestrator.config.orchestrator, "max_steps_per_turn", 60)
         try:
-            results = run_until_response(orchestrator, renderer)
+            results = run_until_response(orchestrator, renderer, max_steps=max_steps)
         except Exception as e:
             renderer.error(f"Step failed: {e}")
             # Remove the user message on failure

{zwarm-3.3.0 → zwarm-3.4.0}/src/zwarm/core/config.py

@@ -60,6 +60,7 @@ class OrchestratorConfig:
     prompt: str | None = None  # path to prompt yaml
     tools: list[str] = field(default_factory=lambda: ["delegate", "converse", "check_session", "end_session", "bash"])
     max_steps: int = 50
+    max_steps_per_turn: int = 60  # Max tool-call steps before returning to user (pilot mode)
     parallel_delegations: int = 4
     compaction: CompactionConfig = field(default_factory=CompactionConfig)
 
@@ -172,6 +173,7 @@ class ZwarmConfig:
                 "prompt": self.orchestrator.prompt,
                 "tools": self.orchestrator.tools,
                 "max_steps": self.orchestrator.max_steps,
+                "max_steps_per_turn": self.orchestrator.max_steps_per_turn,
                 "parallel_delegations": self.orchestrator.parallel_delegations,
                 "compaction": {
                     "enabled": self.orchestrator.compaction.enabled,

{zwarm-3.3.0 → zwarm-3.4.0}/src/zwarm/orchestrator.py

@@ -81,6 +81,8 @@ class Orchestrator(YamlAgent):
             "total_tokens": 0,
         }
     )
+    # Callback for step progress (used by CLI to print tool calls)
+    _step_callback: Callable[[int, list[tuple[dict[str, Any], Any]]], None] | None = PrivateAttr(default=None)
 
     def model_post_init(self, __context: Any) -> None:
         """Initialize state after model creation."""
@@ -149,6 +151,10 @@ class Orchestrator(YamlAgent):
         """Access state manager."""
         return self._state
 
+    def get_executor_usage(self) -> dict[str, int]:
+        """Get aggregated token usage from executor sessions."""
+        return self._executor_usage
+
     def save_state(self) -> None:
         """Save orchestrator state for resume."""
         self._state.save_orchestrator_messages(self.messages)
@@ -550,7 +556,11 @@ Review what was accomplished in the previous session and delegate new tasks as n
                 }
             # NUDGE and CONTINUE just continue
 
-            self.step()
+            tool_results = self.step()
+
+            # Call step callback if registered (for CLI progress display)
+            if self._step_callback:
+                self._step_callback(self._step_count, tool_results)
 
             if self.stopCondition:
                 break