0xray 3.0.14 → 3.1.1

package/dist/core/config-paths.js

@@ -2,25 +2,23 @@
  * Config Path Resolver
  *
  * Centralizes all 0xRay config file path resolution.
- * Supports STRRAY_CONFIG_DIR env var for custom config roots,
- * making .opencode/ completely optional for environments like Hermes Agent.
+ * Supports XRAY_CONFIG_DIR env var for custom config roots.
  *
  * Resolution order (per file type):
- *   1. STRRAY_CONFIG_DIR/<relative_path>     (if env var set)
- *   2. .strray/<relative_path>                (preferred lightweight root)
- *   3. .opencode/strray/<relative_path>       (legacy OpenCode root)
- *   4. null                                   (callers fall back to built-in defaults)
+ *   1. XRAY_CONFIG_DIR/<relative_path>     (if env var set)
+ *   2. .xray/<relative_path>                 (preferred lightweight root)
+ *   3. null                                   (callers fall back to built-in defaults)
  *
  * For state/data directories, uses:
- *   1. STRRAY_CONFIG_DIR/state                 (if env var set)
- *   2. .strray/state
+ *   1. XRAY_CONFIG_DIR/state                 (if env var set)
+ *   2. .xray/state
  *   3. .opencode/state                         (legacy)
- *   4. .strray/state                           (default — always writable)
+ *   4. .xray/state                              (default — always writable)
  */
 import { existsSync } from "fs";
 import { join, resolve } from "path";
 /** Environment variable name for custom config root */
-export const STRRAY_CONFIG_DIR_ENV = "STRRAY_CONFIG_DIR";
+export const XRAY_CONFIG_DIR_ENV = "XRAY_CONFIG_DIR";
 /** Resolved config directories, cached per projectRoot */
 const _resolvedConfigDirs = new Map();
 /**
@@ -28,11 +26,11 @@ const _resolvedConfigDirs = new Map();
  * Scans in priority order and caches the first one that exists (or the first default).
  */
 export function getConfigDir(projectRoot) {
-    const root = projectRoot || process.cwd();
+    const root = resolveRoot(projectRoot);
     const cached = _resolvedConfigDirs.get(root);
     if (cached)
         return cached;
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     // Priority candidates
     const candidates = [];
     if (envDir) {
@@ -40,8 +38,7 @@ export function getConfigDir(projectRoot) {
         const resolved = resolve(root, envDir);
         candidates.push({ dir: resolved, source: "env" });
     }
-    candidates.push({ dir: join(root, ".strray"), source: "dot-strray" });
-    candidates.push({ dir: join(root, ".opencode", "strray"), source: "dot-opencode" });
+    candidates.push({ dir: join(root, ".xray"), source: "dot-xray" });
     // Return the first that exists, or the highest-priority default
     for (const c of candidates) {
         if (existsSync(c.dir)) {
@@ -49,7 +46,7 @@ export function getConfigDir(projectRoot) {
             return c.dir;
         }
     }
-    // Nothing exists — use highest priority default (env > .strray > .opencode)
+    // Nothing exists — use highest priority default (env > .xray)
     const defaultDir = candidates[0];
     _resolvedConfigDirs.set(root, defaultDir.dir);
     return defaultDir.dir;
@@ -62,14 +59,13 @@ export function getConfigDir(projectRoot) {
  * @param projectRoot  - Optional project root override
  */
 export function resolveConfigPath(relativePath, projectRoot) {
-    const root = projectRoot || process.cwd();
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const root = resolveRoot(projectRoot);
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(resolve(root, envDir, relativePath));
     }
-    candidates.push(join(root, ".strray", relativePath));
-    candidates.push(join(root, ".opencode", "strray", relativePath));
+    candidates.push(join(root, ".xray", relativePath));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
             return candidate;
@@ -84,13 +80,13 @@ export function resolveConfigPath(relativePath, projectRoot) {
  * Similar logic to resolveConfigPath but for the state/ subdirectory.
  */
 export function resolveStateDir(projectRoot) {
-    const root = projectRoot || process.cwd();
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const root = resolveRoot(projectRoot);
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "state"));
     }
-    candidates.push(join(root, ".strray", "state"));
+    candidates.push(join(root, ".xray", "state"));
     candidates.push(join(root, ".opencode", "state"));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
@@ -111,14 +107,13 @@ export function resolveStateFilePath(projectRoot) {
  * Get the profiles storage directory.
  */
 export function resolveProfilesDir(projectRoot) {
-    const root = projectRoot || process.cwd();
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const root = resolveRoot(projectRoot);
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "profiles"));
     }
-    candidates.push(join(root, ".strray", "profiles"));
-    candidates.push(join(root, ".opencode", "strray", "profiles"));
+    candidates.push(join(root, ".xray", "profiles"));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
             return candidate;
@@ -130,16 +125,28 @@ export function resolveProfilesDir(projectRoot) {
  * Resolve codex.json path.
  * Has additional fallback locations beyond the standard config dir.
  */
+/** Environment variable for explicit project root override */
+export const XRAY_ROOT_ENV = "XRAY_ROOT";
+/**
+ * Resolve project root using XRAY_ROOT env var if set,
+ * otherwise fall back to projectRoot param or cwd.
+ */
+export function resolveProjectRoot(projectRoot) {
+    return process.env[XRAY_ROOT_ENV] || projectRoot || process.cwd();
+}
+/** @deprecated Use resolveProjectRoot — kept for internal consistency */
+function resolveRoot(projectRoot) {
+    return resolveProjectRoot(projectRoot);
+}
 export function resolveCodexPath(projectRoot) {
-    const root = projectRoot || process.cwd();
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const root = resolveRoot(projectRoot);
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV];
     const candidates = [];
     if (envDir) {
         candidates.push(join(root, envDir, "codex.json"));
     }
-    candidates.push(join(root, ".strray", "codex.json"));
+    candidates.push(join(root, ".xray", "codex.json"));
     candidates.push(join(root, "xray", "codex.json"));
-    candidates.push(join(root, ".opencode", "strray", "codex.json"));
     // Additional fallback locations (for standalone usage)
     candidates.push(join(root, "codex.json"));
     candidates.push(join(root, "src", "codex.json"));
@@ -150,7 +157,7 @@ export function resolveCodexPath(projectRoot) {
  * Get the logs directory for framework logging.
  */
 export function resolveLogDir(projectRoot) {
-    const root = projectRoot || process.cwd();
+    const root = resolveRoot(projectRoot);
     // Logs always go to logs/framework/ regardless of config dir
     return join(root, "logs", "framework");
 }

package/dist/core/context-loader.js

@@ -22,7 +22,7 @@ function isValidMatch(match, index) {
  *
  * Loads and parses the Universal Development Codex v1.2.0 from codex.json
  */
-export class StringRayContextLoader {
+export class XrayContextLoader {
     static instance;
     cachedContext = null;
     codexFilePaths = [];
@@ -33,10 +33,10 @@ export class StringRayContextLoader {
      * Get singleton instance
      */
     static getInstance() {
-        if (!StringRayContextLoader.instance) {
-            StringRayContextLoader.instance = new StringRayContextLoader();
+        if (!XrayContextLoader.instance) {
+            XrayContextLoader.instance = new XrayContextLoader();
         }
-        return StringRayContextLoader.instance;
+        return XrayContextLoader.instance;
     }
     /**
      * Load codex context
@@ -266,4 +266,4 @@ export class StringRayContextLoader {
 /**
  * Export singleton instance
  */
-export const strRayContextLoader = StringRayContextLoader.getInstance();
+export const xrayContextLoader = XrayContextLoader.getInstance();

package/dist/core/features-config.js

@@ -286,7 +286,7 @@ export class FeaturesConfigLoader {
      */
     getDefaultConfig() {
         return {
-            version: "1.22.67",
+            version: "3.1.0",
             description: "0xRay Framework - Unified Feature Configuration",
             token_optimization: {
                 enabled: true,

package/dist/core/index.js

@@ -1,6 +1,6 @@
 export { KernelOrchestrator } from "./orchestrator.js";
-export { defaultStringRayConfig } from "./xray-activation.js"; // consumer runtime compat from prior StringRay releases (1-line min per Scope Rule)
+export { defaultXrayConfig } from "./xray-activation.js";
 // Decoupled config path resolution (Layer 1)
-export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, STRRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
+export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, XRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
 // Standalone codex formatter (Layer 2)
 export { formatCodexPrompt, formatMinimalCodexPrompt, getCodexConfig, findCodexPath, loadCodex, BUILTIN_CODEX, } from "./codex-formatter.js";

package/dist/core/logging-config.js

@@ -1,9 +1,9 @@
 // Default logging configuration
 const defaultLoggingConfig = {
-    enabled: process.env.STRRAY_LOGGING_ENABLED !== "false", // Default true, can be disabled
-    level: process.env.STRRAY_LOG_LEVEL || "info",
+    enabled: process.env.XRAY_LOGGING_ENABLED !== "false", // Default true, can be disabled
+    level: process.env.XRAY_LOG_LEVEL || "info",
     destinations: ["console", "file"],
-    performanceMode: process.env.STRRAY_PERFORMANCE_MODE === "true",
+    performanceMode: process.env.XRAY_PERFORMANCE_MODE === "true",
 };
 // Available log levels in priority order (higher index = more verbose)
 const LOG_LEVELS = ["debug", "info", "warn", "error"];
@@ -32,12 +32,12 @@ export function shouldLog(level) {
     return messageLevelIndex >= currentLevelIndex;
 }
 // Environment variable configuration
-if (process.env.STRRAY_LOGGING_ENABLED === "false") {
+if (process.env.XRAY_LOGGING_ENABLED === "false") {
     setLoggingConfig({ enabled: false });
 }
-if (process.env.STRRAY_LOG_LEVEL) {
-    setLoggingConfig({ level: process.env.STRRAY_LOG_LEVEL });
+if (process.env.XRAY_LOG_LEVEL) {
+    setLoggingConfig({ level: process.env.XRAY_LOG_LEVEL });
 }
-if (process.env.STRRAY_PERFORMANCE_MODE === "true") {
+if (process.env.XRAY_PERFORMANCE_MODE === "true") {
     setLoggingConfig({ performanceMode: true });
 }

package/dist/core/orchestrator.js

@@ -267,7 +267,7 @@ export class KernelOrchestrator {
                 `B) Use a single orchestrator for all dependent tasks\n` +
                 `C) Remove the dependency if it's not needed\n\n` +
                 `Example of correct usage:\n` +
-                `  const orch = new StringRayOrchestrator();\n` +
+                `  const orch = new XrayOrchestrator();\n` +
                 `  await orch.executeComplexTask("test", [\n` +
                 `    { id: "task-1" },\n` +
                 `    { id: "task-2", dependencies: ["task-1"] }  // ✅ Same orchestrator\n` +
@@ -405,4 +405,4 @@ export class KernelOrchestrator {
         };
     }
 }
-export const strRayOrchestrator = new KernelOrchestrator();
+export const xrayOrchestrator = new KernelOrchestrator();

package/dist/core/system-prompt-generator.js

@@ -7,7 +7,7 @@
  * @version 1.0.0
  * @since 2026-03-03
  */
-import { StringRayContextLoader } from "./context-loader.js";
+import { XrayContextLoader } from "./context-loader.js";
 import { validateContext, preventSystemPromptBloat } from "./context-validator.js";
 import fs from "fs";
 import path from "path";
@@ -140,7 +140,7 @@ export async function generateLeanSystemPrompt(config = {}) {
     let finalPrompt = systemPrompt;
     if (showCodexContext && enableTokenOptimization) {
         try {
-            const contextLoader = StringRayContextLoader.getInstance();
+            const contextLoader = XrayContextLoader.getInstance();
             const loadResult = await contextLoader.loadCodexContext(process.cwd());
             if (loadResult.success && loadResult.context) {
                 const codexSummary = generateCodexSummary(loadResult.context, maxTokenBudget);

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).
+ * Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks).
  */
 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,15 +13,15 @@ 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 });
+    frameworkLogger.log("xray-activation", "beginning xray framework activation", "info", { jobId, ...activationConfig });
     const registryValidation = validateRegistryConsistency();
     if (!registryValidation.valid) {
-        frameworkLogger.log("stringray-activation", "registry-validation-failed", "warning", { errors: registryValidation.errors });
+        frameworkLogger.log("xray-activation", "registry-validation-failed", "warning", { errors: registryValidation.errors });
     }
     try {
         if (activationConfig.enableCodexInjection) {
@@ -48,87 +48,88 @@ export async function activateStringRayFramework(config = {}) {
         // Ensure architectural integrity - critical components must always be active
         await ensureCriticalComponents();
         // Loading display moved to init.sh for dramatic line-by-line presentation
-        frameworkLogger.log("stringray-activation", "xray framework activation completed successfully", "success", { jobId });
+        frameworkLogger.log("xray-activation", "xray framework activation completed successfully", "success", { jobId });
     }
     catch (error) {
-        await frameworkLogger.log("stringray-activation", "framework-activation-failed", "error", { jobId, error: String(error) });
+        await frameworkLogger.log("xray-activation", "framework-activation-failed", "error", { jobId, error: String(error) });
         throw error;
     }
 }
 async function activateCodexInjection(jobId) {
-    frameworkLogger.log("stringray-activation", "activating codex injection", "info", { jobId });
+    frameworkLogger.log("xray-activation", "activating codex injection", "info", { jobId });
     const { createXrayCodexInjectorHook } = await import("./codex-injector.js");
     const hook = createXrayCodexInjectorHook();
-    globalThis.strRayHooks = globalThis.strRayHooks || [];
-    globalThis.strRayHooks.push(hook);
-    frameworkLogger.log("stringray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
+    globalThis.xrayHooks = globalThis.xrayHooks || [];
+    globalThis.xrayHooks.push(hook);
+    frameworkLogger.log("xray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
 }
 async function activateHooks(jobId) {
     try {
-        frameworkLogger.log("stringray-activation", "activating xray hooks", "info", { jobId });
+        frameworkLogger.log("xray-activation", "activating xray hooks", "info", { jobId });
         // Create and register the Codex injector hook
         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);
-        frameworkLogger.log("stringray-activation", "xray hooks activated", "success", {
+        globalThis.xrayHooks = globalThis.xrayHooks || [];
+        globalThis.xrayHooks.push(hook);
+        frameworkLogger.log("xray-activation", "xray hooks activated", "success", {
             jobId,
             hookName: hook.name,
-            hooksRegistered: globalThis.strRayHooks.length
+            hooksRegistered: globalThis.xrayHooks.length
         });
     }
     catch (error) {
-        await frameworkLogger.log("stringray-activation", "hooks activation failed", "error", { jobId, error: String(error) });
+        await frameworkLogger.log("xray-activation", "hooks activation failed", "error", { jobId, error: String(error) });
     }
 }
 async function activateBootOrchestrator(jobId) {
-    frameworkLogger.log("stringray-activation", "activating boot orchestrator", "info", { jobId });
+    frameworkLogger.log("xray-activation", "activating boot orchestrator", "info", { jobId });
     const { bootOrchestrator } = await import("./boot-orchestrator");
     await bootOrchestrator.executeBootSequence();
-    frameworkLogger.log("stringray-activation", "boot orchestrator activated", "success", { jobId });
+    frameworkLogger.log("xray-activation", "boot orchestrator activated", "success", { 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();
+    frameworkLogger.log("xray-activation", "activating state management", "info", { jobId });
+    const { XrayStateManager } = await import("../state/state-manager");
+    const stateManager = new XrayStateManager();
     // Store the state manager instance globally for framework use
-    globalThis.strRayStateManager = stateManager;
-    frameworkLogger.log("stringray-activation", "state management activated", "success", { jobId });
+    globalThis.xrayStateManager = stateManager;
+    frameworkLogger.log("xray-activation", "state management activated", "success", { jobId });
 }
 async function activateOrchestrator(jobId) {
-    frameworkLogger.log("stringray-activation", "activating xray orchestrator", "info", { jobId });
-    const { strRayOrchestrator } = await import("./orchestrator");
+    frameworkLogger.log("xray-activation", "activating xray orchestrator", "info", { jobId });
+    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 });
+    frameworkLogger.log("xray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
 }
 async function activateProcessors(jobId) {
-    frameworkLogger.log("stringray-activation", "activating processor pipeline", "info", { jobId });
+    frameworkLogger.log("xray-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;
-    frameworkLogger.log("stringray-activation", "processor pipeline activated", "success", { jobId });
+    globalThis.xrayProcessorManager = processorManager;
+    frameworkLogger.log("xray-activation", "processor pipeline activated", "success", { jobId });
 }
 async function activatePostProcessor(jobId) {
-    frameworkLogger.log("stringray-activation", "activating post-processor system", "info", { jobId });
+    frameworkLogger.log("xray-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;
-    frameworkLogger.log("stringray-activation", "post-processor system activated", "success", { jobId });
+    globalThis.xrayPostProcessor = postProcessor;
+    frameworkLogger.log("xray-activation", "post-processor system activated", "success", { jobId });
     const { pathResolver } = await import("../utils/path-resolver.js");
-    globalThis.strRayPathResolver = pathResolver;
-    frameworkLogger.log("stringray-activation", "path resolver activated", "success", { jobId });
+    globalThis.xrayPathResolver = pathResolver;
+    frameworkLogger.log("xray-activation", "path resolver activated", "success", { jobId });
     const { CodexInjector } = await import("./codex-injector.js");
     const codexInjector = new CodexInjector();
-    globalThis.strRayCodexInjector = codexInjector;
-    frameworkLogger.log("stringray-activation", "codex injector activated", "success", { jobId });
+    globalThis.xrayCodexInjector = codexInjector;
+    frameworkLogger.log("xray-activation", "codex injector activated", "success", { jobId });
 }
+// Backward compat aliases

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(), ".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/enforcement/enforcer-tools.js

@@ -5,8 +5,8 @@
 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 { strRayConfigLoader } from "../core/config-loader.js";
+import { XrayStateManager } from "../state/state-manager.js";
+import { xrayConfigLoader } from "../core/config-loader.js";
 import * as fs from "fs";
 import * as path from "path";
 // Minimum confidence to auto-delegate to another agent
@@ -325,9 +325,9 @@ 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);
+        const delegator = new AgentDelegator(stateManager, xrayConfigLoader);
         // Build task description for the delegated agent
         const taskDescription = buildTaskDescription(operation, context);
         // Build the delegation request

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/, 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(".xray/codex.json");
     }
     /**
      * Check if codex.json exists.

package/dist/execution/opencode-cli-invoker.js

@@ -17,7 +17,7 @@ import { getConfigDir } from "../core/config-paths.js";
 let opencodeAvailable = null;
 export async function invokeViaOpencode(agentName, prompt, projectRoot = process.cwd()) {
     // In pure MCP mode we must never reach here
-    if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === "true") {
+    if (process.env.XRAY_FORCE_MCP_GOVERNANCE === "true") {
         throw new Error(`[PURE MCP] invokeViaOpencode called for "${agentName}" — this path is forbidden.`);
     }
     // GATE: Centralized spawn gate — blocks all agent spawning by default

package/dist/governance/governance-service.js

@@ -128,7 +128,7 @@ export class GovernanceService {
     }
     async callSkillServer(serverName, proposals, context) {
         const votes = [];
-        const useInProcess = process.env.VERCEL === '1';
+        const useInProcess = process.env.VERCEL === '1' || !!process.env.RAILWAY_ENVIRONMENT;
         for (const proposal of proposals) {
             try {
                 let text = '';