nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/runtime/autopilot.py

@@ -1,1057 +0,0 @@
-"""
-AutopilotEngine - Enterprise-Grade Autonomous Sprint Execution
-Multi-slot parallel orchestration with intelligent task assignment.
-
-Features:
-- 4 sprint modes: auto, plan, guided, status
-- Tier-matched task assignment with load balancing
-- Real-time budget tracking with hard limits
-- 7 halt conditions with graceful handling
-- Mission-based orchestration with lifecycle
-- Checkpoint and recovery support
-- <100ms task assignment latency
-
-Scales: 100+ tasks, 10+ slots, 5 concurrent sprints
-
-Author: NOP V3.1 - January 2026
-"""
-
-import json
-import time
-import threading
-import hashlib
-import os
-from pathlib import Path
-from typing import Dict, List, Optional
-from dataclasses import dataclass, field, asdict
-from enum import Enum
-from datetime import datetime
-
-
-class SprintMode(str, Enum):
-    """Sprint execution modes."""
-    AUTO = "auto"       # Full autonomous execution
-    PLAN = "plan"       # Dry run, show what would happen
-    GUIDED = "guided"   # Pause for approval at each step
-    STATUS = "status"   # Report current state only
-
-
-class SprintStatus(str, Enum):
-    """Sprint execution status."""
-    PENDING = "pending"
-    RUNNING = "running"
-    PAUSED = "paused"
-    COMPLETED = "completed"
-    PARTIAL = "partial"   # Some tasks completed
-    FAILED = "failed"
-    HALTED = "halted"
-
-
-class MissionStatus(str, Enum):
-    """Mission lifecycle status."""
-    PENDING = "pending"
-    PLANNING = "planning"
-    RUNNING = "running"
-    PAUSED = "paused"
-    COMPLETED = "completed"
-    FAILED = "failed"
-
-
-class HaltReason(str, Enum):
-    """Reasons for sprint halt."""
-    BUDGET_EXHAUSTED = "budget_exhausted"
-    ALL_SLOTS_EXHAUSTED = "all_slots_exhausted"
-    CIRCULAR_DEPENDENCY = "circular_dependency"
-    CRITICAL_TASK_FAILED = "critical_task_failed"
-    USER_INTERRUPT = "user_interrupt"
-    TIME_LIMIT = "time_limit"
-    TIER_MISMATCH = "tier_mismatch"
-
-
-@dataclass
-class BudgetState:
-    """Budget tracking state."""
-    limit: float = 0.0
-    spent: float = 0.0
-    reserved: float = 0.0
-    tokens_used: int = 0
-    reservations: Dict[str, float] = field(default_factory=dict)
-    
-    @property
-    def remaining(self) -> float:
-        return max(0, self.limit - self.spent - self.reserved)
-    
-    @property
-    def burn_rate(self) -> float:
-        """Estimate burn rate per hour."""
-        return 0.0  # Calculated from history
-    
-    def can_afford(self, estimated_cost: float) -> bool:
-        return self.remaining >= estimated_cost
-    
-    def reserve(self, task_id: str, amount: float) -> bool:
-        if not self.can_afford(amount):
-            return False
-        self.reservations[task_id] = amount
-        self.reserved += amount
-        return True
-    
-    def commit(self, task_id: str, actual_cost: float, tokens: int = 0) -> None:
-        reserved = self.reservations.pop(task_id, 0)
-        self.reserved -= reserved
-        self.spent += actual_cost
-        self.tokens_used += tokens
-    
-    def release(self, task_id: str) -> None:
-        if task_id in self.reservations:
-            self.reserved -= self.reservations.pop(task_id)
-
-
-@dataclass
-class SlotState:
-    """Slot state for sprint execution."""
-    slot_id: str
-    model: str
-    tier: str
-    status: str = "idle"  # idle, busy, exhausted
-    current_task: Optional[str] = None
-    queue_depth: int = 0
-    tasks_completed: int = 0
-    tasks_failed: int = 0
-    last_activity: Optional[str] = None
-
-
-@dataclass
-class TaskAssignment:
-    """Task assignment result."""
-    task_id: str
-    slot_id: str
-    assigned_at: str
-    estimated_cost: float = 0.0
-    priority: int = 3
-
-
-@dataclass
-class HaltCondition:
-    """Halt condition with details."""
-    reason: HaltReason
-    message: str
-    recoverable: bool
-    tasks_affected: List[str] = field(default_factory=list)
-    timestamp: str = field(default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()))
-    recommendation: str = ""
-
-
-@dataclass
-class SprintCheckpoint:
-    """Checkpoint for sprint recovery."""
-    sprint_id: str
-    timestamp: str
-    wave: int
-    tasks_completed: List[str]
-    tasks_in_progress: Dict[str, str]  # task_id -> slot_id
-    tasks_remaining: List[str]
-    budget_state: Dict
-    slot_states: List[Dict]
-    
-    def to_dict(self) -> Dict:
-        return asdict(self)
-
-
-@dataclass
-class SprintResult:
-    """Complete sprint execution result."""
-    sprint_id: str
-    mission_id: Optional[str]
-    status: SprintStatus
-    mode: SprintMode
-    
-    # Timing
-    started_at: str
-    completed_at: str
-    duration_seconds: float
-    
-    # Task metrics
-    tasks_total: int
-    tasks_completed: int
-    tasks_failed: int
-    tasks_skipped: int
-    tasks_remaining: int
-    
-    # Slot metrics
-    slots_used: int
-    slot_utilization: float
-    slot_exhaustions: int
-    
-    # Budget metrics
-    budget_limit: Optional[float]
-    budget_spent: float
-    tokens_used: int
-    
-    # Details
-    completed_tasks: List[str] = field(default_factory=list)
-    failed_tasks: List[Dict] = field(default_factory=list)
-    warnings: List[str] = field(default_factory=list)
-    halt_reason: Optional[str] = None
-    
-    # Recommendations
-    next_steps: List[str] = field(default_factory=list)
-    
-    def to_dict(self) -> Dict:
-        result = asdict(self)
-        result["status"] = self.status.value
-        result["mode"] = self.mode.value
-        return result
-
-
-@dataclass
-class Mission:
-    """Mission definition for orchestration."""
-    id: str
-    name: str
-    goal: str
-    success_criteria: List[str]
-    tasks: List[str]
-    slots: List[str]
-    budget_limit: float
-    time_limit_hours: float
-    priority: int = 3
-    status: MissionStatus = MissionStatus.PENDING
-    created_at: str = field(default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()))
-    started_at: Optional[str] = None
-    completed_at: Optional[str] = None
-    result: Optional[Dict] = None
-    
-    def to_dict(self) -> Dict:
-        result = asdict(self)
-        result["status"] = self.status.value
-        return result
-
-
-class RetryPolicy:
-    """Retry policy with exponential backoff."""
-    
-    def __init__(self, max_retries: int = 3, backoff_base: float = 2.0, backoff_max: float = 60.0):
-        self.max_retries = max_retries
-        self.backoff_base = backoff_base
-        self.backoff_max = backoff_max
-        self.attempts: Dict[str, int] = {}
-    
-    def get_delay(self, task_id: str) -> float:
-        attempt = self.attempts.get(task_id, 0)
-        delay = self.backoff_base ** attempt
-        return min(delay, self.backoff_max)
-    
-    def record_attempt(self, task_id: str) -> int:
-        self.attempts[task_id] = self.attempts.get(task_id, 0) + 1
-        return self.attempts[task_id]
-    
-    def should_retry(self, task_id: str, error: Exception = None) -> bool:
-        attempts = self.attempts.get(task_id, 0)
-        if attempts >= self.max_retries:
-            return False
-        # Retry on transient errors
-        if error:
-            return isinstance(error, (TimeoutError, ConnectionError))
-        return True
-    
-    def reset(self, task_id: str) -> None:
-        self.attempts.pop(task_id, None)
-
-
-class WaveAnalyzer:
-    """Analyze task dependencies and organize into waves."""
-    
-    def __init__(self, tasks: List[Dict]):
-        self.tasks = {t["id"]: t for t in tasks}
-        self.waves: List[List[str]] = []
-        self._analyze()
-    
-    def _analyze(self) -> None:
-        """Organize tasks into dependency waves."""
-        remaining = set(self.tasks.keys())
-        completed = set()
-        
-        while remaining:
-            # Find tasks with all dependencies satisfied
-            ready = []
-            for task_id in remaining:
-                task = self.tasks[task_id]
-                deps = set(task.get("blocked_by", []) + task.get("depends_on", []))
-                if deps <= completed:
-                    ready.append(task_id)
-            
-            if not ready:
-                # Check for circular dependencies
-                break
-            
-            self.waves.append(ready)
-            completed.update(ready)
-            remaining -= set(ready)
-        
-        # Any remaining are blocked or circular
-        if remaining:
-            self.waves.append(list(remaining))  # Put in final wave as blocked
-    
-    def get_wave(self, index: int) -> List[str]:
-        if 0 <= index < len(self.waves):
-            return self.waves[index]
-        return []
-    
-    def get_wave_count(self) -> int:
-        return len(self.waves)
-    
-    def detect_circular(self) -> List[str]:
-        """Detect tasks in circular dependencies."""
-        all_in_waves = set()
-        for wave in self.waves[:-1]:  # Exclude last wave which has blocked
-            all_in_waves.update(wave)
-        
-        circular = []
-        for task_id, task in self.tasks.items():
-            if task_id not in all_in_waves:
-                deps = set(task.get("blocked_by", []) + task.get("depends_on", []))
-                # Check if any dependency is also not in waves
-                if any(d not in all_in_waves for d in deps if d in self.tasks):
-                    circular.append(task_id)
-        
-        return circular
-
-
-class TaskAssigner:
-    """Intelligent task assignment with tier matching."""
-    
-    TIER_ORDER = ["T1_RESEARCH", "T2_CODE", "T3_REVIEW", "T4_ADMIN"]
-    
-    def __init__(self, slots: List[SlotState]):
-        self.slots = {s.slot_id: s for s in slots}
-    
-    def assign(self, task: Dict, force: bool = False) -> Optional[TaskAssignment]:
-        """Assign task to best available slot."""
-        required_tier = task.get("required_tier", "T2_CODE")
-        set(task.get("required_skills", []))
-        
-        # Step 1: Filter by tier capability
-        capable = [s for s in self.slots.values() 
-                   if self._tier_capable(s.tier, required_tier) and s.status != "exhausted"]
-        
-        if not capable:
-            if force:
-                # Force assign to any non-exhausted slot
-                capable = [s for s in self.slots.values() if s.status != "exhausted"]
-            if not capable:
-                return None
-        
-        # Step 2: Prefer idle slots
-        idle = [s for s in capable if s.status == "idle"]
-        if idle:
-            # Pick least loaded
-            best = min(idle, key=lambda s: s.queue_depth)
-        else:
-            # Pick slot with shallowest queue
-            best = min(capable, key=lambda s: s.queue_depth)
-        
-        return TaskAssignment(
-            task_id=task["id"],
-            slot_id=best.slot_id,
-            assigned_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-            estimated_cost=task.get("estimated_cost", 0.1),
-            priority=task.get("priority", 3),
-        )
-    
-    def _tier_capable(self, slot_tier: str, required_tier: str) -> bool:
-        """Check if slot tier can handle required tier."""
-        try:
-            slot_idx = self.TIER_ORDER.index(slot_tier) if slot_tier in self.TIER_ORDER else 1
-            req_idx = self.TIER_ORDER.index(required_tier) if required_tier in self.TIER_ORDER else 1
-            return slot_idx <= req_idx  # Lower index = higher capability
-        except ValueError:
-            return True  # Default to capable if tier unknown
-    
-    def update_slot(self, slot_id: str, **updates) -> None:
-        """Update slot state."""
-        if slot_id in self.slots:
-            for key, value in updates.items():
-                if hasattr(self.slots[slot_id], key):
-                    setattr(self.slots[slot_id], key, value)
-    
-    def get_available_count(self) -> int:
-        return sum(1 for s in self.slots.values() if s.status != "exhausted")
-    
-    def get_idle_count(self) -> int:
-        return sum(1 for s in self.slots.values() if s.status == "idle")
-
-
-class AutopilotEngine:
-    """
-    Enterprise-grade autonomous sprint execution engine.
-    
-    Orchestrates multiple slots in parallel with intelligent
-    task assignment, budget control, and halt conditions.
-    """
-    
-    def __init__(
-        self,
-        orchestrator=None,
-        brain_path: Path = None,
-    ):
-        self.orch = orchestrator
-        self.brain_path = brain_path or Path(os.environ.get("NUCLEAR_BRAIN_PATH", ".brain"))
-        
-        # State
-        self.current_sprint_id: Optional[str] = None
-        self.current_mission: Optional[Mission] = None
-        self.budget: BudgetState = BudgetState()
-        self.retry_policy = RetryPolicy()
-        
-        # Tracking
-        self.completed_tasks: List[str] = []
-        self.failed_tasks: List[Dict] = []
-        self.warnings: List[str] = []
-        
-        # Threading
-        self.lock = threading.RLock()
-        self.halt_requested = False
-    
-    def execute_sprint(
-        self,
-        slots: List[str] = None,
-        mode: SprintMode = SprintMode.AUTO,
-        halt_on_blocker: bool = True,
-        halt_on_tier_mismatch: bool = False,
-        max_tasks_per_slot: int = 10,
-        budget_limit: float = None,
-        time_limit_hours: float = None,
-        dry_run: bool = False,
-    ) -> SprintResult:
-        """
-        Execute a sprint with the specified configuration.
-        
-        Args:
-            slots: Slot IDs to use (None = all active)
-            mode: Execution mode (auto, plan, guided, status)
-            halt_on_blocker: Stop if circular dependency detected
-            halt_on_tier_mismatch: Stop if no slot can handle tier
-            max_tasks_per_slot: Max tasks per slot in one sprint
-            budget_limit: Max cost in USD (None = unlimited)
-            time_limit_hours: Max duration (None = unlimited)
-            dry_run: Override to plan mode
-        
-        Returns:
-            SprintResult with detailed execution report
-        """
-        if dry_run:
-            mode = SprintMode.PLAN
-        
-        # Initialize sprint
-        sprint_id = f"sprint_{int(time.time())}_{hashlib.sha256(str(time.time()).encode()).hexdigest()[:6]}"
-        self.current_sprint_id = sprint_id
-        started_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-        start_time = time.time()
-        
-        # Reset state
-        self.completed_tasks = []
-        self.failed_tasks = []
-        self.warnings = []
-        self.halt_requested = False
-        
-        # Initialize budget
-        if budget_limit:
-            self.budget = BudgetState(limit=budget_limit)
-        else:
-            self.budget = BudgetState(limit=float('inf'))
-        
-        # Get tasks and slots
-        tasks = self._get_pending_tasks()
-        slot_states = self._get_slot_states(slots)
-        
-        if not tasks:
-            return self._create_result(
-                sprint_id, started_at, mode, SprintStatus.COMPLETED,
-                "No pending tasks", tasks, slot_states
-            )
-        
-        if not slot_states:
-            return self._create_result(
-                sprint_id, started_at, mode, SprintStatus.FAILED,
-                "No available slots", tasks, slot_states
-            )
-        
-        # Analyze waves
-        wave_analyzer = WaveAnalyzer(tasks)
-        circular = wave_analyzer.detect_circular()
-        
-        if circular and halt_on_blocker:
-            return self._create_result(
-                sprint_id, started_at, mode, SprintStatus.HALTED,
-                f"Circular dependencies detected: {circular}", tasks, slot_states
-            )
-        
-        # Status mode - just return current state
-        if mode == SprintMode.STATUS:
-            return self._create_status_result(sprint_id, started_at, tasks, slot_states)
-        
-        # Plan mode - return execution plan
-        if mode == SprintMode.PLAN:
-            return self._create_plan_result(sprint_id, started_at, tasks, slot_states, wave_analyzer)
-        
-        # Initialize assigner
-        assigner = TaskAssigner(slot_states)
-        
-        # Execute waves
-        halt_condition = None
-        for wave_idx in range(wave_analyzer.get_wave_count()):
-            wave_tasks = wave_analyzer.get_wave(wave_idx)
-            
-            for task_id in wave_tasks:
-                # Check halt conditions
-                halt_condition = self._check_halt_conditions(
-                    assigner, time_limit_hours, start_time, halt_on_tier_mismatch
-                )
-                if halt_condition or self.halt_requested:
-                    break
-                
-                task = next((t for t in tasks if t["id"] == task_id), None)
-                if not task:
-                    continue
-                
-                # Assign task
-                assignment = assigner.assign(task)
-                if not assignment:
-                    if halt_on_tier_mismatch:
-                        halt_condition = HaltCondition(
-                            reason=HaltReason.TIER_MISMATCH,
-                            message=f"No slot available for task {task_id}",
-                            recoverable=True,
-                            tasks_affected=[task_id],
-                        )
-                        break
-                    self.warnings.append(f"Could not assign task {task_id}")
-                    continue
-                
-                # Reserve budget
-                if not self.budget.reserve(task_id, assignment.estimated_cost):
-                    halt_condition = HaltCondition(
-                        reason=HaltReason.BUDGET_EXHAUSTED,
-                        message="Budget limit reached",
-                        recoverable=False,
-                    )
-                    break
-                
-                # Execute task (in auto/guided mode)
-                if mode == SprintMode.GUIDED:
-                    # In real implementation, would pause for approval
-                    pass
-                
-                success = self._execute_task(task, assignment, assigner)
-                
-                if success:
-                    self.completed_tasks.append(task_id)
-                    self.budget.commit(task_id, assignment.estimated_cost, tokens=1000)
-                else:
-                    if self.retry_policy.should_retry(task_id):
-                        # Re-queue for retry
-                        self.warnings.append(f"Task {task_id} will be retried")
-                    else:
-                        self.failed_tasks.append({
-                            "task_id": task_id,
-                            "error": "Max retries exceeded",
-                            "attempts": self.retry_policy.attempts.get(task_id, 0),
-                        })
-                        
-                        # Check if critical task
-                        if task.get("priority", 3) == 1:
-                            halt_condition = HaltCondition(
-                                reason=HaltReason.CRITICAL_TASK_FAILED,
-                                message=f"Critical task {task_id} failed",
-                                recoverable=False,
-                                tasks_affected=[task_id],
-                            )
-                            break
-            
-            if halt_condition or self.halt_requested:
-                break
-            
-            # Checkpoint after each wave
-            self._save_checkpoint(sprint_id, wave_idx, tasks, assigner)
-        
-        # Determine final status
-        if halt_condition:
-            status = SprintStatus.HALTED
-            halt_reason = halt_condition.message
-        elif self.halt_requested:
-            status = SprintStatus.HALTED
-            halt_reason = "User interrupt"
-        elif len(self.failed_tasks) > 0:
-            status = SprintStatus.PARTIAL
-            halt_reason = None
-        else:
-            status = SprintStatus.COMPLETED
-            halt_reason = None
-        
-        return self._create_result(
-            sprint_id, started_at, mode, status, halt_reason, tasks, slot_states
-        )
-    
-    def start_mission(
-        self,
-        name: str,
-        goal: str,
-        task_ids: List[str],
-        slot_ids: List[str] = None,
-        budget_limit: float = 10.0,
-        time_limit_hours: float = 4.0,
-        success_criteria: List[str] = None,
-    ) -> Mission:
-        """Start a new mission."""
-        mission_id = f"mission_{int(time.time())}_{hashlib.sha256(name.encode()).hexdigest()[:6]}"
-        
-        mission = Mission(
-            id=mission_id,
-            name=name,
-            goal=goal,
-            success_criteria=success_criteria or [f"Complete all {len(task_ids)} tasks"],
-            tasks=task_ids,
-            slots=slot_ids or [],
-            budget_limit=budget_limit,
-            time_limit_hours=time_limit_hours,
-            status=MissionStatus.RUNNING,
-            started_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-        )
-        
-        self.current_mission = mission
-        self._save_mission(mission)
-        
-        return mission
-    
-    def get_mission_status(self, mission_id: str = None) -> Dict:
-        """Get current mission status."""
-        mission = self._load_mission(mission_id) if mission_id else self.current_mission
-        
-        if not mission:
-            return {"error": "No mission found"}
-        
-        # Calculate progress
-        total = len(mission.tasks)
-        completed = len([t for t in mission.tasks if t in self.completed_tasks])
-        
-        return {
-            "mission_id": mission.id,
-            "name": mission.name,
-            "status": mission.status.value,
-            "progress": {
-                "total": total,
-                "completed": completed,
-                "percent": int(completed / total * 100) if total > 0 else 0,
-            },
-            "budget": {
-                "limit": mission.budget_limit,
-                "spent": self.budget.spent,
-                "remaining": mission.budget_limit - self.budget.spent,
-            },
-            "started_at": mission.started_at,
-            "elapsed": self._calculate_elapsed(mission.started_at),
-        }
-    
-    def halt_sprint(self, reason: str = "User requested halt") -> Dict:
-        """Request halt of current sprint."""
-        with self.lock:
-            self.halt_requested = True
-        
-        return {
-            "status": "halt_requested",
-            "reason": reason,
-            "sprint_id": self.current_sprint_id,
-        }
-    
-    def resume_sprint(self, sprint_id: str = None) -> SprintResult:
-        """Resume a halted sprint from checkpoint."""
-        checkpoint = self._load_checkpoint(sprint_id or self.current_sprint_id)
-        
-        if not checkpoint:
-            return SprintResult(
-                sprint_id=sprint_id or "unknown",
-                mission_id=None,
-                status=SprintStatus.FAILED,
-                mode=SprintMode.AUTO,
-                started_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-                completed_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-                duration_seconds=0,
-                tasks_total=0,
-                tasks_completed=0,
-                tasks_failed=0,
-                tasks_skipped=0,
-                tasks_remaining=0,
-                slots_used=0,
-                slot_utilization=0,
-                slot_exhaustions=0,
-                budget_limit=None,
-                budget_spent=0,
-                tokens_used=0,
-                halt_reason="No checkpoint found",
-            )
-        
-        # Restore state
-        self.completed_tasks = checkpoint.tasks_completed
-        self.budget = BudgetState(**checkpoint.budget_state)
-        
-        # Continue from checkpoint
-        return self.execute_sprint(
-            slots=[s["slot_id"] for s in checkpoint.slot_states],
-        )
-    
-    def _get_pending_tasks(self) -> List[Dict]:
-        """Get pending tasks from orchestrator."""
-        if self.orch:
-            return self.orch.get_all_tasks(status="PENDING")
-        
-        # Fallback to file
-        tasks_path = self.brain_path / "ledger" / "tasks.json"
-        if tasks_path.exists():
-            with open(tasks_path) as f:
-                data = json.load(f)
-            return [t for t in data.get("tasks", []) if t.get("status") in ["PENDING", "READY"]]
-        
-        return []
-    
-    def _get_slot_states(self, slot_ids: List[str] = None) -> List[SlotState]:
-        """Get slot states from registry."""
-        registry_path = self.brain_path / "slots" / "registry.json"
-        
-        if not registry_path.exists():
-            return []
-        
-        with open(registry_path) as f:
-            registry = json.load(f)
-        
-        states = []
-        for slot_id, slot in registry.get("slots", {}).items():
-            if slot_ids and slot_id not in slot_ids:
-                continue
-            if slot.get("status") == "exhausted":
-                continue
-            
-            states.append(SlotState(
-                slot_id=slot_id,
-                model=slot.get("model", "unknown"),
-                tier=slot.get("tier", "T2_CODE"),
-                status=slot.get("status", "idle"),
-            ))
-        
-        return states
-    
-    def _check_halt_conditions(
-        self,
-        assigner: TaskAssigner,
-        time_limit_hours: float,
-        start_time: float,
-        halt_on_tier_mismatch: bool,
-    ) -> Optional[HaltCondition]:
-        """Check all halt conditions."""
-        # Budget exhausted
-        if self.budget.remaining <= 0:
-            return HaltCondition(
-                reason=HaltReason.BUDGET_EXHAUSTED,
-                message="Budget limit reached",
-                recoverable=False,
-            )
-        
-        # All slots exhausted
-        if assigner.get_available_count() == 0:
-            return HaltCondition(
-                reason=HaltReason.ALL_SLOTS_EXHAUSTED,
-                message="All slots exhausted",
-                recoverable=True,
-                recommendation="Wait for slot recovery or add new slots",
-            )
-        
-        # Time limit
-        if time_limit_hours:
-            elapsed_hours = (time.time() - start_time) / 3600
-            if elapsed_hours >= time_limit_hours:
-                return HaltCondition(
-                    reason=HaltReason.TIME_LIMIT,
-                    message=f"Time limit of {time_limit_hours}h exceeded",
-                    recoverable=True,
-                )
-        
-        return None
-    
-    def _execute_task(
-        self,
-        task: Dict,
-        assignment: TaskAssignment,
-        assigner: TaskAssigner,
-    ) -> bool:
-        """Execute a single task."""
-        # Update slot state
-        assigner.update_slot(
-            assignment.slot_id,
-            status="busy",
-            current_task=task["id"],
-        )
-        
-        # In real implementation, this would delegate to the slot
-        # For now, simulate execution
-        success = True  # Simulated success
-        
-        # Update slot state
-        if success:
-            assigner.update_slot(
-                assignment.slot_id,
-                status="idle",
-                current_task=None,
-                tasks_completed=assigner.slots[assignment.slot_id].tasks_completed + 1,
-            )
-        else:
-            assigner.update_slot(
-                assignment.slot_id,
-                status="idle",
-                current_task=None,
-                tasks_failed=assigner.slots[assignment.slot_id].tasks_failed + 1,
-            )
-        
-        # Update task in orchestrator
-        if self.orch:
-            if success:
-                self.orch.complete_task(task["id"], assignment.slot_id, "success")
-            else:
-                self.orch.update_task(task["id"], {"status": "FAILED"})
-        
-        return success
-    
-    def _save_checkpoint(
-        self,
-        sprint_id: str,
-        wave: int,
-        tasks: List[Dict],
-        assigner: TaskAssigner,
-    ) -> None:
-        """Save checkpoint for recovery."""
-        checkpoint_dir = self.brain_path / "sprints" / sprint_id
-        checkpoint_dir.mkdir(parents=True, exist_ok=True)
-        
-        checkpoint = SprintCheckpoint(
-            sprint_id=sprint_id,
-            timestamp=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-            wave=wave,
-            tasks_completed=self.completed_tasks.copy(),
-            tasks_in_progress={s.current_task: s.slot_id for s in assigner.slots.values() if s.current_task},
-            tasks_remaining=[t["id"] for t in tasks if t["id"] not in self.completed_tasks],
-            budget_state=asdict(self.budget),
-            slot_states=[asdict(s) for s in assigner.slots.values()],
-        )
-        
-        with open(checkpoint_dir / "checkpoint.json", "w") as f:
-            json.dump(checkpoint.to_dict(), f, indent=2)
-    
-    def _load_checkpoint(self, sprint_id: str) -> Optional[SprintCheckpoint]:
-        """Load checkpoint for recovery."""
-        checkpoint_path = self.brain_path / "sprints" / sprint_id / "checkpoint.json"
-        
-        if not checkpoint_path.exists():
-            return None
-        
-        with open(checkpoint_path) as f:
-            data = json.load(f)
-        
-        return SprintCheckpoint(**data)
-    
-    def _save_mission(self, mission: Mission) -> None:
-        """Save mission to disk."""
-        missions_dir = self.brain_path / "missions"
-        missions_dir.mkdir(parents=True, exist_ok=True)
-        
-        with open(missions_dir / f"{mission.id}.json", "w") as f:
-            json.dump(mission.to_dict(), f, indent=2)
-    
-    def _load_mission(self, mission_id: str) -> Optional[Mission]:
-        """Load mission from disk."""
-        mission_path = self.brain_path / "missions" / f"{mission_id}.json"
-        
-        if not mission_path.exists():
-            return None
-        
-        with open(mission_path) as f:
-            data = json.load(f)
-        
-        data["status"] = MissionStatus(data["status"])
-        return Mission(**data)
-    
-    def _calculate_elapsed(self, started_at: str) -> str:
-        """Calculate elapsed time from start."""
-        try:
-            start = datetime.fromisoformat(started_at.replace("Z", "+00:00"))
-            now = datetime.utcnow()
-            elapsed = now - start.replace(tzinfo=None)
-            
-            hours = int(elapsed.total_seconds() // 3600)
-            minutes = int((elapsed.total_seconds() % 3600) // 60)
-            
-            return f"{hours}h {minutes}m"
-        except Exception:
-            return "N/A"
-    
-    def _create_result(
-        self,
-        sprint_id: str,
-        started_at: str,
-        mode: SprintMode,
-        status: SprintStatus,
-        halt_reason: Optional[str],
-        tasks: List[Dict],
-        slot_states: List[SlotState],
-    ) -> SprintResult:
-        """Create sprint result."""
-        completed_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-        
-        try:
-            start = datetime.fromisoformat(started_at.replace("Z", "+00:00"))
-            end = datetime.fromisoformat(completed_at.replace("Z", "+00:00"))
-            duration = (end - start).total_seconds()
-        except Exception:
-            duration = 0
-        
-        total = len(tasks)
-        completed = len(self.completed_tasks)
-        failed = len(self.failed_tasks)
-        
-        # Calculate slot metrics
-        slots_used = len(slot_states)
-        if slots_used > 0:
-            active = sum(1 for s in slot_states if s.status != "exhausted")
-            utilization = active / slots_used
-        else:
-            utilization = 0
-        exhaustions = sum(1 for s in slot_states if s.status == "exhausted")
-        
-        return SprintResult(
-            sprint_id=sprint_id,
-            mission_id=self.current_mission.id if self.current_mission else None,
-            status=status,
-            mode=mode,
-            started_at=started_at,
-            completed_at=completed_at,
-            duration_seconds=duration,
-            tasks_total=total,
-            tasks_completed=completed,
-            tasks_failed=failed,
-            tasks_skipped=0,
-            tasks_remaining=total - completed - failed,
-            slots_used=slots_used,
-            slot_utilization=utilization,
-            slot_exhaustions=exhaustions,
-            budget_limit=self.budget.limit if self.budget.limit != float('inf') else None,
-            budget_spent=self.budget.spent,
-            tokens_used=self.budget.tokens_used,
-            completed_tasks=self.completed_tasks.copy(),
-            failed_tasks=self.failed_tasks.copy(),
-            warnings=self.warnings.copy(),
-            halt_reason=halt_reason,
-            next_steps=self._generate_next_steps(status, halt_reason),
-        )
-    
-    def _create_status_result(
-        self,
-        sprint_id: str,
-        started_at: str,
-        tasks: List[Dict],
-        slot_states: List[SlotState],
-    ) -> SprintResult:
-        """Create status-only result."""
-        return self._create_result(
-            sprint_id, started_at, SprintMode.STATUS, SprintStatus.PENDING,
-            None, tasks, slot_states
-        )
-    
-    def _create_plan_result(
-        self,
-        sprint_id: str,
-        started_at: str,
-        tasks: List[Dict],
-        slot_states: List[SlotState],
-        wave_analyzer: WaveAnalyzer,
-    ) -> SprintResult:
-        """Create plan-only result."""
-        result = self._create_result(
-            sprint_id, started_at, SprintMode.PLAN, SprintStatus.PENDING,
-            None, tasks, slot_states
-        )
-        
-        # Add wave information to next_steps
-        result.next_steps = [
-            f"Wave 1: {len(wave_analyzer.get_wave(0))} tasks (roots)",
-        ]
-        for i in range(1, wave_analyzer.get_wave_count()):
-            result.next_steps.append(
-                f"Wave {i+1}: {len(wave_analyzer.get_wave(i))} tasks"
-            )
-        
-        return result
-    
-    def _generate_next_steps(self, status: SprintStatus, halt_reason: Optional[str]) -> List[str]:
-        """Generate recommended next steps."""
-        steps = []
-        
-        if status == SprintStatus.COMPLETED:
-            steps.append("All tasks completed successfully")
-            steps.append("Review completed work and verify quality")
-        
-        elif status == SprintStatus.PARTIAL:
-            steps.append(f"Retry failed tasks: {len(self.failed_tasks)}")
-            steps.append("Review failure logs for root cause")
-        
-        elif status == SprintStatus.HALTED:
-            if "budget" in (halt_reason or "").lower():
-                steps.append("Increase budget limit and resume")
-            elif "slot" in (halt_reason or "").lower():
-                steps.append("Wait for slot recovery or spawn new slots")
-            elif "circular" in (halt_reason or "").lower():
-                steps.append("Break circular dependencies manually")
-            else:
-                steps.append("Review halt reason and resume when ready")
-        
-        return steps
-
-
-def format_sprint_result(result: SprintResult) -> str:
-    """Format sprint result as ASCII report."""
-    lines = [
-        f"🚀 Sprint Report: {result.sprint_id}",
-        "═" * 50,
-        f"Status: {result.status.value.upper()}",
-        f"Mode: {result.mode.value}",
-        f"Duration: {result.duration_seconds:.1f}s",
-        "",
-        "📊 TASKS",
-        f"   ├── Total: {result.tasks_total}",
-        f"   ├── Completed: {result.tasks_completed}",
-        f"   ├── Failed: {result.tasks_failed}",
-        f"   └── Remaining: {result.tasks_remaining}",
-        "",
-        "🤖 SLOTS",
-        f"   ├── Used: {result.slots_used}",
-        f"   ├── Utilization: {int(result.slot_utilization * 100)}%",
-        f"   └── Exhaustions: {result.slot_exhaustions}",
-        "",
-        "💰 BUDGET",
-        f"   ├── Spent: ${result.budget_spent:.2f}",
-        f"   └── Tokens: {result.tokens_used}",
-    ]
-    
-    if result.halt_reason:
-        lines.extend([
-            "",
-            "⚠️ HALT REASON",
-            f"   {result.halt_reason}",
-        ])
-    
-    if result.next_steps:
-        lines.extend([
-            "",
-            "📋 NEXT STEPS",
-        ])
-        for step in result.next_steps:
-            lines.append(f"   • {step}")
-    
-    return "\n".join(lines)