diff --git a/docs/ecosystem.md b/docs/ecosystem.md
index dea86601..32b391fa 100644
--- a/docs/ecosystem.md
+++ b/docs/ecosystem.md
@@ -90,6 +90,7 @@ again.
 | `scratchpad-collision` | hook |
 | `ui-input-guard` | hook |
 | `hook-freshness` | hook (advisory) |
+| `hook-health` | hook (advisory) |
 | `llm-judge` | hook (shared background model judge; its inbox delivers finished verdicts on the next turn: Claude `UserPromptSubmit`, Cursor `stop`, Codex `notify`) |
 | `engine/CLAUDE.core.md` | global hand-written Claude rules |
 | `scripts/`, `always-on/`, `cursor/rules/` (repo root), root `install.sh` | runtime (engine-owned entrypoints at root for CI) |
diff --git a/engine/hooks/_runner/README.md b/engine/hooks/_runner/README.md
index 5250553e..719b8250 100644
--- a/engine/hooks/_runner/README.md
+++ b/engine/hooks/_runner/README.md
@@ -92,3 +92,81 @@ hook stderr:
 ```text
 catstack-hook-metrics: could not write row to <path>: <error>
 ```
+
+## Report
+
+Usage:
+
+```sh
+python3 engine/hooks/_runner/report.py [--since 7d] [--json]
+```
+
+`report.py` reads registered catstack hook commands from `~/.claude/settings.json`,
+`~/.cursor/hooks.json`, and `~/.codex/hooks.json`, then compares them with rows
+from `~/.cache/catstack-hook-metrics/runs.jsonl` by default. Set
+`CATSTACK_HOOK_METRICS_DIR` to read `runs.jsonl` from a different directory.
+`--since` accepts hour and day windows such as `12h` or `7d`.
+
+The text table header is:
+
+```text
+harness hook/script runs spoke silent blocked crashed caught_error timed_out p95_ms last_error
+```
+
+Columns:
+
+- `harness`: the harness that owns the installed command or metrics row.
+- `hook/script`: the hook name joined to the script path recorded by the runner.
+- `runs`: total matching rows in the selected window.
+- `spoke`, `silent`, `blocked`, `crashed`, `caught_error`, `timed_out`: counts
+  for each recorded outcome.
+- `p95_ms`: the 95th percentile of integer `duration_ms` values, or `-` when no
+  duration was recorded.
+- `last_error`: the first non-empty stderr line from the newest failed row, when
+  a failed row recorded one.
+
+Every registered hook gets a row. A registered hook with no rows in the selected
+window prints `no record` after `hook/script`; it is not reported as healthy:
+
+```text
+cursor hook-b/b.py no record
+```
+
+Rows in the log that do not match a currently registered catstack hook are
+printed after an `unregistered:` line:
+
+```text
+unregistered:
+claude loose/z.py 1 0 0 0 0 0 1 10 slow
+```
+
+Malformed JSONL rows, non-object rows, rows without parseable timestamps, and
+rows outside the `--since` window are skipped. Malformed rows inside the log are
+reported before the table as:
+
+```text
+skipped <count> malformed row(s)
+```
+
+Unreadable harness config files are reported before the table as:
+
+```text
+unchecked config: <path>: <error>
+```
+
+If the metrics log cannot be read, `report.py` exits `2` and prints one of the
+unchecked messages instead of a table:
+
+```text
+unchecked: no metrics log at <path>
+unchecked: <path>: <error>
+```
+
+An unsupported `--since` value also exits `2` and prints:
+
+```text
+unsupported --since value: <value>
+```
+
+With `--json`, the same report is printed as JSON with `registered`,
+`unregistered`, `malformed_rows`, `config_warnings`, and `window_rows`.
diff --git a/engine/hooks/_runner/report.py b/engine/hooks/_runner/report.py
new file mode 100644
index 00000000..0b3b90b5
--- /dev/null
+++ b/engine/hooks/_runner/report.py
@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+import wrap_installed
+
+FAILURE_OUTCOMES = {"crashed", "timed_out", "caught_error"}
+OUTCOMES = ("spoke", "silent", "blocked", "crashed", "caught_error", "timed_out")
+
+
+def metrics_path() -> Path:
+    root = os.environ.get("CATSTACK_HOOK_METRICS_DIR")
+    if root is None:
+        root = os.path.expanduser("~/.cache/catstack-hook-metrics")
+    return Path(root) / "runs.jsonl"
+
+
+def parse_since(value: str) -> timedelta:
+    if value.endswith("h"):
+        return timedelta(hours=float(value[:-1]))
+    if value.endswith("d"):
+        return timedelta(days=float(value[:-1]))
+    raise ValueError(f"unsupported --since value: {value}")
+
+
+def parse_ts(value: object) -> datetime | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        return parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def key(row: dict[str, Any]) -> tuple[str, str, str]:
+    return str(row.get("harness") or ""), str(row.get("hook") or ""), str(row.get("script") or "")
+
+
+def read_registered() -> tuple[set[tuple[str, str, str]], list[str]]:
+    home = Path(os.path.expanduser("~"))
+    registered: set[tuple[str, str, str]] = set()
+    unchecked = []
+    for _harness, relative in wrap_installed.CONFIGS:
+        path = home / relative
+        if not path.exists():
+            continue
+        try:
+            with path.open(encoding="utf-8") as handle:
+                data = json.load(handle)
+        except (OSError, json.JSONDecodeError) as exc:
+            unchecked.append(f"unchecked config: {path}: {exc}")
+            continue
+        hooks = data.get("hooks") if isinstance(data, dict) else None
+        for entry in wrap_installed._iter_command_objects(hooks):
+            identity = wrap_installed._catstack_identity(entry["command"])
+            if identity is not None:
+                harness, hook, script, _trailing = identity
+                registered.add((harness, hook, script))
+    return registered, unchecked
+
+
+def read_rows(path: Path, threshold: datetime) -> tuple[list[dict[str, Any]] | None, int, str | None]:
+    try:
+        with path.open(encoding="utf-8") as handle:
+            lines = handle.readlines()
+    except FileNotFoundError:
+        return None, 0, f"unchecked: no metrics log at {path}"
+    except OSError as exc:
+        return None, 0, f"unchecked: {path}: {exc}"
+    rows = []
+    malformed = 0
+    for line in lines:
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError:
+            malformed += 1
+            continue
+        if not isinstance(row, dict):
+            malformed += 1
+            continue
+        ts = parse_ts(row.get("ts"))
+        if ts is None:
+            malformed += 1
+            continue
+        if ts >= threshold:
+            rows.append(row)
+    return rows, malformed, None
+
+
+def p95(values: list[int]) -> int | None:
+    if not values:
+        return None
+    ordered = sorted(values)
+    index = max(0, math.ceil(len(ordered) * 0.95) - 1)
+    return ordered[index]
+
+
+def first_line(value: object) -> str:
+    if not isinstance(value, str):
+        return ""
+    for line in value.splitlines():
+        if line.strip():
+            return line.strip()
+    return ""
+
+
+def summarize_one(key_value: tuple[str, str, str], rows: list[dict[str, Any]]) -> dict[str, Any]:
+    harness, hook, script = key_value
+    summary: dict[str, Any] = {
+        "harness": harness,
+        "hook": hook,
+        "script": script,
+        "runs": len(rows),
+        "spoke": 0,
+        "silent": 0,
+        "blocked": 0,
+        "crashed": 0,
+        "caught_error": 0,
+        "timed_out": 0,
+        "p95_ms": None,
+        "last_error": "",
+        "no_record": not rows,
+    }
+    if not rows:
+        return summary
+    durations = []
+    newest_failure: tuple[datetime, str] | None = None
+    for row in rows:
+        outcome = row.get("outcome")
+        if outcome in OUTCOMES:
+            summary[outcome] += 1
+        duration = row.get("duration_ms")
+        if isinstance(duration, int) and not isinstance(duration, bool):
+            durations.append(duration)
+        if outcome in FAILURE_OUTCOMES:
+            line = first_line(row.get("stderr_tail"))
+            ts = parse_ts(row.get("ts"))
+            if line and ts is not None and (newest_failure is None or ts > newest_failure[0]):
+                newest_failure = (ts, line)
+    summary["p95_ms"] = p95(durations)
+    if newest_failure is not None:
+        summary["last_error"] = newest_failure[1]
+    return summary
+
+
+def build_report(registered: set[tuple[str, str, str]], rows: list[dict[str, Any]], malformed: int, config_warnings: list[str]) -> dict[str, Any]:
+    grouped: dict[tuple[str, str, str], list[dict[str, Any]]] = {}
+    for row in rows:
+        grouped.setdefault(key(row), []).append(row)
+    registered_rows = []
+    for item in sorted(registered):
+        registered_rows.append(summarize_one(item, grouped.pop(item, [])))
+    unregistered = []
+    for item in sorted(grouped):
+        unregistered.append(summarize_one(item, grouped[item]))
+    return {
+        "window_rows": len(rows),
+        "malformed_rows": malformed,
+        "config_warnings": config_warnings,
+        "registered": registered_rows,
+        "unregistered": unregistered,
+    }
+
+
+def format_counts(row: dict[str, Any]) -> str:
+    if row["no_record"]:
+        return "no record"
+    return (
+        f"{row['runs']} {row['spoke']} {row['silent']} {row['blocked']} "
+        f"{row['crashed']} {row['caught_error']} {row['timed_out']} "
+        f"{row['p95_ms'] if row['p95_ms'] is not None else '-'} {row['last_error']}"
+    ).rstrip()
+
+
+def format_table(report: dict[str, Any]) -> str:
+    lines = []
+    for warning in report["config_warnings"]:
+        lines.append(warning)
+    if report["malformed_rows"]:
+        lines.append(f"skipped {report['malformed_rows']} malformed row(s)")
+    lines.append("harness hook/script runs spoke silent blocked crashed caught_error timed_out p95_ms last_error")
+    for row in report["registered"]:
+        lines.append(f"{row['harness']} {row['hook']}/{row['script']} {format_counts(row)}")
+    if report["unregistered"]:
+        lines.append("unregistered:")
+        for row in report["unregistered"]:
+            lines.append(f"{row['harness']} {row['hook']}/{row['script']} {format_counts(row)}")
+    return "\n".join(lines) + "\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--since", default="7d")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        since = parse_since(args.since)
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+    path = metrics_path()
+    rows, malformed, error = read_rows(path, datetime.now(timezone.utc) - since)
+    if error is not None:
+        print(error)
+        return 2
+    registered, warnings = read_registered()
+    report = build_report(registered, rows or [], malformed, warnings)
+    if args.json:
+        print(json.dumps(report, sort_keys=True))
+    else:
+        print(format_table(report), end="")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/engine/hooks/_runner/tests/test_report.py b/engine/hooks/_runner/tests/test_report.py
new file mode 100644
index 00000000..03d7288c
--- /dev/null
+++ b/engine/hooks/_runner/tests/test_report.py
@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+RUNNER_DIR = Path(__file__).resolve().parents[1]
+REPORT = RUNNER_DIR / "report.py"
+
+
+class ReportCli(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.home = Path(self.tmp.name) / "home"
+        self.metrics = Path(self.tmp.name) / "metrics"
+        self.metrics.mkdir(parents=True)
+        self.log = self.metrics / "runs.jsonl"
+
+    def env(self) -> dict[str, str]:
+        return {**os.environ, "HOME": str(self.home), "CATSTACK_HOOK_METRICS_DIR": str(self.metrics)}
+
+    def run_report(self, *args: str) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            [sys.executable, str(REPORT), *args],
+            capture_output=True,
+            text=True,
+            env=self.env(),
+            timeout=10,
+        )
+
+    def write_json(self, path: Path, data: object) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("w", encoding="utf-8") as handle:
+            json.dump(data, handle, indent=2)
+            handle.write("\n")
+
+    def row(self, harness: str, hook: str, script: str, outcome: str, **extra: object) -> dict[str, object]:
+        data: dict[str, object] = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "harness": harness,
+            "hook": hook,
+            "script": script,
+            "event": "UserPromptSubmit",
+            "session_id": "s1",
+            "outcome": outcome,
+            "exit_code": 0,
+            "duration_ms": 10,
+            "stdout_bytes": 0,
+            "stderr_tail": "",
+        }
+        data.update(extra)
+        return data
+
+    def seed_configs(self) -> None:
+        self.write_json(
+            self.home / ".claude" / "settings.json",
+            {
+                "hooks": {
+                    "UserPromptSubmit": [
+                        {
+                            "hooks": [
+                                {
+                                    "type": "command",
+                                    "command": "python3 $HOME/.claude/hooks/_runner/run.py --timeout 9 hook-a/a.py",
+                                }
+                            ]
+                        }
+                    ]
+                }
+            },
+        )
+        self.write_json(
+            self.home / ".cursor" / "hooks.json",
+            {
+                "hooks": {
+                    "beforeSubmitPrompt": [
+                        {
+                            "command": "python3 $HOME/.cursor/hooks/_runner/run.py --timeout 9 hook-b/b.py",
+                        }
+                    ]
+                }
+            },
+        )
+        self.write_json(
+            self.home / ".codex" / "hooks.json",
+            {
+                "hooks": {
+                    "UserPromptSubmit": [
+                        {
+                            "hooks": [
+                                {
+                                    "type": "command",
+                                    "command": "python3 $HOME/.codex/hooks/_runner/run.py --timeout 9 hook-c/c.py",
+                                }
+                            ]
+                        }
+                    ]
+                }
+            },
+        )
+
+    def write_rows(self, rows: list[dict[str, object]], malformed: bool = False) -> None:
+        with self.log.open("w", encoding="utf-8") as handle:
+            for row in rows:
+                handle.write(json.dumps(row) + "\n")
+            if malformed:
+                handle.write("{bad\n")
+
+    def test_seeded_rows_include_no_record_and_unregistered(self) -> None:
+        self.seed_configs()
+        self.write_rows(
+            [
+                self.row("claude", "hook-a", "a.py", "crashed", exit_code=1, stderr_tail="boom\nsecond"),
+                self.row("codex", "hook-c", "c.py", "silent", duration_ms=20),
+                self.row("claude", "loose", "z.py", "timed_out", exit_code=1, stderr_tail="slow"),
+            ],
+            malformed=True,
+        )
+        result = self.run_report("--since", "24h")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertIn("skipped 1 malformed row(s)", result.stdout)
+        self.assertIn("claude hook-a/a.py 1 0 0 0 1 0 0 10 boom", result.stdout)
+        self.assertIn("cursor hook-b/b.py no record", result.stdout)
+        self.assertIn("codex hook-c/c.py 1 0 1 0 0 0 0 20", result.stdout)
+        self.assertIn("unregistered:\nclaude loose/z.py", result.stdout)
+
+    def test_missing_log_exits_two_with_unchecked(self) -> None:
+        self.seed_configs()
+        result = self.run_report()
+        self.assertEqual(result.returncode, 2)
+        self.assertIn("unchecked: no metrics log at", result.stdout)
+
+    def test_json_output_reports_same_data(self) -> None:
+        self.seed_configs()
+        self.write_rows([self.row("claude", "hook-a", "a.py", "spoke")])
+        result = self.run_report("--json")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        data = json.loads(result.stdout)
+        self.assertEqual(data["registered"][0]["hook"], "hook-a")
+        self.assertTrue(any(row["no_record"] for row in data["registered"]))
+
+    def test_since_filters_old_rows(self) -> None:
+        self.seed_configs()
+        old = self.row("claude", "hook-a", "a.py", "spoke")
+        old["ts"] = (datetime.now(timezone.utc) - timedelta(days=9)).isoformat()
+        self.write_rows([old])
+        result = self.run_report("--since", "7d")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertIn("claude hook-a/a.py no record", result.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/engine/hooks/hook-health/README.md b/engine/hooks/hook-health/README.md
new file mode 100644
index 00000000..e0f35a95
--- /dev/null
+++ b/engine/hooks/hook-health/README.md
@@ -0,0 +1,54 @@
+# hook-health
+
+`hook-health` is the non-blocking prompt hook that tells the agent about failed
+catstack hook runs recorded by `_runner/run.py`. It is installed as
+`UserPromptSubmit` for Claude and Codex, and as `beforeSubmitPrompt` for Cursor.
+
+On each prompt it reads `~/.cache/catstack-hook-metrics/runs.jsonl` by default,
+or `$CATSTACK_HOOK_METRICS_DIR/runs.jsonl` when that environment variable is
+set. It starts at the byte offset stored in the current session's state file:
+
+```text
+hook-health-<harness>-<session>.json
+```
+
+The session value comes from `session_id`, then `conversation_id`, then
+`unknown`; characters outside letters, digits, `_`, `.`, and `-` are replaced
+with `_`. If the saved offset is past the end of the log, reading starts at the
+beginning.
+
+The notice appears only when new rows since that offset contain failures for
+the current harness. Failure outcomes are `crashed`, `timed_out`, and
+`caught_error`. Rows for `hook-health` itself are ignored. `spoke`, `silent`,
+and `blocked` rows do not produce a notice. A missing log also stays silent
+because no wrapped hook has written metrics yet.
+
+The failure notice has this shape:
+
+```text
+hook-health: <count> hook run(s) failed since the last prompt: <hook>/<script> <outcome> (exit <exit_code>)[: <first stderr line>][; ...][; and <n> more] -- run python3 ~/.claude/hooks/_runner/report.py for the table.
+```
+
+At most five failed rows are named. If there are more than five, the notice ends
+the row list with `and <n> more`. The stderr suffix uses the first non-empty
+line from `stderr_tail`; it is omitted when there is no such line.
+
+An unreadable metrics log emits this unchecked notice instead:
+
+```text
+hook-health: could not read the hook metrics log <path>: <error>; hook failures are unchecked this turn.
+```
+
+The hook never blocks prompt submission. Claude and Codex receive the notice as
+`hookSpecificOutput.additionalContext`; Cursor receives it as
+`additional_context` with `continue: true`. Malformed stdin and unexpected
+runtime errors are written to stderr as `catstack-hook-error hook-health: ...`
+and the hook exits zero.
+
+## Files
+
+- `detect.py` returns the notice from already-loaded rows.
+- `runtime.py` owns the log offset and output shape.
+- `claude_prompt_submit.py`, `cursor_before_submit.py`, `codex_prompt_submit.py` are non-blocking entrypoints.
+- `*.hook.json` and `install_*_hook.py` merge the hook into the three harnesses.
+- `tests/` covers failed rows, silent rows, self-ignore, truncation, one-shot offsets, and unreadable logs.
diff --git a/engine/hooks/hook-health/claude.hook.json b/engine/hooks/hook-health/claude.hook.json
new file mode 100644
index 00000000..bf5721c1
--- /dev/null
+++ b/engine/hooks/hook-health/claude.hook.json
@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 $HOME/.claude/hooks/hook-health/claude_prompt_submit.py",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/engine/hooks/hook-health/claude_prompt_submit.py b/engine/hooks/hook-health/claude_prompt_submit.py
new file mode 100644
index 00000000..a570958d
--- /dev/null
+++ b/engine/hooks/hook-health/claude_prompt_submit.py
@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from runtime import main
+
+
+if __name__ == "__main__":
+    main("claude")
diff --git a/engine/hooks/hook-health/codex.hook.json b/engine/hooks/hook-health/codex.hook.json
new file mode 100644
index 00000000..40d9d2ea
--- /dev/null
+++ b/engine/hooks/hook-health/codex.hook.json
@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 $HOME/.codex/hooks/hook-health/codex_prompt_submit.py",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/engine/hooks/hook-health/codex_prompt_submit.py b/engine/hooks/hook-health/codex_prompt_submit.py
new file mode 100644
index 00000000..d10d03b4
--- /dev/null
+++ b/engine/hooks/hook-health/codex_prompt_submit.py
@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from runtime import main
+
+
+if __name__ == "__main__":
+    main("codex")
diff --git a/engine/hooks/hook-health/cursor.hook.json b/engine/hooks/hook-health/cursor.hook.json
new file mode 100644
index 00000000..4f16e0df
--- /dev/null
+++ b/engine/hooks/hook-health/cursor.hook.json
@@ -0,0 +1,10 @@
+{
+  "hooks": {
+    "beforeSubmitPrompt": [
+      {
+        "command": "python3 $HOME/.cursor/hooks/hook-health/cursor_before_submit.py",
+        "timeout": 5
+      }
+    ]
+  }
+}
diff --git a/engine/hooks/hook-health/cursor_before_submit.py b/engine/hooks/hook-health/cursor_before_submit.py
new file mode 100644
index 00000000..01204cf8
--- /dev/null
+++ b/engine/hooks/hook-health/cursor_before_submit.py
@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from runtime import main
+
+
+if __name__ == "__main__":
+    main("cursor")
diff --git a/engine/hooks/hook-health/detect.py b/engine/hooks/hook-health/detect.py
new file mode 100644
index 00000000..0a88d576
--- /dev/null
+++ b/engine/hooks/hook-health/detect.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+FAILURES = {"crashed", "timed_out", "caught_error"}
+
+
+def first_stderr_line(row: dict) -> str:
+    tail = row.get("stderr_tail")
+    if not isinstance(tail, str):
+        return ""
+    for line in tail.splitlines():
+        if line.strip():
+            return line.strip()
+    return ""
+
+
+def notice(rows: list[dict], harness: str) -> str | None:
+    failures = [
+        row
+        for row in rows
+        if row.get("harness") == harness
+        and row.get("outcome") in FAILURES
+        and row.get("hook") != "hook-health"
+    ]
+    if not failures:
+        return None
+    parts = []
+    for row in failures[:5]:
+        hook = row.get("hook") or ""
+        script = row.get("script") or ""
+        outcome = row.get("outcome") or ""
+        code = row.get("exit_code")
+        stderr = first_stderr_line(row)
+        suffix = f": {stderr}" if stderr else ""
+        parts.append(f"{hook}/{script} {outcome} (exit {code}){suffix}")
+    if len(failures) > 5:
+        parts.append(f"and {len(failures) - 5} more")
+    return (
+        f"hook-health: {len(failures)} hook run(s) failed since the last prompt: "
+        f"{'; '.join(parts)} -- run python3 ~/.claude/hooks/_runner/report.py for the table."
+    )
+
+
+def unreadable_notice(path: str, error: str) -> str:
+    return (
+        f"hook-health: could not read the hook metrics log {path}: {error}; "
+        "hook failures are unchecked this turn."
+    )
diff --git a/engine/hooks/hook-health/install_claude_hook.py b/engine/hooks/hook-health/install_claude_hook.py
new file mode 100644
index 00000000..1dbe432c
--- /dev/null
+++ b/engine/hooks/hook-health/install_claude_hook.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import json
+import os
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SETTINGS_PATH = os.path.expanduser("~/.claude/settings.json")
+FRAGMENT_PATH = os.path.join(HERE, "claude.hook.json")
+MARKER = "hook-health/claude_prompt_submit.py"
+EVENT = "UserPromptSubmit"
+
+
+def is_ours(entry: dict) -> bool:
+    return any(MARKER in hook.get("command", "") for hook in entry.get("hooks", []))
+
+
+def merge(settings: dict, fragment: dict) -> bool:
+    entries = settings.setdefault("hooks", {}).setdefault(EVENT, [])
+    incoming = fragment.get("hooks", {}).get(EVENT, [])
+    before = json.dumps(entries, sort_keys=True)
+    entries[:] = [entry for entry in entries if not is_ours(entry)] + incoming
+    return json.dumps(entries, sort_keys=True) != before
+
+
+def main() -> None:
+    settings: dict = {}
+    if os.path.exists(SETTINGS_PATH):
+        with open(SETTINGS_PATH, encoding="utf-8") as handle:
+            settings = json.load(handle)
+    with open(FRAGMENT_PATH, encoding="utf-8") as handle:
+        fragment = json.load(handle)
+    if not merge(settings, fragment):
+        print("ok      claude UserPromptSubmit hook-health already up to date")
+        return
+    os.makedirs(os.path.dirname(SETTINGS_PATH), exist_ok=True)
+    with open(SETTINGS_PATH, "w", encoding="utf-8") as handle:
+        json.dump(settings, handle, indent=2)
+        handle.write("\n")
+    print("link    claude UserPromptSubmit hook-health merged")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/engine/hooks/hook-health/install_codex_hook.py b/engine/hooks/hook-health/install_codex_hook.py
new file mode 100644
index 00000000..26d7da7d
--- /dev/null
+++ b/engine/hooks/hook-health/install_codex_hook.py
@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import copy
+import json
+import os
+
+HOOKS_PATH = os.path.expanduser("~/.codex/hooks.json")
+HERE = os.path.dirname(os.path.abspath(__file__))
+FRAGMENT_PATH = os.path.join(HERE, "codex.hook.json")
+MARKER = "hook-health/codex_prompt_submit.py"
+EVENT = "UserPromptSubmit"
+
+
+def is_ours(entry: dict) -> bool:
+    return any(MARKER in str(hook.get("command", "")) for hook in entry.get("hooks", []))
+
+
+def merge_hooks(settings: dict) -> dict:
+    result = copy.deepcopy(settings)
+    hooks = result.get("hooks")
+    if not isinstance(hooks, dict):
+        hooks = {}
+        result["hooks"] = hooks
+    with open(FRAGMENT_PATH, encoding="utf-8") as handle:
+        incoming = json.load(handle)["hooks"][EVENT]
+    existing = hooks.get(EVENT, [])
+    hooks[EVENT] = [entry for entry in existing if not is_ours(entry)] + incoming
+    return result
+
+
+def main() -> None:
+    settings: dict = {}
+    if os.path.exists(HOOKS_PATH):
+        with open(HOOKS_PATH, encoding="utf-8") as handle:
+            settings = json.load(handle)
+    merged = merge_hooks(settings)
+    if merged == settings:
+        print("ok      codex UserPromptSubmit hook-health already up to date")
+        return
+    os.makedirs(os.path.dirname(HOOKS_PATH), exist_ok=True)
+    with open(HOOKS_PATH, "w", encoding="utf-8") as handle:
+        json.dump(merged, handle, indent=2)
+        handle.write("\n")
+    print("link    codex UserPromptSubmit hook-health merged")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/engine/hooks/hook-health/install_cursor_hook.py b/engine/hooks/hook-health/install_cursor_hook.py
new file mode 100644
index 00000000..83b0eb53
--- /dev/null
+++ b/engine/hooks/hook-health/install_cursor_hook.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import json
+import os
+
+HOOKS_PATH = os.path.expanduser("~/.cursor/hooks.json")
+HERE = os.path.dirname(os.path.abspath(__file__))
+FRAGMENT_PATH = os.path.join(HERE, "cursor.hook.json")
+MARKER = "hook-health/cursor_before_submit.py"
+EVENT = "beforeSubmitPrompt"
+
+
+def load_hooks() -> dict:
+    if not os.path.exists(HOOKS_PATH):
+        return {"version": 1, "hooks": {}}
+    with open(HOOKS_PATH, encoding="utf-8") as handle:
+        data = json.load(handle)
+    if not isinstance(data, dict):
+        return {"version": 1, "hooks": {}}
+    data.setdefault("version", 1)
+    data.setdefault("hooks", {})
+    return data
+
+
+def materialize_real_file_if_symlink() -> bool:
+    if not os.path.islink(HOOKS_PATH):
+        return False
+    data = load_hooks()
+    os.unlink(HOOKS_PATH)
+    os.makedirs(os.path.dirname(HOOKS_PATH), exist_ok=True)
+    with open(HOOKS_PATH, "w", encoding="utf-8") as handle:
+        json.dump(data, handle, indent=2)
+        handle.write("\n")
+    print("fix    cursor hooks.json was a symlink; replaced with a real merged file")
+    return True
+
+
+def merge(data: dict, fragment: dict) -> bool:
+    hooks = data.setdefault("hooks", {})
+    entries = list(hooks.get(EVENT, []))
+    incoming = fragment.get("hooks", {}).get(EVENT, [])
+    before = json.dumps(entries, sort_keys=True)
+    hooks[EVENT] = [entry for entry in entries if MARKER not in str(entry.get("command", ""))] + incoming
+    return json.dumps(hooks[EVENT], sort_keys=True) != before
+
+
+def main() -> None:
+    materialized = materialize_real_file_if_symlink()
+    data = load_hooks()
+    with open(FRAGMENT_PATH, encoding="utf-8") as handle:
+        fragment = json.load(handle)
+    changed = merge(data, fragment)
+    if not changed and not materialized:
+        print("ok      cursor beforeSubmitPrompt hook-health already up to date")
+        return
+    os.makedirs(os.path.dirname(HOOKS_PATH), exist_ok=True)
+    with open(HOOKS_PATH, "w", encoding="utf-8") as handle:
+        json.dump(data, handle, indent=2)
+        handle.write("\n")
+    print("link    cursor beforeSubmitPrompt hook-health merged")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/engine/hooks/hook-health/runtime.py b/engine/hooks/hook-health/runtime.py
new file mode 100644
index 00000000..5c48f34f
--- /dev/null
+++ b/engine/hooks/hook-health/runtime.py
@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+from detect import notice, unreadable_notice
+
+
+def metrics_dir() -> Path:
+    root = os.environ.get("CATSTACK_HOOK_METRICS_DIR")
+    if root is None:
+        root = os.path.expanduser("~/.cache/catstack-hook-metrics")
+    return Path(root)
+
+
+def session_id(payload: object) -> str:
+    if not isinstance(payload, dict):
+        return "unknown"
+    value = payload.get("session_id")
+    if value is None:
+        value = payload.get("conversation_id")
+    if value is None:
+        return "unknown"
+    return re.sub(r"[^A-Za-z0-9_.-]+", "_", str(value))[:160] or "unknown"
+
+
+def cursor_path(root: Path, harness: str, session: str) -> Path:
+    return root / f"hook-health-{harness}-{session}.json"
+
+
+def read_offset(path: Path) -> int:
+    try:
+        with path.open(encoding="utf-8") as handle:
+            data = json.load(handle)
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return 0
+    offset = data.get("offset") if isinstance(data, dict) else None
+    if isinstance(offset, int) and not isinstance(offset, bool) and offset >= 0:
+        return offset
+    return 0
+
+
+def write_offset(path: Path, offset: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump({"offset": offset}, handle, sort_keys=True)
+        handle.write("\n")
+
+
+def read_rows_from(path: Path, offset: int) -> tuple[list[dict[str, Any]], int, str | None]:
+    try:
+        size = path.stat().st_size
+    except FileNotFoundError:
+        return [], offset, None
+    except OSError as exc:
+        return [], offset, str(exc)
+    if offset > size:
+        offset = 0
+    try:
+        with path.open("rb") as handle:
+            handle.seek(offset)
+            data = handle.read()
+            end = handle.tell()
+    except OSError as exc:
+        return [], offset, str(exc)
+    rows = []
+    for line in data.decode("utf-8", errors="replace").splitlines():
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(row, dict):
+            rows.append(row)
+    return rows, end, None
+
+
+def emit_notice(harness: str, text: str) -> None:
+    if harness in {"claude", "codex"}:
+        print(
+            json.dumps(
+                {
+                    "hookSpecificOutput": {
+                        "hookEventName": "UserPromptSubmit",
+                        "additionalContext": text,
+                    }
+                }
+            )
+        )
+    else:
+        print(json.dumps({"continue": True, "additional_context": text}))
+
+
+def run(harness: str, payload: object) -> None:
+    root = metrics_dir()
+    log = root / "runs.jsonl"
+    state = cursor_path(root, harness, session_id(payload))
+    offset = read_offset(state)
+    rows, new_offset, error = read_rows_from(log, offset)
+    if error is not None:
+        emit_notice(harness, unreadable_notice(str(log), error))
+        return
+    if new_offset != offset:
+        write_offset(state, new_offset)
+    text = notice(rows, harness)
+    if text is not None:
+        emit_notice(harness, text)
+
+
+def main(harness: str) -> None:
+    try:
+        payload = json.load(sys.stdin)
+    except Exception as exc:
+        sys.stderr.write(f"catstack-hook-error hook-health: {type(exc).__name__}: {exc}\n")
+        return
+    try:
+        run(harness, payload)
+    except Exception as exc:
+        sys.stderr.write(f"catstack-hook-error hook-health: {type(exc).__name__}: {exc}\n")
diff --git a/engine/hooks/hook-health/tests/test_detect.py b/engine/hooks/hook-health/tests/test_detect.py
new file mode 100644
index 00000000..66ded6e2
--- /dev/null
+++ b/engine/hooks/hook-health/tests/test_detect.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import os
+import sys
+import unittest
+
+HOOK_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, HOOK_DIR)
+
+import detect
+
+
+class DetectNotice(unittest.TestCase):
+    def row(self, outcome: str, hook: str = "demo", script: str = "x.py", harness: str = "claude") -> dict:
+        return {
+            "harness": harness,
+            "hook": hook,
+            "script": script,
+            "outcome": outcome,
+            "exit_code": 1,
+            "stderr_tail": "boom\nmore",
+        }
+
+    def test_fires_on_crashed_row_names_hook(self) -> None:
+        text = detect.notice([self.row("crashed")], "claude")
+        self.assertIsNotNone(text)
+        self.assertIn("1 hook run(s) failed", text)
+        self.assertIn("demo/x.py crashed (exit 1): boom", text)
+
+    def test_negative_spoke_silent_blocked_rows_return_none(self) -> None:
+        rows = [self.row("spoke"), self.row("silent"), self.row("blocked")]
+        self.assertIsNone(detect.notice(rows, "claude"))
+
+    def test_hook_health_own_crash_is_ignored(self) -> None:
+        self.assertIsNone(detect.notice([self.row("crashed", hook="hook-health")], "claude"))
+
+    def test_over_five_truncation_reports_more(self) -> None:
+        rows = [self.row("crashed", hook=f"h{i}") for i in range(7)]
+        text = detect.notice(rows, "claude")
+        self.assertIsNotNone(text)
+        self.assertIn("and 2 more", text)
+        self.assertNotIn("h6/x.py", text)
+
+    def test_unreadable_notice_names_unchecked(self) -> None:
+        text = detect.unreadable_notice("/tmp/runs.jsonl", "is a directory")
+        self.assertIn("could not read the hook metrics log /tmp/runs.jsonl", text)
+        self.assertIn("unchecked this turn", text)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/engine/hooks/hook-health/tests/test_hooks.py b/engine/hooks/hook-health/tests/test_hooks.py
new file mode 100644
index 00000000..cc8ee989
--- /dev/null
+++ b/engine/hooks/hook-health/tests/test_hooks.py
@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from datetime import datetime, timezone
+from pathlib import Path
+
+HOOK_DIR = Path(__file__).resolve().parents[1]
+
+
+class EntrypointHooks(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.home = Path(self.tmp.name) / "home"
+        self.metrics = Path(self.tmp.name) / "metrics"
+        self.metrics.mkdir(parents=True)
+        self.log = self.metrics / "runs.jsonl"
+
+    def env(self) -> dict[str, str]:
+        return {**os.environ, "HOME": str(self.home), "CATSTACK_HOOK_METRICS_DIR": str(self.metrics)}
+
+    def row(self, harness: str = "claude", hook: str = "demo") -> dict[str, object]:
+        return {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "harness": harness,
+            "hook": hook,
+            "script": "x.py",
+            "event": "UserPromptSubmit",
+            "session_id": "s1",
+            "outcome": "crashed",
+            "exit_code": 1,
+            "duration_ms": 4,
+            "stdout_bytes": 0,
+            "stderr_tail": "boom\nmore",
+        }
+
+    def write_rows(self, rows: list[dict[str, object]]) -> None:
+        with self.log.open("a", encoding="utf-8") as handle:
+            for row in rows:
+                handle.write(json.dumps(row) + "\n")
+
+    def run_hook(self, script: str, payload: dict[str, object] | None = None) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            [sys.executable, str(HOOK_DIR / script)],
+            input=json.dumps(payload or {"session_id": "s1"}),
+            capture_output=True,
+            text=True,
+            env=self.env(),
+            timeout=10,
+        )
+
+    def assert_notice_once(self, script: str, expected_shape: str) -> None:
+        first = self.run_hook(script)
+        self.assertEqual(first.returncode, 0, first.stderr)
+        self.assertEqual(first.stderr, "")
+        self.assertIn("hook-health: 1 hook run(s) failed", first.stdout)
+        data = json.loads(first.stdout)
+        dumped = json.dumps(data)
+        self.assertIn(expected_shape, dumped)
+        second = self.run_hook(script)
+        self.assertEqual(second.returncode, 0, second.stderr)
+        self.assertEqual(second.stdout, "")
+        self.assertEqual(second.stderr, "")
+
+    def test_claude_positive_notice_once(self) -> None:
+        self.write_rows([self.row("claude")])
+        self.assert_notice_once("claude_prompt_submit.py", "hookSpecificOutput")
+
+    def test_cursor_positive_notice_once(self) -> None:
+        self.write_rows([self.row("cursor")])
+        self.assert_notice_once("cursor_before_submit.py", "additional_context")
+
+    def test_codex_positive_notice_once(self) -> None:
+        self.write_rows([self.row("codex")])
+        self.assert_notice_once("codex_prompt_submit.py", "hookSpecificOutput")
+
+    def test_missing_log_prints_nothing_and_exits_zero(self) -> None:
+        result = self.run_hook("claude_prompt_submit.py")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(result.stdout, "")
+
+    def test_unreadable_log_emits_notice_and_exits_zero(self) -> None:
+        self.log.mkdir()
+        for script in ("claude_prompt_submit.py", "cursor_before_submit.py", "codex_prompt_submit.py"):
+            result = self.run_hook(script, {"session_id": f"s-{script}"})
+            self.assertEqual(result.returncode, 0, result.stderr)
+            self.assertIn("hook failures are unchecked this turn", result.stdout)
+
+    def test_malformed_payload_logs_caught_error_and_exits_zero(self) -> None:
+        result = subprocess.run(
+            [sys.executable, str(HOOK_DIR / "claude_prompt_submit.py")],
+            input="not-json",
+            capture_output=True,
+            text=True,
+            env=self.env(),
+            timeout=10,
+        )
+        self.assertEqual(result.returncode, 0)
+        self.assertEqual(result.stdout, "")
+        self.assertIn("catstack-hook-error hook-health: JSONDecodeError", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/install.sh b/install.sh
index ede21b4f..d5e2d1bb 100755
--- a/install.sh
+++ b/install.sh
@@ -232,6 +232,7 @@ link_item "history-claim-check" "$REPO_DIR/engine/hooks/history-claim-check" "$H
 link_item "external-claim-gate" "$REPO_DIR/engine/hooks/external-claim-gate" "$HOME/.claude/hooks/external-claim-gate"
 link_item "wrong-check-reflect" "$REPO_DIR/engine/hooks/wrong-check-reflect" "$HOME/.claude/hooks/wrong-check-reflect"
 link_item "llm-judge" "$REPO_DIR/engine/hooks/llm-judge" "$HOME/.claude/hooks/llm-judge"
+link_item "hook-health" "$REPO_DIR/engine/hooks/hook-health" "$HOME/.claude/hooks/hook-health"
 link_item "build-the-lever" "$REPO_DIR/engine/hooks/build-the-lever" "$HOME/.claude/hooks/build-the-lever"
 link_item "split-scope" "$REPO_DIR/engine/hooks/split-scope" "$HOME/.claude/hooks/split-scope"
 link_item "no-comments" "$REPO_DIR/engine/hooks/no-comments" "$HOME/.claude/hooks/no-comments"
@@ -275,6 +276,7 @@ link_item "auto-pr" "$REPO_DIR/engine/hooks/auto-pr" "$HOME/.cursor/hooks/auto-p
 link_item "pr-schema-gate" "$REPO_DIR/engine/hooks/pr-schema-gate" "$HOME/.cursor/hooks/pr-schema-gate"
 link_item "wrong-check-reflect" "$REPO_DIR/engine/hooks/wrong-check-reflect" "$HOME/.cursor/hooks/wrong-check-reflect"
 link_item "llm-judge" "$REPO_DIR/engine/hooks/llm-judge" "$HOME/.cursor/hooks/llm-judge"
+link_item "hook-health" "$REPO_DIR/engine/hooks/hook-health" "$HOME/.cursor/hooks/hook-health"
 link_item "build-the-lever" "$REPO_DIR/engine/hooks/build-the-lever" "$HOME/.cursor/hooks/build-the-lever"
 link_item "split-scope" "$REPO_DIR/engine/hooks/split-scope" "$HOME/.cursor/hooks/split-scope"
 link_item "repeat-error-stop" "$REPO_DIR/engine/hooks/repeat-error-stop" "$HOME/.cursor/hooks/repeat-error-stop"
@@ -289,6 +291,7 @@ link_item "auto-pr" "$REPO_DIR/engine/hooks/auto-pr" "$HOME/.codex/hooks/auto-pr
 link_item "pr-schema-gate" "$REPO_DIR/engine/hooks/pr-schema-gate" "$HOME/.codex/hooks/pr-schema-gate"
 link_item "wrong-check-reflect" "$REPO_DIR/engine/hooks/wrong-check-reflect" "$HOME/.codex/hooks/wrong-check-reflect"
 link_item "llm-judge" "$REPO_DIR/engine/hooks/llm-judge" "$HOME/.codex/hooks/llm-judge"
+link_item "hook-health" "$REPO_DIR/engine/hooks/hook-health" "$HOME/.codex/hooks/hook-health"
 link_item "build-the-lever" "$REPO_DIR/engine/hooks/build-the-lever" "$HOME/.codex/hooks/build-the-lever"
 link_item "split-scope" "$REPO_DIR/engine/hooks/split-scope" "$HOME/.codex/hooks/split-scope"
 link_item "repeat-error-stop" "$REPO_DIR/engine/hooks/repeat-error-stop" "$HOME/.codex/hooks/repeat-error-stop"
@@ -349,6 +352,7 @@ python3 "$REPO_DIR/engine/hooks/history-claim-check/install_claude_hook.py"
 python3 "$REPO_DIR/engine/hooks/external-claim-gate/install_claude_hook.py"
 python3 "$REPO_DIR/engine/hooks/wrong-check-reflect/install_claude_hook.py"
 python3 "$REPO_DIR/engine/hooks/llm-judge/install_claude_hook.py"
+python3 "$REPO_DIR/engine/hooks/hook-health/install_claude_hook.py"
 python3 "$REPO_DIR/engine/hooks/build-the-lever/install_claude_hook.py"
 python3 "$REPO_DIR/engine/hooks/split-scope/install_claude_hook.py"
 python3 "$REPO_DIR/engine/hooks/no-comments/install_claude_hook.py"
@@ -393,6 +397,7 @@ python3 "$REPO_DIR/engine/hooks/auto-pr/install_cursor_hook.py"
 python3 "$REPO_DIR/engine/hooks/pr-schema-gate/install_cursor_hook.py"
 python3 "$REPO_DIR/engine/hooks/wrong-check-reflect/install_cursor_hook.py"
 python3 "$REPO_DIR/engine/hooks/llm-judge/install_cursor_hook.py"
+python3 "$REPO_DIR/engine/hooks/hook-health/install_cursor_hook.py"
 python3 "$REPO_DIR/engine/hooks/build-the-lever/install_cursor_hook.py"
 python3 "$REPO_DIR/engine/hooks/split-scope/install_cursor_hook.py"
 python3 "$REPO_DIR/engine/hooks/repeat-error-stop/install_cursor_hook.py"
@@ -409,6 +414,7 @@ python3 "$REPO_DIR/engine/hooks/pr-schema-gate/install_codex_hook.py"
 
 echo "--- codex native scope-lock hooks (\$HOME/.codex/hooks.json) ---"
 python3 "$REPO_DIR/engine/hooks/scope-lock/install_codex_hook.py"
+python3 "$REPO_DIR/engine/hooks/hook-health/install_codex_hook.py"
 python3 "$REPO_DIR/engine/hooks/build-the-lever/install_codex_hook.py"
 python3 "$REPO_DIR/engine/hooks/split-scope/install_codex_hook.py"
 python3 "$REPO_DIR/engine/hooks/repeat-error-stop/install_codex_hook.py"
diff --git a/tests/test_install.py b/tests/test_install.py
index 3a7b1892..1459f54e 100644
--- a/tests/test_install.py
+++ b/tests/test_install.py
@@ -484,6 +484,37 @@ def test_split_scope_wired_for_claude_cursor_and_codex(self):
         ]
         self.assertTrue(any("split-scope/codex_prompt_submit.py" in command for command in codex_prompt_commands))
 
+    def test_hook_health_wired_for_claude_cursor_and_codex(self):
+        for agent_dir in (".claude", ".cursor", ".codex"):
+            target = os.path.join(self.fake_home, agent_dir, "hooks", "hook-health")
+            self.assertTrue(os.path.islink(target), target)
+            self.assertEqual(os.readlink(target), hook_src("hook-health"))
+
+        with open(os.path.join(self.fake_home, ".claude", "settings.json")) as handle:
+            settings = json.load(handle)
+        claude_prompt_commands = [
+            hook["command"]
+            for entry in settings["hooks"]["UserPromptSubmit"]
+            for hook in entry["hooks"]
+        ]
+        self.assertTrue(any("hook-health/claude_prompt_submit.py" in command for command in claude_prompt_commands))
+
+        with open(os.path.join(self.fake_home, ".cursor", "hooks.json")) as handle:
+            cursor_hooks = json.load(handle)["hooks"]
+        self.assertTrue(any(
+            "hook-health/cursor_before_submit.py" in str(entry.get("command", ""))
+            for entry in cursor_hooks["beforeSubmitPrompt"]
+        ))
+
+        with open(os.path.join(self.fake_home, ".codex", "hooks.json")) as handle:
+            codex_hooks = json.load(handle)["hooks"]
+        codex_prompt_commands = [
+            hook["command"]
+            for entry in codex_hooks["UserPromptSubmit"]
+            for hook in entry["hooks"]
+        ]
+        self.assertTrue(any("hook-health/codex_prompt_submit.py" in command for command in codex_prompt_commands))
+
     def test_llm_judge_inbox_wired_for_claude_cursor_and_codex(self):
         for agent_dir in (".claude", ".cursor", ".codex"):
             target = os.path.join(self.fake_home, agent_dir, "hooks", "llm-judge")
@@ -809,6 +840,7 @@ def test_rerun_reports_already_done_and_produces_no_duplicates(self):
 
             for hook_type, marker in (
                 ("UserPromptSubmit", "build-the-lever/claude_prompt_submit.py"),
+                ("UserPromptSubmit", "hook-health/claude_prompt_submit.py"),
                 ("UserPromptSubmit", "split-scope/claude_prompt_submit.py"),
                 ("PostToolUse", "build-the-lever/claude_posttooluse.py"),
             ):
@@ -1210,7 +1242,7 @@ def test_agent_pretooluse_hook_wired_for_claude(self):
 
 
 class TestCursorHooksDanglingLink(unittest.TestCase):
-    INSTALLERS = ("bug-complaint-leak", "build-the-lever", "split-scope", "pr-schema-gate")
+    INSTALLERS = ("bug-complaint-leak", "build-the-lever", "hook-health", "split-scope", "pr-schema-gate")
     DIU_PROMPT_START = "Find the assistant's last response in this conversation"
 
     def _seed_link(self, fake_home, target):