0xray 3.1.0 → 3.1.1

package/dist/core/boot-orchestrator.js

@@ -1,5 +1,5 @@
 /**
- * Boot Orchestrator (min documented consumer runtime compat shim from prior 0xRay releases; primary Xray* paths + XRAY_||STRRAY_ env + .xray fallbacks only; 1-line per Scope Rule).
+ * Boot Orchestrator (min documented consumer runtime compat shim from prior 0xRay releases; primary Xray paths + .xray fallbacks only; 1-line per Scope Rule).
  */
 import { XrayContextLoader } from "./context-loader.js";
 import { XrayStateManager } from "../state/state-manager.js";
@@ -9,7 +9,7 @@ import * as fs from "fs";
 import * as path from "path";
 const { existsSync, readFileSync } = fs;
 // Path configuration - can be overridden by environment or use path resolver
-const AGENTS_BASE_PATH = process.env.XRAY_AGENTS_PATH || process.env.STRRAY_AGENTS_PATH || "../agents";
+const AGENTS_BASE_PATH = process.env.XRAY_AGENTS_PATH || process.env.XRAY_AGENTS_PATH || "../agents";
 import { createAgentDelegator, createSessionCoordinator, } from "../delegation/index.js";
 import { createSessionCleanupManager } from "../session/session-cleanup-manager.js";
 import { createSessionMonitor } from "../session/session-monitor.js";
@@ -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";
@@ -47,7 +47,7 @@ function setupGracefulShutdown() {
         }
         catch (error) {
             // Suppress error output in CLI mode to avoid breaking interface
-            if (process.env.STRRAY_CLI_MODE !== "true" &&
+            if (process.env.XRAY_CLI_MODE !== "true" &&
                 process.env.OPENCODE_CLI !== "true") {
                 frameworkLogger.log("boot-orchestrator", "shutdown-error", "error", { error, message: "Error during graceful shutdown" });
             }
@@ -69,7 +69,7 @@ function setupGracefulShutdown() {
     // Handle uncaught exceptions that might cause JSON parsing errors
     process.on("uncaughtException", (error) => {
         // Suppress error output in CLI mode to avoid breaking interface
-        if (process.env.STRRAY_CLI_MODE !== "true" &&
+        if (process.env.XRAY_CLI_MODE !== "true" &&
             process.env.OPENCODE_CLI !== "true") {
             frameworkLogger.log("boot-orchestrator", "uncaught-exception", "error", { error, message: "Uncaught Exception" });
         }
@@ -79,7 +79,7 @@ function setupGracefulShutdown() {
     });
     process.on("unhandledRejection", (reason, promise) => {
         // Suppress error output in CLI mode to avoid breaking interface
-        if (process.env.STRRAY_CLI_MODE !== "true" &&
+        if (process.env.XRAY_CLI_MODE !== "true" &&
             process.env.OPENCODE_CLI !== "true") {
             frameworkLogger.log("boot-orchestrator", "unhandled-rejection", "error", { promise, reason, message: "Unhandled Rejection" });
         }
@@ -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);
@@ -132,7 +132,6 @@ export class BootOrchestrator {
         try {
             const configPaths = [
                 path.join(process.cwd(), ".xray", "features.json"),
-                path.join(process.cwd(), ".opencode", "xray", "features.json"),
             ];
             for (const configPath of configPaths) {
                 if (existsSync(configPath)) {
@@ -189,7 +188,7 @@ export class BootOrchestrator {
                 });
                 return false;
             }
-            const orchestratorInstance = orchestratorModule.strRayOrchestrator;
+            const orchestratorInstance = orchestratorModule.xrayOrchestrator;
             if (!orchestratorInstance) {
                 frameworkLogger.log("boot-orchestrator", "orchestrator-not-found", "error", { message: "Orchestrator instance not found in module" });
                 return false;
@@ -596,7 +595,7 @@ export class BootOrchestrator {
         };
         try {
             frameworkLogger.log("boot-orchestrator", "loading xray configuration", "info", { jobId });
-            // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks)
+            // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks)
             await this.loadXrayConfiguration(jobId);
             frameworkLogger.log("boot-orchestrator", "xray configuration loaded", "success", { jobId });
             // Phase 1: Initialize core systems
@@ -727,12 +726,12 @@ export class BootOrchestrator {
         this.stateManager.set("boot:errors", result.errors);
         return result;
     }
-    // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks)
+    // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks)
     async loadXrayConfiguration(jobId) {
         try {
-            // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks)
+            // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks)
             const xrayConfig = {
-                version: "1.22.67",
+                version: "3.1.0",
                 codex_enabled: true,
                 codex_version: "v1.7.5",
                 codex_terms: [

package/dist/core/bridge.mjs

@@ -69,7 +69,7 @@ let frameworkLoadAttempted = false;
 // ============================================================================
 
 function findProjectRoot() {
-  const envHome = process.env.STRRAY_HOME;
+  const envHome = process.env.XRAY_HOME;
   if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
 
   const candidates = [
@@ -219,7 +219,7 @@ 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;
   const candidates = [];
   if (envDir) candidates.push(join(projectRoot, envDir, "codex.json"));
   candidates.push(join(projectRoot, ".xray", "codex.json"));
@@ -747,8 +747,8 @@ function startHttpServer(port, projectRoot) {
 
   return new Promise((resolve, reject) => {
     const server = createServer(async (req, res) => {
-      // CORS headers (wildcard — restrict via STRRAY_HTTP_CORS_ORIGIN env var in production)
-      const corsOrigin = process.env.STRRAY_HTTP_CORS_ORIGIN || "*";
+      // CORS headers (wildcard — restrict via XRAY_HTTP_CORS_ORIGIN env var in production)
+      const corsOrigin = process.env.XRAY_HTTP_CORS_ORIGIN || "*";
       res.setHeader("Content-Type", "application/json");
       res.setHeader("Access-Control-Allow-Origin", corsOrigin);
       res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");

package/dist/core/codex-formatter.js

@@ -84,13 +84,12 @@ export const BUILTIN_CODEX = {
  */
 export function findCodexPath(projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env.STRRAY_CONFIG_DIR;
+    const envDir = process.env.XRAY_CONFIG_DIR;
     const candidates = [];
     if (envDir) {
         candidates.push(resolve(root, envDir, "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.js

@@ -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 .xray/ work.
+ * Uses config-paths.ts resolver so XRAY_CONFIG_DIR and .xray/ work.
  */
 function getCodexFileLocations(projectRoot) {
     const root = projectRoot || process.cwd();
@@ -170,7 +170,7 @@ export function createXrayCodexInjectorHook() {
                     });
                     // Skip codex enforcement during testing
                     if (process.env.NODE_ENV === "test" ||
-                        process.env.STRRAY_TEST_MODE === "true") {
+                        process.env.XRAY_TEST_MODE === "true") {
                         await frameworkLogger.log("codex-injector", "skipping enforcement in test mode", "info", { jobId });
                         return;
                     }
@@ -263,7 +263,7 @@ export function createXrayCodexInjectorHook() {
                     frameworkLogger.log("codex-injector", "tool.execute.after hook triggered", "info", { jobId, tool: input.tool, sessionId });
                     // Skip codex enforcement during testing
                     if (process.env.NODE_ENV === "test" ||
-                        process.env.STRRAY_TEST_MODE === "true") {
+                        process.env.XRAY_TEST_MODE === "true") {
                         frameworkLogger.log("codex-injector", "skipping injection in test mode", "info", { jobId });
                         return output;
                     }

package/dist/core/config-loader.js

@@ -146,5 +146,4 @@ export class XrayConfigLoader {
 }
 // Export singleton instance
 export const xrayConfigLoader = new XrayConfigLoader();
-export { XrayConfigLoader as StringRayConfigLoader };
-export { xrayConfigLoader as strRayConfigLoader };
+// Backward compat aliases

package/dist/core/config-paths.js

@@ -2,17 +2,15 @@
  * 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)
+ *   1. XRAY_CONFIG_DIR/<relative_path>     (if env var set)
  *   2. .xray/<relative_path>                 (preferred lightweight root)
- *   3. .opencode/xray/<relative_path>        (legacy OpenCode root)
- *   4. null                                   (callers fall back to built-in defaults)
+ *   3. null                                   (callers fall back to built-in defaults)
  *
  * For state/data directories, uses:
- *   1. STRRAY_CONFIG_DIR/state                 (if env var set)
+ *   1. XRAY_CONFIG_DIR/state                 (if env var set)
  *   2. .xray/state
  *   3. .opencode/state                         (legacy)
  *   4. .xray/state                              (default — always writable)
@@ -20,7 +18,7 @@
 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) {
@@ -41,7 +39,6 @@ export function getConfigDir(projectRoot) {
         candidates.push({ dir: resolved, source: "env" });
     }
     candidates.push({ dir: join(root, ".xray"), source: "dot-xray" });
-    candidates.push({ dir: join(root, ".opencode", "xray"), source: "dot-opencode" });
     // 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 > .xray > .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, ".xray", relativePath));
-    candidates.push(join(root, ".opencode", "xray", relativePath));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
             return candidate;
@@ -84,8 +80,8 @@ 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"));
@@ -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, ".xray", "profiles"));
-    candidates.push(join(root, ".opencode", "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, ".xray", "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"));
@@ -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

@@ -267,6 +267,3 @@ export class XrayContextLoader {
  * Export singleton instance
  */
 export const xrayContextLoader = XrayContextLoader.getInstance();
-// Backward compat aliases
-export { XrayContextLoader as StringRayContextLoader };
-export { xrayContextLoader as strRayContextLoader };

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 { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig } from "./xray-activation.js"; // consumer runtime compat
+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

@@ -405,4 +405,4 @@ export class KernelOrchestrator {
         };
     }
 }
-export const strRayOrchestrator = new KernelOrchestrator();
+export const xrayOrchestrator = new KernelOrchestrator();

package/dist/core/xray-activation.js

@@ -1,5 +1,5 @@
 /**
- * Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray 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";
@@ -98,7 +98,7 @@ async function activateStateManagement(jobId) {
 }
 async function activateOrchestrator(jobId) {
     frameworkLogger.log("xray-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("xray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
@@ -132,5 +132,4 @@ async function activatePostProcessor(jobId) {
     globalThis.xrayCodexInjector = codexInjector;
     frameworkLogger.log("xray-activation", "codex injector activated", "success", { jobId });
 }
-export { defaultXrayConfig as defaultStringRayConfig };
-export { activateXrayFramework as activateStringRayFramework };
+// Backward compat aliases

package/dist/delegation/agent-delegator.js

@@ -47,7 +47,7 @@ export class AgentDelegator {
         const candidates = [
             path.resolve(process.cwd(), ".xray/routing-mappings.json"),
             path.resolve(process.cwd(), "xray/routing-mappings.json"),
-            path.resolve(process.cwd(), ".opencode/xray/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

@@ -6,7 +6,7 @@ import { ruleEnforcer, } from "./rule-enforcer.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { AgentDelegator } from "../delegation/agent-delegator.js";
 import { XrayStateManager } from "../state/state-manager.js";
-import { strRayConfigLoader } from "../core/config-loader.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
@@ -327,7 +327,7 @@ async function delegateToAgent(agentName, operation, context, jobId) {
         // Create a minimal state manager and config loader for the delegator
         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 .xray/, .opencode/xray/, 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/xray/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 = '';

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

@@ -59,8 +59,10 @@ function readHermesOAuthToken() {
         if (!entry?.access_token && Array.isArray(data)) {
             entry = data.find((e) => e.provider === "xai-oauth" || !!e.access_token);
         }
-        if (!entry?.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;
@@ -82,16 +84,25 @@ function getConfig() {
     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) {
@@ -111,8 +122,10 @@ function parseVote(text) {
 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
 

package/dist/index.js

@@ -4,13 +4,13 @@
  * This is the main entry point for the 0xRay framework.
  * It exports the core initialization function and key components.
  */
-export { XrayOrchestrator, StringRayOrchestrator } from "./orchestrator/orchestrator.js";
-export { XrayStateManager, 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 { defaultXrayConfig } from "./core/index.js";
-export { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig };
+export { defaultXrayConfig };
 export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
 // Main initialization function
 export function initializeXray(config = {}) {
@@ -22,5 +22,3 @@ export function initializeXray(config = {}) {
         message: "0xRay framework initialized successfully",
     };
 }
-// Backward compat alias
-export { initializeXray as initializeStringRay };