zwarm 3.10.2__tar.gz → 3.10.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zwarm
-Version: 3.10.2
+Version: 3.10.5
 Summary: Multi-Agent CLI Orchestration Research Platform
 Requires-Python: <3.14,>=3.13
 Requires-Dist: prompt-toolkit>=3.0.52
@@ -87,14 +87,18 @@ Want a 3-minute walkthrough? See `docs/DEMO.md` for a pilot + interactive demo.
 
 ## Multi-Adapter Support
 
-zwarm supports multiple executor backends:
+zwarm supports multiple executor backends with simple model shortcuts:
 
-| Adapter | CLI | Models | Config |
-|---------|-----|--------|--------|
-| **Codex** | `codex` | gpt-5.1-codex-mini, etc. | `.zwarm/codex.toml` |
-| **Claude** | `claude` | sonnet, opus, haiku | `.zwarm/claude.toml` |
+| Model | Alias | Description |
+|-------|-------|-------------|
+| `gpt-5.2-codex` | `5.2` | GPT-5.2 Codex - fast, great for code (default) |
+| `gpt-5.2` | `5.2-think` | GPT-5.2 with extended reasoning |
+| `sonnet` | - | Claude Sonnet - balanced |
+| `opus` | - | Claude Opus - most capable |
 
-You can mix adapters in the same session - for example, use Claude Opus for complex reasoning tasks and Codex Mini for quick edits.
+**Adapter is auto-detected from model name** - just use `model="opus"` and zwarm handles the rest.
+
+Mix models freely - use Opus for complex reasoning, 5.2 for quick edits.
 
 ---
 
@@ -184,7 +188,7 @@ zwarm interactive
 
 | Command | Description |
 |---------|-------------|
-| `spawn "task" [--search]` | Start a new session (--search enables web) |
+| `spawn "task" [--model M]` | Start a new session (model: 5.2, opus, sonnet) |
 | `ls` | Dashboard of all sessions (with costs, models) |
 | `? ID` / `peek ID` | Quick status check |
 | `show ID` | Full session details |
@@ -213,8 +217,8 @@ $ zwarm interactive
 ⟳ 2 running
 
 ID       │    │ Task                          │ Model        │ Tokens  │ Cost
-abc123   │ ⟳  │ Add tests for the auth...     │ codex-mini   │ 5,234   │ $0.052
-def456   │ ⟳  │ Fix type errors in utils...   │ codex-mini   │ 2,100   │ $0.021
+abc123   │ ⟳  │ Add tests for the auth...     │ 5.2-codex   │ 5,234   │ $0.052
+def456   │ ⟳  │ Fix type errors in utils...   │ 5.2-codex   │ 2,100   │ $0.021
 
 > watch abc123
 Watching abc123... (Ctrl+C to stop)
@@ -254,17 +258,20 @@ The orchestrator LLM has access to:
 
 | Tool | Description |
 |------|-------------|
-| `delegate(task, adapter="codex")` | Start a new coding session |
+| `delegate(task, model="5.2")` | Start a new coding session |
 | `converse(id, msg)` | Continue a session |
 | `check_session(id)` | Get full session details |
 | `peek_session(id)` | Quick status check |
+| `get_trajectory(id)` | See what steps the agent took |
 | `list_sessions()` | List all sessions |
 | `end_session(id)` | Kill/delete a session |
 | `sleep(seconds)` | Wait before checking again |
+| `bash(cmd)` | Run verification commands (tests, linters) |
+| `exit()` | Signal task completion |
 
 **Async-first**: All sessions run in the background. The orchestrator uses `sleep()` to wait, then checks on progress.
 
-**Multi-adapter**: Pass `adapter="claude"` or `adapter="codex"` to `delegate()` to choose the backend.
+**Model shortcuts**: Just use `model="5.2"` or `model="opus"` - the adapter is auto-detected.
 
 **Web Search**: Enable `web_search=True` in config for tasks needing current info (API docs, latest releases, etc.).
 
@@ -361,14 +368,14 @@ enabled = ["progress", "budget", "delegation", "delegation_reminder"]
 
 **`.zwarm/codex.toml`** - Controls the Codex CLI:
 ```toml
-model = "gpt-5.1-codex-mini"
+model = "gpt-5.2-codex"  # or gpt-5.2 for extended reasoning
 model_reasoning_effort = "high"  # low | medium | high
-full_auto = true
+full_danger = true  # Skip approval prompts
 ```
 
 **`.zwarm/claude.toml`** - Controls the Claude Code CLI:
 ```toml
-model = "sonnet"  # sonnet | opus | haiku
+model = "opus"  # opus | sonnet
 full_danger = true  # Skip permission prompts
 ```
 

{zwarm-3.10.2 → zwarm-3.10.5}/README.md

@@ -73,14 +73,18 @@ Want a 3-minute walkthrough? See `docs/DEMO.md` for a pilot + interactive demo.
 
 ## Multi-Adapter Support
 
-zwarm supports multiple executor backends:
+zwarm supports multiple executor backends with simple model shortcuts:
 
-| Adapter | CLI | Models | Config |
-|---------|-----|--------|--------|
-| **Codex** | `codex` | gpt-5.1-codex-mini, etc. | `.zwarm/codex.toml` |
-| **Claude** | `claude` | sonnet, opus, haiku | `.zwarm/claude.toml` |
+| Model | Alias | Description |
+|-------|-------|-------------|
+| `gpt-5.2-codex` | `5.2` | GPT-5.2 Codex - fast, great for code (default) |
+| `gpt-5.2` | `5.2-think` | GPT-5.2 with extended reasoning |
+| `sonnet` | - | Claude Sonnet - balanced |
+| `opus` | - | Claude Opus - most capable |
 
-You can mix adapters in the same session - for example, use Claude Opus for complex reasoning tasks and Codex Mini for quick edits.
+**Adapter is auto-detected from model name** - just use `model="opus"` and zwarm handles the rest.
+
+Mix models freely - use Opus for complex reasoning, 5.2 for quick edits.
 
 ---
 
@@ -170,7 +174,7 @@ zwarm interactive
 
 | Command | Description |
 |---------|-------------|
-| `spawn "task" [--search]` | Start a new session (--search enables web) |
+| `spawn "task" [--model M]` | Start a new session (model: 5.2, opus, sonnet) |
 | `ls` | Dashboard of all sessions (with costs, models) |
 | `? ID` / `peek ID` | Quick status check |
 | `show ID` | Full session details |
@@ -199,8 +203,8 @@ $ zwarm interactive
 ⟳ 2 running
 
 ID       │    │ Task                          │ Model        │ Tokens  │ Cost
-abc123   │ ⟳  │ Add tests for the auth...     │ codex-mini   │ 5,234   │ $0.052
-def456   │ ⟳  │ Fix type errors in utils...   │ codex-mini   │ 2,100   │ $0.021
+abc123   │ ⟳  │ Add tests for the auth...     │ 5.2-codex   │ 5,234   │ $0.052
+def456   │ ⟳  │ Fix type errors in utils...   │ 5.2-codex   │ 2,100   │ $0.021
 
 > watch abc123
 Watching abc123... (Ctrl+C to stop)
@@ -240,17 +244,20 @@ The orchestrator LLM has access to:
 
 | Tool | Description |
 |------|-------------|
-| `delegate(task, adapter="codex")` | Start a new coding session |
+| `delegate(task, model="5.2")` | Start a new coding session |
 | `converse(id, msg)` | Continue a session |
 | `check_session(id)` | Get full session details |
 | `peek_session(id)` | Quick status check |
+| `get_trajectory(id)` | See what steps the agent took |
 | `list_sessions()` | List all sessions |
 | `end_session(id)` | Kill/delete a session |
 | `sleep(seconds)` | Wait before checking again |
+| `bash(cmd)` | Run verification commands (tests, linters) |
+| `exit()` | Signal task completion |
 
 **Async-first**: All sessions run in the background. The orchestrator uses `sleep()` to wait, then checks on progress.
 
-**Multi-adapter**: Pass `adapter="claude"` or `adapter="codex"` to `delegate()` to choose the backend.
+**Model shortcuts**: Just use `model="5.2"` or `model="opus"` - the adapter is auto-detected.
 
 **Web Search**: Enable `web_search=True` in config for tasks needing current info (API docs, latest releases, etc.).
 
@@ -347,14 +354,14 @@ enabled = ["progress", "budget", "delegation", "delegation_reminder"]
 
 **`.zwarm/codex.toml`** - Controls the Codex CLI:
 ```toml
-model = "gpt-5.1-codex-mini"
+model = "gpt-5.2-codex"  # or gpt-5.2 for extended reasoning
 model_reasoning_effort = "high"  # low | medium | high
-full_auto = true
+full_danger = true  # Skip approval prompts
 ```
 
 **`.zwarm/claude.toml`** - Controls the Claude Code CLI:
 ```toml
-model = "sonnet"  # sonnet | opus | haiku
+model = "opus"  # opus | sonnet
 full_danger = true  # Skip permission prompts
 ```
 

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

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

{zwarm-3.10.2 → zwarm-3.10.5}/src/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-3.10.2 → zwarm-3.10.5}/src/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-3.10.2 → zwarm-3.10.5}/src/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-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)