@trac3er/oh-my-god 2.1.0 → 2.1.4

package/build/lib/runtime/claim_judge.py

@@ -1,17 +1,21 @@
 from __future__ import annotations
 
 import json
+import os
 from pathlib import Path
 from typing import Any
 
 from runtime import artifact_parsers
+from runtime.context_engine import load_profile_digest
 from runtime.evidence_query import get_evidence_pack
+from runtime.evidence_requirements import FULL_REQUIREMENTS, requirements_for_profile
 
 
 def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, Any]:
     root = Path(project_dir)
     evidence_dir = root / ".omg" / "evidence"
     evidence_dir.mkdir(parents=True, exist_ok=True)
+    profile_digest = load_profile_digest(project_dir)
 
     results: list[dict[str, Any]] = []
     aggregate_tokens: list[str] = []
@@ -23,16 +27,37 @@ def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, An
         if run_id:
             evidence_pack = get_evidence_pack(project_dir, run_id)
             trace_ids: list[str] = []
+            context_checksum = ""
+            profile_version = ""
+            intent_gate_version = ""
+            evidence_profile = ""
             if isinstance(evidence_pack, dict):
                 trace_ids = _as_non_empty_str_list(evidence_pack.get("trace_ids"))
+                context_checksum = str(evidence_pack.get("context_checksum", "")).strip()
+                profile_version = str(evidence_pack.get("profile_version", "")).strip()
+                intent_gate_version = str(evidence_pack.get("intent_gate_version", "")).strip()
+                evidence_profile = str(evidence_pack.get("evidence_profile", "")).strip()
             resolved_claim = {
                 **claim,
                 "artifacts": [f".omg/evidence/{run_id}.json"],
                 "trace_ids": trace_ids,
+                "context_checksum": context_checksum,
+                "profile_version": profile_version,
+                "intent_gate_version": intent_gate_version,
+                "evidence_profile": evidence_profile,
             }
 
         result = judge_claim(resolved_claim)
+        council_reasons = _load_council_reasons(project_dir=project_dir, run_id=run_id)
+        if council_reasons:
+            updated_reasons = list(result.get("reasons", []))
+            updated_reasons.extend(council_reasons)
+            result = {**result, "reasons": updated_reasons, "verdict": "block"}
         result_with_run = {**result, "run_id": run_id}
+        result_with_run["context_checksum"] = str(resolved_claim.get("context_checksum", "")).strip()
+        result_with_run["profile_version"] = str(resolved_claim.get("profile_version", "")).strip()
+        result_with_run["intent_gate_version"] = str(resolved_claim.get("intent_gate_version", "")).strip()
+        result_with_run["advisory_context"] = {"profile_digest": profile_digest}
         results.append(result_with_run)
         aggregate_tokens.append(str(result.get("verdict", "")).strip().lower())
 
@@ -43,6 +68,10 @@ def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, An
             "run_id": run_id,
             "claim": claim,
             "result": result,
+            "context_checksum": str(resolved_claim.get("context_checksum", "")).strip(),
+            "profile_version": str(resolved_claim.get("profile_version", "")).strip(),
+            "intent_gate_version": str(resolved_claim.get("intent_gate_version", "")).strip(),
+            "advisory_context": {"profile_digest": profile_digest},
         }
         artifact_path.write_text(json.dumps(artifact_payload, indent=2, sort_keys=True), encoding="utf-8")
 
@@ -52,7 +81,12 @@ def judge_claims(project_dir: str, claims: list[dict[str, Any]]) -> dict[str, An
     elif any(token == "block" for token in aggregate_tokens):
         verdict = "insufficient"
 
-    return {"schema": "ClaimJudgeResults", "verdict": verdict, "results": results}
+    return {
+        "schema": "ClaimJudgeResults",
+        "verdict": verdict,
+        "results": results,
+        "advisory_context": {"profile_digest": profile_digest},
+    }
 
 
 def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
@@ -63,10 +97,15 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
     trace_ids = _as_non_empty_str_list(normalized_claim.get("trace_ids"))
     security_scans = normalized_claim.get("security_scans")
     browser_evidence = normalized_claim.get("browser_evidence")
+    evidence_profile = str(normalized_claim.get("evidence_profile", "")).strip()
+    evidence_requirements = requirements_for_profile(evidence_profile)
+    requirement_set = {str(item).strip() for item in evidence_requirements if str(item).strip()}
+    causal_chain = _as_dict(normalized_claim.get("causal_chain"))
 
     reasons: list[dict[str, Any]] = []
+    advisories: list[str] = []
 
-    if not artifacts:
+    if "tests" in requirement_set and not artifacts:
         reasons.append(
             {
                 "code": "missing_artifacts",
@@ -75,7 +114,7 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
-    if not trace_ids:
+    if "trace_link" in requirement_set and not trace_ids:
         reasons.append(
             {
                 "code": "missing_trace_ids",
@@ -84,7 +123,7 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
-    if _has_failed_scan(security_scans):
+    if "security_scan" in requirement_set and _has_failed_scan(security_scans):
         reasons.append(
             {
                 "code": "security_scan_failed",
@@ -93,7 +132,7 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
-    if _has_failed_scan(browser_evidence):
+    if requirement_set == set(FULL_REQUIREMENTS) and _has_failed_scan(browser_evidence):
         reasons.append(
             {
                 "code": "browser_evidence_failed",
@@ -118,6 +157,26 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             }
         )
 
+    strict_mode = os.environ.get("OMG_PROOF_CHAIN_STRICT", "0").strip() == "1"
+    strict_causal_chain = strict_mode or _claim_type_enforces_strict_causal_chain(
+        claim_type=claim_type,
+        claim=claim,
+    )
+
+    causal_chain_errors = _validate_causal_chain(causal_chain, require_versions=strict_causal_chain)
+    if causal_chain_errors:
+        if strict_causal_chain:
+            reasons.append(
+                {
+                    "code": "missing_causal_chain",
+                    "message": "Claim must include lock->delta->verification causal chain evidence: "
+                    + "; ".join(causal_chain_errors),
+                    "field": "causal_chain",
+                }
+            )
+        else:
+            advisories.append("claim_judge_causal_chain_missing_permissive")
+
     hard_fail_codes = {"missing_artifacts", "missing_trace_ids"}
     if any(reason.get("code") in hard_fail_codes for reason in reasons):
         verdict = "fail"
@@ -138,6 +197,10 @@ def judge_claim(claim: dict[str, Any]) -> dict[str, Any]:
             "lineage": normalized_claim.get("lineage") if isinstance(normalized_claim.get("lineage"), dict) else {},
             "security_scans": security_scans if isinstance(security_scans, list) else [],
             "browser_evidence": browser_evidence if isinstance(browser_evidence, list) else [],
+            "causal_chain": causal_chain,
+            "advisories": advisories,
+            "evidence_profile": evidence_profile,
+            "evidence_requirements": list(evidence_requirements),
         },
     }
 
@@ -160,6 +223,18 @@ def _normalize_claim(claim: dict[str, Any]) -> dict[str, Any]:
     claim_browser_evidence = claim.get("browser_evidence")
     browser_evidence = claim_browser_evidence if isinstance(claim_browser_evidence, list) else _as_non_empty_dict_list(evidence.get("browser_evidence"))
 
+    lock_verification = claim.get("lock_verification") if isinstance(claim.get("lock_verification"), dict) else _as_dict(evidence.get("lock_verification"))
+    causal_chain = {
+        "lock_id": str(claim.get("lock_id", evidence.get("lock_id", ""))).strip(),
+        "delta_summary": claim.get("delta_summary") if isinstance(claim.get("delta_summary"), dict) else _as_dict(evidence.get("delta_summary")),
+        "verification_status": str(claim.get("verification_status", evidence.get("verification_status", ""))).strip(),
+        "waiver_artifact_path": str(claim.get("waiver_artifact_path", evidence.get("waiver_artifact_path", ""))).strip(),
+        "lock_verification": lock_verification,
+        "context_checksum": str(claim.get("context_checksum", evidence.get("context_checksum", ""))).strip(),
+        "profile_version": str(claim.get("profile_version", evidence.get("profile_version", ""))).strip(),
+        "intent_gate_version": str(claim.get("intent_gate_version", evidence.get("intent_gate_version", ""))).strip(),
+    }
+
     return {
         "schema_version": claim.get("schema_version", 1),
         "claim_type": claim.get("claim_type", ""),
@@ -169,9 +244,62 @@ def _normalize_claim(claim: dict[str, Any]) -> dict[str, Any]:
         "lineage": lineage,
         "security_scans": security_scans,
         "browser_evidence": browser_evidence,
+        "causal_chain": causal_chain,
+        "evidence_profile": str(claim.get("evidence_profile", evidence.get("evidence_profile", ""))).strip(),
     }
 
 
+def _validate_causal_chain(causal_chain: dict[str, Any], *, require_versions: bool) -> list[str]:
+    errors: list[str] = []
+    lock_id = str(causal_chain.get("lock_id", "")).strip()
+    delta_summary = causal_chain.get("delta_summary")
+    verification_status = str(causal_chain.get("verification_status", "")).strip()
+    waiver_artifact_path = str(causal_chain.get("waiver_artifact_path", "")).strip()
+    context_checksum = str(causal_chain.get("context_checksum", "")).strip()
+    profile_version = str(causal_chain.get("profile_version", "")).strip()
+    intent_gate_version = str(causal_chain.get("intent_gate_version", "")).strip()
+    lock_verification = _as_dict(causal_chain.get("lock_verification"))
+
+    if not lock_id:
+        errors.append("missing_lock_id")
+    if not isinstance(delta_summary, dict) or not delta_summary:
+        errors.append("missing_delta_summary")
+    if not verification_status:
+        errors.append("missing_verification_status")
+
+    lock_status = str(lock_verification.get("status", "")).strip().lower()
+    lock_satisfied = lock_status == "ok"
+    if not waiver_artifact_path and not lock_satisfied:
+        errors.append("missing_waiver_or_lock_satisfied_proof")
+
+    if require_versions:
+        if not context_checksum:
+            errors.append("missing_context_checksum")
+        if not profile_version:
+            errors.append("missing_profile_version")
+        if not intent_gate_version:
+            errors.append("missing_intent_gate_version")
+
+    return errors
+
+
+def _claim_type_enforces_strict_causal_chain(*, claim_type: str, claim: dict[str, Any]) -> bool:
+    mode = str(claim.get("causal_chain_mode", "")).strip().lower()
+    if mode == "legacy":
+        return False
+    if mode == "strict":
+        return True
+
+    if isinstance(claim.get("require_causal_chain"), bool):
+        return bool(claim.get("require_causal_chain"))
+
+    normalized = claim_type.strip().lower()
+    if not normalized:
+        return False
+    tokens = {item for item in normalized.replace("-", "_").split("_") if item}
+    return bool(tokens & {"runtime", "council"})
+
+
 def _normalize_artifact_records(value: Any) -> list[str]:
     if not isinstance(value, list):
         return []
@@ -270,3 +398,35 @@ _PARSERS: dict[str, Any] = {
 def _sanitize_run_id(value: str) -> str:
     cleaned = "".join(ch if ch.isalnum() or ch in {"-", "_", "."} else "-" for ch in value.strip())
     return cleaned or "unknown"
+
+
+def _load_council_reasons(project_dir: str, run_id: str) -> list[dict[str, Any]]:
+    if not run_id:
+        return []
+    path = Path(project_dir) / ".omg" / "state" / "council_verdicts" / f"{run_id}.json"
+    if not path.exists():
+        return []
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+    if not isinstance(payload, dict):
+        return []
+
+    verdicts = _as_dict(payload.get("verdicts"))
+    evidence_completeness = _as_dict(verdicts.get("evidence_completeness"))
+    verdict = str(evidence_completeness.get("verdict", "")).strip().lower()
+    if verdict not in {"fail", "block", "blocked", "error"}:
+        return []
+    findings = evidence_completeness.get("findings")
+    finding_items = findings if isinstance(findings, list) else []
+    message = "council evidence completeness failed"
+    if finding_items:
+        message = "; ".join(str(item).strip() for item in finding_items if str(item).strip()) or message
+    return [
+        {
+            "code": "council_evidence_incomplete",
+            "message": message,
+            "field": "council_verdicts.evidence_completeness",
+        }
+    ]

package/build/lib/runtime/compat.py

@@ -603,7 +603,21 @@ def _init_bootstrap(project_dir: str, reason: str) -> list[str]:
         "name: omg-project\n"
         "description: initialized by OMG standalone compat bootstrap\n"
         "language: unknown\n"
-        "framework: unknown\n",
+        "framework: unknown\n"
+        "stack: []\n"
+        "conventions: {}\n"
+        "ai_behavior: {}\n"
+        "preferences:\n"
+        "  architecture_requests: []\n"
+        "  constraints: {}\n"
+        "  routing:\n"
+        "    prefer_clarification: false\n"
+        "user_vector:\n"
+        "  tags: []\n"
+        "  summary: \"\"\n"
+        "  confidence: 0.0\n"
+        "profile_provenance:\n"
+        "  recent_updates: []\n",
     )
     _write_if_missing(
         idea_path,

package/build/lib/runtime/context_engine.py

@@ -11,11 +11,22 @@ from __future__ import annotations
 
 import json
 import os
+import re
 from pathlib import Path
 from typing import Any
 
+import yaml
+
+from runtime.profile_io import profile_version_from_map
+
 _MAX_SUMMARY_CHARS = 1000
+_MAX_CLARIFICATION_PROMPT_CHARS = 180
+_PROFILE_SUMMARY_MAX_CHARS = 120
+_PROFILE_DIGEST_TAG_MAX = 5
+_PROFILE_DIGEST_ARCH_MAX = 3
+_PROFILE_DIGEST_CONSTRAINT_MAX = 5
 _PACKET_REL_PATH = Path(".omg") / "state" / "context_engine_packet.json"
+_PROFILE_REL_PATH = Path(".omg") / "state" / "profile.yaml"
 
 _STATE_PATHS = {
     "architecture_signal": Path(".omg") / "state" / "architecture_signal" / "latest.json",
@@ -23,6 +34,203 @@ _STATE_PATHS = {
     "background_verification": Path(".omg") / "state" / "background-verification.json",
     "context_pressure": Path(".omg") / "state" / ".context-pressure.json",
 }
+_COUNCIL_REL_BASE = Path(".omg") / "state" / "council_verdicts"
+_INTENT_GATE_REL_BASE = Path(".omg") / "state" / "intent_gate"
+
+
+def load_profile_digest(project_dir: str | Path) -> dict[str, Any]:
+    root = Path(project_dir)
+    profile_path = root / _PROFILE_REL_PATH
+    if not profile_path.exists():
+        return _empty_profile_digest()
+
+    raw_profile = ""
+    parsed: dict[str, Any] = {}
+    try:
+        raw_profile = profile_path.read_text(encoding="utf-8")
+    except OSError:
+        return _empty_profile_digest()
+
+    try:
+        payload = yaml.safe_load(raw_profile)
+    except Exception:
+        payload = None
+    if isinstance(payload, dict):
+        parsed = payload
+
+    digest = _profile_digest_from_map(parsed, raw_profile)
+    return digest
+
+
+def render_profile_digest_text(project_dir: str | Path, *, max_chars: int) -> str:
+    digest = load_profile_digest(project_dir)
+    arch_items = digest.get("architecture_requests")
+    arch_list = arch_items if isinstance(arch_items, list) else []
+    arch = ",".join(str(item)[:18] for item in arch_list if str(item).strip())
+    constraints_obj = digest.get("constraints", {})
+    constraints = constraints_obj if isinstance(constraints_obj, dict) else {}
+    constraint_tokens = []
+    for key, value in constraints.items():
+        if len(constraint_tokens) >= _PROFILE_DIGEST_CONSTRAINT_MAX:
+            break
+        value_text = str(value).strip()
+        if not value_text:
+            continue
+        constraint_tokens.append(f"{str(key)[:14]}={value_text[:14]}")
+    cons = ",".join(constraint_tokens)
+    tags_items = digest.get("tags")
+    tags_list = tags_items if isinstance(tags_items, list) else []
+    tags = ",".join(str(item)[:14] for item in tags_list if str(item).strip())
+    try:
+        confidence = round(float(digest.get("confidence", 0.0)), 2)
+    except (TypeError, ValueError):
+        confidence = 0.0
+    version = str(digest.get("profile_version", "")).strip()[:24]
+    summary = str(digest.get("summary", "")).strip()
+
+    prefix = f"arch[{arch}]|cons[{cons}]|tags[{tags}]|conf={confidence}|ver={version}|sum="
+    if len(prefix) >= max_chars:
+        return prefix[:max_chars]
+    remaining = max_chars - len(prefix)
+    if len(summary) > remaining:
+        if remaining <= 3:
+            summary = summary[:remaining]
+        else:
+            summary = summary[: remaining - 3] + "..."
+    return prefix + summary
+
+
+def _empty_profile_digest() -> dict[str, Any]:
+    return {
+        "architecture_requests": [],
+        "constraints": {},
+        "tags": [],
+        "summary": "",
+        "confidence": 0.0,
+        "profile_version": "",
+    }
+
+
+def _profile_digest_from_map(profile: dict[str, Any], raw_profile: str) -> dict[str, Any]:
+    preferences_obj = profile.get("preferences")
+    preferences: dict[str, Any] = preferences_obj if isinstance(preferences_obj, dict) else {}
+    user_vector_obj = profile.get("user_vector")
+    user_vector: dict[str, Any] = user_vector_obj if isinstance(user_vector_obj, dict) else {}
+    provenance_obj = profile.get("profile_provenance")
+    provenance: dict[str, Any] = provenance_obj if isinstance(provenance_obj, dict) else {}
+
+    architecture_obj = preferences.get("architecture_requests")
+    architecture_raw: list[Any] = architecture_obj if isinstance(architecture_obj, list) else []
+    architecture_requests = [
+        _clean_single_line(item)
+        for item in architecture_raw
+        if _clean_single_line(item)
+    ][:_PROFILE_DIGEST_ARCH_MAX]
+
+    constraints_obj = preferences.get("constraints")
+    constraints_raw: dict[str, Any] = constraints_obj if isinstance(constraints_obj, dict) else {}
+    constraints = _normalize_constraints(constraints_raw)
+
+    tags_obj = user_vector.get("tags")
+    tags_raw: list[Any] = tags_obj if isinstance(tags_obj, list) else []
+    tags = [_normalize_tag(item) for item in tags_raw if _normalize_tag(item)][:_PROFILE_DIGEST_TAG_MAX]
+
+    summary = _clean_single_line(
+        user_vector.get("summary")
+        or profile.get("summary")
+        or profile.get("name")
+    )[:_PROFILE_SUMMARY_MAX_CHARS]
+
+    confidence = _resolve_profile_confidence(profile, user_vector, provenance)
+    profile_version = _resolve_profile_version_pointer(profile, provenance, raw_profile)
+
+    return {
+        "architecture_requests": architecture_requests,
+        "constraints": constraints,
+        "tags": tags,
+        "summary": summary,
+        "confidence": confidence,
+        "profile_version": profile_version,
+    }
+
+
+def _normalize_constraints(raw: dict[str, Any]) -> dict[str, str | int | float | bool | None]:
+    out: dict[str, str | int | float | bool | None] = {}
+    for key, value in raw.items():
+        if len(out) >= _PROFILE_DIGEST_CONSTRAINT_MAX:
+            break
+        normalized_key = _normalize_constraint_key(key)
+        normalized_value = _normalize_constraint_value(value)
+        if not normalized_key or normalized_value is None:
+            continue
+        out[normalized_key] = normalized_value
+    return out
+
+
+def _normalize_constraint_key(value: object) -> str:
+    token = re.sub(r"\s+", "_", str(value).strip().lower())
+    token = "".join(ch for ch in token if ch.isalnum() or ch == "_")
+    return token[:40]
+
+
+def _normalize_constraint_value(value: object) -> str | int | float | bool | None:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return round(value, 3)
+    if value is None:
+        return None
+    text = _clean_single_line(value).lower()
+    return text[:80] if text else None
+
+
+def _normalize_tag(value: object) -> str:
+    token = re.sub(r"\s+", "_", str(value).strip().lower())
+    token = "".join(ch for ch in token if ch.isalnum() or ch in {"_", "-"})
+    return token[:24]
+
+
+def _clean_single_line(value: object) -> str:
+    return " ".join(str(value).strip().split())
+
+
+def _resolve_profile_confidence(
+    profile: dict[str, Any],
+    user_vector: dict[str, Any],
+    provenance: dict[str, Any],
+) -> float:
+    candidates = [
+        profile.get("confidence"),
+        user_vector.get("confidence"),
+        provenance.get("confidence"),
+    ]
+    for candidate in candidates:
+        if not isinstance(candidate, (int, float, str)):
+            continue
+        try:
+            value = float(candidate)
+        except (TypeError, ValueError):
+            continue
+        return round(max(0.0, min(1.0, value)), 2)
+    return 0.0
+
+
+def _resolve_profile_version_pointer(profile: dict[str, Any], provenance: dict[str, Any], raw_profile: str) -> str:
+    for candidate in (
+        profile.get("profile_version"),
+        profile.get("version"),
+        provenance.get("checksum"),
+        provenance.get("version"),
+    ):
+        if candidate is None:
+            continue
+        text = _clean_single_line(candidate)
+        if text:
+            return text[:64]
+    # Deterministic: hash the parsed dict, not the raw text
+    return profile_version_from_map(profile)
 
 
 class ContextEngine:
@@ -61,12 +269,13 @@ class ContextEngine:
     # ------------------------------------------------------------------
 
     def _build(self, run_id: str, *, delta_only: bool) -> dict[str, Any]:
-        raw = self._read_all_state()
-        artifact_pointers = self._collect_artifact_pointers()
+        raw = self._read_all_state(run_id)
+        artifact_pointers = self._collect_artifact_pointers(run_id)
 
         if not artifact_pointers and all(v == {} for v in raw.values()):
             pkt = self._fallback(run_id)
             pkt["delta_only"] = delta_only
+            pkt["profile_digest"] = load_profile_digest(self.project_dir)
             self._persist_packet(pkt)
             return pkt
 
@@ -88,6 +297,8 @@ class ContextEngine:
         packet: dict[str, Any] = {
             "summary": summary,
             "artifact_pointers": artifact_pointers,
+            "clarification_status": self._compose_clarification_status(raw),
+            "profile_digest": load_profile_digest(self.project_dir),
             "budget": {
                 "max_chars": _MAX_SUMMARY_CHARS,
                 "used_chars": len(summary),
@@ -99,11 +310,13 @@ class ContextEngine:
         self._persist_packet(packet)
         return packet
 
-    def _read_all_state(self) -> dict[str, Any]:
+    def _read_all_state(self, run_id: str) -> dict[str, Any]:
         """Read all state files, returning empty dicts for missing ones."""
         result: dict[str, Any] = {}
         for name, rel_path in _STATE_PATHS.items():
             result[name] = self._read_json(self.project_dir / rel_path)
+        result["council_verdicts"] = self._read_json(self.project_dir / _COUNCIL_REL_BASE / f"{run_id}.json")
+        result["intent_gate"] = self._read_json(self.project_dir / _INTENT_GATE_REL_BASE / f"{run_id}.json")
         return result
 
     def _read_json(self, path: Path) -> dict[str, Any]:
@@ -115,15 +328,43 @@ class ContextEngine:
             return {}
         return payload if isinstance(payload, dict) else {}
 
-    def _collect_artifact_pointers(self) -> list[str]:
+    def _collect_artifact_pointers(self, run_id: str) -> list[str]:
         """Collect relative paths to existing state artifacts — NO raw content."""
         pointers: list[str] = []
         for rel_path in _STATE_PATHS.values():
             full = self.project_dir / rel_path
             if full.exists():
                 pointers.append(str(rel_path))
+
+        council_rel = _COUNCIL_REL_BASE / f"{run_id}.json"
+        if (self.project_dir / council_rel).exists():
+            pointers.append(str(council_rel))
+
+        intent_gate_rel = _INTENT_GATE_REL_BASE / f"{run_id}.json"
+        if (self.project_dir / intent_gate_rel).exists():
+            pointers.append(str(intent_gate_rel))
         return pointers
 
+    def _compose_clarification_status(self, raw: dict[str, Any]) -> dict[str, Any]:
+        intent_gate = raw.get("intent_gate", {})
+        if not isinstance(intent_gate, dict):
+            intent_gate = {}
+
+        prompt = str(intent_gate.get("clarification_prompt", "")).strip().replace("\n", " ")
+        confidence_raw = intent_gate.get("confidence", 0.0)
+        try:
+            confidence = float(confidence_raw)
+        except (TypeError, ValueError):
+            confidence = 0.0
+        confidence = max(0.0, min(1.0, confidence))
+
+        return {
+            "requires_clarification": bool(intent_gate.get("requires_clarification") is True),
+            "intent_class": str(intent_gate.get("intent_class", "")).strip()[:48],
+            "clarification_prompt": prompt[:_MAX_CLARIFICATION_PROMPT_CHARS],
+            "confidence": round(confidence, 2),
+        }
+
     def _compose_summary(self, raw: dict[str, Any]) -> str:
         """Compose a bounded summary from state signals."""
         parts: list[str] = []
@@ -157,6 +398,15 @@ class ContextEngine:
         if tool_count is not None:
             parts.append(f"pressure: tools={tool_count} high={is_high}")
 
+        council = raw.get("council_verdicts", {})
+        if isinstance(council, dict):
+            verdicts = council.get("verdicts")
+            if isinstance(verdicts, dict) and verdicts:
+                evidence = verdicts.get("evidence_completeness")
+                if isinstance(evidence, dict):
+                    token = str(evidence.get("verdict", "")).strip().lower() or "unknown"
+                    parts.append(f"council: evidence_completeness={token}")
+
         if not parts:
             return "no context signals available"
 
@@ -188,6 +438,13 @@ class ContextEngine:
         return {
             "summary": "no context signals available",
             "artifact_pointers": [],
+            "clarification_status": {
+                "requires_clarification": False,
+                "intent_class": "",
+                "clarification_prompt": "",
+                "confidence": 0.0,
+            },
+            "profile_digest": _empty_profile_digest(),
             "budget": {"max_chars": _MAX_SUMMARY_CHARS, "used_chars": 0},
             "delta_only": False,
             "run_id": run_id,