0xray 3.0.12 → 3.1.0

package/dist/nucleus/default-plugins.js

@@ -8,6 +8,18 @@
  */
 import { frameworkLogger } from '../core/framework-logger.js';
 import { pluginRegistry } from './plugin-registry.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+const origSetRequestHandler = Server.prototype.setRequestHandler;
+Server.prototype.setRequestHandler = function (schema, handler) {
+    if (schema === ListToolsRequestSchema) {
+        this.__xrayListToolsHandler = handler;
+    }
+    if (schema === CallToolRequestSchema) {
+        this.__xrayCallToolHandler = handler;
+    }
+    return origSetRequestHandler.call(this, schema, handler);
+};
 // ── Named exports (17 servers) ──────────────────────────────────────────────
 import { XrayCodeReviewServer } from '../mcps/knowledge-skills/code-review.server.js';
 import { XraySecurityAuditServer } from '../mcps/knowledge-skills/security-audit.server.js';
@@ -36,15 +48,36 @@ import SessionManagementServer from '../mcps/knowledge-skills/session-management
 import XrayApiDesignServer from '../mcps/knowledge-skills/api-design.server.js';
 import XrayGitWorkflowServer from '../mcps/knowledge-skills/git-workflow.server.js';
 import XrayArchitecturePatternsServer from '../mcps/knowledge-skills/architecture-patterns.server.js';
-// ── Helpers ─────────────────────────────────────────────────────────────────
-/**
- * Extract tools and handler dispatch from a server instance.
- * Protected members are accessed via any-cast (contained compromise).
- */
-function toServerDescriptor(instance, serverName) {
+// ── Named exports (additional servers) ──────────────────────────────────────
+import { XrayTestingBestPracticesServer } from '../mcps/knowledge-skills/testing-best-practices.server.js';
+async function toServerDescriptor(instance, serverName) {
     const srv = instance;
     const tools = srv.tools ?? [];
     const handlers = srv.handlers ?? {};
+    // Try captured handlers from the inner MCP Server instance
+    const mcp = srv.server;
+    const listHandler = mcp?.__xrayListToolsHandler ?? srv.__xrayListToolsHandler;
+    const callHandler = mcp?.__xrayCallToolHandler ?? srv.__xrayCallToolHandler;
+    if (tools.length === 0 && listHandler) {
+        try {
+            const listResult = await listHandler();
+            if (listResult?.tools?.length) {
+                return {
+                    name: serverName,
+                    tools: listResult.tools,
+                    callTool: async (toolName, args) => {
+                        if (!callHandler) {
+                            throw new Error(`Unknown tool '${toolName}' on server '${serverName}'`);
+                        }
+                        return callHandler({ params: { name: toolName, arguments: args } });
+                    },
+                };
+            }
+        }
+        catch {
+            // fall through to default
+        }
+    }
     return {
         name: serverName,
         tools,
@@ -57,10 +90,10 @@ function toServerDescriptor(instance, serverName) {
         },
     };
 }
-function registerOne(label, create, serverName) {
+async function registerOne(label, create, serverName) {
     try {
         const instance = create();
-        const descriptor = toServerDescriptor(instance, serverName);
+        const descriptor = await toServerDescriptor(instance, serverName);
         pluginRegistry.registerServer(descriptor);
         frameworkLogger.log('default-plugins', `register-${label}`, 'info', { serverName });
         return true;
@@ -74,10 +107,10 @@ function registerOne(label, create, serverName) {
     }
 }
 // ── Batches ─────────────────────────────────────────────────────────────────
-function registerBatch(tag, servers) {
+async function registerBatch(tag, servers) {
     let count = 0;
     for (const s of servers) {
-        if (registerOne(s.label, s.create, s.serverName)) {
+        if (await registerOne(s.label, s.create, s.serverName)) {
             count++;
         }
     }
@@ -91,16 +124,16 @@ function registerBatch(tag, servers) {
  * Register all knowledge-skill servers as SkillToolPlugins.
  * Called once at boot. Returns counts of registered and failed servers.
  */
-export function registerDefaultPlugins() {
+export async function registerDefaultPlugins() {
     const failed = [];
     // ── Batch 1: Governance-critical (priority) ──
-    const batch1Count = registerBatch('governance', [
+    const batch1Count = await registerBatch('governance', [
         { label: 'code-review', create: () => new XrayCodeReviewServer(), serverName: 'code-review' },
         { label: 'security-audit', create: () => new XraySecurityAuditServer(), serverName: 'security-audit' },
         { label: 'researcher', create: () => new XrayLibrarianServer(), serverName: 'researcher' },
     ]);
     // ── Batch 2: Design & Architecture ──
-    const batch2Count = registerBatch('design-architecture', [
+    const batch2Count = await registerBatch('design-architecture', [
         { label: 'api-design', create: () => new XrayApiDesignServer(), serverName: 'api-design' },
         { label: 'architecture-patterns', create: () => new XrayArchitecturePatternsServer(), serverName: 'architecture-patterns' },
         { label: 'database-design', create: () => new XrayDatabaseDesignServer(), serverName: 'database-design' },
@@ -108,7 +141,7 @@ export function registerDefaultPlugins() {
         { label: 'ui-ux-design', create: () => new XrayUIUXDesignServer(), serverName: 'ui-ux-design' },
     ]);
     // ── Batch 3: Analysis & Quality ──
-    const batch3Count = registerBatch('analysis-quality', [
+    const batch3Count = await registerBatch('analysis-quality', [
         { label: 'code-analyzer', create: () => new CodeAnalyzerServer(), serverName: 'code-analyzer' },
         { label: 'performance-optimization', create: () => new XrayPerformanceOptimizationServer(), serverName: 'performance-optimization' },
         { label: 'project-analysis', create: () => new ProjectAnalysisServer(), serverName: 'project-analysis' },
@@ -116,7 +149,7 @@ export function registerDefaultPlugins() {
         { label: 'testing-strategy', create: () => new XrayTestingStrategyServer(), serverName: 'testing-strategy' },
     ]);
     // ── Batch 4: Operations & Workflow ──
-    const batch4Count = registerBatch('operations-workflow', [
+    const batch4Count = await registerBatch('operations-workflow', [
         { label: 'devops-deployment', create: () => new XrayDevOpsDeploymentServer(), serverName: 'devops-deployment' },
         { label: 'git-workflow', create: () => new XrayGitWorkflowServer(), serverName: 'git-workflow' },
         { label: 'log-monitor', create: () => new LogMonitorServer(), serverName: 'log-monitor' },
@@ -124,7 +157,7 @@ export function registerDefaultPlugins() {
         { label: 'strategist', create: () => new StrategistServer(), serverName: 'xray/strategist' },
     ]);
     // ── Batch 5: Content & Growth ──
-    const batch5Count = registerBatch('content-growth', [
+    const batch5Count = await registerBatch('content-growth', [
         { label: 'content-creator', create: () => new SEOCopywriterServer(), serverName: 'content-creator' },
         { label: 'growth-strategist', create: () => new MarketingExpertServer(), serverName: 'growth-strategist' },
         { label: 'multimodal-looker', create: () => new MultimodalLookerServer(), serverName: 'multimodal-looker' },
@@ -132,9 +165,10 @@ export function registerDefaultPlugins() {
         { label: 'documentation-generation', create: () => new XrayDocumentationGenerationServer(), serverName: 'documentation-generation' },
     ]);
     // ── Batch 6: Specialized ──
-    const batch6Count = registerBatch('specialized', [
+    const batch6Count = await registerBatch('specialized', [
         { label: 'bug-triage-specialist', create: () => new BugTriageSpecialistServer(), serverName: 'bug-triage-specialist' },
         { label: 'skill-invocation', create: () => new SkillInvocationServer(), serverName: 'xray/skill-invocation' },
+        { label: 'testing-best-practices', create: () => new XrayTestingBestPracticesServer(), serverName: 'testing-best-practices' },
     ]);
     const registered = batch1Count + batch2Count + batch3Count + batch4Count + batch5Count + batch6Count;
     frameworkLogger.log('default-plugins', 'register-default-plugins-complete', 'info', {
@@ -143,4 +177,3 @@ export function registerDefaultPlugins() {
     });
     return { registered, failed };
 }
-//# sourceMappingURL=default-plugins.js.map

package/dist/nucleus/govern-http.js

@@ -173,4 +173,3 @@ if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith
     });
 }
 /* c8 ignore stop */
-//# sourceMappingURL=govern-http.js.map

package/dist/nucleus/index.js

@@ -10,4 +10,3 @@ export { NucleusOrchestrator } from './orchestrator.js';
 export { scoreComplexity, routeToAgent, scoreAndRoute } from './thin-dispatch.js';
 export { NUCLEUS_THIN_DISPATCH_VERSION } from './thin-dispatch.js';
 export { registerDefaultPlugins } from './default-plugins.js';
-//# sourceMappingURL=index.js.map

package/dist/nucleus/kernel.js

@@ -60,4 +60,3 @@ export async function governSingle(proposal, context, options) {
     };
     return handleGovernRequest(fullRequest);
 }
-//# sourceMappingURL=kernel.js.map

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

@@ -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

@@ -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

@@ -13,7 +13,7 @@ import { createAgentDelegator } from "../delegation/agent-delegator.js";
 import { XrayStateManager } 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 as xrayConfigLoader } from "../core/config-loader.js";
 export class MultiAgentOrchestrationCoordinator {
     xrayOrchestrator;
     enhancedOrchestrator;
@@ -454,4 +454,3 @@ export class MultiAgentOrchestrationCoordinator {
 }
 // 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 { XrayStateManager } from "../state/state-manager.js";
 import fs from "fs";
 export class XrayOrchestrator {
     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 XrayStateManager());
     }
     /**
      * Load orchestrator config from features.json
@@ -147,7 +151,7 @@ export class XrayOrchestrator {
             // Execute post-processors for agent task completion logging
             try {
                 // Get processor manager from global state
-                const globalStateManager = globalThis.strRayStateManager;
+                const globalStateManager = globalThis.xrayStateManager;
                 frameworkLogger.log("orchestrator", "global-state-check", "debug", {
                     jobId,
                     exists: !!globalStateManager,
@@ -196,7 +200,7 @@ export class XrayOrchestrator {
             await frameworkLogger.log("orchestrator", "task-execution-failed", "error", { taskId: task.id, duration, error: String(error) });
             // Execute post-processors even on failure for error logging
             try {
-                const globalStateManager = globalThis.strRayStateManager;
+                const globalStateManager = globalThis.xrayStateManager;
                 const processorManager = globalStateManager?.get("processor:manager");
                 if (processorManager) {
                     const agentContext = {
@@ -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) {
@@ -634,6 +655,5 @@ export class XrayOrchestrator {
 }
 // Export singleton instance
 export const xrayOrchestrator = new XrayOrchestrator();
-// Backward compat alias
-export { xrayOrchestrator as strRayOrchestrator };
-//# sourceMappingURL=orchestrator.js.map
+// Backward compatibility alias
+export { XrayOrchestrator as 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();