zwarm 3.10.2__py3-none-any.whl → 3.10.5__py3-none-any.whl

zwarm/cli/interactive.py

@@ -269,10 +269,10 @@ def cmd_ls(manager):
         task_preview = s.task[:23] + "..." if len(s.task) > 26 else s.task
         updated = time_ago(s.updated_at)
 
-        # Short model name (e.g., "gpt-5.1-codex-mini" -> "codex-mini")
+        # Short model name (e.g., "gpt-5.2-codex" -> "5.2-codex")
         model_short = s.model or "?"
         if "codex" in model_short.lower():
-            # Extract codex variant: gpt-5.1-codex-mini -> codex-mini
+            # Extract codex variant: gpt-5.2-codex -> 5.2-codex
             parts = model_short.split("-")
             codex_idx = next((i for i, p in enumerate(parts) if "codex" in p.lower()), -1)
             if codex_idx >= 0:

zwarm/cli/main.py

@@ -838,19 +838,17 @@ def init(
         console.print("  [dim]These control the underlying Codex CLI that runs executor sessions[/]\n")
 
         console.print("  Available models:")
-        console.print("    [cyan]1[/] gpt-5.2-codex   [dim]- GPT-5.2 Codex, balanced (Recommended)[/]")
+        console.print("    [cyan]1[/] gpt-5.2-codex   [dim]- GPT-5.2 Codex, fast and balanced (Recommended)[/]")
         console.print("    [cyan]2[/] gpt-5.2         [dim]- GPT-5.2 with extended reasoning[/]")
-        console.print("    [cyan]3[/] gpt-5.1-codex   [dim]- GPT-5.1 Codex (legacy)[/]")
 
         model_choice = typer.prompt(
-            "  Select model (1-3)",
+            "  Select model (1-2)",
             default="1",
             type=str,
         )
         model_map = {
             "1": "gpt-5.2-codex",
             "2": "gpt-5.2",
-            "3": "gpt-5.1-codex",
         }
         codex_model = model_map.get(model_choice, model_choice)
         if model_choice not in model_map:
@@ -1668,7 +1666,7 @@ def session_start(
         $ zwarm session start "Fix the bug in auth.py"
 
         [dim]# With specific model[/]
-        $ zwarm session start "Refactor the API" --model gpt-5.1-codex-max
+        $ zwarm session start "Refactor the API" --model gpt-5.2-codex
 
         [dim]# Web search is always available[/]
         $ zwarm session start "Research latest OAuth2 best practices"

zwarm/cli/pilot.py

@@ -83,22 +83,14 @@ class ChoogingSpinner:
 # Context window sizes for different models (in tokens)
 # These are for the ORCHESTRATOR LLM, not the executors
 MODEL_CONTEXT_WINDOWS = {
-    # OpenAI models
+    # OpenAI models (via Codex CLI)
     "gpt-5.2-codex": 200_000,
     "gpt-5.2": 200_000,
-    "gpt-5.1-codex": 200_000,
-    "gpt-5.1-codex-mini": 200_000,
-    "gpt-5": 200_000,
-    "gpt-5-mini": 200_000,
-    "o3": 200_000,
-    "o3-mini": 200_000,
-    # Claude models (if used as orchestrator)
-    "claude-sonnet": 200_000,
-    "claude-opus": 200_000,
-    "claude-haiku": 200_000,
+    # Claude models (via Claude CLI)
     "sonnet": 200_000,
     "opus": 200_000,
-    "haiku": 200_000,
+    "claude-sonnet": 200_000,
+    "claude-opus": 200_000,
     # Fallback
     "default": 128_000,
 }
@@ -1080,7 +1072,7 @@ def _run_pilot_repl(
                 renderer.status("")
 
                 # Get model from orchestrator if available
-                model = "gpt-5.1-codex"  # Default
+                model = "gpt-5.2-codex"  # Default
                 if hasattr(orchestrator, "lm") and hasattr(orchestrator.lm, "model"):
                     model = orchestrator.lm.model
                 elif hasattr(orchestrator, "config"):

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/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/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/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,