@trac3er/oh-my-god 2.1.0 → 2.1.4

package/hooks/stop_dispatcher.py

@@ -9,10 +9,12 @@ import subprocess
 import sys
 import time
 from datetime import datetime, timedelta, timezone
+import warnings
 
 sys.path.insert(0, os.path.dirname(__file__))
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
 
-from _common import (  # noqa: E402
+from hooks._common import (  # noqa: E402
     atomic_json_write,
     block_decision,
     check_performance_budget,
@@ -27,7 +29,10 @@ from _common import (  # noqa: E402
     should_skip_stop_hooks,
     STOP_CHECK_MAX_MS,
 )
-from state_migration import resolve_state_file  # noqa: E402
+from hooks.state_migration import resolve_state_file  # noqa: E402
+
+from runtime.release_run_coordinator import resolve_current_run_id  # noqa: E402
+from runtime import test_intent_lock  # noqa: E402
 
 
 setup_crash_handler("stop_dispatcher")
@@ -132,7 +137,7 @@ def _is_internal_control_path(file_path: str) -> bool:
 
 
 try:
-    from shadow_manager import has_recent_evidence  # type: ignore
+    from hooks.shadow_manager import has_recent_evidence  # type: ignore
 except Exception:  # intentional: optional feature — shadow_manager may not exist
     has_recent_evidence = None
 
@@ -621,6 +626,104 @@ def check_bare_done(data, project_dir):
 
     return []
 
+
+def _proof_chain_strict_enabled() -> bool:
+    return os.environ.get("OMG_PROOF_CHAIN_STRICT", "0").strip() == "1"
+
+
+def _load_test_delta_from_evidence(project_dir: str, run_id: str | None) -> dict[str, object]:
+    evidence_dir = os.path.join(project_dir, ".omg", "evidence")
+    if not os.path.isdir(evidence_dir):
+        return {}
+
+    candidates = sorted(
+        [
+            os.path.join(evidence_dir, name)
+            for name in os.listdir(evidence_dir)
+            if name.endswith(".json")
+        ],
+        key=os.path.getmtime,
+        reverse=True,
+    )
+    for path in candidates:
+        try:
+            with open(path, "r", encoding="utf-8", errors="ignore") as handle:
+                payload = json.load(handle)
+        except (OSError, json.JSONDecodeError):
+            continue
+        if not isinstance(payload, dict):
+            continue
+        if payload.get("schema") != "EvidencePack":
+            continue
+        payload_run_id = str(payload.get("run_id", "")).strip()
+        if run_id and payload_run_id and payload_run_id != run_id:
+            continue
+        test_delta = payload.get("test_delta")
+        if isinstance(test_delta, dict):
+            return test_delta
+    return {}
+
+
+def _has_waiver_artifact(delta_summary: dict[str, object]) -> bool:
+    waiver = delta_summary.get("waiver_artifact")
+    if isinstance(waiver, dict):
+        for field in ("artifact_path", "path", "id", "reason"):
+            if str(waiver.get(field, "")).strip():
+                return True
+    return False
+
+
+def _has_weakened_or_drift(delta_summary: dict[str, object]) -> bool:
+    flags = delta_summary.get("flags")
+    if not isinstance(flags, list):
+        return False
+    risk_flags = {
+        "weakened_assertions",
+        "tests_mismatch",
+        "selector_drift",
+        "removed_touched_area_coverage",
+        "integration_to_mock_downgrade",
+        "snapshot_only_refresh",
+    }
+    normalized = {str(item).strip().lower() for item in flags if str(item).strip()}
+    return bool(normalized & risk_flags)
+
+
+def check_tdd_proof_chain(data, project_dir):
+    if not get_feature_flag("tdd_proof_chain", True):
+        return []
+
+    context = data["_stop_ctx"]
+    if not context.get("has_source_writes", False):
+        return []
+
+    run_id = resolve_current_run_id(project_dir=project_dir)
+    lock_verdict = test_intent_lock.verify_lock(project_dir, run_id=run_id)
+    delta_summary = data.get("_test_delta") if isinstance(data.get("_test_delta"), dict) else {}
+    if not delta_summary:
+        delta_summary = _load_test_delta_from_evidence(project_dir, run_id)
+
+    lock_missing = str(lock_verdict.get("status", "")).strip() != "ok"
+    weakened_without_waiver = _has_weakened_or_drift(delta_summary) and not _has_waiver_artifact(delta_summary)
+    if not lock_missing and not weakened_without_waiver:
+        return []
+
+    strict_mode = _proof_chain_strict_enabled()
+    if strict_mode:
+        return [json.dumps({"status": "blocked", "reason": "tdd_proof_chain_incomplete"}, sort_keys=True)]
+
+    warnings.warn(
+        "tdd_proof_chain_incomplete_permissive",
+        RuntimeWarning,
+        stacklevel=2,
+    )
+    advisories = data.setdefault("_stop_advisories", [])
+    advisories.append(
+        "[OMG advisory] tdd proof chain incomplete: active lock evidence or waiver artifact is missing. "
+        "Set OMG_PROOF_CHAIN_STRICT=1 to hard-block completion."
+    )
+    return []
+
 def check_simplifier(data, project_dir):
     """CHECK 7: Code simplifier — advisory only, never blocks."""
     if not get_feature_flag("simplifier", True):
@@ -832,7 +935,7 @@ def check_scope_drift(project_dir):
 
 
 
-def check_todo_continuation(data: dict) -> dict | None:
+def check_todo_continuation(data: dict[str, object]) -> dict[str, str] | None:
     """Check if agent should continue due to incomplete todos.
     Returns a dict with continuation response if idle, None otherwise.
     Budget: STOP_CHECK_MAX_MS (15s)
@@ -911,6 +1014,7 @@ def main():
         check_diff_budget,
         check_recent_failures,
         check_test_execution,
+        check_tdd_proof_chain,
         check_test_validator_coverage,
         check_false_fix,
         check_write_failures,

package/hud/omg-hud.mjs

@@ -87,7 +87,7 @@ function readOmgVersion() {
     // fall through to static fallback
   }
 
-  return "2.1.0";
+  return "2.1.4";
 }
 
 const OMG_VERSION = readOmgVersion();
@@ -723,6 +723,15 @@ function readSessionHealthFromStdin(stdin) {
   return null;
 }
 
+const STALENESS_THRESHOLD_MS = 5 * 60 * 1000;
+
+function isSessionHealthStale(health) {
+  if (!health || !health.updated_at) return false;
+  const updatedMs = new Date(health.updated_at).getTime();
+  if (isNaN(updatedMs)) return false;
+  return Date.now() - updatedMs > STALENESS_THRESHOLD_MS;
+}
+
 function renderSessionHealth(health) {
   if (!health) return null;
   const contamination = typeof health.contamination_risk === "number" ? health.contamination_risk : 0;
@@ -734,14 +743,16 @@ function renderSessionHealth(health) {
   const overPct = Math.round(overthinking * 100);
   const healthPct = Math.round(ctxHealth * 100);
 
-  const contColor = contamination >= 0.7 ? red : contamination >= 0.3 ? yellow : green;
-  const overColor = overthinking >= 0.85 ? red : overthinking >= 0.5 ? yellow : green;
-  const healthColor = ctxHealth <= 0.2 ? red : ctxHealth <= 0.4 ? yellow : green;
+  const stale = isSessionHealthStale(health);
+  const contColor = stale ? dim : contamination >= 0.7 ? red : contamination >= 0.3 ? yellow : green;
+  const overColor = stale ? dim : overthinking >= 0.85 ? red : overthinking >= 0.5 ? yellow : green;
+  const healthColor = stale ? dim : ctxHealth <= 0.2 ? red : ctxHealth <= 0.4 ? yellow : green;
 
   let badge = "";
   if (action === "block") badge = ` ${red("BLOCK")}`;
   else if (action === "reflect") badge = ` ${yellow("REFLECT")}`;
   else if (action === "warn") badge = ` ${yellow("WARN")}`;
+  if (stale) badge += ` ${yellow("[STALE]")}`;
 
   return (
     `contam:${contColor(`${contPct}%`)} ` +
@@ -940,7 +951,7 @@ function renderBackgroundTasks(tasks) {
 
 function renderVerificationStatus(state) {
   if (!state) return dim("verification: unknown");
-  const { status, blockers, evidence_links } = state;
+  const { status, blockers, evidence_links, progress } = state;
   const blockerCount = blockers.length;
   const latestEvidence = evidence_links.length > 0
     ? evidence_links[evidence_links.length - 1]
@@ -948,11 +959,24 @@ function renderVerificationStatus(state) {
   const evidenceSuffix = latestEvidence
     ? ` ${dim(`evidence:${basename(latestEvidence)}`)}`
     : "";
+
+  // Build progress suffix from step/total when available
+  const step = progress && typeof progress.step === "number" ? progress.step : null;
+  const total = progress && typeof progress.total === "number" ? progress.total : null;
+  const currentStage = progress && progress.current_stage ? progress.current_stage : null;
+  let progressSuffix = "";
+  if (step !== null && total !== null && status === "running") {
+    progressSuffix = ` ${dim(`[${step}/${total}]`)}`;
+    if (currentStage) {
+      progressSuffix += ` ${dim(currentStage)}`;
+    }
+  }
+
   if (status === "ok") {
     return green("\u2713 verification ok") + evidenceSuffix;
   }
   if (status === "running") {
-    return yellow("\u27F3 verification running") + evidenceSuffix;
+    return yellow("\u27F3 verification running") + progressSuffix + evidenceSuffix;
   }
   if (status === "error" || status === "blocked") {
     const blockerSuffix = blockerCount > 0 ? ` (${blockerCount} blockers)` : "";

package/lab/pipeline.py

@@ -3,16 +3,42 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
+from pathlib import Path
+from time import monotonic
 from typing import Any
 
 from .policies import validate_job_request
 
+PIPELINE_STAGE_ORDER: tuple[str, ...] = (
+    "data_prepare",
+    "synthetic_refine",
+    "train_distill",
+    "evaluate",
+    "regression_test",
+)
+
+_STAGE_ADAPTER_KIND: dict[str, str] = {
+    "train_distill": "training",
+    "evaluate": "simulator",
+    "regression_test": "simulator",
+}
+
 
 def _now() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
-def run_pipeline(job: dict[str, Any]) -> dict[str, Any]:
+def run_pipeline(
+    job: dict[str, Any],
+    *,
+    run_id: str | None = None,
+    project_dir: str | None = None,
+) -> dict[str, Any]:
+    from runtime.forge_contracts import build_stage_evidence, read_stage_runtime_snapshots, resolve_stage_timeout_ms
+
+    from runtime.forge_agents import check_required_backends_satisfied, resolve_adapters
+
+    active_run_id = str(run_id or _now())
     ok, reason = validate_job_request(job)
     if not ok:
         return {
@@ -21,43 +47,124 @@ def run_pipeline(job: dict[str, Any]) -> dict[str, Any]:
             "reason": reason,
             "published": False,
             "evaluation_report": None,
+            "run_id": active_run_id,
+            "stage_evidence": [],
+        }
+
+    adapter_evidence = resolve_adapters(job)
+    backends_ok, backends_reason = check_required_backends_satisfied(adapter_evidence)
+    if not backends_ok:
+        return {
+            "status": "blocked",
+            "stage": "adapter",
+            "reason": backends_reason,
+            "published": False,
+            "evaluation_report": None,
+            "run_id": active_run_id,
+            "stage_evidence": [],
+            "adapter_evidence": adapter_evidence,
         }
 
+    adapter_by_kind: dict[str, list[dict[str, object]]] = {}
+    for ev in adapter_evidence:
+        kind = str(ev.get("kind", ""))
+        adapter_by_kind.setdefault(kind, []).append(ev)
+
     target_metric = float(job.get("target_metric", 0.8))
     simulated_metric = float(job.get("simulated_metric", target_metric))
+    failed_stages = _normalize_stage_set(job.get("stage_failures"))
+    explicit_failed_stage = str(job.get("fail_stage", "")).strip().lower()
+    if explicit_failed_stage:
+        failed_stages.add(explicit_failed_stage)
 
-    stages = [
-        {"name": "data_prepare", "status": "ok"},
-        {"name": "synthetic_refine", "status": "ok"},
-        {"name": "train_distill", "status": "ok"},
-        {"name": "evaluate", "status": "ok" if simulated_metric >= target_metric else "fail"},
-        {"name": "regression_test", "status": "ok" if simulated_metric >= target_metric else "fail"},
-    ]
+    stage_durations_ms = _normalize_int_map(job.get("stage_durations_ms"))
+    stage_artifacts = _normalize_artifact_map(job.get("stage_artifacts"))
 
-    report = {
-        "created_at": _now(),
-        "metric": simulated_metric,
-        "target_metric": target_metric,
-        "passed": simulated_metric >= target_metric,
-        "notes": job.get("evaluation_notes", ""),
-    }
+    stages: list[dict[str, str]] = []
+    stage_evidence: list[dict[str, object]] = []
+    snapshot_root = str(Path(project_dir)) if project_dir else ""
 
-    if not report["passed"]:
-        return {
-            "status": "failed_evaluation",
-            "stage": "evaluate",
-            "stages": stages,
-            "published": False,
-            "evaluation_report": report,
-        }
+    for stage in PIPELINE_STAGE_ORDER:
+        started_at = monotonic()
+        stage_status = "success"
+        timeout_ms = resolve_stage_timeout_ms(job, stage)
+        requested_duration_ms = stage_durations_ms.get(stage, 0)
 
-    return {
+        if timeout_ms == 0 or requested_duration_ms > timeout_ms:
+            stage_status = "timeout"
+        elif stage in failed_stages:
+            stage_status = "failed"
+        elif stage in {"evaluate", "regression_test"} and simulated_metric < target_metric:
+            stage_status = "failed"
+
+        stage_adapter_kind = _STAGE_ADAPTER_KIND.get(stage)
+        stage_adapter_ev = adapter_by_kind.get(stage_adapter_kind, []) if stage_adapter_kind else []
+
+        defense_snapshot: dict[str, object] = {}
+        session_health_snapshot: dict[str, object] = {}
+        if snapshot_root:
+            defense_snapshot, session_health_snapshot = read_stage_runtime_snapshots(snapshot_root, active_run_id)
+
+        stage_record = build_stage_evidence(
+            stage=stage,
+            run_id=active_run_id,
+            status=stage_status,
+            started_at_ms=started_at,
+            defense_snapshot=defense_snapshot,
+            session_health_snapshot=session_health_snapshot,
+            artifacts=stage_artifacts.get(stage, []),
+            adapter_evidence=stage_adapter_ev if stage_adapter_ev else None,
+        )
+        stage_evidence.append(stage_record)
+        stages.append({"name": stage, "status": _to_legacy_stage_status(stage_status)})
+
+        if stage_status == "timeout":
+            return {
+                "status": "stage_timeout",
+                "stage": stage,
+                "reason": f"stage timeout envelope exceeded for {stage}",
+                "stages": stages,
+                "published": False,
+                "evaluation_report": _evaluation_report(job, simulated_metric, target_metric),
+                "run_id": active_run_id,
+                "stage_evidence": stage_evidence,
+            }
+        if stage_status == "failed":
+            if stage in {"evaluate", "regression_test"} and simulated_metric < target_metric:
+                return {
+                    "status": "failed_evaluation",
+                    "stage": "evaluate",
+                    "stages": stages,
+                    "published": False,
+                    "evaluation_report": _evaluation_report(job, simulated_metric, target_metric),
+                    "run_id": active_run_id,
+                    "stage_evidence": stage_evidence,
+                }
+            return {
+                "status": "failed_stage",
+                "stage": stage,
+                "reason": f"stage execution failed for {stage}",
+                "stages": stages,
+                "published": False,
+                "evaluation_report": _evaluation_report(job, simulated_metric, target_metric),
+                "run_id": active_run_id,
+                "stage_evidence": stage_evidence,
+            }
+
+    report = _evaluation_report(job, simulated_metric, target_metric)
+
+    result: dict[str, Any] = {
         "status": "ready",
         "stage": "complete",
         "stages": stages,
         "published": False,
         "evaluation_report": report,
+        "run_id": active_run_id,
+        "stage_evidence": stage_evidence,
     }
+    if adapter_evidence:
+        result["adapter_evidence"] = adapter_evidence
+    return result
 
 
 def publish_artifact(result: dict[str, Any]) -> dict[str, Any]:
@@ -79,8 +186,72 @@ def publish_artifact(result: dict[str, Any]) -> dict[str, Any]:
 def run_pipeline_with_evidence(project_dir: str, job: dict[str, Any], run_id: str) -> dict[str, Any]:
     from runtime.forge_contracts import build_forge_evidence
 
-    result = run_pipeline(job)
-    evidence_path = build_forge_evidence(project_dir=project_dir, run_id=run_id, job=job, result=result)
+    result = run_pipeline(job, run_id=run_id, project_dir=project_dir)
+    evidence_path = build_forge_evidence(
+        project_dir=project_dir,
+        run_id=run_id,
+        job=job,
+        result=result,
+        stage_evidence=result.get("stage_evidence", []),
+    )
     out = dict(result)
     out["evidence_path"] = evidence_path
+    out["labs_only"] = True
+    out["proof_backed"] = True
     return out
+
+
+def _evaluation_report(job: dict[str, Any], simulated_metric: float, target_metric: float) -> dict[str, object]:
+    return {
+        "created_at": _now(),
+        "metric": simulated_metric,
+        "target_metric": target_metric,
+        "passed": simulated_metric >= target_metric,
+        "notes": job.get("evaluation_notes", ""),
+    }
+
+
+def _normalize_stage_set(value: object) -> set[str]:
+    if not isinstance(value, list):
+        return set()
+    out: set[str] = set()
+    for item in value:
+        stage = str(item).strip().lower()
+        if stage in PIPELINE_STAGE_ORDER:
+            out.add(stage)
+    return out
+
+
+def _normalize_int_map(value: object) -> dict[str, int]:
+    if not isinstance(value, dict):
+        return {}
+    out: dict[str, int] = {}
+    for raw_key, raw_value in value.items():
+        stage = str(raw_key).strip().lower()
+        if stage not in PIPELINE_STAGE_ORDER:
+            continue
+        try:
+            out[stage] = max(0, int(raw_value))
+        except (TypeError, ValueError):
+            continue
+    return out
+
+
+def _normalize_artifact_map(value: object) -> dict[str, list[str]]:
+    if not isinstance(value, dict):
+        return {}
+    out: dict[str, list[str]] = {}
+    for raw_key, raw_value in value.items():
+        stage = str(raw_key).strip().lower()
+        if stage not in PIPELINE_STAGE_ORDER or not isinstance(raw_value, list):
+            continue
+        out[stage] = [str(item) for item in raw_value]
+    return out
+
+
+def _to_legacy_stage_status(stage_status: str) -> str:
+    if stage_status == "success":
+        return "ok"
+    if stage_status == "timeout":
+        return "timeout"
+    return "fail"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trac3er/oh-my-god",
-  "version": "2.1.0",
+  "version": "2.1.4",
   "description": "OMG (Oh My God) — Multi-agent orchestration, evidence-backed verification, and durable session state for Claude Code, Codex, and supported agent hosts",
   "main": "OMG-setup.sh",
   "scripts": {

package/plugins/advanced/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "omg-advanced",
-  "version": "2.1.0",
+  "version": "2.1.4",
   "description": "Advanced OMG commands - deep planning, learning, code review, and specialized workflows",
   "type": "omg-plugin",
   "commands": {
@@ -53,35 +53,52 @@
   "categories": {
     "planning": {
       "description": "Strategic planning and architecture",
-      "commands": ["deep-plan"]
+      "commands": [
+        "deep-plan"
+      ]
     },
     "quality": {
       "description": "Code quality and review",
-      "commands": ["code-review"]
+      "commands": [
+        "code-review"
+      ]
     },
     "knowledge": {
       "description": "Learning and skill creation",
-      "commands": ["learn"]
+      "commands": [
+        "learn"
+      ]
     },
     "delivery": {
       "description": "Shipping and release workflows",
-      "commands": ["ship"]
+      "commands": [
+        "ship"
+      ]
     },
     "collaboration": {
       "description": "Team collaboration and handoff",
-      "commands": ["handoff"]
+      "commands": [
+        "handoff"
+      ]
     },
     "automation": {
       "description": "Autonomous execution modes",
-      "commands": ["ralph-start", "ralph-stop"]
+      "commands": [
+        "ralph-start",
+        "ralph-stop"
+      ]
     },
     "thinking": {
       "description": "Structured thinking tools",
-      "commands": ["sequential-thinking"]
+      "commands": [
+        "sequential-thinking"
+      ]
     },
     "oss": {
       "description": "Open source maintainer tools",
-      "commands": ["maintainer"]
+      "commands": [
+        "maintainer"
+      ]
     }
   }
 }