0xray 2.0.1 → 2.1.0

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

@@ -1,4 +1,4 @@
-"""StringRay Hermes Plugin — full framework pipeline integration.
+"""Xray Hermes Plugin — full framework pipeline integration.
 
 Mirrors the OpenCode xray-codex-injection.ts behavior:
   1. Captures ALL tool calls and logs to disk
@@ -29,24 +29,30 @@ except ImportError:
     schemas = importlib.import_module("schemas")
     tools = importlib.import_module("tools")
 
-logger = logging.getLogger("strray-hermes")
+logger = logging.getLogger("xray-hermes")
 
 # ── Paths ─────────────────────────────────────────────────────
 
 PLUGIN_DIR = Path(__file__).resolve().parent
 BRIDGE_PATH = PLUGIN_DIR / "bridge.mjs"
 
-# Project root: find the StringRay project directory
+# Project root: find the Xray project directory
 # The plugin lives at ~/.hermes/plugins/ which is NOT inside any project tree,
 # so walking up from PLUGIN_DIR will never find the project. Instead:
-#   1. Check STRRAY_PROJECT_ROOT env var (explicit override)
-#   2. Walk up from cwd looking for node_modules/0xray or strray-ai (consumer install)
+#   1. Check XRAY_PROJECT_ROOT env var (explicit override)
+#   2. Walk up from cwd looking for node_modules/0xray (consumer install)
+
+def _find_project_root():
+    cwd = os.getcwd()
+    home = Path.home()
+    d = Path(cwd).resolve()
+    while True:
         ...
         # node_modules/0xray — consumer install marker
-        if (d / "node_modules" / "0xray" / "package.json").exists() or (d / "node_modules" / "strray-ai" / "package.json").exists():
+        if (d / "node_modules" / "0xray" / "package.json").exists():
             return d
-        # .opencode/strray — dev repo marker
-        if (d / ".opencode" / "strray" / "features.json").exists():
+        # .opencode/xray — dev repo marker
+        if (d / ".opencode" / "xray" / "features.json").exists():
             return d
         # package.json but not home dir
         if d != home and (d / "package.json").exists():
@@ -79,20 +85,20 @@ _TOOL_AGENT_MAP = {
     "delegate_task": ("orchestrator",  "delegation"),
 }
 
-# Tools where StringRay has a better alternative
+# Tools where Xray has a better alternative
 # terminal: only nudge when the command looks lint/security/search related
-_BETTER_WITH_STRRAY = {
-    "search_files": "Use mcp_strray_researcher_search_codebase for code pattern searches",
+_BETTER_WITH_XRAY = {
+    "search_files": "Use mcp_xray_researcher_search_codebase for code pattern searches",
 }
 
 # Patterns that suggest the terminal command should use an MCP tool instead
 _TERMINAL_NUDGE_PATTERNS = {
-    "grep": "Use mcp_strray_researcher_search_codebase instead of grep",
-    "rg ": "Use mcp_strray_researcher_search_codebase instead of ripgrep",
-    "eslint": "Use mcp_strray_lint_lint instead of raw eslint",
-    "npx eslint": "Use mcp_strray_lint_lint instead of raw eslint",
-    "npm audit": "Use mcp_strray_security_scan_security_scan instead of npm audit",
-    "yarn audit": "Use mcp_strray_security_scan_security_scan instead of yarn audit",
+    "grep": "Use mcp_xray_researcher_search_codebase instead of grep",
+    "rg ": "Use mcp_xray_researcher_search_codebase instead of ripgrep",
+    "eslint": "Use mcp_xray_lint_lint instead of raw eslint",
+    "npx eslint": "Use mcp_xray_lint_lint instead of raw eslint",
+    "npm audit": "Use mcp_xray_security_scan_security_scan instead of npm audit",
+    "yarn audit": "Use mcp_xray_security_scan_security_scan instead of yarn audit",
     "find ": "Use search_files(target='files') instead of find",
     "sed ": "Use patch tool instead of sed",
     "awk ": "Use patch tool instead of awk",
@@ -108,7 +114,7 @@ _session_stats = {
     "session_id": None,
     "code_operations": 0,
     "total_tool_calls": 0,
-    "strray_mcp_calls": 0,
+    "xray_mcp_calls": 0,
     "native_tool_calls": 0,
     "quality_gate_runs": 0,
     "quality_gate_blocks": 0,
@@ -184,8 +190,8 @@ def _call_bridge(command: dict, timeout: int = 10) -> dict:
 
 # ── Hook: pre_tool_call ───────────────────────────────────────
 
-def _is_strray_mcp(tool_name: str) -> bool:
-    return tool_name.startswith("mcp_strray_")
+def _is_xray_mcp(tool_name: str) -> bool:
+    return tool_name.startswith("mcp_xray_")
 
 
 def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
@@ -195,17 +201,17 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
       1. Track stats
       2. Log tool-start event to disk
       3. For code-producing tools: run quality gate + pre-processors via bridge
-      4. For non-code tools: nudge if StringRay alternative exists
+      4. For non-code tools: nudge if Xray alternative exists
     """
     _session_stats["total_tool_calls"] += 1
 
     # Log start event
     _log_tool_event("start", tool_name, args)
 
-    # StringRay MCP tools — track but don't interfere
-    if _is_strray_mcp(tool_name):
-        _session_stats["strray_mcp_calls"] += 1
-        _log_to_file("activity.log", f"[quality-gate] SKIP (strray-mcp): {tool_name}")
+    # Xray MCP tools — track but don't interfere
+    if _is_xray_mcp(tool_name):
+        _session_stats["xray_mcp_calls"] += 1
+        _log_to_file("activity.log", f"[quality-gate] SKIP (xray-mcp): {tool_name}")
         return
 
     # delegate_task: snapshot working tree so post_hook can validate changes
@@ -252,7 +258,7 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
                 _log_to_file("activity.log",
                     f"[quality-gate] BLOCKED: tool={tool_name} violations={violation_msg}")
                 logger.warning(
-                    "[strray] Quality gate BLOCKED %s: %s",
+                    "[xray] Quality gate BLOCKED %s: %s",
                     tool_name, violation_msg,
                 )
             else:
@@ -277,10 +283,10 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
                 f"[bridge] ERROR in pre-process: {bridge_result.get('error', 'unknown')}")
         return
 
-    # Non-code tools: nudge for StringRay alternatives
-    if tool_name in _BETTER_WITH_STRRAY:
-        tip = _BETTER_WITH_STRRAY[tool_name]
-        logger.info("[strray] Tip: %s — %s", tool_name, tip)
+    # Non-code tools: nudge for Xray alternatives
+    if tool_name in _BETTER_WITH_XRAY:
+        tip = _BETTER_WITH_XRAY[tool_name]
+        logger.info("[xray] Tip: %s — %s", tool_name, tip)
         _log_to_file("activity.log",
             f"[nudge] {tool_name}: {tip}")
 
@@ -290,7 +296,7 @@ def _on_pre_tool_call(tool_name: str, args: dict, task_id: str, **kwargs):
         if isinstance(cmd, str):
             for pattern, tip in _TERMINAL_NUDGE_PATTERNS.items():
                 if pattern in cmd:
-                    logger.info("[strray] Tip: %s — %s", tool_name, tip)
+                    logger.info(                    "[xray] Tip: %s — %s", tool_name, tip)
                     _log_to_file("activity.log",
                         f"[nudge] {tool_name}: {tip}")
                     break
@@ -378,14 +384,14 @@ def _on_post_tool_call(tool_name: str, args: dict, result, task_id: str, **kwarg
     if calls - _last_tune_tool_call_count >= _INFERENCE_TUNE_INTERVAL:
         _last_tune_tool_call_count = calls
         logger.info(
-            "[strray] Triggering inference tuning cycle (tool call #%d)", calls
+            "[xray] Triggering inference tuning cycle (tool call #%d)", calls
         )
         _log_to_file("activity.log",
             f"[inference-tune] auto-cycle at tool call #{calls}")
         try:
             _run_inference_tune()
         except Exception as e:
-            logger.warning("[strray] Inference tuning failed: %s", e)
+            logger.warning("[xray] Inference tuning failed: %s", e)
 
 
 # ── Hook: session_start ───────────────────────────────────────
@@ -394,7 +400,7 @@ def _on_session_start(session_id: str, platform: str, **kwargs):
     """Fires when a new session starts. Resets stats, logs to disk."""
     _session_stats["started_at"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
     _session_stats["session_id"] = session_id
-    for key in ("code_operations", "total_tool_calls", "strray_mcp_calls",
+    for key in ("code_operations", "total_tool_calls", "xray_mcp_calls",
                 "native_tool_calls", "quality_gate_runs", "quality_gate_blocks",
                 "pre_processor_runs", "post_processor_runs",
                 "bridge_calls", "bridge_errors",
@@ -406,23 +412,23 @@ def _on_session_start(session_id: str, platform: str, **kwargs):
     _ensure_log_dir()
     _log_to_file("activity.log",
         f"[session-start] session={session_id} platform={platform}")
-    logger.info("[strray] Session %s started on %s", session_id, platform)
+    logger.info("[xray] Session %s started on %s", session_id, platform)
 
 
 # ── Slash command ─────────────────────────────────────────────
 
-def _strray_command(args: str) -> str:
-    """Slash command handler: /strray [status|stats|help]"""
+def _xray_command(args: str) -> str:
+    """Slash command handler: /xray [status|stats|help]"""
     cmd = (args or "status").strip().lower()
 
     if cmd == "stats":
         return (
-            f"StringRay Session Stats\n"
+            f"Xray Session Stats\n"
             f"  Session: {_session_stats['session_id'] or 'N/A'}\n"
             f"  Started: {_session_stats['started_at'] or 'N/A'}\n"
             f"  Tool calls: {_session_stats['total_tool_calls']}\n"
             f"  Code operations: {_session_stats['code_operations']}\n"
-            f"  StringRay MCP: {_session_stats['strray_mcp_calls']}\n"
+            f"  Xray MCP: {_session_stats['xray_mcp_calls']}\n"
             f"  Native tools: {_session_stats['native_tool_calls']}\n"
             f"  Quality gate runs: {_session_stats['quality_gate_runs']}\n"
             f"  Quality gate blocks: {_session_stats['quality_gate_blocks']}\n"
@@ -437,19 +443,19 @@ def _strray_command(args: str) -> str:
 
     if cmd == "help":
         return (
-            "StringRay Commands:\n"
-            "  /strray status — Plugin and framework health\n"
-            "  /strray stats  — Session pipeline statistics\n"
-            "  /strray help   — This message"
+            "Xray Commands:\n"
+            "  /xray status — Plugin and framework health\n"
+            "  /xray stats  — Session pipeline statistics\n"
+            "  /xray help   — This message"
         )
 
     # Default: status (calls bridge health)
     bridge_result = _call_bridge({"command": "health"}, timeout=10)
     if "error" in bridge_result:
-        return f"StringRay plugin loaded. Bridge: {bridge_result['error']}"
+        return f"Xray plugin loaded. Bridge: {bridge_result['error']}"
 
     return (
-        f"StringRay Hermes Plugin Status\n"
+        f"Xray Hermes Plugin Status\n"
         f"  Framework: {bridge_result.get('framework', 'unknown')}\n"
         f"  Version: {bridge_result.get('version', 'unknown')}\n"
         f"  Quality Gate: {'ready' if bridge_result.get('components', {}).get('qualityGate') else 'not loaded'}\n"
@@ -518,7 +524,7 @@ def _record_tool_outcome(tool_name: str, args: dict, success: bool):
         with open(_OUTCOMES_PATH, "w") as f:
             json.dump(outcomes, f, indent=2)
     except Exception as e:
-        logger.debug("[strray] outcome recording failed: %s", e)
+        logger.debug("[xray] outcome recording failed: %s", e)
 
 
 # ── Inference tuning (auto-calibration) ────────────────────────
@@ -560,7 +566,7 @@ def _run_inference_tune():
 # ── Registration ──────────────────────────────────────────────
 
 # ── Subagent (delegate_task) enforcement ────────────────────
-# Subagents bypass all StringRay hooks because they run in isolated
+# Subagents bypass all Xray hooks because they run in isolated
 # contexts. We enforce by snapshotting the working tree before dispatch
 # and validating all changed files after return.
 
@@ -647,7 +653,7 @@ def _validate_subagent_changes(task_id: str, **kwargs):
                 f"[subagent-validate] BLOCKED: {rel_path} "
                 f"violations={'; '.join(str(v) for v in violations[:3])}")
             logger.warning(
-                "[strray] Subagent BLOCKED %s: %s",
+                "[xray] Subagent BLOCKED %s: %s",
                 rel_path, violations[:3],
             )
         else:
@@ -659,28 +665,28 @@ def register(ctx):
     """Wire schemas to handlers and register lifecycle hooks."""
     # ── Register tools ────────────────────────────────────────
     ctx.register_tool(
-        name="strray_validate",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_VALIDATE,
-        handler=tools.strray_validate,
+        name="xray_validate",
+        toolset="0xray-hermes",
+        schema=schemas.XRAY_VALIDATE,
+        handler=tools.xray_validate,
     )
     ctx.register_tool(
-        name="strray_codex_check",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_CODEX_CHECK,
-        handler=tools.strray_codex_check,
+        name="xray_codex_check",
+        toolset="0xray-hermes",
+        schema=schemas.XRAY_CODEX_CHECK,
+        handler=tools.xray_codex_check,
     )
     ctx.register_tool(
-        name="strray_health",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_HEALTH,
-        handler=tools.strray_health,
+        name="xray_health",
+        toolset="0xray-hermes",
+        schema=schemas.XRAY_HEALTH,
+        handler=tools.xray_health,
     )
     ctx.register_tool(
-        name="strray_hooks",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_HOOKS,
-        handler=tools.strray_hooks,
+        name="xray_hooks",
+        toolset="0xray-hermes",
+        schema=schemas.XRAY_HOOKS,
+        handler=tools.xray_hooks,
     )
 
     # ── Register hooks ────────────────────────────────────────
@@ -691,28 +697,28 @@ def register(ctx):
     try:
         ctx.register_hook("on_session_start", _on_session_start)
     except (AttributeError, TypeError):
-        logger.debug("[strray] on_session_start hook not yet available")
+        logger.debug("[xray] on_session_start hook not yet available")
 
     # ── Register slash command ────────────────────────────────
     try:
         ctx.register_command(
-            name="strray",
-            handler=_strray_command,
-            description="StringRay status, stats, hooks, and enforcement info",
+            name="xray",
+            handler=_xray_command,
+            description="Xray status, stats, hooks, and enforcement info",
             args_hint="[status|stats|help]",
             aliases=("sr",),
         )
     except (AttributeError, TypeError):
-        logger.debug("[strray] Slash command registration not yet available")
+        logger.debug("[xray] Slash command registration not yet available")
 
     # ── Bootstrap ─────────────────────────────────────────────
     _ensure_log_dir()
     _log_to_file("activity.log",
-        f"[plugin-loaded] StringRay Hermes Plugin v2.2 — "
+        f"[plugin-loaded] Xray Hermes Plugin v2.2 — "
         f"4 tools, 2 hooks, subagent enforcement, bridge={BRIDGE_PATH.exists()}")
 
     logger.info(
-        "[strray] Plugin v2.2 loaded: 4 tools, 2 hooks, "
+        "[xray] Plugin v2.2 loaded: 4 tools, 2 hooks, "
         "subagent enforcement active, bridge=%s",
         BRIDGE_PATH.exists(),
     )

package/dist/integrations/hermes-agent/after-install.md

@@ -1,4 +1,4 @@
-# StringRay Hermes Plugin Installed
+# Xray Hermes Plugin Installed
 
 **Restart your Hermes session** for the plugin to take effect.
 
@@ -6,10 +6,10 @@
 
 | Component | Description |
 |-----------|-------------|
-| `strray_validate` | Pre-commit validation with quality gates |
-| `strray_codex_check` | Code review against 60 Codex error-prevention rules |
-| `strray_health` | Framework health check |
-| `strray_hooks` | Git hooks management (install, uninstall, list, status) |
+| `xray_validate` | Pre-commit validation with quality gates |
+| `xray_codex_check` | Code review against 60 Codex error-prevention rules |
+| `xray_health` | Framework health check |
+| `xray_hooks` | Git hooks management (install, uninstall, list, status) |
 | `pre_tool_call` hook | Quality gates + nudges before every tool call |
 | `post_tool_call` hook | Post-processors after every tool call |
 
@@ -27,24 +27,24 @@ The plugin can install git hooks for automated validation:
 ### Install Hooks
 
 ```
-/strray hooks install
+/xray hooks install
 ```
 
 Or use the tool directly:
 ```
-strray_hooks(action="install")
+xray_hooks(action="install")
 ```
 
 ### Check Hook Status
 
 ```
-/strray hooks status
+/xray hooks status
 ```
 
 ### Uninstall Hooks
 
 ```
-/strray hooks uninstall
+/xray hooks uninstall
 ```
 
 ## Quick Test
@@ -52,20 +52,20 @@ strray_hooks(action="install")
 After restarting Hermes, try:
 
 ```
-/strray status
-/strray stats
+/xray status
+/xray stats
 ```
 
-Or use the tools directly — `strray_health` will confirm the bridge is connected.
+Or use the tools directly — `xray_health` will confirm the bridge is connected.
 
 ## MCP Servers
 
-The plugin works alongside StringRay's MCP servers (if configured in your
+The plugin works alongside Xray's MCP servers (if configured in your
 Hermes config). The plugin's native tools provide offline/offline-first
 validation, while MCP servers offer deeper framework integration.
 
 ## Files
 
-The plugin lives at `~/.hermes/plugins/strray-hermes/`. It is auto-updated
+The plugin lives at `~/.hermes/plugins/xray-hermes/`. It is auto-updated
 when you run `npm install` or `npm update` in a project with `0xray`
 as a dependency.

package/dist/integrations/hermes-agent/bridge.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * StringRay Framework Bridge for Hermes Agent
+ * Xray Framework Bridge for Hermes Agent
  *
- * Provides direct access to StringRay framework components
+ * Provides direct access to Xray framework components
  * (ProcessorManager, QualityGate, StateManager) from Python.
  * Uses JSON stdin/stdout protocol for IPC.
  *
@@ -237,7 +237,7 @@ async function runProcessors(tool, args, phase, projectRoot, logDir) {
   const logger = new BridgeLogger(logDir);
 
   try {
-    const stateDir = join(projectRoot, ".strray", "state");
+    const stateDir = join(projectRoot, ".xray", "state");
     const stateManager = new StrRayStateManager(stateDir);
     const processorManager = new ProcessorManager(stateManager);
 
@@ -575,7 +575,7 @@ function handleHooks(input, projectRoot) {
   const { action, hooks } = input;
   const hookTypes = hooks || ["pre-commit", "post-commit", "pre-push", "post-push"];
   const gitHooksDir = join(projectRoot, ".git", "hooks");
-  const strrayHooksDir = join(projectRoot, "hooks");
+  const xrayHooksDir = join(projectRoot, "hooks");
 
   if (!existsSync(gitHooksDir)) {
     return { error: "Not a git repository — no .git/hooks directory" };
@@ -587,7 +587,7 @@ function handleHooks(input, projectRoot) {
   if (action === "list" || action === "status") {
     for (const hookName of hookTypes) {
       const gitHook = join(gitHooksDir, hookName);
-      const strrayHook = join(strrayHooksDir, hookName);
+      const xrayHook = join(xrayHooksDir, hookName);
 
       if (!existsSync(gitHook)) {
         result.missing.push(hookName);
@@ -604,8 +604,8 @@ function handleHooks(input, projectRoot) {
         }
       }
 
-      // Check if strray source hook exists
-      if (!existsSync(strrayHook)) {
+      // Check if xray source hook exists
+      if (!existsSync(xrayHook)) {
         result.stale.push(hookName);
       }
     }
@@ -615,7 +615,7 @@ function handleHooks(input, projectRoot) {
       action,
       hooks: result,
       gitHooksDir,
-      strrayHooksDir,
+      xrayHooksDir,
     };
   }
 
@@ -626,7 +626,7 @@ function handleHooks(input, projectRoot) {
     const errors = [];
 
     for (const hookName of hookTypes) {
-      const src = join(strrayHooksDir, hookName);
+      const src = join(xrayHooksDir, hookName);
       const dst = join(gitHooksDir, hookName);
 
       if (!existsSync(src)) {
@@ -635,11 +635,11 @@ function handleHooks(input, projectRoot) {
       }
 
       try {
-        // Backup existing non-strray hooks
+        // Backup existing non-xray hooks
         if (existsSync(dst)) {
           const content = readFileSync(dst, "utf-8");
           if (!content.includes("StringRay") && !content.includes("strray") && !content.includes("run-hook.js")) {
-            renameSync(dst, `${dst}.strray-backup`);
+            renameSync(dst, `${dst}.xray-backup`);
           } else {
             unlinkSync(dst);
           }
@@ -671,15 +671,15 @@ function handleHooks(input, projectRoot) {
 
     for (const hookName of hookTypes) {
       const dst = join(gitHooksDir, hookName);
-      const backup = `${dst}.strray-backup`;
+      const backup = `${dst}.xray-backup`;
 
       if (!existsSync(dst)) continue;
 
       try {
         const content = readFileSync(dst, "utf-8");
-        const isStrray = content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js");
+        const isXray = content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js");
 
-        if (isStrray || lstatSync(dst).isSymbolicLink()) {
+        if (isXray || lstatSync(dst).isSymbolicLink()) {
           unlinkSync(dst);
 
           // Restore backup if exists

package/dist/integrations/hermes-agent/logs/framework/routing-outcomes.json

@@ -0,0 +1 @@
+[]

package/dist/integrations/hermes-agent/plugin.yaml

@@ -1,12 +1,12 @@
-name: strray-hermes
+name: 0xray-hermes
 version: 2.2.0
 description: 0xRay AI integration plugin — auto-enforcement hooks, quality gates, git hooks, and tool awareness for Hermes Agent
 author: 0xRay AI
 provides_tools:
-  - strray_validate
-  - strray_codex_check
-  - strray_health
-  - strray_hooks
+  - xray_validate
+  - xray_codex_check
+  - xray_health
+  - xray_hooks
 provides_hooks:
   - pre_tool_call
   - post_tool_call

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

@@ -1,9 +1,9 @@
 """Tool schemas — what the LLM sees."""
 
-STRRAY_VALIDATE = {
-    "name": "strray_validate",
+XRAY_VALIDATE = {
+    "name": "xray_validate",
     "description": (
-        "Run StringRay pre-commit validation on specified files. "
+        "Run Xray pre-commit validation on specified files. "
         "Checks codex compliance, rule validation, and quality gates. "
         "Use this before committing any code changes. Returns pass/fail "
         "with actionable remediation for any violations."
@@ -26,8 +26,8 @@ STRRAY_VALIDATE = {
     },
 }
 
-STRRAY_CODEX_CHECK = {
-    "name": "strray_codex_check",
+XRAY_CODEX_CHECK = {
+    "name": "xray_codex_check",
     "description": (
         "Validate code against the Universal Development Codex (60 error-prevention terms). "
         "Checks error-handling, type-safety, performance, security, and architecture patterns. "
@@ -57,12 +57,12 @@ STRRAY_CODEX_CHECK = {
     },
 }
 
-STRRAY_HEALTH = {
-    "name": "strray_health",
+XRAY_HEALTH = {
+    "name": "xray_health",
     "description": (
-        "Run StringRay framework health check. Returns version, agent count, "
+        "Run Xray framework health check. Returns version, agent count, "
         "MCP server status, and enforcement statistics. Use to verify the "
-        "StringRay integration is working correctly."
+        "Xray integration is working correctly."
     ),
     "parameters": {
         "type": "object",
@@ -70,10 +70,10 @@ STRRAY_HEALTH = {
     },
 }
 
-STRRAY_HOOKS = {
-    "name": "strray_hooks",
+XRAY_HOOKS = {
+    "name": "xray_hooks",
     "description": (
-        "Manage StringRay git hooks (install, uninstall, list, status). "
+        "Manage Xray git hooks (install, uninstall, list, status). "
         "Installs pre-commit, post-commit, pre-push, and post-push hooks "
         "that run TypeScript validation, Codex checks, and monitoring. "
         "Use 'install' to set up all hooks, 'list' to see current status."