0xray 3.1.0 → 3.1.1

package/dist/inference/inference-cycle.js

@@ -328,7 +328,7 @@ export class InferenceCycle {
         try {
             let agentName = p.type === "refactor" ? "refactorer" : "code-reviewer";
             // In pure MCP mode, use real skill server names so the orchestrator dispatches to actual MCP tools
-            if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true') {
+            if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
                 agentName = p.type === "refactor" ? "refactoring-strategies" : "code-review";
             }
             await this.invokeAgentInternal(agentName, prompt);
@@ -353,11 +353,11 @@ export class InferenceCycle {
             ``,
             `1. Read the relevant source files`,
             `2. Add the missing guard, validation, or edge case handling`,
-            `3. If this is a codex rule, add the term to .opencode/xray/codex.json`,
+            `3. If this is a codex rule, add the term to .xray/codex.json`,
             `4. Make minimal, surgical changes`,
         ].join("\n");
         try {
-            const agentName = process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true'
+            const agentName = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true'
                 ? "code-review"
                 : "code-reviewer";
             await this.invokeAgentInternal(agentName, prompt);
@@ -388,7 +388,7 @@ export class InferenceCycle {
             `3. Implement it if straightforward, otherwise describe the design`,
         ].join("\n");
         try {
-            const agentName = process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true'
+            const agentName = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true'
                 ? "architecture-patterns"
                 : "architect";
             await this.invokeAgentInternal(agentName, prompt);
@@ -455,7 +455,7 @@ Respond with EXACTLY one of:
     async governProposals(proposals) {
         // Primary path: Use the first-class Governance MCP (real skill servers + required Dynamo)
         // This is the clean, centralized path (governance.server.ts + GovernanceService)
-        const useGovernanceMcp = process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true' ||
+        const useGovernanceMcp = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true' ||
             this.isGovernanceMcpPreferred();
         if (useGovernanceMcp) {
             try {
@@ -488,7 +488,7 @@ Respond with EXACTLY one of:
                     error: err instanceof Error ? err.message : String(err),
                 });
                 // In forced pure MCP mode we must not silently fall back
-                if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true') {
+                if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
                     throw err;
                 }
                 // In normal mode, fall back to legacy path with deprecation warning.
@@ -552,7 +552,7 @@ Respond with EXACTLY one of:
      */
     async governProposalsInternal(proposals) {
         // Defensive: if pure MCP mode is forced, use individual skill servers only
-        if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true') {
+        if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
             return this.governProposalsWithIndividualSkills(proposals);
         }
         const coordinator = this.getCoordinator();
@@ -633,7 +633,7 @@ Respond with EXACTLY one of:
     }
     /**
      * Pure individual knowledge-skill MCP path for governance.
-     * Used when STRRAY_FORCE_MCP_GOVERNANCE=true.
+     * Used when XRAY_FORCE_MCP_GOVERNANCE=true.
      * Each proposal is evaluated directly by the relevant skill servers using analyze_proposal.
      */
     async governProposalsWithIndividualSkills(proposals) {
@@ -801,7 +801,7 @@ Respond with EXACTLY one of:
                 responseText = JSON.stringify(result);
             }
             // In pure MCP governance mode, trust the orchestrator response (it now does real work)
-            const isPureMcp = process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true';
+            const isPureMcp = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true';
             const hasRealContent = /PROPOSAL:\s*\d+/i.test(responseText) ||
                 /DECISION:\s*(approve|reject|abstain)/i.test(responseText) ||
                 /Agent Outputs \(real MCP responses\):/i.test(responseText);
@@ -830,7 +830,7 @@ Respond with EXACTLY one of:
             return this.agentInvoker(agentName, prompt);
         }
         // Only fall back to OpenCode if not in forced pure MCP mode
-        if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === 'true') {
+        if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
             throw new Error(`[PURE MCP] Orchestrator returned no usable response for agent "${agentName}" and OpenCode fallback is disabled`);
         }
         return this.invokeViaOpencode(agentName, prompt);
@@ -975,7 +975,7 @@ Respond with EXACTLY one of:
         return texts.join("\n").trim();
     }
     resolveOpencodeRoot() {
-        // Use the provider-agnostic config path resolver (prefers .xray/, falls back to .opencode/xray/)
+        // Use the provider-agnostic config path resolver (prefers .xray/)
         const configDir = getConfigDir(this.projectRoot);
         // If we resolved to a .xray or custom dir, use its parent as the "root"
         if (configDir.includes(".xray") || configDir.includes("xray")) {

package/dist/integrations/base/README.md

@@ -21,7 +21,7 @@ src/integrations/
 │   ├── ExampleIntegration.ts  # Example implementation
 │   └── index.ts           # Module exports
 ├── core/                  # Core framework integrations
-│   └── strray-integration.ts  # Cross-framework integration
+│   └── xray-integration.ts  # Cross-framework integration
 └── openclaw/              # External service integrations
     ├── index.ts
     ├── client.ts

package/dist/integrations/enforcement-gate.js

@@ -48,7 +48,7 @@ async function loadV3PostProcessor() {
     if (global.xrayPostProcessor && typeof global.xrayPostProcessor.executePostProcessorLoop === "function") {
         return global.xrayPostProcessor;
     }
-    // strRayPostProcessor fallback removed in v2.2
+    // xrayPostProcessor fallback removed in v2.2
     return null;
 }
 // ── Context Builder ────────────────────────────────────────────
@@ -302,7 +302,7 @@ async function loadStateManager() {
     const global = globalThis;
     if (global.xrayStateManager)
         return global.xrayStateManager;
-    // strRayStateManager fallback removed in v2.2
+    // xrayStateManager fallback removed in v2.2
     const candidatePaths = [
         () => import("../state/state-manager.js"),
         () => import("../../node_modules/0xray/dist/state/state-manager.js"),

package/dist/integrations/governance/index.js

@@ -283,7 +283,7 @@ export class InferenceGovernanceIntegration extends BaseIntegration {
      */
     async loadConfig() {
         try {
-            const configPath = path.join(process.cwd(), '.opencode', 'strray', 'features.json');
+            const configPath = path.join(process.cwd(), '.xray', 'features.json');
             if (!fs.existsSync(configPath)) {
                 await this.log('warning', 'features.json not found, using defaults');
                 return;

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,10 @@ 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()}")
 
     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
   ];
 
@@ -582,7 +582,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 +626,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 +665,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 +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}` };
   }

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):