0xray 3.0.14 → 3.1.1

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,32 +29,31 @@ 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
-# 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)
-        ...
-        # node_modules/0xray — consumer install marker
-        if (d / "node_modules" / "0xray" / "package.json").exists() or (d / "node_modules" / "strray-ai" / "package.json").exists():
+def _find_project_root() -> Path:
+    """Walk up from cwd to find project root."""
+    cwd = Path.cwd()
+    home = Path.home()
+    override = os.environ.get("XRAY_PROJECT_ROOT")
+    if override:
+        return Path(override).resolve()
+    d = cwd
+    while True:
+        if (d / "node_modules" / "0xray" / "package.json").exists():
             return d
-        # .opencode/strray — dev repo marker
-        if (d / ".opencode" / "strray" / "features.json").exists():
+        if (d / ".xray" / "features.json").exists():
             return d
-        # package.json but not home dir
         if d != home and (d / "package.json").exists():
             return d
         d = d.parent
         if d == d.parent:
             break
-
     return cwd
 
 PROJECT_ROOT = _find_project_root()
@@ -79,20 +78,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 +107,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 +183,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 +194,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 +251,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 +276,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 +289,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 +377,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 +393,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 +405,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 +436,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,13 +517,13 @@ 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) ────────────────────────
 
 def _run_inference_tune():
-    """Shell out to strray-ai inference:tuner --run-once.
+    """Shell out to 0xray inference:tuner --run-once.
 
     Runs in a background thread so it doesn't block the tool call pipeline.
     The tuner reads routing outcomes, runs the analytics pipeline, and
@@ -560,7 +559,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 +646,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 +658,40 @@ 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="xray-hermes",
+        schema=schemas.XRAY_VALIDATE,
+        handler=tools.xray_validate,
+    )
+    ctx.register_tool(
+        name="xray_codex_check",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_CODEX_CHECK,
+        handler=tools.xray_codex_check,
+    )
+    ctx.register_tool(
+        name="xray_health",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_HEALTH,
+        handler=tools.xray_health,
     )
     ctx.register_tool(
-        name="strray_codex_check",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_CODEX_CHECK,
-        handler=tools.strray_codex_check,
+        name="xray_hooks",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_HOOKS,
+        handler=tools.xray_hooks,
     )
     ctx.register_tool(
-        name="strray_health",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_HEALTH,
-        handler=tools.strray_health,
+        name="xray_skill_install",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_SKILL_INSTALL,
+        handler=tools.xray_skill_install,
     )
     ctx.register_tool(
-        name="strray_hooks",
-        toolset="strray-hermes",
-        schema=schemas.STRRAY_HOOKS,
-        handler=tools.strray_hooks,
+        name="xray_skill_registry",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_SKILL_REGISTRY,
+        handler=tools.xray_skill_registry,
     )
 
     # ── Register hooks ────────────────────────────────────────
@@ -691,28 +702,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"4 tools, 2 hooks, subagent enforcement, bridge={BRIDGE_PATH.exists()}")
+        f"[plugin-loaded] Xray Hermes Plugin v2.2 — "
+        f"6 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: 6 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.
  *
@@ -44,7 +44,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 // ── Framework components (lazy-loaded) ───────────────────────
 let ProcessorManager = null;
-let StrRayStateManager = null;
+let XrayStateManager = null;
 let featuresConfigLoader = null;
 let runQualityGateWithLogging = null;
 let enforcerValidators = null;
@@ -53,12 +53,12 @@ let frameworkLoadAttempted = false;
 
 // ── Project root detection ───────────────────────────────────
 function findProjectRoot() {
-  const envHome = process.env.STRRAY_HOME;
+  const envHome = process.env.XRAY_HOME;
   if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
 
   const candidates = [
     process.cwd(),
-    join(homedir(), "dev", "stringray"),
+    join(homedir(), "dev", "xray"),
     join(dirname(__dirname), "..", "..", "..", ".."), // plugin dir -> project root
   ];
 
@@ -67,7 +67,7 @@ function findProjectRoot() {
       const pkgPath = join(dir, "package.json");
       if (existsSync(pkgPath)) {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.name === "strray-ai" || pkg.dependencies?.["strray-ai"] || pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
+        if (pkg.name === "0xray" || pkg.dependencies?.["0xray"] || pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
           return dir;
         }
       }
@@ -149,11 +149,11 @@ async function loadFramework(projectRoot) {
         }
       }
 
-      if (!StrRayStateManager) {
+      if (!XrayStateManager) {
         const smPath = join(distDir, "state", "state-manager.js");
         if (existsSync(smPath)) {
           const sm = await import(smPath);
-          StrRayStateManager = sm.StrRayStateManager;
+          XrayStateManager = sm.XrayStateManager;
         }
       }
 
@@ -230,15 +230,15 @@ async function runQualityGateCheck(context, projectRoot, logDir) {
 
 // ── Processor Pipeline ───────────────────────────────────────
 async function runProcessors(tool, args, phase, projectRoot, logDir) {
-  if (!ProcessorManager || !StrRayStateManager) {
+  if (!ProcessorManager || !XrayStateManager) {
     return { ran: false, reason: "framework modules not loaded" };
   }
 
   const logger = new BridgeLogger(logDir);
 
   try {
-    const stateDir = join(projectRoot, ".strray", "state");
-    const stateManager = new StrRayStateManager(stateDir);
+    const stateDir = join(projectRoot, ".xray", "state");
+    const stateManager = new XrayStateManager(stateDir);
     const processorManager = new ProcessorManager(stateManager);
 
     // Register processors matching OpenCode plugin
@@ -353,7 +353,7 @@ async function handleHealth(input) {
   const components = {
     qualityGate: !!runQualityGateWithLogging,
     processorManager: !!ProcessorManager,
-    stateManager: !!StrRayStateManager,
+    stateManager: !!XrayStateManager,
     featuresConfig: !!featuresConfigLoader,
   };
 
@@ -563,7 +563,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" };
@@ -575,14 +575,14 @@ 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);
       } else {
         try {
           const content = readFileSync(gitHook, "utf-8");
-          if (content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js")) {
+          if (content.includes("Xray") || content.includes("xray") || false || content.includes("run-hook.js")) {
             result.managed.push(hookName);
           } else {
             result.external.push(hookName);
@@ -592,8 +592,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);
       }
     }
@@ -603,7 +603,7 @@ function handleHooks(input, projectRoot) {
       action,
       hooks: result,
       gitHooksDir,
-      strrayHooksDir,
+      xrayHooksDir,
     };
   }
 
@@ -614,7 +614,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)) {
@@ -623,11 +623,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`);
+          if (!content.includes("Xray") && !content.includes("xray") && !false && !content.includes("run-hook.js")) {
+            renameSync(dst, `${dst}.xray-backup`);
           } else {
             unlinkSync(dst);
           }
@@ -659,15 +659,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("Xray") || content.includes("xray") || false || content.includes("run-hook.js");
 
-        if (isStrray || lstatSync(dst).isSymbolicLink()) {
+        if (isXray || lstatSync(dst).isSymbolicLink()) {
           unlinkSync(dst);
 
           // Restore backup if exists
@@ -743,8 +743,37 @@ async function handleApply(input, projectRoot, logDir) {
 // ── Known commands for positional-arg mode ──────────────────
 const KNOWN_COMMANDS = new Set([
   "health", "stats", "pre-process", "post-process", "validate", "codex-check", "hooks", "govern", "apply",
+  "skill-install", "skill-registry",
 ]);
 
+// ── Skill management ──────────────────────────────────────────
+
+async function handleSkillInstall(command, projectRoot, logDir) {
+  try {
+    const source = command.source;
+    if (!source) {
+      return { error: "Missing 'source' — specify a source name or git URL" };
+    }
+    const { execSync } = await import("child_process");
+    const output = execSync(`npx 0xray skill:install "${source}"`, { cwd: projectRoot, timeout: 120000 }).toString();
+    return { status: "ok", output: output.trim() };
+  } catch (error) {
+    return { error: `Skill install failed: ${error.message || error}` };
+  }
+}
+
+async function handleSkillRegistry(command, projectRoot, logDir) {
+  try {
+    const action = command.action || "list";
+    const { execSync } = await import("child_process");
+    const args = command.source ? `"${command.source}"` : "";
+    const output = execSync(`npx 0xray skill:registry ${action} ${args}`, { cwd: projectRoot, timeout: 30000 }).toString();
+    return { status: "ok", output: output.trim() };
+  } catch (error) {
+    return { error: `Skill registry command failed: ${error.message || error}` };
+  }
+}
+
 // ── Main ─────────────────────────────────────────────────────
 async function main() {
   // Parse --cwd flag and detect positional command arg
@@ -836,6 +865,12 @@ async function main() {
     case "apply":
       response = await handleApply(command, projectRoot, logDir);
       break;
+    case "skill-install":
+      response = await handleSkillInstall(command, projectRoot, logDir);
+      break;
+    case "skill-registry":
+      response = await handleSkillRegistry(command, projectRoot, logDir);
+      break;
     default:
       response = { error: `Unknown command: ${cmd}` };
   }