0xray 2.0.1 → 2.1.1

package/dist/core/xray-activation.js

@@ -1,10 +1,10 @@
 /**
- * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks).
+ * 0xRay activation — reads config from .xray/ runtime state directory.
  */
 import { frameworkLogger } from "../core/framework-logger.js";
 import { ensureCriticalComponents } from "../architect/architectural-integrity.js";
 import { validateRegistryConsistency } from "../agents/registry.js";
-export const defaultStringRayConfig = {
+export const defaultXrayConfig = {
     enableOrchestrator: true,
     enableBootOrchestrator: true,
     enableStateManagement: true,
@@ -13,9 +13,9 @@ export const defaultStringRayConfig = {
     enableProcessors: true,
     enablePostProcessor: true,
 };
-export async function activateStringRayFramework(config = {}) {
+export async function activateXrayFramework(config = {}) {
     const jobId = `activation-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-    const activationConfig = { ...defaultStringRayConfig, ...config };
+    const activationConfig = { ...defaultXrayConfig, ...config };
     // Banner display moved to init.sh execution in plugin
     // Framework activation proceeds quietly
     frameworkLogger.log("stringray-activation", "beginning xray framework activation", "info", { jobId, ...activationConfig });
@@ -57,25 +57,25 @@ export async function activateStringRayFramework(config = {}) {
 }
 async function activateCodexInjection(jobId) {
     frameworkLogger.log("stringray-activation", "activating codex injection", "info", { jobId });
-    const { createStringRayCodexInjectorHook } = await import("./codex-injector.js");
-    const hook = createStringRayCodexInjectorHook();
-    globalThis.strRayHooks = globalThis.strRayHooks || [];
-    globalThis.strRayHooks.push(hook);
+    const { createXrayCodexInjectorHook } = await import("./codex-injector.js");
+    const hook = createXrayCodexInjectorHook();
+    globalThis.xrayHooks = globalThis.xrayHooks || [];
+    globalThis.xrayHooks.push(hook);
     frameworkLogger.log("stringray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
 }
 async function activateHooks(jobId) {
     try {
         frameworkLogger.log("stringray-activation", "activating xray hooks", "info", { jobId });
         // Create and register the Codex injector hook
-        const { createStringRayCodexInjectorHook } = await import("./codex-injector");
-        const hook = createStringRayCodexInjectorHook();
+        const { createXrayCodexInjectorHook } = await import("./codex-injector");
+        const hook = createXrayCodexInjectorHook();
         // Store hook globally for OpenCode to pick up
-        globalThis.strRayHooks = globalThis.strRayHooks || [];
-        globalThis.strRayHooks.push(hook);
+        globalThis.xrayHooks = globalThis.xrayHooks || [];
+        globalThis.xrayHooks.push(hook);
         frameworkLogger.log("stringray-activation", "xray hooks activated", "success", {
             jobId,
             hookName: hook.name,
-            hooksRegistered: globalThis.strRayHooks.length
+            hooksRegistered: globalThis.xrayHooks.length
         });
     }
     catch (error) {
@@ -90,15 +90,16 @@ async function activateBootOrchestrator(jobId) {
 }
 async function activateStateManagement(jobId) {
     frameworkLogger.log("stringray-activation", "activating state management", "info", { jobId });
-    const { StringRayStateManager } = await import("../state/state-manager");
-    const stateManager = new StringRayStateManager();
+    const { XrayStateManager } = await import("../state/state-manager");
+    const stateManager = new XrayStateManager();
     // Store the state manager instance globally for framework use
-    globalThis.strRayStateManager = stateManager;
+    globalThis.xrayStateManager = stateManager;
+    globalThis.strRayStateManager = stateManager; // backward compat
     frameworkLogger.log("stringray-activation", "state management activated", "success", { jobId });
 }
 async function activateOrchestrator(jobId) {
     frameworkLogger.log("stringray-activation", "activating xray orchestrator", "info", { jobId });
-    const { strRayOrchestrator } = await import("./orchestrator");
+    const { xrayOrchestrator } = await import("./orchestrator");
     // Also activate the multi-agent orchestration coordinator
     const { multiAgentOrchestrationCoordinator } = await import("../orchestrator/multi-agent-orchestration-coordinator");
     frameworkLogger.log("stringray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
@@ -106,29 +107,33 @@ async function activateOrchestrator(jobId) {
 async function activateProcessors(jobId) {
     frameworkLogger.log("stringray-activation", "activating processor pipeline", "info", { jobId });
     const { ProcessorManager } = await import("../processors/processor-manager");
-    const { StringRayStateManager } = await import("../state/state-manager");
-    const stateManager = new StringRayStateManager();
+    const { XrayStateManager } = await import("../state/state-manager");
+    const stateManager = new XrayStateManager();
     const processorManager = new ProcessorManager(stateManager);
     // Store the processor manager instance globally for framework use
-    globalThis.strRayProcessorManager = processorManager;
+    globalThis.xrayProcessorManager = processorManager;
+    globalThis.strRayProcessorManager = processorManager; // backward compat
     frameworkLogger.log("stringray-activation", "processor pipeline activated", "success", { jobId });
 }
 async function activatePostProcessor(jobId) {
     frameworkLogger.log("stringray-activation", "activating post-processor system", "info", { jobId });
     const { PostProcessor } = await import("../postprocessor/PostProcessor");
     // Get existing state manager (should be initialized by boot orchestrator)
-    const stateManager = globalThis.strRayStateManager;
+    const stateManager = globalThis.xrayStateManager;
     if (!stateManager) {
         throw new Error("State manager not initialized - boot orchestrator must run first");
     }
     const postProcessor = new PostProcessor(stateManager, null, {});
-    globalThis.strRayPostProcessor = postProcessor;
+    globalThis.xrayPostProcessor = postProcessor;
+    globalThis.strRayPostProcessor = postProcessor; // backward compat
     frameworkLogger.log("stringray-activation", "post-processor system activated", "success", { jobId });
     const { pathResolver } = await import("../utils/path-resolver.js");
-    globalThis.strRayPathResolver = pathResolver;
+    globalThis.xrayPathResolver = pathResolver;
+    globalThis.strRayPathResolver = pathResolver; // backward compat
     frameworkLogger.log("stringray-activation", "path resolver activated", "success", { jobId });
     const { CodexInjector } = await import("./codex-injector.js");
     const codexInjector = new CodexInjector();
-    globalThis.strRayCodexInjector = codexInjector;
+    globalThis.xrayCodexInjector = codexInjector;
+    globalThis.strRayCodexInjector = codexInjector; // backward compat
     frameworkLogger.log("stringray-activation", "codex injector activated", "success", { jobId });
 }

package/dist/delegation/agent-delegator.d.ts

@@ -10,7 +10,7 @@
  * @since 2026-01-07
  */
 import { ComplexityScore } from "./complexity-analyzer.js";
-import { StringRayStateManager } from "../state/state-manager.js";
+import { XrayStateManager } from "../state/state-manager.js";
 import { strRayConfigLoader } from "../core/config-loader.js";
 import { type AggregatedMetrics, type MetricsExport } from "./metrics-aggregator.js";
 export interface AgentCapability {
@@ -102,7 +102,7 @@ export declare class AgentDelegator {
     private agentMetrics;
     /** Minimum confidence for a learned mapping to override hardcoded routing. */
     private static readonly MAPPING_CONFIDENCE_THRESHOLD;
-    constructor(stateManager: StringRayStateManager, configLoader: typeof strRayConfigLoader);
+    constructor(stateManager: XrayStateManager, configLoader: typeof strRayConfigLoader);
     /**
      * Load routing-mappings.json from disk (fresh each call — picks up tuner writes).
      * Same path resolution as inference-tuner.ts.
@@ -183,4 +183,4 @@ export declare class AgentDelegator {
     exportMetricsData(format?: "json" | "csv" | "summary"): MetricsExport;
     updateAgentCapability(agentName: string, capabilities: Partial<AgentCapability>): void;
 }
-export declare function createAgentDelegator(stateManager: StringRayStateManager, configLoader: typeof strRayConfigLoader): AgentDelegator;
+export declare function createAgentDelegator(stateManager: XrayStateManager, configLoader: typeof strRayConfigLoader): AgentDelegator;

package/dist/delegation/agent-delegator.js

@@ -45,9 +45,9 @@ export class AgentDelegator {
      */
     loadRoutingMappings() {
         const candidates = [
-            path.resolve(process.cwd(), ".strray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".xray/routing-mappings.json"),
             path.resolve(process.cwd(), "xray/routing-mappings.json"),
-            path.resolve(process.cwd(), ".opencode/strray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".opencode/xray/routing-mappings.json"),
             path.resolve(process.cwd(), "routing-mappings.json"),
         ];
         for (const p of candidates) {
@@ -451,7 +451,7 @@ export class AgentDelegator {
    */
     resolveProjectDirectory() {
         const root = process.cwd();
-        if (fs.existsSync(`${root}/package.json`) || fs.existsSync(`${root}/strray.config.json`)) {
+        if (fs.existsSync(`${root}/package.json`) || fs.existsSync(`${root}/xray.config.json`)) {
             return root;
         }
         let current = root;

package/dist/delegation/metrics-aggregator.d.ts

@@ -7,7 +7,7 @@
  * @version 1.0.0
  * @since 2026-04-16
  */
-import type { StringRayStateManager } from "../state/state-manager.js";
+import type { XrayStateManager } from "../state/state-manager.js";
 export interface DelegationMetricEntry {
     timestamp: number;
     operation: string;
@@ -74,19 +74,19 @@ export interface MetricsExport {
     exportedAt: number;
     entryCount: number;
 }
-export declare function getDelegationMetrics(stateManager: StringRayStateManager): DelegationMetricEntry[];
-export declare function getOrchestrationMetrics(stateManager: StringRayStateManager): OrchestrationMetricEntry[];
-export declare function aggregateDelegationMetrics(stateManager: StringRayStateManager): AggregatedMetrics;
-export declare function aggregateOrchestrationMetrics(stateManager: StringRayStateManager): AggregatedMetrics;
-export declare function summarizeByAgent(stateManager: StringRayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
-export declare function summarizeByComplexityLevel(stateManager: StringRayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
-export declare function summarizeByTimePeriod(stateManager: StringRayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
-export declare function rotateMetrics(stateManager: StringRayStateManager, maxEntries?: number): {
+export declare function getDelegationMetrics(stateManager: XrayStateManager): DelegationMetricEntry[];
+export declare function getOrchestrationMetrics(stateManager: XrayStateManager): OrchestrationMetricEntry[];
+export declare function aggregateDelegationMetrics(stateManager: XrayStateManager): AggregatedMetrics;
+export declare function aggregateOrchestrationMetrics(stateManager: XrayStateManager): AggregatedMetrics;
+export declare function summarizeByAgent(stateManager: XrayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
+export declare function summarizeByComplexityLevel(stateManager: XrayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
+export declare function summarizeByTimePeriod(stateManager: XrayStateManager, type?: "delegation" | "orchestration"): Record<string, unknown>;
+export declare function rotateMetrics(stateManager: XrayStateManager, maxEntries?: number): {
     delegation: number;
     orchestration: number;
 };
-export declare function cleanupOldMetrics(stateManager: StringRayStateManager, olderThan: number): {
+export declare function cleanupOldMetrics(stateManager: XrayStateManager, olderThan: number): {
     delegation: number;
     orchestration: number;
 };
-export declare function exportMetrics(stateManager: StringRayStateManager, format?: "json" | "csv" | "summary"): MetricsExport;
+export declare function exportMetrics(stateManager: XrayStateManager, format?: "json" | "csv" | "summary"): MetricsExport;

package/dist/delegation/session-coordinator.d.ts

@@ -7,7 +7,7 @@
  * @version 1.0.0
  * @since 2026-01-07
  */
-import { StringRayStateManager } from "../state/state-manager.js";
+import { XrayStateManager } from "../state/state-manager.js";
 import { DelegationResult } from "./agent-delegator.js";
 export interface SessionContext {
     sessionId: string;
@@ -63,7 +63,7 @@ export interface SessionMetrics {
 export declare class SessionCoordinator {
     private stateManager;
     private sessions;
-    constructor(stateManager: StringRayStateManager);
+    constructor(stateManager: XrayStateManager);
     /**
      * Get read-only view of all sessions - avoids breaking encapsulation
      */
@@ -130,4 +130,4 @@ export declare class SessionCoordinator {
     cleanupSession(sessionId: string): void;
     private updateSessionMetrics;
 }
-export declare const createSessionCoordinator: (stateManager: StringRayStateManager) => SessionCoordinator;
+export declare const createSessionCoordinator: (stateManager: XrayStateManager) => SessionCoordinator;

package/dist/delegation/voting-coordinator.d.ts

@@ -13,7 +13,7 @@
 import type { VotingSession, VotingResult, StrategySelectionContext, VotingHistoryEntry, VotingMetrics, ConflictResolutionRequest, ConflictResolutionResponse } from "./voting-types.js";
 import { SessionCoordinator } from "./session-coordinator.js";
 import { WeightedVotingAggregator } from "./weighted-voting-aggregator.js";
-import { StringRayStateManager } from "../state/state-manager.js";
+import { XrayStateManager } from "../state/state-manager.js";
 export interface VotingCoordinatorConfig {
     enableHistoryTracking: boolean;
     enableLearning: boolean;
@@ -28,7 +28,7 @@ export declare class VotingCoordinator {
     private metrics;
     private config;
     private aggregator;
-    constructor(stateManager: StringRayStateManager, sessionCoordinator?: SessionCoordinator, config?: Partial<VotingCoordinatorConfig>);
+    constructor(stateManager: XrayStateManager, sessionCoordinator?: SessionCoordinator, config?: Partial<VotingCoordinatorConfig>);
     initiateVoting(sessionId: string, topic: string, description: string, participants: string[], context?: StrategySelectionContext): Promise<string>;
     submitVote(voteId: string, agentName: string, vote: string, confidence: number, reasoning?: string): boolean;
     resolveVoting(voteId: string): VotingResult | null;
@@ -46,4 +46,4 @@ export declare class VotingCoordinator {
     private initializeMetrics;
     private updateMetricsAfterVote;
 }
-export declare const createVotingCoordinator: (stateManager: StringRayStateManager, sessionCoordinator?: SessionCoordinator) => VotingCoordinator;
+export declare const createVotingCoordinator: (stateManager: XrayStateManager, sessionCoordinator?: SessionCoordinator) => VotingCoordinator;

package/dist/enforcement/enforcer-tools.js

@@ -5,7 +5,7 @@
 import { ruleEnforcer, } from "./rule-enforcer.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { AgentDelegator } from "../delegation/agent-delegator.js";
-import { StringRayStateManager } from "../state/state-manager.js";
+import { XrayStateManager } from "../state/state-manager.js";
 import { strRayConfigLoader } from "../core/config-loader.js";
 import * as fs from "fs";
 import * as path from "path";
@@ -325,7 +325,7 @@ async function executeReleaseWorkflow(operation, context, jobId, routing) {
 async function delegateToAgent(agentName, operation, context, jobId) {
     try {
         // Create a minimal state manager and config loader for the delegator
-        const stateManager = new StringRayStateManager();
+        const stateManager = new XrayStateManager();
         // Create the delegator
         const delegator = new AgentDelegator(stateManager, strRayConfigLoader);
         // Build task description for the delegated agent

package/dist/enforcement/loaders/codex-loader.d.ts

@@ -28,7 +28,7 @@ export declare class CodexLoader extends BaseLoader {
     readonly name = "codex";
     /**
      * Path to the codex.json file.
-     * Uses the standard config-paths resolver which checks .strray/, .opencode/strray/, etc.
+      * Uses the standard config-paths resolver which checks .xray/, .opencode/xray/, etc.
      */
     private get codexPath();
     /**

package/dist/enforcement/loaders/codex-loader.js

@@ -30,13 +30,13 @@ export class CodexLoader extends BaseLoader {
     name = "codex";
     /**
      * Path to the codex.json file.
-     * Uses the standard config-paths resolver which checks .strray/, .opencode/strray/, etc.
+      * Uses the standard config-paths resolver which checks .xray/, .opencode/xray/, etc.
      */
     get codexPath() {
         const candidates = resolveCodexPath();
         const found = candidates.find((p) => existsSync(p));
         // Fallback to primary path even if not found yet
-        return found ?? candidates[0] ?? this.resolvePath(".opencode/strray/codex.json");
+        return found ?? candidates[0] ?? this.resolvePath(".opencode/xray/codex.json");
     }
     /**
      * Check if codex.json exists.

package/dist/index.d.ts

@@ -4,16 +4,16 @@
  * 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, XrayOrchestrator as StringRayOrchestrator } from "./orchestrator/orchestrator.js";
+export { XrayStateManager, XrayStateManager as StringRayStateManager } 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, defaultXrayConfig as defaultStringRayConfig };
 export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
 export type { OpenClawIntegrationConfig } from "./integrations/openclaw/types.js";
-export declare function initializeStringRay(config?: {}): {
+export declare function initializeXray(config?: {}): {
     success: boolean;
     config: {
         enableOrchestrator: boolean;

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, XrayOrchestrator as StringRayOrchestrator } from "./orchestrator/orchestrator.js";
+export { XrayStateManager, XrayStateManager as StringRayStateManager } 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, defaultXrayConfig as defaultStringRayConfig };
 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 ?? {};
     }
@@ -353,7 +353,7 @@ 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 .opencode/xray/codex.json`,
             `4. Make minimal, surgical changes`,
         ].join("\n");
         try {
@@ -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/, falls back to .opencode/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

@@ -1,6 +1,6 @@
 # Integration Base System
 
-The Integration Base System provides a standardized foundation for creating and managing StringRay integrations. It includes the `BaseIntegration` class, `IntegrationRegistry`, and supporting types that ensure consistent lifecycle management, event handling, and configuration across all integrations.
+The Integration Base System provides a standardized foundation for creating and managing Xray integrations. It includes the `BaseIntegration` class, `IntegrationRegistry`, and supporting types that ensure consistent lifecycle management, event handling, and configuration across all integrations.
 
 ## Overview
 
@@ -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/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(), '.opencode', 'xray', 'features.json');
             if (!fs.existsSync(configPath)) {
                 await this.log('warning', 'features.json not found, using defaults');
                 return;

package/dist/integrations/grok/grok-cli.d.ts

@@ -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.
  *

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.
  *
@@ -60,14 +60,14 @@ export async function installForGrokCLI(options = {}) {
         const govMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/governance.server.js');
         const skillsMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/knowledge-skills/skill-invocation.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 "STRRAY_FORCE_MCP_GOVERNANCE=true" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            execSync(`grok mcp add xray-skills --command node --args "${skillsMcpPath}" --env "STRRAY_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('\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.),

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

@@ -1,13 +1,13 @@
 {
   "mcpServers": {
-    "strray-governance": {
+    "xray-governance": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "governance"],
       "env": {
-        "STRRAY_FORCE_MCP_GOVERNANCE": "true"
+        "XRAY_FORCE_MCP_GOVERNANCE": "true"
       }
     },
-    "strray-skills": {
+    "xray-skills": {
       "command": "npx",
       "args": ["-y", "0xray", "mcp", "skills"]
     }

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