@event4u/agent-config 6.1.0 → 7.0.0

package/src/scripts/hooks/replay_hook.py

@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-"""Fixture-driven hook replay — read-only dispatch through the runtime.
-
-Reads a stdin payload fixture from `tests/fixtures/hooks/` (one file per
-event in `EVENT_VOCABULARY`), sets `AGENT_CONFIG_REPLAY=1`, and invokes
-the universal dispatcher with the platform / event / payload tuple. The
-replay flag tells `state_io` (and concerns that honour it) to skip every
-write under `agents/runtime/state/` so the replay never mutates real session
-state.
-
-Invocation:
-
-    python3 scripts/hooks/replay_hook.py \\
-        --platform <name> \\
-        --event <agent-config-event> \\
-        --payload tests/fixtures/hooks/<event>.json \\
-        [--native-event <native>] \\
-        [--manifest <path>] \\
-        [--json]
-
-The `--json` flag prints a structured replay summary on stdout
-(platform, event, dispatcher exit code, captured stderr lines).
-Non-zero exit is propagated from the dispatcher.
-
-Contract reference: `docs/contracts/hook-architecture-v1.md` § Replay
-mode. Roadmap step: P2.4b of `agents/roadmaps/road-to-proof-not-features.md`.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[3]
-DISPATCHER = REPO_ROOT / "src" / "scripts" / "hooks" / "dispatch_hook.py"
-DEFAULT_MANIFEST = REPO_ROOT / "src" / "scripts" / "hook_manifest.yaml"
-FIXTURE_DIR = REPO_ROOT / "tests" / "fixtures" / "hooks"
-REPLAY_ENV_VAR = "AGENT_CONFIG_REPLAY"
-
-
-def _resolve_payload(arg: str) -> Path:
-    """Accept either an absolute path, a path relative to CWD, or a bare
-    event name that resolves to `tests/fixtures/hooks/<name>.json`."""
-    candidate = Path(arg)
-    if candidate.is_file():
-        return candidate
-    bare = FIXTURE_DIR / f"{arg}.json"
-    if bare.is_file():
-        return bare
-    raise FileNotFoundError(
-        f"replay_hook: payload not found — tried '{candidate}' and '{bare}'")
-
-
-def _build_argparser() -> argparse.ArgumentParser:
-    p = argparse.ArgumentParser(description=__doc__)
-    p.add_argument("--platform", required=True,
-                   help="Platform key as declared in hook_manifest.yaml "
-                        "(augment, claude, cursor, cline, windsurf, gemini, copilot).")
-    p.add_argument("--event", required=True,
-                   help="agent-config event (see EVENT_VOCABULARY in "
-                        "src/scripts/hooks/dispatch_hook.py).")
-    p.add_argument("--payload", required=True,
-                   help="Path to a fixture JSON file, or a bare event name "
-                        "resolved under tests/fixtures/hooks/.")
-    p.add_argument("--native-event", default="",
-                   help="Optional native event name for diagnostics.")
-    p.add_argument("--manifest", default=str(DEFAULT_MANIFEST),
-                   help=f"Hook manifest path (default: {DEFAULT_MANIFEST}).")
-    p.add_argument("--json", action="store_true",
-                   help="Emit a structured summary on stdout.")
-    p.add_argument("--dry-run", action="store_true",
-                   help="Resolve concerns and print the dispatch plan; "
-                        "do not invoke concerns.")
-    return p
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = _build_argparser().parse_args(argv)
-
-    try:
-        payload_path = _resolve_payload(args.payload)
-    except FileNotFoundError as exc:
-        sys.stderr.write(f"❌  {exc}\n")
-        return 2
-
-    payload_text = payload_path.read_text(encoding="utf-8")
-    # Validate JSON early so dispatcher stderr stays focused on real
-    # concern problems. Empty / non-object payloads are still dispatched
-    # — that mirrors the platform contract (stdin can be empty).
-    try:
-        decoded = json.loads(payload_text) if payload_text.strip() else {}
-    except (ValueError, TypeError) as exc:
-        sys.stderr.write(f"❌  replay_hook: invalid JSON in {payload_path}: {exc}\n")
-        return 2
-
-    env = dict(os.environ)
-    env[REPLAY_ENV_VAR] = "1"
-
-    cmd = [sys.executable, str(DISPATCHER),
-           "--platform", args.platform,
-           "--event", args.event,
-           "--manifest", args.manifest]
-    if args.native_event:
-        cmd.extend(["--native-event", args.native_event])
-    if args.dry_run:
-        cmd.append("--dry-run")
-
-    proc = subprocess.run(
-        cmd, input=payload_text, capture_output=True, text=True, env=env,
-        check=False,
-    )
-
-    if args.json:
-        summary = {
-            "platform": args.platform,
-            "event": args.event,
-            "native_event": args.native_event or "",
-            "payload": str(payload_path.relative_to(REPO_ROOT)
-                           if str(payload_path).startswith(str(REPO_ROOT))
-                           else payload_path),
-            "session_id": decoded.get("session_id") if isinstance(decoded, dict) else None,
-            "exit_code": proc.returncode,
-            "dispatcher_stdout": (proc.stdout or "").strip(),
-            "dispatcher_stderr": (proc.stderr or "").strip(),
-            "replay_mode": True,
-        }
-        print(json.dumps(summary, indent=2))
-    else:
-        if proc.stdout:
-            sys.stdout.write(proc.stdout)
-        if proc.stderr:
-            sys.stderr.write(proc.stderr)
-        sys.stderr.write(
-            f"replay_hook: platform={args.platform} event={args.event} "
-            f"payload={payload_path.name} rc={proc.returncode} "
-            f"(AGENT_CONFIG_REPLAY=1, no writes)\n")
-    return proc.returncode
-
-
-if __name__ == "__main__":  # pragma: no cover
-    sys.exit(main())

package/src/scripts/hooks/state_io.py

@@ -1,145 +0,0 @@
-"""Concurrency-safe state writes for hook concerns.
-
-Per `docs/contracts/hook-architecture-v1.md` § Concurrency, every concern
-that writes under `agents/runtime/state/` MUST:
-
-1. Acquire `fcntl.flock(LOCK_EX)` on `agents/runtime/state/.dispatcher.lock`.
-2. Write to a sibling `<dest>.tmp.<pid>` file in the same directory.
-3. `os.replace(tmp, dest)` — POSIX-atomic on the same filesystem.
-4. Release the lock.
-
-The single shared lock is intentional: serialising state writes across
-concerns is cheaper than per-file locks, and concerns already run
-sequentially within one dispatcher invocation. Concurrent dispatcher
-invocations (e.g. two platforms firing into the same workspace) are the
-case this lock guards.
-
-Cross-platform notes
---------------------
-- `fcntl` is POSIX-only. On Windows the contract degrades gracefully:
-  the lock acquire is a no-op, atomic replace via `os.replace` still
-  holds, and torn-write risk is accepted (Windows is not a primary
-  agent-config platform — Cline tracks the upstream Windows-path issue
-  separately).
-- The lock file lives under `agents/runtime/state/` which is gitignored.
-- The lock is process-scoped, not session-scoped: each call opens,
-  locks, writes, releases, closes. No long-lived file handles.
-"""
-from __future__ import annotations
-
-import json
-import os
-from pathlib import Path
-from typing import Any
-
-try:
-    import fcntl  # type: ignore[import-not-found]
-    _HAS_FCNTL = True
-except ImportError:  # pragma: no cover — Windows
-    _HAS_FCNTL = False
-
-LOCK_BASENAME = ".dispatcher.lock"
-
-REPLAY_ENV_VAR = "AGENT_CONFIG_REPLAY"
-
-
-def is_replay_mode() -> bool:
-    """True when the caller signalled read-only fixture replay.
-
-    Concerns and the dispatcher honour the flag by skipping side
-    effects under `agents/runtime/state/` (and any other concern-owned state
-    surface). See `docs/contracts/hook-architecture-v1.md` § Replay mode.
-    """
-    return os.environ.get(REPLAY_ENV_VAR, "").strip() == "1"
-
-
-def _lock_path(state_dir: Path) -> Path:
-    return state_dir / LOCK_BASENAME
-
-
-def atomic_write_json(target: Path, payload: Any, *, indent: int = 2) -> None:
-    """Write `payload` as JSON to `target` atomically and concurrency-safely.
-
-    `target` MUST sit under an `agents/runtime/state/` directory (or any other
-    directory the caller treats as the lock scope). The lock file is
-    `<target.parent>/.dispatcher.lock`. Caller does not need to create
-    the directory in advance — this function ensures it.
-
-    Under `AGENT_CONFIG_REPLAY=1` the call is a no-op so fixture
-    replay never mutates real session state.
-    """
-    if is_replay_mode():
-        return
-    target = Path(target)
-    state_dir = target.parent
-    state_dir.mkdir(parents=True, exist_ok=True)
-    body = json.dumps(payload, indent=indent) + "\n"
-    _atomic_write_text(target, body)
-
-
-def atomic_write_text(target: Path, text: str) -> None:
-    """Write text to `target` atomically and concurrency-safely. Same
-    locking discipline as `atomic_write_json` — useful for non-JSON
-    state payloads (chat-history transcript, status text).
-
-    Under `AGENT_CONFIG_REPLAY=1` the call is a no-op."""
-    if is_replay_mode():
-        return
-    target = Path(target)
-    state_dir = target.parent
-    state_dir.mkdir(parents=True, exist_ok=True)
-    _atomic_write_text(target, text)
-
-
-def _atomic_write_text(target: Path, text: str) -> None:
-    tmp = target.with_suffix(target.suffix + f".tmp.{os.getpid()}")
-    lock_path = _lock_path(target.parent)
-    # `os.O_CREAT | os.O_RDWR` — we don't truncate the lock file, just
-    # need an fd to flock. Mode 0o644 is fine; the file holds no data.
-    if _HAS_FCNTL:
-        fd = os.open(str(lock_path), os.O_CREAT | os.O_RDWR, 0o644)
-        try:
-            fcntl.flock(fd, fcntl.LOCK_EX)
-            try:
-                tmp.write_text(text, encoding="utf-8")
-                os.replace(str(tmp), str(target))
-            finally:
-                fcntl.flock(fd, fcntl.LOCK_UN)
-        finally:
-            os.close(fd)
-    else:  # pragma: no cover — Windows fallback, no flock
-        tmp.write_text(text, encoding="utf-8")
-        os.replace(str(tmp), str(target))
-
-
-FEEDBACK_DIRNAME = ".dispatcher"
-
-
-def feedback_dir(state_root: Path, session_id: str) -> Path:
-    """Return the per-session feedback directory under state_root.
-
-    Layout:
-        <state_root>/.dispatcher/<session_id>/
-            <concern>.json     — one per concern that ran
-            summary.json       — rollup written by the dispatcher
-
-    Per Council Round 2 (2026-05-04): exit-code reduction collapses
-    multiple concern signals into a single platform-native code; the
-    feedback dir surfaces the per-concern detail to humans and
-    `task hooks-status` without re-routing control flow.
-    """
-    safe_session = session_id or "unknown-session"
-    # Defence-in-depth: refuse path traversal in session_id.
-    safe_session = safe_session.replace("/", "_").replace("\\", "_").replace("..", "_")
-    return Path(state_root) / FEEDBACK_DIRNAME / safe_session
-
-
-__all__ = [
-    "atomic_write_json",
-    "atomic_write_text",
-    "feedback_dir",
-    "is_replay_mode",
-    "LOCK_BASENAME",
-    "FEEDBACK_DIRNAME",
-    "REPLAY_ENV_VAR",
-]

package/src/scripts/hooks_doctor.py

@@ -1,223 +0,0 @@
-#!/usr/bin/env python3
-"""Hook doctor — read-only diagnostic over the hook runtime.
-
-Wraps `scripts/hooks_status.py` (bridge presence + manifest bindings)
-and adds three diagnostics the bare status table does not surface:
-
-  * **Concerns** — every concern declared in the manifest, its
-    `fail_closed` posture, the on-disk script path, and a one-line
-    file-exists check.
-  * **Trampolines** — per-platform shell trampoline expected under
-    `scripts/hooks/<platform>-dispatcher.sh`; flags any platform that
-    has manifest bindings but no trampoline on disk.
-  * **Last feedback** — for each concern, the most-recent dispatcher
-    feedback file under `agents/runtime/state/.dispatcher/*/<concern>.json`,
-    plus the per-rule state file under `agents/runtime/state/<concern>.json`
-    when one exists.
-
-This is a **read-only** report. It never installs, modifies, or runs
-anything — same contract as `hooks_status.py`. CI uses `--strict` to
-turn missing bindings / trampolines into a non-zero exit.
-
-Schema: docs/contracts/hook-architecture-v1.md.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-sys.path.insert(0, str(REPO_ROOT / "src" / "scripts"))
-sys.path.insert(0, str(REPO_ROOT / "src" / "scripts" / "hooks"))
-
-import dispatch_hook  # noqa: E402
-import hooks_status  # noqa: E402
-
-TRAMPOLINE_DIR = REPO_ROOT / "src" / "scripts" / "hooks"
-STATE_DIR_DEFAULT = "agents/runtime/state"
-
-# Platforms whose bridge file (settings.json) invokes the universal
-# dispatcher directly — no shell trampoline required. Excluded from the
-# "missing trampoline" check.
-NATIVE_DISPATCH_PLATFORMS = frozenset({"claude"})
-
-
-def _trampoline_for(platform: str) -> Path:
-    return TRAMPOLINE_DIR / f"{platform}-dispatcher.sh"
-
-
-def _concern_state_file(state_dir: Path, concern: str) -> Path | None:
-    target = state_dir / f"{concern}.json"
-    return target if target.is_file() else None
-
-
-def _latest_feedback(state_dir: Path, concern: str) -> Path | None:
-    """Return the most-recent dispatcher feedback file for the concern,
-    walking `agents/runtime/state/.dispatcher/<session>/<concern>.json`."""
-    dispatcher_dir = state_dir / ".dispatcher"
-    if not dispatcher_dir.is_dir():
-        return None
-    candidates = sorted(
-        dispatcher_dir.glob(f"*/{concern}.json"),
-        key=lambda p: p.stat().st_mtime,
-        reverse=True,
-    )
-    return candidates[0] if candidates else None
-
-
-def _rel(path: Path | None, root: Path) -> str | None:
-    if path is None:
-        return None
-    try:
-        return str(path.resolve().relative_to(root.resolve()))
-    except ValueError:
-        return str(path)
-
-
-def collect(project_root: Path, manifest: dict,
-            state_dir_rel: str = STATE_DIR_DEFAULT) -> dict:
-    """Build the doctor payload — JSON-serialisable."""
-    matrix = hooks_status.collect(project_root, manifest)
-    state_dir = project_root / state_dir_rel
-
-    concerns_def = manifest.get("concerns") or {}
-    concerns: list[dict] = []
-    for name, spec in sorted(concerns_def.items()):
-        script_rel = (spec or {}).get("script") or ""
-        script_path = REPO_ROOT / script_rel if script_rel else None
-        state_file = _concern_state_file(state_dir, name)
-        last_feedback = _latest_feedback(state_dir, name)
-        concerns.append({
-            "concern": name,
-            "fail_closed": bool((spec or {}).get("fail_closed", False)),
-            "script": script_rel or None,
-            "script_present": bool(script_path and script_path.is_file()),
-            "state_file": _rel(state_file, project_root),
-            "last_feedback": _rel(last_feedback, project_root),
-        })
-
-    trampolines: list[dict] = []
-    for row in matrix["platforms"]:
-        platform = row["platform"]
-        needs_trampoline = bool(row["bindings"]) and platform not in NATIVE_DISPATCH_PLATFORMS
-        tpath = _trampoline_for(platform)
-        trampolines.append({
-            "platform": platform,
-            "expected": _rel(tpath, REPO_ROOT),
-            "present": tpath.is_file(),
-            "required": needs_trampoline,
-            "missing": needs_trampoline and not tpath.is_file(),
-        })
-
-    # Phase 1 of road-to-hooks-actually-fire-in-consumers: surface
-    # the dispatch-issues log so users see hooks that tried and failed.
-    state_root = REPO_ROOT / STATE_DIR_DEFAULT
-    issues: list[dict] = []
-    try:
-        sys.path.insert(0, str(REPO_ROOT / "src" / "scripts" / "hooks"))
-        from dispatch_issues import read_dispatch_issues  # noqa: PLC0415
-        issues = read_dispatch_issues(REPO_ROOT)[-20:]  # last 20
-    except (ImportError, OSError):
-        issues = []
-
-    return {
-        "schema_version": 1,
-        "platforms": matrix["platforms"],
-        "concerns": concerns,
-        "trampolines": trampolines,
-        "dispatch_issues": issues,
-    }
-
-
-def _render_table(payload: dict) -> str:
-    lines: list[str] = []
-    # Phase 1 CTA — surfaces at the TOP when issues exist, so a user
-    # reading the report can't miss it.
-    if payload.get("dispatch_issues"):
-        n = len(payload["dispatch_issues"])
-        lines.append(
-            f"⚠️  Hooks tried to fire but couldn't ({n} entry"
-            f"{'ies' if n != 1 else 'y'} in dispatch-issues.jsonl) — "
-            "run `./agent-config hooks:install --claude --regen` "
-            "(or follow the per-concern hints below)"
-        )
-        lines.append("")
-    lines.append(hooks_status._render_table(payload))
-    lines.append("")
-    lines.append("Concerns")
-    lines.append("-" * 60)
-    for c in payload["concerns"]:
-        posture = "fail-closed" if c["fail_closed"] else "fail-open"
-        script_mark = "✅ " if c["script_present"] else "❌ "
-        lines.append(f"{script_mark}{c['concern']:<22} {posture:<11} {c['script'] or '(no script)'}")
-        if c["state_file"]:
-            lines.append(f"    state:    {c['state_file']}")
-        if c["last_feedback"]:
-            lines.append(f"    feedback: {c['last_feedback']}")
-    lines.append("")
-    lines.append("Trampolines")
-    lines.append("-" * 60)
-    for t in payload["trampolines"]:
-        marker = "❌ " if t["missing"] else ("·  " if not t["required"] else "✅ ")
-        suffix = "" if t["required"] else "  (not required)"
-        lines.append(f"{marker}{t['platform']:<9} {t['expected']}{suffix}")
-    # Dispatch-issues detail — last 20 grouped by concern.
-    if payload.get("dispatch_issues"):
-        lines.append("")
-        lines.append("Dispatch issues (last 20)")
-        lines.append("-" * 60)
-        grouped: dict[str, list[dict]] = {}
-        for entry in payload["dispatch_issues"]:
-            grouped.setdefault(entry.get("hook", "?"), []).append(entry)
-        for hook, entries in sorted(grouped.items()):
-            lines.append(f"⚠️  {hook}: {len(entries)} issue(s)")
-            # Show the most recent reason + resolution per concern.
-            latest = entries[-1]
-            lines.append(f"    {latest.get('issue')}: {latest.get('detail')}")
-            lines.append(f"    fix → {latest.get('resolution')}")
-    return "\n".join(lines)
-
-
-def _final_exit_code(payload: dict, strict: bool) -> int:
-    if not strict:
-        return 0
-    rc = hooks_status._final_exit_code(payload, strict)
-    if rc:
-        return rc
-    if any(t["missing"] for t in payload["trampolines"]):
-        return 1
-    if any(not c["script_present"] for c in payload["concerns"]):
-        return 1
-    return 0
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--format", choices=["table", "json"], default="table")
-    parser.add_argument("--project-root", default=".",
-                        help="Project root to inspect (default: cwd)")
-    parser.add_argument("--manifest", default=str(dispatch_hook.MANIFEST_PATH))
-    parser.add_argument("--strict", action="store_true",
-                        help="Exit non-zero on missing bridges, trampolines, "
-                             "or concern scripts (CI-friendly).")
-    args = parser.parse_args(argv)
-
-    manifest_path = Path(args.manifest)
-    if not manifest_path.exists():
-        sys.stderr.write(f"hooks_doctor: manifest missing at {manifest_path}\n")
-        return 2
-    manifest = dispatch_hook._load_yaml(manifest_path)
-    project_root = Path(args.project_root).resolve()
-    payload = collect(project_root, manifest)
-
-    if args.format == "json":
-        print(json.dumps(payload, indent=2, sort_keys=True))
-    else:
-        print(_render_table(payload))
-    return _final_exit_code(payload, args.strict)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/scripts/hooks_status.py

@@ -1,157 +0,0 @@
-#!/usr/bin/env python3
-"""Print the runtime hook matrix per `docs/contracts/hook-architecture-v1.md`.
-
-For each platform in `scripts/hook_manifest.yaml`, prints whether the
-project-scope bridge files exist on disk, which (event → concerns)
-bindings the manifest declares, and a one-line install hint when the
-bridge is missing. Copilot has no native hook surface — its row carries
-the `degraded: rule-only fallback` marker per Phase 7.12 / Round 2.
-
-This is a **read-only** report. It never installs, modifies, or fires
-anything; that is the contract callers depend on (`task hooks-status`,
-post-install smoke, CI).
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-sys.path.insert(0, str(REPO_ROOT / "src" / "scripts" / "hooks"))
-
-import dispatch_hook  # noqa: E402  — reuse the manifest loader
-
-# (label, project-relative bridge path, install hint).
-# Path may be a directory (cline) — existence => any file inside.
-#
-# Cowork has no project-scope bridge path: the Claude desktop app's
-# local-agent-mode runtime is upstream-blocked from reading any of
-# Claude Code's three settings sources (anthropics/claude-code#40495,
-# #27398). We register cowork here so the manifest's `cowork:`
-# bindings are surfaced in the status report, but the empty bridge
-# path resolves to status="n/a" — strict mode does not fail on
-# n/a (see _final_exit_code), matching Copilot's no-bridge posture.
-# Once upstream lands the fix and a stable settings location is
-# documented, swap the empty path here for that location.
-PLATFORM_BRIDGES: dict[str, tuple[str, str]] = {
-    "augment":  (".augment/settings.json",      "src/scripts/install.py"),
-    "claude":   (".claude/settings.json",       "src/scripts/install.py"),
-    "cowork":   ("",                            "upstream-blocked: anthropics/claude-code#40495 + #27398 (settings.json ignored in Cowork sandbox)"),
-    "cursor":   (".cursor/hooks.json",          "src/scripts/install.py"),
-    "cline":    (".clinerules/hooks",           "src/scripts/install.py"),
-    "windsurf": (".windsurf/hooks.json",        "src/scripts/install.py"),
-    "gemini":   (".gemini/settings.json",       "src/scripts/install.py"),
-    "copilot":  ("",                            "rule-only fallback (no hook surface)"),
-}
-
-
-def _bridge_status(project_root: Path, rel_path: str) -> str:
-    if not rel_path:
-        return "n/a"
-    target = project_root / rel_path
-    if target.is_dir():
-        return "installed" if any(target.iterdir()) else "empty"
-    return "installed" if target.is_file() else "missing"
-
-
-def collect(project_root: Path, manifest: dict) -> dict:
-    """Build the runtime matrix as a plain dict — JSON-serialisable."""
-    platforms = manifest.get("platforms") or {}
-    rows: list[dict] = []
-    for platform in PLATFORM_BRIDGES:
-        rel, hint = PLATFORM_BRIDGES[platform]
-        block = platforms.get(platform) or {}
-        fallback_only = bool(block.get("fallback_only"))
-        bindings = (
-            {} if fallback_only
-            else {ev: list(c) for ev, c in block.items()
-                  if isinstance(c, list)}
-        )
-        status = "degraded" if fallback_only else _bridge_status(project_root, rel)
-        rows.append({
-            "platform": platform,
-            "status": status,
-            "bridge_path": rel or None,
-            "fallback_only": fallback_only,
-            "bindings": bindings,
-            "hint": hint if status in {"missing", "empty", "degraded", "n/a"} else None,
-        })
-    return {"schema_version": 1, "platforms": rows}
-
-
-def _render_table(matrix: dict) -> str:
-    lines: list[str] = []
-    lines.append("agent-config hook matrix")
-    lines.append("=" * 60)
-    for row in matrix["platforms"]:
-        marker = {
-            "installed": "✅ ",
-            "missing":   "❌ ",
-            "empty":     "⚠️  ",
-            "degraded":  "⚠️  ",
-            "n/a":       "·  ",
-        }.get(row["status"], "?  ")
-        head = f"{marker}{row['platform']:<9} {row['status']}"
-        if row["bridge_path"]:
-            head += f"  ({row['bridge_path']})"
-        lines.append(head)
-        if row["fallback_only"]:
-            lines.append("    degraded: rule-only fallback "
-                         "— hooks are not auto-firing on this platform.")
-            continue
-        if not row["bindings"]:
-            lines.append("    (no bindings declared in manifest)")
-            continue
-        for event in sorted(row["bindings"]):
-            concerns = ", ".join(row["bindings"][event]) or "—"
-            lines.append(f"    {event:<22} → {concerns}")
-        if row["hint"]:
-            lines.append(f"    hint: run {row['hint']}")
-    lines.append("")
-    lines.append("Source of truth: scripts/hook_manifest.yaml")
-    lines.append("Contract: docs/contracts/hook-architecture-v1.md")
-    return "\n".join(lines)
-
-
-def _final_exit_code(matrix: dict, strict: bool) -> int:
-    if not strict:
-        return 0
-    # Strict mode: any platform with declared bindings whose bridge is
-    # missing is a CI failure. `degraded`/`n/a` never fail (Copilot is
-    # an explicit no-hook platform; n/a means no bridge expected).
-    for row in matrix["platforms"]:
-        if row["status"] == "missing" and row["bindings"]:
-            return 1
-    return 0
-
-
-def main(argv: list[str] | None = None) -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--format", choices=["table", "json"], default="table")
-    parser.add_argument("--project-root", default=".",
-                        help="Project root to inspect (default: cwd)")
-    parser.add_argument("--manifest", default=str(dispatch_hook.MANIFEST_PATH))
-    parser.add_argument("--strict", action="store_true",
-                        help="Exit non-zero if any platform with bindings is "
-                             "missing its bridge (CI-friendly).")
-    args = parser.parse_args(argv)
-
-    manifest_path = Path(args.manifest)
-    if not manifest_path.exists():
-        sys.stderr.write(f"hooks_status: manifest missing at {manifest_path}\n")
-        return 2
-    manifest = dispatch_hook._load_yaml(manifest_path)
-    project_root = Path(args.project_root).resolve()
-    matrix = collect(project_root, manifest)
-
-    if args.format == "json":
-        print(json.dumps(matrix, indent=2, sort_keys=True))
-    else:
-        print(_render_table(matrix))
-    return _final_exit_code(matrix, args.strict)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())