0xray 2.1.2 → 2.1.4

package/dist/integrations/hermes-agent/test_plugin.py

@@ -1,1103 +0,0 @@
-"""Comprehensive tests for the 0xRay Hermes Plugin v2.
-
-Tests all 3 tools, both hooks, the slash command, bridge integration,
-logging to disk, and the full register() wiring.
-
-v2 changes from v1:
-  - Hooks now pipe through Node.js bridge for real framework integration
-  - Tool events logged to disk (activity.log, plugin-tool-events.log)
-  - Tools use bridge first, fall back to CLI
-  - Session stats track quality gate runs, processor runs, bridge calls
-  - No more in-memory _TOOL_LOG — everything persists to disk
-"""
-
-import json
-import subprocess
-import os
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch, MagicMock, call
-import logging
-import importlib
-import types
-
-# ── Path setup ────────────────────────────────────────────────
-
-PLUGIN_DIR = str(Path(__file__).resolve().parent)
-sys.path.insert(0, PLUGIN_DIR)
-
-# Force reimport
-for mod in list(sys.modules):
-    if "xray" in mod and ("schemas" in mod or "tools" in mod or "plugin" in mod):
-        del sys.modules[mod]
-
-schemas = importlib.import_module("schemas")
-tools_mod = importlib.import_module("tools")
-
-# Create a fake package for __init__.py execution
-pkg = types.ModuleType("xray_hermes_pkg")
-pkg.__path__ = [PLUGIN_DIR]
-pkg.__dict__["schemas"] = schemas
-pkg.__dict__["tools"] = tools_mod
-sys.modules["xray_hermes_pkg"] = pkg
-
-init_path = os.path.join(PLUGIN_DIR, "__init__.py")
-with open(init_path) as f:
-    init_code = f.read()
-init_code = init_code.replace("from . import schemas, tools", "import schemas, tools")
-# Provide __file__ since exec() loses it
-pkg.__dict__["__file__"] = init_path
-exec(compile(init_code, init_path, "exec"), pkg.__dict__)
-
-pi = pkg  # plugin init module
-
-
-class TestSchemas(unittest.TestCase):
-    def test_validate_schema_has_required_fields(self):
-        s = schemas.XRAY_VALIDATE
-        self.assertEqual(s["name"], "xray_validate")
-        params = s["parameters"]
-        self.assertEqual(params["type"], "object")
-        self.assertIn("files", params["properties"])
-        self.assertIn("operation", params["properties"])
-        self.assertIn("files", params["required"])
-        self.assertEqual(params["properties"]["files"]["type"], "array")
-
-    def test_codex_check_schema(self):
-        s = schemas.XRAY_CODEX_CHECK
-        self.assertEqual(s["name"], "xray_codex_check")
-        fa = s["parameters"]["properties"]["focus_areas"]
-        self.assertIn("enum", fa["items"])
-        self.assertIn("error-handling", fa["items"]["enum"])
-
-    def test_health_schema_no_required(self):
-        s = schemas.XRAY_HEALTH
-        self.assertEqual(len(s["parameters"].get("required", [])), 0)
-
-    def test_descriptions_non_empty(self):
-        for name, schema in [("v", schemas.XRAY_VALIDATE), ("c", schemas.XRAY_CODEX_CHECK), ("h", schemas.XRAY_HEALTH)]:
-            self.assertTrue(len(schema["description"]) > 20, f"{name}")
-
-
-class TestRunXrayHelper(unittest.TestCase):
-    """Test the CLI fallback helper (still exists for bridge-less environments)."""
-
-    def test_successful_command(self):
-        with patch("subprocess.run") as m:
-            m.return_value = MagicMock(returncode=0, stdout="all good", stderr="")
-            r = json.loads(tools_mod._run_xray(["health"]))
-            self.assertEqual(r["status"], "ok")
-            self.assertEqual(m.call_args[0][0], ["npx", "0xray", "health"])
-
-    def test_command_failure(self):
-        with patch("subprocess.run") as m:
-            m.return_value = MagicMock(returncode=1, stdout="", stderr="broke")
-            r = json.loads(tools_mod._run_xray(["validate"]))
-            self.assertEqual(r["status"], "error")
-
-    def test_file_not_found(self):
-        with patch("subprocess.run", side_effect=FileNotFoundError):
-            r = json.loads(tools_mod._run_xray(["health"]))
-            self.assertIn("not found", r["error"])
-
-    def test_timeout(self):
-        with patch("subprocess.run", side_effect=subprocess.TimeoutExpired("c", 30)):
-            r = json.loads(tools_mod._run_xray(["health"], timeout=15))
-            self.assertIn("15s", r["error"])
-
-    def test_custom_timeout(self):
-        with patch("subprocess.run") as m:
-            m.return_value = MagicMock(returncode=0, stdout="", stderr="")
-            tools_mod._run_xray(["health"], timeout=60)
-            self.assertEqual(m.call_args[1]["timeout"], 60)
-
-
-class TestBridgeHelper(unittest.TestCase):
-    """Test the bridge.mjs calling helper."""
-
-    def test_successful_bridge_call(self):
-        with patch("subprocess.run") as m:
-            m.return_value = MagicMock(returncode=0, stdout='{"status":"ok"}', stderr="")
-            r = tools_mod._bridge_call({"command": "health"})
-            self.assertEqual(r["status"], "ok")
-            # Should call node with bridge path
-            self.assertIn("node", m.call_args[0][0])
-            self.assertIn("bridge.mjs", m.call_args[0][0][1])
-
-    def test_bridge_returns_error(self):
-        with patch("subprocess.run") as m:
-            m.return_value = MagicMock(returncode=1, stdout="", stderr="module not found")
-            r = tools_mod._bridge_call({"command": "health"})
-            self.assertIn("error", r)
-
-    def test_bridge_node_not_found(self):
-        with patch("subprocess.run", side_effect=FileNotFoundError):
-            r = tools_mod._bridge_call({"command": "health"})
-            self.assertEqual(r["error"], "node not found")
-
-    def test_bridge_timeout(self):
-        with patch("subprocess.run", side_effect=subprocess.TimeoutExpired("c", 10)):
-            r = tools_mod._bridge_call({"command": "health"}, timeout=10)
-            self.assertIn("timed out", r["error"])
-
-
-class TestXrayHealth(unittest.TestCase):
-    def test_health_via_bridge(self):
-        """v2: health uses bridge first."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"status": "ok", "framework": "loaded", "version": "1.15.0", "components": {}}) as m:
-            r = json.loads(tools_mod.xray_health({}))
-            self.assertEqual(r["status"], "ok")
-            self.assertEqual(r["via"], "bridge")
-            m.assert_called_once_with({"command": "health"}, timeout=10)
-
-    def test_health_fallback_to_cli(self):
-        """v2: falls back to CLI when bridge fails."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"error": "node not found"}):
-            with patch.object(tools_mod, "_run_xray", return_value='{"status":"ok","output":"healthy"}') as cli:
-                r = json.loads(tools_mod.xray_health({}))
-                cli.assert_called_once()
-
-    def test_health_ignores_extra_args(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"status": "ok", "framework": "loaded", "version": "1.0", "components": {}}):
-            r = json.loads(tools_mod.xray_health({"x": 1}))
-            self.assertEqual(r["status"], "ok")
-
-
-class TestXrayValidate(unittest.TestCase):
-    def test_with_files_via_bridge(self):
-        """v2: validate uses bridge first."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": True, "fileResults": []}) as m:
-            r = json.loads(tools_mod.xray_validate({"files": ["a.ts", "b.ts"], "operation": "commit"}))
-            self.assertEqual(r["status"], "passed")
-            self.assertEqual(r["files_checked"], 2)
-            self.assertEqual(r["via"], "bridge")
-            m.assert_called_once()
-
-    def test_bridge_violations(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": False, "fileResults": [{"file": "a.ts", "passed": False, "violations": ["tests-required"]}]}) as m:
-            r = json.loads(tools_mod.xray_validate({"files": ["a.ts"]}))
-            self.assertEqual(r["status"], "violations")
-            self.assertEqual(r["file_results"][0]["violations"], ["tests-required"])
-
-    def test_bridge_error_fallback_to_cli(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"error": "node not found"}):
-            with patch.object(tools_mod, "_run_xray", return_value='{"status":"ok","output":"valid"}') as cli:
-                r = json.loads(tools_mod.xray_validate({"files": ["a.ts"]}))
-                self.assertEqual(r["via"], "cli")
-                cli.assert_called_once()
-
-    def test_no_files_error(self):
-        r = json.loads(tools_mod.xray_validate({"files": []}))
-        self.assertIn("No files", r["error"])
-
-    def test_no_files_key_error(self):
-        r = json.loads(tools_mod.xray_validate({}))
-        self.assertIn("error", r)
-
-    def test_default_operation(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": True, "fileResults": []}):
-            r = json.loads(tools_mod.xray_validate({"files": ["a.ts"]}))
-            self.assertEqual(r["operation"], "commit")
-
-    def test_100_files(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": True, "fileResults": []}) as m:
-            fs = [f"f{i}.ts" for i in range(100)]
-            r = json.loads(tools_mod.xray_validate({"files": fs}))
-            self.assertEqual(r["files_checked"], 100)
-
-
-class TestXrayCodexCheck(unittest.TestCase):
-    def test_with_code_via_bridge(self):
-        """v2: codex check uses bridge for real quality gate analysis."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": True, "violations": [], "checks": []}) as m:
-            r = json.loads(tools_mod.xray_codex_check({"code": "const x = null;", "operation": "create"}))
-            self.assertEqual(r["status"], "passed")
-            self.assertEqual(r["via"], "bridge")
-            m.assert_called_once()
-
-    def test_with_code_bridge_violations(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": False, "violations": ["console.log found"], "checks": []}):
-            r = json.loads(tools_mod.xray_codex_check({"code": "console.log(x)", "operation": "create"}))
-            self.assertEqual(r["status"], "violations")
-            self.assertEqual(r["violations"], ["console.log found"])
-
-    def test_with_focus_areas(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": True, "violations": [], "checks": []}) as m:
-            tools_mod.xray_codex_check({"code": "eval()", "operation": "modify", "focus_areas": ["security"]})
-            self.assertEqual(m.call_args[0][0]["focusAreas"], ["security"])
-
-    def test_empty_string_code_treated_as_code(self):
-        """BUG FIX: empty string '' should still be treated as code (is not None)."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": True, "violations": [], "checks": []}) as m:
-            r = json.loads(tools_mod.xray_codex_check({"code": "", "operation": "create"}))
-            self.assertEqual(r["status"], "passed")
-            self.assertEqual(r["code_length"], 0)
-
-    def test_no_code_bridge_health(self):
-        """No code provided — bridge health check."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"framework": "loaded", "version": "1.15.0", "components": {}}) as m:
-            r = json.loads(tools_mod.xray_codex_check({"operation": "refactor"}))
-            self.assertEqual(r["status"], "ok")
-            self.assertIn("Pass", r["note"])
-
-    def test_no_code_bridge_error_fallback(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"error": "node not found"}):
-            with patch.object(tools_mod, "_run_xray", return_value='{"status":"ok","output":"healthy"}') as cli:
-                r = json.loads(tools_mod.xray_codex_check({"operation": "create"}))
-                cli.assert_called_once()
-
-    def test_default_operation(self):
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": True, "violations": [], "checks": []}):
-            r = json.loads(tools_mod.xray_codex_check({"code": "x"}))
-            self.assertEqual(r["operation"], "create")
-
-    def test_multiline_code(self):
-        code = "function foo() {\n  return null;\n}\n"
-        with patch.object(tools_mod, "_bridge_call", return_value={"passed": True, "violations": [], "checks": []}):
-            r = json.loads(tools_mod.xray_codex_check({"code": code, "operation": "create"}))
-            self.assertEqual(r["code_length"], len(code))
-
-
-class TestPreToolCallHook(unittest.TestCase):
-    """v2: pre_tool_call now runs bridge for code tools and logs to disk."""
-
-    def setUp(self):
-        # Reset session stats
-        pi._session_stats = dict.fromkeys(pi._session_stats, 0)
-        pi._session_stats["started_at"] = None
-        pi._session_stats["session_id"] = None
-
-    @patch.object(pi, "_call_bridge")
-    def test_xray_mcp_no_bridge(self, mock_bridge):
-        """0xRay MCP tools skip bridge entirely."""
-        pi._on_pre_tool_call("mcp_xray_lint_lint", {}, "t1")
-        self.assertEqual(pi._session_stats["xray_mcp_calls"], 1)
-        self.assertEqual(pi._session_stats["native_tool_calls"], 0)
-        mock_bridge.assert_not_called()
-
-    @patch.object(pi, "_call_bridge")
-    def test_native_tool_no_bridge(self, mock_bridge):
-        """Non-code native tools don't call bridge."""
-        pi._on_pre_tool_call("read_file", {"path": "a.md"}, "t1")
-        mock_bridge.assert_not_called()
-
-    @patch.object(pi, "_call_bridge", return_value={"passed": True, "qualityGate": {"passed": True, "violations": []}, "processors": {"ran": False}})
-    def test_code_tool_calls_bridge(self, mock_bridge):
-        """Code-producing tools trigger bridge pre-process."""
-        pi._on_pre_tool_call("write_file", {"path": "a.ts"}, "t1")
-        mock_bridge.assert_called_once()
-        call_cmd = mock_bridge.call_args[0][0]
-        self.assertEqual(call_cmd["command"], "pre-process")
-        self.assertEqual(call_cmd["tool"], "write_file")
-
-    @patch.object(pi, "_call_bridge", return_value={"passed": True, "qualityGate": {"passed": True, "violations": []}, "processors": {"ran": False}})
-    def test_code_tool_increments_stats(self, mock_bridge):
-        for t in ["write_file", "patch", "execute_code"]:
-            pi._session_stats["code_operations"] = 0
-            pi._session_stats["quality_gate_runs"] = 0
-            pi._on_pre_tool_call(t, {}, "t1")
-            self.assertEqual(pi._session_stats["code_operations"], 1, f"{t}")
-            self.assertEqual(pi._session_stats["quality_gate_runs"], 1, f"{t}")
-
-    @patch.object(pi, "_call_bridge", return_value={"passed": False, "qualityGate": {"passed": False, "violations": ["tests-required: no test"]}, "processors": {"ran": False}})
-    def test_quality_gate_block(self, mock_bridge):
-        """Quality gate failures increment block counter."""
-        pi._on_pre_tool_call("write_file", {"path": "a.ts"}, "t1")
-        self.assertEqual(pi._session_stats["quality_gate_blocks"], 1)
-
-    @patch.object(pi, "_call_bridge", return_value={"passed": True, "qualityGate": {"passed": True}, "processors": {"ran": True, "success": True, "processorCount": 2, "details": [{"name": "preValidate", "success": True}]}})
-    def test_pre_processor_stats(self, mock_bridge):
-        pi._on_pre_tool_call("write_file", {"path": "a.ts"}, "t1")
-        self.assertEqual(pi._session_stats["pre_processor_runs"], 1)
-
-    def test_nudge_terminal(self):
-        """Terminal nudge only fires when command matches a known pattern."""
-        # No command arg — no nudge
-        with self.assertRaises(AssertionError):
-            with self.assertLogs("xray-hermes", level="INFO"):
-                pi._on_pre_tool_call("terminal", {}, "t1")
-
-        # Generic command (git, ls) — no nudge
-        with self.assertRaises(AssertionError):
-            with self.assertLogs("xray-hermes", level="INFO"):
-                pi._on_pre_tool_call("terminal", {"command": "git status"}, "t1")
-
-        # Grep command — should nudge
-        with self.assertLogs("xray-hermes", level="INFO") as cm:
-            pi._on_pre_tool_call("terminal", {"command": "grep -r 'pattern' src/"}, "t1")
-        self.assertTrue(any("grep" in m for m in cm.output))
-
-        # npm audit — should nudge
-        with self.assertLogs("xray-hermes", level="INFO") as cm:
-            pi._on_pre_tool_call("terminal", {"command": "npm audit"}, "t1")
-        self.assertTrue(any("audit" in m for m in cm.output))
-
-    def test_nudge_search_files(self):
-        with self.assertLogs("xray-hermes", level="INFO") as cm:
-            pi._on_pre_tool_call("search_files", {}, "t1")
-        self.assertTrue(any("Tip" in m for m in cm.output))
-
-    def test_no_nudge_write_file(self):
-        """write_file is a code tool — no nudge, gets bridge instead."""
-        with patch.object(pi, "_call_bridge", return_value={"passed": True, "qualityGate": {"passed": True}, "processors": {"ran": False}}):
-            with self.assertRaises(AssertionError):
-                with self.assertLogs("xray-hermes", level="INFO"):
-                    pi._on_pre_tool_call("write_file", {}, "t1")
-
-    def test_accumulates(self):
-        with patch.object(pi, "_call_bridge", return_value={"passed": True, "qualityGate": {"passed": True}, "processors": {"ran": False}}):
-            for _ in range(5):
-                pi._on_pre_tool_call("terminal", {}, "t1")
-        self.assertEqual(pi._session_stats["total_tool_calls"], 5)
-
-    def test_is_xray_mcp(self):
-        self.assertTrue(pi._is_xray_mcp("mcp_xray_lint_lint"))
-        self.assertTrue(pi._is_xray_mcp("mcp_xray_enforcer_codex_enforcement"))
-        self.assertFalse(pi._is_xray_mcp("terminal"))
-        self.assertFalse(pi._is_xray_mcp("xray_validate"))
-        self.assertFalse(pi._is_xray_mcp("mcp_other_tool"))
-
-
-class TestPostToolCallHook(unittest.TestCase):
-    """v2: post_tool_call logs to disk and calls bridge for code tools."""
-
-    def setUp(self):
-        # Reset post_processor_runs since it accumulates across tests
-        pi._session_stats["post_processor_runs"] = 0
-
-    @patch.object(pi, "_call_bridge")
-    def test_non_code_no_bridge(self, mock_bridge):
-        """Non-code tools don't trigger bridge post-process."""
-        pi._on_post_tool_call("terminal", {"command": "ls"}, None, "t1")
-        mock_bridge.assert_not_called()
-
-    @patch.object(pi, "_call_bridge", return_value={"processors": {"ran": True, "success": True, "processorCount": 2, "details": []}})
-    def test_code_tool_calls_bridge(self, mock_bridge):
-        """Code-producing tools trigger bridge post-process."""
-        pi._on_post_tool_call("write_file", {"path": "a.ts"}, None, "t1")
-        mock_bridge.assert_called_once()
-        call_cmd = mock_bridge.call_args[0][0]
-        self.assertEqual(call_cmd["command"], "post-process")
-        self.assertEqual(call_cmd["tool"], "write_file")
-
-    @patch.object(pi, "_call_bridge", return_value={"processors": {"ran": True, "success": True, "processorCount": 1, "details": []}})
-    def test_post_processor_stats(self, mock_bridge):
-        pi._on_post_tool_call("patch", {"path": "a.ts"}, None, "t1")
-        self.assertEqual(pi._session_stats["post_processor_runs"], 1)
-
-    @patch.object(pi, "_call_bridge", return_value={"processors": {"ran": True, "success": True, "processorCount": 2, "details": []}})
-    def test_post_captures_result(self, mock_bridge):
-        pi._on_post_tool_call("write_file", {"path": "a.ts"}, {"error": "disk full"}, "t1")
-        call_cmd = mock_bridge.call_args[0][0]
-        self.assertEqual(call_cmd["error"], "disk full")
-
-    def test_args_not_dict_no_crash(self):
-        pi._on_post_tool_call("write_file", "not a dict", None, "t1")
-
-    def test_args_none_no_crash(self):
-        pi._on_post_tool_call("write_file", None, None, "t1")
-
-    def test_missing_path_key_no_file_tracking(self):
-        """BUG FIX: missing path key should not crash."""
-        pi._on_post_tool_call("write_file", {"content": "hello"}, None, "t1")
-
-    def test_empty_path_no_file_tracking(self):
-        """Empty string path should not crash."""
-        pi._on_post_tool_call("write_file", {"path": ""}, None, "t1")
-
-
-class TestSlashCommand(unittest.TestCase):
-    def setUp(self):
-        pi._session_stats = {
-            "started_at": "2026-03-27T15:00:00Z",
-            "session_id": "test-session",
-            "code_operations": 5,
-            "total_tool_calls": 20,
-            "xray_mcp_calls": 12,
-            "native_tool_calls": 8,
-            "quality_gate_runs": 10,
-            "quality_gate_blocks": 2,
-            "pre_processor_runs": 8,
-            "post_processor_runs": 6,
-            "bridge_calls": 15,
-            "bridge_errors": 0,
-            "subagent_dispatches": 3,
-            "subagent_validations": 1,
-            "subagent_blocks": 0,
-        }
-
-    def test_stats(self):
-        o = pi._xray_command("stats")
-        self.assertIn("20", o)
-        self.assertIn("12", o)
-        self.assertIn("8", o)
-        self.assertIn("5", o)
-        # v2 new stats
-        self.assertIn("10", o)  # quality_gate_runs
-        self.assertIn("2", o)   # quality_gate_blocks
-        self.assertIn("15", o)  # bridge_calls
-
-    def test_help(self):
-        o = pi._xray_command("help")
-        self.assertIn("status", o)
-        self.assertIn("help", o)
-
-    def test_status_via_bridge(self):
-        """v2: status uses bridge, not tools.xray_health."""
-        with patch.object(pi, "_call_bridge", return_value={"framework": "loaded", "version": "1.15.0", "components": {"qualityGate": True, "processorManager": True}}) as m:
-            o = pi._xray_command("status")
-            self.assertIn("loaded", o)
-            self.assertIn("1.15.0", o)
-            m.assert_called_once_with({"command": "health"}, timeout=10)
-
-    def test_status_bridge_error(self):
-        with patch.object(pi, "_call_bridge", return_value={"error": "node not found"}):
-            o = pi._xray_command("status")
-            self.assertIn("node not found", o)
-
-    def test_default_status(self):
-        with patch.object(pi, "_call_bridge", return_value={"framework": "loaded", "version": "1.0", "components": {}}):
-            o = pi._xray_command("")
-            self.assertIn("loaded", o)
-
-    def test_stats_null_started_at(self):
-        pi._session_stats["started_at"] = None
-        pi._session_stats["session_id"] = None
-        o = pi._xray_command("stats")
-        self.assertIn("N/A", o)
-
-
-class TestSessionStartHook(unittest.TestCase):
-    def test_resets_stats(self):
-        pi._session_stats["total_tool_calls"] = 99
-        pi._session_stats["code_operations"] = 50
-        pi._session_stats["bridge_calls"] = 20
-        pi._session_stats["quality_gate_blocks"] = 5
-        pi._on_session_start("s1", "cli")
-        self.assertEqual(pi._session_stats["total_tool_calls"], 0)
-        self.assertEqual(pi._session_stats["code_operations"], 0)
-        self.assertEqual(pi._session_stats["bridge_calls"], 0)
-        self.assertEqual(pi._session_stats["quality_gate_blocks"], 0)
-        self.assertIsNotNone(pi._session_stats["started_at"])
-        self.assertEqual(pi._session_stats["session_id"], "s1")
-
-    def test_logs(self):
-        with self.assertLogs("xray-hermes", level="INFO") as cm:
-            pi._on_session_start("s1", "telegram")
-        self.assertTrue(any("s1" in m for m in cm.output))
-        self.assertTrue(any("telegram" in m for m in cm.output))
-
-
-class TestRegisterIntegration(unittest.TestCase):
-    def test_wires_three_tools(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        names = [c[1]["name"] for c in ctx.register_tool.call_args_list]
-        self.assertEqual(set(names), {"xray_validate", "xray_codex_check", "xray_health", "xray_hooks"})
-
-    def test_toolset_name(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        for c in ctx.register_tool.call_args_list:
-            self.assertEqual(c[1]["toolset"], "0xray-hermes")
-
-    def test_schemas_wired(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        sm = {c[1]["name"]: c[1]["schema"] for c in ctx.register_tool.call_args_list}
-        self.assertIs(sm["xray_validate"], schemas.XRAY_VALIDATE)
-        self.assertIs(sm["xray_codex_check"], schemas.XRAY_CODEX_CHECK)
-        self.assertIs(sm["xray_health"], schemas.XRAY_HEALTH)
-
-    def test_handlers_wired(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        hm = {c[1]["name"]: c[1]["handler"] for c in ctx.register_tool.call_args_list}
-        self.assertIs(hm["xray_validate"], tools_mod.xray_validate)
-        self.assertIs(hm["xray_codex_check"], tools_mod.xray_codex_check)
-        self.assertIs(hm["xray_health"], tools_mod.xray_health)
-
-    def test_hooks_registered(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        names = [c[0][0] for c in ctx.register_hook.call_args_list]
-        self.assertIn("pre_tool_call", names)
-        self.assertIn("post_tool_call", names)
-
-    def test_hooks_are_callable(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        for c in ctx.register_hook.call_args_list:
-            self.assertTrue(callable(c[0][1]))
-
-    def test_slash_command_attempted(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        cmds = [c for c in ctx.method_calls if "register_command" in str(c)]
-        self.assertTrue(len(cmds) >= 1)
-
-    def test_survives_missing_session_hook(self):
-        ctx = MagicMock()
-        # pre_tool_call, post_tool_call succeed; on_session_start fails; 3 lifecycle hooks fail
-        ctx.register_hook.side_effect = [None, None, AttributeError("nope"), AttributeError("nope"), AttributeError("nope"), AttributeError("nope")]
-        pi.register(ctx)  # should not raise
-
-    def test_survives_missing_command_reg(self):
-        ctx = MagicMock()
-        ctx.register_command.side_effect = TypeError("nope")
-        pi.register(ctx)
-
-    def test_logs_on_load(self):
-        ctx = MagicMock()
-        with self.assertLogs("xray-hermes", level="INFO") as cm:
-            pi.register(ctx)
-        self.assertTrue(any("Plugin" in m and "loaded" in m for m in cm.output))
-
-
-class TestFileLogging(unittest.TestCase):
-    """Test that tool events are written to log files."""
-
-    def test_log_tool_event_creates_file(self):
-        with tempfile.TemporaryDirectory() as td:
-            log_dir = Path(td)
-            # Temporarily override LOG_DIR
-            original = pi.LOG_DIR
-            pi.LOG_DIR = log_dir
-
-            pi._log_tool_event("start", "terminal", {"command": "ls"})
-            pi._log_tool_event("complete", "terminal", {"command": "ls"}, duration=100)
-
-            activity_file = log_dir / "plugin-tool-events.log"
-            self.assertTrue(activity_file.exists())
-
-            content = activity_file.read_text()
-            self.assertIn("tool-started", content)
-            self.assertIn("tool-complete", content)
-            self.assertIn("SUCCESS", content)
-
-            pi.LOG_DIR = original
-
-    def test_log_to_file_creates_file(self):
-        with tempfile.TemporaryDirectory() as td:
-            log_dir = Path(td)
-            original = pi.LOG_DIR
-            pi.LOG_DIR = log_dir
-
-            pi._log_to_file("activity.log", "[test] hello world")
-
-            activity_file = log_dir / "activity.log"
-            self.assertTrue(activity_file.exists())
-            content = activity_file.read_text()
-            self.assertIn("[test] hello world", content)
-
-            pi.LOG_DIR = original
-
-    def test_log_to_file_survives_permission_error(self):
-        """Should never crash the agent over logging."""
-        original = pi.LOG_DIR
-        pi.LOG_DIR = Path("/nonexistent/path/that/does/not/exist/and/cannot/be/created")
-        pi._log_to_file("activity.log", "should not crash")  # noqa: B023
-        pi.LOG_DIR = original
-
-
-class TestLiveBridge(unittest.TestCase):
-    """Live test: actually call bridge.mjs if it exists."""
-
-    def test_bridge_health(self):
-        bridge_path = Path(PLUGIN_DIR) / "bridge.mjs"
-        if not bridge_path.exists():
-            self.skipTest("bridge.mjs not built yet")
-
-        r = tools_mod._bridge_call({"command": "health"}, timeout=10)
-        self.assertNotIn("error", r)
-        self.assertIn("status", r)
-
-    def test_bridge_stats(self):
-        bridge_path = Path(PLUGIN_DIR) / "bridge.mjs"
-        if not bridge_path.exists():
-            self.skipTest("bridge.mjs not built yet")
-
-        r = tools_mod._bridge_call({"command": "stats"}, timeout=5)
-        self.assertIn("frameworkReady", r)
-
-    def test_bridge_quality_gate(self):
-        bridge_path = Path(PLUGIN_DIR) / "bridge.mjs"
-        if not bridge_path.exists():
-            self.skipTest("bridge.mjs not built yet")
-
-        # Clean code should pass
-        r = tools_mod._bridge_call({
-            "command": "codex-check",
-            "code": "const x: number = 42;",
-        }, timeout=10)
-        self.assertNotIn("error", r)
-        self.assertIn("passed", r)
-
-    def test_bridge_quality_gate_violation(self):
-        bridge_path = Path(PLUGIN_DIR) / "bridge.mjs"
-        if not bridge_path.exists():
-            self.skipTest("bridge.mjs not built yet")
-
-        # Code with console.log should fail
-        r = tools_mod._bridge_call({
-            "command": "codex-check",
-            "code": "console.log('hello');",
-        }, timeout=10)
-        self.assertNotIn("error", r)
-        # console.log is a violation
-        if r.get("passed") is False:
-            self.assertTrue(
-                any("console.log" in v.get("message", "") for v in r.get("violations", [])),
-                f"Expected 'console.log' in violations, got: {r.get('violations', [])}",
-            )
-
-    def test_bridge_positional_health(self):
-        """Positional arg mode: node bridge.mjs health --cwd /path (no stdin pipe)."""
-        bridge_path = Path(PLUGIN_DIR) / "bridge.mjs"
-        if not bridge_path.exists():
-            self.skipTest("bridge.mjs not built yet")
-
-        # Use stringray dev repo as project root (has package.json)
-        xray_root = str(Path(PLUGIN_DIR).parent.parent.parent / "dev" / "stringray")
-        cwd = xray_root if Path(xray_root).exists() else PLUGIN_DIR
-
-        r = subprocess.run(
-            ["node", str(bridge_path), "health", "--cwd", cwd],
-            capture_output=True, text=True, timeout=10,
-        )
-        self.assertEqual(r.returncode, 0, f"stderr: {r.stderr}")
-        data = json.loads(r.stdout)
-        self.assertEqual(data["status"], "ok")
-        self.assertIn("framework", data)
-
-    def test_bridge_positional_stats(self):
-        """Positional stats: no stdin needed."""
-        bridge_path = Path(PLUGIN_DIR) / "bridge.mjs"
-        if not bridge_path.exists():
-            self.skipTest("bridge.mjs not built yet")
-
-        xray_root = str(Path(PLUGIN_DIR).parent.parent.parent / "dev" / "stringray")
-        cwd = xray_root if Path(xray_root).exists() else PLUGIN_DIR
-
-        r = subprocess.run(
-            ["node", str(bridge_path), "stats", "--cwd", cwd],
-            capture_output=True, text=True, timeout=10,
-        )
-        self.assertEqual(r.returncode, 0, f"stderr: {r.stderr}")
-        data = json.loads(r.stdout)
-        self.assertIn("frameworkReady", data)
-
-    def test_bridge_positional_with_json_payload(self):
-        """Positional mode with --json payload for commands needing args."""
-        bridge_path = Path(PLUGIN_DIR) / "bridge.mjs"
-        if not bridge_path.exists():
-            self.skipTest("bridge.mjs not built yet")
-
-        xray_root = str(Path(PLUGIN_DIR).parent.parent.parent / "dev" / "stringray")
-        cwd = xray_root if Path(xray_root).exists() else PLUGIN_DIR
-
-        r = subprocess.run(
-            ["node", str(bridge_path), "validate", "--cwd", cwd,
-             "--json", json.dumps({"files": ["src/index.ts"], "operation": "commit"})],
-            capture_output=True, text=True, timeout=15,
-        )
-        self.assertEqual(r.returncode, 0, f"stderr: {r.stderr}")
-        data = json.loads(r.stdout)
-        self.assertIn("passed", data)
-
-    def test_bridge_positional_invalid_json(self):
-        """Positional mode with invalid --json returns error."""
-        bridge_path = Path(PLUGIN_DIR) / "bridge.mjs"
-        if not bridge_path.exists():
-            self.skipTest("bridge.mjs not built yet")
-
-        xray_root = str(Path(PLUGIN_DIR).parent.parent.parent / "dev" / "stringray")
-        cwd = xray_root if Path(xray_root).exists() else PLUGIN_DIR
-
-        r = subprocess.run(
-            ["node", str(bridge_path), "validate", "--cwd", cwd,
-             "--json", "not-json"],
-            capture_output=True, text=True, timeout=10,
-        )
-        # Should fail with error about invalid payload
-        data = json.loads(r.stdout)
-        self.assertIn("error", data)
-
-
-class TestBridgeErrorPaths(unittest.TestCase):
-    """Cover remaining bridge error branches in tools.py."""
-
-    def test_bridge_json_decode_error(self):
-        """_bridge_call with non-JSON stdout returns error."""
-        with patch("subprocess.run") as m:
-            m.return_value = MagicMock(returncode=0, stdout="not json", stderr="")
-            r = tools_mod._bridge_call({"command": "health"})
-            self.assertIn("error", r)
-
-    def test_bridge_os_error(self):
-        """_bridge_call with OSError during subprocess returns error."""
-        with patch("subprocess.run", side_effect=OSError("broken pipe")):
-            r = tools_mod._bridge_call({"command": "health"})
-            self.assertIn("error", r)
-
-    def test_bridge_generic_exception_in_run_xray(self):
-        """_run_xray catches non-standard exceptions."""
-        with patch("subprocess.run", side_effect=RuntimeError("unexpected")):
-            r = json.loads(tools_mod._run_xray(["health"]))
-            self.assertIn("unexpected", r["error"])
-
-    def test_validate_cli_fallback_error(self):
-        """xray_validate CLI fallback when CLI returns an error JSON."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"error": "bridge down"}):
-            with patch.object(tools_mod, "_run_xray", return_value='{"error": "validation failed"}'):
-                r = json.loads(tools_mod.xray_validate({"files": ["a.ts"]}))
-                # CLI error path returns raw result without "via" key
-                self.assertIn("error", r)
-
-    def test_codex_check_static_fallback(self):
-        """xray_codex_check with code but bridge down falls back to static analysis."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"error": "bridge down"}):
-            r = json.loads(tools_mod.xray_codex_check({"code": "console.log(1)", "operation": "create"}))
-            self.assertEqual(r["via"], "static")
-            self.assertIn("basic analysis", r["note"])
-
-    def test_codex_check_cli_health_error(self):
-        """xray_codex_check no-code path: bridge error + CLI also errors."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"error": "no node"}):
-            with patch.object(tools_mod, "_run_xray", return_value='{"error": "0xray not found"}'):
-                r = json.loads(tools_mod.xray_codex_check({"operation": "create"}))
-                self.assertIn("error", r)
-
-
-class TestGetProjectRoot(unittest.TestCase):
-    """Test the _get_project_root helper in tools.py."""
-
-    def test_returns_cwd_when_no_package_json(self):
-        """With no package.json in any ancestor, falls back to cwd."""
-        # _get_project_root delegates to __init__.py's PROJECT_ROOT.
-        # We verify the function exists and is callable.
-        self.assertTrue(callable(tools_mod._get_project_root))
-        # Verify it returns a Path-like value
-        result = tools_mod._get_project_root()
-        self.assertIsNotNone(result)
-
-
-class TestPreToolCallBridgeErrors(unittest.TestCase):
-    """Test pre_tool_call hook when bridge returns errors."""
-
-    def setUp(self):
-        pi._session_stats = dict.fromkeys(pi._session_stats, 0)
-        pi._session_stats["started_at"] = None
-        pi._session_stats["session_id"] = None
-
-    @patch.object(pi, "_call_bridge", return_value={"error": "bridge crashed"})
-    def test_code_tool_bridge_error_does_not_crash(self, mock_bridge):
-        """Bridge error during pre-process should not crash the hook."""
-        pi._on_pre_tool_call("write_file", {"path": "a.ts"}, "t1")
-        self.assertEqual(pi._session_stats["code_operations"], 1)
-        # Note: bridge_calls stat is inside the real _bridge_call,
-        # so mocking it doesn't increment the counter. Verify hook doesn't crash.
-        mock_bridge.assert_called_once()
-
-    @patch.object(pi, "_call_bridge", return_value={"error": "timeout"})
-    def test_multiple_code_tools_with_bridge_errors(self, mock_bridge):
-        """Multiple bridge errors accumulate properly."""
-        for i in range(3):
-            pi._on_pre_tool_call("write_file", {"path": f"f{i}.ts"}, "t1")
-        self.assertEqual(pi._session_stats["code_operations"], 3)
-        self.assertEqual(pi._session_stats["total_tool_calls"], 3)
-
-
-class TestPostToolCallBridgeErrors(unittest.TestCase):
-    """Test post_tool_call hook when bridge returns errors."""
-
-    def setUp(self):
-        pi._session_stats["post_processor_runs"] = 0
-
-    @patch.object(pi, "_call_bridge", return_value={"error": "bridge down"})
-    def test_code_tool_post_bridge_error(self, mock_bridge):
-        """Bridge error during post-process should not crash."""
-        pi._on_post_tool_call("write_file", {"path": "a.ts"}, None, "t1")
-        mock_bridge.assert_called_once()
-
-    @patch.object(pi, "_call_bridge", return_value={"processors": {"ran": False}})
-    def test_code_tool_processors_not_ran(self, mock_bridge):
-        """Processors not running is handled gracefully."""
-        pi._on_post_tool_call("execute_code", {"command": "echo hi"}, {"duration": 42}, "t1")
-        self.assertEqual(pi._session_stats["post_processor_runs"], 0)
-
-    @patch.object(pi, "_call_bridge", return_value={"processors": {"ran": True, "success": False, "processorCount": 1, "details": [{"name": "testAutoCreation", "success": False, "error": "no test file"}]}})
-    def test_post_processor_failure_logging(self, mock_bridge):
-        """Failed post-processors are tracked but don't crash."""
-        pi._on_post_tool_call("write_file", {"path": "a.ts"}, None, "t1")
-        self.assertEqual(pi._session_stats["post_processor_runs"], 1)
-
-
-class TestPreToolCallEdgeCases(unittest.TestCase):
-    """Edge cases for pre_tool_call."""
-
-    def setUp(self):
-        pi._session_stats = dict.fromkeys(pi._session_stats, 0)
-        pi._session_stats["started_at"] = None
-        pi._session_stats["session_id"] = None
-
-    @patch.object(pi, "_call_bridge", return_value={"passed": True, "qualityGate": {"passed": True}, "processors": {"ran": False}})
-    def test_all_code_tools_trigger_bridge(self, mock_bridge):
-        """Every tool in _CODE_TOOLS calls the bridge."""
-        code_tools = ["write_file", "patch", "execute_code", "write", "edit"]
-        for tool in code_tools:
-            pi._session_stats["code_operations"] = 0
-            pi._on_pre_tool_call(tool, {}, "t1")
-            self.assertEqual(pi._session_stats["code_operations"], 1, f"{tool} should be a code tool")
-
-    @patch.object(pi, "_call_bridge")
-    def test_unknown_tool_not_xray_mcp(self, mock_bridge):
-        """Unknown tools should be treated as native tools."""
-        pi._on_pre_tool_call("some_random_tool", {}, "t1")
-        self.assertEqual(pi._session_stats["native_tool_calls"], 1)
-        mock_bridge.assert_not_called()
-
-    def test_xray_validate_tool_not_treated_as_mcp(self):
-        """xray_validate is a native tool, not an MCP tool."""
-        pi._on_pre_tool_call("xray_validate", {}, "t1")
-        self.assertEqual(pi._session_stats["native_tool_calls"], 1)
-        self.assertEqual(pi._session_stats["xray_mcp_calls"], 0)
-
-    @patch.object(pi, "_call_bridge", return_value={"passed": True, "qualityGate": {"passed": True, "violations": []}, "processors": {"ran": True, "success": True, "processorCount": 3, "details": [{"name": "p1", "success": True}, {"name": "p2", "success": True}, {"name": "p3", "success": False, "error": "failed"}]}})
-    def test_pre_processor_partial_failure(self, mock_bridge):
-        """Pre-processors with partial failure still count as ran."""
-        pi._on_pre_tool_call("write_file", {"path": "a.ts"}, "t1")
-        self.assertEqual(pi._session_stats["pre_processor_runs"], 1)
-
-
-class TestSlashCommandEdgeCases(unittest.TestCase):
-    """Edge cases for the slash command handler."""
-
-    def test_unknown_command_defaults_to_status(self):
-        """Unknown args default to status."""
-        with patch.object(pi, "_call_bridge", return_value={"framework": "loaded", "version": "1.0", "components": {}}) as m:
-            pi._xray_command("something-random")
-            m.assert_called_once_with({"command": "health"}, timeout=10)
-
-    def test_case_insensitive(self):
-        """Command arg is lowercased."""
-        o = pi._xray_command(" STATS ")
-        self.assertIn("Session", o)
-
-
-class TestLogToFileTimestamps(unittest.TestCase):
-    """Verify log file formatting."""
-
-    def test_log_entry_has_iso_timestamp(self):
-        """Every log entry should start with an ISO timestamp."""
-        import re
-        with tempfile.TemporaryDirectory() as td:
-            log_dir = Path(td)
-            original = pi.LOG_DIR
-            pi.LOG_DIR = log_dir
-
-            pi._log_to_file("test.log", "[test] message")
-            content = (log_dir / "test.log").read_text()
-            # ISO timestamp: 2026-03-27T17:00:00Z or similar
-            self.assertTrue(re.match(r"\d{4}-\d{2}-\d{2}T", content.split(" ")[0]))
-
-            pi.LOG_DIR = original
-
-
-class TestPostToolCallDuration(unittest.TestCase):
-    """Test that duration is correctly extracted from results."""
-
-    def setUp(self):
-        pi._session_stats["post_processor_runs"] = 0
-
-    @patch.object(pi, "_call_bridge", return_value={"processors": {"ran": False}})
-    def test_duration_extracted_from_result_dict(self, mock_bridge):
-        """Duration from result dict is logged correctly."""
-        # We verify the post hook doesn't crash with duration in result
-        pi._on_post_tool_call("write_file", {"path": "a.ts"}, {"duration": 1234, "success": True}, "t1")
-        # No crash = pass
-
-    @patch.object(pi, "_call_bridge", return_value={"processors": {"ran": False}})
-    def test_non_dict_result_no_crash(self, mock_bridge):
-        """Non-dict result doesn't crash the hook."""
-        pi._on_post_tool_call("write_file", {"path": "a.ts"}, "string result", "t1")
-
-    @patch.object(pi, "_call_bridge", return_value={"processors": {"ran": False}})
-    def test_none_result_no_crash(self, mock_bridge):
-        """None result doesn't crash the hook."""
-        pi._on_post_tool_call("write_file", {"path": "a.ts"}, None, "t1")
-
-
-class TestBridgeHelperTimeoutDefault(unittest.TestCase):
-    """Verify bridge timeout defaults."""
-
-    def test_default_timeout(self):
-        """_bridge_call defaults to 30s timeout."""
-        with patch("subprocess.run") as m:
-            m.return_value = MagicMock(returncode=0, stdout='{"ok":true}', stderr="")
-            tools_mod._bridge_call({"command": "health"})
-            self.assertEqual(m.call_args[1]["timeout"], 30)
-
-    def test_custom_timeout(self):
-        """_bridge_call respects custom timeout."""
-        with patch("subprocess.run") as m:
-            m.return_value = MagicMock(returncode=0, stdout='{"ok":true}', stderr="")
-            tools_mod._bridge_call({"command": "health"}, timeout=5)
-            self.assertEqual(m.call_args[1]["timeout"], 5)
-
-
-class TestXrayHooksTool(unittest.TestCase):
-    """Tests for the xray_hooks tool."""
-
-    def test_list_via_bridge(self):
-        """list action uses bridge when available."""
-        with patch.object(tools_mod, "_bridge_call", return_value={
-            "status": "ok", "action": "list",
-            "hooks": {"managed": ["pre-commit"], "missing": [], "external": [], "stale": []},
-        }) as m:
-            r = json.loads(tools_mod.xray_hooks({"action": "list"}))
-            self.assertEqual(r["status"], "ok")
-            self.assertEqual(r["via"], "bridge")
-            m.assert_called_once()
-            call_cmd = m.call_args[0][0]
-            self.assertEqual(call_cmd["command"], "hooks")
-            self.assertEqual(call_cmd["action"], "list")
-
-    def test_install_via_bridge(self):
-        """install action uses bridge."""
-        with patch.object(tools_mod, "_bridge_call", return_value={
-            "status": "ok", "action": "install", "installed": ["pre-commit", "post-commit"],
-            "skipped": [], "errors": [],
-        }) as m:
-            r = json.loads(tools_mod.xray_hooks({"action": "install"}))
-            self.assertEqual(r["via"], "bridge")
-            self.assertEqual(len(r["result"]["installed"]), 2)
-
-    def test_uninstall_via_bridge(self):
-        """uninstall action uses bridge."""
-        with patch.object(tools_mod, "_bridge_call", return_value={
-            "status": "ok", "action": "uninstall", "removed": ["pre-commit"], "restored": [],
-        }) as m:
-            r = json.loads(tools_mod.xray_hooks({"action": "uninstall"}))
-            self.assertEqual(r["via"], "bridge")
-
-    def test_bridge_error_fallback(self):
-        """Falls back to file-based when bridge errors."""
-        with patch.object(tools_mod, "_bridge_call", return_value={"error": "node not found"}):
-            # Without a real git repo, should return error
-            r = json.loads(tools_mod.xray_hooks({"action": "list"}))
-            self.assertIn("via", r)
-
-    def test_specific_hooks(self):
-        """Can request specific hooks."""
-        with patch.object(tools_mod, "_bridge_call", return_value={
-            "status": "ok", "action": "list",
-            "hooks": {"managed": [], "missing": ["pre-commit"], "external": [], "stale": []},
-        }) as m:
-            tools_mod.xray_hooks({"action": "list", "hooks": ["pre-commit"]})
-            call_cmd = m.call_args[0][0]
-            self.assertEqual(call_cmd["hooks"], ["pre-commit"])
-
-    def test_status_defaults_to_list(self):
-        """status action works like list."""
-        with patch.object(tools_mod, "_bridge_call", return_value={
-            "status": "ok", "action": "status",
-            "hooks": {"managed": [], "missing": [], "external": [], "stale": []},
-        }) as m:
-            r = json.loads(tools_mod.xray_hooks({"action": "status"}))
-            self.assertEqual(r["status"], "ok")
-            m.assert_called_once()
-
-    def test_default_action_is_list(self):
-        """Missing action defaults to list."""
-        with patch.object(tools_mod, "_bridge_call", return_value={
-            "status": "ok", "action": "list",
-            "hooks": {"managed": [], "missing": [], "external": [], "stale": []},
-        }) as m:
-            tools_mod.xray_hooks({})
-            call_cmd = m.call_args[0][0]
-            self.assertEqual(call_cmd["action"], "list")
-
-
-class TestXrayHooksSchema(unittest.TestCase):
-    """Tests for the XRAY_HOOKS schema."""
-
-    def test_schema_has_required_fields(self):
-        s = schemas.XRAY_HOOKS
-        self.assertEqual(s["name"], "xray_hooks")
-        self.assertIn("action", s["parameters"]["properties"])
-        self.assertIn("hooks", s["parameters"]["properties"])
-        self.assertIn("action", s["parameters"]["required"])
-
-    def test_action_enum(self):
-        s = schemas.XRAY_HOOKS
-        action = s["parameters"]["properties"]["action"]
-        self.assertIn("install", action["enum"])
-        self.assertIn("uninstall", action["enum"])
-        self.assertIn("list", action["enum"])
-        self.assertIn("status", action["enum"])
-
-    def test_hooks_enum(self):
-        s = schemas.XRAY_HOOKS
-        hooks = s["parameters"]["properties"]["hooks"]
-        self.assertIn("pre-commit", hooks["items"]["enum"])
-        self.assertIn("post-commit", hooks["items"]["enum"])
-        self.assertIn("pre-push", hooks["items"]["enum"])
-        self.assertIn("post-push", hooks["items"]["enum"])
-
-    def test_description_mentions_hooks(self):
-        s = schemas.XRAY_HOOKS
-        self.assertIn("git hooks", s["description"])
-
-
-class TestRegisterIntegrationV2_1(unittest.TestCase):
-    """Test that register() wires all 4 tools and 2 hooks in v2.2."""
-
-    def test_wires_four_tools(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        names = [c[1]["name"] for c in ctx.register_tool.call_args_list]
-        self.assertEqual(set(names), {
-            "xray_validate", "xray_codex_check",
-            "xray_health", "xray_hooks",
-        })
-
-    def test_xray_hooks_schema_wired(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        sm = {c[1]["name"]: c[1]["schema"] for c in ctx.register_tool.call_args_list}
-        self.assertIs(sm["xray_hooks"], schemas.XRAY_HOOKS)
-
-    def test_xray_hooks_handler_wired(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        hm = {c[1]["name"]: c[1]["handler"] for c in ctx.register_tool.call_args_list}
-        self.assertIs(hm["xray_hooks"], tools_mod.xray_hooks)
-
-    def test_registers_two_hooks(self):
-        ctx = MagicMock()
-        pi.register(ctx)
-        hook_names = [c[0][0] for c in ctx.register_hook.call_args_list]
-        self.assertIn("pre_tool_call", hook_names)
-        self.assertIn("post_tool_call", hook_names)
-
-    def test_survives_missing_session_hook(self):
-        """Session hook should fail gracefully if not supported."""
-        ctx = MagicMock()
-        def side_effect(*args):
-            raise AttributeError("not available")
-        ctx.register_hook.side_effect = [None, None, side_effect]
-        pi.register(ctx)  # should not raise
-
-    def test_v2_2_log_message(self):
-        ctx = MagicMock()
-        with self.assertLogs("xray-hermes", level="INFO") as cm:
-            pi.register(ctx)
-        self.assertTrue(any("v2.2" in m for m in cm.output))
-        self.assertTrue(any("4 tools" in m for m in cm.output))
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)