0xray 3.0.12 → 3.0.14

package/dist/nucleus/orchestrator.js

@@ -300,7 +300,7 @@ export class NucleusOrchestrator {
                 case "logging":
                     return this.initLogging();
                 case "plugin-registration":
-                    return this.initPluginRegistration();
+                    return await this.initPluginRegistration();
                 case "state-management":
                     return this.initStateManagement();
                 case "security":
@@ -341,9 +341,9 @@ export class NucleusOrchestrator {
         }
         return { success: true, duration: 5, message: "Logging system initialized" };
     }
-    initPluginRegistration() {
+    async initPluginRegistration() {
         const start = Date.now();
-        const r = registerDefaultPlugins();
+        const r = await registerDefaultPlugins();
         if (r.registered === 0) {
             return {
                 success: false,
@@ -477,4 +477,3 @@ export class NucleusOrchestrator {
         fs.writeFileSync(stateFile, JSON.stringify(shutdownState, null, 2));
     }
 }
-//# sourceMappingURL=orchestrator.js.map

package/dist/nucleus/plugin-registry.js

@@ -173,4 +173,3 @@ class PluginRegistryImpl {
 }
 /** Singleton plugin registry */
 export const pluginRegistry = new PluginRegistryImpl();
-//# sourceMappingURL=plugin-registry.js.map

package/dist/nucleus/thin-dispatch.js

@@ -55,4 +55,3 @@ export function scoreAndRoute(operation, context, thresholds) {
     const agent = routeToAgent(score);
     return { score, agent };
 }
-//# sourceMappingURL=thin-dispatch.js.map

package/dist/orchestrator/agent-spawn-governor.js

@@ -557,4 +557,3 @@ export class AgentSpawnGovernor {
     }
 }
 export const agentSpawnGovernor = new AgentSpawnGovernor(undefined, true);
-//# sourceMappingURL=agent-spawn-governor.js.map

package/dist/orchestrator/enhanced-multi-agent-orchestrator.js

@@ -2,7 +2,7 @@
  * Enhanced Multi-Agent Orchestration with Clickable Monitoring
  * Integrates subagent spawning visibility and lifecycle management
  */
-import { XrayStateManager } from "../state/state-manager.js";
+import { StringRayStateManager } from "../state/state-manager.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { ComplexityAnalyzer, } from "../delegation/complexity-analyzer.js";
 import { createAgentDelegator, } from "../delegation/agent-delegator.js";
@@ -17,7 +17,7 @@ export class EnhancedMultiAgentOrchestrator {
     executionContext;
     cleanupTimer = null;
     constructor(stateManager, isMainOrchestrator = false) {
-        this.stateManager = stateManager || new XrayStateManager();
+        this.stateManager = stateManager || new StringRayStateManager();
         this.complexityAnalyzer = new ComplexityAnalyzer();
         this.agentDelegator = createAgentDelegator(this.stateManager, strRayConfigLoader);
         this.state = {
@@ -397,4 +397,3 @@ export class EnhancedMultiAgentOrchestrator {
     }
 }
 export const enhancedMultiAgentOrchestrator = new EnhancedMultiAgentOrchestrator(undefined, true);
-//# sourceMappingURL=enhanced-multi-agent-orchestrator.js.map

package/dist/orchestrator/intelligent-commit-batcher.js

@@ -2,7 +2,7 @@
  * Intelligent Commit Batcher - Batches related changes for optimal commit history
  * Implements configurable thresholds for file count, time windows, and risk levels
  *
- * Configuration is read from .xray/features.json -> commit_cycle
+ * Configuration is read from .strray/features.json -> commit_cycle
  */
 import * as fs from "fs";
 import * as path from "path";
@@ -36,8 +36,8 @@ export class IntelligentCommitBatcher {
     loadFeaturesConfig() {
         try {
             const configPaths = [
-                path.join(process.cwd(), ".xray", "features.json"),
-                path.join(process.cwd(), ".opencode", "xray", "features.json"),
+                path.join(process.cwd(), ".strray", "features.json"),
+                path.join(process.cwd(), ".opencode", "strray", "features.json"),
             ];
             for (const configPath of configPaths) {
                 if (fs.existsSync(configPath)) {
@@ -351,4 +351,3 @@ export const createIntelligentCommitBatcher = (config) => {
 };
 // Export default instance
 export const intelligentCommitBatcher = new IntelligentCommitBatcher();
-//# sourceMappingURL=intelligent-commit-batcher.js.map

package/dist/orchestrator/multi-agent-orchestration-coordinator.js

@@ -10,22 +10,22 @@
 import { KernelOrchestrator } from "../core/orchestrator.js";
 import { enhancedMultiAgentOrchestrator } from "./enhanced-multi-agent-orchestrator.js";
 import { createAgentDelegator } from "../delegation/agent-delegator.js";
-import { XrayStateManager } from "../state/state-manager.js";
+import { StringRayStateManager } from "../state/state-manager.js";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { ComplexityAnalyzer } from "../delegation/complexity-analyzer.js";
-import { xrayConfigLoader } from "../core/config-loader.js";
+import { strRayConfigLoader } from "../core/config-loader.js";
 export class MultiAgentOrchestrationCoordinator {
-    xrayOrchestrator;
+    strRayOrchestrator;
     enhancedOrchestrator;
     agentDelegator;
     stateManager;
     complexityAnalyzer;
     coordinationMetrics;
     constructor(stateManager) {
-        this.stateManager = stateManager || new XrayStateManager();
-        this.xrayOrchestrator = new KernelOrchestrator();
+        this.stateManager = stateManager || new StringRayStateManager();
+        this.strRayOrchestrator = new KernelOrchestrator();
         this.enhancedOrchestrator = enhancedMultiAgentOrchestrator;
-        this.agentDelegator = createAgentDelegator(this.stateManager, xrayConfigLoader);
+        this.agentDelegator = createAgentDelegator(this.stateManager, strRayConfigLoader);
         this.complexityAnalyzer = new ComplexityAnalyzer();
         this.coordinationMetrics = {
             totalWorkflows: 0,
@@ -43,7 +43,7 @@ export class MultiAgentOrchestrationCoordinator {
     initializeCoordinationSystem() {
         // Register coordination components in state manager
         this.stateManager.set("coordination:main_coordinator", this);
-        this.stateManager.set("coordination:xray_orchestrator", this.xrayOrchestrator);
+        this.stateManager.set("coordination:strray_orchestrator", this.strRayOrchestrator);
         this.stateManager.set("coordination:enhanced_orchestrator", this.enhancedOrchestrator);
         this.stateManager.set("coordination:agent_delegator", this.agentDelegator);
         this.stateManager.set("coordination:metrics", this.coordinationMetrics);
@@ -175,7 +175,7 @@ export class MultiAgentOrchestrationCoordinator {
                 dependencies: [],
                 subagentType: "orchestrator",
             };
-            const result = await this.xrayOrchestrator.executeComplexTask(task.description, [task]);
+            const result = await this.strRayOrchestrator.executeComplexTask(task.description, [task]);
             result.forEach((r) => {
                 taskResults.push({
                     success: r.success,
@@ -448,10 +448,9 @@ export class MultiAgentOrchestrationCoordinator {
     async shutdown() {
         frameworkLogger.log("orchestration-coordinator", "Shutting down multi-agent orchestration coordinator", "info");
         await this.enhancedOrchestrator.shutdown();
-        await this.xrayOrchestrator.getStatus(); // Just get status, no actual shutdown method
+        await this.strRayOrchestrator.getStatus(); // Just get status, no actual shutdown method
         frameworkLogger.log("orchestration-coordinator", "Multi-agent orchestration coordinator shutdown complete", "info");
     }
 }
 // Export singleton instance
 export const multiAgentOrchestrationCoordinator = new MultiAgentOrchestrationCoordinator();
-//# sourceMappingURL=multi-agent-orchestration-coordinator.js.map

package/dist/orchestrator/orchestrator.js

@@ -11,12 +11,15 @@ import { enhancedMultiAgentOrchestrator } from "./enhanced-multi-agent-orchestra
 import { frameworkLogger } from "../core/framework-logger.js";
 import { routingOutcomeTracker } from "../delegation/analytics/outcome-tracker.js";
 import { patternPerformanceTracker } from "../analytics/pattern-performance-tracker.js";
+import { VotingCoordinator } from "../delegation/voting-coordinator.js";
 import { getAgentExpertiseLevel } from "../delegation/agent-expertise.js";
+import { StringRayStateManager } from "../state/state-manager.js";
 import fs from "fs";
-export class XrayOrchestrator {
+export class StringRayOrchestrator {
     config;
     activeTasks = new Map();
     taskToAgentMap = new Map();
+    votingCoordinator;
     constructor(config = {}) {
         const loadedConfig = this.loadOrchestratorConfig();
         this.config = {
@@ -25,6 +28,7 @@ export class XrayOrchestrator {
             conflictResolutionStrategy: loadedConfig?.conflictResolutionStrategy ?? "majority_vote",
             ...config,
         };
+        this.votingCoordinator = new VotingCoordinator(new StringRayStateManager());
     }
     /**
      * Load orchestrator config from features.json
@@ -32,8 +36,8 @@ export class XrayOrchestrator {
     loadOrchestratorConfig() {
         try {
             const configPaths = [
-                ".xray/features.json",
-                ".opencode/xray/features.json",
+                ".strray/features.json",
+                ".opencode/strray/features.json",
             ];
             for (const configPath of configPaths) {
                 if (fs.existsSync(configPath)) {
@@ -509,6 +513,23 @@ export class XrayOrchestrator {
             .filter((a) => typeof a === "string");
         if (agents.length < 2)
             return conflicts[0];
+        const voteId = this.votingCoordinator.initiateVoting(`orchestrator-conflict-${Date.now()}`, "conflict-resolution", "Resolve conflicting agent responses", agents, {
+            complexity: 30,
+            riskLevel: "medium",
+            hasSecurityConcerns: false,
+            hasArchitecturalImpact: false,
+            participantCount: agents.length,
+        });
+        void voteId.then((id) => {
+            for (const conflict of conflicts) {
+                if (conflict.agentType) {
+                    const vote = conflict.response ? "approve" : "reject";
+                    const confidence = (conflict.expertiseScore ?? 5) / 10;
+                    this.votingCoordinator.submitVote(id, conflict.agentType, vote, confidence);
+                }
+            }
+            this.votingCoordinator.resolveVoting(id);
+        });
         return this.resolveByExpertPriority(conflicts);
     }
     resolveByMajorityVote(conflicts) {
@@ -633,7 +654,4 @@ export class XrayOrchestrator {
     }
 }
 // Export singleton instance
-export const xrayOrchestrator = new XrayOrchestrator();
-// Backward compat alias
-export { xrayOrchestrator as strRayOrchestrator };
-//# sourceMappingURL=orchestrator.js.map
+export const strRayOrchestrator = new StringRayOrchestrator();

package/dist/orchestrator/self-direction-activation.js

@@ -0,0 +1,245 @@
+/**
+ * Self-Direction Activation System (Simplified)
+ *
+ * Commercial version with autonomous self-direction capabilities.
+ * Activates the framework's dormant self-evolution systems for continuous improvement.
+ * This version works without advanced-features dependencies for initial deployment.
+ *
+ * @version 2.0.0
+ * @since 2026-01-24
+ */
+// Framework core imports
+import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
+/**
+ * Simplified Self-Direction Activation System
+ *
+ * Provides basic self-direction capabilities without advanced-features dependencies
+ * for initial deployment and testing.
+ */
+export class SelfDirectionSystem {
+    config;
+    activeMonitoring = false;
+    activeLearning = false;
+    monitoringIntervalId;
+    learningIntervalId;
+    constructor(config = {}) {
+        this.config = {
+            monitoringInterval: 30000, // 30 seconds
+            analyticsInterval: 300000, // 5 minutes
+            learningCycleInterval: 3600000, // 1 hour
+            autonomousReporting: true,
+            predictiveOptimization: true,
+            scalingAutonomy: true,
+            evolutionSafety: true,
+            ...config,
+        };
+    }
+    /**
+     * Phase 1: Activate Self-Monitoring Foundation
+     */
+    async activateSelfMonitoring() {
+        frameworkLogger.log("self-direction-system", "activating-monitoring", "info", { message: "🤖 ACTIVATING SELF-MONITORING FOUNDATION" });
+        try {
+            // Setup autonomous critical issue reporting
+            this.setupAutonomousReporting();
+            frameworkLogger.log("self-direction-system", "reporting-activated", "info", { message: "✅ Autonomous critical issue reporting activated" });
+            // Start continuous self-assessment
+            this.startContinuousSelfAssessment();
+            this.activeMonitoring = true;
+            frameworkLogger.log("self-direction-system", "monitoring-activated", "info", { message: "🎉 Self-monitoring foundation activated" });
+            await frameworkLogger.log("self-direction-system", "monitoring-activated", "success", { phase: 1, componentsActivated: ["reporting", "assessment"] }, undefined, generateJobId("self-monitoring"));
+        }
+        catch (error) {
+            frameworkLogger.log("self-direction-system", "monitoring-activation-failed", "error", { error, message: "❌ Self-monitoring activation failed" });
+            await frameworkLogger.log("self-direction-system", "monitoring-activation-failed", "error", { error: error instanceof Error ? error.message : error }, undefined, generateJobId("self-monitoring-fail"));
+            throw error;
+        }
+    }
+    /**
+     * Setup autonomous critical issue reporting
+     */
+    setupAutonomousReporting() {
+        // Setup basic event listeners for critical issues
+        frameworkLogger.log("self-direction-system", "reporting-configured", "info", { message: "📊 Autonomous reporting configured" });
+    }
+    /**
+     * Start continuous self-assessment cycle
+     */
+    startContinuousSelfAssessment() {
+        // Clear any existing interval first to prevent duplicates
+        if (this.monitoringIntervalId) {
+            clearInterval(this.monitoringIntervalId);
+        }
+        this.monitoringIntervalId = setInterval(async () => {
+            try {
+                if (!this.activeMonitoring)
+                    return; // Don't run if stopped
+                const assessment = await this.performSelfAssessment();
+                await this.processSelfAssessmentResults(assessment);
+            }
+            catch (error) {
+                frameworkLogger.log("self-direction-system", "assessment-cycle-failed", "error", { error, message: "Self-assessment cycle failed" });
+            }
+        }, this.config.monitoringInterval);
+    }
+    /**
+     * Phase 2: Activate Self-Evolution Learning
+     */
+    async activateSelfEvolution() {
+        frameworkLogger.log("self-direction-system", "activating-evolution", "info", { message: "🧠 ACTIVATING SELF-EVOLUTION LEARNING" });
+        try {
+            // Start learning cycles
+            this.startLearningCycles();
+            frameworkLogger.log("self-direction-system", "learning-cycles-activated", "info", { message: "✅ Learning cycles activated" });
+            this.activeLearning = true;
+            frameworkLogger.log("self-direction-system", "evolution-activated", "info", { message: "🎉 Self-evolution learning activated" });
+            await frameworkLogger.log("self-direction-system", "evolution-activated", "success", { phase: 2, componentsActivated: ["learning-cycles"] }, undefined, generateJobId("self-evolution"));
+        }
+        catch (error) {
+            frameworkLogger.log("self-direction-system", "evolution-activation-failed", "error", { error, message: "❌ Self-evolution activation failed" });
+            await frameworkLogger.log("self-direction-system", "evolution-activation-failed", "error", { error: error instanceof Error ? error.message : error }, undefined, generateJobId("self-evolution-fail"));
+            throw error;
+        }
+    }
+    /**
+     * Start learning cycles
+     */
+    startLearningCycles() {
+        // Clear any existing interval first to prevent duplicates
+        if (this.learningIntervalId) {
+            clearInterval(this.learningIntervalId);
+        }
+        this.learningIntervalId = setInterval(async () => {
+            if (!this.activeLearning)
+                return; // Don't run if stopped
+            frameworkLogger.log("self-direction-system", "learning-cycle-executed", "info", { message: "🔄 Learning cycle executed" });
+            // Basic learning cycle - would be enhanced with advanced features
+        }, this.config.learningCycleInterval);
+    }
+    /**
+     * Core self-assessment method
+     */
+    async performSelfAssessment() {
+        const timestamp = Date.now();
+        // Basic health assessment
+        const healthScore = 0.75; // Placeholder
+        // Known critical issues
+        const criticalIssues = [
+            {
+                id: "memory-leak",
+                severity: "critical",
+                component: "memory-management",
+                description: "Memory leaks persist at 1.3GB+ usage",
+                impact: "System instability",
+                recommendedAction: "Deep profiling required",
+            },
+            {
+                id: "performance-budget",
+                severity: "critical",
+                component: "performance",
+                description: "Bundle size and response times exceed limits",
+                impact: "CI/CD deployment blocked",
+                recommendedAction: "Optimization required",
+            },
+        ];
+        // Basic improvement opportunities
+        const improvementOpportunities = [
+            {
+                id: "memory-optimization",
+                type: "performance",
+                description: "Implement comprehensive memory leak fixes",
+                potentialBenefit: "Reduce memory usage by 95%",
+                implementationComplexity: "high",
+                confidence: 0.8,
+            },
+        ];
+        // Basic predictions
+        const predictions = [
+            {
+                type: "performance",
+                prediction: "Performance budget violations will persist",
+                confidence: 0.9,
+                timeHorizon: 24,
+                recommendedAction: "Address bundle size and response times",
+            },
+        ];
+        // Recommendations
+        const recommendations = [
+            "Conduct comprehensive memory profiling",
+            "Fix concurrent spawn limit race condition",
+            "Resolve performance budget violations",
+        ];
+        return {
+            timestamp,
+            healthScore,
+            criticalIssues,
+            improvementOpportunities,
+            predictions,
+            recommendations,
+        };
+    }
+    /**
+     * Process self-assessment results
+     */
+    async processSelfAssessmentResults(assessment) {
+        if (assessment.criticalIssues.length > 0) {
+            frameworkLogger.log("self-direction-system", "critical-issues-detected", "warning", {
+                message: `🚨 ${assessment.criticalIssues.length} critical issues detected`,
+                issues: assessment.criticalIssues.map(i => `${i.severity.toUpperCase()}: ${i.description}`),
+            });
+        }
+        if (assessment.recommendations.length > 0) {
+            frameworkLogger.log("self-direction-system", "recommendations-generated", "info", {
+                message: `💡 ${assessment.recommendations.length} recommendations generated`,
+            });
+        }
+    }
+    /**
+     * Get current self-direction status
+     */
+    getStatus() {
+        return {
+            activeMonitoring: this.activeMonitoring,
+            activeLearning: this.activeLearning,
+            config: this.config,
+            componentsHealth: {
+                metricsCollector: true,
+                analytics: true,
+                streaming: true,
+                scaling: true,
+                loadBalancer: true,
+                metaAnalysis: true,
+                inference: true,
+                selfReflection: true,
+                learningLoops: true,
+                evolutionValidation: true,
+                monitoring: true,
+                reporting: true,
+                assessment: true,
+                learning: true,
+            },
+        };
+    }
+    /**
+     * Shutdown self-direction system
+     */
+    async shutdown() {
+        frameworkLogger.log("self-direction-system", "shutting-down", "info", { message: "🛑 Shutting down self-direction system..." });
+        // Clear all intervals to prevent memory leaks
+        if (this.monitoringIntervalId) {
+            clearInterval(this.monitoringIntervalId);
+            this.monitoringIntervalId = undefined;
+        }
+        if (this.learningIntervalId) {
+            clearInterval(this.learningIntervalId);
+            this.learningIntervalId = undefined;
+        }
+        this.activeMonitoring = false;
+        this.activeLearning = false;
+        frameworkLogger.log("self-direction-system", "shutdown-complete", "info", { message: "✅ Self-direction system shutdown complete" });
+    }
+}
+/**
+ * Export singleton instance
+ */
+export const selfDirectionSystem = new SelfDirectionSystem();