0xray 2.0.0 → 2.1.0

package/dist/core/model-router.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Model Router
+ *
+ * Intelligent model routing based on task complexity and type.
+ * Integrates with features-config for task-based model selection.
+ *
+ * @version 2.0.0
+ * @since 2026-01-25
+ */
+import { type TaskType } from "./features-config.js";
+interface TaskContext {
+    toolName?: string;
+    fileCount?: number;
+    isComplex?: boolean;
+    agentType?: string;
+}
+declare class ModelRouter {
+    private configPath;
+    private config;
+    private availableModels;
+    constructor(configPath?: string);
+    private loadConfig;
+    private discoverModels;
+    /**
+     * Get the appropriate model for a specific task context
+     * Uses features-config for task-based routing when available
+     */
+    getModelForTask(context: TaskContext): string;
+    /**
+     * Get validated model for agent type (legacy method)
+     */
+    getValidatedModel(agentType?: string): string;
+    /**
+     * Get model for a specific task type directly
+     */
+    getModelForTaskType(taskType: TaskType): string;
+    /**
+     * Get max tokens for a task type
+     */
+    getMaxTokensForTaskType(taskType: TaskType): number;
+    private getUserPreference;
+    private isModelAvailable;
+    /**
+     * Reload configuration from disk
+     */
+    reloadConfig(): void;
+    /**
+     * Get current configuration summary
+     */
+    getConfigSummary(): {
+        defaultModel: string;
+        fallbackModel: string;
+        taskRoutingEnabled: boolean;
+        availableModels: string[];
+    };
+}
+export declare const modelRouter: ModelRouter;
+export default modelRouter;
+export declare const getModelForTask: (context: TaskContext) => string;
+export declare const getModelForTaskType: (taskType: TaskType) => string;
+export declare const getValidatedModel: (agentType?: string) => string;

package/dist/core/orchestrator.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 0xRay Framework - Core Orchestrator
+ * Main orchestration engine for multi-agent task coordination
+ */
+import { TaskDefinition } from "../agents/types.js";
+export interface OrchestrationResult {
+    success: boolean;
+    taskId: string;
+    agentUsed: string;
+    duration: number;
+    result: unknown;
+    error?: string;
+    errors?: string[];
+}
+export interface OrchestratorConfig {
+    maxConcurrentTasks?: number;
+    taskTimeout?: number;
+    conflictResolutionStrategy?: "majority_vote" | "expert_priority";
+}
+export declare class KernelOrchestrator {
+    private taskQueue;
+    private activeTasks;
+    private totalProcessed;
+    private config;
+    private kernel;
+    constructor(config?: OrchestratorConfig);
+    executeTask(task: TaskDefinition): Promise<OrchestrationResult>;
+    /**
+     * Execute a single task by delegating to appropriate subagent
+     */
+    private executeSingleTask;
+    private dispatchToAgent;
+    executeComplexTask(description: string, tasks: TaskDefinition[], sessionId?: string): Promise<OrchestrationResult[]>;
+    private topologicalSort;
+    /**
+     * Validates that all task dependencies are within the current task batch.
+     * Prevents cross-orchestrator dependency errors by failing fast with a clear message.
+     */
+    private validateTaskDependencies;
+    executeComplexTaskSingle(task: TaskDefinition): Promise<OrchestrationResult>;
+    resolveConflicts(conflicts: Array<{
+        response?: unknown;
+        proposed?: unknown;
+        expertiseScore?: number;
+    }>): {
+        response: string;
+        expertiseScore: number;
+    };
+    private generateTaskId;
+    /**
+     * Delegate a task to a specific agent with timeout protection
+     */
+    delegateToSubagent(agentName: string, task: TaskDefinition): Promise<{
+        success: boolean;
+        result: unknown;
+        agentName: string;
+        executionTime: number;
+    }>;
+    private performDelegation;
+    getStatus(): {
+        queueSize: number;
+        activeTasks: number;
+        totalProcessed: number;
+        config: {
+            maxConcurrentTasks: number;
+            taskTimeout: number;
+            conflictResolutionStrategy: "majority_vote" | "expert_priority";
+        };
+    };
+}
+export declare const xrayOrchestrator: KernelOrchestrator;
+export declare const strRayOrchestrator: KernelOrchestrator;

package/dist/core/orchestrator.js

@@ -267,7 +267,7 @@ export class KernelOrchestrator {
                 `B) Use a single orchestrator for all dependent tasks\n` +
                 `C) Remove the dependency if it's not needed\n\n` +
                 `Example of correct usage:\n` +
-                `  const orch = new StringRayOrchestrator();\n` +
+                `  const orch = new XrayOrchestrator();\n` +
                 `  await orch.executeComplexTask("test", [\n` +
                 `    { id: "task-1" },\n` +
                 `    { id: "task-2", dependencies: ["task-1"] }  // ✅ Same orchestrator\n` +
@@ -405,4 +405,5 @@ export class KernelOrchestrator {
         };
     }
 }
-export const strRayOrchestrator = new KernelOrchestrator();
+export const xrayOrchestrator = new KernelOrchestrator();
+export const strRayOrchestrator = xrayOrchestrator; // backward compat

package/dist/core/system-prompt-generator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 0xRay Lean System Prompt Generator
+ *
+ * Generates optimized, token-efficient system prompts by implementing
+ * selective injection and smart compression strategies.
+ *
+ * @version 1.0.0
+ * @since 2026-03-03
+ */
+/**
+ * System prompt configuration options
+ */
+export interface SystemPromptConfig {
+    showWelcomeBanner?: boolean;
+    showCodexContext?: boolean;
+    enableTokenOptimization?: boolean;
+    maxTokenBudget?: number;
+    showCriticalTermsOnly?: boolean;
+    showEssentialLinks?: boolean;
+}
+/**
+ * Generate optimized system prompt with bloat prevention
+ */
+export declare function generateLeanSystemPrompt(config?: SystemPromptConfig): Promise<string>;
+/**
+ * Smart context injection based on available tokens
+ */
+export declare function injectContextIntelligently(basePrompt: string, additionalContext: string, maxTokens?: number): string;
+/**
+ * System prompt validation
+ */
+export declare function validateSystemPrompt(prompt: string): {
+    valid: boolean;
+    warnings: string[];
+};

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

@@ -7,7 +7,7 @@
  * @version 1.0.0
  * @since 2026-03-03
  */
-import { StringRayContextLoader } from "./context-loader.js";
+import { XrayContextLoader } from "./context-loader.js";
 import { validateContext, preventSystemPromptBloat } from "./context-validator.js";
 import fs from "fs";
 import path from "path";
@@ -140,7 +140,7 @@ export async function generateLeanSystemPrompt(config = {}) {
     let finalPrompt = systemPrompt;
     if (showCodexContext && enableTokenOptimization) {
         try {
-            const contextLoader = StringRayContextLoader.getInstance();
+            const contextLoader = XrayContextLoader.getInstance();
             const loadResult = await contextLoader.loadCodexContext(process.cwd());
             if (loadResult.success && loadResult.context) {
                 const codexSummary = generateCodexSummary(loadResult.context, maxTokenBudget);

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/xray-activation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 0xRay activation — reads config from .xray/ runtime state directory.
+ */
+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,10 +1,10 @@
 /**
- * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks).
+ * 0xRay activation — reads config from .xray/ runtime state directory.
  */
 import { frameworkLogger } from "../core/framework-logger.js";
 import { ensureCriticalComponents } from "../architect/architectural-integrity.js";
 import { validateRegistryConsistency } from "../agents/registry.js";
-export const defaultStringRayConfig = {
+export const defaultXrayConfig = {
     enableOrchestrator: true,
     enableBootOrchestrator: true,
     enableStateManagement: true,
@@ -13,9 +13,9 @@ export const defaultStringRayConfig = {
     enableProcessors: true,
     enablePostProcessor: true,
 };
-export async function activateStringRayFramework(config = {}) {
+export async function activateXrayFramework(config = {}) {
     const jobId = `activation-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-    const activationConfig = { ...defaultStringRayConfig, ...config };
+    const activationConfig = { ...defaultXrayConfig, ...config };
     // Banner display moved to init.sh execution in plugin
     // Framework activation proceeds quietly
     frameworkLogger.log("stringray-activation", "beginning xray framework activation", "info", { jobId, ...activationConfig });
@@ -57,25 +57,25 @@ export async function activateStringRayFramework(config = {}) {
 }
 async function activateCodexInjection(jobId) {
     frameworkLogger.log("stringray-activation", "activating codex injection", "info", { jobId });
-    const { createStringRayCodexInjectorHook } = await import("./codex-injector.js");
-    const hook = createStringRayCodexInjectorHook();
-    globalThis.strRayHooks = globalThis.strRayHooks || [];
-    globalThis.strRayHooks.push(hook);
+    const { createXrayCodexInjectorHook } = await import("./codex-injector.js");
+    const hook = createXrayCodexInjectorHook();
+    globalThis.xrayHooks = globalThis.xrayHooks || [];
+    globalThis.xrayHooks.push(hook);
     frameworkLogger.log("stringray-activation", "codex injection activated", "success", { jobId, hookName: hook.name });
 }
 async function activateHooks(jobId) {
     try {
         frameworkLogger.log("stringray-activation", "activating xray hooks", "info", { jobId });
         // Create and register the Codex injector hook
-        const { createStringRayCodexInjectorHook } = await import("./codex-injector");
-        const hook = createStringRayCodexInjectorHook();
+        const { createXrayCodexInjectorHook } = await import("./codex-injector");
+        const hook = createXrayCodexInjectorHook();
         // Store hook globally for OpenCode to pick up
-        globalThis.strRayHooks = globalThis.strRayHooks || [];
-        globalThis.strRayHooks.push(hook);
+        globalThis.xrayHooks = globalThis.xrayHooks || [];
+        globalThis.xrayHooks.push(hook);
         frameworkLogger.log("stringray-activation", "xray hooks activated", "success", {
             jobId,
             hookName: hook.name,
-            hooksRegistered: globalThis.strRayHooks.length
+            hooksRegistered: globalThis.xrayHooks.length
         });
     }
     catch (error) {
@@ -90,15 +90,16 @@ async function activateBootOrchestrator(jobId) {
 }
 async function activateStateManagement(jobId) {
     frameworkLogger.log("stringray-activation", "activating state management", "info", { jobId });
-    const { StringRayStateManager } = await import("../state/state-manager");
-    const stateManager = new StringRayStateManager();
+    const { XrayStateManager } = await import("../state/state-manager");
+    const stateManager = new XrayStateManager();
     // Store the state manager instance globally for framework use
-    globalThis.strRayStateManager = stateManager;
+    globalThis.xrayStateManager = stateManager;
+    globalThis.strRayStateManager = stateManager; // backward compat
     frameworkLogger.log("stringray-activation", "state management activated", "success", { jobId });
 }
 async function activateOrchestrator(jobId) {
     frameworkLogger.log("stringray-activation", "activating xray orchestrator", "info", { jobId });
-    const { strRayOrchestrator } = await import("./orchestrator");
+    const { xrayOrchestrator } = await import("./orchestrator");
     // Also activate the multi-agent orchestration coordinator
     const { multiAgentOrchestrationCoordinator } = await import("../orchestrator/multi-agent-orchestration-coordinator");
     frameworkLogger.log("stringray-activation", "xray orchestrator and multi-agent coordination activated", "success", { jobId });
@@ -106,29 +107,33 @@ async function activateOrchestrator(jobId) {
 async function activateProcessors(jobId) {
     frameworkLogger.log("stringray-activation", "activating processor pipeline", "info", { jobId });
     const { ProcessorManager } = await import("../processors/processor-manager");
-    const { StringRayStateManager } = await import("../state/state-manager");
-    const stateManager = new StringRayStateManager();
+    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.strRayProcessorManager = processorManager;
+    globalThis.xrayProcessorManager = processorManager;
+    globalThis.strRayProcessorManager = processorManager; // backward compat
     frameworkLogger.log("stringray-activation", "processor pipeline activated", "success", { jobId });
 }
 async function activatePostProcessor(jobId) {
     frameworkLogger.log("stringray-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.strRayStateManager;
+    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.strRayPostProcessor = postProcessor;
+    globalThis.xrayPostProcessor = postProcessor;
+    globalThis.strRayPostProcessor = postProcessor; // backward compat
     frameworkLogger.log("stringray-activation", "post-processor system activated", "success", { jobId });
     const { pathResolver } = await import("../utils/path-resolver.js");
-    globalThis.strRayPathResolver = pathResolver;
+    globalThis.xrayPathResolver = pathResolver;
+    globalThis.strRayPathResolver = pathResolver; // backward compat
     frameworkLogger.log("stringray-activation", "path resolver activated", "success", { jobId });
     const { CodexInjector } = await import("./codex-injector.js");
     const codexInjector = new CodexInjector();
-    globalThis.strRayCodexInjector = codexInjector;
+    globalThis.xrayCodexInjector = codexInjector;
+    globalThis.strRayCodexInjector = codexInjector; // backward compat
     frameworkLogger.log("stringray-activation", "codex injector activated", "success", { jobId });
 }

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

@@ -0,0 +1,186 @@
+/**
+ * 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.
+ *
+ * @version 1.1.0
+ * @since 2026-01-07
+ */
+import { ComplexityScore } from "./complexity-analyzer.js";
+import { XrayStateManager } from "../state/state-manager.js";
+import { strRayConfigLoader } 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 strRayConfigLoader);
+    /**
+     * 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 strRayConfigLoader): AgentDelegator;

package/dist/delegation/agent-delegator.js

@@ -45,9 +45,9 @@ export class AgentDelegator {
      */
     loadRoutingMappings() {
         const candidates = [
-            path.resolve(process.cwd(), ".strray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".xray/routing-mappings.json"),
             path.resolve(process.cwd(), "xray/routing-mappings.json"),
-            path.resolve(process.cwd(), ".opencode/strray/routing-mappings.json"),
+            path.resolve(process.cwd(), ".opencode/xray/routing-mappings.json"),
             path.resolve(process.cwd(), "routing-mappings.json"),
         ];
         for (const p of candidates) {
@@ -451,7 +451,7 @@ export class AgentDelegator {
    */
     resolveProjectDirectory() {
         const root = process.cwd();
-        if (fs.existsSync(`${root}/package.json`) || fs.existsSync(`${root}/strray.config.json`)) {
+        if (fs.existsSync(`${root}/package.json`) || fs.existsSync(`${root}/xray.config.json`)) {
             return root;
         }
         let current = root;

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

@@ -0,0 +1,16 @@
+/**
+ * Agent Expertise Configuration
+ *
+ * Defines expertise levels for weighted voting across all 0xRay agents.
+ * Higher expertise = higher weight in voting decisions.
+ *
+ * @version 1.0.0
+ * @since 2026-04-16
+ */
+import type { AgentExpertise } from "./voting-types.js";
+export declare const AGENT_EXPERTISE_LEVELS: Record<string, AgentExpertise>;
+export declare function getAgentExpertise(agentName: string): AgentExpertise | undefined;
+export declare function getAgentExpertiseLevel(agentName: string): number;
+export declare function getVotingWeight(agentName: string): number;
+export declare function getAgentsWithExpertiseDomain(domain: string): AgentExpertise[];
+export declare function getTopExpertsForDomain(domain: string, count?: number): AgentExpertise[];

package/dist/delegation/analytics/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Analytics Module Index
+ *
+ * Barrel export for all analytics components.
+ * Extracted from task-skill-router.ts as part of Phase 2 refactoring.
+ *
+ * @version 1.0.0
+ * @since 2026-03-12
+ */
+export { RoutingOutcomeTracker, routingOutcomeTracker } from './outcome-tracker.js';
+export { RoutingAnalytics } from './routing-analytics.js';
+export { LearningEngine, learningEngine } from './learning-engine.js';