@trac3er/oh-my-god 2.1.0 → 2.1.4

package/build/lib/runtime/contract_compiler.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import hashlib
 import asyncio
 import importlib
+import importlib.util
 import json
 import os
 from pathlib import Path
@@ -20,6 +21,8 @@ import yaml
 
 from runtime.asset_loader import resolve_asset, resolve_assets
 from runtime.proof_chain import _normalize_evidence_pack
+from runtime.evidence_requirements import requirements_for_profile
+from runtime.runtime_contracts import schema_versions
 from runtime.adoption import (
     CANONICAL_MARKETPLACE_ID,
     CANONICAL_PACKAGE_NAME,
@@ -141,6 +144,23 @@ HOST_COMPILED_ARTIFACTS = {
     ),
 }
 
+_REQUIRED_EXECUTION_PRIMITIVES = (
+    "release_run_coordinator_state",
+    "tdd_proof_chain_lock",
+    "rollback_manifest",
+    "intent_gate_state",
+    "profile_digest",
+    "session_health_state",
+    "council_verdicts",
+    "forge_starter_proof",
+)
+
+_REQUIRED_CONTEXT_METADATA = (
+    "context_checksum",
+    "profile_version",
+    "intent_gate_version",
+)
+
 
 def _ensure_list(
     *,
@@ -1419,78 +1439,58 @@ def _check_mcp_fabric() -> dict[str, Any]:
 
 
 def _check_version_identity_drift(root: Path) -> dict[str, Any]:
-    """Check version/identity drift across all public surface files.
-    
-    Returns a dict with:
-    - status: "ok" or "error"
-    - blockers: list of named blockers for each mismatch
-    - drift_details: dict mapping file paths to their found versions
-    """
     canonical_version = CANONICAL_VERSION
     blockers: list[str] = []
     drift_details: dict[str, str] = {}
-    
-    # Files to check with their JSON paths to extract version
-    files_to_check = [
-        ("package.json", ["version"]),
-        ("pyproject.toml", None),  # Special case: extract from version = "X.Y.Z"
-        ("settings.json", ["_omg", "_version"]),
-        (".claude-plugin/plugin.json", ["version"]),
-        (".claude-plugin/marketplace.json", ["version"]),
-        ("plugins/core/plugin.json", ["version"]),
-        ("plugins/advanced/plugin.json", ["version"]),
-        ("CHANGELOG.md", None),  # Special case: check for version in header
-    ]
-    
-    for file_path, json_path in files_to_check:
-        full_path = root / file_path
-        if not full_path.exists():
-            blockers.append(f"version_drift: missing file {file_path}")
-            continue
-        
-        found_version = None
-        
-        try:
-            if file_path == "pyproject.toml":
-                # Extract from version = "X.Y.Z"
-                content = full_path.read_text(encoding="utf-8")
-                for line in content.split("\n"):
-                    if line.startswith("version = "):
-                        found_version = line.split('"')[1]
-                        break
-            elif file_path == "CHANGELOG.md":
-                # Extract from "## X.Y.Z -" header (skip "Unreleased" section)
-                content = full_path.read_text(encoding="utf-8")
-                for line in content.split("\n"):
-                    if line.startswith("## ") and " - " in line:
-                        version_str = line.split(" - ")[0].replace("## ", "").strip()
-                        if version_str.lower() != "unreleased":
-                            found_version = version_str
-                            break
-            else:
-                # JSON file: use json_path to navigate
-                data = _load_json(full_path)
-                current = data
-                if json_path:
-                    for key in json_path:
-                        current = current.get(key)
-                        if current is None:
-                            break
-                found_version = current
-        except Exception as e:
-            blockers.append(f"version_drift: failed to parse {file_path}: {e}")
+
+    from runtime.release_surfaces import AUTHORED_SURFACES
+
+    sync_script = Path(__file__).resolve().parents[1] / "scripts" / "sync-release-identity.py"
+    if not sync_script.exists():
+        return {
+            "status": "error",
+            "canonical_version": canonical_version,
+            "blockers": ["version_drift: missing scripts/sync-release-identity.py"],
+            "drift_details": {},
+        }
+
+    spec = importlib.util.spec_from_file_location("sync_release_identity", sync_script)
+    if spec is None or spec.loader is None:
+        return {
+            "status": "error",
+            "canonical_version": canonical_version,
+            "blockers": ["version_drift: unable to load scripts/sync-release-identity.py"],
+            "drift_details": {},
+        }
+
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    check_surface = getattr(module, "check_surface", None)
+    if not callable(check_surface):
+        return {
+            "status": "error",
+            "canonical_version": canonical_version,
+            "blockers": ["version_drift: scripts/sync-release-identity.py missing check_surface"],
+            "drift_details": {},
+        }
+
+    for surface in AUTHORED_SURFACES:
+        raw_drifts = check_surface(root, surface, canonical_version)
+        if not isinstance(raw_drifts, list):
+            blockers.append(
+                f"version_drift: {surface.file_path} has version <invalid drift payload>, expected {canonical_version}"
+            )
             continue
-        
-        if found_version is None:
-            blockers.append(f"version_drift: could not extract version from {file_path}")
-        elif str(found_version) != canonical_version:
+        for drift in raw_drifts:
+            if not isinstance(drift, (tuple, list)) or len(drift) != 2:
+                continue
+            label, found = drift
+            found_value = "<not found>" if found is None else str(found)
             blockers.append(
-                f"version_drift: {file_path} has version {found_version}, expected {canonical_version}"
+                f"version_drift: {label} has version {found_value}, expected {canonical_version}"
             )
-            drift_details[file_path] = str(found_version)
-        else:
-            drift_details[file_path] = str(found_version)
-    
+            drift_details[str(label)] = found_value
+
     return {
         "status": "ok" if not blockers else "error",
         "canonical_version": canonical_version,
@@ -1811,6 +1811,10 @@ def build_release_readiness(
     checks["proof_chain"] = proof_chain_check
     blockers.extend(proof_chain_check.get("blockers", []))
 
+    execution_primitives = _check_execution_primitives(output_root=output, evidence_profile="release")
+    checks["execution_primitives"] = execution_primitives
+    blockers.extend(execution_primitives.get("blockers", []))
+
     security_blockers = [
         blocker
         for blocker in evidence_check.get("blockers", [])
@@ -1879,35 +1883,11 @@ def build_release_readiness(
 
 
 def _check_recent_evidence(output_root: Path) -> dict[str, Any]:
-    evidence_dir = output_root / ".omg" / "evidence"
-    if not evidence_dir.exists():
-        return {"status": "missing", "blockers": []}
-
-    evidence_files = sorted(path for path in evidence_dir.glob("*.json") if path.is_file())
-    if not evidence_files:
+    latest = _latest_evidence_pack(output_root)
+    if latest is None:
         return {"status": "missing", "blockers": []}
 
-    evidence_payloads: list[tuple[Path, dict[str, Any]]] = []
-    for path in evidence_files:
-        try:
-            payload = _load_json(path)
-        except Exception:
-            continue
-        if payload.get("schema") == "EvidencePack":
-            try:
-                payload = _normalize_evidence_pack(payload)
-            except ValueError as exc:
-                return {
-                    "status": "error",
-                    "evidence_file": str(path.relative_to(output_root)),
-                    "blockers": [f"invalid evidence pack: {exc}"],
-                }
-            evidence_payloads.append((path, payload))
-
-    if not evidence_payloads:
-        return {"status": "missing", "blockers": []}
-
-    evidence_path, payload = evidence_payloads[-1]
+    evidence_path, payload = latest
     blockers: list[str] = []
     if not payload.get("security_scans"):
         blockers.append("cosmetic evidence: security_scans is empty")
@@ -1936,10 +1916,307 @@ def _check_recent_evidence(output_root: Path) -> dict[str, Any]:
     return {
         "status": "ok" if not blockers else "error",
         "evidence_file": str(evidence_path.relative_to(output_root)),
+        "run_id": str(payload.get("run_id", "")).strip(),
         "blockers": blockers,
     }
 
 
+def _latest_evidence_pack(output_root: Path) -> tuple[Path, dict[str, Any]] | None:
+    evidence_dir = output_root / ".omg" / "evidence"
+    if not evidence_dir.exists():
+        return None
+
+    evidence_files = sorted(path for path in evidence_dir.glob("*.json") if path.is_file())
+    evidence_payloads: list[tuple[Path, dict[str, Any]]] = []
+    for path in evidence_files:
+        try:
+            payload = _load_json(path)
+        except Exception:
+            continue
+        if payload.get("schema") != "EvidencePack":
+            continue
+        try:
+            payload = _normalize_evidence_pack(payload)
+        except ValueError as exc:
+            return path, {"schema": "EvidencePack", "invalid": f"invalid evidence pack: {exc}"}
+        evidence_payloads.append((path, payload))
+
+    if not evidence_payloads:
+        return None
+    return evidence_payloads[-1]
+
+
+def _required_fields_for_module(module: str) -> list[str]:
+    metadata = schema_versions().get(module, {})
+    required = metadata.get("required_fields", []) if isinstance(metadata, dict) else []
+    if isinstance(required, list):
+        return [str(field) for field in required if str(field).strip()]
+    return []
+
+
+def _missing_context_metadata(payload: dict[str, Any]) -> list[str]:
+    missing: list[str] = []
+    for key in _REQUIRED_CONTEXT_METADATA:
+        value = str(payload.get(key, "")).strip()
+        if not value:
+            missing.append(key)
+    return missing
+
+
+def _check_execution_primitives(*, output_root: Path, evidence_profile: str | None = None) -> dict[str, Any]:
+    blockers: list[str] = []
+    missing: list[str] = []
+    invalid: list[str] = []
+    evidence_paths: dict[str, str] = {key: "" for key in _REQUIRED_EXECUTION_PRIMITIVES}
+    resolved_profile = (evidence_profile or "").strip()
+    required_evidence_requirements = requirements_for_profile(resolved_profile)
+
+    latest = _latest_evidence_pack(output_root)
+    if latest is None:
+        missing.extend(list(_REQUIRED_EXECUTION_PRIMITIVES))
+        blockers.extend(f"missing_execution_primitive: {item}" for item in missing)
+        return {
+            "status": "error",
+            "run_id": "",
+            "evidence_profile": resolved_profile,
+            "required_evidence_requirements": list(required_evidence_requirements),
+            "required": list(_REQUIRED_EXECUTION_PRIMITIVES),
+            "missing": missing,
+            "invalid": invalid,
+            "evidence_paths": evidence_paths,
+            "blockers": blockers,
+        }
+
+    evidence_path, evidence_payload = latest
+    invalid_evidence = str(evidence_payload.get("invalid", "")).strip()
+    if invalid_evidence:
+        invalid.append(f"release_evidence_pack:{invalid_evidence}")
+        blockers.append(f"invalid_execution_primitive: release_evidence_pack: {invalid_evidence}")
+        return {
+            "status": "error",
+            "run_id": "",
+            "evidence_profile": resolved_profile,
+            "required_evidence_requirements": list(required_evidence_requirements),
+            "required": list(_REQUIRED_EXECUTION_PRIMITIVES),
+            "missing": list(_REQUIRED_EXECUTION_PRIMITIVES),
+            "invalid": invalid,
+            "evidence_paths": evidence_paths,
+            "blockers": blockers,
+        }
+
+    if not resolved_profile:
+        resolved_profile = str(evidence_payload.get("evidence_profile", "")).strip()
+        required_evidence_requirements = requirements_for_profile(resolved_profile)
+
+    run_id = str(evidence_payload.get("run_id", "")).strip()
+    if not run_id:
+        invalid.append("run_id_unresolved")
+        blockers.append("invalid_execution_primitive: run_id_unresolved")
+
+    evidence_metadata_missing = _missing_context_metadata(evidence_payload)
+    if evidence_metadata_missing:
+        invalid.append("release_evidence_pack:missing_context_metadata")
+        blockers.append(
+            "invalid_execution_primitive: release_evidence_pack: "
+            f"missing_context_metadata={','.join(sorted(evidence_metadata_missing))}"
+        )
+
+    checks: list[tuple[str, str, str]] = [
+        ("release_run_coordinator_state", "release_run_coordinator", "ReleaseRunCoordinatorState"),
+        ("rollback_manifest", "rollback_manifest", "RollbackManifest"),
+        ("intent_gate_state", "intent_gate", "IntentGateDecision"),
+        ("session_health_state", "session_health", "SessionHealth"),
+        ("council_verdicts", "council_verdicts", "CouncilVerdicts"),
+    ]
+    for token, module, schema_name in checks:
+        matched_path, matched_payload = _find_state_for_run(output_root=output_root, module=module, run_id=run_id)
+        if matched_path is None or matched_payload is None:
+            missing.append(token)
+            blockers.append(f"missing_execution_primitive: {token}")
+            continue
+        evidence_paths[token] = str(matched_path.relative_to(output_root)).replace("\\", "/")
+        schema = str(matched_payload.get("schema", "")).strip()
+        if schema != schema_name:
+            invalid.append(f"{token}:schema_mismatch")
+            blockers.append(f"invalid_execution_primitive: {token}: schema_mismatch")
+            continue
+        required_fields = _required_fields_for_module(module)
+        missing_fields = [field for field in required_fields if field not in matched_payload]
+        if missing_fields:
+            invalid.append(f"{token}:missing_fields")
+            blockers.append(
+                f"invalid_execution_primitive: {token}: missing_fields={','.join(sorted(missing_fields))}"
+            )
+        if token in {"intent_gate_state", "session_health_state", "council_verdicts"}:
+            metadata_missing = _missing_context_metadata(matched_payload)
+            if metadata_missing:
+                invalid.append(f"{token}:missing_context_metadata")
+                blockers.append(
+                    f"invalid_execution_primitive: {token}: "
+                    f"missing_context_metadata={','.join(sorted(metadata_missing))}"
+                )
+
+    profile_path = output_root / ".omg" / "state" / "profile.yaml"
+    if not profile_path.exists():
+        missing.append("profile_digest")
+        blockers.append("missing_execution_primitive: profile_digest")
+    else:
+        evidence_paths["profile_digest"] = str(profile_path.relative_to(output_root)).replace("\\", "/")
+        try:
+            profile_payload = yaml.safe_load(profile_path.read_text(encoding="utf-8"))
+        except Exception:
+            profile_payload = None
+        profile_version = ""
+        if isinstance(profile_payload, dict):
+            profile_version = str(
+                profile_payload.get("profile_version")
+                or profile_payload.get("version")
+                or ""
+            ).strip()
+            if not profile_version:
+                provenance = profile_payload.get("profile_provenance")
+                if isinstance(provenance, dict):
+                    profile_version = str(
+                        provenance.get("checksum")
+                        or provenance.get("version")
+                        or ""
+                    ).strip()
+        if not profile_version:
+            invalid.append("profile_digest:missing_profile_version")
+            blockers.append("invalid_execution_primitive: profile_digest: missing_profile_version")
+
+    lock_path, lock_payload = _find_test_intent_lock(output_root=output_root, run_id=run_id, evidence_payload=evidence_payload)
+    if lock_path is None or lock_payload is None:
+        missing.append("tdd_proof_chain_lock")
+        blockers.append("missing_execution_primitive: tdd_proof_chain_lock")
+    else:
+        evidence_paths["tdd_proof_chain_lock"] = str(lock_path.relative_to(output_root)).replace("\\", "/")
+        lock_status = str(lock_payload.get("status", "")).strip().lower()
+        if lock_status in {"", "error", "blocked"}:
+            invalid.append("tdd_proof_chain_lock:status_invalid")
+            blockers.append("invalid_execution_primitive: tdd_proof_chain_lock: status_invalid")
+
+    forge_path, forge_payload = _find_forge_starter_proof(output_root=output_root, run_id=run_id)
+    if forge_path is None or forge_payload is None:
+        missing.append("forge_starter_proof")
+        blockers.append("missing_execution_primitive: forge_starter_proof")
+    else:
+        evidence_paths["forge_starter_proof"] = str(forge_path.relative_to(output_root)).replace("\\", "/")
+        forge_schema = str(forge_payload.get("schema", "")).strip()
+        if forge_schema != "ForgeSpecialistDispatchEvidence":
+            invalid.append("forge_starter_proof:schema_mismatch")
+            blockers.append("invalid_execution_primitive: forge_starter_proof: schema_mismatch")
+        if forge_payload.get("proof_backed") is not True:
+            invalid.append("forge_starter_proof:not_proof_backed")
+            blockers.append("invalid_execution_primitive: forge_starter_proof: proof_backed_false")
+        forge_metadata_missing = _missing_context_metadata(forge_payload)
+        if forge_metadata_missing:
+            invalid.append("forge_starter_proof:missing_context_metadata")
+            blockers.append(
+                "invalid_execution_primitive: forge_starter_proof: "
+                f"missing_context_metadata={','.join(sorted(forge_metadata_missing))}"
+            )
+
+    return {
+        "status": "ok" if not blockers else "error",
+        "run_id": run_id,
+        "evidence_profile": resolved_profile,
+        "required_evidence_requirements": list(required_evidence_requirements),
+        "evidence_pack": str(evidence_path.relative_to(output_root)).replace("\\", "/"),
+        "required": list(_REQUIRED_EXECUTION_PRIMITIVES),
+        "missing": sorted(set(missing)),
+        "invalid": sorted(set(invalid)),
+        "evidence_paths": evidence_paths,
+        "blockers": blockers,
+    }
+
+
+def _find_state_for_run(
+    *,
+    output_root: Path,
+    module: str,
+    run_id: str,
+) -> tuple[Path | None, dict[str, Any] | None]:
+    state_dir = output_root / ".omg" / "state" / module
+    if not state_dir.exists():
+        return None, None
+
+    preferred = state_dir / f"{run_id}.json"
+    if run_id and preferred.exists():
+        try:
+            payload = _load_json(preferred)
+        except Exception:
+            payload = {}
+        if isinstance(payload, dict):
+            return preferred, payload
+
+    for path in sorted(state_dir.glob("*.json")):
+        try:
+            payload = _load_json(path)
+        except Exception:
+            continue
+        if not isinstance(payload, dict):
+            continue
+        if run_id and str(payload.get("run_id", "")).strip() != run_id:
+            continue
+        return path, payload
+    return None, None
+
+
+def _find_test_intent_lock(
+    *,
+    output_root: Path,
+    run_id: str,
+    evidence_payload: dict[str, Any],
+) -> tuple[Path | None, dict[str, Any] | None]:
+    lock_dir = output_root / ".omg" / "state" / "test-intent-lock"
+    if not lock_dir.exists():
+        return None, None
+
+    lock_id = ""
+    test_delta = evidence_payload.get("test_delta")
+    if isinstance(test_delta, dict):
+        lock_id = str(test_delta.get("lock_id", "")).strip()
+
+    for path in sorted(lock_dir.glob("*.json")):
+        try:
+            payload = _load_json(path)
+        except Exception:
+            continue
+        if not isinstance(payload, dict):
+            continue
+        payload_lock_id = str(payload.get("lock_id", "")).strip()
+        if lock_id and payload_lock_id == lock_id:
+            return path, payload
+        intent = payload.get("intent")
+        if isinstance(intent, dict):
+            intent_run = str(intent.get("run_id", "")).strip()
+            if run_id and intent_run == run_id:
+                return path, payload
+        payload_run = str(payload.get("run_id", "")).strip()
+        if run_id and payload_run == run_id:
+            return path, payload
+    return None, None
+
+
+def _find_forge_starter_proof(*, output_root: Path, run_id: str) -> tuple[Path | None, dict[str, Any] | None]:
+    evidence_dir = output_root / ".omg" / "evidence"
+    if not evidence_dir.exists():
+        return None, None
+    for path in sorted(evidence_dir.glob("forge-specialists-*.json")):
+        try:
+            payload = _load_json(path)
+        except Exception:
+            continue
+        if not isinstance(payload, dict):
+            continue
+        payload_run = str(payload.get("run_id", "")).strip()
+        if run_id and payload_run and payload_run != run_id:
+            continue
+        return path, payload
+    return None, None
+
+
 def _check_test_intent_claims(payload: dict[str, Any]) -> list[str]:
     test_delta = payload.get("test_delta")
     claims = payload.get("claims", [])

package/build/lib/runtime/defense_state.py

@@ -10,19 +10,23 @@ from typing import Any
 _DEFENSE_STATE_REL_PATH = Path(".omg") / "state" / "defense_state" / "current.json"
 _CONTEXT_PRESSURE_REL_PATH = Path(".omg") / "state" / ".context-pressure.json"
 _UNTRUSTED_STATE_REL_PATH = Path(".omg") / "state" / "untrusted-content.json"
+_ACTIVE_RUN_REL_PATH = Path(".omg") / "shadow" / "active-run"
+_INTENT_GATE_REL_PATH = Path(".omg") / "state" / "intent_gate"
 
 _SAFE_STATE: dict[str, Any] = {
     "risk_level": "low",
     "injection_hits": 0,
     "contamination_score": 0.0,
     "overthinking_score": 0.0,
+    "premature_fixer_score": 0.0,
+    "clarification_sensitive": False,
     "actions": [],
     "updated_at": "",
     "reasons": [],
     "thresholds": {
         "critical": {"injection_hits": 3, "contamination_score": 0.7},
         "high": {"injection_hits": 1, "contamination_score": 0.4},
-        "medium": {"overthinking_score": 0.5},
+        "medium": {"overthinking_score": 0.5, "premature_fixer_score": 0.5},
     },
     "context_pressure": {
         "tool_count": 0,
@@ -44,6 +48,7 @@ class DefenseState:
         injection_hits: int = 0,
         contamination_score: float = 0.0,
         overthinking_score: float = 0.0,
+        premature_fixer_score: float | None = None,
     ) -> dict[str, Any]:
         pressure = self._read_json(self.project_dir / _CONTEXT_PRESSURE_REL_PATH)
         pressure_tool_count = self._to_int(pressure.get("tool_count"), default=0)
@@ -52,28 +57,49 @@ class DefenseState:
         if pressure_threshold > 0:
             pressure_ratio = pressure_tool_count / pressure_threshold
         combined_overthinking = max(float(overthinking_score), pressure_ratio)
+        normalized_injection_hits = max(0, int(injection_hits))
+        normalized_contamination = self._clamp_score(contamination_score)
+        normalized_overthinking = self._clamp_score(combined_overthinking)
+
+        clarification = self._read_clarification_signal()
+        clarification_sensitive = bool(
+            clarification["requires_clarification"]
+            or clarification["intent_class"] == "ambiguous_config"
+        )
+        premature_fixer_score = self._compute_premature_fixer_score(
+            clarification_sensitive=clarification_sensitive,
+            requires_clarification=bool(clarification["requires_clarification"]),
+            confidence=self._to_float(clarification.get("confidence"), default=0.0),
+            injection_hits=normalized_injection_hits,
+            contamination_score=normalized_contamination,
+            overthinking_score=normalized_overthinking,
+        )
+        scanner_premature_fixer = self._clamp_score(premature_fixer_score)
+        premature_fixer_score = max(premature_fixer_score, scanner_premature_fixer)
 
         trust_posture = self._read_trust_posture()
         level, actions, reasons = self._score(
-            injection_hits=max(0, int(injection_hits)),
-            contamination_score=self._clamp_score(contamination_score),
-            overthinking_score=self._clamp_score(combined_overthinking),
+            injection_hits=normalized_injection_hits,
+            contamination_score=normalized_contamination,
+            overthinking_score=normalized_overthinking,
         )
         if pressure_ratio >= 1.0:
             reasons.append("context pressure is above configured threshold")
 
         state: dict[str, Any] = {
             "risk_level": level,
-            "injection_hits": max(0, int(injection_hits)),
-            "contamination_score": self._clamp_score(contamination_score),
-            "overthinking_score": self._clamp_score(combined_overthinking),
+            "injection_hits": normalized_injection_hits,
+            "contamination_score": normalized_contamination,
+            "overthinking_score": normalized_overthinking,
+            "premature_fixer_score": round(premature_fixer_score, 4),
+            "clarification_sensitive": clarification_sensitive,
             "actions": actions,
             "updated_at": datetime.now(timezone.utc).isoformat(),
             "reasons": reasons,
             "thresholds": {
                 "critical": {"injection_hits": 3, "contamination_score": 0.7},
                 "high": {"injection_hits": 1, "contamination_score": 0.4},
-                "medium": {"overthinking_score": 0.5},
+                "medium": {"overthinking_score": 0.5, "premature_fixer_score": 0.5},
             },
             "context_pressure": {
                 "tool_count": pressure_tool_count,
@@ -96,6 +122,8 @@ class DefenseState:
             "injection_hits": self._to_int(payload.get("injection_hits"), default=0),
             "contamination_score": self._clamp_score(payload.get("contamination_score", 0.0)),
             "overthinking_score": self._clamp_score(payload.get("overthinking_score", 0.0)),
+            "premature_fixer_score": self._clamp_score(payload.get("premature_fixer_score", 0.0)),
+            "clarification_sensitive": bool(payload.get("clarification_sensitive", False)),
             "actions": self._to_str_list(payload.get("actions")),
             "updated_at": str(payload.get("updated_at", "")),
             "reasons": self._to_str_list(payload.get("reasons")),
@@ -105,6 +133,49 @@ class DefenseState:
             "action_recommendations": self._to_str_list(payload.get("action_recommendations")),
         }
 
+    def _read_clarification_signal(self) -> dict[str, Any]:
+        active_run_path = self.project_dir / _ACTIVE_RUN_REL_PATH
+        if not active_run_path.exists():
+            return {"requires_clarification": False, "intent_class": "", "confidence": 0.0}
+
+        try:
+            run_id = active_run_path.read_text(encoding="utf-8").strip()
+        except OSError:
+            run_id = ""
+        if not run_id:
+            return {"requires_clarification": False, "intent_class": "", "confidence": 0.0}
+
+        intent_gate_path = self.project_dir / _INTENT_GATE_REL_PATH / f"{run_id}.json"
+        payload = self._read_json(intent_gate_path)
+        confidence = self._clamp_score(self._to_float(payload.get("confidence"), default=0.0))
+        return {
+            "requires_clarification": bool(payload.get("requires_clarification") is True),
+            "intent_class": str(payload.get("intent_class", "")).strip(),
+            "confidence": confidence,
+        }
+
+    def _compute_premature_fixer_score(
+        self,
+        *,
+        clarification_sensitive: bool,
+        requires_clarification: bool,
+        confidence: float,
+        injection_hits: int,
+        contamination_score: float,
+        overthinking_score: float,
+    ) -> float:
+        if not clarification_sensitive:
+            return 0.0
+
+        score = 0.0
+        if requires_clarification:
+            score += 0.2
+        score += min(0.2, self._clamp_score(confidence) * 0.2)
+        score += min(0.2, max(0, injection_hits) * 0.1)
+        score += min(0.2, self._clamp_score(contamination_score) * 0.25)
+        score += min(0.2, self._clamp_score(overthinking_score) * 0.25)
+        return self._clamp_score(score)
+
     def _read_trust_posture(self) -> str:
         payload = self._read_json(self.project_dir / _UNTRUSTED_STATE_REL_PATH)
         scores = payload.get("trust_scores") if isinstance(payload, dict) else {}