0xray 3.1.0 → 3.2.0

package/dist/integrations/grok/grok-cli.js

@@ -1,5 +1,5 @@
 /**
- * Grok CLI Integration for StringRay / 0xRay
+ * Grok CLI Integration for 0xRay
  *
  * This module provides the integration points for using 0xRay with the official Grok CLI.
  *
@@ -18,6 +18,7 @@ import { frameworkLogger } from '../../core/framework-logger.js';
 import fs from 'fs';
 import path from 'path';
 import { execSync } from 'child_process';
+import { syncBuiltinSkills } from '../../cli/commands/skill-install.js';
 // ESM-compatible __dirname (this file is compiled to ESM)
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 export async function installForGrokCLI(options = {}) {
@@ -47,6 +48,13 @@ export async function installForGrokCLI(options = {}) {
         fs.cpSync(sourceDir, targetPluginDir, { recursive: true, force: true });
         frameworkLogger.log('grok-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
         console.log(`\x1b[32m✓ Copied Grok plugin to ${targetPluginDir}\x1b[0m`);
+        // Sync builtin skills to Grok plugin skills dir
+        const grokSkillsDir = path.join(targetPluginDir, 'skills');
+        const skillsCopied = syncBuiltinSkills(grokSkillsDir);
+        if (skillsCopied > 0) {
+            console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to Grok plugin\x1b[0m`);
+        }
+        frameworkLogger.log('grok-integration', 'skills-synced', 'info', { count: skillsCopied });
         // Attempt auto-trust (best effort)
         try {
             execSync(`grok plugins trust "${targetPluginDir}"`, { stdio: 'ignore' });
@@ -59,15 +67,21 @@ export async function installForGrokCLI(options = {}) {
         // Register MCP servers via grok mcp add (most reliable mechanism)
         const govMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/governance.server.js');
         const skillsMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/knowledge-skills/skill-invocation.server.js');
+        const orchMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/orchestrator.server.js');
+        const enforcerMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/enforcer-tools.server.js');
         try {
-            execSync(`grok mcp add strray-governance --command node --args "${govMcpPath}" --env "STRRAY_FORCE_MCP_GOVERNANCE=true" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            execSync(`grok mcp add strray-skills --command node --args "${skillsMcpPath}" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
-            console.log('\x1b[32m✓ Registered strray MCP servers with Grok CLI\x1b[0m');
+            execSync(`grok mcp add xray-governance --command node --args "${govMcpPath}" --env "XRAY_FORCE_MCP_GOVERNANCE=true" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            execSync(`grok mcp add xray-skills --command node --args "${skillsMcpPath}" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            execSync(`grok mcp add xray-orchestrator --command node --args "${orchMcpPath}" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            execSync(`grok mcp add xray-enforcer --command node --args "${enforcerMcpPath}" --env "XRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            console.log('\x1b[32m✓ Registered xray MCP servers with Grok CLI\x1b[0m');
         }
         catch {
             console.log('\nCould not auto-register MCP servers. Run manually:');
-            console.log(`  grok mcp add strray-governance --command node --args "${govMcpPath}"`);
-            console.log(`  grok mcp add strray-skills --command node --args "${skillsMcpPath}"`);
+            console.log(`  grok mcp add xray-governance --command node --args "${govMcpPath}"`);
+            console.log(`  grok mcp add xray-skills --command node --args "${skillsMcpPath}"`);
+            console.log(`  grok mcp add xray-orchestrator --command node --args "${orchMcpPath}"`);
+            console.log(`  grok mcp add xray-enforcer --command node --args "${enforcerMcpPath}"`);
         }
         console.log('\n✅ 0xRay is now installed as a first-class Grok CLI plugin!');
         console.log('Restart Grok or run `grok` to load the new hooks and MCP servers.');

package/dist/integrations/grok/hooks/pre-tool-use.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Grok CLI PreToolUse Hook Handler for StringRay (0xRay) — First Class Citizen
+ * Grok CLI PreToolUse Hook Handler for 0xRay — First Class Citizen
  *
  * Real governance enforcement hook.
  * When Grok is about to execute a tool (write_file, edit, terminal cmd, etc.),
@@ -16,7 +16,7 @@ function findGovernanceCore() {
   const here = path.dirname(new URL(import.meta.url).pathname);
 
   // Priority: explicit dev root
-  const devRoot = process.env.STRRAY_ROOT;
+  const devRoot = process.env.XRAY_ROOT;
   if (devRoot) {
     const devCandidate = path.resolve(devRoot, 'dist/governance/governance-core.js');
     if (fs.existsSync(devCandidate)) return devCandidate;
@@ -49,7 +49,7 @@ function walkUpForCore(startDir, maxLevels = 8) {
     if (fs.existsSync(pkgPath)) {
       try {
         const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        if (pkg.name === 'strray-ai' || pkg.name === 'stringray' || pkg.name === '0xray') {
+        if (pkg.name === '0xray') {
           results.push(path.resolve(current, 'dist/governance/governance-core.js'));
           results.push(path.resolve(current, 'governance/governance-core.js'));
         }

package/dist/integrations/grok/plugin/0xray/.mcp.json

@@ -1,23 +1,35 @@
 {
   "mcpServers": {
-    "0xray-governance": {
+    "xray-governance": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "governance"],
       "env": {
         "XRAY_FORCE_MCP_GOVERNANCE": "true"
       }
     },
-    "0xray-skills": {
+    "xray-skills": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "skills"]
     },
-    "0xray-orchestrator": {
+    "xray-orchestrator": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "orchestrator"]
     },
-    "0xray-enforcer": {
+    "xray-enforcer": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "enforcer"]
+    },
+    "xray-researcher": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "researcher"]
+    },
+    "xray-code-review": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "code-review"]
+    },
+    "xray-architect-tools": {
+      "command": "npx",
+      "args": ["-y", "0xray", "mcp", "architect-tools"]
     }
   }
 }

package/dist/integrations/grok/plugin/0xray/hooks/hooks.json

@@ -8,7 +8,7 @@
             "type": "command",
             "command": "node",
             "args": [
-              "${STRRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js"
+              "${XRAY_AI_PATH:-node_modules/0xray}/dist/integrations/grok/hooks/pre-tool-use.js"
             ],
             "timeout": 30000
           }
@@ -21,7 +21,7 @@
           {
             "type": "command",
             "command": "echo",
-            "args": ["[0xRay] Grok session started with StringRay governance enabled"]
+            "args": ["[0xRay] Grok session started with 0xRay governance enabled"]
           }
         ]
       }

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

@@ -36,25 +36,24 @@ logger = logging.getLogger("xray-hermes")
 PLUGIN_DIR = Path(__file__).resolve().parent
 BRIDGE_PATH = PLUGIN_DIR / "bridge.mjs"
 
-# 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 XRAY_PROJECT_ROOT env var (explicit override)
-#   2. Walk up from cwd looking for node_modules/0xray (consumer install)
-        ...
-        # node_modules/0xray — consumer install marker
-        if (d / "node_modules" / "0xray" / "package.json").exists() or (d / "node_modules" / "0xray" / "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/xray — dev repo marker
-        if (d / ".opencode" / "xray" / "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()
@@ -682,6 +681,18 @@ def register(ctx):
         schema=schemas.XRAY_HOOKS,
         handler=tools.xray_hooks,
     )
+    ctx.register_tool(
+        name="xray_skill_install",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_SKILL_INSTALL,
+        handler=tools.xray_skill_install,
+    )
+    ctx.register_tool(
+        name="xray_skill_registry",
+        toolset="xray-hermes",
+        schema=schemas.XRAY_SKILL_REGISTRY,
+        handler=tools.xray_skill_registry,
+    )
 
     # ── Register hooks ────────────────────────────────────────
     ctx.register_hook("pre_tool_call", _on_pre_tool_call)
@@ -709,10 +720,14 @@ def register(ctx):
     _ensure_log_dir()
     _log_to_file("activity.log",
         f"[plugin-loaded] Xray Hermes Plugin v2.2 — "
-        f"4 tools, 2 hooks, subagent enforcement, bridge={BRIDGE_PATH.exists()}")
+        f"6 tools, 2 hooks, subagent enforcement, bridge={BRIDGE_PATH.exists()}")
+
+    # Log session-start since on_session_start may not fire in oneshot mode
+    _log_to_file("activity.log",
+        f"[session-start] session={session_id}")
 
     logger.info(
-        "[xray] 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/bridge.mjs

@@ -58,7 +58,7 @@ function findProjectRoot() {
 
   const candidates = [
     process.cwd(),
-    join(homedir(), "dev", "stringray"),
+    join(homedir(), "dev", "xray"),
     join(dirname(__dirname), "..", "..", "..", ".."), // plugin dir -> project root
   ];
 
@@ -98,6 +98,30 @@ function logToActivity(logDir, message) {
   }
 }
 
+function logRoutingOutcome(logDir, outcome) {
+  try {
+    const routingPath = join(logDir, "routing-outcomes.json");
+    let entries = [];
+    if (existsSync(routingPath)) {
+      try { entries = JSON.parse(readFileSync(routingPath, "utf-8")); } catch { entries = []; }
+    }
+    if (!Array.isArray(entries)) entries = [];
+    entries.push({
+      taskId: outcome.taskId || `bridge-${Date.now()}`,
+      taskDescription: outcome.taskDescription || outcome.tool || "unknown",
+      routedAgent: outcome.routedAgent || "direct",
+      routedSkill: outcome.routedSkill || outcome.tool || "unknown",
+      confidence: outcome.confidence || 0.8,
+      success: outcome.success !== false,
+      routingMethod: outcome.routingMethod || "bridge",
+      timestamp: new Date().toISOString(),
+    });
+    writeFileSync(routingPath, JSON.stringify(entries, null, 2), "utf-8");
+  } catch {
+    // Silent fail
+  }
+}
+
 function logToolEvent(logDir, eventType, tool, args = {}, result = null) {
   try {
     const eventsPath = join(logDir, "plugin-tool-events.log");
@@ -430,6 +454,15 @@ async function handlePostProcess(input, projectRoot, logDir) {
 
   logToActivity(logDir, `post-process: complete duration=${duration}ms processors=${processorResult.success}`);
 
+  // Log routing outcome for test verification
+  logRoutingOutcome(logDir, {
+    tool,
+    taskDescription: `[post-process] ${tool}`,
+    routedAgent: "bridge",
+    routedSkill: tool,
+    success: processorResult.success !== false,
+  });
+
   return {
     duration,
     processors: processorResult,
@@ -582,7 +615,7 @@ function handleHooks(input, projectRoot) {
       } else {
         try {
           const content = readFileSync(gitHook, "utf-8");
-          if (content.includes("Xray") || content.includes("xray") || 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);
@@ -626,7 +659,7 @@ function handleHooks(input, projectRoot) {
         // Backup existing non-xray hooks
         if (existsSync(dst)) {
           const content = readFileSync(dst, "utf-8");
-          if (!content.includes("Xray") && !content.includes("xray") && !content.includes("strray") && !content.includes("run-hook.js")) {
+          if (!content.includes("Xray") && !content.includes("xray") && !false && !content.includes("run-hook.js")) {
             renameSync(dst, `${dst}.xray-backup`);
           } else {
             unlinkSync(dst);
@@ -665,7 +698,7 @@ function handleHooks(input, projectRoot) {
 
       try {
         const content = readFileSync(dst, "utf-8");
-        const isXray = content.includes("Xray") || content.includes("xray") || content.includes("strray") || content.includes("run-hook.js");
+        const isXray = content.includes("Xray") || content.includes("xray") || false || content.includes("run-hook.js");
 
         if (isXray || lstatSync(dst).isSymbolicLink()) {
           unlinkSync(dst);
@@ -743,8 +776,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
@@ -800,6 +862,10 @@ async function main() {
   const projectRoot = findProjectRoot();
   const logDir = ensureLogDir(projectRoot);
 
+  // Log session start for test verification
+  const sessionId = `bridge-${Date.now()}`;
+  logToActivity(logDir, `session-start: session=${sessionId} source=bridge`);
+
   // Lazy-load framework on first call
   if (!frameworkReady && !frameworkLoadAttempted) {
     await loadFramework(projectRoot);
@@ -836,6 +902,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}` };
   }

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

@@ -70,6 +70,55 @@ XRAY_HEALTH = {
     },
 }
 
+XRAY_SKILL_INSTALL = {
+    "name": "xray_skill_install",
+    "description": (
+        "Install skills from the registry or any git repo. "
+        "Downloads skill definitions for specialized capabilities "
+        "like UI/UX design, mobile development, security auditing, etc. "
+        "Use this to add new skills to your development environment."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "source": {
+                "type": "string",
+                "description": "Source name or git URL to install skills from",
+            },
+        },
+        "required": ["source"],
+    },
+}
+
+XRAY_SKILL_REGISTRY = {
+    "name": "xray_skill_registry",
+    "description": (
+        "Manage the skills registry — list available sources, "
+        "add new sources, or remove existing ones. Use 'list' to see "
+        "all available skill sources, 'add' to register a new source, "
+        "'remove' to unregister an existing source."
+    ),
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["list", "add", "remove"],
+                "description": "Registry action to perform",
+            },
+            "name": {
+                "type": "string",
+                "description": "Source name (required for add/remove)",
+            },
+            "url": {
+                "type": "string",
+                "description": "Repository URL (required for add)",
+            },
+        },
+        "required": ["action"],
+    },
+}
+
 XRAY_HOOKS = {
     "name": "xray_hooks",
     "description": (

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

@@ -81,7 +81,7 @@ class TestSchemas(unittest.TestCase):
             self.assertTrue(len(schema["description"]) > 20, f"{name}")
 
 
-class TestRunStrrayHelper(unittest.TestCase):
+class TestRunXrayHelper(unittest.TestCase):
     """Test the CLI fallback helper (still exists for bridge-less environments)."""
 
     def test_successful_command(self):
@@ -143,7 +143,7 @@ class TestBridgeHelper(unittest.TestCase):
             self.assertIn("timed out", r["error"])
 
 
-class TestStrrayHealth(unittest.TestCase):
+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:
@@ -165,7 +165,7 @@ class TestStrrayHealth(unittest.TestCase):
             self.assertEqual(r["status"], "ok")
 
 
-class TestStrrayValidate(unittest.TestCase):
+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:
@@ -208,7 +208,7 @@ class TestStrrayValidate(unittest.TestCase):
             self.assertEqual(r["files_checked"], 100)
 
 
-class TestStrrayCodexCheck(unittest.TestCase):
+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:
@@ -656,7 +656,7 @@ class TestLiveBridge(unittest.TestCase):
         if not bridge_path.exists():
             self.skipTest("bridge.mjs not built yet")
 
-        # Use stringray dev repo as project root (has package.json)
+        # Use xray dev repo as project root (has package.json)
         xray_root = str(Path(PLUGIN_DIR).parent.parent.parent / "dev" / "xray")
         cwd = xray_root if Path(xray_root).exists() else PLUGIN_DIR
 
@@ -945,7 +945,7 @@ class TestBridgeHelperTimeoutDefault(unittest.TestCase):
             self.assertEqual(m.call_args[1]["timeout"], 5)
 
 
-class TestStrrayHooksTool(unittest.TestCase):
+class TestXrayHooksTool(unittest.TestCase):
     """Tests for the xray_hooks tool."""
 
     def test_list_via_bridge(self):
@@ -1018,7 +1018,7 @@ class TestStrrayHooksTool(unittest.TestCase):
             self.assertEqual(call_cmd["action"], "list")
 
 
-class TestStrrayHooksSchema(unittest.TestCase):
+class TestXrayHooksSchema(unittest.TestCase):
     """Tests for the XRAY_HOOKS schema."""
 
     def test_schema_has_required_fields(self):

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

@@ -2,13 +2,40 @@
 
 v2.0: Now uses the Node.js bridge for real framework integration.
 Falls back to CLI (npx 0xray) when bridge is unavailable.
+"""
+
+import json
+import subprocess
+import shutil
+import os
+from pathlib import Path
+from . import schemas
+
+def _bridge_call(command: dict, timeout: int = 10) -> dict:
+    """Call the Hermes bridge via subprocess stdin."""
+    from . import _call_bridge
+    return _call_bridge(command, timeout)
+
+def _run_xray(args: list, timeout: int = 30) -> str:
+    """Fallback: run npx 0xray CLI command."""
+    try:
+        result = subprocess.run(
             ["npx", "0xray"] + args,
+            capture_output=True, text=True, timeout=timeout,
+        )
+        return result.stdout
+    except FileNotFoundError:
         return json.dumps({"error": "0xray not found. Run: npm install -g 0xray"})
     except subprocess.TimeoutExpired:
         return json.dumps({"error": f"Command timed out after {timeout}s"})
     except Exception as e:
         return json.dumps({"error": str(e)})
 
+def _get_project_root() -> str:
+    """Find project root (used in fallback mode)."""
+    from . import PROJECT_ROOT
+    return str(PROJECT_ROOT)
+
 
 # ── Tool: xray_validate ─────────────────────────────────────
 
@@ -189,7 +216,7 @@ def xray_hooks(args: dict, **kwargs) -> str:
             else:
                 try:
                     content = git_hook.read_text()[:500]
-                    if "Xray" in content or "xray" in content or "strray" in content or "run-hook.js" in content:
+                    if "Xray" in content or "xray" in content or False or "run-hook.js" in content:
                         result["managed"].append(hook_name)
                     else:
                         result["external"].append(hook_name)
@@ -212,7 +239,7 @@ def xray_hooks(args: dict, **kwargs) -> str:
                 if dst.exists():
                     try:
                         content = dst.read_text()[:500]
-                        if "Xray" not in content and "xray" not in content and "strray" not in content:
+                        if "Xray" not in content and "xray" not in content:
                             dst.rename(dst.with_suffix(".xray-backup"))
                         else:
                             dst.unlink()
@@ -238,7 +265,7 @@ def xray_hooks(args: dict, **kwargs) -> str:
                 continue
             try:
                 content = dst.read_text()[:500]
-                is_xray = "Xray" in content or "xray" in content or "strray" in content or "run-hook.js" in content
+                is_xray = "Xray" in content or "xray" in content or False or "run-hook.js" in content
                 if is_xray or dst.is_symlink():
                     dst.unlink()
                     if backup.exists():
@@ -251,3 +278,80 @@ def xray_hooks(args: dict, **kwargs) -> str:
         return json.dumps({"status": "ok", "action": "uninstall", "removed": removed, "restored": restored, "via": "fallback"})
 
     return json.dumps({"error": f"Unknown action: {action}", "via": "fallback"})
+
+
+# ── Tool: xray_skill_install ─────────────────────────────────
+
+def xray_skill_install(args: dict, **kwargs) -> str:
+    """Install skills from registry or git repo via bridge."""
+    source = args.get("source", "")
+
+    if not source:
+        return json.dumps({"error": "No source specified for skill install"})
+
+    bridge_result = _bridge_call({
+        "command": "skill-install",
+        "source": source,
+    }, timeout=120)
+
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "source": source,
+            "output": bridge_result.get("output", ""),
+            "via": "bridge",
+        })
+
+    # Fallback to CLI
+    result = _run_xray(["skill:install", source], timeout=120)
+    try:
+        parsed = json.loads(result)
+        if "error" in parsed:
+            return json.dumps(parsed)
+    except json.JSONDecodeError:
+        pass
+    return json.dumps({
+        "status": "ok",
+        "source": source,
+        "output": result.strip(),
+        "via": "cli",
+    })
+
+
+# ── Tool: xray_skill_registry ───────────────────────────────
+
+def xray_skill_registry(args: dict, **kwargs) -> str:
+    """Manage skill registry sources via bridge."""
+    action = args.get("action", "list")
+    name = args.get("name", "")
+    url = args.get("url", "")
+
+    bridge_args = {"command": "skill-registry", "action": action}
+    if name:
+        bridge_args["source"] = name
+    if url:
+        bridge_args["url"] = url
+
+    bridge_result = _bridge_call(bridge_args, timeout=30)
+
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "action": action,
+            "output": bridge_result.get("output", ""),
+            "via": "bridge",
+        })
+
+    # Fallback to CLI
+    cli_args = ["skill:registry", action]
+    if name:
+        cli_args.extend(["--name", name])
+    if url:
+        cli_args.extend(["--url", url])
+    result = _run_xray(cli_args, timeout=30)
+    return json.dumps({
+        "status": "ok",
+        "action": action,
+        "output": result.strip(),
+        "via": "cli",
+    })

package/dist/integrations/openclaw/README.md

@@ -37,7 +37,7 @@ npm install ws
 
 ### 2. Configure OpenClaw
 
-Create `.strray/config/openclaw.json`:
+Create `.xray/config/openclaw.json`:
 
 ```json
 {
@@ -82,11 +82,11 @@ const integration = await initializeOpenClawIntegration('/path/to/config.json',
 
 After installation, use these commands in any OpenClaw channel:
 
-- `/strray` - Show status
-- `/strray-analyze <file>` - Analyze code
-- `/strray-code <file>` - Code review
-- `/strray-file <file>` - Read file
-- `/strray-exec <command>` - Execute command
+- `/xray` - Show status
+- `/xray-analyze <file>` - Analyze code
+- `/xray-code <file>` - Code review
+- `/xray-file <file>` - Read file
+- `/xray-exec <command>` - Execute command
 
 ## Configuration
 

package/dist/integrations/openclaw/api-server.js

@@ -4,7 +4,6 @@
  * HTTP API server that OpenClaw skills call to invoke 0xRay capabilities.
  * This is the bridge between OpenClaw skills and 0xRay.
  *
- * @version 1.0.0
  * @since 2026-03-14
  */
 import * as crypto from 'crypto';

package/dist/integrations/openclaw/client.js

@@ -4,7 +4,6 @@
  * Implements OpenClaw Gateway Protocol v3 with proper request/response handling,
  * reconnection logic, and event management.
  *
- * @version 1.0.0
  * @since 2026-03-14
  */
 import { WebSocket } from 'ws';