@trac3er/oh-my-god 2.1.8 → 2.2.2

package/build/lib/runtime/context_engine.py

@@ -17,6 +17,8 @@ from typing import Any
 
 import yaml
 
+from runtime.forge_run_id import build_deterministic_contract
+from runtime.memory_store import MemoryStore
 from runtime.profile_io import profile_version_from_map
 
 _MAX_SUMMARY_CHARS = 1000
@@ -27,6 +29,12 @@ _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"
+_MEMORY_STORE_REL_PATH = Path(".omg") / "state" / "memory.sqlite3"
+_RELEASE_COORDINATOR_REL_BASE = Path(".omg") / "state" / "release_run_coordinator"
+_CONTEXT_PACKET_KIND = "context_engine_v2_packet"
+_CONTEXT_PACKET_SUMMARY = "governed context packet index"
+_PACKET_VERSION = "v2"
+_MAX_PROVENANCE_POINTERS = 24
 
 _STATE_PATHS = {
     "architecture_signal": Path(".omg") / "state" / "architecture_signal" / "latest.json",
@@ -196,6 +204,49 @@ def _clean_single_line(value: object) -> str:
     return " ".join(str(value).strip().split())
 
 
+def _extract_clarification(data_or_state: object) -> dict[str, Any]:
+    source: dict[str, Any] = {}
+    if isinstance(data_or_state, dict):
+        clarification_obj = data_or_state.get("clarification_status")
+        intent_gate_obj = data_or_state.get("intent_gate")
+        if isinstance(clarification_obj, dict):
+            source = clarification_obj
+        elif isinstance(intent_gate_obj, dict):
+            source = intent_gate_obj
+        else:
+            source = data_or_state
+
+    prompt = _clean_single_line(source.get("clarification_prompt", ""))
+    try:
+        confidence = float(source.get("confidence", 0.0))
+    except (TypeError, ValueError):
+        confidence = 0.0
+
+    slots_candidate = source.get("missing_slots")
+    missing_slots_raw = slots_candidate if isinstance(slots_candidate, list) else []
+    missing_slots: list[str] = []
+    for raw_slot in missing_slots_raw:
+        slot = _clean_single_line(raw_slot)[:32]
+        if not slot:
+            continue
+        missing_slots.append(slot)
+        if len(missing_slots) >= 6:
+            break
+
+    requires_clarification = bool(source.get("requires_clarification") is True)
+    unresolved = requires_clarification or bool(missing_slots)
+    return {
+        "requires_clarification": requires_clarification,
+        "intent_class": str(source.get("intent_class", "")).strip()[:48],
+        "clarification_prompt": prompt[:_MAX_CLARIFICATION_PROMPT_CHARS],
+        "confidence": round(max(0.0, min(1.0, confidence)), 2),
+        "missing_slots": missing_slots,
+        "updated_at": str(source.get("updated_at", "")).strip()[:48],
+        "status": "unresolved" if unresolved else "resolved",
+        "unresolved": unresolved,
+    }
+
+
 def _resolve_profile_confidence(
     profile: dict[str, Any],
     user_vector: dict[str, Any],
@@ -269,20 +320,51 @@ class ContextEngine:
     # ------------------------------------------------------------------
 
     def _build(self, run_id: str, *, delta_only: bool) -> dict[str, Any]:
-        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)
+        profile_digest = load_profile_digest(self.project_dir)
+        profile_id_raw = str(profile_digest.get("profile_version", "")).strip()
+        profile_id = profile_id_raw if profile_id_raw else None
+
+        coordinator_run_id = self._resolve_coordinator_run_id(run_id)
+        scoped_run_id = coordinator_run_id or run_id
+
+        raw = self._read_all_state(scoped_run_id)
+        clarification_status = self._compose_clarification_status(raw)
+        ambiguity_state = self._compose_ambiguity_state(raw)
+        provenance_only = bool(ambiguity_state.get("unresolved") is True)
+
+        release_metadata, release_pointers = self._compose_release_metadata(scoped_run_id)
+        artifact_pointers = self._collect_artifact_pointers(scoped_run_id)
+        provenance_pointers = self._merge_provenance_pointers(artifact_pointers, release_pointers)
+        artifact_handles = self._collect_artifact_handles(scoped_run_id, profile_id=profile_id)
+
+        if (
+            not provenance_pointers
+            and not artifact_handles
+            and all(v == {} for v in raw.values())
+            and not release_metadata
+        ):
+            pkt = self._fallback(run_id, coordinator_run_id=coordinator_run_id)
             pkt["delta_only"] = delta_only
-            pkt["profile_digest"] = load_profile_digest(self.project_dir)
+            pkt["profile_digest"] = profile_digest
             self._persist_packet(pkt)
+            self._index_governed_packet(pkt, scoped_run_id=scoped_run_id, profile_id=profile_id)
             return pkt
 
-        summary = self._compose_summary(raw)
-        current_snapshot = self._snapshot_key(raw)
-
-        if delta_only and self._last_snapshot is not None:
+        summary = (
+            self._provenance_only_summary(clarification_status)
+            if provenance_only
+            else self._compose_summary(raw)
+        )
+        current_snapshot = self._snapshot_key(
+            {
+                **raw,
+                "_release_metadata": release_metadata,
+                "_ambiguity_state": ambiguity_state,
+                "_provenance_only": provenance_only,
+            }
+        )
+
+        if delta_only and self._last_snapshot is not None and not provenance_only:
             changed_keys: list[str] = []
             for key in current_snapshot:
                 if current_snapshot.get(key) != self._last_snapshot.get(key):
@@ -291,23 +373,36 @@ class ContextEngine:
             if not changed_keys:
                 summary = "no changes since last packet"
                 artifact_pointers = []
+                provenance_pointers = []
 
         self._last_snapshot = current_snapshot
 
         packet: dict[str, Any] = {
+            "packet_version": _PACKET_VERSION,
             "summary": summary,
             "artifact_pointers": artifact_pointers,
-            "clarification_status": self._compose_clarification_status(raw),
-            "profile_digest": load_profile_digest(self.project_dir),
+            "provenance_pointers": provenance_pointers,
+            "artifact_handles": artifact_handles,
+            "clarification_status": clarification_status,
+            "ambiguity_state": ambiguity_state,
+            "provenance_only": provenance_only,
+            "governance": self._compose_governance(raw),
+            "release_metadata": release_metadata,
+            "coordinator_run_id": coordinator_run_id,
+            "profile_digest": profile_digest,
             "budget": {
                 "max_chars": _MAX_SUMMARY_CHARS,
                 "used_chars": len(summary),
             },
             "delta_only": delta_only,
             "run_id": run_id,
+            "deterministic_contract": build_deterministic_contract(run_id),
         }
+        if not provenance_only:
+            packet["derived_action_summary"] = summary
 
         self._persist_packet(packet)
+        self._index_governed_packet(packet, scoped_run_id=scoped_run_id, profile_id=profile_id)
         return packet
 
     def _read_all_state(self, run_id: str) -> dict[str, Any]:
@@ -345,26 +440,156 @@ class ContextEngine:
             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 = {}
+    def _resolve_coordinator_run_id(self, run_id: str) -> str:
+        try:
+            module = __import__("runtime.release_run_coordinator", fromlist=["get_active_coordinator_run_id"])
+            resolver = getattr(module, "get_active_coordinator_run_id", None)
+            if callable(resolver):
+                active_run_id = resolver(str(self.project_dir))
+                if isinstance(active_run_id, str) and active_run_id.strip():
+                    return active_run_id.strip()
+        except Exception:
+            pass
+        return run_id
+
+    def _compose_release_metadata(self, run_id: str) -> tuple[dict[str, Any], list[str]]:
+        run_token = str(run_id).strip()
+        if not run_token:
+            return {}, []
+
+        state_rel = _RELEASE_COORDINATOR_REL_BASE / f"{run_token}.json"
+        evidence_rel = _RELEASE_COORDINATOR_REL_BASE / f"{run_token}-release-evidence.json"
+        council_rel = _RELEASE_COORDINATOR_REL_BASE / run_token / "council.json"
+        rollback_rel = _RELEASE_COORDINATOR_REL_BASE / run_token / "rollback.json"
+
+        pointers: list[str] = []
+        for rel_path in (state_rel, evidence_rel, council_rel, rollback_rel):
+            if (self.project_dir / rel_path).exists():
+                pointers.append(str(rel_path))
+
+        state_payload = self._read_json(self.project_dir / state_rel)
+        evidence_payload = self._read_json(self.project_dir / evidence_rel)
+        if not state_payload and not evidence_payload and not pointers:
+            return {}, []
+
+        evidence_links_obj = state_payload.get("evidence_links")
+        evidence_links = evidence_links_obj if isinstance(evidence_links_obj, list) else []
+        claims_obj = evidence_payload.get("claims")
+        claims = claims_obj if isinstance(claims_obj, list) else []
+        artifact_obj = evidence_payload.get("artifact")
+        artifact = artifact_obj if isinstance(artifact_obj, dict) else {}
+        attestation_obj = artifact.get("attestation")
+
+        metadata = {
+            "run_id": str(state_payload.get("run_id", run_token)).strip(),
+            "status": str(state_payload.get("status", "")).strip()[:24],
+            "phase": str(state_payload.get("phase", "")).strip()[:24],
+            "resolution_source": str(state_payload.get("resolution_source", "")).strip()[:24],
+            "resolution_reason": str(state_payload.get("resolution_reason", "")).strip()[:80],
+            "health_action": str(state_payload.get("health_action", "")).strip()[:48],
+            "compliance_authority": str(state_payload.get("compliance_authority", "")).strip()[:48],
+            "compliance_reason": str(state_payload.get("compliance_reason", "")).strip()[:120],
+            "evidence_links_count": len(evidence_links),
+            "claim_count": len(claims),
+            "has_release_evidence": bool(evidence_payload),
+            "artifact_attested": isinstance(attestation_obj, dict),
+        }
+        return metadata, pointers
+
+    def _merge_provenance_pointers(self, pointers: list[str], release_pointers: list[str]) -> list[str]:
+        merged: list[str] = []
+        seen: set[str] = set()
+        for raw_pointer in [*pointers, *release_pointers]:
+            pointer = str(raw_pointer).strip()
+            if not pointer or pointer in seen:
+                continue
+            seen.add(pointer)
+            merged.append(pointer)
+            if len(merged) >= _MAX_PROVENANCE_POINTERS:
+                break
+        return merged
+
+    def _compose_ambiguity_state(self, raw: dict[str, Any]) -> dict[str, Any]:
+        clarification = _extract_clarification(raw)
+        return {
+            "status": str(clarification.get("status", "resolved")),
+            "unresolved": bool(clarification.get("unresolved") is True),
+            "requires_clarification": bool(clarification.get("requires_clarification") is True),
+            "missing_slots": list(clarification.get("missing_slots", [])),
+            "updated_at": str(clarification.get("updated_at", "")).strip()[:48],
+        }
+
+    def _provenance_only_summary(self, clarification_status: dict[str, Any]) -> str:
+        intent_class = str(clarification_status.get("intent_class", "")).strip()
+        if intent_class:
+            return f"clarification pending for intent={intent_class}; provenance-only packet"[:_MAX_SUMMARY_CHARS]
+        return "clarification pending; provenance-only packet"
+
+    def _index_governed_packet(self, packet: dict[str, Any], *, scoped_run_id: str, profile_id: str | None) -> None:
+        run_token = str(scoped_run_id).strip()
+        if not run_token:
+            return
+
+        clarification_obj = packet.get("clarification_status")
+        clarification = clarification_obj if isinstance(clarification_obj, dict) else {}
+        release_obj = packet.get("release_metadata")
+        release_metadata = release_obj if isinstance(release_obj, dict) else {}
+
+        metadata: dict[str, Any] = {
+            "packet_version": str(packet.get("packet_version", "")).strip(),
+            "coordinator_run_id": str(packet.get("coordinator_run_id", "")).strip(),
+            "provenance_only": bool(packet.get("provenance_only") is True),
+            "artifact_pointer_count": len(packet.get("artifact_pointers", [])) if isinstance(packet.get("artifact_pointers"), list) else 0,
+            "provenance_pointer_count": len(packet.get("provenance_pointers", [])) if isinstance(packet.get("provenance_pointers"), list) else 0,
+            "artifact_handle_count": len(packet.get("artifact_handles", [])) if isinstance(packet.get("artifact_handles"), list) else 0,
+            "requires_clarification": bool(clarification.get("requires_clarification") is True),
+            "intent_class": str(clarification.get("intent_class", "")).strip()[:48],
+            "release_phase": str(release_metadata.get("phase", "")).strip()[:24],
+            "release_status": str(release_metadata.get("status", "")).strip()[:24],
+        }
 
-        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))
+            store = MemoryStore(store_path=str(self.project_dir / _MEMORY_STORE_REL_PATH))
+            scoped_profile_id = str(profile_id or "")
+            existing = store.query_artifacts(
+                run_id=run_token,
+                profile_id=scoped_profile_id or None,
+                kind=_CONTEXT_PACKET_KIND,
+                limit=1,
+            )
+            if existing:
+                store.close()
+                return
+            store.index_artifact(
+                run_id=run_token,
+                profile_id=scoped_profile_id,
+                kind=_CONTEXT_PACKET_KIND,
+                path=str(_PACKET_REL_PATH),
+                summary=_CONTEXT_PACKET_SUMMARY,
+                metadata=metadata,
+            )
+            store.close()
+        except Exception:
+            pass
 
+    def _compose_clarification_status(self, raw: dict[str, Any]) -> dict[str, Any]:
+        clarification = _extract_clarification(raw)
         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),
+            "requires_clarification": bool(clarification.get("requires_clarification") is True),
+            "intent_class": str(clarification.get("intent_class", "")).strip()[:48],
+            "clarification_prompt": str(clarification.get("clarification_prompt", "")).strip()[:_MAX_CLARIFICATION_PROMPT_CHARS],
+            "confidence": round(float(clarification.get("confidence", 0.0)), 2),
         }
 
+    def _compose_governance(self, raw: dict[str, Any]) -> dict[str, Any]:
+        intent_gate = raw.get("intent_gate", {})
+        if not isinstance(intent_gate, dict):
+            return {}
+        governance = intent_gate.get("governance")
+        if isinstance(governance, dict):
+            return dict(governance)
+        return {}
+
     def _compose_summary(self, raw: dict[str, Any]) -> str:
         """Compose a bounded summary from state signals."""
         parts: list[str] = []
@@ -434,18 +659,50 @@ class ContextEngine:
         except Exception:
             pass  # crash isolation
 
-    def _fallback(self, run_id: str) -> dict[str, Any]:
+    def _fallback(self, run_id: str, *, coordinator_run_id: str = "") -> dict[str, Any]:
         return {
+            "packet_version": _PACKET_VERSION,
             "summary": "no context signals available",
             "artifact_pointers": [],
+            "provenance_pointers": [],
+            "artifact_handles": [],
             "clarification_status": {
                 "requires_clarification": False,
                 "intent_class": "",
                 "clarification_prompt": "",
                 "confidence": 0.0,
             },
+            "ambiguity_state": {
+                "status": "resolved",
+                "unresolved": False,
+                "requires_clarification": False,
+                "missing_slots": [],
+                "updated_at": "",
+            },
+            "provenance_only": False,
+            "governance": {},
+            "release_metadata": {},
+            "coordinator_run_id": coordinator_run_id,
             "profile_digest": _empty_profile_digest(),
             "budget": {"max_chars": _MAX_SUMMARY_CHARS, "used_chars": 0},
             "delta_only": False,
             "run_id": run_id,
+            "deterministic_contract": build_deterministic_contract(run_id),
         }
+
+    def _collect_artifact_handles(self, run_id: str, *, profile_id: str | None = None) -> list[dict[str, Any]]:
+        run_token = str(run_id).strip()
+        if not run_token:
+            return []
+        try:
+            profile_id_raw = str(profile_id or "").strip()
+            if not profile_id_raw:
+                digest_profile_id = str(load_profile_digest(self.project_dir).get("profile_version", "")).strip()
+                profile_id_raw = digest_profile_id
+            scoped_profile_id = profile_id_raw if profile_id_raw else None
+            store = MemoryStore(store_path=str(self.project_dir / _MEMORY_STORE_REL_PATH))
+            handles = store.query_artifacts(run_id=run_token, profile_id=scoped_profile_id)
+            store.close()
+            return handles
+        except Exception:
+            return []