0xray 3.1.0 → 3.2.0

package/dist/core/config-loader.js

@@ -1,53 +1,57 @@
 /**
- * Configuration Loader
+ * Configuration Loader (backward-compat shim)
  *
- * Loads and validates 0xRay-specific configuration from opencode.json
+ * Delegates to FeaturesConfigLoader as the single source of truth.
+ * Retained for backward compatibility -- all consumers of xrayConfigLoader
+ * continue to work without changes.
  *
- * @version 1.0.0
- * @since 2026-01-09
+ * @deprecated Use featuresConfigLoader from "./features-config.js" instead.
+ * Will be removed in v4.0.0.
  */
+import { featuresConfigLoader } from "./features-config.js";
+import { frameworkLogger } from "./framework-logger.js";
+import { resolveConfigPath } from "./config-paths.js";
 import * as fs from "fs";
 import * as path from "path";
-import { frameworkLogger } from "./framework-logger.js";
-import { getConfigDir, resolveConfigPath } from "./config-paths.js";
 export class XrayConfigLoader {
     configPath;
     cachedConfig = null;
-    cacheExpiry = 30000; // 30 seconds
+    cacheExpiry = 30000;
     lastLoadTime = 0;
     constructor(configPath) {
-        this.configPath = configPath || resolveConfigPath("config.json") || path.join(getConfigDir(), "config.json");
+        this.configPath = configPath || resolveConfigPath("config.json") || path.join(process.cwd(), ".xray", "config.json");
     }
     /**
-     * Load 0xRay configuration from the resolved config directory
+     * Load configuration -- delegates to FeaturesConfigLoader
+     * @deprecated Use featuresConfigLoader.getXrayConfig() instead.
      */
     loadConfig() {
         const now = Date.now();
-        // Return cached config if still valid
         if (this.cachedConfig && now - this.lastLoadTime < this.cacheExpiry) {
             return this.cachedConfig;
         }
+        const primary = featuresConfigLoader.getXrayConfig();
         try {
             const configPath = path.resolve(process.cwd(), this.configPath);
-            if (!fs.existsSync(configPath)) {
-                return this.getDefaultConfig();
+            if (fs.existsSync(configPath)) {
+                const configData = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                if (configData.multi_agent_orchestration || configData.autonomous_reporting || configData.disabled_agents) {
+                    frameworkLogger.log("config-loader", "deprecated-config-json", "warning", { message: "config.json contains overlapping keys. Migrate to features.json. See: https://0xray.ai/docs/config-migration" });
+                }
             }
-            const configData = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-            const config = this.parseConfig(configData);
-            this.cachedConfig = config;
-            this.lastLoadTime = now;
-            return config;
         }
-        catch (error) {
-            frameworkLogger.log("config-loader", "load-failed", "error", { error, message: "Failed to load 0xRay config" });
-            return this.getDefaultConfig();
+        catch {
+            // config.json may not exist -- that's fine, features.json is SSOT
         }
+        this.cachedConfig = primary;
+        this.lastLoadTime = now;
+        return primary;
     }
     /**
      * Parse configuration data with validation
+     * @deprecated Use featuresConfigLoader.loadConfig() instead.
      */
     parseConfig(configData) {
-        // Handle null/undefined config data
         if (!configData || typeof configData !== 'object') {
             return this.getDefaultConfig();
         }
@@ -62,6 +66,7 @@ export class XrayConfigLoader {
     }
     /**
      * Parse multi-agent orchestration configuration
+     * @deprecated Use featuresConfigLoader.loadConfig().multi_agent_orchestration instead.
      */
     parseMultiAgentConfig(config) {
         if (!config || typeof config !== 'object') {
@@ -80,6 +85,7 @@ export class XrayConfigLoader {
     }
     /**
      * Parse autonomous reporting configuration
+     * @deprecated Use featuresConfigLoader.loadConfig().autonomous_reporting instead.
      */
     parseAutonomousReportingConfig(config) {
         if (!config || typeof config !== 'object') {
@@ -87,9 +93,9 @@ export class XrayConfigLoader {
         }
         const cfg = config;
         return {
-            enabled: typeof cfg.enabled === 'boolean' ? cfg.enabled : false,
-            interval_minutes: Math.max(5, Math.min(1440, typeof cfg.interval_minutes === 'number' ? cfg.interval_minutes : 60)), // 5min to 24hrs
-            auto_schedule: typeof cfg.auto_schedule === 'boolean' ? cfg.auto_schedule : false,
+            enabled: typeof cfg.enabled === 'boolean' ? cfg.enabled : true,
+            interval_minutes: Math.max(5, Math.min(1440, typeof cfg.interval_minutes === 'number' ? cfg.interval_minutes : 60)),
+            auto_schedule: typeof cfg.auto_schedule === 'boolean' ? cfg.auto_schedule : true,
             include_health_assessment: typeof cfg.include_health_assessment === 'boolean' ? cfg.include_health_assessment : true,
             include_agent_activities: typeof cfg.include_agent_activities === 'boolean' ? cfg.include_agent_activities : true,
             include_pipeline_operations: typeof cfg.include_pipeline_operations === 'boolean' ? cfg.include_pipeline_operations : true,
@@ -103,6 +109,7 @@ export class XrayConfigLoader {
     }
     /**
      * Get default configuration
+     * @deprecated Use featuresConfigLoader.getDefaultConfig() instead.
      */
     getDefaultConfig() {
         return {
@@ -116,9 +123,9 @@ export class XrayConfigLoader {
                 session_persistence: true,
             },
             autonomous_reporting: {
-                enabled: false, // Disabled by default for performance
+                enabled: true,
                 interval_minutes: 60,
-                auto_schedule: false,
+                auto_schedule: true,
                 include_health_assessment: true,
                 include_agent_activities: true,
                 include_pipeline_operations: true,
@@ -132,19 +139,19 @@ export class XrayConfigLoader {
     }
     /**
      * Validate enum values
+     * @deprecated Internal implementation detail.
      */
     validateEnum(value, allowedValues, defaultValue) {
         return allowedValues.includes(value) ? value : defaultValue;
     }
     /**
      * Clear configuration cache
+     * @deprecated Use featuresConfigLoader.clearCache() instead.
      */
     clearCache() {
         this.cachedConfig = null;
         this.lastLoadTime = 0;
+        featuresConfigLoader.clearCache();
     }
 }
-// Export singleton instance
 export const xrayConfigLoader = new XrayConfigLoader();
-export { XrayConfigLoader as StringRayConfigLoader };
-export { xrayConfigLoader as strRayConfigLoader };

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

@@ -4,7 +4,6 @@
  * Loads Universal Development Codex v1.2.0 context for agent initialization.
  * Provides structured access to 30+ codex terms, interweaves, lenses, and anti-patterns.
  *
- * @version 1.0.0
  * @since 2026-01-06
  */
 import * as fs from "fs";
@@ -267,6 +266,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/context-validator.js

@@ -4,7 +4,6 @@
  * Prevents system prompt bloat by validating and rejecting context-injection attempts
  * that would exceed token budgets.
  *
- * @version 1.0.0
  * @since 2026-03-03
  */
 /**

package/dist/core/features-config.js

@@ -4,7 +4,6 @@
  * Loads and validates the unified features configuration from features.json
  * Supports token optimization, model routing, batch operations, and more.
  *
- * @version 1.0.0
  * @since 2026-01-25
  */
 import * as fs from "fs";
@@ -286,7 +285,7 @@ export class FeaturesConfigLoader {
      */
     getDefaultConfig() {
         return {
-            version: "1.22.67",
+            version: "3.1.0",
             description: "0xRay Framework - Unified Feature Configuration",
             token_optimization: {
                 enabled: true,
@@ -446,6 +445,43 @@ export class FeaturesConfigLoader {
             });
         }
     }
+    /**
+     * Get XrayConfig-shaped slice for backward compatibility
+     * @deprecated Use individual getters or loadConfig() directly instead.
+     */
+    getXrayConfig() {
+        const config = this.loadConfig();
+        return {
+            multi_agent_orchestration: config.multi_agent_orchestration,
+            autonomous_reporting: config.autonomous_reporting,
+            disabled_agents: config.agent_management?.disabled_agents ?? [],
+        };
+    }
+    getTokenManagement() {
+        return this.loadConfig().token_optimization;
+    }
+    getProcessors() {
+        return this.loadConfig().processors;
+    }
+    getCommitCycle() {
+        return this.loadConfig().commit_cycle;
+    }
+    getStorytelling() {
+        return this.loadConfig().storytelling;
+    }
+    getInference() {
+        return this.loadConfig().inference;
+    }
+    getPublish() {
+        return this.loadConfig().publish;
+    }
+    getAutoReporting() {
+        return this.loadConfig().autonomous_reporting;
+    }
+    getGovernance() {
+        const config = this.loadConfig();
+        return config.inference;
+    }
 }
 // Export singleton instance
 export const featuresConfigLoader = new FeaturesConfigLoader();

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/kernel-patterns.js

@@ -4,7 +4,6 @@
  * Pattern definitions from v1.1.0 → v2.0 kernel update
  * Includes 35+ patterns from 80+ reflections
  *
- * @version 2.0.0-SECURITY-ENHANCED
  */
 export class KernelAnalyzer {
     config;

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/model-router.js

@@ -2,48 +2,24 @@
  * Model Router
  *
  * Intelligent model routing based on task complexity and type.
- * Integrates with features-config for task-based model selection.
+ * Uses featuresConfigLoader as the single source of truth for all model config.
  *
- * @version 2.0.0
  * @since 2026-01-25
  */
-import * as fs from "fs";
-import * as path from "path";
 import { featuresConfigLoader, detectTaskType, } from "./features-config.js";
 // ============================================================================
 // Model Router Class
 // ============================================================================
 class ModelRouter {
-    configPath;
-    config;
     availableModels;
-    constructor(configPath) {
-        this.configPath =
-            configPath || path.resolve(process.cwd(), "opencode.json");
-        this.config = this.loadConfig();
+    constructor() {
         this.availableModels = this.discoverModels();
     }
-    loadConfig() {
-        try {
-            const configData = fs.readFileSync(this.configPath, "utf8");
-            return JSON.parse(configData);
-        }
-        catch (error) {
-            // Provide defaults if config not found
-            return {
-                model_routing: {},
-                model_default: "claude-sonnet-4",
-                model_fallback: "claude-haiku-4",
-            };
-        }
-    }
     discoverModels() {
         const defaultModels = [
-            // Anthropic Claude models (preferred for 0xRay)
             "claude-opus-4",
             "claude-sonnet-4",
             "claude-haiku-4",
-            // Other supported models
             "openai/gpt-4o",
             "openai/gpt-4o-mini",
             "google/gemini-pro-1.5",
@@ -51,7 +27,15 @@ class ModelRouter {
             "meta/llama-3.1-70b-instruct",
             "mistral/mistral-7b-instruct",
         ];
-        const configModels = this.config.available_models || [];
+        const featuresConfig = featuresConfigLoader.loadConfig();
+        const configModels = [];
+        if (featuresConfig.model_routing?.task_routing) {
+            for (const route of Object.values(featuresConfig.model_routing.task_routing)) {
+                if (route?.model && !configModels.includes(route.model)) {
+                    configModels.push(route.model);
+                }
+            }
+        }
         const uniqueModels = new Set([...defaultModels, ...configModels]);
         return Array.from(uniqueModels);
     }
@@ -82,44 +66,28 @@ class ModelRouter {
         return this.getValidatedModel();
     }
     /**
-     * Get validated model for agent type (legacy method)
+     * Get validated model for agent type
      */
     getValidatedModel(agentType) {
-        // 1. User preference (future enhancement)
-        const userModel = this.getUserPreference();
-        if (userModel && this.isModelAvailable(userModel)) {
-            return userModel;
-        }
-        // 2. Check features config for agent-specific model
+        const featuresConfig = featuresConfigLoader.loadConfig();
+        // 1. Check features config for agent-specific model
         if (agentType) {
-            const featuresConfig = featuresConfigLoader.loadConfig();
-            const agentModel = featuresConfig.agent_management.agent_models[agentType];
+            const agentModel = featuresConfig.agent_management?.agent_models?.[agentType];
             if (agentModel && this.isModelAvailable(agentModel)) {
                 return agentModel;
             }
-            // Fall back to opencode.json model routing
-            if (this.config.model_routing?.[agentType]) {
-                const configModel = this.config.model_routing[agentType];
-                if (this.isModelAvailable(configModel)) {
-                    return configModel;
-                }
-            }
         }
-        // 3. Framework default from features config
-        const featuresConfig = featuresConfigLoader.loadConfig();
+        // 2. Framework default from features config
         const defaultModel = featuresConfig.model_routing?.default_model;
         if (defaultModel && this.isModelAvailable(defaultModel)) {
             return defaultModel;
         }
-        // 4. Legacy default
-        const legacyDefault = this.config.model_default || "claude-sonnet-4";
-        if (this.isModelAvailable(legacyDefault)) {
-            return legacyDefault;
+        // 3. Hardcoded default
+        if (this.isModelAvailable("claude-sonnet-4")) {
+            return "claude-sonnet-4";
         }
-        // 5. Ultimate fallback
-        const fallbackModel = featuresConfig.model_routing?.fallback_model ||
-            this.config.model_fallback ||
-            "claude-haiku-4";
+        // 4. Ultimate fallback
+        const fallbackModel = featuresConfig.model_routing?.fallback_model || "claude-haiku-4";
         return fallbackModel;
     }
     /**
@@ -134,24 +102,15 @@ class ModelRouter {
     getMaxTokensForTaskType(taskType) {
         return featuresConfigLoader.getMaxTokensForTask(taskType);
     }
-    getUserPreference() {
-        // Check for user-specific config (future enhancement)
-        return null;
-    }
-    isModelAvailable(model) {
-        if (this.config.deprecated_models?.includes(model)) {
-            return false;
-        }
-        // For now, accept all models - the API will validate
+    isModelAvailable(_model) {
         return true;
     }
     /**
      * Reload configuration from disk
      */
     reloadConfig() {
-        this.config = this.loadConfig();
-        this.availableModels = this.discoverModels();
         featuresConfigLoader.clearCache();
+        this.availableModels = this.discoverModels();
     }
     /**
      * Get current configuration summary

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/system-prompt-generator.js

@@ -4,7 +4,6 @@
  * Generates optimized, token-efficient system prompts by implementing
  * selective injection and smart compression strategies.
  *
- * @version 1.0.0
  * @since 2026-03-03
  */
 import { XrayContextLoader } from "./context-loader.js";

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

@@ -6,7 +6,6 @@
  *
  * Integrates with TaskSkillRouter for keyword-based preprocessing.
  *
- * @version 1.1.0
  * @since 2026-01-07
  */
 import * as fs from "fs";
@@ -47,7 +46,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 +450,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/agent-expertise.js

@@ -4,7 +4,6 @@
  * Defines expertise levels for weighted voting across all 0xRay agents.
  * Higher expertise = higher weight in voting decisions.
  *
- * @version 1.0.0
  * @since 2026-04-16
  */
 export const AGENT_EXPERTISE_LEVELS = {

package/dist/delegation/analytics/index.js

@@ -4,7 +4,6 @@
  * Barrel export for all analytics components.
  * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
  *
- * @version 1.0.0
  * @since 2026-03-12
  */
 export { RoutingOutcomeTracker, routingOutcomeTracker } from './outcome-tracker.js';