zwarm 3.10.3__tar.gz → 3.10.5__tar.gz

{zwarm-3.10.3 → zwarm-3.10.5}/PKG-INFO

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

{zwarm-3.10.3 → zwarm-3.10.5}/pyproject.toml

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

zwarm-3.10.5/src/zwarm/compression/__init__.py

@@ -0,0 +1,37 @@
+"""
+Compression modules for infinite-running agents.
+
+Two types of compression:
+1. TC (Tool Call) Compression - compresses tool call results before they enter context
+2. Rollout Compression - manages message history eviction (LRU-style)
+
+These modules allow agents to run virtually indefinitely without context explosion.
+"""
+
+from .tc_compression import (
+    TCCompressor,
+    NoOpTCCompressor,
+    NaiveSizeTCCompressor,
+    get_tc_compressor,
+)
+from .rollout_compression import (
+    RolloutCompressor,
+    NoOpRolloutCompressor,
+    LRURolloutCompressor,
+    SlidingWindowRolloutCompressor,
+    get_rollout_compressor,
+)
+
+__all__ = [
+    # TC Compression
+    "TCCompressor",
+    "NoOpTCCompressor",
+    "NaiveSizeTCCompressor",
+    "get_tc_compressor",
+    # Rollout Compression
+    "RolloutCompressor",
+    "NoOpRolloutCompressor",
+    "LRURolloutCompressor",
+    "SlidingWindowRolloutCompressor",
+    "get_rollout_compressor",
+]

zwarm-3.10.5/src/zwarm/compression/rollout_compression.py

@@ -0,0 +1,292 @@
+"""
+Rollout Compression - manages message history eviction for infinite-running agents.
+
+As agents run, their conversation history grows. These compressors implement
+different strategies for evicting old messages to keep context bounded.
+
+Available compressors:
+- NoOpRolloutCompressor: No eviction (context will eventually overflow)
+- LRURolloutCompressor: Evict oldest messages, keeping system prompt
+- SlidingWindowRolloutCompressor: Keep last N turns (user+assistant pairs)
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class EvictionStats:
+    """Statistics about message eviction."""
+
+    messages_before: int = 0
+    messages_after: int = 0
+    messages_evicted: int = 0
+    tokens_evicted_estimate: int = 0  # Rough estimate
+    eviction_triggered: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "messages_before": self.messages_before,
+            "messages_after": self.messages_after,
+            "messages_evicted": self.messages_evicted,
+            "tokens_evicted_estimate": self.tokens_evicted_estimate,
+            "eviction_triggered": self.eviction_triggered,
+        }
+
+
+class RolloutCompressor(ABC):
+    """
+    Abstract base class for rollout (message history) compression.
+
+    Subclasses implement different eviction strategies to keep the
+    conversation history bounded while preserving important context.
+    """
+
+    name: str = "base"
+
+    @abstractmethod
+    def compress(self, messages: list[dict]) -> tuple[list[dict], EvictionStats]:
+        """
+        Compress message history, returning trimmed version and stats.
+
+        Args:
+            messages: List of message dicts with 'role' and 'content' keys
+
+        Returns:
+            (compressed_messages, eviction_stats)
+        """
+        pass
+
+    def should_compress(self, messages: list[dict]) -> bool:
+        """Check if compression is needed (subclasses may override)."""
+        return True
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+
+class NoOpRolloutCompressor(RolloutCompressor):
+    """
+    No-op compressor - keeps all messages.
+
+    Use this when you want to disable rollout compression and let the
+    context window naturally overflow (will error eventually).
+    """
+
+    name = "noop"
+
+    def compress(self, messages: list[dict]) -> tuple[list[dict], EvictionStats]:
+        """Pass through unchanged."""
+        return messages, EvictionStats(
+            messages_before=len(messages),
+            messages_after=len(messages),
+            eviction_triggered=False,
+        )
+
+
+class LRURolloutCompressor(RolloutCompressor):
+    """
+    LRU (Least Recently Used) compressor - evicts oldest messages.
+
+    Keeps the system prompt and the most recent messages. When the message
+    count exceeds max_messages, evicts oldest non-system messages.
+
+    Args:
+        max_messages: Maximum messages to keep (default: 50)
+        preserve_system: Keep all system messages (default: True)
+        preserve_first_user: Keep first user message as context (default: True)
+    """
+
+    name = "lru"
+
+    def __init__(
+        self,
+        max_messages: int = 50,
+        preserve_system: bool = True,
+        preserve_first_user: bool = True,
+    ):
+        self.max_messages = max_messages
+        self.preserve_system = preserve_system
+        self.preserve_first_user = preserve_first_user
+
+    def should_compress(self, messages: list[dict]) -> bool:
+        """Only compress if we exceed max_messages."""
+        return len(messages) > self.max_messages
+
+    def compress(self, messages: list[dict]) -> tuple[list[dict], EvictionStats]:
+        """Evict oldest messages, keeping system prompt and recent history."""
+        stats = EvictionStats(messages_before=len(messages))
+
+        if not self.should_compress(messages):
+            stats.messages_after = len(messages)
+            return messages, stats
+
+        # Separate preserved messages from evictable ones
+        preserved = []
+        evictable = []
+
+        first_user_seen = False
+        for i, msg in enumerate(messages):
+            role = msg.get("role", "")
+
+            # Always preserve system messages
+            if self.preserve_system and role == "system":
+                preserved.append((i, msg))
+            # Preserve first user message as task context
+            elif self.preserve_first_user and role == "user" and not first_user_seen:
+                preserved.append((i, msg))
+                first_user_seen = True
+            else:
+                evictable.append((i, msg))
+
+        # Calculate how many evictable messages to keep
+        preserved_count = len(preserved)
+        keep_count = max(0, self.max_messages - preserved_count)
+
+        # Keep the most recent evictable messages
+        kept_evictable = evictable[-keep_count:] if keep_count > 0 else []
+        evicted = evictable[:-keep_count] if keep_count > 0 and len(evictable) > keep_count else []
+
+        # Merge preserved and kept messages, maintaining original order
+        all_kept = preserved + kept_evictable
+        all_kept.sort(key=lambda x: x[0])  # Sort by original index
+        result = [msg for _, msg in all_kept]
+
+        # Estimate tokens evicted (rough: ~4 chars per token)
+        evicted_content = sum(len(str(msg.get("content", ""))) for _, msg in evicted)
+        tokens_evicted = evicted_content // 4
+
+        stats.messages_after = len(result)
+        stats.messages_evicted = len(evicted)
+        stats.tokens_evicted_estimate = tokens_evicted
+        stats.eviction_triggered = len(evicted) > 0
+
+        return result, stats
+
+    def __repr__(self) -> str:
+        return f"LRURolloutCompressor(max_messages={self.max_messages})"
+
+
+class SlidingWindowRolloutCompressor(RolloutCompressor):
+    """
+    Sliding window compressor - keeps last N turns (user+assistant pairs).
+
+    A "turn" is a user message followed by an assistant response. This
+    preserves conversation coherence better than raw message count.
+
+    Args:
+        max_turns: Maximum turns to keep (default: 20)
+        preserve_system: Keep all system messages (default: True)
+        preserve_first_turn: Keep first turn as context (default: True)
+    """
+
+    name = "sliding_window"
+
+    def __init__(
+        self,
+        max_turns: int = 20,
+        preserve_system: bool = True,
+        preserve_first_turn: bool = True,
+    ):
+        self.max_turns = max_turns
+        self.preserve_system = preserve_system
+        self.preserve_first_turn = preserve_first_turn
+
+    def compress(self, messages: list[dict]) -> tuple[list[dict], EvictionStats]:
+        """Keep last N turns, preserving system messages."""
+        stats = EvictionStats(messages_before=len(messages))
+
+        # Extract system messages
+        system_messages = []
+        conversation = []
+
+        for msg in messages:
+            if msg.get("role") == "system":
+                system_messages.append(msg)
+            else:
+                conversation.append(msg)
+
+        # Group conversation into turns (user + assistant + tool results)
+        turns: list[list[dict]] = []
+        current_turn: list[dict] = []
+
+        for msg in conversation:
+            role = msg.get("role", "")
+            if role == "user" and current_turn:
+                # New user message starts a new turn
+                turns.append(current_turn)
+                current_turn = [msg]
+            else:
+                current_turn.append(msg)
+
+        # Don't forget the last turn
+        if current_turn:
+            turns.append(current_turn)
+
+        # Decide which turns to keep
+        if len(turns) <= self.max_turns:
+            # No eviction needed
+            result = system_messages + conversation
+            stats.messages_after = len(result)
+            return result, stats
+
+        # Keep first turn + last (max_turns - 1) turns
+        kept_turns = []
+        if self.preserve_first_turn and turns:
+            kept_turns.append(turns[0])
+            remaining_turns = turns[1:]
+            kept_turns.extend(remaining_turns[-(self.max_turns - 1):])
+        else:
+            kept_turns = turns[-self.max_turns:]
+
+        # Flatten kept turns back into messages
+        kept_conversation = []
+        for turn in kept_turns:
+            kept_conversation.extend(turn)
+
+        result = system_messages + kept_conversation
+
+        # Calculate eviction stats
+        evicted_count = len(messages) - len(result)
+        stats.messages_after = len(result)
+        stats.messages_evicted = evicted_count
+        stats.eviction_triggered = evicted_count > 0
+
+        return result, stats
+
+    def __repr__(self) -> str:
+        return f"SlidingWindowRolloutCompressor(max_turns={self.max_turns})"
+
+
+# =============================================================================
+# Factory
+# =============================================================================
+
+
+def get_rollout_compressor(
+    name: str = "lru",
+    **kwargs,
+) -> RolloutCompressor:
+    """
+    Get a rollout compressor by name.
+
+    Args:
+        name: Compressor name ("noop", "lru", "sliding_window")
+        **kwargs: Passed to compressor constructor
+
+    Returns:
+        Configured RolloutCompressor instance
+    """
+    compressors = {
+        "noop": NoOpRolloutCompressor,
+        "lru": LRURolloutCompressor,
+        "sliding_window": SlidingWindowRolloutCompressor,
+    }
+
+    if name not in compressors:
+        raise ValueError(f"Unknown rollout compressor: {name}. Available: {list(compressors.keys())}")
+
+    return compressors[name](**kwargs)

zwarm-3.10.5/src/zwarm/compression/tc_compression.py

@@ -0,0 +1,165 @@
+"""
+Tool Call (TC) Compression - compresses tool results before they enter context.
+
+When an agent makes a tool call, the result can be arbitrarily large. These
+compressors marshal results into a more digestible format for the agent.
+
+Available compressors:
+- NoOpTCCompressor: Pass-through, no compression (default for now)
+- NaiveSizeTCCompressor: Truncate to last N characters
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class TCCompressor(ABC):
+    """
+    Abstract base class for tool call result compression.
+
+    Subclasses implement different compression strategies to prevent
+    tool results from exploding the agent's context window.
+    """
+
+    name: str = "base"
+
+    @abstractmethod
+    def compress(self, tool_name: str, result: Any) -> Any:
+        """
+        Compress a tool call result.
+
+        Args:
+            tool_name: Name of the tool that was called
+            result: The raw result from the tool
+
+        Returns:
+            Compressed result (same type or string)
+        """
+        pass
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+
+class NoOpTCCompressor(TCCompressor):
+    """
+    No-op compressor - passes results through unchanged.
+
+    Use this when tool results are already well-bounded or when you want
+    to disable compression entirely.
+    """
+
+    name = "noop"
+
+    def compress(self, tool_name: str, result: Any) -> Any:
+        """Pass through unchanged."""
+        return result
+
+
+class NaiveSizeTCCompressor(TCCompressor):
+    """
+    Naive size-based compressor - truncates results to last N characters.
+
+    Simple but effective: keeps the most recent output which is usually
+    the most relevant (e.g., last N chars of a log file).
+
+    Args:
+        max_chars: Maximum characters to keep (default: 25000)
+        truncation_marker: String to prepend when truncated
+    """
+
+    name = "naive_size"
+
+    def __init__(
+        self,
+        max_chars: int = 25000,
+        truncation_marker: str = "... [truncated, showing last {n} chars] ...\n",
+    ):
+        self.max_chars = max_chars
+        self.truncation_marker = truncation_marker
+
+    def compress(self, tool_name: str, result: Any) -> Any:
+        """Truncate to last max_chars characters if needed."""
+        # Handle dict results (common for our tools)
+        if isinstance(result, dict):
+            return self._compress_dict(result)
+
+        # Handle string results
+        if isinstance(result, str):
+            return self._truncate_string(result)
+
+        # Handle list results
+        if isinstance(result, list):
+            return self._compress_list(result)
+
+        # For other types, convert to string and truncate
+        result_str = str(result)
+        return self._truncate_string(result_str)
+
+    def _truncate_string(self, s: str) -> str:
+        """Truncate string to last max_chars."""
+        if len(s) <= self.max_chars:
+            return s
+
+        # Keep last N chars with marker
+        marker = self.truncation_marker.format(n=self.max_chars)
+        keep_chars = self.max_chars - len(marker)
+        return marker + s[-keep_chars:]
+
+    def _compress_dict(self, d: dict) -> dict:
+        """Recursively compress dict values."""
+        compressed = {}
+        for key, value in d.items():
+            if isinstance(value, str):
+                compressed[key] = self._truncate_string(value)
+            elif isinstance(value, dict):
+                compressed[key] = self._compress_dict(value)
+            elif isinstance(value, list):
+                compressed[key] = self._compress_list(value)
+            else:
+                compressed[key] = value
+        return compressed
+
+    def _compress_list(self, lst: list) -> list:
+        """Compress list items."""
+        return [
+            self._truncate_string(item) if isinstance(item, str)
+            else self._compress_dict(item) if isinstance(item, dict)
+            else item
+            for item in lst
+        ]
+
+    def __repr__(self) -> str:
+        return f"NaiveSizeTCCompressor(max_chars={self.max_chars})"
+
+
+# =============================================================================
+# Factory
+# =============================================================================
+
+
+def get_tc_compressor(
+    name: str = "noop",
+    **kwargs,
+) -> TCCompressor:
+    """
+    Get a TC compressor by name.
+
+    Args:
+        name: Compressor name ("noop", "naive_size")
+        **kwargs: Passed to compressor constructor
+
+    Returns:
+        Configured TCCompressor instance
+    """
+    compressors = {
+        "noop": NoOpTCCompressor,
+        "naive_size": NaiveSizeTCCompressor,
+    }
+
+    if name not in compressors:
+        raise ValueError(f"Unknown TC compressor: {name}. Available: {list(compressors.keys())}")
+
+    return compressors[name](**kwargs)

{zwarm-3.10.3 → zwarm-3.10.5}/src/zwarm/core/config.py

@@ -40,9 +40,18 @@ class ExecutorConfig:
     # Note: web_search is always enabled via .codex/config.toml (set up by `zwarm init`)
 
 
+@dataclass
+class TCCompressionConfig:
+    """Configuration for tool call result compression."""
+
+    enabled: bool = True
+    compressor: str = "naive_size"  # noop | naive_size
+    max_chars: int = 25000  # For naive_size compressor
+
+
 @dataclass
 class CompactionConfig:
-    """Configuration for context window compaction."""
+    """Configuration for context window compaction (rollout compression)."""
 
     enabled: bool = True
     max_tokens: int = 100000  # Trigger compaction when estimated tokens exceed this
@@ -62,7 +71,10 @@ class OrchestratorConfig:
     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)
+
+    # Compression settings for infinite-running agents
+    compaction: CompactionConfig = field(default_factory=CompactionConfig)  # Rollout compression
+    tc_compression: TCCompressionConfig = field(default_factory=TCCompressionConfig)  # Tool call compression
 
     # Directory restrictions for agent delegations
     # None = only working_dir allowed (most restrictive, default)
@@ -115,10 +127,13 @@ class ZwarmConfig:
         orchestrator_data = data.get("orchestrator", {})
         watchers_data = data.get("watchers", {})
 
-        # Parse compaction config from orchestrator
+        # Parse compression configs from orchestrator
         compaction_data = orchestrator_data.pop("compaction", {}) if orchestrator_data else {}
         compaction_config = CompactionConfig(**compaction_data) if compaction_data else CompactionConfig()
 
+        tc_compression_data = orchestrator_data.pop("tc_compression", {}) if orchestrator_data else {}
+        tc_compression_config = TCCompressionConfig(**tc_compression_data) if tc_compression_data else TCCompressionConfig()
+
         # Parse watchers config - handle both list shorthand and dict format
         if isinstance(watchers_data, list):
             # Shorthand: watchers: [progress, budget, scope]
@@ -140,11 +155,18 @@ class ZwarmConfig:
                 message_role=watchers_data.get("message_role", "user"),
             )
 
-        # Build orchestrator config with nested compaction
+        # Build orchestrator config with nested compression configs
         if orchestrator_data:
-            orchestrator_config = OrchestratorConfig(**orchestrator_data, compaction=compaction_config)
+            orchestrator_config = OrchestratorConfig(
+                **orchestrator_data,
+                compaction=compaction_config,
+                tc_compression=tc_compression_config,
+            )
         else:
-            orchestrator_config = OrchestratorConfig(compaction=compaction_config)
+            orchestrator_config = OrchestratorConfig(
+                compaction=compaction_config,
+                tc_compression=tc_compression_config,
+            )
 
         return cls(
             weave=WeaveConfig(**weave_data) if weave_data else WeaveConfig(),
@@ -183,6 +205,11 @@ class ZwarmConfig:
                     "keep_first_n": self.orchestrator.compaction.keep_first_n,
                     "keep_last_n": self.orchestrator.compaction.keep_last_n,
                 },
+                "tc_compression": {
+                    "enabled": self.orchestrator.tc_compression.enabled,
+                    "compressor": self.orchestrator.tc_compression.compressor,
+                    "max_chars": self.orchestrator.tc_compression.max_chars,
+                },
             },
             "watchers": {
                 "enabled": self.watchers.enabled,

{zwarm-3.10.3 → zwarm-3.10.5}/src/zwarm/orchestrator.py

@@ -83,6 +83,8 @@ class Orchestrator(YamlAgent):
     )
     # 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)
+    # TC compression for tool call results
+    _tc_compressor: Any = PrivateAttr(default=None)
 
     def model_post_init(self, __context: Any) -> None:
         """Initialize state after model creation."""
@@ -132,6 +134,14 @@ class Orchestrator(YamlAgent):
         from zwarm.sessions import CodexSessionManager
         self._session_manager = CodexSessionManager(self.working_dir / ".zwarm")
 
+        # Initialize TC compressor for tool call result compression
+        if self.config.orchestrator.tc_compression.enabled:
+            from zwarm.compression import get_tc_compressor
+            self._tc_compressor = get_tc_compressor(
+                name=self.config.orchestrator.tc_compression.compressor,
+                max_chars=self.config.orchestrator.tc_compression.max_chars,
+            )
+
         # Link session manager to environment for live session visibility in observe()
         if hasattr(self.env, "set_session_manager"):
             self.env.set_session_manager(self._session_manager)
@@ -532,6 +542,10 @@ Review what was accomplished in the previous session and delegate new tasks as n
             else:
                 tc_output = f"Unknown tool: {tc_name}"
 
+            # Apply TC compression to reduce context usage
+            if self._tc_compressor is not None:
+                tc_output = self._tc_compressor.compress(tc_name, tc_output)
+
             # Collect tool call info and result
             tool_call_info = {
                 "name": tc_name,

{zwarm-3.10.3 → zwarm-3.10.5}/src/zwarm/prompts/orchestrator.py

@@ -48,16 +48,18 @@ You command executor agents - capable coding agents that handle specific tasks.
 
 **converse(session_id, message)** - Send follow-up to an executor. Returns immediately.
 
-**peek_session(session_id)** - Quick poll: {is_running, status}. Use in polling loops.
-
-**check_session(session_id)** - Get FULL result. Complete response, tokens, runtime.
+**list_sessions(status=None)** - Dashboard of all executors. Shows status, preview, and `needs_attention` flag.
+  - `status`: Filter by "running", "completed", "failed", or None for all
+  - Use this to check which sessions are done before calling check_session.
 
-**get_trajectory(session_id, full=False)** - See what steps the agent took.
-  - `full=True`: Complete untruncated details (debugging)
-  - `full=False`: Concise summaries (default)
+**check_session(session_id, latest=True)** - Get session result.
+  - `latest=True` (default): Only the latest response (keeps context small)
+  - `latest=False`: Full conversation history
+  - Returns: status, response, tokens, runtime
 
-**list_sessions(status=None)** - See all executors. `needs_attention=True` = ready for review.
-  - `status`: Filter by "running", "completed", "failed", or None for all
+**get_trajectory(session_id)** - Debug tool: see step-by-step what the agent did.
+  - Use when a session failed or went off-rails to understand what happened.
+  - Returns concise summaries of each step.
 
 **end_session(session_id, reason=None, delete=False)** - End an executor.
   - `delete=True`: Remove from list entirely
@@ -81,9 +83,9 @@ All executor sessions run in the background. delegate() and converse() return im
 ```
 1. delegate(task, model="5.2") → session_id
 2. sleep(30)
-3. peek_session(id) → done?
-4. If running, goto 2
-5. check_session(id) → FULL result
+3. list_sessions() → check needs_attention
+4. If still running, goto 2
+5. check_session(id) → get result
 ```
 
 **Parallel work:**
@@ -91,8 +93,8 @@ All executor sessions run in the background. delegate() and converse() return im
 1. delegate(task1) → session_a
 2. delegate(task2) → session_b
 3. sleep(30)
-4. list_sessions() → see needs_attention
-5. check_session() for each done
+4. list_sessions() → see which have needs_attention=True
+5. check_session(id) for each done
 6. Repeat until all complete
 ```
 

{zwarm-3.10.3 → zwarm-3.10.5}/src/zwarm/prompts/pilot.py

@@ -54,16 +54,18 @@ You command executor agents - capable coding agents that do specific tasks. Thin
 
 **converse(session_id, message)** - Send follow-up to a crew member. Returns immediately.
 
-**peek_session(session_id)** - Quick status check. Use for polling: {is_running, status}
-
-**check_session(session_id)** - Get FULL result. Complete response, tokens, runtime.
+**list_sessions(status=None)** - Dashboard of all crew. Shows status, preview, and `needs_attention` flag.
+  - `status`: Filter by "running", "completed", "failed", or None for all
+  - Use this to check which sessions are done before calling check_session.
 
-**get_trajectory(session_id, full=False)** - See what steps the agent took.
-  - `full=True`: Show complete untruncated content for all steps (debugging)
-  - `full=False`: Concise summaries (default)
+**check_session(session_id, latest=True)** - Get session result.
+  - `latest=True` (default): Only the latest response (keeps context small)
+  - `latest=False`: Full conversation history
+  - Returns: status, response, tokens, runtime
 
-**list_sessions(status=None)** - See all crew. `needs_attention=True` means ready for review.
-  - `status`: Filter by "running", "completed", "failed", or None for all
+**get_trajectory(session_id)** - Debug tool: see step-by-step what the agent did.
+  - Use when a session failed or went off-rails to understand what happened.
+  - Returns concise summaries of each step (reasoning, commands, tool calls).
 
 **end_session(session_id, reason=None, delete=False)** - Dismiss a crew member.
   - `reason`: Optional note about why
@@ -80,9 +82,9 @@ NOTE: Only use the tools listed above. Do NOT use `list_agents`, `run_agent`, `e
 ```
 1. delegate(task, model="5.2") → session_id   # or model="opus" for complex tasks
 2. sleep(30)
-3. peek_session(id) → done?
-4. If running, goto 2
-5. check_session(id) → FULL result
+3. list_sessions() → see which are done (needs_attention=True)
+4. If all still running, goto 2
+5. check_session(id) → get the result
 ```
 
 Parallelize freely - dispatch multiple crew, sleep, check which finished.

{zwarm-3.10.3 → zwarm-3.10.5}/src/zwarm/tools/delegation.py

@@ -34,17 +34,43 @@ if TYPE_CHECKING:
 ADAPTERS = ["codex", "claude"]
 
 
-def _get_session_manager(orchestrator: "Orchestrator"):
+def _get_all_adapter_managers(orchestrator: "Orchestrator") -> dict:
     """
-    Get the default session manager for list/get operations.
+    Get session managers for ALL adapters.
 
-    Uses CodexSessionManager as the default since all adapters share
-    the same .zwarm/sessions/ directory structure.
+    This ensures we can find sessions regardless of which adapter created them.
+    Returns a dict of {adapter_name: manager}.
     """
-    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
+    # Initialize adapter managers dict if needed
+    if not hasattr(orchestrator, "_adapter_managers"):
+        orchestrator._adapter_managers = {}
+
+    # Ensure all adapters have managers
+    from zwarm.sessions import get_session_manager
+    for adapter in ADAPTERS:
+        if adapter not in orchestrator._adapter_managers:
+            manager = get_session_manager(adapter, str(orchestrator.working_dir / ".zwarm"))
+            orchestrator._adapter_managers[adapter] = manager
+
+    return orchestrator._adapter_managers
+
+
+def _get_session_with_manager(orchestrator: "Orchestrator", session_id: str):
+    """
+    Find a session across all adapters and return (session, manager).
+
+    Since sessions are adapter-scoped, we need to check each adapter's
+    manager to find where the session lives.
+
+    Returns:
+        (session, manager) if found, (None, None) if not found
+    """
+    managers = _get_all_adapter_managers(orchestrator)
+    for adapter, manager in managers.items():
+        session = manager.get_session(session_id)
+        if session:
+            return session, manager
+    return None, None
 
 
 def _get_adapter_manager(orchestrator: "Orchestrator", adapter: str):
@@ -177,7 +203,7 @@ def delegate(
     WORKFLOW:
         1. delegate(task="...", model="5.2") -> session_id
         2. sleep(30)
-        3. peek_session(session_id) -> {is_running: true/false}
+        3. list_sessions() -> check which are done (needs_attention=True)
         4. If is_running, goto 2
         5. check_session(session_id) -> FULL response
 
@@ -295,9 +321,8 @@ def converse(
         sleep(30)
         check_session(session_id)  # Get response
     """
-    # First get session to determine adapter
-    default_manager = _get_session_manager(self)
-    session = default_manager.get_session(session_id)
+    # Find session across all adapters
+    session, manager = _get_session_with_manager(self, session_id)
 
     if not session:
         return {
@@ -322,9 +347,8 @@ def converse(
             "hint": "Start a new session with delegate()",
         }
 
-    # Get the correct adapter manager for this session
+    # Use the manager that found the session (correct adapter)
     adapter = getattr(session, "adapter", "codex")
-    manager = _get_adapter_manager(self, adapter)
 
     # Inject the follow-up message
     # This uses the adapter's inject_message() which:
@@ -356,25 +380,22 @@ def converse(
 def check_session(
     self: "Orchestrator",
     session_id: str,
+    latest: bool = True,
 ) -> dict[str, Any]:
     """
-    Check the status of a session and get the FULL response.
+    Check the status of a session and get the response.
 
     This is your primary tool for seeing what an executor accomplished.
-    Returns the complete, untruncated response from the agent.
-
-    Use this after peek_session() shows the session is done, or when
-    you need to see the full details of what was accomplished.
 
     Args:
         session_id: The session to check.
+        latest: If True (default), only return the latest assistant message.
+                If False, return full conversation history.
 
     Returns:
-        {session_id, status, response (FULL), tokens, runtime}
+        {session_id, status, response, tokens, runtime}
     """
-    manager = _get_session_manager(self)
-
-    session = manager.get_session(session_id)
+    session, manager = _get_session_with_manager(self, session_id)
     if not session:
         return {
             "success": False,
@@ -382,13 +403,22 @@ def check_session(
             "hint": "Use list_sessions() to see available sessions",
         }
 
-    # Get latest response - FULL, not truncated
-    response_text = ""
     messages = manager.get_messages(session_id)
-    for msg in reversed(messages):
-        if msg.role == "assistant":
-            response_text = msg.content  # Full content, no truncation
-            break
+
+    if latest:
+        # Only get the latest assistant message
+        response_text = ""
+        for msg in reversed(messages):
+            if msg.role == "assistant":
+                response_text = msg.content
+                break
+        response_content = response_text if response_text else "(no response yet)"
+    else:
+        # Return full conversation history
+        response_content = [
+            {"role": msg.role, "content": msg.content}
+            for msg in messages
+        ]
 
     # Build log path
     log_path = str(manager._output_path(session.id, session.turn))
@@ -401,8 +431,8 @@ def check_session(
         "is_running": session.is_running,
         "turn": session.turn,
         "message_count": len(messages),
-        "task": _truncate(session.task, 80),  # Task can stay truncated
-        "response": response_text if response_text else "(no response yet)",  # FULL response
+        "task": _truncate(session.task, 80),
+        "response": response_content,
         "tokens": _get_total_tokens(session),
         "runtime": session.runtime,
         "log_file": log_path,
@@ -417,51 +447,6 @@ def check_session(
     return result
 
 
-@weaveTool
-def peek_session(
-    self: "Orchestrator",
-    session_id: str,
-) -> dict[str, Any]:
-    """
-    Quick peek at a session - minimal info for FAST POLLING.
-
-    Use this in your polling loop to check if a session is done:
-        1. delegate() -> start work
-        2. sleep(30)
-        3. peek_session() -> is_running? If yes, goto 2
-        4. check_session() -> get FULL response
-
-    Returns truncated preview only. Once done, use check_session() for full response.
-
-    Args:
-        session_id: The session to peek at.
-
-    Returns:
-        {session_id, status, is_running, latest_message (truncated preview)}
-    """
-    manager = _get_session_manager(self)
-
-    session = manager.get_session(session_id)
-    if not session:
-        return {"success": False, "error": f"Unknown session: {session_id}"}
-
-    # Get latest assistant message only
-    latest = ""
-    messages = manager.get_messages(session_id)
-    for msg in reversed(messages):
-        if msg.role == "assistant":
-            latest = msg.content.replace("\n", " ")
-            break
-
-    return {
-        "success": True,
-        "session_id": session.short_id,
-        "status": session.status.value,
-        "is_running": session.status.value == "running",
-        "latest_message": _truncate(latest, 150) if latest else None,
-    }
-
-
 @weaveTool
 def get_trajectory(
     self: "Orchestrator",
@@ -487,9 +472,7 @@ def get_trajectory(
     - check_session() -> what did the agent conclude? (FULL response)
     - get_trajectory() -> what steps did the agent take? (step-by-step)
     """
-    manager = _get_session_manager(self)
-
-    session = manager.get_session(session_id)
+    session, manager = _get_session_with_manager(self, session_id)
     if not session:
         return {"success": False, "error": f"Unknown session: {session_id}"}
 
@@ -565,9 +548,7 @@ def end_session(
     Returns:
         {session_id, status}
     """
-    manager = _get_session_manager(self)
-
-    session = manager.get_session(session_id)
+    session, manager = _get_session_with_manager(self, session_id)
     if not session:
         return {
             "success": False,
@@ -594,7 +575,7 @@ def end_session(
                 "session_id": session_id,
             }
 
-        # Refresh
+        # Refresh - use same manager
         session = manager.get_session(session_id)
 
     return {
@@ -633,7 +614,8 @@ def list_sessions(
     """
     from datetime import datetime
 
-    manager = _get_session_manager(self)
+    # Get managers for ALL adapters to aggregate sessions
+    managers = _get_all_adapter_managers(self)
 
     # Map string status to enum
     from zwarm.sessions import SessionStatus
@@ -648,7 +630,13 @@ def list_sessions(
         }
         status_filter = status_map.get(status.lower())
 
-    sessions = manager.list_sessions(status=status_filter)
+    # Aggregate sessions from ALL adapters
+    sessions = []
+    for manager in managers.values():
+        sessions.extend(manager.list_sessions(status=status_filter))
+
+    # Sort by created_at descending (newest first)
+    sessions.sort(key=lambda s: s.created_at, reverse=True)
 
     def time_ago(iso_str: str) -> tuple[str, float]:
         """Convert ISO timestamp to ('Xm ago', seconds)."""
@@ -681,13 +669,16 @@ def list_sessions(
 
         updated_str, updated_secs = time_ago(s.updated_at)
 
-        # Get last assistant message
-        messages = manager.get_messages(s.id)
+        # Get last assistant message using the correct adapter's manager
+        session_adapter = getattr(s, "adapter", "codex")
+        session_manager = managers.get(session_adapter)
         last_message = ""
-        for msg in reversed(messages):
-            if msg.role == "assistant":
-                last_message = msg.content.replace("\n", " ")
-                break
+        if session_manager:
+            messages = session_manager.get_messages(s.id)
+            for msg in reversed(messages):
+                if msg.role == "assistant":
+                    last_message = msg.content.replace("\n", " ")
+                    break
 
         # Flag sessions that need attention:
         # - Recently completed (< 60s)
@@ -739,10 +730,11 @@ def sleep(self, seconds: float) -> dict[str, Any]:
     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
+    1. delegate(task) -> start background work
+    2. sleep(30) -> wait a bit
+    3. list_sessions() -> check which are done (needs_attention=True)
     4. Repeat 2-3 if still running
+    5. check_session(id) -> get result
 
     Args:
         seconds: Number of seconds to sleep (max 300 = 5 minutes)

{zwarm-3.10.3 → zwarm-3.10.5}/src/zwarm/watchers/llm_watcher.py

@@ -58,7 +58,7 @@ def _extract_tool_call_summary(tc: Any) -> str:
         elif name == "bash":
             cmd = args.get("command", "")[:60]
             return f"$ {cmd}"
-        elif name in ("check_session", "peek_session", "end_session"):
+        elif name in ("check_session", "end_session"):
             sid = args.get("session_id", "")[:8]
             return f"{name}({sid})"
         elif name == "list_sessions":