0xray 3.0.12 → 3.1.0

package/dist/core/framework-logger.js

@@ -1,4 +1,5 @@
-import { promises as fs, existsSync, mkdirSync, appendFileSync } from "fs";
+import { isLoggingEnabled, shouldLog, } from "./logging-config.js";
+import { promises as fs, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 /**
  * Generate a unique job ID for tracking work sessions
@@ -74,55 +75,25 @@ export function withJobContext(operation, jobId) {
         if (result instanceof Promise) {
             return result.finally(async () => {
                 // Auto-complete job on operation finish
-                await jobContext.complete(true);
+                await jobContext.complete(true).catch(() => { });
                 // Restore original context
                 currentJobContext = originalContext;
             });
         }
         else {
             // Sync operation - complete immediately
-            jobContext.complete(true);
+            jobContext.complete(true).catch(() => { });
             currentJobContext = originalContext;
             return Promise.resolve(result);
         }
     }
     catch (error) {
         // Error occurred - complete job with failure
-        jobContext.complete(false, { error: String(error) });
+        jobContext.complete(false, { error: String(error) }).catch(() => { });
         currentJobContext = originalContext;
         throw error;
     }
 }
-const defaultLoggingConfig = {
-    enabled: (process.env.XRAY_LOGGING_ENABLED) !== "false",
-    level: (process.env.XRAY_LOG_LEVEL) || "info",
-    destinations: ["console", "file"],
-    performanceMode: (process.env.XRAY_PERFORMANCE_MODE) === "true",
-};
-const LOG_LEVELS = ["debug", "info", "warn", "error"];
-let globalLoggingConfig = { ...defaultLoggingConfig };
-function isLoggingEnabled() {
-    return globalLoggingConfig.enabled;
-}
-function shouldLog(level) {
-    if (!globalLoggingConfig.enabled)
-        return false;
-    const currentLevelIndex = LOG_LEVELS.indexOf(globalLoggingConfig.level);
-    const messageLevelIndex = LOG_LEVELS.indexOf(level);
-    if (currentLevelIndex === -1 || messageLevelIndex === -1)
-        return true;
-    return messageLevelIndex >= currentLevelIndex;
-}
-// Module-level side effects for env var config (previously in logging-config.ts)
-if (process.env.XRAY_LOGGING_ENABLED === "false") {
-    globalLoggingConfig.enabled = false;
-}
-if (process.env.XRAY_LOG_LEVEL) {
-    globalLoggingConfig.level = process.env.XRAY_LOG_LEVEL;
-}
-if (process.env.XRAY_PERFORMANCE_MODE === "true") {
-    globalLoggingConfig.performanceMode = true;
-}
 export class JobContext {
     jobId;
     startTime;
@@ -233,7 +204,7 @@ export class FrameworkUsageLogger {
             ...(currentTraceId && { traceId: currentTraceId }),
             ...(currentSpanId && { spanId: currentSpanId }),
             ...(currentParentSpanId && { parentSpanId: currentParentSpanId }),
-            ...(details !== undefined && { details }),
+            details,
         };
         this.logs.push(entry);
         if (this.logs.length > this.maxLogs) {
@@ -241,7 +212,7 @@ export class FrameworkUsageLogger {
         }
         this.bufferEntry(entry);
     }
-    async bufferEntry(entry) {
+    bufferEntry(entry) {
         const jobIdPart = entry.jobId ? `[${entry.jobId}] ` : "";
         const tracePart = entry.traceId ? `[${entry.traceId}.${entry.spanId}] ` : "";
         const detailsPart = entry.details
@@ -255,7 +226,7 @@ export class FrameworkUsageLogger {
         const line = `${new Date(entry.timestamp).toISOString()} ${jobIdPart}${tracePart}[${entry.component}] ${entry.action} - ${entry.status.toUpperCase()}${detailsPart}\n`;
         this.buffer.push(line);
         if (this.buffer.length >= this.MAX_BUFFER_SIZE) {
-            await this.flushBuffer();
+            this.flushBuffer();
             return;
         }
         if (!this.flushTimer) {
@@ -276,21 +247,17 @@ export class FrameworkUsageLogger {
         const data = toWrite.join("");
         try {
             const cwd = process.cwd();
-            if (!cwd) {
-                this.flushing = false;
+            if (!cwd)
                 return;
-            }
             const logDir = join(cwd, "logs", "framework");
             const logFile = join(logDir, "activity.log");
             if (!existsSync(logDir)) {
                 mkdirSync(logDir, { recursive: true });
             }
-            await fs.appendFile(logFile, data);
+            await fs.appendFile(logFile, data).catch(() => { });
+            this.flushing = false;
         }
         catch {
-            // flush failure is non-fatal
-        }
-        finally {
             this.flushing = false;
         }
     }
@@ -304,36 +271,5 @@ export class FrameworkUsageLogger {
     printRundown() {
         // Framework usage analytics placeholder
     }
-    flushSync() {
-        if (this.flushing || this.buffer.length === 0)
-            return;
-        const toWrite = this.buffer.splice(0, this.buffer.length);
-        const data = toWrite.join("");
-        try {
-            const cwd = process.cwd();
-            if (!cwd)
-                return;
-            const logDir = join(cwd, "logs", "framework");
-            const logFile = join(logDir, "activity.log");
-            if (!existsSync(logDir)) {
-                mkdirSync(logDir, { recursive: true });
-            }
-            appendFileSync(logFile, data);
-        }
-        catch {
-            // flush failure is non-fatal
-        }
-    }
 }
 export const frameworkLogger = new FrameworkUsageLogger();
-// Flush buffer synchronously on exit so CLI commands don't lose log entries
-if (typeof process !== "undefined" && process.env?.NODE_ENV !== "test") {
-    process.on("exit", () => {
-        frameworkLogger.flushSync();
-    });
-}
-// Startup self-test: verify logger works
-if (typeof process !== "undefined" && process.env?.NODE_ENV !== "test") {
-    frameworkLogger.log("system", "logger initialized", "info").catch(() => { });
-}
-//# sourceMappingURL=framework-logger.js.map

package/dist/core/index.js

@@ -1,9 +1,6 @@
 export { KernelOrchestrator } from "./orchestrator.js";
-export { defaultXrayConfig } from "./xray-activation.js";
+export { defaultXrayConfig, defaultXrayConfig as defaultStringRayConfig } from "./xray-activation.js"; // consumer runtime compat
 // Decoupled config path resolution (Layer 1)
-export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, XRAY_CONFIG_DIR_ENV,
-// Legacy export for compat shims
- } from "./config-paths.js";
+export { getConfigDir, resolveConfigPath, resolveStateDir, resolveProfilesDir, resolveCodexPath, resolveLogDir, resetConfigDirCache, STRRAY_CONFIG_DIR_ENV, } from "./config-paths.js";
 // Standalone codex formatter (Layer 2)
 export { formatCodexPrompt, formatMinimalCodexPrompt, getCodexConfig, findCodexPath, loadCodex, BUILTIN_CODEX, } from "./codex-formatter.js";
-//# sourceMappingURL=index.js.map

package/dist/core/kernel-patterns.js

@@ -300,4 +300,3 @@ export function getKernel() {
 export function resetKernel() {
     kernelInstance = null;
 }
-//# sourceMappingURL=kernel-patterns.js.map

package/dist/core/logging-config.js

@@ -0,0 +1,43 @@
+// Default logging configuration
+const defaultLoggingConfig = {
+    enabled: process.env.STRRAY_LOGGING_ENABLED !== "false", // Default true, can be disabled
+    level: process.env.STRRAY_LOG_LEVEL || "info",
+    destinations: ["console", "file"],
+    performanceMode: process.env.STRRAY_PERFORMANCE_MODE === "true",
+};
+// Available log levels in priority order (higher index = more verbose)
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+// Global logging configuration instance
+let globalLoggingConfig = { ...defaultLoggingConfig };
+export function getLoggingConfig() {
+    return { ...globalLoggingConfig };
+}
+export function setLoggingConfig(config) {
+    globalLoggingConfig = { ...globalLoggingConfig, ...config };
+}
+export function isLoggingEnabled() {
+    return globalLoggingConfig.enabled;
+}
+export function shouldLog(level) {
+    if (!globalLoggingConfig.enabled) {
+        return false;
+    }
+    const currentLevelIndex = LOG_LEVELS.indexOf(globalLoggingConfig.level);
+    const messageLevelIndex = LOG_LEVELS.indexOf(level);
+    // If either level is not found, default to showing the message
+    if (currentLevelIndex === -1 || messageLevelIndex === -1) {
+        return true;
+    }
+    // Show message if its level is >= current configured level
+    return messageLevelIndex >= currentLevelIndex;
+}
+// Environment variable configuration
+if (process.env.STRRAY_LOGGING_ENABLED === "false") {
+    setLoggingConfig({ enabled: false });
+}
+if (process.env.STRRAY_LOG_LEVEL) {
+    setLoggingConfig({ level: process.env.STRRAY_LOG_LEVEL });
+}
+if (process.env.STRRAY_PERFORMANCE_MODE === "true") {
+    setLoggingConfig({ performanceMode: true });
+}

package/dist/core/model-router.js

@@ -173,4 +173,3 @@ export default modelRouter;
 export const getModelForTask = (context) => modelRouter.getModelForTask(context);
 export const getModelForTaskType = (taskType) => modelRouter.getModelForTaskType(taskType);
 export const getValidatedModel = (agentType) => modelRouter.getValidatedModel(agentType);
-//# sourceMappingURL=model-router.js.map

package/dist/core/orchestrator.js

@@ -1,15 +1,9 @@
 /**
- * 0xRay Framework - Core Orchestrator (deprecated)
- *
- * Use thin-dispatch (src/nucleus/thin-dispatch.ts) for runtime agent routing
- * and src/utils/task-graph.ts for task graph utilities.
- * KernelOrchestrator is kept for backward compat with boot sequence integration.
- *
- * @deprecated since v3.0.0 — use thin-dispatch for routing, task-graph for utilities
+ * 0xRay Framework - Core Orchestrator
+ * Main orchestration engine for multi-agent task coordination
  */
 import { frameworkLogger } from "../core/framework-logger.js";
 import { getKernel } from "./kernel-patterns.js";
-import { topologicalSort, validateTaskDependencies, resolveConflicts } from "../utils/task-graph.js";
 export class KernelOrchestrator {
     taskQueue = new Map();
     activeTasks = new Set();
@@ -21,10 +15,6 @@ export class KernelOrchestrator {
         this.kernel = getKernel();
         frameworkLogger.log("orchestrator", "initialized", "info", { config: this.config });
     }
-    /**
-     * @deprecated since v3.0.0 — use thin-dispatch routing (scoreComplexity → routeToAgent)
-     *             and agent-delegator for actual execution.
-     */
     async executeTask(task) {
         const taskId = this.generateTaskId();
         this.taskQueue.set(taskId, task);
@@ -150,9 +140,23 @@ export class KernelOrchestrator {
             };
         }
     }
+    async dispatchToAgent(task) {
+        // Agent selection and dispatch logic
+        const startTime = Date.now();
+        // Simulate task execution with minimal delay to avoid hanging in test environment
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        const duration = Date.now() - startTime;
+        return {
+            success: true,
+            taskId: task.id,
+            agentUsed: task.subagentType || "default-agent",
+            duration,
+            result: { id: task.id, type: task.type, simulated: true },
+        };
+    }
     async executeComplexTask(description, tasks, sessionId) {
         // Validate that all task dependencies are within this orchestrator's batch
-        validateTaskDependencies(tasks);
+        this.validateTaskDependencies(tasks);
         frameworkLogger.log("orchestrator", "complex-task-started", "info", {
             description,
             taskCount: tasks.length,
@@ -160,7 +164,7 @@ export class KernelOrchestrator {
         const results = [];
         const completedTaskIds = new Set();
         // Sort tasks by dependencies (simple topological sort)
-        const sortedTasks = topologicalSort(tasks);
+        const sortedTasks = this.topologicalSort(tasks);
         for (const task of sortedTasks) {
             // Check dependencies
             if (task.dependencies && task.dependencies.length > 0) {
@@ -204,8 +208,156 @@ export class KernelOrchestrator {
         });
         return results;
     }
+    topologicalSort(tasks) {
+        const visited = new Set();
+        const visiting = new Set();
+        const result = [];
+        const visit = (taskId) => {
+            if (visiting.has(taskId)) {
+                throw new Error(`Circular dependency detected: ${taskId}`);
+            }
+            if (visited.has(taskId)) {
+                return;
+            }
+            visiting.add(taskId);
+            const task = tasks.find((t) => t.id === taskId);
+            if (task && task.dependencies) {
+                for (const dep of task.dependencies) {
+                    visit(dep);
+                }
+            }
+            visiting.delete(taskId);
+            visited.add(taskId);
+            if (task) {
+                result.push(task);
+            }
+        };
+        for (const task of tasks) {
+            if (!visited.has(task.id)) {
+                visit(task.id);
+            }
+        }
+        return result;
+    }
+    /**
+     * Validates that all task dependencies are within the current task batch.
+     * Prevents cross-orchestrator dependency errors by failing fast with a clear message.
+     */
+    validateTaskDependencies(tasks) {
+        const taskIds = new Set(tasks.map((t) => t.id));
+        const errors = [];
+        for (const task of tasks) {
+            if (task.dependencies && task.dependencies.length > 0) {
+                for (const dep of task.dependencies) {
+                    if (!taskIds.has(dep)) {
+                        errors.push(`Task "${task.id}" depends on "${dep}" which is NOT in this orchestrator's task batch.\n` +
+                            `Available tasks in this batch: ${Array.from(taskIds).join(", ")}`);
+                    }
+                }
+            }
+        }
+        if (errors.length > 0) {
+            const errorMessage = `[TEST ARCHITECTURE ERROR] Cross-orchestrator dependencies detected.\n\n` +
+                `${errors.join("\n\n")}\n\n` +
+                `This usually means:\n` +
+                `1. You're creating multiple orchestrator instances in one test\n` +
+                `2. Task dependencies are crossing orchestrator boundaries\n\n` +
+                `FIX: Either:\n` +
+                `A) Include the missing dependency task in this executeComplexTask() call\n` +
+                `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 XrayOrchestrator();\n` +
+                `  await orch.executeComplexTask("test", [\n` +
+                `    { id: "task-1" },\n` +
+                `    { id: "task-2", dependencies: ["task-1"] }  // ✅ Same orchestrator\n` +
+                `  ]);`;
+            throw new Error(errorMessage);
+        }
+    }
+    async executeComplexTaskSingle(task) {
+        const taskId = this.generateTaskId();
+        this.taskQueue.set(taskId, task);
+        this.activeTasks.add(taskId);
+        frameworkLogger.log("orchestrator", "complex-task-started", "info", {
+            taskId,
+            taskType: task.type,
+            complexity: task.complexity,
+            dependencies: task.dependencies,
+        });
+        try {
+            const startTime = Date.now();
+            if (task.dependencies && task.dependencies.length > 0) {
+                frameworkLogger.log("orchestrator", "processing-dependencies", "info", {
+                    taskId,
+                    dependencies: task.dependencies,
+                });
+                await new Promise((resolve) => setTimeout(resolve, 200));
+            }
+            await new Promise((resolve) => setTimeout(resolve, 300));
+            const duration = Date.now() - startTime;
+            frameworkLogger.log("orchestrator", "complex-task-completed", "success", {
+                taskId,
+                duration,
+                dependenciesResolved: task.dependencies?.length || 0,
+            });
+            return {
+                success: true,
+                taskId,
+                agentUsed: task.subagentType || "default-agent",
+                duration,
+                result: {
+                    complexTask: true,
+                    taskType: task.type,
+                    dependenciesProcessed: task.dependencies?.length || 0,
+                },
+            };
+        }
+        catch (error) {
+            frameworkLogger.log("orchestrator", "complex-task-failed", "error", {
+                taskId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return {
+                success: false,
+                taskId,
+                agentUsed: task.subagentType || "default-agent",
+                duration: 0,
+                result: null,
+                errors: [error instanceof Error ? error.message : String(error)],
+            };
+        }
+        finally {
+            this.activeTasks.delete(taskId);
+            this.taskQueue.delete(taskId);
+        }
+    }
     resolveConflicts(conflicts) {
-        return resolveConflicts(conflicts, this.config.conflictResolutionStrategy);
+        if (conflicts.length === 0) {
+            return { response: "", expertiseScore: 0 };
+        }
+        if (this.config.conflictResolutionStrategy === "majority_vote") {
+            const votes = {};
+            conflicts.forEach((conflict) => {
+                const response = String(conflict.response ?? conflict.proposed ?? '');
+                votes[response] = (votes[response] || 0) + 1;
+            });
+            const maxVotes = Math.max(...Object.values(votes));
+            const winner = Object.entries(votes).find(([_, voteCount]) => voteCount === maxVotes);
+            if (winner) {
+                const winningConflicts = conflicts.filter((c) => String(c.response ?? c.proposed ?? '') === winner[0]);
+                const avgExpertise = winningConflicts.reduce((sum, c) => sum + (c.expertiseScore || 0), 0) / winningConflicts.length;
+                return { response: winner[0], expertiseScore: avgExpertise };
+            }
+        }
+        // Fallback to highest expertise score
+        const bestConflict = conflicts.reduce((best, current) => (current.expertiseScore || 0) > (best.expertiseScore || 0)
+            ? current
+            : best);
+        return {
+            response: String(bestConflict.response ?? bestConflict.proposed ?? ''),
+            expertiseScore: bestConflict.expertiseScore || 0,
+        };
     }
     generateTaskId() {
         return `task-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
@@ -236,19 +388,12 @@ export class KernelOrchestrator {
         }
     }
     async performDelegation(agentName, task) {
-        const { scoreAndRoute } = await import("../nucleus/thin-dispatch.js");
-        const routing = scoreAndRoute(task.description, { taskType: task.type, agentName });
-        frameworkLogger.log("orchestrator", "thin-dispatch-routing", "info", {
-            requestedAgent: agentName,
-            routedAgent: routing.agent,
-            score: routing.score.score,
-            level: routing.score.level,
-        });
+        await new Promise((resolve) => setTimeout(resolve, 50));
         return {
             success: true,
-            result: `Task routed to ${routing.agent} via thin-dispatch`,
-            agentName: routing.agent,
-            executionTime: 0,
+            result: `Task completed successfully by ${agentName}`,
+            agentName,
+            executionTime: 50,
         };
     }
     getStatus() {
@@ -260,6 +405,4 @@ export class KernelOrchestrator {
         };
     }
 }
-export const xrayOrchestrator = new KernelOrchestrator();
-export const strRayOrchestrator = xrayOrchestrator; // backward compat
-//# sourceMappingURL=orchestrator.js.map
+export const strRayOrchestrator = new KernelOrchestrator();

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

@@ -263,4 +263,3 @@ export function validateSystemPrompt(prompt) {
         warnings
     };
 }
-//# sourceMappingURL=system-prompt-generator.js.map

package/dist/core/trace-context.js

@@ -0,0 +1,33 @@
+// src/core/trace-context.ts
+// Centralized trace propagation
+let currentTrace = null;
+function generateId() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return Date.now().toString(36) + Math.random().toString(36).substring(2);
+}
+export function startTrace(operation, metadata) {
+    const trace = {
+        traceId: generateId(),
+        operation,
+        governanceApproved: false,
+        startTime: Date.now(),
+        metadata: metadata || {}
+    };
+    currentTrace = trace;
+    return trace;
+}
+export function getCurrentTrace() {
+    return currentTrace;
+}
+export function endTrace(approved = true) {
+    if (currentTrace)
+        currentTrace.governanceApproved = approved;
+    currentTrace = null;
+}
+export function propagateTrace(childOperation) {
+    if (!currentTrace)
+        return null;
+    return { ...currentTrace, parentId: currentTrace.traceId, operation: childOperation, startTime: Date.now() };
+}

package/dist/core/xray-activation.js

@@ -1,5 +1,5 @@
 /**
- * 0xRay activation — reads config from .xray/ runtime state directory.
+ * Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .xray fallbacks).
  */
 import { frameworkLogger } from "../core/framework-logger.js";
 import { ensureCriticalComponents } from "../architect/architectural-integrity.js";
@@ -11,17 +11,17 @@ export const defaultXrayConfig = {
     enableHooks: true,
     enableCodexInjection: true,
     enableProcessors: true,
-    enablePostProcessor: false,
+    enablePostProcessor: true,
 };
 export async function activateXrayFramework(config = {}) {
     const jobId = `activation-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
     const activationConfig = { ...defaultXrayConfig, ...config };
     // Banner display moved to init.sh execution in plugin
     // Framework activation proceeds quietly
-    frameworkLogger.log("stringray-activation", "beginning xray framework activation", "info", { jobId, ...activationConfig });
+    frameworkLogger.log("xray-activation", "beginning xray framework activation", "info", { jobId, ...activationConfig });
     const registryValidation = validateRegistryConsistency();
     if (!registryValidation.valid) {
-        frameworkLogger.log("stringray-activation", "registry-validation-failed", "warning", { errors: registryValidation.errors });
+        frameworkLogger.log("xray-activation", "registry-validation-failed", "warning", { errors: registryValidation.errors });
     }
     try {
         if (activationConfig.enableCodexInjection) {
@@ -48,75 +48,73 @@ export async function activateXrayFramework(config = {}) {
         // Ensure architectural integrity - critical components must always be active
         await ensureCriticalComponents();
         // Loading display moved to init.sh for dramatic line-by-line presentation
-        frameworkLogger.log("stringray-activation", "xray framework activation completed successfully", "success", { jobId });
+        frameworkLogger.log("xray-activation", "xray framework activation completed successfully", "success", { jobId });
     }
     catch (error) {
-        await frameworkLogger.log("stringray-activation", "framework-activation-failed", "error", { jobId, error: String(error) });
+        await frameworkLogger.log("xray-activation", "framework-activation-failed", "error", { jobId, error: String(error) });
         throw error;
     }
 }
 async function activateCodexInjection(jobId) {
-    frameworkLogger.log("stringray-activation", "activating codex injection", "info", { jobId });
+    frameworkLogger.log("xray-activation", "activating codex injection", "info", { jobId });
     const { createXrayCodexInjectorHook } = await import("./codex-injector.js");
     const hook = createXrayCodexInjectorHook();
     globalThis.xrayHooks = globalThis.xrayHooks || [];
     globalThis.xrayHooks.push(hook);
-    frameworkLogger.log("stringray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
+    frameworkLogger.log("xray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
 }
 async function activateHooks(jobId) {
     try {
-        frameworkLogger.log("stringray-activation", "activating xray hooks", "info", { jobId });
+        frameworkLogger.log("xray-activation", "activating xray hooks", "info", { jobId });
         // Create and register the Codex injector hook
         const { createXrayCodexInjectorHook } = await import("./codex-injector");
         const hook = createXrayCodexInjectorHook();
         // Store hook globally for OpenCode to pick up
         globalThis.xrayHooks = globalThis.xrayHooks || [];
         globalThis.xrayHooks.push(hook);
-        frameworkLogger.log("stringray-activation", "xray hooks activated", "success", {
+        frameworkLogger.log("xray-activation", "xray hooks activated", "success", {
             jobId,
             hookName: hook.name,
             hooksRegistered: globalThis.xrayHooks.length
         });
     }
     catch (error) {
-        await frameworkLogger.log("stringray-activation", "hooks activation failed", "error", { jobId, error: String(error) });
+        await frameworkLogger.log("xray-activation", "hooks activation failed", "error", { jobId, error: String(error) });
     }
 }
 async function activateBootOrchestrator(jobId) {
-    frameworkLogger.log("stringray-activation", "activating boot orchestrator", "info", { jobId });
+    frameworkLogger.log("xray-activation", "activating boot orchestrator", "info", { jobId });
     const { bootOrchestrator } = await import("./boot-orchestrator");
     await bootOrchestrator.executeBootSequence();
-    frameworkLogger.log("stringray-activation", "boot orchestrator activated", "success", { jobId });
+    frameworkLogger.log("xray-activation", "boot orchestrator activated", "success", { jobId });
 }
 async function activateStateManagement(jobId) {
-    frameworkLogger.log("stringray-activation", "activating state management", "info", { jobId });
+    frameworkLogger.log("xray-activation", "activating state management", "info", { jobId });
     const { XrayStateManager } = await import("../state/state-manager");
     const stateManager = new XrayStateManager();
     // Store the state manager instance globally for framework use
     globalThis.xrayStateManager = stateManager;
-    globalThis.strRayStateManager = stateManager; // backward compat
-    frameworkLogger.log("stringray-activation", "state management activated", "success", { jobId });
+    frameworkLogger.log("xray-activation", "state management activated", "success", { jobId });
 }
 async function activateOrchestrator(jobId) {
-    frameworkLogger.log("stringray-activation", "activating xray orchestrator", "info", { jobId });
-    const { xrayOrchestrator } = await import("./orchestrator");
+    frameworkLogger.log("xray-activation", "activating xray orchestrator", "info", { jobId });
+    const { strRayOrchestrator } = await import("./orchestrator");
     // Also activate the multi-agent orchestration coordinator
     const { multiAgentOrchestrationCoordinator } = await import("../orchestrator/multi-agent-orchestration-coordinator");
-    frameworkLogger.log("stringray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
+    frameworkLogger.log("xray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
 }
 async function activateProcessors(jobId) {
-    frameworkLogger.log("stringray-activation", "activating processor pipeline", "info", { jobId });
+    frameworkLogger.log("xray-activation", "activating processor pipeline", "info", { jobId });
     const { ProcessorManager } = await import("../processors/processor-manager");
     const { 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.xrayProcessorManager = processorManager;
-    globalThis.strRayProcessorManager = processorManager; // backward compat
-    frameworkLogger.log("stringray-activation", "processor pipeline activated", "success", { jobId });
+    frameworkLogger.log("xray-activation", "processor pipeline activated", "success", { jobId });
 }
 async function activatePostProcessor(jobId) {
-    frameworkLogger.log("stringray-activation", "activating post-processor system", "info", { jobId });
+    frameworkLogger.log("xray-activation", "activating post-processor system", "info", { jobId });
     const { PostProcessor } = await import("../postprocessor/PostProcessor");
     // Get existing state manager (should be initialized by boot orchestrator)
     const stateManager = globalThis.xrayStateManager;
@@ -125,16 +123,14 @@ async function activatePostProcessor(jobId) {
     }
     const postProcessor = new PostProcessor(stateManager, null, {});
     globalThis.xrayPostProcessor = postProcessor;
-    globalThis.strRayPostProcessor = postProcessor; // backward compat
-    frameworkLogger.log("stringray-activation", "post-processor system activated", "success", { jobId });
+    frameworkLogger.log("xray-activation", "post-processor system activated", "success", { jobId });
     const { pathResolver } = await import("../utils/path-resolver.js");
     globalThis.xrayPathResolver = pathResolver;
-    globalThis.strRayPathResolver = pathResolver; // backward compat
-    frameworkLogger.log("stringray-activation", "path resolver activated", "success", { jobId });
+    frameworkLogger.log("xray-activation", "path resolver activated", "success", { jobId });
     const { CodexInjector } = await import("./codex-injector.js");
     const codexInjector = new CodexInjector();
     globalThis.xrayCodexInjector = codexInjector;
-    globalThis.strRayCodexInjector = codexInjector; // backward compat
-    frameworkLogger.log("stringray-activation", "codex injector activated", "success", { jobId });
+    frameworkLogger.log("xray-activation", "codex injector activated", "success", { jobId });
 }
-//# sourceMappingURL=xray-activation.js.map
+export { defaultXrayConfig as defaultStringRayConfig };
+export { activateXrayFramework as activateStringRayFramework };