guard-cli 0.1.0__tar.gz → 0.1.1__tar.gz

{guard_cli-0.1.0 → guard_cli-0.1.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: guard-cli
-Version: 0.1.0
+Version: 0.1.1
 Summary: Graph-powered safety layer for AI coding agents built on FalkorDB
-License: MIT
+License-Expression: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -193,6 +193,22 @@ Initializes Guard in a repository, detects backends, and configures integrations
 guard init [--backend server|docker|embedded] [--skip-coverage]
 ```
 
+#### Backends & Platform Support
+
+Guard supports three FalkorDB backend topologies:
+1. **Server (`--backend server`)**: Connects to an existing FalkorDB instance (default: `localhost:6379`). Works across all platforms.
+2. **Docker (`--backend docker`)**: Automatically launches and manages a dedicated `guard-falkordb` container on port 6390. Works on any platform with Docker installed.
+3. **Embedded (`--backend embedded`)**: Zero-configuration, in-process FalkorDBLite instance.
+   - **Supported OS & Platform Requirements**:
+     - **Python**: 3.12 or newer
+     - **Linux**: `glibc` 2.39 or newer (e.g., Ubuntu 24.04+, Fedora 40+)
+     - **macOS**: macOS 15 (Sequoia) or newer
+   - **Platform Fallback**: On unsupported platforms (such as Linux with glibc < 2.39 or macOS < 15), Guard prints a clear message:
+     ```text
+     no embedded build for this platform, use Docker or a server
+     ```
+     and guides you to use `--backend docker` or `--backend server` instead of failing with a build error.
+
 ### `guard doctor`
 Verifies system health, backend reachability, graph counts, and settings:
 ```bash

{guard_cli-0.1.0 → guard_cli-0.1.1}/README.md

@@ -172,6 +172,22 @@ Initializes Guard in a repository, detects backends, and configures integrations
 guard init [--backend server|docker|embedded] [--skip-coverage]
 ```
 
+#### Backends & Platform Support
+
+Guard supports three FalkorDB backend topologies:
+1. **Server (`--backend server`)**: Connects to an existing FalkorDB instance (default: `localhost:6379`). Works across all platforms.
+2. **Docker (`--backend docker`)**: Automatically launches and manages a dedicated `guard-falkordb` container on port 6390. Works on any platform with Docker installed.
+3. **Embedded (`--backend embedded`)**: Zero-configuration, in-process FalkorDBLite instance.
+   - **Supported OS & Platform Requirements**:
+     - **Python**: 3.12 or newer
+     - **Linux**: `glibc` 2.39 or newer (e.g., Ubuntu 24.04+, Fedora 40+)
+     - **macOS**: macOS 15 (Sequoia) or newer
+   - **Platform Fallback**: On unsupported platforms (such as Linux with glibc < 2.39 or macOS < 15), Guard prints a clear message:
+     ```text
+     no embedded build for this platform, use Docker or a server
+     ```
+     and guides you to use `--backend docker` or `--backend server` instead of failing with a build error.
+
 ### `guard doctor`
 Verifies system health, backend reachability, graph counts, and settings:
 ```bash

guard_cli-0.1.1/guard_cli/__init__.py

@@ -0,0 +1,7 @@
+"""Guard: Graph-powered safety layer for AI coding agents."""
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("guard-cli")
+except PackageNotFoundError:
+    __version__ = "0.1.1"

{guard_cli-0.1.0/guard → guard_cli-0.1.1/guard_cli}/agent_integration.py

@@ -14,7 +14,7 @@ import subprocess
 from pathlib import Path
 from typing import Any
 
-from guard.thin_slice import guard_check
+from guard_cli.thin_slice import guard_check
 
 REPO_ROOT = Path("target_repos/flask").resolve()
 

{guard_cli-0.1.0/guard → guard_cli-0.1.1/guard_cli}/api.py

@@ -19,17 +19,17 @@ import subprocess
 from pathlib import Path
 from typing import Any
 
-from guard import db
-from guard import feedback
-from guard.events import log_event
-from guard.thin_slice import (
+from guard_cli import db
+from guard_cli import feedback
+from guard_cli.events import log_event
+from guard_cli.thin_slice import (
     guard_check,
     parse_unified_diff,
     resolve_changed_functions,
     thin_slice_decision,
     CheckResult,
 )
-from guard.agent_integration import (
+from guard_cli.agent_integration import (
     REPO_ROOT,
     apply_patch,
     reset_repo,
@@ -91,6 +91,7 @@ def check(
     strict: bool = False,
     no_confidence_filter: bool = False,
     no_dynamic_widening: bool = False,
+    baseline_sha: str | None = None,
 ) -> dict[str, Any]:
     """Evaluates proposed changes and returns test selection decision.
     
@@ -107,6 +108,7 @@ def check(
             graph_name=graph_name,
             no_confidence_filter=no_confidence_filter,
             no_dynamic_widening=no_dynamic_widening,
+            baseline_sha=baseline_sha,
         )
 
         is_fallback = res.is_fallback
@@ -175,6 +177,7 @@ def run(
     graph_name: str = "guard",
     strict: bool = False,
     session_id: str | None = None,
+    baseline_sha: str | None = None,
 ) -> tuple[dict[str, Any], int]:
     """Runs Guard check and executes the selected tests.
     
@@ -192,6 +195,7 @@ def run(
             repo_path=repo,
             graph_name=graph_name,
             strict=strict,
+            baseline_sha=baseline_sha,
         )
     except Exception as exc:
         if strict:
@@ -271,16 +275,18 @@ def run(
         py_bin = sys.executable
         if repo:
             try:
-                from guard.init_cmd import find_test_environment
+                from guard_cli.init_cmd import find_test_environment
                 py_bin = str(find_test_environment(repo))
             except Exception:
                 pass
 
-        # 3. Execute pytest (180s timeout for worst-case run-all test suites)
+        # 3. Execute pytest with configurable timeout
+        from guard_cli.hook import get_hook_timeout
+        timeout = get_hook_timeout(repo)
         cmd = [py_bin, "-m", "pytest", "-q", "--tb=short"] + tests_to_run
         start = time.time()
         try:
-            proc = subprocess.run(cmd, cwd=str(repo), capture_output=True, text=True, timeout=180)
+            proc = subprocess.run(cmd, cwd=str(repo), capture_output=True, text=True, timeout=timeout)
             duration_s = round(time.time() - start, 3)
             passed = (proc.returncode == 0)
             failures = _extract_failures(proc.stdout, proc.stderr)
@@ -289,9 +295,20 @@ def run(
         except subprocess.TimeoutExpired:
             duration_s = round(time.time() - start, 3)
             passed = False
-            failures = ["test_suite_timeout_expired_180s"]
-            summary_line = f"Test execution timed out after {duration_s:.1f}s."
+            failures = [f"test_suite_timeout_expired_{timeout}s"]
+            summary_line = f"Test execution timed out after {duration_s:.1f}s (timeout: {timeout}s)."
             proc_exit_code = 124
+            log_event(
+                event="timeout",
+                session_id=session_id,
+                repo_path=repo,
+                details={
+                    "timeout_s": timeout,
+                    "duration_s": duration_s,
+                    "tests_run": tests_to_run,
+                    "policy": check_dict.get("policy", "subset"),
+                },
+            )
 
         report = {
             "version": SCHEMA_VERSION,

{guard_cli-0.1.0/guard → guard_cli-0.1.1/guard_cli}/backend.py

@@ -338,23 +338,64 @@ class DockerBackend(GraphBackend):
         self._client = None
 
 
+def check_embedded_platform_support() -> tuple[bool, str]:
+    """Checks whether the current operating system and C library satisfy FalkorDBLite requirements.
+    
+    Requirements:
+    - Python 3.12+
+    - macOS 15+ (Sequoia or newer)
+    - Linux with glibc >= 2.39
+    """
+    if sys.platform not in ("darwin", "linux") and not sys.platform.startswith("linux"):
+        return False, (
+            f"Embedded backend (FalkorDBLite) is not supported on platform '{sys.platform}'. "
+            f"no embedded build for this platform, use Docker or a server"
+        )
+
+    if sys.version_info < (3, 12):
+        return False, (
+            f"Embedded backend (FalkorDBLite) requires Python 3.12 or newer. "
+            f"Current interpreter is Python {sys.version.split()[0]}. "
+            f"no embedded build for this platform, use Docker or a server"
+        )
+
+    if sys.platform == "darwin":
+        import platform
+        mac_ver = platform.mac_ver()[0]
+        if mac_ver:
+            try:
+                major = int(mac_ver.split(".")[0])
+                if major < 15:
+                    return False, (
+                        f"Embedded backend (FalkorDBLite) requires macOS 15 or newer (current: macOS {mac_ver}). "
+                        f"no embedded build for this platform, use Docker or a server"
+                    )
+            except (ValueError, IndexError):
+                pass
+    elif sys.platform.startswith("linux"):
+        import platform
+        libc_name, libc_ver = platform.libc_ver()
+        if libc_name == "glibc" and libc_ver:
+            try:
+                parts = [int(p) for p in libc_ver.split(".")[:2]]
+                if tuple(parts) < (2, 39):
+                    return False, (
+                        f"Embedded backend (FalkorDBLite) requires glibc 2.39 or newer (current: {libc_name} {libc_ver}). "
+                        f"no embedded build for this platform, use Docker or a server"
+                    )
+            except (ValueError, IndexError):
+                pass
+
+    return True, ""
+
+
 class EmbeddedBackend(GraphBackend):
-    """Manages an embedded FalkorDBLite instance (Python 3.12+)."""
+    """Manages an embedded FalkorDBLite instance (Python 3.12+ on supported platforms)."""
 
     def __init__(self, data_path: str | Path | None = None):
-        if sys.platform not in ("darwin", "linux") and not sys.platform.startswith("linux"):
-            raise RuntimeError(
-                f"Embedded backend (FalkorDBLite) is not supported on platform '{sys.platform}'. "
-                f"FalkorDBLite only supports Linux and macOS. "
-                f"Please use Docker backend ('guard init --backend docker') or Server backend ('guard init --backend server')."
-            )
-
-        if sys.version_info < (3, 12):
-            raise RuntimeError(
-                f"Embedded backend (FalkorDBLite) requires Python 3.12 or newer. "
-                f"Current interpreter is Python {sys.version.split()[0]}. "
-                f"Try: uv tool install --python 3.12 guard-cli, or use Docker/Server backend."
-            )
+        ok, msg = check_embedded_platform_support()
+        if not ok:
+            raise RuntimeError(msg)
 
         if data_path is None:
             base_dir = Path.home() / ".guard" / "data"
@@ -372,18 +413,36 @@ class EmbeddedBackend(GraphBackend):
 
     def connect(self) -> Any:
         if self._client is None:
-            # Check import paths (redislite vs falkordblite)
+            ok, msg = check_embedded_platform_support()
+            if not ok:
+                raise RuntimeError(msg)
             try:
                 from redislite import FalkorDB
-            except ImportError:
+            except (ImportError, OSError) as err:
                 try:
                     from falkordblite import FalkorDB  # type: ignore
-                except ImportError as err:
-                    raise ImportError(
-                        "falkordblite is not installed. Install with: pip install 'guard-cli[embedded]'"
-                    ) from err
+                except (ImportError, OSError) as inner_err:
+                    err_msg = f"{inner_err} {err}"
+                    if any(term in err_msg for term in ("GLIBC", "version", "symbol", "dlopen", "image not found")):
+                        raise RuntimeError(
+                            f"Failed importing embedded FalkorDB: {inner_err}. "
+                            f"no embedded build for this platform, use Docker or a server"
+                        ) from inner_err
+                    raise RuntimeError(
+                        f"falkordblite is not installed or not supported: {inner_err}. "
+                        f"no embedded build for this platform, use Docker or a server"
+                    ) from inner_err
 
-            self._client = FalkorDB(dbfilename=str(self.db_path))
+            try:
+                self._client = FalkorDB(dbfilename=str(self.db_path))
+            except (ImportError, OSError, Exception) as run_err:
+                err_msg = str(run_err)
+                if any(term in err_msg for term in ("GLIBC", "version", "symbol", "dlopen", "image not found")):
+                    raise RuntimeError(
+                        f"Failed starting embedded FalkorDB: {run_err}. "
+                        f"no embedded build for this platform, use Docker or a server"
+                    ) from run_err
+                raise
         return self._client
 
     def is_healthy(self) -> bool:

{guard_cli-0.1.0/guard → guard_cli-0.1.1/guard_cli}/cli.py

@@ -16,7 +16,7 @@ import argparse
 import json
 import sys
 
-from guard.ingest.static import analyze_repo
+from guard_cli.ingest.static import analyze_repo
 
 
 def cmd_ingest_static(args) -> int:
@@ -26,7 +26,7 @@ def cmd_ingest_static(args) -> int:
         print("parse error:", err, file=sys.stderr)
     if args.dry_run:
         return 0
-    from guard import db
+    from guard_cli import db
 
     g = db.get_graph(args.graph)
     db.reset_graph(g)
@@ -38,7 +38,7 @@ def cmd_ingest_static(args) -> int:
 
 
 def cmd_callers(args) -> int:
-    from guard import api
+    from guard_cli import api
 
     hops = int(args.hops)
     callers = api.callers(
@@ -54,7 +54,7 @@ def cmd_callers(args) -> int:
 
 
 def cmd_stats(args) -> int:
-    from guard import db
+    from guard_cli import db
 
     g = db.get_graph(args.graph)
     counts = db.get_schema_counts(g)
@@ -69,7 +69,7 @@ def cmd_stats(args) -> int:
 
 
 def cmd_covering_tests(args) -> int:
-    from guard import api
+    from guard_cli import api
 
     tests = api.covering_tests(
         args.function,
@@ -83,7 +83,7 @@ def cmd_covering_tests(args) -> int:
 
 
 def cmd_ingest_coverage(args) -> int:
-    from guard.ingest.coverage import ingest_coverage
+    from guard_cli.ingest.coverage import ingest_coverage
 
     res = ingest_coverage(
         repo_path=args.repo,
@@ -96,7 +96,7 @@ def cmd_ingest_coverage(args) -> int:
 
 
 def cmd_check(args) -> int:
-    from guard import api
+    from guard_cli import api
 
     res = api.check(
         diff_file=args.diff,
@@ -120,7 +120,7 @@ def cmd_check(args) -> int:
 
 
 def cmd_feedback(args) -> int:
-    from guard import api
+    from guard_cli import api
 
     res = api.report_miss(
         function_id=args.function,
@@ -138,7 +138,7 @@ def cmd_feedback(args) -> int:
 
 
 def cmd_run(args) -> int:
-    from guard import api
+    from guard_cli import api
 
     report, exit_code = api.run(
         diff_file=args.diff,
@@ -164,7 +164,7 @@ def cmd_run(args) -> int:
 
 
 def cmd_hook_stop(args) -> int:
-    from guard.hook import run_stop_hook
+    from guard_cli.hook import run_stop_hook
     return run_stop_hook(
         repo_override=args.repo,
         strict=getattr(args, "strict", False),
@@ -172,41 +172,41 @@ def cmd_hook_stop(args) -> int:
 
 
 def cmd_hook_install(args) -> int:
-    from guard.integrations import claude
+    from guard_cli.integrations import claude
     ok, msg = claude.install(repo_path=args.repo, shared=args.shared)
     print(msg)
     return 0 if ok else 1
 
 
 def cmd_hook_uninstall(args) -> int:
-    from guard.integrations import claude
+    from guard_cli.integrations import claude
     ok, msg = claude.uninstall(repo_path=args.repo, shared=args.shared)
     print(msg)
     return 0 if ok else 1
 
 
 def cmd_hook_status(args) -> int:
-    from guard.integrations import claude
+    from guard_cli.integrations import claude
     stat = claude.status(repo_path=args.repo, shared=args.shared)
     print(json.dumps(stat, indent=2))
     return 0
 
 
 def cmd_init(args) -> int:
-    from guard.init_cmd import run_init
+    from guard_cli.init_cmd import run_init
 
     return run_init(
         repo_path=getattr(args, "repo", None),
         backend_preference=getattr(args, "backend", None),
         skip_coverage=getattr(args, "skip_coverage", False),
         auto_yes=getattr(args, "yes", False),
-        agents=getattr(args, "agents", "claude,cursor,codex"),
+        agents=getattr(args, "agents", "claude,cursor,codex,antigravity"),
         runs=getattr(args, "runs", None),
     )
 
 
 def cmd_doctor(args) -> int:
-    from guard.doctor_cmd import run_doctor
+    from guard_cli.doctor_cmd import run_doctor
 
     return run_doctor(
         repo_path=getattr(args, "repo", None),
@@ -216,10 +216,10 @@ def cmd_doctor(args) -> int:
 
 
 def main(argv=None) -> int:
-    import guard
+    import guard_cli
 
     p = argparse.ArgumentParser(prog="guard")
-    p.add_argument("-v", "--version", action="version", version=f"guard {guard.__version__}")
+    p.add_argument("-v", "--version", action="version", version=f"guard {guard_cli.__version__}")
     p.add_argument("--graph", default="guard")
     sub = p.add_subparsers(dest="cmd", required=True)
 
@@ -228,7 +228,7 @@ def main(argv=None) -> int:
     ini.add_argument("--backend", choices=["server", "docker", "embedded"], default=None, help="database backend")
     ini.add_argument("--skip-coverage", action="store_true", help="skip per-test coverage ingestion")
     ini.add_argument("-y", "--yes", action="store_true", help="non-interactive mode accepting all defaults")
-    ini.add_argument("--agents", default="claude,cursor,codex", help="comma-separated agents to configure")
+    ini.add_argument("--agents", default="claude,cursor,codex,antigravity", help="comma-separated agents to configure")
     ini.add_argument("--runs", type=int, default=None, help="number of baseline test runs (1 or 3)")
     ini.set_defaults(fn=cmd_init)
 

{guard_cli-0.1.0/guard → guard_cli-0.1.1/guard_cli}/db.py

@@ -11,6 +11,7 @@ INDEXES = [
     "CREATE INDEX FOR (t:Test) ON (t.id)",
     "CREATE INDEX FOR (x:File) ON (x.path)",
     "CREATE INDEX FOR (r:Run) ON (r.id)",
+    "CREATE INDEX FOR (m:GuardMeta) ON (m.id)",
 ]
 
 
@@ -28,7 +29,7 @@ def get_backend(repo_path: Any = None) -> Any:
     global _active_backend
     if _active_backend is not None:
         return _active_backend
-    from guard.backend import resolve_backend, ServerBackend
+    from guard_cli.backend import resolve_backend, ServerBackend
 
     if "FALKORDB_HOST" in os.environ or "FALKORDB_PORT" in os.environ:
         host = os.getenv("FALKORDB_HOST", "localhost")
@@ -132,6 +133,7 @@ def write_static(g, result, commit_sha: str | None = None) -> None:
                    e.last_verified_sha = $sha""",
             {"rows": b, "sha": commit_sha},
         )
+    update_graph_meta(g)
 
 
 def write_coverage(
@@ -170,9 +172,45 @@ def write_coverage(
                    e.last_verified_sha = $sha""",
             {"rows": b, "conf": confidence, "sha": commit_sha},
         )
+    update_graph_meta(g)
     return len(pairs)
 
 
+def update_graph_meta(g) -> None:
+    """Updates Guard metadata generation and timestamp in the graph."""
+    import time
+    if g is None:
+        return
+    try:
+        ts = time.time()
+        g.query(
+            "MERGE (m:GuardMeta {id: 'meta'}) "
+            "SET m.updated_at = $ts, m.generation = coalesce(m.generation, 0) + 1",
+            {"ts": ts},
+        )
+    except Exception:
+        pass
+
+
+def get_graph_state(g) -> dict[str, Any]:
+    """Returns a dictionary summarizing graph state for cache invalidation."""
+    if g is None:
+        return {"status": "none"}
+    try:
+        counts = get_schema_counts(g)
+        meta = {}
+        try:
+            res = g.query("MATCH (m:GuardMeta {id: 'meta'}) RETURN m.updated_at, m.generation").result_set
+            if res and res[0]:
+                meta = {"updated_at": res[0][0], "generation": res[0][1]}
+        except Exception:
+            pass
+        return {"counts": counts, "meta": meta}
+    except Exception as exc:
+        return {"error": str(exc)}
+
+
+
 def write_run(
     g,
     run_data: dict[str, Any],

{guard_cli-0.1.0/guard → guard_cli-0.1.1/guard_cli}/doctor_cmd.py

@@ -26,15 +26,15 @@ from typing import Any
 from rich.console import Console
 from rich.table import Table
 
-import guard
-from guard import db
-from guard.backend import (
+import guard_cli
+from guard_cli import db
+from guard_cli.backend import (
     GraphBackend,
     get_repo_graph_name,
     resolve_backend,
     DockerBackend,
 )
-from guard.init_cmd import (
+from guard_cli.init_cmd import (
     find_repo_root,
     find_test_environment,
     write_integrations,
@@ -68,14 +68,14 @@ def check_environment() -> CheckResult:
         return CheckResult(
             name="environment",
             status="warn",
-            message=f"Python {py_ver}, guard v{guard.__version__}. 'guard' is not found on PATH for subshells and agent hooks.",
+            message=f"Python {py_ver}, guard v{guard_cli.__version__}. 'guard' is not found on PATH for subshells and agent hooks.",
             fix="Add your Python/uv tool bin directory to PATH (e.g. run 'uv tool update-shell' or add ~/.local/bin to PATH).",
         )
 
     return CheckResult(
         name="environment",
         status="pass",
-        message=f"Python {py_ver}, guard v{guard.__version__} (binary: {guard_bin}).",
+        message=f"Python {py_ver}, guard v{guard_cli.__version__} (binary: {guard_bin}).",
     )
 
 
@@ -310,11 +310,12 @@ def check_integrations(repo_path: Path) -> CheckResult:
     if not gi.exists() or (".guard/" not in gi.read_text(encoding="utf-8") and ".guard" not in gi.read_text(encoding="utf-8")):
         missing.append(".guard/ in .gitignore")
 
-    # 2. Check Claude Code Stop hook in settings.local.json or settings.json
-    from guard.integrations import claude
+    # 2. Check Stop hook in Claude Code or Antigravity CLI
+    from guard_cli.integrations import claude, antigravity
     claude_info = claude.check_all_settings(repo_path)
-    if not claude_info["installed"]:
-        missing.append("hook in .claude/settings.local.json or .claude/settings.json")
+    agy_info = antigravity.status(repo_path)
+    if not claude_info["installed"] and not agy_info["installed"]:
+        missing.append("hook in .agents/hooks.json or .claude/settings.json")
 
     # 3. Check AGENTS.md or CLAUDE.md marked block
     agents_doc = repo_path / "AGENTS.md"
@@ -335,10 +336,59 @@ def check_integrations(repo_path: Path) -> CheckResult:
             fix="Run 'guard doctor --fix' or 'guard init' to write integration files.",
         )
 
+    active_agents = []
+    if claude_info["installed"]:
+        active_agents.append("claude")
+    if agy_info["installed"]:
+        active_agents.append("antigravity")
+
     return CheckResult(
         name="integrations",
         status="pass",
-        message="Integrations verified in .claude/settings.json, AGENTS.md, and .gitignore.",
+        message=f"Integrations verified for {', '.join(active_agents) if active_agents else 'agents'} (AGENTS.md and .gitignore present).",
+    )
+
+
+def check_hook_timeout(repo_path: Path) -> CheckResult:
+    """Verify hook timeout configuration and warn if baseline test duration is near the limit."""
+    from guard_cli.hook import get_hook_timeout
+    timeout = get_hook_timeout(repo_path)
+
+    # Read baseline duration from state.json if present
+    state_file = repo_path / ".guard" / "state.json"
+    baseline_s = None
+    if state_file.exists():
+        try:
+            data = json.loads(state_file.read_text(encoding="utf-8"))
+            baseline_s = data.get("baseline_duration_s") or data.get("baseline_s")
+        except Exception:
+            pass
+
+    if baseline_s is not None:
+        try:
+            baseline_f = float(baseline_s)
+            if baseline_f >= (0.7 * timeout):
+                return CheckResult(
+                    name="hook_timeout",
+                    status="warn",
+                    message=(
+                        f"Baseline test run took {baseline_f:.1f}s, which is near the hook timeout limit ({timeout}s). "
+                        f"Slow test execution may cause agent hook timeout."
+                    ),
+                    fix=f"Increase timeout in .guard/config.toml ([hook] timeout = {int(baseline_f * 2)}) or optimize slow tests.",
+                )
+            return CheckResult(
+                name="hook_timeout",
+                status="pass",
+                message=f"Baseline test run took {baseline_f:.1f}s (comfortably within {timeout}s timeout limit).",
+            )
+        except (ValueError, TypeError):
+            pass
+
+    return CheckResult(
+        name="hook_timeout",
+        status="pass",
+        message=f"Hook timeout is configured to {timeout}s.",
     )
 
 
@@ -353,8 +403,8 @@ def apply_fixes(repo_path: Path, backend: GraphBackend | None, checks: list[Chec
                 applied.append(f"Started docker container '{backend.container_name}'.")
 
         elif c.name == "integrations":
-            write_integrations(repo_path, agents=["claude", "cursor", "codex"])
-            applied.append("Wrote integrations to .gitignore, .claude/settings.json, AGENTS.md, and CLAUDE.md.")
+            write_integrations(repo_path, agents=["claude", "cursor", "codex", "antigravity"])
+            applied.append("Wrote integrations to .gitignore, .agents/hooks.json, .claude/settings.json, AGENTS.md, and CLAUDE.md.")
 
     return applied
 
@@ -385,6 +435,7 @@ def run_doctor(
     check_f_res = check_freshness(root)
     check_t_res = check_target_repo(root)
     check_i_res = check_integrations(root)
+    check_to_res = check_hook_timeout(root)
 
     checks = [
         check_env_res,
@@ -393,6 +444,7 @@ def run_doctor(
         check_f_res,
         check_t_res,
         check_i_res,
+        check_to_res,
     ]
 
     applied_fixes: list[str] = []