0xray 3.0.14 → 3.1.1

package/dist/governance/llm-governance-provider.js

@@ -0,0 +1,223 @@
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { frameworkLogger } from "../core/framework-logger.js";
+const XAI_ENDPOINT = "https://api.x.ai/v1/chat/completions";
+const XAI_MODEL = "grok-4.3";
+const ROLE_PROMPTS = {
+    "code-review": `You are a senior code reviewer on a governance committee for a software project. Analyze the following proposal from a code quality, maintainability, readability, and engineering best practices perspective.
+
+Consider:
+- Does the proposal improve or degrade code quality?
+- Does it follow established design patterns?
+- Does it introduce technical debt?
+- Are there potential regressions or edge cases?
+
+Respond with a structured vote in exactly this format:
+DECISION: approve|reject|abstain
+CONFIDENCE: <0.0-1.0>
+REASONING: <2-4 sentence analysis of the proposal's code quality implications>`,
+    "security-audit": `You are a senior security engineer on a governance committee for a software project. Analyze the following proposal from a security, threat modeling, and compliance perspective.
+
+Consider:
+- Does the proposal introduce new attack surface?
+- Does it handle authentication, authorization, and data protection properly?
+- Are there compliance implications (GDPR, SOC2, PCI-DSS, etc.)?
+- Does it follow security best practices (input validation, least privilege, defense in depth)?
+
+Respond with a structured vote in exactly this format:
+DECISION: approve|reject|abstain
+CONFIDENCE: <0.0-1.0>
+REASONING: <2-4 sentence analysis of the proposal's security implications>`,
+    "researcher": `You are a senior architect and researcher on a governance committee for a software project. Analyze the following proposal from a codebase-wide architectural and historical perspective.
+
+Consider:
+- Does the proposal align with the project's observed architecture patterns?
+- Does it integrate well with existing systems and data flows?
+- Does it address recurring problems observed in the project history?
+- What is the broader impact on the codebase ecosystem?
+
+Respond with a structured vote in exactly this format:
+DECISION: approve|reject|abstain
+CONFIDENCE: <0.0-1.0>
+REASONING: <2-4 sentence analysis of the proposal's broader project impact>`,
+};
+function readHermesOAuthToken() {
+    try {
+        const authPath = join(homedir(), ".hermes", "auth.json");
+        if (!existsSync(authPath))
+            return null;
+        const raw = readFileSync(authPath, "utf-8");
+        const data = JSON.parse(raw);
+        let entry;
+        if (data && typeof data === "object" && !Array.isArray(data)) {
+            entry = data["xai-oauth"];
+            if (!entry?.access_token && data.access_token) {
+                entry = data;
+            }
+        }
+        if (!entry?.access_token && Array.isArray(data)) {
+            entry = data.find((e) => e.provider === "xai-oauth" || !!e.access_token);
+        }
+        if (!entry?.access_token) {
+            process.stderr.write("[llm] readHermesOAuthToken: no access_token in auth file\n");
+            return null;
+        }
+        if (entry.expires_at && Date.now() / 1000 > entry.expires_at) {
+            frameworkLogger.log("llm-governance", "hermes-token-expired", "warning", { expiresAt: entry.expires_at });
+            return null;
+        }
+        return entry.access_token;
+    }
+    catch (err) {
+        frameworkLogger.log("llm-governance", "hermes-auth-read-error", "warning", { error: String(err) });
+        return null;
+    }
+}
+function getConfig() {
+    const directEndpoint = process.env.XRAY_LLM_ENDPOINT ||
+        process.env.XRAY_GOVERNANCE_LLM_ENDPOINT ||
+        "";
+    const directApiKey = process.env.XRAY_LLM_API_KEY ||
+        process.env.XRAY_GOVERNANCE_LLM_API_KEY ||
+        "";
+    const directModel = process.env.XRAY_LLM_MODEL ||
+        process.env.XRAY_GOVERNANCE_LLM_MODEL ||
+        "gpt-4o";
+    // First try: direct env-var config (highest priority)
+    const directEnabled = process.env.XRAY_GOVERNANCE_LLM_ENABLED === "true" ||
+        process.env.XRAY_LLM_ENABLED === "true";
+    if (directEnabled && directEndpoint && directApiKey) {
+        return { endpoint: directEndpoint, apiKey: directApiKey, model: directModel };
+    }
+    // Second try: Hermes xAI OAuth token from ~/.hermes/auth.json
+    const hermesToken = readHermesOAuthToken();
+    if (hermesToken) {
+        frameworkLogger.log("llm-governance", "using-hermes-oauth", "info", { provider: "xai-oauth", endpoint: XAI_ENDPOINT, model: XAI_MODEL });
+        return { endpoint: XAI_ENDPOINT, apiKey: hermesToken, model: XAI_MODEL };
+    }
+    // Third try: direct endpoint even without explicit enable flag (if endpoint+key set)
+    if (directEndpoint && directApiKey) {
+        return { endpoint: directEndpoint, apiKey: directApiKey, model: directModel };
+    }
+    if (process.env.DEBUG_LLM) {
+        process.stderr.write("[llm-debug] No config found. directEnabled=" + directEnabled + " endpoint=" + !!directEndpoint + " apiKey=" + !!directApiKey + " hermes=" + !!hermesToken + "\n");
+    }
+    return null;
+}
+function parseVote(text) {
+    const decisionMatch = text.match(/DECISION:\s*(approve|reject|abstain)/i);
+    const confidenceMatch = text.match(/CONFIDENCE:\s*([0-9.]+)/i);
+    const reasoningMatch = text.match(/REASONING:\s*(.+)/is);
+    if (!decisionMatch || !decisionMatch[1])
+        return null;
+    const rawConfidence = confidenceMatch?.[1];
+    const confidence = rawConfidence ? parseFloat(rawConfidence) : 0.5;
+    return {
+        decision: decisionMatch[1].toLowerCase(),
+        confidence: isNaN(confidence) ? 0.5 : Math.min(1, Math.max(0, confidence)),
+        reasoning: reasoningMatch?.[1]?.trim() || "No reasoning provided",
+    };
+}
+export async function tryLLMGovernance(role, proposalTitle, proposalDescription, evidence, proposalType) {
+    const config = getConfig();
+    if (!config) {
+        process.stderr.write("[llm] no config for role=" + role + "\n");
+        return null;
+    }
+    process.stderr.write("[llm] using config endpoint=" + config.endpoint + " model=" + config.model + "\n");
+    const systemPrompt = ROLE_PROMPTS[role];
+    const userMessage = `## Proposal
+
+**Title:** ${proposalTitle}
+
+**Description:** ${proposalDescription}
+
+**Type:** ${proposalType}
+
+${evidence.length > 0 ? `**Supporting Evidence:**\n${evidence.map((e, i) => `${i + 1}. ${e}`).join("\n")}` : ""}
+
+---
+
+Please provide your structured vote.`;
+    try {
+        const response = await fetch(config.endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: config.model,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userMessage },
+                ],
+                temperature: 0.3,
+                max_tokens: 500,
+            }),
+        });
+        if (!response.ok) {
+            frameworkLogger.log("llm-governance", "api-call", "error", {
+                status: response.status,
+                statusText: response.statusText,
+                role,
+            });
+            return null;
+        }
+        const data = (await response.json());
+        const choices = data?.choices;
+        const message = choices?.[0]?.message;
+        const content = message?.content;
+        if (!content) {
+            frameworkLogger.log("llm-governance", "parse", "warning", {
+                issue: "missing content in response",
+                role,
+            });
+            return null;
+        }
+        const vote = parseVote(content);
+        if (!vote) {
+            frameworkLogger.log("llm-governance", "parse", "warning", {
+                issue: "unparseable response",
+                snippet: content.slice(0, 200),
+                role,
+            });
+            return null;
+        }
+        frameworkLogger.log("llm-governance", "vote", "success", {
+            role,
+            decision: vote.decision,
+            confidence: vote.confidence,
+        });
+        return vote;
+    }
+    catch (error) {
+        frameworkLogger.log("llm-governance", "error", "error", {
+            error: String(error),
+            role,
+        });
+        return null;
+    }
+}
+export function checkHermesOAuthStatus() {
+    const config = getConfig();
+    if (!config) {
+        const hermesPath = join(homedir(), ".hermes", "auth.json");
+        if (existsSync(hermesPath)) {
+            return {
+                configured: false,
+                error: "Hermes auth file found but no valid xai-oauth token. Run: hermes auth add xai-oauth --no-browser",
+            };
+        }
+        return {
+            configured: false,
+            error: "No Hermes auth file found (~/.hermes/auth.json). Install Hermes and run: hermes auth add xai-oauth --no-browser",
+        };
+    }
+    return {
+        configured: true,
+        endpoint: XAI_ENDPOINT,
+        model: XAI_MODEL,
+    };
+}

package/dist/index.js

@@ -4,17 +4,17 @@
  * This is the main entry point for the 0xRay framework.
  * It exports the core initialization function and key components.
  */
-export { StringRayOrchestrator } from "./orchestrator/orchestrator.js";
-export { StringRayStateManager } from "./state/index.js";
+export { XrayOrchestrator } from "./orchestrator/orchestrator.js";
+export { XrayStateManager } from "./state/index.js";
 export { AgentDelegator } from "./delegation/index.js";
 export { frameworkLogger } from "./core/framework-logger.js";
 export { BUILTIN_CODEX } from "./core/codex-formatter.js";
-import { defaultStringRayConfig } from "./core/index.js";
-export { defaultStringRayConfig };
+import { defaultXrayConfig } from "./core/index.js";
+export { defaultXrayConfig };
 export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
 // Main initialization function
-export function initializeStringRay(config = {}) {
-    const mergedConfig = { ...defaultStringRayConfig, ...config };
+export function initializeXray(config = {}) {
+    const mergedConfig = { ...defaultXrayConfig, ...config };
     // Return a standardized initialization result
     return {
         success: true,

package/dist/inference/deploy-verifier.js

@@ -43,7 +43,7 @@ export class DeployVerifier {
         if (!packCheck.passed) {
             return this.result(false, version, tarballPath, installDir, checks, startTime);
         }
-        installDir = fs.mkdtempSync(path.join(os.tmpdir(), "strray-deploy-verify-"));
+        installDir = fs.mkdtempSync(path.join(os.tmpdir(), "xray-deploy-verify-"));
         const installCheck = this.runCheck("npm-install-fresh", () => {
             this.exec(`npm install ${tarballPath} --no-save`, installDir, 60000);
             return "Fresh install succeeded";

package/dist/inference/inference-cycle.js

@@ -3,7 +3,7 @@ import * as path from "path";
 import { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
 import { DeployVerifier } from "./deploy-verifier.js";
 import { VotingCoordinator } from "../delegation/voting-coordinator.js";
-import { StringRayStateManager } from "../state/state-manager.js";
+import { XrayStateManager } from "../state/state-manager.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { getGovernanceIntegration } from "../integrations/governance/index.js";
 import { featuresConfigLoader } from "../core/features-config.js";
@@ -50,7 +50,7 @@ export class InferenceCycle {
     constructor(projectRoot, agentInvoker, options) {
         this.projectRoot = projectRoot || process.cwd();
         this.inferenceDir = path.join(this.projectRoot, "docs", "inference");
-        this.stateDir = path.join(this.projectRoot, ".strray", "inference");
+        this.stateDir = path.join(this.projectRoot, ".xray", "inference");
         this.agentInvoker = agentInvoker ?? null;
         this.options = options ?? {};
     }
@@ -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/strray/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);
@@ -922,7 +922,7 @@ Respond with EXACTLY one of:
             fs.mkdirSync(this.stateDir, { recursive: true });
         }
         const stateFile = path.join(this.stateDir, "governance-state.json");
-        const stateManager = new StringRayStateManager();
+        const stateManager = new XrayStateManager();
         if (fs.existsSync(stateFile)) {
             try {
                 const data = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
@@ -975,10 +975,10 @@ Respond with EXACTLY one of:
         return texts.join("\n").trim();
     }
     resolveOpencodeRoot() {
-        // Use the provider-agnostic config path resolver (prefers .strray/, falls back to .opencode/strray/)
+        // Use the provider-agnostic config path resolver (prefers .xray/)
         const configDir = getConfigDir(this.projectRoot);
-        // If we resolved to a .strray or custom dir, use its parent as the "root"
-        if (configDir.includes(".strray") || configDir.includes("strray")) {
+        // If we resolved to a .xray or custom dir, use its parent as the "root"
+        if (configDir.includes(".xray") || configDir.includes("xray")) {
             return path.dirname(configDir);
         }
         // Legacy fallback

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"]
           }
         ]
       }