0xray 2.0.1 → 2.1.0

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 };

package/dist/core/config-loader.d.ts

@@ -27,12 +27,12 @@ export interface AutonomousReportingConfig {
     report_retention_days: number;
     notification_channels: string[];
 }
-export interface StringRayConfig {
+export interface XrayConfig {
     multi_agent_orchestration: MultiAgentOrchestrationConfig;
     autonomous_reporting: AutonomousReportingConfig;
     disabled_agents: string[];
 }
-export declare class StringRayConfigLoader {
+export declare class XrayConfigLoader {
     private configPath;
     private cachedConfig;
     private cacheExpiry;
@@ -41,7 +41,7 @@ export declare class StringRayConfigLoader {
     /**
      * Load 0xRay configuration from the resolved config directory
      */
-    loadConfig(): StringRayConfig;
+    loadConfig(): XrayConfig;
     /**
      * Parse configuration data with validation
      */
@@ -67,4 +67,5 @@ export declare class StringRayConfigLoader {
      */
     clearCache(): void;
 }
-export declare const strRayConfigLoader: StringRayConfigLoader;
+export declare const xrayConfigLoader: XrayConfigLoader;
+export { xrayConfigLoader as strRayConfigLoader, XrayConfigLoader as StringRayConfigLoader };

package/dist/core/config-loader.js

@@ -10,7 +10,7 @@ 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 StringRayConfigLoader {
+export class XrayConfigLoader {
     configPath;
     cachedConfig = null;
     cacheExpiry = 30000; // 30 seconds
@@ -145,4 +145,6 @@ export class StringRayConfigLoader {
     }
 }
 // Export singleton instance
-export const strRayConfigLoader = new StringRayConfigLoader();
+export const xrayConfigLoader = new XrayConfigLoader();
+// Backward compat alias
+export { xrayConfigLoader as strRayConfigLoader, XrayConfigLoader as StringRayConfigLoader };

package/dist/core/config-paths.d.ts

@@ -2,22 +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)
+ *   1. XRAY_CONFIG_DIR/<relative_path>     (if env var set)
+ *   2. .xray/<relative_path>                (preferred lightweight root)
+ *   3. .opencode/xray/<relative_path>        (OpenCode root)
  *   4. 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)
  */
 /** Environment variable name for custom config root */
+export declare const XRAY_CONFIG_DIR_ENV = "XRAY_CONFIG_DIR";
+/** Legacy env var name (backward compat) */
 export declare const STRRAY_CONFIG_DIR_ENV = "STRRAY_CONFIG_DIR";
 /**
  * Detect the best available config directory.

package/dist/core/config-paths.js

@@ -2,24 +2,25 @@
  * 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)
+ *   1. XRAY_CONFIG_DIR/<relative_path>     (if env var set)
+ *   2. .xray/<relative_path>                (preferred lightweight root)
+ *   3. .opencode/xray/<relative_path>        (OpenCode root)
  *   4. 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 XRAY_CONFIG_DIR_ENV = "XRAY_CONFIG_DIR";
+/** Legacy env var name (backward compat) */
 export const STRRAY_CONFIG_DIR_ENV = "STRRAY_CONFIG_DIR";
 /** Resolved config directories, cached per projectRoot */
 const _resolvedConfigDirs = new Map();
@@ -32,7 +33,7 @@ export function getConfigDir(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] || process.env[STRRAY_CONFIG_DIR_ENV];
     // Priority candidates
     const candidates = [];
     if (envDir) {
@@ -40,8 +41,8 @@ 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" });
+    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 +50,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 > .opencode)
     const defaultDir = candidates[0];
     _resolvedConfigDirs.set(root, defaultDir.dir);
     return defaultDir.dir;
@@ -63,13 +64,13 @@ export function getConfigDir(projectRoot) {
  */
 export function resolveConfigPath(relativePath, projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_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));
+    candidates.push(join(root, ".opencode", "xray", relativePath));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
             return candidate;
@@ -85,12 +86,12 @@ export function resolveConfigPath(relativePath, projectRoot) {
  */
 export function resolveStateDir(projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_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)) {
@@ -112,13 +113,13 @@ export function resolveStateFilePath(projectRoot) {
  */
 export function resolveProfilesDir(projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_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"));
+    candidates.push(join(root, ".opencode", "xray", "profiles"));
     for (const candidate of candidates) {
         if (existsSync(candidate)) {
             return candidate;
@@ -132,14 +133,14 @@ export function resolveProfilesDir(projectRoot) {
  */
 export function resolveCodexPath(projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env[STRRAY_CONFIG_DIR_ENV];
+    const envDir = process.env[XRAY_CONFIG_DIR_ENV] || process.env[STRRAY_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"));
+    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/context-loader.d.ts

@@ -46,7 +46,7 @@ export interface ContextLoadResult {
  *
  * Loads and parses the Universal Development Codex v1.2.0 from codex.json
  */
-export declare class StringRayContextLoader {
+export declare class XrayContextLoader {
     private static instance;
     private cachedContext;
     private codexFilePaths;
@@ -54,7 +54,7 @@ export declare class StringRayContextLoader {
     /**
      * Get singleton instance
      */
-    static getInstance(): StringRayContextLoader;
+    static getInstance(): XrayContextLoader;
     /**
      * Load codex context
      *
@@ -118,4 +118,5 @@ export declare class StringRayContextLoader {
 /**
  * Export singleton instance
  */
-export declare const strRayContextLoader: StringRayContextLoader;
+export declare const xrayContextLoader: XrayContextLoader;
+export { xrayContextLoader as strRayContextLoader, XrayContextLoader as StringRayContextLoader };

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,6 @@ export class StringRayContextLoader {
 /**
  * Export singleton instance
  */
-export const strRayContextLoader = StringRayContextLoader.getInstance();
+export const xrayContextLoader = XrayContextLoader.getInstance();
+// Backward compat alias
+export { xrayContextLoader as strRayContextLoader, XrayContextLoader as StringRayContextLoader };

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
 export { KernelOrchestrator } from "./orchestrator.js";
-export { defaultStringRayConfig } from "./xray-activation.js";
+export { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig } from "./xray-activation.js";
 export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, STRRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
 export { formatCodexPrompt, formatMinimalCodexPrompt, getCodexConfig, findCodexPath, loadCodex, BUILTIN_CODEX, } from "./codex-formatter.js";
 export type { CodexTerm, CodexConfig, FormatOptions, FormatResult, } from "./codex-formatter.js";

package/dist/core/index.js

@@ -1,5 +1,5 @@
 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, defaultXrayConfig as defaultStringRayConfig } from "./xray-activation.js"; // consumer runtime compat from prior StringRay releases (1-line min per Scope Rule)
 // Decoupled config path resolution (Layer 1)
 export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, STRRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
 // Standalone codex formatter (Layer 2)

package/dist/core/orchestrator.d.ts

@@ -68,4 +68,5 @@ export declare class KernelOrchestrator {
         };
     };
 }
+export declare const xrayOrchestrator: KernelOrchestrator;
 export declare const strRayOrchestrator: KernelOrchestrator;

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,5 @@ export class KernelOrchestrator {
         };
     }
 }
-export const strRayOrchestrator = new KernelOrchestrator();
+export const xrayOrchestrator = new KernelOrchestrator();
+export const strRayOrchestrator = xrayOrchestrator; // backward compat

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.d.ts

@@ -1,7 +1,7 @@
 /**
- * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks).
+ * 0xRay activation — reads config from .xray/ runtime state directory.
  */
-export interface StringRayActivationConfig {
+export interface XrayActivationConfig {
     enableOrchestrator: boolean;
     enableBootOrchestrator: boolean;
     enableStateManagement: boolean;
@@ -10,5 +10,5 @@ export interface StringRayActivationConfig {
     enableProcessors: boolean;
     enablePostProcessor: boolean;
 }
-export declare const defaultStringRayConfig: StringRayActivationConfig;
-export declare function activateStringRayFramework(config?: Partial<StringRayActivationConfig>): Promise<void>;
+export declare const defaultXrayConfig: XrayActivationConfig;
+export declare function activateXrayFramework(config?: Partial<XrayActivationConfig>): Promise<void>;

package/dist/core/xray-activation.js

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

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

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

package/dist/delegation/agent-delegator.js

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

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

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