zwarm 3.4.0__py3-none-any.whl → 3.7.0__py3-none-any.whl

zwarm/cli/main.py

@@ -299,7 +299,8 @@ def pilot(
     config: Annotated[Optional[Path], typer.Option("--config", "-c", help="Path to config YAML")] = None,
     overrides: Annotated[Optional[list[str]], typer.Option("--set", help="Override config (key=value)")] = None,
     working_dir: Annotated[Path, typer.Option("--working-dir", "-w", help="Working directory")] = Path("."),
-    instance: Annotated[Optional[str], typer.Option("--instance", "-i", help="Instance ID (for isolation)")] = None,
+    resume: Annotated[bool, typer.Option("--resume", help="Resume from previous state")] = False,
+    instance: Annotated[Optional[str], typer.Option("--instance", "-i", help="Instance ID (for isolation/resume)")] = None,
     instance_name: Annotated[Optional[str], typer.Option("--name", "-n", help="Human-readable instance name")] = None,
     model: Annotated[PilotLM, typer.Option("--model", "-m", help="LM to use")] = PilotLM.gpt5_verbose,
 ):
@@ -341,19 +342,30 @@ def pilot(
 
         [dim]# Named instance[/]
         $ zwarm pilot --name my-feature
+
+        [dim]# Resume a previous session[/]
+        $ zwarm pilot --resume --instance abc123
     """
     from zwarm.cli.pilot import run_pilot, build_pilot_orchestrator
 
     # Resolve task (optional for pilot)
     resolved_task = _resolve_task(task, task_file)
 
-    console.print(f"[bold]Starting pilot session...[/]")
+    # Validate resume requirements
+    if resume and not instance:
+        console.print("[red]Error:[/] --resume requires --instance to specify which session to resume")
+        console.print("  [dim]Use 'zwarm instances' to list available instances[/]")
+        raise typer.Exit(1)
+
+    console.print(f"[bold]{'Resuming' if resume else 'Starting'} pilot session...[/]")
     console.print(f"  Working dir: {working_dir.absolute()}")
     console.print(f"  Model: {model.value}")
     if resolved_task:
         console.print(f"  Initial task: {resolved_task[:60]}...")
     if instance:
         console.print(f"  Instance: {instance}" + (f" ({instance_name})" if instance_name else ""))
+    if resume:
+        console.print(f"  [yellow]Resuming from saved state...[/]")
     console.print()
 
     orchestrator = None
@@ -371,6 +383,12 @@ def pilot(
         if orchestrator.instance_id and not instance:
             console.print(f"  [dim]Instance: {orchestrator.instance_id[:8]}[/]")
 
+        # Resume from saved state if requested
+        if resume:
+            orchestrator.load_state()
+            msg_count = len(orchestrator.messages)
+            console.print(f"  [green]✓[/] Resumed with {msg_count} messages")
+
         # Run the pilot REPL
         run_pilot(orchestrator, initial_task=resolved_task)
 
@@ -917,6 +935,23 @@ def init(
         codex_toml_path.write_text(codex_content)
         console.print(f"  [green]✓[/] Created .zwarm/codex.toml")
 
+    # Create claude.toml for isolated Claude Code configuration
+    claude_toml_path = state_dir / "claude.toml"
+    write_claude_toml = True
+    if claude_toml_path.exists():
+        if not non_interactive:
+            overwrite_claude = typer.confirm("  .zwarm/claude.toml exists. Overwrite?", default=False)
+            if not overwrite_claude:
+                write_claude_toml = False
+                console.print("  [dim]Skipping claude.toml[/]")
+        else:
+            write_claude_toml = False  # Don't overwrite in non-interactive mode
+
+    if write_claude_toml:
+        claude_content = _generate_claude_toml(model="sonnet")
+        claude_toml_path.write_text(claude_content)
+        console.print(f"  [green]✓[/] Created .zwarm/claude.toml")
+
     # Create zwarm.yaml
     if create_project_config:
         if zwarm_yaml_path.exists() and not non_interactive:
@@ -959,41 +994,87 @@ def _generate_config_toml(
     adapter: str = "codex_mcp",
     watchers: list[str] | None = None,
 ) -> str:
-    """Generate config.toml content."""
+    """Generate config.toml content with all options at their defaults."""
     watchers = watchers or []
 
     lines = [
         "# zwarm configuration",
         "# Generated by 'zwarm init'",
+        "# All values shown are defaults - uncomment and modify as needed",
         "",
+        "# ============================================================================",
+        "# Weave Integration (optional tracing/observability)",
+        "# ============================================================================",
         "[weave]",
     ]
 
     if weave_project:
         lines.append(f'project = "{weave_project}"')
     else:
-        lines.append("# project = \"your-entity/your-project\"  # Uncomment to enable Weave tracing")
+        lines.append('# project = "your-entity/your-project"  # Uncomment to enable Weave tracing')
 
     lines.extend([
+        "enabled = true",
         "",
+        "# ============================================================================",
+        "# Orchestrator Settings",
+        "# ============================================================================",
         "[orchestrator]",
-        "max_steps = 50",
+        '# lm = "gpt-5-mini"                    # LLM for orchestrator (gpt-5-mini, gpt-5, claude-sonnet-4)',
+        "max_steps = 50                         # Max steps for orchestrate command",
+        "max_steps_per_turn = 60                # Max steps per turn in pilot mode",
+        "parallel_delegations = 4               # Max concurrent delegations",
+        '# prompt = "path/to/prompt.yaml"       # Custom prompt file (optional)',
+        '# allowed_dirs = ["*"]                 # Directories agent can delegate to (default: working_dir only)',
+        "",
+        "# Context window compaction (prevents overflow on long tasks)",
+        "[orchestrator.compaction]",
+        "enabled = true",
+        "max_tokens = 100000                    # Trigger compaction above this",
+        "threshold_pct = 0.85                   # Compact when at this % of max_tokens",
+        "target_pct = 0.7                       # Target this % after compaction",
+        "keep_first_n = 2                       # Always keep first N messages (system + task)",
+        "keep_last_n = 10                       # Always keep last N messages (recent context)",
         "",
+        "# ============================================================================",
+        "# Executor Settings (codex agent configuration)",
+        "# ============================================================================",
         "[executor]",
-        f'adapter = "{adapter}"',
-        "# model = \"\"  # Optional model override",
-        "# web_search = false  # Enable web search for delegated sessions",
+        f'adapter = "{adapter}"                  # codex_mcp | codex_exec | claude_code',
+        '# model = "gpt-5.1-codex-mini"         # Model for delegated sessions (uses codex.toml default if not set)',
+        'sandbox = "workspace-write"            # read-only | workspace-write | danger-full-access',
+        "timeout = 3600                         # Session timeout in seconds",
+        'reasoning_effort = "high"              # low | medium | high',
         "",
+        "# ============================================================================",
+        "# Watchers (automated monitoring and nudges)",
+        "# ============================================================================",
         "[watchers]",
-        f"enabled = {watchers}",
+        f"enabled = {str(bool(watchers)).lower()}",
+        'message_role = "user"                  # Role for nudge messages: user | assistant | system',
         "",
-        "# Watcher-specific configuration",
-        "# [watchers.budget]",
-        "# max_steps = 50",
+        "# Default watchers: progress, budget, delegation_reminder",
+        "# Uncomment below to customize:",
+        "",
+        "# [[watchers.watchers]]",
+        '# name = "progress"',
+        "# enabled = true",
+        "",
+        "# [[watchers.watchers]]",
+        '# name = "budget"',
+        "# enabled = true",
+        "# [watchers.watchers.config]",
+        "# max_sessions = 10",
         "# warn_at_percent = 80",
         "",
-        "# [watchers.pattern]",
-        "# patterns = [\"DROP TABLE\", \"rm -rf\"]",
+        "# [[watchers.watchers]]",
+        '# name = "delegation_reminder"',
+        "# enabled = true",
+        "",
+        "# ============================================================================",
+        "# State Directory",
+        "# ============================================================================",
+        '# state_dir = ".zwarm"                 # Where to store session data',
         "",
     ])
 
@@ -1042,6 +1123,38 @@ def _generate_codex_toml(
     return "\n".join(lines)
 
 
+def _generate_claude_toml(
+    model: str = "sonnet",
+) -> str:
+    """
+    Generate claude.toml for isolated Claude Code configuration.
+
+    This file is parsed by zwarm and settings are passed to claude via CLI flags.
+    Each .zwarm directory has its own claude config.
+    """
+    lines = [
+        "# Claude Code configuration for zwarm",
+        "# zwarm parses this file and passes settings to claude via CLI flags",
+        "# Each .zwarm dir has its own config",
+        "# Generated by 'zwarm init'",
+        "",
+        "# Model settings",
+        f'model = "{model}"  # sonnet | opus | haiku',
+        "",
+        "# DANGER MODE - bypasses all permission checks",
+        "# Set to true to use --dangerously-skip-permissions",
+        "full_danger = true",
+        "",
+        "# Note: Claude Code uses different CLI flags than Codex",
+        "# Common options:",
+        "#   --model <model>         Model to use (sonnet, opus, haiku)",
+        "#   --add-dir <path>        Additional directories to allow",
+        "#   --allowed-tools <tools> Restrict available tools",
+        "",
+    ]
+    return "\n".join(lines)
+
+
 def _generate_zwarm_yaml(
     description: str = "",
     context: str = "",

zwarm/cli/pilot.py

@@ -81,14 +81,23 @@ class ChoogingSpinner:
 
 
 # Context window sizes for different models (in tokens)
+# These are for the ORCHESTRATOR LLM, not the executors
 MODEL_CONTEXT_WINDOWS = {
+    # OpenAI models
     "gpt-5.1-codex": 200_000,
     "gpt-5.1-codex-mini": 200_000,
     "gpt-5.1-codex-max": 400_000,
     "gpt-5": 200_000,
     "gpt-5-mini": 200_000,
-    "claude-sonnet-4": 200_000,
-    "claude-opus-4": 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,
+    "sonnet": 200_000,
+    "opus": 200_000,
+    "haiku": 200_000,
     # Fallback
     "default": 128_000,
 }
@@ -204,11 +213,12 @@ def build_pilot_orchestrator(
     # Build pilot system prompt
     system_prompt = get_pilot_prompt(working_dir=str(working_dir))
 
-    # Create lean orchestrator environment
+    # Create lean orchestrator environment (pilot mode = simpler observation)
     env = OrchestratorEnv(
         task="",  # No task - pilot is conversational
         working_dir=working_dir,
     )
+    env.set_pilot_mode(True)  # Human is in control, use lean observation
 
     # Create orchestrator with ONLY delegation tools (no bash)
     orchestrator = Orchestrator(
@@ -612,6 +622,15 @@ def execute_step_with_events(
     # Execute invoke (calls LLM)
     response = orchestrator.invoke()
 
+    # Track cumulative token usage from the API response
+    # (This mirrors what step() does in orchestrator.py)
+    if hasattr(orchestrator, "_last_response") and orchestrator._last_response:
+        last_response = orchestrator._last_response
+        if hasattr(last_response, "usage") and last_response.usage:
+            usage = last_response.usage
+            tokens_this_call = getattr(usage, "total_tokens", 0)
+            orchestrator._total_tokens = getattr(orchestrator, "_total_tokens", 0) + tokens_this_call
+
     # Extract and render events from response
     if response:
         events = extract_events_from_response(response)
@@ -739,7 +758,12 @@ def print_help(renderer: EventRenderer) -> None:
         "  :goto <turn|root>    Jump to a prior turn (e.g., :goto T1)",
         "  :sessions            Show executor sessions",
         "  :reasoning [on|off]  Toggle reasoning display",
-        "  :quit / :exit        Exit the pilot",
+        "  :save                Save state (for later resume)",
+        "  :quit / :exit        Exit the pilot (auto-saves)",
+        "",
+        "Resume:",
+        "  State is auto-saved after each turn. To resume a session:",
+        "  $ zwarm pilot --resume --instance <instance_id>",
         "",
         "Multiline input:",
         '  Start with """ and end with """ to enter multiple lines.',
@@ -943,6 +967,10 @@ def _run_pilot_repl(
 
             # :quit / :exit
             if cmd in ("quit", "exit", "q"):
+                # Save state before exiting
+                if hasattr(orchestrator, "save_state"):
+                    orchestrator.save_state()
+                    renderer.status("[dim]State saved.[/]")
                 renderer.status("Goodbye!")
                 break
 
@@ -1135,6 +1163,20 @@ def _run_pilot_repl(
                 renderer.status(f"Reasoning display: {current}")
                 continue
 
+            # :save
+            if cmd == "save":
+                if hasattr(orchestrator, "save_state"):
+                    orchestrator.save_state()
+                    instance_id = getattr(orchestrator, "instance_id", None)
+                    if instance_id:
+                        renderer.status(f"[green]✓[/] State saved (instance: {instance_id[:8]})")
+                        renderer.status(f"  [dim]Resume with: zwarm pilot --resume --instance {instance_id[:8]}[/]")
+                    else:
+                        renderer.status("[green]✓[/] State saved")
+                else:
+                    renderer.error("State saving not available")
+                continue
+
             # Unknown command
             renderer.error(f"Unknown command: {cmd}")
             renderer.status("Type :help for available commands.")
@@ -1175,6 +1217,10 @@ def _run_pilot_repl(
             },
         )
 
+        # Save state for resume capability
+        if hasattr(orchestrator, "save_state"):
+            orchestrator.save_state()
+
         # Show turn info
         cp = state.current()
         if cp:
@@ -1190,4 +1236,6 @@ def _run_pilot_repl(
         if hasattr(orchestrator, "stopCondition") and orchestrator.stopCondition:
             renderer.status("")
             renderer.status("Orchestrator signaled completion.")
+            if hasattr(orchestrator, "save_state"):
+                orchestrator.save_state()
             break

zwarm/core/costs.py

@@ -1,109 +1,42 @@
 """
 Token cost estimation for LLM models.
 
-Pricing data is hardcoded and may become stale. Last updated: 2026-01.
+This module re-exports from the centralized model registry.
+For adding new models, edit: zwarm/core/registry.py
 
-Sources:
-- https://www.helicone.ai/llm-cost/provider/openai/model/gpt-5.1-codex
-- https://pricepertoken.com/pricing-page/model/openai-codex-mini
+Backwards-compatible API preserved for existing code.
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any
-
-
-@dataclass
-class ModelPricing:
-    """Pricing for a model in $ per million tokens."""
-    input_per_million: float
-    output_per_million: float
-    cached_input_per_million: float | None = None  # Some models have cached input discount
-
-    def estimate_cost(
-        self,
-        input_tokens: int,
-        output_tokens: int,
-        cached_tokens: int = 0,
-    ) -> float:
-        """
-        Estimate cost in dollars.
-
-        Args:
-            input_tokens: Number of input tokens
-            output_tokens: Number of output tokens
-            cached_tokens: Number of cached input tokens (if applicable)
-
-        Returns:
-            Estimated cost in USD
-        """
-        input_cost = (input_tokens / 1_000_000) * self.input_per_million
-        output_cost = (output_tokens / 1_000_000) * self.output_per_million
-
-        cached_cost = 0.0
-        if cached_tokens and self.cached_input_per_million:
-            cached_cost = (cached_tokens / 1_000_000) * self.cached_input_per_million
-
-        return input_cost + output_cost + cached_cost
-
-
-# Model pricing table ($ per million tokens)
-# Last updated: 2026-01
-MODEL_PRICING: dict[str, ModelPricing] = {
-    # OpenAI Codex models
-    "gpt-5.1-codex": ModelPricing(
-        input_per_million=1.25,
-        output_per_million=10.00,
-        cached_input_per_million=0.125,  # 90% discount for cached
-    ),
-    "gpt-5.1-codex-mini": ModelPricing(
-        input_per_million=0.25,
-        output_per_million=2.00,
-        cached_input_per_million=0.025,
-    ),
-    "gpt-5.1-codex-max": ModelPricing(
-        input_per_million=1.25,
-        output_per_million=10.00,
-        cached_input_per_million=0.125,
-    ),
-    # GPT-5 base models (for reference)
-    "gpt-5": ModelPricing(
-        input_per_million=1.25,
-        output_per_million=10.00,
-    ),
-    "gpt-5-mini": ModelPricing(
-        input_per_million=0.25,
-        output_per_million=2.00,
-    ),
-    # Claude models (Anthropic)
-    "claude-sonnet-4-20250514": ModelPricing(
-        input_per_million=3.00,
-        output_per_million=15.00,
-    ),
-    "claude-opus-4-20250514": ModelPricing(
-        input_per_million=15.00,
-        output_per_million=75.00,
-    ),
-    "claude-3-5-sonnet-20241022": ModelPricing(
-        input_per_million=3.00,
-        output_per_million=15.00,
-    ),
-}
-
-# Aliases for common model names
-MODEL_ALIASES: dict[str, str] = {
-    "codex": "gpt-5.1-codex",
-    "codex-mini": "gpt-5.1-codex-mini",
-    "codex-max": "gpt-5.1-codex-max",
-    "gpt5": "gpt-5",
-    "gpt5-mini": "gpt-5-mini",
-    "sonnet": "claude-sonnet-4-20250514",
-    "opus": "claude-opus-4-20250514",
-}
-
-
-def get_pricing(model: str) -> ModelPricing | None:
+# Re-export everything from registry for backwards compatibility
+from zwarm.core.registry import (
+    ModelInfo,
+    MODELS,
+    resolve_model,
+    get_adapter_for_model,
+    get_default_model,
+    list_models,
+    list_adapters,
+    get_models_help_text,
+    get_models_table_data,
+    estimate_cost,
+    format_cost,
+    estimate_session_cost,
+)
+
+# Backwards compatibility alias
+ModelPricing = ModelInfo
+
+# Legacy aliases for backwards compatibility
+MODEL_PRICING = {m.canonical: m for m in MODELS}
+MODEL_ALIASES = {}
+for m in MODELS:
+    for alias in m.aliases:
+        MODEL_ALIASES[alias] = m.canonical
+
+
+def get_pricing(model: str) -> ModelInfo | None:
     """
     Get pricing for a model.
 
@@ -111,89 +44,28 @@ def get_pricing(model: str) -> ModelPricing | None:
         model: Model name or alias
 
     Returns:
-        ModelPricing or None if unknown
-    """
-    # Check aliases first
-    resolved = MODEL_ALIASES.get(model.lower(), model)
-
-    # Exact match
-    if resolved in MODEL_PRICING:
-        return MODEL_PRICING[resolved]
-
-    # Try lowercase
-    if resolved.lower() in MODEL_PRICING:
-        return MODEL_PRICING[resolved.lower()]
-
-    # Try prefix matching (e.g., "gpt-5.1-codex-mini-2026-01" -> "gpt-5.1-codex-mini")
-    for known_model in MODEL_PRICING:
-        if resolved.lower().startswith(known_model.lower()):
-            return MODEL_PRICING[known_model]
-
-    return None
-
-
-def estimate_cost(
-    model: str,
-    input_tokens: int,
-    output_tokens: int,
-    cached_tokens: int = 0,
-) -> float | None:
+        ModelInfo or None if unknown
     """
-    Estimate cost for a model run.
-
-    Args:
-        model: Model name
-        input_tokens: Number of input tokens
-        output_tokens: Number of output tokens
-        cached_tokens: Number of cached input tokens
-
-    Returns:
-        Cost in USD, or None if model pricing unknown
-    """
-    pricing = get_pricing(model)
-    if pricing is None:
-        return None
-
-    return pricing.estimate_cost(input_tokens, output_tokens, cached_tokens)
-
-
-def format_cost(cost: float | None) -> str:
-    """Format cost as a human-readable string."""
-    if cost is None:
-        return "?"
-    if cost < 0.01:
-        return f"${cost:.4f}"
-    elif cost < 1.00:
-        return f"${cost:.3f}"
-    else:
-        return f"${cost:.2f}"
-
-
-def estimate_session_cost(
-    model: str,
-    token_usage: dict[str, Any],
-) -> dict[str, Any]:
-    """
-    Estimate cost for a session given its token usage.
-
-    Args:
-        model: Model used
-        token_usage: Dict with input_tokens, output_tokens, etc.
-
-    Returns:
-        Dict with cost info: {cost, cost_formatted, pricing_known}
-    """
-    input_tokens = token_usage.get("input_tokens", 0)
-    output_tokens = token_usage.get("output_tokens", 0)
-    cached_tokens = token_usage.get("cached_tokens", 0)
-
-    cost = estimate_cost(model, input_tokens, output_tokens, cached_tokens)
-
-    return {
-        "cost": cost,
-        "cost_formatted": format_cost(cost),
-        "pricing_known": cost is not None,
-        "model": model,
-        "input_tokens": input_tokens,
-        "output_tokens": output_tokens,
-    }
+    return resolve_model(model)
+
+
+__all__ = [
+    # New API
+    "ModelInfo",
+    "MODELS",
+    "resolve_model",
+    "get_adapter_for_model",
+    "get_default_model",
+    "list_models",
+    "list_adapters",
+    "get_models_help_text",
+    "get_models_table_data",
+    "estimate_cost",
+    "format_cost",
+    "estimate_session_cost",
+    # Legacy API
+    "MODEL_PRICING",
+    "MODEL_ALIASES",
+    "ModelPricing",
+    "get_pricing",
+]

zwarm/core/environment.py

@@ -52,6 +52,9 @@ class OrchestratorEnv(Environment):
     # Budget config (set from config)
     _budget_max_sessions: int | None = PrivateAttr(default=None)
 
+    # Pilot mode: simpler observation since human is in control
+    _pilot_mode: bool = PrivateAttr(default=False)
+
     def set_session_manager(self, manager: "CodexSessionManager") -> None:
         """Set the session manager for live session visibility in observe()."""
         self._session_manager = manager
@@ -77,18 +80,69 @@ class OrchestratorEnv(Environment):
         """Set budget limits from config."""
         self._budget_max_sessions = max_sessions
 
+    def set_pilot_mode(self, enabled: bool = True) -> None:
+        """
+        Enable pilot mode for simpler env observation.
+
+        In pilot mode, the human is in control and can use :status/:sessions
+        commands to see detailed progress. The LLM only needs a brief context.
+        """
+        self._pilot_mode = enabled
+
     def observe(self) -> str:
         """
         Return observable state for the orchestrator.
 
-        Shows:
+        In full mode (autonomous orchestrator):
         - Progress (steps, tokens)
         - Session summary (pulled LIVE from CodexSessionManager)
         - Active sessions with their status
         - Working directory
 
+        In pilot mode (human in control):
+        - Brief session status (just what's active)
+        - Working directory
+
         Note: Task is NOT included here as it's already in the user message.
         """
+        if self._pilot_mode:
+            return self._observe_pilot()
+        return self._observe_full()
+
+    def _observe_pilot(self) -> str:
+        """Lean observation for pilot mode (human is in control)."""
+        parts = []
+
+        # Brief session status - just enough for context
+        if self._session_manager is not None:
+            sessions = self._session_manager.list_sessions()
+
+            running = [s for s in sessions if s.status.value == "running"]
+            if running:
+                session_lines = []
+                for s in running:
+                    task_preview = s.task[:40] + "..." if len(s.task) > 40 else s.task
+                    session_lines.append(f"  • {s.short_id}: {task_preview}")
+                parts.append("## Active Sessions\n" + "\n".join(session_lines))
+
+            # Just show counts for completed/failed
+            completed = sum(1 for s in sessions if s.status.value == "completed")
+            failed = sum(1 for s in sessions if s.status.value == "failed")
+            if completed or failed:
+                status = []
+                if completed:
+                    status.append(f"{completed} completed")
+                if failed:
+                    status.append(f"{failed} failed")
+                parts.append(f"Previous: {', '.join(status)}")
+
+        # Working directory
+        parts.append(f"Working dir: {self.working_dir.absolute()}")
+
+        return "\n\n".join(parts) if parts else ""
+
+    def _observe_full(self) -> str:
+        """Full observation for autonomous orchestrator runs."""
         parts = []
 
         # Progress bar and stats