0xray 4.0.13 → 4.0.15

package/dist/core/codex-injector.js

@@ -0,0 +1,423 @@
+/**
+ * 0xRay Codex Context Injector Hook
+ *
+ * Injects Universal Development Codex v1.2.0 context into agent operations.
+ * Follows production-tested pattern from rules-injector.
+ *
+ * @since 2026-01-06
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { resolveCodexPath } from "./config-paths.js";
+// Dynamic imports for cross-environment compatibility
+let extractCodexMetadata;
+let XrayContextLoaderClass;
+let importsInitialized = false;
+async function initializeImports() {
+    if (importsInitialized)
+        return;
+    try {
+        const codexParser = await import("../utils/codex-parser.js");
+        const contextLoaderModule = await import("./context-loader.js");
+        extractCodexMetadata = codexParser.extractCodexMetadata;
+        XrayContextLoaderClass = contextLoaderModule.XrayContextLoader;
+    }
+    catch {
+        const codexParser = await import("../utils/codex-parser");
+        const contextLoaderModule = await import("./context-loader");
+        extractCodexMetadata = codexParser.extractCodexMetadata;
+        XrayContextLoaderClass = contextLoaderModule.XrayContextLoader;
+    }
+    importsInitialized = true;
+}
+/**
+ * Session cache for codex context
+ */
+const codexCache = new Map();
+/**
+ * Codex file locations resolved through the standard priority chain.
+ * Uses config-paths.ts resolver so XRAY_CONFIG_DIR and .xray/ work.
+ */
+function getCodexFileLocations(projectRoot) {
+    const root = projectRoot || process.cwd();
+    return resolveCodexPath(root);
+}
+/**
+ * Read file content safely
+ */
+function readFileContent(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            return fs.readFileSync(filePath, "utf-8");
+        }
+    }
+    catch (error) {
+        frameworkLogger.log("codex-injector", "read-file-error", "error", { error, message: "0xRay Codex Hook Error" });
+    }
+    return null;
+}
+/**
+ * Create codex context entry
+ */
+async function createCodexContextEntry(filePath, content) {
+    await initializeImports();
+    if (!extractCodexMetadata) {
+        throw new Error("Codex metadata extractor not available");
+    }
+    const metadata = extractCodexMetadata(content);
+    return {
+        id: `xray-codex-${path.basename(filePath)}`,
+        source: filePath,
+        content,
+        priority: "critical",
+        metadata: {
+            version: metadata.version,
+            termCount: metadata.termCount,
+            loadedAt: new Date().toISOString(),
+        },
+    };
+}
+/**
+ * Load codex context for current session
+ */
+async function loadCodexContext(sessionId) {
+    if (codexCache.has(sessionId)) {
+        return codexCache.get(sessionId);
+    }
+    const codexContexts = [];
+    const locations = getCodexFileLocations();
+    for (const relativePath of locations) {
+        try {
+            const fullPath = path.isAbsolute(relativePath) ? relativePath : path.join(process.cwd(), relativePath);
+            const content = readFileContent(fullPath);
+            if (content) {
+                const entry = await createCodexContextEntry(fullPath, content);
+                codexContexts.push(entry);
+            }
+        }
+        catch (error) {
+            frameworkLogger.log("codex-injector", "load-codex-context-error", "error", { error, message: "0xRay Codex Hook Error" });
+        }
+    }
+    codexCache.set(sessionId, codexContexts);
+    return codexContexts;
+}
+/**
+ * Format codex context for display
+ */
+function formatCodexContext(contexts, sessionId) {
+    if (contexts.length === 0) {
+        return "⚠️ No codex context available";
+    }
+    const parts = ["0xRay Codex Context"];
+    for (const context of contexts) {
+        parts.push(`✅ ${context.source} (${context.metadata.termCount} terms)`);
+    }
+    const stats = getCodexStats(sessionId);
+    parts.push(`📁 ${stats.fileCount} source(s)`);
+    parts.push(`🎯 90% runtime error prevention target`);
+    return parts.join("\n");
+}
+/**
+ * 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 createXrayCodexInjectorHook() {
+    return {
+        name: "xray-codex-injector",
+        hooks: {
+            "agent.start": async (sessionId) => {
+                const jobId = `agent-start-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+                try {
+                    await frameworkLogger.log("codex-injector", "agent.start hook triggered", "info", { jobId, sessionId });
+                    // Load codex context to ensure it's available for the session
+                    await loadCodexContext(sessionId);
+                    const stats = getCodexStats(sessionId);
+                    if (stats.loaded) {
+                        await frameworkLogger.log("codex-injector", "-xray-codex-loaded-stats-totalterms-terms-sta", "success", {
+                            message: `✅ 0xRay Codex loaded: ${stats.totalTerms} terms, ${stats.fileCount} sources`,
+                        });
+                        await frameworkLogger.log("codex-injector", "codex context loaded successfully", "success", { jobId, ...stats });
+                    }
+                    else {
+                        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 });
+                    }
+                }
+                catch (error) {
+                    await frameworkLogger.log("codex-injector", "agent.start hook failed", "error", { jobId, error });
+                    frameworkLogger.log("codex-injector", "agent-start-hook-error", "error", { error, jobId, message: "Error in agent.start hook" });
+                    throw error;
+                }
+            },
+            "tool.execute.before": async (input, sessionId) => {
+                const jobId = `tool-before-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+                try {
+                    await frameworkLogger.log("codex-injector", "tool.execute.before hook triggered", "info", { jobId, tool: input.tool, sessionId });
+                    // Log ALL tool usage for framework transparency
+                    await frameworkLogger.log("framework-activity", `tool called: ${input.tool}`, "info", {
+                        jobId,
+                        tool: input.tool,
+                        args: input.args,
+                        sessionId,
+                    });
+                    // Skip codex enforcement during testing
+                    if (process.env.NODE_ENV === "test" ||
+                        process.env.XRAY_TEST_MODE === "true") {
+                        await frameworkLogger.log("codex-injector", "skipping enforcement in test mode", "info", { jobId });
+                        return;
+                    }
+                    // Only enforce on critical tools that could violate codex terms
+                    const criticalTools = ["write", "edit", "multiedit", "batch"];
+                    if (!criticalTools.includes(input.tool)) {
+                        await frameworkLogger.log("codex-injector", "non-critical tool allowed", "info", { jobId, tool: input.tool });
+                        return; // Allow non-critical tools
+                    }
+                    await frameworkLogger.log("codex-injector", "enforcing codex on critical tool", "info", { jobId, tool: input.tool });
+                    // Load codex context for validation
+                    const codexContexts = await loadCodexContext(sessionId);
+                    if (codexContexts.length === 0) {
+                        await frameworkLogger.log("codex-injector", "-no-codex-loaded-allowing-action-but-enforcement-d", "info", {
+                            message: "⚠️  No codex loaded - allowing action but enforcement disabled",
+                        });
+                        await frameworkLogger.log("codex-injector", "no codex context available", "error", { jobId, sessionId });
+                        return;
+                    }
+                    await frameworkLogger.log("codex-injector", "codex context loaded for validation", "success", { jobId, contextCount: codexContexts.length });
+                    // Use the initialized context loader
+                    await initializeImports();
+                    const ContextLoaderClass = XrayContextLoaderClass;
+                    const contextLoader = new ContextLoaderClass();
+                    const loadResult = await contextLoader.loadCodexContext(sessionId);
+                    if (!loadResult.success || !loadResult.context) {
+                        // Codex context warning - operational, keep
+                        return;
+                    }
+                    // Validate action against codex
+                    const actionDescription = `${input.tool} ${JSON.stringify(input.args || {})}`;
+                    const validation = contextLoader.validateAgainstCodex(loadResult.context, actionDescription, {
+                        strictMode: true,
+                        blockOnViolations: true,
+                    });
+                    if (!validation.compliant) {
+                        // Check for blocking violations
+                        const blockingViolations = validation.violations.filter((v) => v.severity === "blocking");
+                        if (blockingViolations.length > 0) {
+                            const errorMsg = `🚫 BLOCKED: Codex violation detected\n${blockingViolations.map((v) => `• ${v.reason}`).join("\n")}`;
+                            frameworkLogger.log("codex-injector", "blocking-violation", "error", { message: errorMsg, jobId });
+                            frameworkLogger.log("codex-injector", "blocking codex violation detected", "error", {
+                                jobId,
+                                violationCount: blockingViolations.length,
+                                tool: input.tool,
+                            });
+                            throw new Error(`Codex enforcement blocked action: ${blockingViolations[0]?.reason || "Unknown violation"}`);
+                        }
+                        // Log non-blocking violations but allow action
+                        await frameworkLogger.log("codex-injector", "-codex-warnings-detected-", "info", { message: `⚠️  Codex warnings detected:` });
+                        for (const v of validation.violations) {
+                            await frameworkLogger.log("codex-injector", "-v-reason-", "info", { message: `   • ${v.reason}` });
+                        }
+                        await frameworkLogger.log("codex-injector", "-recommendations-validation-recommendations-join-", "info", {
+                            message: `💡 Recommendations: ${validation.recommendations.join(", ")}`,
+                        });
+                        frameworkLogger.log("codex-injector", "non-blocking codex warnings", "info", {
+                            jobId,
+                            warningCount: validation.violations.length,
+                            tool: input.tool,
+                        });
+                    }
+                    else {
+                        frameworkLogger.log("codex-injector", "codex validation passed", "success", { jobId, tool: input.tool });
+                    }
+                }
+                catch (error) {
+                    frameworkLogger.log("codex-injector", "tool.execute.before hook error", "error", {
+                        jobId,
+                        error: error instanceof Error ? error.message : String(error),
+                        tool: input.tool,
+                    });
+                    frameworkLogger.log("codex-injector", "tool-execute-before-hook-error", "error", {
+                        error,
+                        message: "Error in tool.execute.before hook",
+                        jobId,
+                        tool: input.tool,
+                    });
+                    // For blocking violations, re-throw to prevent action
+                    if (error instanceof Error &&
+                        error.message.includes("Codex enforcement blocked action")) {
+                        throw error;
+                    }
+                    // For other errors, log but allow action to prevent breaking workflow
+                }
+            },
+            "tool.execute.after": async (input, output, sessionId) => {
+                const jobId = `tool-after-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+                try {
+                    frameworkLogger.log("codex-injector", "tool.execute.after hook triggered", "info", { jobId, tool: input.tool, sessionId });
+                    // Skip codex enforcement during testing
+                    if (process.env.NODE_ENV === "test" ||
+                        process.env.XRAY_TEST_MODE === "true") {
+                        frameworkLogger.log("codex-injector", "skipping injection in test mode", "info", { jobId });
+                        return output;
+                    }
+                    if (!["read", "write", "edit", "multiedit", "batch"].includes(input.tool)) {
+                        frameworkLogger.log("codex-injector", "non-critical tool - no injection", "info", { jobId, tool: input.tool });
+                        return output;
+                    }
+                    await frameworkLogger.log("codex-injector", "-xray-tool-execution-hook-triggered-for-input", "info", {
+                        message: `🔧 0xRay: Tool execution hook triggered for ${input.tool}`,
+                    });
+                    const codexContexts = await loadCodexContext(sessionId);
+                    await frameworkLogger.log("codex-injector", "-xray-loaded-codexcontexts-length-codex-conte", "info", {
+                        message: `📚 0xRay: Loaded ${codexContexts.length} codex contexts`,
+                    });
+                    frameworkLogger.log("codex-injector", "codex contexts loaded for injection", "success", {
+                        jobId,
+                        contextCount: codexContexts.length,
+                        tool: input.tool,
+                    });
+                    if (codexContexts.length === 0) {
+                        return output;
+                    }
+                    const formattedCodex = formatCodexContext(codexContexts, sessionId);
+                    const injectedOutput = {
+                        ...output,
+                        output: `${formattedCodex}\n${output.output || ""}`,
+                    };
+                    frameworkLogger.log("codex-injector", "codex context injected into output", "success", {
+                        jobId,
+                        tool: input.tool,
+                        outputLength: injectedOutput.output?.length,
+                    });
+                    return injectedOutput;
+                }
+                catch (error) {
+                    frameworkLogger.log("codex-injector", "tool.execute.after hook error", "error", {
+                        jobId,
+                        error: error instanceof Error ? error.message : String(error),
+                        tool: input.tool,
+                    });
+                    frameworkLogger.log("codex-injector", "tool-execute-after-hook-error", "error", {
+                        error,
+                        message: "Error in tool.execute.after hook",
+                        jobId,
+                        tool: input.tool,
+                    });
+                    // Return original output on error to not break the session
+                    return output;
+                }
+            },
+        },
+    };
+}
+/**
+ * Get codex statistics for debugging
+ */
+export function getCodexStats(sessionId) {
+    const contexts = codexCache.get(sessionId);
+    if (!contexts || contexts.length === 0) {
+        return {
+            loaded: false,
+            fileCount: 0,
+            totalTerms: 0,
+            version: "unknown",
+        };
+    }
+    const totalTerms = contexts.reduce((sum, ctx) => sum + ctx.metadata.termCount, 0);
+    return {
+        loaded: true,
+        fileCount: contexts.length,
+        totalTerms,
+        version: contexts[0].metadata.version,
+    };
+}
+/**
+ * Clear codex cache (useful for testing or forced reload)
+ */
+export function clearCodexCache(sessionId) {
+    if (sessionId) {
+        codexCache.delete(sessionId);
+    }
+    else {
+        codexCache.clear();
+    }
+}
+/**
+ * CodexInjector class for plugin compatibility
+ */
+export class CodexInjector {
+    injectCodexRules(context, options) {
+        // Implementation for plugin compatibility
+        return context;
+    }
+    getCodexStats() {
+        // Return aggregated stats for plugin
+        const allContexts = [];
+        for (const contexts of Array.from(codexCache.values())) {
+            allContexts.push(...contexts);
+        }
+        const totalTerms = allContexts.reduce((sum, ctx) => sum + ctx.metadata.termCount, 0);
+        return {
+            loaded: allContexts.length > 0,
+            fileCount: allContexts.length,
+            totalTerms,
+            version: allContexts.length > 0 ? allContexts[0].metadata.version : "unknown",
+        };
+    }
+    /**
+     * Permissive comment validation - recognizes that comments are beneficial
+     * Only flags truly problematic patterns, provides guidance not requirements
+     */
+    validateCommentsPermissively(content) {
+        const guidance = [];
+        const concerns = [];
+        const lines = content.split("\n");
+        let commentLines = 0;
+        let codeLines = 0;
+        let todoCount = 0;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip empty lines
+            if (!trimmed)
+                continue;
+            // Count code vs comments
+            if (trimmed.startsWith("//") ||
+                trimmed.startsWith("/*") ||
+                trimmed.startsWith("*") ||
+                trimmed.startsWith("*/")) {
+                commentLines++;
+            }
+            else {
+                codeLines++;
+            }
+            // Check for problematic patterns
+            if (trimmed.includes("TODO") ||
+                trimmed.includes("FIXME") ||
+                trimmed.includes("XXX")) {
+                todoCount++;
+            }
+        }
+        // Provide helpful guidance (not requirements)
+        const commentRatio = commentLines / (commentLines + codeLines);
+        if (commentLines === 0 && codeLines > 30) {
+            guidance.push("💡 Consider adding comments for complex logic - they improve maintainability");
+        }
+        if (commentRatio > 0.4) {
+            guidance.push("💡 High comment ratio detected - consider if code can be made more self-explanatory");
+        }
+        if (todoCount > 3) {
+            concerns.push("⚠️ Multiple unresolved tasks detected - consider addressing or documenting timelines");
+        }
+        // Recognize good commenting practices
+        if (commentRatio > 0.1 && commentRatio < 0.3) {
+            guidance.push("✅ Good balance of code and comments detected");
+        }
+        return { guidance, concerns };
+    }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Configuration Loader (backward-compat shim)
+ *
+ * Delegates to FeaturesConfigLoader as the single source of truth.
+ * Retained for backward compatibility -- all consumers of xrayConfigLoader
+ * continue to work without changes.
+ *
+ * @deprecated Use featuresConfigLoader from "./features-config.js" instead.
+ * Will be removed in v4.0.0.
+ */
+export type { MultiAgentOrchestrationConfig, AutonomousReportingConfig } from "./features-config.js";
+export interface XrayConfig {
+    multi_agent_orchestration: import("./features-config.js").MultiAgentOrchestrationConfig;
+    autonomous_reporting: import("./features-config.js").AutonomousReportingConfig;
+    disabled_agents: string[];
+}
+export declare class XrayConfigLoader {
+    private configPath;
+    private cachedConfig;
+    private cacheExpiry;
+    private lastLoadTime;
+    constructor(configPath?: string);
+    /**
+     * Load configuration -- delegates to FeaturesConfigLoader
+     * @deprecated Use featuresConfigLoader.getXrayConfig() instead.
+     */
+    loadConfig(): XrayConfig;
+    /**
+     * Parse configuration data with validation
+     * @deprecated Use featuresConfigLoader.loadConfig() instead.
+     */
+    private parseConfig;
+    /**
+     * Parse multi-agent orchestration configuration
+     * @deprecated Use featuresConfigLoader.loadConfig().multi_agent_orchestration instead.
+     */
+    private parseMultiAgentConfig;
+    /**
+     * Parse autonomous reporting configuration
+     * @deprecated Use featuresConfigLoader.loadConfig().autonomous_reporting instead.
+     */
+    private parseAutonomousReportingConfig;
+    /**
+     * Get default configuration
+     * @deprecated Use featuresConfigLoader.getDefaultConfig() instead.
+     */
+    private getDefaultConfig;
+    /**
+     * Validate enum values
+     * @deprecated Internal implementation detail.
+     */
+    private validateEnum;
+    /**
+     * Clear configuration cache
+     * @deprecated Use featuresConfigLoader.clearCache() instead.
+     */
+    clearCache(): void;
+}
+export declare const xrayConfigLoader: XrayConfigLoader;

package/dist/core/config-loader.js

@@ -0,0 +1,157 @@
+/**
+ * Configuration Loader (backward-compat shim)
+ *
+ * Delegates to FeaturesConfigLoader as the single source of truth.
+ * Retained for backward compatibility -- all consumers of xrayConfigLoader
+ * continue to work without changes.
+ *
+ * @deprecated Use featuresConfigLoader from "./features-config.js" instead.
+ * Will be removed in v4.0.0.
+ */
+import { featuresConfigLoader } from "./features-config.js";
+import { frameworkLogger } from "./framework-logger.js";
+import { resolveConfigPath } from "./config-paths.js";
+import * as fs from "fs";
+import * as path from "path";
+export class XrayConfigLoader {
+    configPath;
+    cachedConfig = null;
+    cacheExpiry = 30000;
+    lastLoadTime = 0;
+    constructor(configPath) {
+        this.configPath = configPath || resolveConfigPath("config.json") || path.join(process.cwd(), ".xray", "config.json");
+    }
+    /**
+     * Load configuration -- delegates to FeaturesConfigLoader
+     * @deprecated Use featuresConfigLoader.getXrayConfig() instead.
+     */
+    loadConfig() {
+        const now = Date.now();
+        if (this.cachedConfig && now - this.lastLoadTime < this.cacheExpiry) {
+            return this.cachedConfig;
+        }
+        const primary = featuresConfigLoader.getXrayConfig();
+        try {
+            const configPath = path.resolve(process.cwd(), this.configPath);
+            if (fs.existsSync(configPath)) {
+                const configData = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                if (configData.multi_agent_orchestration || configData.autonomous_reporting || configData.disabled_agents) {
+                    frameworkLogger.log("config-loader", "deprecated-config-json", "warning", { message: "config.json contains overlapping keys. Migrate to features.json. See: https://0xray.ai/docs/config-migration" });
+                }
+            }
+        }
+        catch {
+            // config.json may not exist -- that's fine, features.json is SSOT
+        }
+        this.cachedConfig = primary;
+        this.lastLoadTime = now;
+        return primary;
+    }
+    /**
+     * Parse configuration data with validation
+     * @deprecated Use featuresConfigLoader.loadConfig() instead.
+     */
+    parseConfig(configData) {
+        if (!configData || typeof configData !== 'object') {
+            return this.getDefaultConfig();
+        }
+        const data = configData;
+        return {
+            multi_agent_orchestration: this.parseMultiAgentConfig(data.multi_agent_orchestration),
+            autonomous_reporting: this.parseAutonomousReportingConfig(data.autonomous_reporting),
+            disabled_agents: Array.isArray(data.disabled_agents)
+                ? data.disabled_agents
+                : [],
+        };
+    }
+    /**
+     * Parse multi-agent orchestration configuration
+     * @deprecated Use featuresConfigLoader.loadConfig().multi_agent_orchestration instead.
+     */
+    parseMultiAgentConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return this.getDefaultConfig().multi_agent_orchestration;
+        }
+        const cfg = config;
+        return {
+            enabled: typeof cfg.enabled === 'boolean' ? cfg.enabled : true,
+            coordination_model: this.validateEnum(cfg.coordination_model, ["async-multi-agent", "sync-multi-agent"], "async-multi-agent"),
+            max_concurrent_agents: Math.max(1, Math.min(10, typeof cfg.max_concurrent_agents === 'number' ? cfg.max_concurrent_agents : 3)),
+            task_distribution_strategy: this.validateEnum(cfg.task_distribution_strategy, ["capability-based", "load-balanced", "round-robin"], "capability-based"),
+            conflict_resolution: this.validateEnum(cfg.conflict_resolution, ["expert-priority", "majority-vote", "consensus"], "expert-priority"),
+            progress_tracking: typeof cfg.progress_tracking === 'boolean' ? cfg.progress_tracking : true,
+            session_persistence: typeof cfg.session_persistence === 'boolean' ? cfg.session_persistence : true,
+        };
+    }
+    /**
+     * Parse autonomous reporting configuration
+     * @deprecated Use featuresConfigLoader.loadConfig().autonomous_reporting instead.
+     */
+    parseAutonomousReportingConfig(config) {
+        if (!config || typeof config !== 'object') {
+            return this.getDefaultConfig().autonomous_reporting;
+        }
+        const cfg = config;
+        return {
+            enabled: typeof cfg.enabled === 'boolean' ? cfg.enabled : true,
+            interval_minutes: Math.max(5, Math.min(1440, typeof cfg.interval_minutes === 'number' ? cfg.interval_minutes : 60)),
+            auto_schedule: typeof cfg.auto_schedule === 'boolean' ? cfg.auto_schedule : true,
+            include_health_assessment: typeof cfg.include_health_assessment === 'boolean' ? cfg.include_health_assessment : true,
+            include_agent_activities: typeof cfg.include_agent_activities === 'boolean' ? cfg.include_agent_activities : true,
+            include_pipeline_operations: typeof cfg.include_pipeline_operations === 'boolean' ? cfg.include_pipeline_operations : true,
+            include_critical_issues: typeof cfg.include_critical_issues === 'boolean' ? cfg.include_critical_issues : true,
+            include_recommendations: typeof cfg.include_recommendations === 'boolean' ? cfg.include_recommendations : true,
+            report_retention_days: Math.max(1, Math.min(365, typeof cfg.report_retention_days === 'number' ? cfg.report_retention_days : 30)),
+            notification_channels: Array.isArray(cfg.notification_channels)
+                ? cfg.notification_channels.filter((ch) => ["console", "file", "webhook"].includes(ch))
+                : ["console"],
+        };
+    }
+    /**
+     * Get default configuration
+     * @deprecated Use featuresConfigLoader.getDefaultConfig() instead.
+     */
+    getDefaultConfig() {
+        return {
+            multi_agent_orchestration: {
+                enabled: true,
+                coordination_model: "async-multi-agent",
+                max_concurrent_agents: 3,
+                task_distribution_strategy: "capability-based",
+                conflict_resolution: "expert-priority",
+                progress_tracking: true,
+                session_persistence: true,
+            },
+            autonomous_reporting: {
+                enabled: true,
+                interval_minutes: 60,
+                auto_schedule: true,
+                include_health_assessment: true,
+                include_agent_activities: true,
+                include_pipeline_operations: true,
+                include_critical_issues: true,
+                include_recommendations: true,
+                report_retention_days: 30,
+                notification_channels: ["console"],
+            },
+            disabled_agents: [],
+        };
+    }
+    /**
+     * Validate enum values
+     * @deprecated Internal implementation detail.
+     */
+    validateEnum(value, allowedValues, defaultValue) {
+        return allowedValues.includes(value) ? value : defaultValue;
+    }
+    /**
+     * Clear configuration cache
+     * @deprecated Use featuresConfigLoader.clearCache() instead.
+     */
+    clearCache() {
+        this.cachedConfig = null;
+        this.lastLoadTime = 0;
+        featuresConfigLoader.clearCache();
+    }
+}
+export const xrayConfigLoader = new XrayConfigLoader();