@trac3er/oh-my-god 2.1.9 → 2.2.2

package/build/lib/runtime/team_router.py

@@ -14,6 +14,7 @@ import shutil
 import subprocess
 import threading
 import uuid
+from pathlib import Path
 from typing import Any
 from typing import cast
 
@@ -24,6 +25,11 @@ _OMG_ROOT = os.path.dirname(_ROUTER_DIR)
 _logger = logging.getLogger(__name__)
 _ROUTING_MODE_DEFAULT = "normal"
 _ROUTING_MODE_CLARIFICATION = "planning_read_only"
+_TEAM_STAGED_FLOW = ["team-plan", "team-exec", "team-verify", "team-fix"]
+_TEAM_COMMAND_ALIASES = {
+    "canonical": "/OMG:team",
+    "compatibility": ["/OMG:teams"],
+}
 
 # Import providers to trigger auto-registration in provider registry
 try:
@@ -36,7 +42,9 @@ except ImportError:
 from runtime.runtime_profile import resolve_parallel_workers
 from runtime.runtime_contracts import write_run_state
 from runtime.release_run_coordinator import resolve_current_run_id as resolve_coordinator_run_id
+from runtime.exec_kernel import get_exec_kernel
 from runtime.context_engine import ContextEngine
+from runtime.context_engine import _extract_clarification
 from runtime.context_engine import render_profile_digest_text
 from runtime.defense_state import DefenseState
 from runtime.equalizer import select_provider
@@ -266,26 +274,43 @@ def dispatch_team(req: TeamDispatchRequest) -> TeamDispatchResult:
             ]
         )
 
-    routing_mode = _ROUTING_MODE_DEFAULT
+    # --- Native question: block the turn when clarification is required ---
     if clarification_required:
-        routing_mode = _ROUTING_MODE_CLARIFICATION
-        findings.append("Clarification unresolved; downgrading to read-only planning mode")
-        actions = [
-            "Collect missing details using read/search/review tools only",
-            "Draft a concrete execution plan without mutation-capable steps",
-            "Return a single clarification request before any edits or writes",
-        ]
+        prompt = str(clarification_status.get("clarification_prompt", "")).strip()
+        if prompt:
+            findings.append(f"Clarification required: {prompt}")
+        else:
+            findings.append("Clarification required before dispatch")
+        return TeamDispatchResult(
+            status="clarification_required",
+            findings=findings,
+            actions=["Resolve the clarification question before dispatch"],
+            evidence={
+                "target": target,
+                "staged_flow": list(_TEAM_STAGED_FLOW),
+                "command_aliases": dict(_TEAM_COMMAND_ALIASES),
+                "clarification_status": clarification_status,
+                "routing_mode": _ROUTING_MODE_CLARIFICATION,
+                "generated_at": datetime.now(timezone.utc).isoformat(),
+            },
+        )
 
     evidence = {
         "target": target,
+        "staged_flow": list(_TEAM_STAGED_FLOW),
+        "command_aliases": dict(_TEAM_COMMAND_ALIASES),
         "equalizer": equalizer_decision,
         "generated_at": datetime.now(timezone.utc).isoformat(),
         "context_length": len(req.context or ""),
         "file_count": len(req.files or []),
-        "routing_mode": routing_mode,
+        "routing_mode": _ROUTING_MODE_DEFAULT,
         "clarification_status": clarification_status,
         "cli_health": cli_health,
         "live_connection": all(h.get("live_connection") for h in cli_health.values()) if cli_health else True,
+        "exec_kernel": {
+            "enabled": get_exec_kernel(_OMG_ROOT).enabled,
+            "run_id": resolve_coordinator_run_id(project_dir=_OMG_ROOT),
+        },
     }
 
     return TeamDispatchResult(status="ok", findings=findings, actions=actions, evidence=evidence)
@@ -675,6 +700,27 @@ def execute_crazy_mode(
         context_parts.append(f"Focus files: {', '.join(files[:8])}")
     full_context = "\n\n".join(context_parts) if context_parts else ""
     
+    run_id = resolve_coordinator_run_id(project_dir=project_dir)
+    kernel = get_exec_kernel(project_dir)
+    if run_id:
+        kernel.register_run(run_id, source="team_router.execute_crazy_mode", reason="crazy_mode")
+    context_packet = _build_router_context_packet(
+        project_dir=project_dir,
+        run_id=run_id,
+        summary=full_context,
+        files=files,
+    )
+    clarification_status = _extract_clarification_status(context_packet)
+    if clarification_status.get("requires_clarification") is True:
+        return _build_clarification_blocked_result(
+            mode="crazy",
+            target_worker_count=5,
+            run_id=run_id,
+            clarification_status=clarification_status,
+            problem=problem,
+            project_dir=project_dir,
+        )
+
     worker_tasks = [
         {
             "agent_name": "architect-mode",
@@ -738,14 +784,6 @@ def execute_crazy_mode(
         + "\n\nProvide a unified action plan with dependency ordering."
     )
 
-    run_id = resolve_coordinator_run_id(project_dir=project_dir)
-    context_packet = _build_router_context_packet(
-        project_dir=project_dir,
-        run_id=run_id,
-        summary=full_context,
-        files=files,
-    )
-
     council_verdicts = run_critics(
         candidate={"output": synthesis_prompt},
         context_packet=context_packet,
@@ -763,6 +801,8 @@ def execute_crazy_mode(
 
     return {
         "status": "ok",
+        "stages": list(_TEAM_STAGED_FLOW),
+        "current_stage": "team-fix",
         "phases": [
             {"phase": 1, "agent": "claude-orchestrator", "status": "completed"},
             *[
@@ -790,6 +830,11 @@ def execute_crazy_mode(
             f"Council status: {council_status}",
         ],
         "council_verdicts": council_verdicts,
+        "exec_kernel": {
+            "enabled": kernel.enabled,
+            "run_id": run_id,
+            "attach_log": kernel.attach_log(run_id) if run_id else "",
+        },
     }
 
 
@@ -816,6 +861,27 @@ def execute_ccg_mode(
         context_parts.append(f"Focus files: {', '.join(files[:8])}")
     full_context = "\n\n".join(context_parts) if context_parts else ""
 
+    run_id = resolve_coordinator_run_id(project_dir=project_dir)
+    kernel = get_exec_kernel(project_dir)
+    if run_id:
+        kernel.register_run(run_id, source="team_router.execute_ccg_mode", reason="ccg_mode")
+    context_packet = _build_router_context_packet(
+        project_dir=project_dir,
+        run_id=run_id,
+        summary=full_context,
+        files=files,
+    )
+    clarification_status = _extract_clarification_status(context_packet)
+    if clarification_status.get("requires_clarification") is True:
+        return _build_clarification_blocked_result(
+            mode="ccg",
+            target_worker_count=2,
+            run_id=run_id,
+            clarification_status=clarification_status,
+            problem=problem,
+            project_dir=project_dir,
+        )
+
     worker_tasks = [
         {
             "agent_name": "backend-engineer",
@@ -852,14 +918,6 @@ def execute_ccg_mode(
         + "\n\nProvide a unified action plan merging backend and frontend perspectives."
     )
 
-    run_id = resolve_coordinator_run_id(project_dir=project_dir)
-    context_packet = _build_router_context_packet(
-        project_dir=project_dir,
-        run_id=run_id,
-        summary=full_context,
-        files=files,
-    )
-
     council_verdicts = run_critics(
         candidate={"output": synthesis_prompt},
         context_packet=context_packet,
@@ -877,6 +935,8 @@ def execute_ccg_mode(
 
     return {
         "status": "ok",
+        "stages": list(_TEAM_STAGED_FLOW),
+        "current_stage": "team-fix",
         "phases": [
             {"phase": 1, "agent": "claude-orchestrator", "status": "completed"},
             *[
@@ -904,6 +964,87 @@ def execute_ccg_mode(
             f"Council status: {council_status}",
         ],
         "council_verdicts": council_verdicts,
+        "exec_kernel": {
+            "enabled": kernel.enabled,
+            "run_id": run_id,
+            "attach_log": kernel.attach_log(run_id) if run_id else "",
+        },
+    }
+
+
+def _persist_question_state(
+    project_dir: str,
+    run_id: str,
+    question_text: str,
+    mode: str,
+    problem: str,
+) -> None:
+    """Write minimal question state to the run-state directory.
+
+    This is NOT a new schema — it is a flat file under .omg/state/ that
+    records which question is pending so the session can resume or reject.
+    """
+    state_dir = Path(project_dir) / ".omg" / "state" / "pending_question"
+    state_dir.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "question_pending": True,
+        "question_text": str(question_text).strip()[:500],
+        "mode": mode,
+        "problem": str(problem).strip()[:200],
+        "run_id": run_id,
+        "emitted_at": datetime.now(timezone.utc).isoformat(),
+    }
+    target = state_dir / f"{run_id}.json"
+    tmp = target.with_suffix(".tmp")
+    tmp.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    os.rename(tmp, target)
+
+
+def _build_clarification_blocked_result(
+    *,
+    mode: str,
+    target_worker_count: int,
+    run_id: str | None,
+    clarification_status: dict[str, Any],
+    problem: str,
+    project_dir: str = "",
+) -> dict[str, Any]:
+    """Build a blocked result when clarification is required.
+
+    The returned dict signals ``status='clarification_required'`` which
+    guarantees the turn ends — no worker dispatch or tool action follows.
+    Minimal question state is persisted via the run-state directory so the
+    session can resume or reject the question later.
+    """
+    prompt = str(clarification_status.get("clarification_prompt", "")).strip()
+    findings = [
+        f"Staged flow halted at team-plan for {mode} routing",
+        "Clarification unresolved before worker dispatch",
+    ]
+    if prompt:
+        findings.append(f"Clarification request: {prompt}")
+
+    # Persist minimal run-scoped question state for resume / reject
+    if run_id and project_dir:
+        _persist_question_state(project_dir, run_id, prompt, mode, problem)
+
+    return {
+        "status": "clarification_required",
+        "stages": list(_TEAM_STAGED_FLOW),
+        "current_stage": "team-plan",
+        "parallel_execution": False,
+        "sequential_execution": False,
+        "worker_count": 0,
+        "target_worker_count": target_worker_count,
+        "findings": findings,
+        "actions": [
+            "Clarify intent and acceptance criteria",
+            "Confirm required files and expected outcome",
+            "Re-run /OMG:team once clarification is resolved",
+        ],
+        "clarification_status": clarification_status,
+        "problem": problem,
+        "run_id": run_id,
     }
 
 
@@ -936,31 +1077,12 @@ def _build_router_context_packet(
 
 
 def _extract_clarification_status(context_packet: dict[str, Any] | None) -> dict[str, Any]:
-    if not isinstance(context_packet, dict):
-        return {
-            "requires_clarification": False,
-            "intent_class": "",
-            "clarification_prompt": "",
-            "confidence": 0.0,
-        }
-    status = context_packet.get("clarification_status")
-    if not isinstance(status, dict):
-        return {
-            "requires_clarification": False,
-            "intent_class": "",
-            "clarification_prompt": "",
-            "confidence": 0.0,
-        }
-    prompt = str(status.get("clarification_prompt", "")).strip().replace("\n", " ")
-    try:
-        confidence = float(status.get("confidence", 0.0))
-    except (TypeError, ValueError):
-        confidence = 0.0
+    status = _extract_clarification(context_packet)
     return {
         "requires_clarification": bool(status.get("requires_clarification") is True),
         "intent_class": str(status.get("intent_class", "")).strip(),
-        "clarification_prompt": prompt,
-        "confidence": round(max(0.0, min(1.0, confidence)), 2),
+        "clarification_prompt": str(status.get("clarification_prompt", "")).strip(),
+        "confidence": round(float(status.get("confidence", 0.0)), 2),
     }
 
 
@@ -1062,7 +1184,7 @@ def get_active_credential(provider: str, session_id: str | None = None) -> str |
 
     try:
         store = cred_mod.load_store(passphrase)
-    except (ValueError, OSError):
+    except (ValueError, OSError, RuntimeError):
         return None
 
     providers = store.get("providers", {})
@@ -1093,7 +1215,7 @@ def get_active_credential(provider: str, session_id: str | None = None) -> str |
     # Persist updated stats (best-effort)
     try:
         cred_mod.save_store(store, passphrase)
-    except (ValueError, OSError):
+    except (ValueError, OSError, RuntimeError):
         pass
 
     return keys[idx].get("key")
@@ -1122,7 +1244,7 @@ def on_rate_limit(provider: str, session_id: str | None = None) -> str | None:
 
     try:
         store = cred_mod.load_store(passphrase)
-    except (ValueError, OSError):
+    except (ValueError, OSError, RuntimeError):
         return None
 
     providers = store.get("providers", {})
@@ -1145,7 +1267,7 @@ def on_rate_limit(provider: str, session_id: str | None = None) -> str | None:
     # Persist (best-effort)
     try:
         cred_mod.save_store(store, passphrase)
-    except (ValueError, OSError):
+    except (ValueError, OSError, RuntimeError):
         pass
 
     return keys[new_idx].get("key")

package/build/lib/runtime/test_intent_lock.py

@@ -142,6 +142,33 @@ def verify_lock(project_dir: str, run_id: str | None, lock_id: str | None = None
     }
 
 
+def verify_done_when(metadata: dict[str, Any] | None, run_id: str | None) -> dict[str, Any]:
+    metadata_obj = metadata if isinstance(metadata, dict) else {}
+    criteria = _extract_done_when_criteria(metadata_obj.get("done_when"))
+    if not criteria:
+        return {
+            "status": "missing_done_when",
+            "reason": "done_when_required",
+            "run_id": str(run_id or "").strip() or None,
+        }
+
+    done_when_run_id = _extract_done_when_run_id(metadata_obj.get("done_when"))
+    normalized_run_id = str(run_id or "").strip()
+    if done_when_run_id and normalized_run_id and done_when_run_id != normalized_run_id:
+        return {
+            "status": "done_when_contract_mismatch",
+            "reason": "done_when_run_id_mismatch",
+            "run_id": normalized_run_id,
+        }
+
+    return {
+        "status": "ok",
+        "reason": "done_when_present",
+        "run_id": normalized_run_id or done_when_run_id or None,
+        "done_when": criteria,
+    }
+
+
 def evaluate_test_delta(delta: dict[str, Any], project_dir: str | None = None) -> dict[str, Any]:
     override = delta.get("override")
     waiver_artifact = delta.get("waiver_artifact")
@@ -296,6 +323,30 @@ def _normalize_string_list(value: Any) -> list[str]:
     return [str(item).strip() for item in value if str(item).strip()]
 
 
+def _extract_done_when_criteria(value: Any) -> list[str]:
+    if isinstance(value, str):
+        token = value.strip()
+        return [token] if token else []
+    if isinstance(value, list):
+        return _normalize_string_list(value)
+    if isinstance(value, dict):
+        criteria = value.get("criteria")
+        if isinstance(criteria, str):
+            token = criteria.strip()
+            return [token] if token else []
+        if isinstance(criteria, list):
+            return _normalize_string_list(criteria)
+        summary = str(value.get("summary", "")).strip()
+        return [summary] if summary else []
+    return []
+
+
+def _extract_done_when_run_id(value: Any) -> str:
+    if isinstance(value, dict):
+        return str(value.get("run_id", "")).strip()
+    return ""
+
+
 def _selector_to_path(selector: str) -> str:
     return selector.split("::", 1)[0].strip()