@trac3er/oh-my-god 2.1.0 → 2.1.4

package/build/lib/runtime/session_health.py

@@ -8,6 +8,8 @@ import os
 from pathlib import Path
 from typing import Any
 
+from runtime.runtime_contracts import write_run_state
+
 
 _SESSION_HEALTH_REL = Path(".omg") / "state" / "session_health"
 _DEFENSE_STATE_REL = Path(".omg") / "state" / "defense_state" / "current.json"
@@ -15,8 +17,9 @@ _CONTEXT_PRESSURE_REL = Path(".omg") / "state" / ".context-pressure.json"
 _JOURNAL_REL = Path(".omg") / "state" / "interaction_journal"
 
 _DEFAULT_THRESHOLDS: dict[str, Any] = {
-    "contamination_risk": {"warn": 0.3, "block": 0.7},
-    "overthinking_score": {"warn": 0.5, "block": 0.85},
+    "contamination_risk": {"reflect": 0.05, "block": 0.7},
+    "overthinking_score": {"reflect": 0.15, "block": 0.85},
+    "premature_fixer_score": {"reflect": 0.5},
     "context_health": {"warn": 0.4, "critical": 0.2},
 }
 
@@ -53,28 +56,52 @@ def compute_session_health(
             pressure_ratio,
         )
     )
+    premature_fixer_score = _clamp(_to_float(defense.get("premature_fixer_score"), 0.0))
+    clarification_sensitive = bool(defense.get("clarification_sensitive") is True)
 
     context_health = _compute_context_health(pressure_ratio, journal_count)
 
     verification_status = str(verification.get("status", "unknown"))
 
-    recommended_action = _recommend_action(
+    action_recommendations = _recommend_actions(
         contamination_risk=contamination_risk,
         overthinking_score=overthinking_score,
+        premature_fixer_score=premature_fixer_score,
+        clarification_sensitive=clarification_sensitive,
         context_health=context_health,
         verification_status=verification_status,
     )
+    recommended_action = action_recommendations[0] if action_recommendations else "continue"
+    reflect_triggers = {
+        "contamination": contamination_risk > _DEFAULT_THRESHOLDS["contamination_risk"]["reflect"],
+        "overthinking": overthinking_score > _DEFAULT_THRESHOLDS["overthinking_score"]["reflect"],
+        "premature_fixer": premature_fixer_score > _DEFAULT_THRESHOLDS["premature_fixer_score"]["reflect"],
+    }
+
+    _ACTION_TO_STATUS = {
+        "continue": "ok",
+        "warn": "running",
+        "reflect": "running",
+        "block": "blocked",
+    }
+    status = _ACTION_TO_STATUS.get(recommended_action, "running")
 
     result: dict[str, Any] = {
         "schema": "SessionHealth",
         "schema_version": "1.0.0",
         "run_id": run_id,
+        "status": status,
         "contamination_risk": round(contamination_risk, 4),
         "overthinking_score": round(overthinking_score, 4),
+        "premature_fixer_score": round(premature_fixer_score, 4),
+        "clarification_sensitive": clarification_sensitive,
         "context_health": round(context_health, 4),
         "verification_status": verification_status,
         "journal_steps": journal_count,
         "recommended_action": recommended_action,
+        "action_recommendations": action_recommendations,
+        "defense_pause_required": bool(reflect_triggers["contamination"] or reflect_triggers["overthinking"]),
+        "reflect_triggers": reflect_triggers,
         "thresholds": dict(_DEFAULT_THRESHOLDS),
         "sources": {
             "defense_state": bool(defense),
@@ -85,37 +112,54 @@ def compute_session_health(
         "updated_at": datetime.now(timezone.utc).isoformat(),
     }
 
-    _write_atomic(root / _SESSION_HEALTH_REL / f"{run_id}.json", result)
+    write_run_state(project_dir, "session_health", run_id, result)
     return result
 
 
-def _recommend_action(
+def _recommend_actions(
     *,
     contamination_risk: float,
     overthinking_score: float,
+    premature_fixer_score: float,
+    clarification_sensitive: bool,
     context_health: float,
     verification_status: str,
-) -> str:
+) -> list[str]:
     thresholds = _DEFAULT_THRESHOLDS
+    actions: list[str] = []
 
     if contamination_risk >= thresholds["contamination_risk"]["block"]:
-        return "block"
+        actions.append("block")
     if overthinking_score >= thresholds["overthinking_score"]["block"]:
-        return "block"
+        actions.append("block")
+
+    if actions:
+        return ["block"]
+
+    if clarification_sensitive:
+        if contamination_risk > thresholds["contamination_risk"]["reflect"]:
+            actions.append("reflect")
+        if overthinking_score > thresholds["overthinking_score"]["reflect"]:
+            actions.append("reflect")
+        if premature_fixer_score > thresholds["premature_fixer_score"]["reflect"]:
+            actions.append("reflect")
 
-    if contamination_risk >= thresholds["contamination_risk"]["warn"]:
-        return "reflect"
-    if overthinking_score >= thresholds["overthinking_score"]["warn"]:
-        return "reflect"
     if context_health <= thresholds["context_health"]["critical"]:
-        return "reflect"
+        actions.append("reflect")
 
     if verification_status in ("error", "blocked"):
-        return "warn"
+        actions.append("warn")
     if context_health <= thresholds["context_health"]["warn"]:
-        return "warn"
+        actions.append("warn")
+
+    if actions:
+        deduped: list[str] = []
+        for action in actions:
+            if action not in deduped:
+                deduped.append(action)
+        return deduped
 
-    return "continue"
+    return ["continue"]
 
 
 def _compute_context_health(pressure_ratio: float, journal_count: int) -> float:

package/build/lib/runtime/team_router.py

@@ -22,6 +22,8 @@ _ROUTER_DIR = os.path.dirname(os.path.abspath(__file__))
 _OMG_ROOT = os.path.dirname(_ROUTER_DIR)
 
 _logger = logging.getLogger(__name__)
+_ROUTING_MODE_DEFAULT = "normal"
+_ROUTING_MODE_CLARIFICATION = "planning_read_only"
 
 # Import providers to trigger auto-registration in provider registry
 try:
@@ -32,18 +34,25 @@ except ImportError:
     pass
 
 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.context_engine import ContextEngine
+from runtime.context_engine import render_profile_digest_text
+from runtime.defense_state import DefenseState
 from runtime.equalizer import select_provider
 from runtime.router_executor import WorkerTask, execute_workers
 from runtime.router_critics import run_critics
 from runtime.router_selector import collect_cli_health as _selector_collect_cli_health
 from runtime.router_selector import infer_target as _selector_infer_target
 from runtime.router_selector import select_target
+from runtime.session_health import compute_session_health
 
 @dataclass
 class TeamDispatchRequest:
     target: str  # codex | gemini | ccg | auto
     problem: str
     context: str = ""
+    context_packet: dict[str, Any] | None = None
     files: list[str] | None = None
     expected_outcome: str = ""
 
@@ -192,6 +201,9 @@ def dispatch_team(req: TeamDispatchRequest) -> TeamDispatchResult:
         selected = select_target(req.problem, req.context)
         target = selected["target"]
 
+    clarification_status = _extract_clarification_status(req.context_packet)
+    clarification_required = bool(clarification_status.get("requires_clarification") is True)
+
     findings = [f"Target router selected: {target}", f"Problem: {req.problem}"]
     if req.files:
         findings.append(f"Focus files: {', '.join(req.files[:8])}")
@@ -243,12 +255,24 @@ def dispatch_team(req: TeamDispatchRequest) -> TeamDispatchResult:
             ]
         )
 
+    routing_mode = _ROUTING_MODE_DEFAULT
+    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",
+        ]
+
     evidence = {
         "target": target,
         "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,
+        "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,
     }
@@ -335,19 +359,16 @@ def _read_working_memory(project_dir: str) -> str:
 
 
 def _read_profile_context(project_dir: str) -> str:
-    """Read profile context from .omg/state/profile.yaml."""
     profile_path = os.path.join(project_dir, ".omg", "state", "profile.yaml")
     if not os.path.exists(profile_path):
         return ""
 
     try:
-        with open(profile_path, "r", encoding="utf-8", errors="replace") as f:
-            content = f.read()
-        if len(content) > 300:
-            content = content[:300] + "..."
-        return content
+        return render_profile_digest_text(project_dir, max_chars=300)
     except (OSError, UnicodeDecodeError):
         return ""
+    except Exception:
+        return ""
 
 
 def _read_failure_history(project_dir: str) -> str:
@@ -507,9 +528,10 @@ def dispatch_to_model(agent_name: str, user_prompt: str, project_dir: str) -> di
         detect_available_models = getattr(agent_registry, "detect_available_models", lambda: {"claude": True})
         get_provider_with_equalizer = getattr(agent_registry, "get_provider_with_equalizer", None)
 
-        agent = AGENT_REGISTRY.get(agent_name)
-        if not agent:
+        agent_obj = AGENT_REGISTRY.get(agent_name)
+        if not isinstance(agent_obj, dict):
             return {"error": f"Unknown agent: {agent_name}", "fallback": "claude"}
+        agent = agent_obj
 
         available = detect_available_models()
         preferred = agent.get("preferred_model", "claude")
@@ -519,7 +541,8 @@ def dispatch_to_model(agent_name: str, user_prompt: str, project_dir: str) -> di
                 project_dir=project_dir,
                 agent_name=agent_name,
             )
-            preferred = equalizer_info.get("preferred_model", preferred)
+            if isinstance(equalizer_info, dict):
+                preferred = str(equalizer_info.get("preferred_model", preferred))
         packaged = package_prompt(agent_name, user_prompt, project_dir)
 
         provider_name_map = {
@@ -692,11 +715,22 @@ def execute_crazy_mode(
         + "\n\nProvide a unified action plan with dependency ordering."
     )
 
-    _ = run_critics(
+    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={"summary": full_context},
+        context_packet=context_packet,
         project_dir=project_dir,
     )
+    _persist_council_verdicts(project_dir, run_id, council_verdicts)
+    _update_post_council_state(project_dir=project_dir, run_id=run_id)
+    council_status = _council_status(council_verdicts)
 
     model_mix = {
         "gpt": [r.get("agent") for r in results if r.get("model") == "codex-cli"],
@@ -730,7 +764,9 @@ def execute_crazy_mode(
             f"GPT tracks: {len(model_mix['gpt'])}",
             f"Gemini tracks: {len(model_mix['gemini'])}",
             f"Claude tracks: {len(model_mix['claude'])}",
+            f"Council status: {council_status}",
         ],
+        "council_verdicts": council_verdicts,
     }
 
 
@@ -793,11 +829,22 @@ def execute_ccg_mode(
         + "\n\nProvide a unified action plan merging backend and frontend perspectives."
     )
 
-    _ = run_critics(
+    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={"summary": full_context},
+        context_packet=context_packet,
         project_dir=project_dir,
     )
+    _persist_council_verdicts(project_dir, run_id, council_verdicts)
+    _update_post_council_state(project_dir=project_dir, run_id=run_id)
+    council_status = _council_status(council_verdicts)
 
     model_mix = {
         "gpt": [r.get("agent") for r in results if r.get("model") == "codex-cli"],
@@ -831,8 +878,104 @@ def execute_ccg_mode(
             f"GPT tracks: {len(model_mix['gpt'])}",
             f"Gemini tracks: {len(model_mix['gemini'])}",
             f"Claude tracks: {len(model_mix['claude'])}",
+            f"Council status: {council_status}",
         ],
+        "council_verdicts": council_verdicts,
+    }
+
+
+def _build_router_context_packet(
+    *,
+    project_dir: str,
+    run_id: str | None,
+    summary: str,
+    files: list[str] | None,
+) -> dict[str, object]:
+    if run_id:
+        packet = ContextEngine(project_dir).build_packet(run_id=run_id, delta_only=True)
+        if summary and not str(packet.get("summary", "")).strip():
+            packet["summary"] = summary
+        if _requires_clarification(packet):
+            packet["routing_mode"] = _ROUTING_MODE_CLARIFICATION
+        return packet
+    return {
+        "summary": summary,
+        "artifact_pointers": [],
+        "clarification_status": {
+            "requires_clarification": False,
+            "intent_class": "",
+            "clarification_prompt": "",
+            "confidence": 0.0,
+        },
+        "routing_mode": _ROUTING_MODE_DEFAULT,
+        "files": list(files or []),
+    }
+
+
+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
+    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),
+    }
+
+
+def _requires_clarification(context_packet: dict[str, object]) -> bool:
+    status = _extract_clarification_status(cast(dict[str, Any], context_packet))
+    return bool(status.get("requires_clarification") is True)
+
+
+def _persist_council_verdicts(project_dir: str, run_id: str | None, verdicts: dict[str, dict[str, Any]]) -> None:
+    if not run_id:
+        return
+
+    payload: dict[str, object] = {
+        "status": _council_status(verdicts),
+        "verification_status": _council_status(verdicts),
+        "verdicts": verdicts,
+    }
+    write_run_state(project_dir, "council_verdicts", run_id, payload)
+
+
+def _update_post_council_state(*, project_dir: str, run_id: str | None) -> None:
+    DefenseState(project_dir).update()
+    compute_session_health(project_dir, run_id=run_id or "default")
+
+
+def _council_status(verdicts: dict[str, dict[str, Any]]) -> str:
+    verdict_tokens = {
+        str(item.get("verdict", "")).strip().lower()
+        for item in verdicts.values()
+        if isinstance(item, dict)
     }
+    if "fail" in verdict_tokens:
+        return "blocked"
+    if "warn" in verdict_tokens:
+        return "running"
+    if "pass" in verdict_tokens:
+        return "ok"
+    return "pending"
 
 
 # =============================================================================

package/build/lib/runtime/test_intent_lock.py

@@ -69,6 +69,79 @@ def verify_intent(project_dir: str, lock_id: str, results: dict[str, Any]) -> di
     return {"status": status, "lock_id": lock_id, "reasons": reasons}
 
 
+def verify_lock(project_dir: str, run_id: str | None, lock_id: str | None = None) -> dict[str, Any]:
+    normalized_run_id = str(run_id or "").strip()
+    normalized_lock_id = str(lock_id or "").strip()
+
+    if normalized_lock_id:
+        payload = _load_lock_payload_from_project(project_dir, normalized_lock_id)
+        if payload is None:
+            return {
+                "status": "missing_lock",
+                "reason": "no_active_test_intent_lock",
+                "run_id": normalized_run_id or None,
+                "lock_id": normalized_lock_id,
+            }
+
+        contract_check = _check_run_contract(payload, normalized_run_id)
+        if contract_check is not None:
+            return {
+                "status": "lock_contract_mismatch",
+                "reason": contract_check,
+                "run_id": normalized_run_id or None,
+                "lock_id": normalized_lock_id,
+            }
+
+        return {
+            "status": "ok",
+            "reason": "active_test_intent_lock",
+            "run_id": normalized_run_id or None,
+            "lock_id": normalized_lock_id,
+        }
+
+    if not normalized_run_id:
+        return {
+            "status": "missing_lock",
+            "reason": "no_active_test_intent_lock",
+            "run_id": None,
+            "lock_id": None,
+        }
+
+    lock_dir = Path(project_dir) / ".omg" / "state" / "test-intent-lock"
+    if not lock_dir.exists():
+        return {
+            "status": "missing_lock",
+            "reason": "no_active_test_intent_lock",
+            "run_id": normalized_run_id,
+            "lock_id": None,
+        }
+
+    for path in sorted(lock_dir.glob("*.json"), key=lambda candidate: candidate.stat().st_mtime, reverse=True):
+        payload = _load_lock_payload_from_path(path)
+        if payload is None:
+            continue
+        intent = payload.get("intent")
+        intent_run_id = ""
+        if isinstance(intent, dict):
+            intent_run_id = str(intent.get("run_id", "")).strip()
+        if intent_run_id != normalized_run_id:
+            continue
+        lock_id_candidate = str(payload.get("lock_id", "")).strip() or path.stem
+        return {
+            "status": "ok",
+            "reason": "active_test_intent_lock",
+            "run_id": normalized_run_id,
+            "lock_id": lock_id_candidate,
+        }
+
+    return {
+        "status": "missing_lock",
+        "reason": "no_active_test_intent_lock",
+        "run_id": normalized_run_id,
+        "lock_id": None,
+    }
+
+
 def evaluate_test_delta(delta: dict[str, Any]) -> dict[str, Any]:
     override = delta.get("override")
     waiver_artifact = delta.get("waiver_artifact")
@@ -244,6 +317,35 @@ def _load_lock_payload(lock_id: str) -> dict[str, Any] | None:
     return payload
 
 
+def _load_lock_payload_from_project(project_dir: str, lock_id: str) -> dict[str, Any] | None:
+    lock_path = Path(project_dir) / ".omg" / "state" / "test-intent-lock" / f"{lock_id}.json"
+    return _load_lock_payload_from_path(lock_path)
+
+
+def _load_lock_payload_from_path(lock_path: Path) -> dict[str, Any] | None:
+    try:
+        payload = json.loads(lock_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, dict):
+        return None
+    return payload
+
+
+def _check_run_contract(payload: dict[str, Any], run_id: str) -> str | None:
+    if not run_id:
+        return None
+    intent = payload.get("intent")
+    if not isinstance(intent, dict):
+        return "run_id_mismatch"
+    intent_run_id = str(intent.get("run_id", "")).strip()
+    if not intent_run_id:
+        return "run_id_mismatch"
+    if intent_run_id != run_id:
+        return "run_id_mismatch"
+    return None
+
+
 def _evaluate_locked_contract(
     lock_payload: dict[str, Any],
     selectors: list[str],