0xray 2.0.0 → 2.1.0

package/dist/core/boot-orchestrator.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Boot Orchestrator (min documented consumer runtime compat shim from prior StringRay releases; primary Xray* paths + XRAY_||STRRAY_ env + .xray fallbacks only; 1-line per Scope Rule).
+ */
+import { XrayStateManager } from "../state/state-manager.js";
+import { type MemoryStats } from "../monitoring/memory-monitor.js";
+export interface BootSequenceConfig {
+    enableEnforcement: boolean;
+    codexValidation: boolean;
+    sessionManagement: boolean;
+    processorActivation: boolean;
+    agentLoading: boolean;
+}
+export interface BootResult {
+    success: boolean;
+    orchestratorLoaded: boolean;
+    sessionManagementActive: boolean;
+    processorsActivated: boolean;
+    enforcementEnabled: boolean;
+    codexComplianceActive: boolean;
+    agentsLoaded: string[];
+    errors: string[];
+}
+export declare class BootOrchestrator {
+    private contextLoader;
+    private stateManager;
+    private processorManager;
+    private config;
+    private pluginRegistry?;
+    private pluginServerRegistry?;
+    private shutdownInitialized;
+    constructor(config?: Partial<BootSequenceConfig>, stateManager?: XrayStateManager);
+    /**
+     * Initialize delegation system components
+     */
+    private initializeDelegationSystem;
+    private loadProcessorsConfig;
+    /**
+     * Initialize plugin system and register MCP servers
+     */
+    private initializePluginSystem;
+    /**
+     * Load orchestrator as the first component
+     */
+    private loadOrchestrator;
+    /**
+     * Initialize session management system
+     */
+    private initializeSessionManagement;
+    /**
+     * Activate pre/post processors
+     */
+    private activateProcessors;
+    /**
+     * Load remaining agents after orchestrator
+     */
+    private loadRemainingAgents;
+    /**
+     * Enable automatic enforcement activation
+     */
+    private enableEnforcement;
+    /**
+     * Activate codex compliance checking during boot
+     */
+    private activateCodexCompliance;
+    private initializeSecurityComponents;
+    private finalizeSecurityIntegration;
+    private runInitialSecurityAudit;
+    /**
+     * Validate processor health during boot
+     */
+    private validateProcessorHealth;
+    /**
+     * Get current boot status information
+     */
+    getBootStatus(): BootResult;
+    /**
+     * Set up comprehensive memory monitoring and alerting
+     */
+    private setupMemoryMonitoring;
+    /**
+     * Perform comprehensive memory health check
+     */
+    getMemoryHealth(): {
+        healthy: boolean;
+        issues: string[];
+        metrics: {
+            current: MemoryStats;
+            peak: MemoryStats;
+            average: number;
+            trend: string;
+        };
+    };
+    /**
+     * Execute the boot sequence (internal framework initialization)
+     */
+    executeBootSequence(): Promise<BootResult>;
+    private loadXrayConfiguration;
+}
+export declare const bootOrchestrator: BootOrchestrator;

package/dist/core/boot-orchestrator.js

@@ -1,8 +1,8 @@
 /**
- * Boot Orchestrator (min documented consumer runtime compat shim from prior StringRay releases; primary Xray* paths + XRAY_||STRRAY_ env + .strray fallbacks only; 1-line per Scope Rule).
+ * Boot Orchestrator (min documented consumer runtime compat shim from prior StringRay releases; primary Xray* paths + XRAY_||STRRAY_ env + .xray fallbacks only; 1-line per Scope Rule).
  */
-import { StringRayContextLoader } from "./context-loader.js";
-import { StringRayStateManager } from "../state/state-manager.js";
+import { XrayContextLoader } from "./context-loader.js";
+import { XrayStateManager } from "../state/state-manager.js";
 import { ProcessorManager } from "../processors/processor-manager.js";
 import { pathResolver } from "../utils/path-resolver.js";
 import * as fs from "fs";
@@ -20,7 +20,7 @@ import { frameworkLogger } from "../core/framework-logger.js";
 import { featuresConfigLoader } from "../core/features-config.js";
 import { memoryMonitor } from "../monitoring/memory-monitor.js";
 import { advancedProfiler } from "../monitoring/advanced-profiler.js";
-import { strRayConfigLoader } from "./config-loader.js";
+import { xrayConfigLoader } from "./config-loader.js";
 import { PluginRegistry } from "../integrations/plugins/index.js";
 import { PluginServerConfigRegistry } from "../mcps/config/index.js";
 import { initializeGovernanceIntegration } from "../integrations/governance/index.js";
@@ -30,10 +30,10 @@ import { initializeGovernanceIntegration } from "../integrations/governance/inde
  */
 function setupGracefulShutdown() {
     // Prevent duplicate listeners
-    if (process._strrayShutdownSetup) {
+    if (process._xrayShutdownSetup) {
         return;
     }
-    process._strrayShutdownSetup = true;
+    process._xrayShutdownSetup = true;
     let isShuttingDown = false;
     process.on("SIGINT", async () => {
         if (isShuttingDown) {
@@ -98,8 +98,8 @@ export class BootOrchestrator {
     shutdownInitialized = false;
     constructor(config = {}, stateManager) {
         // Initialize components first for state management
-        this.contextLoader = StringRayContextLoader.getInstance();
-        this.stateManager = stateManager || new StringRayStateManager();
+        this.contextLoader = XrayContextLoader.getInstance();
+        this.stateManager = stateManager || new XrayStateManager();
         this.processorManager = new ProcessorManager(this.stateManager);
         this.config = {
             enableEnforcement: true,
@@ -115,7 +115,7 @@ export class BootOrchestrator {
      */
     async initializeDelegationSystem() {
         try {
-            const agentDelegator = createAgentDelegator(this.stateManager, strRayConfigLoader);
+            const agentDelegator = createAgentDelegator(this.stateManager, xrayConfigLoader);
             this.stateManager.set("delegation:agent_delegator", agentDelegator);
             const sessionCoordinator = createSessionCoordinator(this.stateManager);
             this.stateManager.set("delegation:session_coordinator", sessionCoordinator);
@@ -131,8 +131,8 @@ export class BootOrchestrator {
     loadProcessorsConfig() {
         try {
             const configPaths = [
-                path.join(process.cwd(), ".strray", "features.json"),
-                path.join(process.cwd(), ".opencode", "strray", "features.json"),
+                path.join(process.cwd(), ".xray", "features.json"),
+                path.join(process.cwd(), ".opencode", "xray", "features.json"),
             ];
             for (const configPath of configPaths) {
                 if (existsSync(configPath)) {
@@ -152,7 +152,7 @@ export class BootOrchestrator {
     async initializePluginSystem(jobId) {
         try {
             frameworkLogger.log("boot-orchestrator", "initializing plugin system", "info", { jobId });
-            const pluginsDir = path.join(process.cwd(), ".strray", "plugins");
+            const pluginsDir = path.join(process.cwd(), ".xray", "plugins");
             this.pluginRegistry = new PluginRegistry({
                 pluginsDir,
                 autoStart: true,
@@ -189,7 +189,7 @@ export class BootOrchestrator {
                 });
                 return false;
             }
-            const orchestratorInstance = orchestratorModule.strRayOrchestrator;
+            const orchestratorInstance = orchestratorModule.xrayOrchestrator || orchestratorModule.strRayOrchestrator;
             if (!orchestratorInstance) {
                 frameworkLogger.log("boot-orchestrator", "orchestrator-not-found", "error", { message: "Orchestrator instance not found in module" });
                 return false;
@@ -596,8 +596,8 @@ export class BootOrchestrator {
         };
         try {
             frameworkLogger.log("boot-orchestrator", "loading xray configuration", "info", { jobId });
-            // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)
-            await this.loadStringRayConfiguration(jobId);
+            // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks)
+            await this.loadXrayConfiguration(jobId);
             frameworkLogger.log("boot-orchestrator", "xray configuration loaded", "success", { jobId });
             // Phase 1: Initialize core systems
             frameworkLogger.log("boot-orchestrator", "initializing core systems", "info", { jobId });
@@ -727,14 +727,14 @@ export class BootOrchestrator {
         this.stateManager.set("boot:errors", result.errors);
         return result;
     }
-    // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)
-    async loadStringRayConfiguration(jobId) {
+    // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks)
+    async loadXrayConfiguration(jobId) {
         try {
-            // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)
-            const stringRayConfig = {
-                version: "1.22.67",
+            // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks)
+            const xrayConfig = {
+                version: "2.0.0",
                 codex_enabled: true,
-                codex_version: "v1.7.5",
+                codex_version: "v2.0.0",
                 codex_terms: [
                     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
                     21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
@@ -793,13 +793,13 @@ export class BootOrchestrator {
                 },
             };
             // Store configuration in state manager for use by other components
-            this.stateManager.set("strray:config", stringRayConfig);
-            this.stateManager.set("strray:version", stringRayConfig.version);
-            this.stateManager.set("strray:codex_enabled", stringRayConfig.codex_enabled);
-            this.stateManager.set("strray:codex_terms", stringRayConfig.codex_terms);
-            this.stateManager.set("strray:monitoring_metrics", stringRayConfig.monitoring_metrics);
-            this.stateManager.set("strray:monitoring_alerts", stringRayConfig.monitoring_alerts);
-            this.stateManager.set("strray:agent_capabilities", stringRayConfig.agent_capabilities);
+            this.stateManager.set("xray:config", xrayConfig);
+            this.stateManager.set("xray:version", xrayConfig.version);
+            this.stateManager.set("xray:codex_enabled", xrayConfig.codex_enabled);
+            this.stateManager.set("xray:codex_terms", xrayConfig.codex_terms);
+            this.stateManager.set("xray:monitoring_metrics", xrayConfig.monitoring_metrics);
+            this.stateManager.set("xray:monitoring_alerts", xrayConfig.monitoring_alerts);
+            this.stateManager.set("xray:agent_capabilities", xrayConfig.agent_capabilities);
             await frameworkLogger.log("boot-orchestrator", "configuration-loaded", "success", { jobId });
         }
         catch (error) {

package/dist/core/bridge.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * StringRay Universal Bridge
+ * Xray Universal Bridge
  *
- * Standalone bridge that provides StringRay framework capabilities
+ * Standalone bridge that provides Xray framework capabilities
  * to ANY consumer — no OpenCode dependency.
  *
  * Supports three transport modes:
@@ -84,7 +84,7 @@ function findProjectRoot() {
       const pkgPath = join(dir, "package.json");
       if (existsSync(pkgPath)) {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.name === "strray-ai" || pkg.dependencies?.["strray-ai"] || pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
+        if (pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
           return dir;
         }
       }
@@ -219,11 +219,11 @@ async function handleHealth(input) {
  */
 /** Codex candidate paths — single source of truth for both loadCodexFromFs and handleGetConfig */
 function getCodexCandidates(projectRoot) {
-  const envDir = process.env.STRRAY_CONFIG_DIR;
+  const envDir = process.env.XRAY_CONFIG_DIR || process.env.STRRAY_CONFIG_DIR;
   const candidates = [];
   if (envDir) candidates.push(join(projectRoot, envDir, "codex.json"));
-  candidates.push(join(projectRoot, ".strray", "codex.json"));
-  candidates.push(join(projectRoot, ".opencode", "strray", "codex.json"));
+  candidates.push(join(projectRoot, ".xray", "codex.json"));
+  candidates.push(join(projectRoot, ".opencode", "xray", "codex.json"));
   candidates.push(join(projectRoot, "codex.json"));
   return candidates;
 }
@@ -281,7 +281,7 @@ async function handleGetCodexPrompt(input, projectRoot, logDir) {
     terms.sort((a, b) => (severityOrder[a.severity] || 3) - (severityOrder[b.severity] || 3));
     if (maxTerms) terms = terms.slice(0, maxTerms);
 
-    const lines = [`## StringRay Universal Development Codex v${termsSource.version}`];
+    const lines = [`## Xray Universal Development Codex v${termsSource.version}`];
     const emojis = { blocking: "🔴", high: "🟡", medium: "🟢" };
     const labels = { blocking: "BLOCKING", high: "HIGH PRIORITY", medium: "MEDIUM" };
 
@@ -348,8 +348,8 @@ async function handleGetConfig(input, projectRoot, logDir) {
   // Load features.json
   const featurePaths = [];
   if (envDir) featurePaths.push(join(projectRoot, envDir, "features.json"));
-  featurePaths.push(join(projectRoot, ".strray", "features.json"));
-  featurePaths.push(join(projectRoot, ".opencode", "strray", "features.json"));
+  featurePaths.push(join(projectRoot, ".xray", "features.json"));
+  featurePaths.push(join(projectRoot, ".opencode", "xray", "features.json"));
 
   let featurePath = null;
   for (const p of featurePaths) {
@@ -604,7 +604,7 @@ function handleHooks(input, projectRoot) {
   const { action, hooks } = input;
   const hookTypes = hooks || ["pre-commit", "post-commit", "pre-push", "post-push"];
   const gitHooksDir = join(projectRoot, ".git", "hooks");
-  const strrayHooksDir = join(projectRoot, "hooks");
+  const xrayHooksDir = join(projectRoot, "hooks");
 
   if (!existsSync(gitHooksDir)) {
     return { error: "Not a git repository — no .git/hooks directory" };
@@ -616,14 +616,14 @@ function handleHooks(input, projectRoot) {
   if (action === "list" || action === "status") {
     for (const hookName of hookTypes) {
       const gitHook = join(gitHooksDir, hookName);
-      const strrayHook = join(strrayHooksDir, hookName);
+      const xrayHook = join(xrayHooksDir, hookName);
 
       if (!existsSync(gitHook)) {
         result.missing.push(hookName);
       } else {
         try {
           const content = readFileSync(gitHook, "utf-8");
-          if (content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js")) {
+          if (content.includes("Xray") || content.includes("StringRay") || content.includes("xray") || content.includes("strray") || content.includes("run-hook.js")) {
             result.managed.push(hookName);
           } else {
             result.external.push(hookName);
@@ -633,8 +633,8 @@ function handleHooks(input, projectRoot) {
         }
       }
 
-      // Check if strray source hook exists
-      if (!existsSync(strrayHook)) {
+      // Check if xray source hook exists
+      if (!existsSync(xrayHook)) {
         result.stale.push(hookName);
       }
     }
@@ -644,7 +644,7 @@ function handleHooks(input, projectRoot) {
       action,
       hooks: result,
       gitHooksDir,
-      strrayHooksDir,
+      xrayHooksDir,
     };
   }
 
@@ -655,7 +655,7 @@ function handleHooks(input, projectRoot) {
     const errors = [];
 
     for (const hookName of hookTypes) {
-      const src = join(strrayHooksDir, hookName);
+      const src = join(xrayHooksDir, hookName);
       const dst = join(gitHooksDir, hookName);
 
       if (!existsSync(src)) {
@@ -664,11 +664,11 @@ function handleHooks(input, projectRoot) {
       }
 
       try {
-        // Backup existing non-strray hooks
+        // Backup existing non-xray hooks
         if (existsSync(dst)) {
           const content = readFileSync(dst, "utf-8");
-          if (!content.includes("StringRay") && !content.includes("strray") && !content.includes("run-hook.js")) {
-            renameSync(dst, `${dst}.strray-backup`);
+          if (!content.includes("Xray") && !content.includes("StringRay") && !content.includes("xray") && !content.includes("strray") && !content.includes("run-hook.js")) {
+            renameSync(dst, `${dst}.xray-backup`);
           } else {
             unlinkSync(dst);
           }
@@ -699,15 +699,15 @@ function handleHooks(input, projectRoot) {
 
     for (const hookName of hookTypes) {
       const dst = join(gitHooksDir, hookName);
-      const backup = `${dst}.strray-backup`;
+      const backup = `${dst}.xray-backup`;
 
       if (!existsSync(dst)) continue;
 
       try {
         const content = readFileSync(dst, "utf-8");
-        const isStrray = content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js");
+        const isXray = content.includes("Xray") || content.includes("StringRay") || content.includes("xray") || content.includes("strray") || content.includes("run-hook.js");
 
-        if (isStrray || lstatSync(dst).isSymbolicLink()) {
+        if (isXray || lstatSync(dst).isSymbolicLink()) {
           unlinkSync(dst);
 
           // Restore backup if exists

package/dist/core/codex-formatter.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Codex Formatter — Standalone Codex-to-Prompt Converter
+ *
+ * Converts 0xRay's Universal Development Codex terms into
+ * formatted system prompt text. No OpenCode dependency, no plugin
+ * API, no framework imports. Pure input/output.
+ *
+ * This is the decoupled replacement for the codex injection that
+ * previously lived inside the OpenCode plugin (xray-codex-injection.ts).
+ *
+ * Usage from any host (Node.js, Python via bridge, HTTP, etc.):
+ *   import { formatCodexPrompt } from './codex-formatter.js';
+ *   const prompt = formatCodexPrompt({ projectRoot: '/path' });
+ *   // Append to system prompt
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+export interface CodexTerm {
+    id: string;
+    title: string;
+    description: string;
+    severity: "blocking" | "high" | "medium";
+    examples?: string[];
+}
+export interface CodexConfig {
+    version: string;
+    terms: CodexTerm[];
+    categories?: Record<string, string[]>;
+}
+export interface FormatOptions {
+    /** Project root for config resolution (default: cwd) */
+    projectRoot?: string;
+    /** Include only terms matching these severity levels (default: all) */
+    severityFilter?: Array<"blocking" | "high" | "medium">;
+    /** Include examples for each term (default: false) */
+    includeExamples?: boolean;
+    /** Maximum number of terms to include (default: all) */
+    maxTerms?: number;
+    /** Custom header text (default: auto-generated) */
+    header?: string;
+    /** Include config path reference in footer (default: true) */
+    includeConfigPath?: boolean;
+    /** Compress output by omitting descriptions for medium-severity terms */
+    compressed?: boolean;
+}
+export interface FormatResult {
+    /** The formatted prompt text */
+    prompt: string;
+    /** Number of terms included */
+    termCount: number;
+    /** Total terms available */
+    totalTerms: number;
+    /** Codex version */
+    version: string;
+    /** Config source path (or null if using built-in fallback) */
+    configPath: string | null;
+    /** Approximate character count */
+    charCount: number;
+}
+export declare const BUILTIN_CODEX: CodexConfig;
+/**
+ * Find codex.json using the standard priority chain.
+ * Mirrors config-paths.ts resolveCodexPath() but returns first match.
+ */
+export declare function findCodexPath(projectRoot?: string): string | null;
+/**
+ * Load and parse codex.json. Falls back to built-in codex if not found.
+ */
+export declare function loadCodex(projectRoot?: string): {
+    config: CodexConfig;
+    source: string | null;
+};
+/**
+ * Format codex terms into a system-prompt-ready string.
+ *
+ * This is the primary export. Any host (OpenCode, Hermes, Claude Desktop,
+ * custom agent) can call this to get enforcement text for their system prompt.
+ */
+export declare function formatCodexPrompt(options?: FormatOptions): FormatResult;
+/**
+ * Get codex as a structured JSON object (for programmatic consumers).
+ */
+export declare function getCodexConfig(options?: {
+    projectRoot?: string;
+}): {
+    version: string;
+    terms: CodexTerm[];
+    termCount: number;
+    source: string | null;
+};
+/**
+ * Get a minimal codex prompt for token-constrained environments.
+ * Only includes blocking terms, no descriptions.
+ */
+export declare function formatMinimalCodexPrompt(options?: FormatOptions): FormatResult;

package/dist/core/codex-formatter.js

@@ -89,8 +89,8 @@ export function findCodexPath(projectRoot) {
     if (envDir) {
         candidates.push(resolve(root, envDir, "codex.json"));
     }
-    candidates.push(join(root, ".strray", "codex.json"));
-    candidates.push(join(root, ".opencode", "strray", "codex.json"));
+    candidates.push(join(root, ".xray", "codex.json"));
+    candidates.push(join(root, ".opencode", "xray", "codex.json"));
     // Additional fallback locations (for standalone usage)
     candidates.push(join(root, "codex.json"));
     candidates.push(join(root, "src", "codex.json"));

package/dist/core/codex-injector.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 0xRay Codex Context Injector Hook
+ *
+ * Injects Universal Development Codex v1.2.0 context into agent operations.
+ * Follows production-tested pattern from rules-injector.
+ *
+ * @version 1.0.0
+ * @since 2026-01-06
+ */
+/**
+ * Create xray-codex-injector hook
+ *
+ * This hook injects codex context into tool outputs and displays
+ * a welcome message on agent startup, following the production-tested
+ * pattern from OpenCode's rules-injector.
+ */
+export declare function createXrayCodexInjectorHook(): {
+    name: "xray-codex-injector";
+    hooks: {
+        "agent.start": (sessionId: string) => Promise<void>;
+        "tool.execute.before": (input: {
+            tool: string;
+            args?: Record<string, unknown>;
+        }, sessionId: string) => Promise<void>;
+        "tool.execute.after": (input: {
+            tool: string;
+            args?: Record<string, unknown>;
+        }, output: {
+            output?: string;
+            [key: string]: unknown;
+        }, sessionId: string) => Promise<{
+            [key: string]: unknown;
+            output?: string;
+        } | {
+            output: string;
+        }>;
+    };
+};
+/**
+ * Get codex statistics for debugging
+ */
+export declare function getCodexStats(sessionId: string): {
+    loaded: boolean;
+    fileCount: number;
+    totalTerms: number;
+    version: string;
+};
+/**
+ * Clear codex cache (useful for testing or forced reload)
+ */
+export declare function clearCodexCache(sessionId?: string): void;
+/**
+ * CodexInjector class for plugin compatibility
+ */
+export declare class CodexInjector {
+    injectCodexRules(context: Record<string, unknown>, options: {
+        priority?: string;
+        mergeStrategy?: string;
+    }): Record<string, unknown>;
+    getCodexStats(): {
+        loaded: boolean;
+        fileCount: number;
+        totalTerms: number;
+        version: string;
+    };
+    /**
+     * Permissive comment validation - recognizes that comments are beneficial
+     * Only flags truly problematic patterns, provides guidance not requirements
+     */
+    validateCommentsPermissively(content: string): {
+        guidance: string[];
+        concerns: string[];
+    };
+}
+export { createXrayCodexInjectorHook as createStringRayCodexInjectorHook };

package/dist/core/codex-injector.js

@@ -13,7 +13,7 @@ import { frameworkLogger } from "../core/framework-logger.js";
 import { resolveCodexPath } from "./config-paths.js";
 // Dynamic imports for cross-environment compatibility
 let extractCodexMetadata;
-let StringRayContextLoader;
+let XrayContextLoader;
 let importsInitialized = false;
 async function initializeImports() {
     if (importsInitialized)
@@ -22,13 +22,13 @@ async function initializeImports() {
         const codexParser = await import("../utils/codex-parser.js");
         const contextLoaderModule = await import("./context-loader.js");
         extractCodexMetadata = codexParser.extractCodexMetadata;
-        StringRayContextLoader = contextLoaderModule.StringRayContextLoader;
+        XrayContextLoader = contextLoaderModule.XrayContextLoader;
     }
     catch {
         const codexParser = await import("../utils/codex-parser");
         const contextLoaderModule = await import("./context-loader");
         extractCodexMetadata = codexParser.extractCodexMetadata;
-        StringRayContextLoader = contextLoaderModule.StringRayContextLoader;
+        XrayContextLoader = contextLoaderModule.XrayContextLoader;
     }
     importsInitialized = true;
 }
@@ -38,7 +38,7 @@ async function initializeImports() {
 const codexCache = new Map();
 /**
  * Codex file locations resolved through the standard priority chain.
- * Uses config-paths.ts resolver so STRRAY_CONFIG_DIR and .strray/ work.
+ * Uses config-paths.ts resolver so XRAY_CONFIG_DIR and .xray/ work.
  */
 function getCodexFileLocations(projectRoot) {
     const root = projectRoot || process.cwd();
@@ -68,7 +68,7 @@ async function createCodexContextEntry(filePath, content) {
     }
     const metadata = extractCodexMetadata(content);
     return {
-        id: `strray-codex-${path.basename(filePath)}`,
+        id: `xray-codex-${path.basename(filePath)}`,
         source: filePath,
         content,
         priority: "critical",
@@ -121,15 +121,15 @@ function formatCodexContext(contexts, sessionId) {
     return parts.join("\n");
 }
 /**
- * Create strray-codex-injector hook
+ * Create xray-codex-injector hook
  *
  * This hook injects codex context into tool outputs and displays
  * a welcome message on agent startup, following the production-tested
  * pattern from OpenCode's rules-injector.
  */
-export function createStringRayCodexInjectorHook() {
+export function createXrayCodexInjectorHook() {
     return {
-        name: "strray-codex-injector",
+        name: "xray-codex-injector",
         hooks: {
             "agent.start": async (sessionId) => {
                 const jobId = `agent-start-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
@@ -145,7 +145,7 @@ export function createStringRayCodexInjectorHook() {
                         await frameworkLogger.log("codex-injector", "codex context loaded successfully", "success", { jobId, ...stats });
                     }
                     else {
-                        await frameworkLogger.log("codex-injector", "-no-codex-files-found-checked-strray-codex-json-co", "info", {
+                        await frameworkLogger.log("codex-injector", "-no-codex-files-found-checked-xray-codex-json-co", "info", {
                             message: `⚠️  No codex files found. Checked: ${getCodexFileLocations().join(", ")}`,
                         });
                         await frameworkLogger.log("codex-injector", "no codex files found", "error", { jobId });
@@ -193,7 +193,7 @@ export function createStringRayCodexInjectorHook() {
                     await frameworkLogger.log("codex-injector", "codex context loaded for validation", "success", { jobId, contextCount: codexContexts.length });
                     // Use the initialized context loader
                     await initializeImports();
-                    const ContextLoaderClass = StringRayContextLoader;
+                    const ContextLoaderClass = XrayContextLoader;
                     const contextLoader = new ContextLoaderClass();
                     const loadResult = await contextLoader.loadCodexContext(sessionId);
                     if (!loadResult.success || !loadResult.context) {
@@ -422,3 +422,4 @@ export class CodexInjector {
         return { guidance, concerns };
     }
 }
+export { createXrayCodexInjectorHook as createStringRayCodexInjectorHook };