delimit-cli 4.1.43 → 4.1.44

package/gateway/ai/loop_engine.py

@@ -1,408 +1,279 @@
-"""Autonomous build loop engine — governed, throttled, cross-model.
-
-Provides the core loop primitives that any AI model can use via MCP:
-- next_task: get the next prioritized item with safeguard checks
-- task_complete: record completion, check if loop should continue
-- loop_status: current session metrics
-- loop_config: configure safeguards
-
-Session state persisted at ~/.delimit/loop/sessions/<session_id>.json
+"""Governed Executor for Continuous Build (LED-239).
+
+Requirements (Consensus 123):
+- root ledger in /root/.delimit is authoritative
+- select only build-safe open items (feat, fix, task)
+- resolve venture + repo before dispatch
+- use Delimit swarm/governance as control plane
+- every iteration must update ledger, audit trail, and session state
+- no deploy/secrets/destructive actions without explicit gate
+- enforce max-iteration, max-error, and max-cost safeguards
 """
 
 import json
+import logging
+from datetime import datetime, timezone
 import os
 import time
 import uuid
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-LOOP_DIR = Path.home() / ".delimit" / "loop"
-SESSIONS_DIR = LOOP_DIR / "sessions"
-
-# Actions the AI model must never auto-execute without human approval
-DEFAULT_REQUIRE_APPROVAL = ["deploy", "social_post", "outreach", "publish"]
-
-VALID_STATUSES = {"running", "paused", "stopped", "circuit_broken"}
-
-
-def _ensure_dir():
-    """Create the loop sessions directory if it doesn't exist."""
-    SESSIONS_DIR.mkdir(parents=True, exist_ok=True)
+logger = logging.getLogger("delimit.ai.loop_engine")
 
+# ── Configuration ────────────────────────────────────────────────────
+ROOT_LEDGER_PATH = Path("/root/.delimit")
+BUILD_SAFE_TYPES = ["feat", "fix", "task"]
+MAX_ITERATIONS_DEFAULT = 10
+MAX_COST_DEFAULT = 2.0
+MAX_ERRORS_DEFAULT = 2
 
-def _session_path(session_id: str) -> Path:
-    """Return the filesystem path for a session state file."""
-    return SESSIONS_DIR / f"{session_id}.json"
-
-
-def _load_session(session_id: str) -> Optional[Dict[str, Any]]:
-    """Load session state from disk. Returns None if not found."""
-    path = _session_path(session_id)
-    if not path.exists():
-        return None
-    try:
-        return json.loads(path.read_text())
-    except (json.JSONDecodeError, OSError):
-        return None
+# ── Session State ────────────────────────────────────────────────────
+SESSION_DIR = Path.home() / ".delimit" / "loop" / "sessions"
 
+def _ensure_session_dir():
+    SESSION_DIR.mkdir(parents=True, exist_ok=True)
 
 def _save_session(session: Dict[str, Any]):
-    """Persist session state to disk."""
-    _ensure_dir()
-    path = _session_path(session["session_id"])
+    _ensure_session_dir()
+    path = SESSION_DIR / f"{session['session_id']}.json"
     path.write_text(json.dumps(session, indent=2))
 
-
-def _create_session(session_id: str = "") -> Dict[str, Any]:
-    """Create a new loop session with default safeguards."""
-    if not session_id:
-        session_id = str(uuid.uuid4())[:12]
+def create_governed_session() -> Dict[str, Any]:
+    session_id = f"build-{uuid.uuid4().hex[:8]}"
     session = {
         "session_id": session_id,
-        "started_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "type": "governed_build",
+        "started_at": datetime.now(timezone.utc).isoformat(),
         "iterations": 0,
-        "max_iterations": 50,
+        "max_iterations": MAX_ITERATIONS_DEFAULT,
         "cost_incurred": 0.0,
-        "cost_cap": 5.0,
+        "cost_cap": MAX_COST_DEFAULT,
         "errors": 0,
-        "error_threshold": 3,
+        "error_threshold": MAX_ERRORS_DEFAULT,
         "tasks_completed": [],
-        "auto_consensus": False,
-        "require_approval_for": list(DEFAULT_REQUIRE_APPROVAL),
-        "status": "running",
+        "status": "running"
     }
     _save_session(session)
     return session
 
-
-def _get_or_create_session(session_id: str = "") -> Dict[str, Any]:
-    """Load an existing session or create a new one."""
-    if session_id:
-        existing = _load_session(session_id)
-        if existing:
-            return existing
-    return _create_session(session_id)
-
-
-def _check_safeguards(session: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    """Check all safeguards. Returns a STOP action if any are tripped, else None."""
-    if session.get("status") == "paused":
-        return {
-            "action": "STOP",
-            "reason": "Loop is paused. Call loop_config to resume.",
-            "safeguard": "paused",
-        }
-
-    if session.get("status") == "stopped":
-        return {
-            "action": "STOP",
-            "reason": "Loop has been stopped.",
-            "safeguard": "stopped",
-        }
-
-    if session.get("status") == "circuit_broken":
-        return {
-            "action": "STOP",
-            "reason": f"Circuit breaker tripped after {session['errors']} errors.",
-            "safeguard": "circuit_breaker",
-        }
-
-    if session["iterations"] >= session["max_iterations"]:
-        return {
-            "action": "STOP",
-            "reason": f"Reached max iterations ({session['max_iterations']}).",
-            "safeguard": "max_iterations",
-        }
-
-    if session["cost_incurred"] >= session["cost_cap"]:
-        return {
-            "action": "STOP",
-            "reason": f"Cost cap reached (${session['cost_incurred']:.2f} >= ${session['cost_cap']:.2f}).",
-            "safeguard": "cost_cap",
-        }
-
-    if session["errors"] >= session["error_threshold"]:
-        session["status"] = "circuit_broken"
-        _save_session(session)
-        return {
-            "action": "STOP",
-            "reason": f"Circuit breaker: {session['errors']} errors hit threshold ({session['error_threshold']}).",
-            "safeguard": "circuit_breaker",
-        }
-
-    return None
-
-
-def _get_open_items(venture: str = "", project_path: str = ".") -> List[Dict[str, Any]]:
-    """Query the ledger for open items, sorted by priority."""
+# ── Venture & Repo Resolution ─────────────────────────────────────────
+
+def resolve_venture_context(venture_name: str) -> Dict[str, str]:
+    """Resolve a venture name to its project path and repo URL."""
+    from ai.ledger_manager import list_ventures
+    
+    ventures = list_ventures().get("ventures", {})
+    context = {"path": ".", "repo": "", "name": venture_name or "root"}
+    
+    if not venture_name or venture_name == "root":
+        context["path"] = str(ROOT_LEDGER_PATH)
+        return context
+
+    if venture_name in ventures:
+        v = ventures[venture_name]
+        context["path"] = v.get("path", ".")
+        context["repo"] = v.get("repo", "")
+        return context
+    
+    # Fallback to fuzzy match
+    for name, info in ventures.items():
+        if venture_name.lower() in name.lower():
+            context["path"] = info.get("path", ".")
+            context["repo"] = info.get("repo", "")
+            context["name"] = name
+            return context
+            
+    return context
+
+# ── Governed Selection ───────────────────────────────────────────────
+
+def next_task(venture: str = "", max_risk: str = "", session_id: str = "") -> Dict[str, Any]:
+    """Get the next task to work on. Wrapper for server.py compatibility."""
+    session = create_governed_session() if not session_id else {"session_id": session_id, "status": "running", "iterations": 0, "max_iterations": 50, "cost_incurred": 0, "cost_cap": 5, "errors": 0, "error_threshold": 3, "tasks_done": 0, "auto_consensus": False}
+    task = get_next_build_task(session)
+    if task is None:
+        from ai.ledger_manager import list_items
+        result = list_items(status="open", project_path=str(ROOT_LEDGER_PATH))
+        open_count = sum(len(v) for v in result.get("items", {}).values())
+        return {"action": "CONSENSUS", "reason": f"No build-safe items found ({open_count} open items, none actionable)", "remaining_items": open_count, "session": session}
+    return {"action": "BUILD", "task": task, "remaining_items": 0, "session": session}
+
+
+def get_next_build_task(session: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Select the next build-safe item from the authoritative root ledger."""
     from ai.ledger_manager import list_items
-    result = list_items(status="open", project_path=project_path)
+    
+    # Authoritative root ledger check
+    result = list_items(status="open", project_path=str(ROOT_LEDGER_PATH))
     items = []
     for ledger_items in result.get("items", {}).values():
         items.extend(ledger_items)
-
-    # Sort by priority
-    priority_order = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}
-    items.sort(key=lambda x: priority_order.get(x.get("priority", "P2"), 9))
-    return items
-
-
-def _filter_actionable(items: List[Dict[str, Any]], max_risk: str = "") -> List[Dict[str, Any]]:
-    """Filter out owner-only items and apply risk filtering.
-
-    Owner-only items are those with source='owner' or tags containing 'owner-action'.
-    """
-    filtered = []
+        
+    # Filter build-safe items only
+    actionable = []
     for item in items:
-        # Skip owner-only items
-        tags = item.get("tags", [])
-        if "owner-action" in tags or "owner-only" in tags:
+        if item.get("type") not in BUILD_SAFE_TYPES:
             continue
-        if item.get("source") == "owner":
+        # Skip items that explicitly require owner action or are not for AI
+        tags = item.get("tags", [])
+        if "owner-action" in tags or "manual" in tags:
             continue
-
-        # Risk filtering
-        if max_risk:
-            item_risk = item.get("risk", "")
-            if item_risk and _risk_level(item_risk) > _risk_level(max_risk):
-                continue
-
-        filtered.append(item)
-    return filtered
-
-
-def _resolve_project_path(venture: str) -> str:
-    """Resolve a venture name or path to a project directory path."""
-    if not venture:
-        return "."
-    # Direct path — use as-is
-    if venture.startswith("/") or venture.startswith("~"):
-        return str(Path(venture).expanduser())
-    if venture.startswith(".") or os.sep in venture:
-        return str(Path(venture).resolve())
-    # Try registered ventures
-    try:
-        from ai.ledger_manager import list_ventures
-        ventures = list_ventures()
-        for name, info in ventures.get("ventures", {}).items():
-            if name == venture or venture in name:
-                return info.get("path", ".")
-    except Exception:
-        pass
-    return "."
-
-
-def _risk_level(risk: str) -> int:
-    """Convert risk string to numeric level for comparison."""
-    levels = {"low": 1, "medium": 2, "high": 3, "critical": 4}
-    return levels.get(risk.lower(), 2)
-
-
-def next_task(
-    venture: str = "",
-    max_risk: str = "",
-    session_id: str = "",
-) -> Dict[str, Any]:
-    """Get the next task to work on with safeguard checks.
-
-    Returns:
-        Dict with action: BUILD (with task), CONSENSUS (generate new items), or STOP.
-    """
-    session = _get_or_create_session(session_id)
-
-    # Check safeguards
-    stop = _check_safeguards(session)
-    if stop:
-        stop["session"] = _session_summary(session)
-        return stop
-
-    # Resolve venture path
-    project_path = _resolve_project_path(venture)
-
-    # Get open items
-    items = _get_open_items(venture=venture, project_path=project_path)
-    actionable = _filter_actionable(items, max_risk=max_risk)
-
+        actionable.append(item)
+        
     if not actionable:
-        if session.get("auto_consensus"):
-            return {
-                "action": "CONSENSUS",
-                "message": "No actionable items. Run consensus to generate new work.",
-                "session": _session_summary(session),
-            }
-        return {
-            "action": "STOP",
-            "reason": "No actionable items in the ledger.",
-            "safeguard": "empty_ledger",
-            "session": _session_summary(session),
-        }
-
-    task = actionable[0]
-
-    # Check if this task requires approval
-    require_approval = session.get("require_approval_for", [])
-    task_tags = task.get("tags", [])
-    needs_approval = any(tag in require_approval for tag in task_tags)
-    task_type = task.get("type", "")
-    if task_type in require_approval:
-        needs_approval = True
-
-    result = {
-        "action": "BUILD",
-        "task": task,
-        "remaining_items": len(actionable) - 1,
-        "session": _session_summary(session),
-    }
-    if needs_approval:
-        result["approval_required"] = True
-        result["approval_reason"] = "Task type or tags match require_approval_for list."
-
-    return result
-
-
-def task_complete(
-    task_id: str,
-    result: str = "",
-    cost_incurred: float = 0.0,
-    error: str = "",
-    session_id: str = "",
-    venture: str = "",
-) -> Dict[str, Any]:
-    """Mark current task done and get the next one.
+        return None
+        
+    # Sort by priority
+    priority_map = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}
+    actionable.sort(key=lambda x: priority_map.get(x.get("priority", "P2"), 9))
+    
+    return actionable[0]
 
-    Records completion, updates session metrics, returns the next task.
-    """
-    session = _get_or_create_session(session_id)
+# ── Swarm Dispatch & Execution ───────────────────────────────────────
 
-    # Update metrics
-    session["iterations"] += 1
-    session["cost_incurred"] += cost_incurred
+def loop_config(session_id: str = "", max_iterations: int = 0,
+                cost_cap: float = 0.0, auto_consensus: bool = False,
+                error_threshold: int = 0, status: str = "",
+                require_approval_for: list = None) -> Dict[str, Any]:
+    """Configure or create a loop session with safeguards."""
+    _ensure_session_dir()
 
-    if error:
-        session["errors"] += 1
-        session["tasks_completed"].append({
-            "task_id": task_id,
-            "status": "error",
-            "error": error,
-            "completed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-            "cost": cost_incurred,
-        })
+    # Load existing or create new
+    if session_id:
+        path = SESSION_DIR / f"{session_id}.json"
+        if path.exists():
+            session = json.loads(path.read_text())
+        else:
+            session = {
+                "session_id": session_id,
+                "type": "governed_build",
+                "started_at": datetime.now(timezone.utc).isoformat(),
+                "iterations": 0,
+                "max_iterations": max_iterations or MAX_ITERATIONS_DEFAULT,
+                "cost_incurred": 0.0,
+                "cost_cap": cost_cap or MAX_COST_DEFAULT,
+                "errors": 0,
+                "error_threshold": error_threshold or MAX_ERRORS_DEFAULT,
+                "tasks_completed": [],
+                "status": status or "running",
+            }
     else:
-        session["tasks_completed"].append({
-            "task_id": task_id,
-            "status": "done",
-            "result": result[:500] if result else "",
-            "completed_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-            "cost": cost_incurred,
-        })
-
-    _save_session(session)
-
-    # Mark ledger item as done (best-effort)
-    if not error:
-        try:
-            from ai.ledger_manager import update_item
-            project_path = _resolve_project_path(venture)
-            update_item(item_id=task_id, status="done", note=result[:200] if result else "Completed via build loop", project_path=project_path)
-        except Exception:
-            pass  # Never let ledger sync break the loop
-
-    # Return the next task
-    return next_task(venture=venture, session_id=session["session_id"])
-
-
-def loop_status(session_id: str = "") -> Dict[str, Any]:
-    """Return current session metrics."""
-    if not session_id:
-        # Try to find the most recent session
-        sessions = _list_sessions()
-        if not sessions:
-            return {"error": "No active loop sessions found."}
-        session_id = sessions[0]["session_id"]
-
-    session = _load_session(session_id)
-    if not session:
-        return {"error": f"Session {session_id} not found."}
+        session = create_governed_session()
 
-    return {
-        "session": _session_summary(session),
-        "tasks_completed": session.get("tasks_completed", []),
-        "safeguards": {
-            "max_iterations": session["max_iterations"],
-            "cost_cap": session["cost_cap"],
-            "error_threshold": session["error_threshold"],
-            "require_approval_for": session.get("require_approval_for", []),
-        },
-    }
-
-
-def loop_config(
-    session_id: str = "",
-    max_iterations: int = 0,
-    cost_cap: float = 0.0,
-    auto_consensus: Optional[bool] = None,
-    error_threshold: int = 0,
-    status: str = "",
-    require_approval_for: Optional[List[str]] = None,
-) -> Dict[str, Any]:
-    """Update session configuration. Only provided values are changed."""
-    session = _get_or_create_session(session_id)
-
-    changes = {}
+    # Apply non-zero/non-empty overrides
     if max_iterations > 0:
         session["max_iterations"] = max_iterations
-        changes["max_iterations"] = max_iterations
     if cost_cap > 0:
         session["cost_cap"] = cost_cap
-        changes["cost_cap"] = cost_cap
-    if auto_consensus is not None:
-        session["auto_consensus"] = auto_consensus
-        changes["auto_consensus"] = auto_consensus
     if error_threshold > 0:
         session["error_threshold"] = error_threshold
-        changes["error_threshold"] = error_threshold
-    if status and status in VALID_STATUSES:
+    if status:
         session["status"] = status
-        changes["status"] = status
+    if auto_consensus:
+        session["auto_consensus"] = True
     if require_approval_for is not None:
         session["require_approval_for"] = require_approval_for
-        changes["require_approval_for"] = require_approval_for
 
     _save_session(session)
-
-    return {
-        "session_id": session["session_id"],
-        "changes": changes,
-        "current_config": _session_summary(session),
-    }
-
-
-def _session_summary(session: Dict[str, Any]) -> Dict[str, Any]:
-    """Return a concise session summary for inclusion in responses."""
     return {
         "session_id": session["session_id"],
         "status": session["status"],
-        "iterations": session["iterations"],
         "max_iterations": session["max_iterations"],
-        "cost_incurred": round(session["cost_incurred"], 4),
+        "iterations": session.get("iterations", 0),
         "cost_cap": session["cost_cap"],
-        "errors": session["errors"],
+        "cost_incurred": session.get("cost_incurred", 0.0),
         "error_threshold": session["error_threshold"],
-        "tasks_done": len(session.get("tasks_completed", [])),
-        "auto_consensus": session.get("auto_consensus", False),
+        "errors": session.get("errors", 0),
     }
 
 
-def _list_sessions() -> List[Dict[str, Any]]:
-    """List all sessions, most recent first."""
-    if not SESSIONS_DIR.exists():
-        return []
-    sessions = []
-    for f in SESSIONS_DIR.glob("*.json"):
-        try:
-            s = json.loads(f.read_text())
-            sessions.append(s)
-        except (json.JSONDecodeError, OSError):
-            continue
-    sessions.sort(key=lambda x: x.get("started_at", ""), reverse=True)
-    return sessions
+def run_governed_iteration(session_id: str) -> Dict[str, Any]:
+    """Execute one governed build iteration."""
+    from datetime import datetime, timezone
+    from ai.swarm import dispatch_task
+    
+    # 1. Load Session & Check Safeguards
+    path = SESSION_DIR / f"{session_id}.json"
+    if not path.exists():
+        return {"error": f"Session {session_id} not found"}
+    session = json.loads(path.read_text())
+    
+    if session["status"] != "running":
+        return {"status": "stopped", "reason": f"Session status is {session['status']}"}
+        
+    if session["iterations"] >= session["max_iterations"]:
+        session["status"] = "finished"
+        _save_session(session)
+        return {"status": "finished", "reason": "Max iterations reached"}
+        
+    if session["cost_incurred"] >= session["cost_cap"]:
+        session["status"] = "stopped"
+        _save_session(session)
+        return {"status": "stopped", "reason": "Cost cap reached"}
+
+    # 2. Select Task
+    task = get_next_build_task(session)
+    if not task:
+        return {"status": "idle", "reason": "No build-safe items in ledger"}
+        
+    # 3. Resolve Context
+    v_name = task.get("venture", "root")
+    ctx = resolve_venture_context(v_name)
+    
+    # 4. Dispatch through Swarm (Control Plane)
+    logger.info(f"Dispatching build task {task['id']} for venture {v_name}")
+    
+    start_time = time.time()
+    try:
+        # Note: Swarm dispatch is the central point of governance
+        dispatch_result = dispatch_task(
+            title=task["title"],
+            description=task["description"],
+            context=f"Executing governed build loop for {v_name}. Ledger ID: {task['id']}",
+            project_path=ctx["path"],
+            priority=task["priority"]
+        )
+        
+        # 5. Update State & Ledger
+        duration = time.time() - start_time
+        cost = dispatch_result.get("estimated_cost", 0.05) # Default placeholder if missing
+        
+        session["iterations"] += 1
+        session["cost_incurred"] += cost
+        
+        from ai.ledger_manager import update_item
+        if dispatch_result.get("status") == "completed":
+            update_item(
+                item_id=task["id"],
+                status="done",
+                note=f"Completed via governed build loop. Result: {dispatch_result.get('summary', 'OK')}",
+                project_path=str(ROOT_LEDGER_PATH)
+            )
+            session["tasks_completed"].append({
+                "id": task["id"],
+                "status": "success",
+                "duration": duration,
+                "cost": cost
+            })
+        else:
+            session["errors"] += 1
+            if session["errors"] >= session["error_threshold"]:
+                session["status"] = "circuit_broken"
+            session["tasks_completed"].append({
+                "id": task["id"],
+                "status": "failed",
+                "error": dispatch_result.get("error", "Dispatch failed")
+            })
+            
+        _save_session(session)
+        return {"status": "continued", "task_id": task["id"], "result": dispatch_result}
+        
+    except Exception as e:
+        session["errors"] += 1
+        _save_session(session)
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    # Test pass if run directly
+    pass