0xray 4.0.12 → 4.0.13

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

@@ -1,264 +0,0 @@
-/**
- * 0xRay Lean System Prompt Generator
- *
- * Generates optimized, token-efficient system prompts by implementing
- * selective injection and smart compression strategies.
- *
- * @since 2026-03-03
- */
-import { XrayContextLoader } from "./context-loader.js";
-import { validateContext, preventSystemPromptBloat } from "./context-validator.js";
-import fs from "fs";
-import path from "path";
-/**
- * Get the current framework version from package.json
- */
-function getFrameworkVersion() {
-    try {
-        const packageJsonPath = path.join(process.cwd(), "package.json");
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-        return packageJson.version || "1.4.6";
-    }
-    catch {
-        return "1.4.6";
-    }
-}
-/**
- * Essential codex terms (blocking enforcement only)
- */
-const ESSENTIAL_TERMS = [
-    {
-        number: 1,
-        title: "Progressive Prod-Ready Code",
-        description: "All code must be production-ready from the first commit."
-    },
-    {
-        number: 2,
-        title: "No Patches/Boiler/Stubs/Bridge Code",
-        description: "Prohibit temporary patches and boilerplate code."
-    },
-    {
-        number: 7,
-        title: "Resolve All Errors (90% Runtime Prevention)",
-        description: "Zero-tolerance for unresolved errors.",
-        zeroTolerance: true,
-        enforcementLevel: "blocking"
-    },
-    {
-        number: 8,
-        title: "Prevent Infinite Loops",
-        description: "Guarantee termination in all iterative processes.",
-        zeroTolerance: true,
-        enforcementLevel: "blocking"
-    },
-    {
-        number: 11,
-        title: "Type Safety First",
-        description: "Never use `any`, `@ts-ignore`, or `@ts-expect-error`.",
-        zeroTolerance: true,
-        enforcementLevel: "blocking"
-    },
-    {
-        number: 5,
-        title: "Surgical Changes Only",
-        description: "Read first. Understand context. Fix root cause only. Minimal changes. Never refactor unless asked.",
-        zeroTolerance: false,
-        enforcementLevel: "critical"
-    }
-];
-/**
- * Rules for code-writing agents (surgical changes)
- */
-const SURGICAL_CHANGE_RULES = `
-## Surgical Change Rules (Code Writers)
-When writing or fixing code:
-1. READ the entire file before making any changes
-2. UNDERSTAND the existing code - trace logic, understand patterns
-3. FIX only the root cause - never rewrite working code
-4. PRESERVE existing functionality - never simplify logic
-5. If a fix is complex: mark as TODO with explanation, do not skip
-6. ALWAYS attempt to fix - never simplify to "make it work"
-7. Tests: attempt fix first, only skip if truly blocked, return to later
-
-## Test Fixing Rules
-When fixing tests:
-1. NEVER simplify tests to make them pass
-2. If test is wrong: fix the code, not the test
-3. If blocked: add TODO comment, return to later
-4. Only skip tests with explicit TODO and reason
-`;
-/**
- * Lean welcome banner (minimal version)
- */
-function getLeanWelcomeBanner() {
-    const version = getFrameworkVersion();
-    return `0xRay Framework v${version} - AI Orchestration Engine
-
-🔧 Core: enforcer, architect, orchestrator, code-reviewer, refactorer, testing-lead
-📚 Codex: 5 Essential Terms (99.6% Error Prevention Target)
-🎯 Goal: Progressive, production-ready development workflow
-
-`;
-}
-/**
- * Format critical codex terms for injection
- */
-function formatEssentialTerms() {
-    const parts = ["## Essential 0xRay Rules (Blocking Enforcement)"];
-    for (const term of ESSENTIAL_TERMS) {
-        const termNum = term.number;
-        const zeroTolBadge = term.zeroTolerance ? " ⚠️ ZERO TOLERANCE" : " 🟡 High Priority";
-        parts.push(`\n**${termNum}. ${term.title}** ${zeroTolBadge}\n${term.description}`);
-    }
-    parts.push("\n🔗 Key: config dir (codex, config, agents docs) — resolved via config-paths");
-    return parts.join("");
-}
-/**
- * Generate optimized system prompt with bloat prevention
- */
-export async function generateLeanSystemPrompt(config = {}) {
-    const { showWelcomeBanner = true, showCodexContext = false, // Disabled by default for token efficiency
-    enableTokenOptimization = true, maxTokenBudget = 8192, // Increased token budget
-    showCriticalTermsOnly = true, showEssentialLinks = true } = config;
-    let systemPrompt = "";
-    // 1. Welcome banner (minimal if enabled)
-    if (showWelcomeBanner) {
-        const banner = getLeanWelcomeBanner();
-        if (banner.length < maxTokenBudget * 0.2) { // 20% of budget
-            systemPrompt += banner;
-        }
-    }
-    // 2. Critical terms only (major token savings)
-    if (showCriticalTermsOnly) {
-        const essentialTerms = formatEssentialTerms();
-        if ((systemPrompt.length + essentialTerms.length) < maxTokenBudget * 0.6) { // 60% of budget
-            systemPrompt += essentialTerms;
-        }
-    }
-    // 3. Full codex context only if explicitly enabled and within budget
-    let finalPrompt = systemPrompt;
-    if (showCodexContext && enableTokenOptimization) {
-        try {
-            const contextLoader = XrayContextLoader.getInstance();
-            const loadResult = await contextLoader.loadCodexContext(process.cwd());
-            if (loadResult.success && loadResult.context) {
-                const codexSummary = generateCodexSummary(loadResult.context, maxTokenBudget);
-                // Combine and validate total prompt
-                const combinedPrompt = `${systemPrompt}\n\n${codexSummary}`;
-                const validation = validateContext(combinedPrompt, {
-                    maxTotalPromptLength: maxTokenBudget * 2,
-                    enableCompression: true,
-                    preventDuplicateContent: true
-                });
-                if (validation.isValid) {
-                    finalPrompt = combinedPrompt;
-                }
-                else {
-                    // Use optimized version if validation fails
-                    finalPrompt = validation.optimizedContent || combinedPrompt;
-                }
-            }
-        }
-        catch (error) {
-            // Silent fallback - prompt generation should not break
-            finalPrompt = systemPrompt;
-        }
-    }
-    else {
-        finalPrompt = systemPrompt;
-    }
-    // 4. Apply bloat prevention to final prompt
-    let safePrompt = preventSystemPromptBloat(finalPrompt);
-    // 5. Essential links if space permits
-    if (showEssentialLinks && safePrompt.length < 1500) {
-        safePrompt += "\n📖 Documentation: config dir | AGENTS.md\n";
-    }
-    // Final validation and fallback
-    if (safePrompt.length < 100) {
-        return generateMinimalFallbackPrompt();
-    }
-    return safePrompt;
-}
-/**
- * Generate compressed codex summary
- */
-function generateCodexSummary(context, maxTokens) {
-    const parts = ["\n## 0xRay Codex Summary"];
-    // Add just the most essential metadata
-    parts.push(`\nVersion: ${context.version}`);
-    parts.push(`Terms: ${context.terms?.size || 0} total`);
-    parts.push(`Last Updated: ${context.lastUpdated}`);
-    // Only add validation criteria if space permits
-    if (context.validationCriteria && parts.join("").length < maxTokens * 0.8) {
-        parts.push(`\n📋 Validation: ${Object.entries(context.validationCriteria).filter(([_, v]) => v).length}/${Object.keys(context.validationCriteria).length} criteria met`);
-    }
-    return parts.join("");
-}
-/**
- * Absolute minimal fallback prompt
- */
-function generateMinimalFallbackPrompt() {
-    return `0xRay Framework v${getFrameworkVersion()}
-Essential: Production-ready code, zero-tolerance errors, type safety
-📖: config dir (resolved via config-paths) | AGENTS.md
-`;
-}
-/**
- * Smart context injection based on available tokens
- */
-export function injectContextIntelligently(basePrompt, additionalContext, maxTokens = 4000) {
-    const availableTokens = maxTokens - basePrompt.length;
-    if (availableTokens <= 0) {
-        return basePrompt; // No room for additional context
-    }
-    // Compress additional context if needed
-    if (additionalContext.length > availableTokens) {
-        additionalContext = compressContext(additionalContext, availableTokens * 0.8);
-    }
-    return basePrompt + "\n\n" + additionalContext;
-}
-/**
- * Context compression utilities
- */
-function compressContext(context, targetLength) {
-    if (context.length <= targetLength)
-        return context;
-    // Simple compression: remove whitespace, keep first lines
-    const lines = context.split('\n').filter(line => line.trim());
-    const compressed = [];
-    let currentLength = 0;
-    for (const line of lines) {
-        if (currentLength + line.length <= targetLength) {
-            compressed.push(line);
-            currentLength += line.length;
-        }
-        else {
-            break;
-        }
-    }
-    return compressed.join('\n') + '\n... (truncated)';
-}
-/**
- * System prompt validation
- */
-export function validateSystemPrompt(prompt) {
-    const warnings = [];
-    const maxLength = 8000; // Safety limit
-    if (prompt.length > maxLength) {
-        warnings.push(`Prompt exceeds maximum length: ${prompt.length} > ${maxLength}`);
-    }
-    if (prompt.length < 200) {
-        warnings.push('Prompt may be too short for effective operation');
-    }
-    // Check for problematic patterns
-    if (prompt.includes('══════════')) {
-        warnings.push('ASCII art detected - consuming excessive tokens');
-    }
-    if (prompt.includes('v1.6.22') && prompt.includes('v1.2.25')) {
-        warnings.push('Duplicate context blocks detected');
-    }
-    return {
-        valid: warnings.length === 0,
-        warnings
-    };
-}

package/dist/core/trace-context.d.ts

@@ -1,12 +0,0 @@
-export interface TraceContext {
-    traceId: string;
-    parentId?: string;
-    operation: string;
-    governanceApproved: boolean;
-    startTime: number;
-    metadata?: Record<string, any>;
-}
-export declare function startTrace(operation: string, metadata?: Record<string, any>): TraceContext;
-export declare function getCurrentTrace(): TraceContext | null;
-export declare function endTrace(approved?: boolean): void;
-export declare function propagateTrace(childOperation: string): TraceContext | null;

package/dist/core/trace-context.js

@@ -1,33 +0,0 @@
-// 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.d.ts

@@ -1,14 +0,0 @@
-/**
- * Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks).
- */
-export interface XrayActivationConfig {
-    enableOrchestrator: boolean;
-    enableBootOrchestrator: boolean;
-    enableStateManagement: boolean;
-    enableHooks: boolean;
-    enableCodexInjection: boolean;
-    enableProcessors: boolean;
-    enablePostProcessor: boolean;
-}
-export declare const defaultXrayConfig: XrayActivationConfig;
-export declare function activateXrayFramework(config?: Partial<XrayActivationConfig>): Promise<void>;

package/dist/core/xray-activation.js

@@ -1,135 +0,0 @@
-/**
- * Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks).
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-import { ensureCriticalComponents } from "../architect/architectural-integrity.js";
-import { validateRegistryConsistency } from "../agents/registry.js";
-export const defaultXrayConfig = {
-    enableOrchestrator: true,
-    enableBootOrchestrator: true,
-    enableStateManagement: true,
-    enableHooks: true,
-    enableCodexInjection: true,
-    enableProcessors: true,
-    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("xray-activation", "beginning xray framework activation", "info", { jobId, ...activationConfig });
-    const registryValidation = validateRegistryConsistency();
-    if (!registryValidation.valid) {
-        frameworkLogger.log("xray-activation", "registry-validation-failed", "warning", { errors: registryValidation.errors });
-    }
-    try {
-        if (activationConfig.enableCodexInjection) {
-            await activateCodexInjection(jobId);
-        }
-        if (activationConfig.enableHooks) {
-            await activateHooks(jobId);
-        }
-        if (activationConfig.enableOrchestrator) {
-            await activateOrchestrator(jobId);
-        }
-        if (activationConfig.enableBootOrchestrator) {
-            await activateBootOrchestrator(jobId);
-        }
-        if (activationConfig.enableStateManagement) {
-            await activateStateManagement(jobId);
-        }
-        if (activationConfig.enableProcessors) {
-            await activateProcessors(jobId);
-        }
-        if (activationConfig.enablePostProcessor) {
-            await activatePostProcessor(jobId);
-        }
-        // 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("xray-activation", "xray framework activation completed successfully", "success", { jobId });
-    }
-    catch (error) {
-        await frameworkLogger.log("xray-activation", "framework-activation-failed", "error", { jobId, error: String(error) });
-        throw error;
-    }
-}
-async function activateCodexInjection(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("xray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
-}
-async function activateHooks(jobId) {
-    try {
-        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("xray-activation", "xray hooks activated", "success", {
-            jobId,
-            hookName: hook.name,
-            hooksRegistered: globalThis.xrayHooks.length
-        });
-    }
-    catch (error) {
-        await frameworkLogger.log("xray-activation", "hooks activation failed", "error", { jobId, error: String(error) });
-    }
-}
-async function activateBootOrchestrator(jobId) {
-    frameworkLogger.log("xray-activation", "activating boot orchestrator", "info", { jobId });
-    const { bootOrchestrator } = await import("./boot-orchestrator");
-    await bootOrchestrator.executeBootSequence();
-    frameworkLogger.log("xray-activation", "boot orchestrator activated", "success", { jobId });
-}
-async function activateStateManagement(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;
-    frameworkLogger.log("xray-activation", "state management activated", "success", { jobId });
-}
-async function activateOrchestrator(jobId) {
-    frameworkLogger.log("xray-activation", "activating xray orchestrator", "info", { jobId });
-    const { xrayOrchestrator } = await import("./orchestrator");
-    // Also activate the multi-agent orchestration coordinator
-    const { multiAgentOrchestrationCoordinator } = await import("../orchestrator/multi-agent-orchestration-coordinator");
-    frameworkLogger.log("xray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
-}
-async function activateProcessors(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;
-    frameworkLogger.log("xray-activation", "processor pipeline activated", "success", { jobId });
-}
-async function activatePostProcessor(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;
-    if (!stateManager) {
-        throw new Error("State manager not initialized - boot orchestrator must run first");
-    }
-    const postProcessor = new PostProcessor(stateManager, null, {});
-    globalThis.xrayPostProcessor = postProcessor;
-    frameworkLogger.log("xray-activation", "post-processor system activated", "success", { jobId });
-    const { pathResolver } = await import("../utils/path-resolver.js");
-    globalThis.xrayPathResolver = pathResolver;
-    frameworkLogger.log("xray-activation", "path resolver activated", "success", { jobId });
-    const { CodexInjector } = await import("./codex-injector.js");
-    const codexInjector = new CodexInjector();
-    globalThis.xrayCodexInjector = codexInjector;
-    frameworkLogger.log("xray-activation", "codex injector activated", "success", { jobId });
-}
-// Backward compat aliases

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

@@ -1,185 +0,0 @@
-/**
- * Agent Delegator
- *
- * Intelligent agent delegation system that uses complexity analysis to determine
- * optimal task distribution strategies and conflict resolution.
- *
- * Integrates with TaskSkillRouter for keyword-based preprocessing.
- *
- * @since 2026-01-07
- */
-import { ComplexityScore } from "./complexity-analyzer.js";
-import { XrayStateManager } from "../state/state-manager.js";
-import { xrayConfigLoader } from "../core/config-loader.js";
-import { type AggregatedMetrics, type MetricsExport } from "./metrics-aggregator.js";
-export interface AgentCapability {
-    name: string;
-    capabilities: string[];
-    expertise?: string[];
-    specialties?: string[];
-    status: "active" | "inactive";
-    [key: string]: string | string[] | boolean | number | undefined;
-}
-export interface DelegationContext {
-    workingDirectory?: string;
-    availableTools?: string[];
-    isDelegated?: boolean;
-    files?: string[];
-    dependencies?: string[];
-    changeVolume?: number;
-    riskLevel?: string;
-    [key: string]: unknown;
-}
-export interface DelegationResponse {
-    agent: string;
-    operation: string;
-    description: string;
-    capabilities: string[];
-    mode: string;
-    status: string;
-    timestamp: string;
-    message: string;
-}
-export interface DelegationRequest {
-    operation: string;
-    description: string;
-    context?: DelegationContext;
-    sessionId?: string;
-}
-export interface DelegationAnalysis {
-    strategy: "single-agent" | "multi-agent" | "orchestrator-led";
-    agents: string[];
-    agentDetails: Array<{
-        name: string;
-        confidence: number;
-        role: string;
-    }>;
-    complexity: ComplexityScore;
-    conflictResolution: "majority_vote" | "expert_priority" | "consensus";
-    estimatedDuration: number;
-    metrics?: Record<string, string | number | boolean>;
-}
-export interface DelegationResult {
-    success: boolean;
-    results: Array<{
-        agent: string;
-        output: DelegationResponse;
-        executionTime: number;
-    }>;
-    totalTime: number;
-    errors?: string[] | undefined;
-    agents?: string[];
-}
-export interface PerformanceMetrics {
-    totalDelegations: number;
-    successfulDelegations: number;
-    failedDelegations: number;
-    averageExecutionTime: number;
-    averageResponseTime: number;
-    averageComplexity: number;
-    averageDuration: number;
-    strategyUsage: Record<string, number>;
-    agentUtilization: Record<string, number>;
-}
-export interface DelegationMetrics extends PerformanceMetrics {
-    recentDelegations: Array<{
-        timestamp: number;
-        operation: string;
-        strategy: string;
-        success: boolean;
-        totalTime: number;
-    }>;
-}
-/**
- * AgentDelegator class for intelligent task delegation
- */
-export declare class AgentDelegator {
-    private complexityAnalyzer;
-    private stateManager;
-    private configLoader;
-    private kernel;
-    private agentMetrics;
-    /** Minimum confidence for a learned mapping to override hardcoded routing. */
-    private static readonly MAPPING_CONFIDENCE_THRESHOLD;
-    constructor(stateManager: XrayStateManager, configLoader: typeof xrayConfigLoader);
-    /**
-     * Load routing-mappings.json from disk (fresh each call — picks up tuner writes).
-     * Same path resolution as inference-tuner.ts.
-     */
-    private loadRoutingMappings;
-    /**
-     * Match a task description against learned keyword mappings.
-     * Returns the best matching mapping if any keyword hits above threshold.
-     */
-    private matchRoutingMappings;
-    getAvailableAgents(): AgentCapability[];
-    /**
-     * Pre-process a task description using TaskSkillRouter
-     * This extracts operation type and context from natural language descriptions
-     * before running complexity analysis
-     */
-    preprocessTaskDescription(description: string, options?: {
-        sessionId?: string;
-        taskId?: string;
-        complexity?: number;
-    }): {
-        operation: string;
-        context: Record<string, unknown>;
-        suggestedAgent: string;
-        suggestedSkill: string;
-        confidence: number;
-    };
-    analyzeDelegation(request: DelegationRequest): Promise<DelegationAnalysis>;
-    private determineAgents;
-    private mapOperationToType;
-    /**
-     * Record analysis results for learning system
-     */
-    private recordAnalysisForLearning;
-    private determineConflictResolution;
-    /**
-   * Resolve the project directory for delegated agents
-   * Ensures working directory is set correctly (src/ vs dist/ vs project root)
-   */
-    private resolveProjectDirectory;
-    /**
-     * Allowlist of valid agent names for dynamic imports
-     * Prevents path traversal and unauthorized agent loading
-     */
-    private static readonly ALLOWED_AGENTS;
-    /**
-     * Validate agent name for security
-     * @throws Error if agent name is invalid or not allowed
-     */
-    private validateAgentName;
-    /**
-     * Create a properly configured agent with full tool access and working directory context
-     */
-    private createProperlyConfiguredAgent;
-    /**
-     * Clear agent-stub creation and deprecated features
-     * Remove this method if it exists in the future version
-     */
-    private clearDeprecatedStubAgent;
-    executeDelegation(analysis: DelegationAnalysis, request: DelegationRequest): Promise<DelegationResult>;
-    getPerformanceMetrics(): PerformanceMetrics;
-    getDelegationMetrics(): DelegationMetrics;
-    aggregateAllMetrics(): {
-        delegation: AggregatedMetrics;
-        orchestration: AggregatedMetrics;
-    };
-    getMetricsByAgent(type?: "delegation" | "orchestration"): Record<string, unknown>;
-    getMetricsByComplexity(type?: "delegation" | "orchestration"): Record<string, unknown>;
-    getMetricsByTimePeriod(type?: "delegation" | "orchestration"): Record<string, unknown>;
-    rotateMetricsEntries(maxEntries?: number): {
-        delegation: number;
-        orchestration: number;
-    };
-    cleanupMetricsOlderThan(olderThanMs: number): {
-        delegation: number;
-        orchestration: number;
-    };
-    exportMetricsData(format?: "json" | "csv" | "summary"): MetricsExport;
-    updateAgentCapability(agentName: string, capabilities: Partial<AgentCapability>): void;
-}
-export declare function createAgentDelegator(stateManager: XrayStateManager, configLoader: typeof xrayConfigLoader): AgentDelegator;