@trac3er/oh-my-god 2.1.8 → 2.2.2

package/hooks/stop_dispatcher.py

@@ -9,14 +9,20 @@ import subprocess
 import sys
 import time
 from datetime import datetime, timedelta, timezone
+from pathlib import Path
 import warnings
 
-sys.path.insert(0, os.path.dirname(__file__))
-sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+HOOKS_DIR = str(Path(__file__).resolve().parent)
+PROJECT_ROOT = str(Path(HOOKS_DIR).parent)
+PORTABLE_RUNTIME_ROOT = str(Path(PROJECT_ROOT) / "omg-runtime")
+for path in (HOOKS_DIR, PROJECT_ROOT, PORTABLE_RUNTIME_ROOT):
+    if path not in sys.path:
+        sys.path.insert(0, path)
 
 from hooks._common import (  # noqa: E402
     atomic_json_write,
     block_decision,
+    bootstrap_runtime_paths,
     check_performance_budget,
     get_feature_flag,
     get_project_dir,
@@ -28,9 +34,12 @@ from hooks._common import (  # noqa: E402
     setup_crash_handler,
     should_skip_stop_hooks,
     STOP_CHECK_MAX_MS,
+    STOP_DISPATCHER_TOTAL_MAX_MS,
 )
 from hooks.state_migration import resolve_state_file  # noqa: E402
 
+bootstrap_runtime_paths(__file__)
+
 from runtime.release_run_coordinator import resolve_current_run_id  # noqa: E402
 from runtime import test_intent_lock  # noqa: E402
 
@@ -136,6 +145,14 @@ def _is_internal_control_path(file_path: str) -> bool:
     return any(p.lower() in fl for p in INTERNAL_CONTROL_PATH_PATTERNS)
 
 
+_RALPH_DEFAULT_TIMEOUT_MINUTES = 10
+
+
+def _watchdog_check(start_time):
+    """Return True if the dispatcher has exceeded its wall-clock budget."""
+    return (time.time() - start_time) >= (STOP_DISPATCHER_TOTAL_MAX_MS / 1000)
+
+
 try:
     from hooks.shadow_manager import has_recent_evidence  # type: ignore
 except Exception:  # intentional: optional feature — shadow_manager may not exist
@@ -628,7 +645,7 @@ def check_bare_done(data, project_dir):
 
 
 def _proof_chain_strict_enabled() -> bool:
-    return os.environ.get("OMG_PROOF_CHAIN_STRICT", "0").strip() == "1"
+    return os.environ.get("OMG_PROOF_CHAIN_STRICT", "1").strip() != "0"
 
 
 def _load_test_delta_from_evidence(project_dir: str, run_id: str | None) -> dict[str, object]:
@@ -720,7 +737,7 @@ def check_tdd_proof_chain(data, project_dir):
     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."
+        "Production default is fail-closed; OMG_PROOF_CHAIN_STRICT=0 downgrades to advisory."
     )
     return []
 
@@ -828,24 +845,63 @@ def format_ralph_block_reason(state, project_dir):
         f"If truly done, run: /OMG:ralph-stop"
     )
 
+def persist_ralph_question(project_dir, question_text):
+    """Persist a pending clarification question in the Ralph loop state.
+
+    Called when any hook or the context engine detects ambiguity during a
+    Ralph iteration.  The next stop-hook check will emit the question via
+    block_decision and end the turn — no tool action may proceed.
+    """
+    ralph_path = os.path.join(project_dir, ".omg", "state", "ralph-loop.json")
+    if not os.path.exists(ralph_path):
+        return
+    try:
+        with open(ralph_path, "r", encoding="utf-8") as f:
+            state = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return
+    state["question_pending"] = True
+    state["question_text"] = str(question_text).strip()[:500]
+    state["question_emitted_at"] = datetime.now(timezone.utc).isoformat()
+    atomic_json_write(ralph_path, state)
+
+
 def check_ralph_loop(project_dir, data):
+    """Check Ralph loop state and return (block_reasons, advisories, is_question).
+
+    When *is_question* is True the block is a clarification question and the
+    caller MUST use block_reason="clarification_required" so that the turn
+    ends without any further tool action.
+    """
     del data
 
     if not get_feature_flag("ralph_loop"):
-        return [], []
+        return [], [], False
     ralph_path = os.path.join(project_dir, ".omg", "state", "ralph-loop.json")
     if not os.path.exists(ralph_path):
-        return [], []
+        return [], [], False
     try:
         with open(ralph_path, "r", encoding="utf-8") as f:
             state = json.load(f)
     except (json.JSONDecodeError, OSError):
-        return [], []
+        return [], [], False
     if not state.get("active"):
-        return [], []
-    
+        return [], [], False
+
+    # --- Pending clarification question: block and end turn immediately ---
+    if state.get("question_pending"):
+        question_text = str(state.get("question_text", "")).strip()
+        if not question_text:
+            question_text = "Clarification required before continuing Ralph loop"
+        # Do NOT increment iteration — the loop is paused on the question
+        return [question_text], [], True
+
     # Check if Ralph loop has expired
-    timeout_minutes = int(os.environ.get("OMG_RALPH_TIMEOUT_MINUTES", "30"))
+    _raw_timeout = os.environ.get("OMG_RALPH_TIMEOUT_MINUTES", "")
+    try:
+        timeout_minutes = int(_raw_timeout) if _raw_timeout.strip() else _RALPH_DEFAULT_TIMEOUT_MINUTES
+    except (ValueError, TypeError):
+        timeout_minutes = _RALPH_DEFAULT_TIMEOUT_MINUTES
     started_at_str = state.get("started_at")
     if started_at_str:
         try:
@@ -855,7 +911,7 @@ def check_ralph_loop(project_dir, data):
             if elapsed.total_seconds() > timeout_minutes * 60:
                 state["active"] = False
                 atomic_json_write(ralph_path, state)
-                return [], [f"Ralph loop expired after {timeout_minutes} minutes. Stopping."]
+                return [], [f"Ralph loop expired after {timeout_minutes} minutes. Stopping."], False
         except (ValueError, TypeError):
             pass
     
@@ -864,11 +920,11 @@ def check_ralph_loop(project_dir, data):
     if iteration >= max_iter:
         state["active"] = False
         atomic_json_write(ralph_path, state)
-        return [], ["Ralph loop reached max iterations. Stopping."]
+        return [], ["Ralph loop reached max iterations. Stopping."], False
     state["iteration"] = iteration + 1
     atomic_json_write(ralph_path, state)
     reason = format_ralph_block_reason(state, project_dir)
-    return [reason], []
+    return [reason], [], False
 
 
 def check_planning_gate(project_dir):
@@ -972,41 +1028,63 @@ def check_todo_continuation(data: dict[str, object]) -> dict[str, str] | None:
 
 
 def main():
+    _watchdog_start = time.time()
+
     data = json_input()
 
     # Unified guard: stop-hook loop, context-limit, and re-entry detection
     if should_skip_stop_hooks(data):
         sys.exit(0)
 
+    # Watchdog: bail out if we already burned too much wall-clock time
+    if _watchdog_check(_watchdog_start):
+        print("[OMG] stop_dispatcher: wall-clock watchdog expired", file=sys.stderr)
+        sys.exit(0)
+
     project_dir = _resolve_project_dir()
     data["_stop_ctx"] = _build_context(project_dir)
     data["_stop_advisories"] = []
 
     # P1: Ralph loop check (implemented in Task 18)
-    block_reasons, advisories = check_ralph_loop(project_dir, data)
+    block_reasons, advisories, is_question = check_ralph_loop(project_dir, data)
     if advisories:
         data["_stop_advisories"].extend(advisories)
     if block_reasons:
-        record_stop_block(project_dir, reason="ralph_loop")
-        block_decision(block_reasons[0])
+        # Clarification questions use a distinct block_reason so the turn
+        # ends cleanly — no tool action may follow a question emission.
+        br = "clarification_required" if is_question else "ralph_loop"
+        block_decision(block_reasons[0], block_reason=br, project_dir=project_dir)
+        return
+
+    if _watchdog_check(_watchdog_start):
+        print("[OMG] stop_dispatcher: wall-clock watchdog expired", file=sys.stderr)
+        sys.exit(0)
 
     # P2: Planning enforcement (implemented in Task 22)
     block_reasons, advisories = check_planning_gate(project_dir)
     if block_reasons:
-        record_stop_block(project_dir, reason="planning_gate")
-        block_decision(block_reasons[0])
+        block_decision(block_reasons[0], block_reason="planning_gate", project_dir=project_dir)
+        return
     advisories.extend(check_scope_drift(project_dir))
     if advisories:
         data["_stop_advisories"].extend(advisories)
 
+    if _watchdog_check(_watchdog_start):
+        print("[OMG] stop_dispatcher: wall-clock watchdog expired", file=sys.stderr)
+        sys.exit(0)
+
     # P3: Todo continuation enforcement (Task 1.6)
     _p3_start = time.monotonic()
     todo_result = check_todo_continuation(data)
     _p3_elapsed = (time.monotonic() - _p3_start) * 1000
     check_performance_budget("check_todo_continuation", _p3_elapsed, STOP_CHECK_MAX_MS)
     if todo_result and todo_result.get("decision") == "block":
-        record_stop_block(project_dir, reason="todo_continuation")
-        block_decision(todo_result["reason"])
+        block_decision(todo_result["reason"], block_reason="todo_continuation", project_dir=project_dir)
+        return
+
+    if _watchdog_check(_watchdog_start):
+        print("[OMG] stop_dispatcher: wall-clock watchdog expired", file=sys.stderr)
+        sys.exit(0)
 
     blocks = []
     for check_fn in [
@@ -1022,6 +1100,9 @@ def main():
         _test_validator_check,
         _quality_runner_check,
     ]:
+        if _watchdog_check(_watchdog_start):
+            print("[OMG] stop_dispatcher: wall-clock watchdog expired during quality checks", file=sys.stderr)
+            sys.exit(0)
         if check_fn is None:
             continue
         try:
@@ -1037,8 +1118,8 @@ def main():
         print("\n".join(advisories), file=sys.stderr)
 
     if blocks:
-        record_stop_block(project_dir, reason="quality_check")
-        block_decision("\n\n---\n\n".join(blocks))
+        block_decision("\n\n---\n\n".join(blocks), block_reason="quality_check", project_dir=project_dir)
+        return
 
     check_simplifier(data, project_dir)
     reset_stop_block_tracker(project_dir)

package/hooks/test-validator.py

@@ -23,10 +23,13 @@ from collections import Counter
 from datetime import datetime, timezone
 
 HOOKS_DIR = os.path.dirname(__file__)
+PROJECT_ROOT = os.path.dirname(HOOKS_DIR)
 if HOOKS_DIR not in sys.path:
     sys.path.insert(0, HOOKS_DIR)
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
 
-from _common import _resolve_project_dir, should_skip_stop_hooks
+from hooks._common import _resolve_project_dir, should_skip_stop_hooks
 
 # --- Builtins excluded from parameterized-gap detection ---
 _BUILTIN_FUNCS = frozenset({
@@ -36,6 +39,9 @@ _BUILTIN_FUNCS = frozenset({
     "expect", "require", "import", "open", "super", "getattr", "setattr",
     "hasattr", "sorted", "enumerate", "zip", "map", "filter", "min", "max",
 })
+_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
+_SKIP_DIR_SEGMENTS = frozenset({"build", "dist", "node_modules", ".git"})
+_TEST_DIR_NAMES = frozenset({"tests", "test", "__tests__"})
 
 
 def analyze_test_content(content, filename="test.py"):
@@ -267,6 +273,31 @@ def persist_metrics(project_dir, analysis):
         pass  # Crash isolation: never fail the hook
 
 
+def _is_test_file(rel_path):
+    """
+    Heuristic: is this path likely a test file (vs source module)?
+
+    Excludes build artifacts and source modules that happen to start with
+    ``test_`` but live outside test directories (e.g. ``runtime/test_intent_lock.py``).
+    """
+    parts = rel_path.replace("\\", "/").split("/")
+    # Skip build artifacts and vendored code
+    if any(seg in _SKIP_DIR_SEGMENTS for seg in parts[:-1]):
+        return False
+    basename = parts[-1].lower() if parts else ""
+    # Standard test file patterns (checked against basename)
+    if any(p in basename for p in (".test.", ".spec.", "_test.", ".tests.")):
+        return True
+    # __tests__ directory anywhere in path
+    if "__tests__" in rel_path:
+        return True
+    # test_ prefix: only match if file is in a test directory or at repo root
+    if basename.startswith("test_"):
+        parent_dirs = {p.lower() for p in parts[:-1]}
+        return not parent_dirs or bool(parent_dirs & _TEST_DIR_NAMES)
+    return False
+
+
 def check_test_quality(data, project_dir):
     """Core test-quality validation. Returns list of block-reason strings."""
     import subprocess
@@ -279,8 +310,7 @@ def check_test_quality(data, project_dir):
             capture_output=True, text=True, timeout=10, cwd=project_dir
         )
         for f in result.stdout.strip().split("\n"):
-            if f and any(p in f.lower() for p in
-                         [".test.", ".spec.", "_test.", "test_", "__tests__", ".tests."]):
+            if f and _is_test_file(f):
                 full = os.path.join(project_dir, f)
                 if os.path.exists(full):
                     test_files.append(full)
@@ -344,6 +374,44 @@ def check_test_quality(data, project_dir):
     return []
 
 
+def check_methodology_contract(data):
+    if not isinstance(data, dict):
+        return []
+
+    tool_name = str(data.get("tool_name", "")).strip().lower()
+    if tool_name not in _MUTATION_TOOLS:
+        return []
+
+    tool_input = data.get("tool_input")
+    if not isinstance(tool_input, dict):
+        return ["METHODOLOGY: mutation-capable flow requires metadata with done_when criteria"]
+
+    exemption = str(tool_input.get("exemption", "")).strip().lower()
+    if exemption == "docs":
+        return []
+
+    metadata = tool_input.get("metadata")
+    if not isinstance(metadata, dict):
+        return ["METHODOLOGY: mutation-capable flow requires metadata with done_when criteria"]
+
+    done_when = metadata.get("done_when")
+    if isinstance(done_when, str) and done_when.strip():
+        return []
+    if isinstance(done_when, list):
+        if any(str(item).strip() for item in done_when):
+            return []
+    if isinstance(done_when, dict):
+        criteria = done_when.get("criteria")
+        if isinstance(criteria, str) and criteria.strip():
+            return []
+        if isinstance(criteria, list) and any(str(item).strip() for item in criteria):
+            return []
+        if str(done_when.get("summary", "")).strip():
+            return []
+
+    return ["METHODOLOGY: done_when criteria required before mutation-capable execution"]
+
+
 # Standalone execution (backward compat: invoked directly by hook runner)
 if __name__ == "__main__":
     try:
@@ -356,6 +424,7 @@ if __name__ == "__main__":
 
     project_dir = _resolve_project_dir()
     blocks = check_test_quality(data, project_dir)
+    blocks.extend(check_methodology_contract(data))
     if blocks:
         json.dump({"decision": "block", "reason": blocks[0]}, sys.stdout)
     sys.exit(0)

package/hooks/tool-ledger.py

@@ -53,8 +53,19 @@ entry = {
     "ts": datetime.now(timezone.utc).isoformat(),
     "pid": os.getpid(),
     "tool": tool_name,
+    "surface_tags": [],
 }
 
+if isinstance(tool_input, dict):
+    lane_name = tool_input.get("lane_name", tool_input.get("lane"))
+    if isinstance(lane_name, str) and lane_name.strip():
+        entry["lane"] = lane_name.strip().lower()
+        entry["surface_tags"].append("governed_tools")
+    governed_tool = tool_input.get("tool_name")
+    if isinstance(governed_tool, str) and governed_tool.strip() and governed_tool != tool_name:
+        entry["governed_tool"] = governed_tool.strip()
+        entry["surface_tags"].append("governed_tools")
+
 # Link ledger entries to OMG v1 run/evidence artifacts when available.
 run_id = os.environ.get("OMG_RUN_ID")
 if not run_id:
@@ -69,6 +80,7 @@ if run_id:
     entry["run_id"] = run_id
 
 if tool_name == "Bash":
+    entry["surface_tags"].append("hooks")
     entry["command"] = tool_input.get("command", "")[:500]
     if isinstance(tool_response, dict):
         entry["exit_code"] = tool_response.get("exitCode", tool_response.get("exit_code"))
@@ -107,6 +119,10 @@ if run_id:
     ev_path = os.path.join(project_dir, ".omg", "evidence", f"{run_id}.json")
     if os.path.exists(ev_path):
         entry["evidence_path"] = os.path.relpath(ev_path, project_dir)
+        entry["evidence_links"] = [entry["evidence_path"]]
+
+if not entry["surface_tags"]:
+    entry.pop("surface_tags", None)
 
 # ── Latency tracking: duration_ms ──
 # Prefer startTime/endTime from hook stdin (ISO8601), fall back to wall clock.

package/hud/omg-hud.mjs

@@ -6,7 +6,7 @@
  * and native options via `omgHud`.
  */
 
-import { readFileSync, existsSync, readdirSync, realpathSync } from "node:fs";
+import { readFileSync, existsSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
@@ -87,7 +87,7 @@ function readOmgVersion() {
     // fall through to static fallback
   }
 
-  return "2.1.8";
+  return "2.2.2";
 }
 
 const OMG_VERSION = readOmgVersion();
@@ -495,6 +495,74 @@ function getModelShort(stdin, format = "short") {
   return formatModelName(id, format);
 }
 
+function getModelId(stdin) {
+  const fromStdin = stdin?.model?.id ?? stdin?.model?.display_name ?? "";
+  const fromEnv = process.env.CLAUDE_MODEL || process.env.OMG_MODEL_ID || process.env.OPENAI_MODEL || "";
+  return String(fromStdin || fromEnv || "").trim();
+}
+
+function isKnownModelHost(modelId) {
+  const lower = String(modelId || "").toLowerCase();
+  if (!lower) return false;
+  return (
+    lower.startsWith("claude") ||
+    lower.startsWith("gpt") ||
+    lower.startsWith("o3") ||
+    lower.startsWith("o4") ||
+    lower.startsWith("gemini") ||
+    lower.startsWith("kimi") ||
+    lower.startsWith("moonshot")
+  );
+}
+
+function getHostAwareCompactionTrigger(cwd, modelId) {
+  const fallback = 200_000;
+  if (!isKnownModelHost(modelId)) {
+    return fallback;
+  }
+
+  const projectDir = cwd || process.cwd();
+  try {
+    const output = execFileSync(
+      "python3",
+      [
+        "-c",
+        "import os; from runtime.context_limits import compaction_trigger; m=(os.environ.get('OMG_MODEL_ID') or '').strip(); print(int(compaction_trigger(m)))",
+      ],
+      {
+        cwd: projectDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env: {
+          ...process.env,
+          OMG_MODEL_ID: String(modelId || "").trim(),
+        },
+      },
+    ).trim();
+    const parsed = Number(output);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return Math.round(parsed);
+    }
+  } catch {
+    // fallback below
+  }
+  return fallback;
+}
+
+function getCompactWarningThreshold(stdin, cfg, cwd) {
+  const configuredPercent = Number(
+    cfg.contextLimitWarning.threshold ?? cfg.thresholds.contextCompactSuggestion ?? 80,
+  );
+  const contextWindowSize = Number(stdin?.context_window?.context_window_size ?? 0);
+  const modelId = getModelId(stdin);
+  const triggerTokens = getHostAwareCompactionTrigger(cwd, modelId);
+  if (contextWindowSize > 0 && Number.isFinite(contextWindowSize)) {
+    const derivedPercent = Math.round((triggerTokens / contextWindowSize) * 100);
+    return Math.max(1, Math.min(100, derivedPercent));
+  }
+  return configuredPercent;
+}
+
 function sessionDuration(transcriptPath) {
   if (!transcriptPath || !existsSync(transcriptPath)) return null;
   try {
@@ -698,18 +766,121 @@ function readBackgroundVerificationState(stateDir) {
   };
 }
 
+function readActiveRunId(stateDir) {
+  const activeRunPath = join(dirname(stateDir), "shadow", "active-run");
+  try {
+    if (existsSync(activeRunPath)) {
+      const value = readFileSync(activeRunPath, "utf8").trim();
+      if (value) return value;
+    }
+  } catch {
+    return readActiveCoordinatorRunId(stateDir);
+  }
+  return readActiveCoordinatorRunId(stateDir);
+}
+
+function readActiveCoordinatorRunId(stateDir) {
+  const projectDir = dirname(dirname(stateDir));
+  try {
+    const output = execFileSync(
+      "python3",
+      [
+        "-c",
+        "from runtime.release_run_coordinator import get_active_coordinator_run_id; import os; print(get_active_coordinator_run_id(os.environ.get('OMG_HUD_PROJECT_DIR')) or '')",
+      ],
+      {
+        cwd: projectDir,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env: {
+          ...process.env,
+          OMG_HUD_PROJECT_DIR: projectDir,
+        },
+      },
+    ).trim();
+    return output || null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeVerificationState(data) {
+  if (!data || typeof data !== "object") return null;
+  const schema = data.schema;
+  if (schema !== "VerificationControllerState" && schema !== "BackgroundVerificationState") {
+    return null;
+  }
+  return {
+    status: data.status || "unknown",
+    blockers: Array.isArray(data.blockers) ? data.blockers : [],
+    evidence_links: Array.isArray(data.evidence_links) ? data.evidence_links : [],
+    progress: data.progress || {},
+    updated_at: data.updated_at || null,
+    run_id: data.run_id || null,
+  };
+}
+
+function readVerificationState(stateDir) {
+  const activeRunId = readActiveRunId(stateDir);
+  if (!activeRunId) {
+    return {
+      status: "no_active_run",
+      blockers: [],
+      evidence_links: [],
+      progress: {},
+      updated_at: null,
+      run_id: null,
+    };
+  }
+  const candidates = [];
+  candidates.push(join(stateDir, "verification_controller", `${activeRunId}.json`));
+  candidates.push(join(stateDir, "verification_controller", "latest.json"));
+  candidates.push(join(stateDir, "background-verification.json"));
+
+  for (const candidate of candidates) {
+    const normalized = normalizeVerificationState(readJsonSafe(candidate));
+    if (activeRunId && normalized?.run_id && normalized.run_id !== activeRunId) {
+      continue;
+    }
+    if (normalized) return normalized;
+  }
+  return null;
+}
+
 function readLatestSessionHealth(stateDir) {
   const healthDir = join(stateDir, "session_health");
   if (!existsSync(healthDir)) return null;
   try {
+    const activeRunId = readActiveRunId(stateDir);
+    const candidates = [];
+    if (activeRunId) {
+      candidates.push(join(healthDir, `${activeRunId}.json`));
+    }
+    candidates.push(join(healthDir, "latest.json"));
+    for (const candidate of candidates) {
+      const data = readJsonSafe(candidate);
+      if (activeRunId && data?.run_id && data.run_id !== activeRunId) continue;
+      if (data?.schema === "SessionHealth") return data;
+    }
+
     const files = readdirSync(healthDir)
-      .filter((f) => f.endsWith(".json") && !f.endsWith(".tmp"))
-      .sort();
-    if (files.length === 0) return null;
-    const latest = files[files.length - 1];
-    const data = readJsonSafe(join(healthDir, latest));
-    if (!data || data.schema !== "SessionHealth") return null;
-    return data;
+      .filter((f) => f.endsWith(".json") && !f.endsWith(".tmp") && f !== "latest.json")
+      .map((f) => {
+        const fullPath = join(healthDir, f);
+        try {
+          return { fullPath, mtimeMs: statSync(fullPath).mtimeMs };
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean)
+      .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const file of files) {
+      const data = readJsonSafe(file.fullPath);
+      if (activeRunId && data?.run_id && data.run_id !== activeRunId) continue;
+      if (data?.schema === "SessionHealth") return data;
+    }
+    return null;
   } catch {
     return null;
   }
@@ -951,6 +1122,9 @@ function renderBackgroundTasks(tasks) {
 
 function renderVerificationStatus(state) {
   if (!state) return dim("verification: unknown");
+  if (state.status === "no_active_run") {
+    return dim("verification: no active run");
+  }
   const { status, blockers, evidence_links, progress } = state;
   const blockerCount = blockers.length;
   const latestEvidence = evidence_links.length > 0
@@ -1233,9 +1407,7 @@ async function main() {
 
     const warning = Number(cfg.thresholds.contextWarning ?? 60);
     const critical = Number(cfg.thresholds.contextCritical ?? 85);
-    const compactThreshold = Number(
-      cfg.contextLimitWarning.threshold ?? cfg.thresholds.contextCompactSuggestion ?? 80
-    );
+    const compactThreshold = getCompactWarningThreshold(stdin, cfg, cwd);
 
     const els = [];
 
@@ -1356,7 +1528,7 @@ async function main() {
     }
 
     const verificationStateDir = join(cwd, ".omg", "state");
-    const verificationState = readBackgroundVerificationState(verificationStateDir);
+    const verificationState = readVerificationState(verificationStateDir);
     els.push(renderVerificationStatus(verificationState));
 
     // Session health monitor