0xray 4.0.11 → 4.0.13

package/dist/core/codex-injector.js

@@ -1,423 +0,0 @@
-/**
- * 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

@@ -1,59 +0,0 @@
-/**
- * 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

@@ -1,157 +0,0 @@
-/**
- * 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();