0xray 4.0.13 → 4.0.15

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

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

@@ -0,0 +1,12 @@
+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

@@ -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.d.ts

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

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

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