0xray 2.0.1 → 2.1.1

package/dist/core/bridge.mjs

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

package/dist/core/codex-formatter.js

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

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

@@ -8,14 +8,14 @@
  * @since 2026-01-06
  */
 /**
- * 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 declare function createStringRayCodexInjectorHook(): {
-    name: "strray-codex-injector";
+export declare function createXrayCodexInjectorHook(): {
+    name: "xray-codex-injector";
     hooks: {
         "agent.start": (sessionId: string) => Promise<void>;
         "tool.execute.before": (input: {
@@ -72,3 +72,4 @@ export declare class CodexInjector {
         concerns: string[];
     };
 }
+export { createXrayCodexInjectorHook as createStringRayCodexInjectorHook };

package/dist/core/codex-injector.js

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

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/features-config.js

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

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