0xray 4.0.13 → 4.0.14

package/dist/core/boot-orchestrator.js

@@ -0,0 +1,809 @@
+/**
+ * Boot Orchestrator (min documented consumer runtime compat shim from prior 0xRay releases; primary Xray paths + .xray fallbacks only; 1-line per Scope Rule).
+ */
+import { readFileSync } from "fs";
+import { XrayContextLoader } from "./context-loader.js";
+import { XrayStateManager } from "../state/state-manager.js";
+import { ProcessorManager } from "../processors/processor-manager.js";
+import { pathResolver } from "../utils/path-resolver.js";
+import * as path from "path";
+// Path configuration - can be overridden by environment or use path resolver
+const AGENTS_BASE_PATH = process.env.XRAY_AGENTS_PATH || process.env.XRAY_AGENTS_PATH || "../agents";
+import { createAgentDelegator, createSessionCoordinator, } from "../delegation/index.js";
+import { createSessionCleanupManager } from "../session/session-cleanup-manager.js";
+import { createSessionMonitor } from "../session/session-monitor.js";
+import { createSessionStateManager } from "../session/session-state-manager.js";
+import { securityHardener } from "../security/security-hardener.js";
+import { securityHeadersMiddleware } from "../security/security-headers.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { featuresConfigLoader } from "../core/features-config.js";
+import { memoryMonitor } from "../monitoring/memory-monitor.js";
+import { advancedProfiler } from "../monitoring/advanced-profiler.js";
+import { xrayConfigLoader } from "./config-loader.js";
+import { PluginRegistry } from "../integrations/plugins/index.js";
+import { PluginServerConfigRegistry } from "../mcps/config/index.js";
+import { initializeGovernanceIntegration } from "../integrations/governance/index.js";
+/**
+ * Set up graceful interruption handling to prevent JSON parsing errors
+ * when processes are interrupted mid-operation
+ */
+function setupGracefulShutdown() {
+    // Prevent duplicate listeners
+    if (process._xrayShutdownSetup) {
+        return;
+    }
+    process._xrayShutdownSetup = true;
+    let isShuttingDown = false;
+    process.on("SIGINT", async () => {
+        if (isShuttingDown) {
+            process.exit(0);
+        }
+        isShuttingDown = true;
+        try {
+            await frameworkLogger.log("boot-orchestrator", "-received-sigint-shutting-down-gracefully-", "info", { message: "Received SIGINT, shutting down gracefully..." });
+            // Basic cleanup - orchestrator shutdown handled by process termination
+            process.exit(0);
+        }
+        catch (error) {
+            // Suppress error output in CLI mode to avoid breaking interface
+            if (process.env.XRAY_CLI_MODE !== "true" &&
+                process.env.OPENCODE_CLI !== "true") {
+                frameworkLogger.log("boot-orchestrator", "shutdown-error", "error", { error, message: "Error during graceful shutdown" });
+            }
+            process.exit(1);
+        }
+    });
+    process.on("SIGTERM", async () => {
+        // Termination signal message kept as console.log
+        try {
+            memoryMonitor.stop();
+            advancedProfiler.stop();
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            process.exit(0);
+        }
+        catch (error) {
+            process.exit(1);
+        }
+    });
+    // Handle uncaught exceptions that might cause JSON parsing errors
+    process.on("uncaughtException", (error) => {
+        // Suppress error output in CLI mode to avoid breaking interface
+        if (process.env.XRAY_CLI_MODE !== "true" &&
+            process.env.OPENCODE_CLI !== "true") {
+            frameworkLogger.log("boot-orchestrator", "uncaught-exception", "error", { error, message: "Uncaught Exception" });
+        }
+        memoryMonitor.stop();
+        advancedProfiler.stop();
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason, promise) => {
+        // Suppress error output in CLI mode to avoid breaking interface
+        if (process.env.XRAY_CLI_MODE !== "true" &&
+            process.env.OPENCODE_CLI !== "true") {
+            frameworkLogger.log("boot-orchestrator", "unhandled-rejection", "error", { promise, reason, message: "Unhandled Rejection" });
+        }
+        memoryMonitor.stop();
+        advancedProfiler.stop();
+        process.exit(1);
+    });
+}
+export class BootOrchestrator {
+    contextLoader;
+    stateManager;
+    processorManager;
+    config;
+    pluginRegistry;
+    pluginServerRegistry;
+    shutdownInitialized = false;
+    constructor(config = {}, stateManager) {
+        // Initialize components first for state management
+        this.contextLoader = XrayContextLoader.getInstance();
+        this.stateManager = stateManager || new XrayStateManager();
+        this.processorManager = new ProcessorManager(this.stateManager);
+        this.config = {
+            enableEnforcement: true,
+            codexValidation: true,
+            sessionManagement: true,
+            processorActivation: true,
+            agentLoading: true,
+            ...config,
+        };
+    }
+    /**
+     * Initialize delegation system components
+     */
+    async initializeDelegationSystem() {
+        try {
+            const agentDelegator = createAgentDelegator(this.stateManager, xrayConfigLoader);
+            this.stateManager.set("delegation:agent_delegator", agentDelegator);
+            const sessionCoordinator = createSessionCoordinator(this.stateManager);
+            this.stateManager.set("delegation:session_coordinator", sessionCoordinator);
+            const defaultSession = sessionCoordinator.initializeSession("default");
+            this.stateManager.set("delegation:default_session", defaultSession);
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "delegation-init-failed", "error", { error, message: "Failed to initialize delegation system" });
+            return false;
+        }
+    }
+    loadProcessorsConfig() {
+        try {
+            return featuresConfigLoader.loadConfig().processors ?? null;
+        }
+        catch {
+            // use defaults
+        }
+        return null;
+    }
+    /**
+     * Initialize plugin system and register MCP servers
+     */
+    async initializePluginSystem(jobId) {
+        try {
+            frameworkLogger.log("boot-orchestrator", "initializing plugin system", "info", { jobId });
+            const pluginsDir = path.join(process.cwd(), ".xray", "plugins");
+            this.pluginRegistry = new PluginRegistry({
+                pluginsDir,
+                autoStart: true,
+                enableMetrics: true,
+            });
+            await this.pluginRegistry.initialize();
+            this.pluginServerRegistry = new PluginServerConfigRegistry();
+            const registered = this.pluginServerRegistry.registerAllPluginServers(this.pluginRegistry, { overwrite: false });
+            this.stateManager.set("plugin:registry", this.pluginRegistry);
+            this.stateManager.set("plugin:serverRegistry", this.pluginServerRegistry);
+            this.stateManager.set("plugin:registered", registered);
+            frameworkLogger.log("boot-orchestrator", "plugin system initialized", "success", { jobId, pluginsDir, registeredServers: registered });
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "plugin-system-init-failed", "error", { jobId, error: error instanceof Error ? error.message : String(error) });
+            return false;
+        }
+    }
+    /**
+     * Load orchestrator as the first component
+     */
+    async loadOrchestrator() {
+        try {
+            // Import orchestrator dynamically to ensure it's loaded first
+            let orchestratorModule;
+            try {
+                orchestratorModule = await import("../core/orchestrator");
+            }
+            catch (importError) {
+                frameworkLogger.log("boot-orchestrator", "orchestrator-load-failed", "error", {
+                    error: importError,
+                    message: "Failed to load orchestrator",
+                });
+                return false;
+            }
+            const orchestratorInstance = orchestratorModule.xrayOrchestrator;
+            if (!orchestratorInstance) {
+                frameworkLogger.log("boot-orchestrator", "orchestrator-not-found", "error", { message: "Orchestrator instance not found in module" });
+                return false;
+            }
+            // Store in state manager for later access
+            this.stateManager.set("orchestrator", orchestratorInstance);
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "orchestrator-load-failed-outer", "error", { error, message: "Failed to load orchestrator" });
+            return false;
+        }
+    }
+    /**
+     * Initialize session management system
+     */
+    async initializeSessionManagement() {
+        try {
+            // Initialize session state
+            this.stateManager.set("session:active", true);
+            this.stateManager.set("session:boot_time", Date.now());
+            this.stateManager.set("session:agents", []);
+            const sessionCoordinator = this.stateManager.get("delegation:session_coordinator");
+            if (sessionCoordinator) {
+                // Initialize session monitor first
+                const sessionMonitor = createSessionMonitor(this.stateManager, sessionCoordinator, undefined);
+                this.stateManager.set("session:monitor", sessionMonitor);
+                // Initialize session cleanup manager with session monitor reference
+                const cleanupManager = createSessionCleanupManager(this.stateManager, {}, sessionMonitor);
+                this.stateManager.set("session:cleanup_manager", cleanupManager);
+                cleanupManager.start();
+                // Update session monitor with cleanup manager reference
+                sessionMonitor.cleanupManager = cleanupManager;
+                const stateManagerInstance = createSessionStateManager(this.stateManager, sessionCoordinator);
+                this.stateManager.set("session:state_manager", stateManagerInstance);
+                const defaultSession = this.stateManager.get("delegation:default_session");
+                if (defaultSession?.sessionId) {
+                    cleanupManager.registerSession(defaultSession.sessionId);
+                    sessionMonitor.registerSession(defaultSession.sessionId);
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "session-init-failed", "error", { error, message: "Failed to initialize session management" });
+            return false;
+        }
+    }
+    /**
+     * Activate pre/post processors
+     */
+    async activateProcessors(jobId) {
+        try {
+            frameworkLogger.log("boot-orchestrator", "activateProcessors started", "info", { jobId });
+            // Processor definitions — single source of truth for all registrations
+            // Load from features.json if available, otherwise use defaults
+            const processorsConfig = this.loadProcessorsConfig();
+            const prePriorityOrder = processorsConfig?.pre_processors?.priority_order || ["preValidate", "codexCompliance"];
+            const postPriorityOrder = processorsConfig?.post_processors?.priority_order || ["storytellingTrigger", "testExecution", "regressionTesting"];
+            const prePriorityMap = {};
+            prePriorityOrder.forEach((name, idx) => { prePriorityMap[name] = 10 + (idx * 10); });
+            const postPriorityMap = {};
+            postPriorityOrder.forEach((name, idx) => { postPriorityMap[name] = 5 + (idx * 10); });
+            const PROCESSOR_DEFS = [
+                { name: "preValidate", type: "pre", priority: prePriorityMap["preValidate"] || 10, enabled: true },
+                { name: "typescriptCompilation", type: "pre", priority: prePriorityMap["typescriptCompilation"] || 15, enabled: true },
+                { name: "codexCompliance", type: "pre", priority: prePriorityMap["codexCompliance"] || 20, enabled: true },
+                { name: "testAutoCreation", type: "pre", priority: prePriorityMap["testAutoCreation"] || 22, enabled: true },
+                { name: "versionCompliance", type: "pre", priority: prePriorityMap["versionCompliance"] || 25, enabled: true },
+                { name: "errorBoundary", type: "pre", priority: prePriorityMap["errorBoundary"] || 30, enabled: true },
+                { name: "agentsMdValidation", type: "pre", priority: prePriorityMap["agentsMdValidation"] || 35, enabled: true },
+                { name: "logProtection", type: "pre", priority: prePriorityMap["logProtection"] || 37, enabled: true },
+                { name: "stateValidation", type: "post", priority: postPriorityMap["stateValidation"] || 130, enabled: true },
+                { name: "spawnGovernance", type: "pre", priority: prePriorityMap["spawnGovernance"] || 40, enabled: true },
+                { name: "performanceBudget", type: "pre", priority: prePriorityMap["performanceBudget"] || 45, enabled: true },
+                { name: "asyncPattern", type: "pre", priority: prePriorityMap["asyncPattern"] || 50, enabled: true },
+                { name: "consoleLogGuard", type: "pre", priority: prePriorityMap["consoleLogGuard"] || 55, enabled: true },
+                { name: "testExecution", type: "post", priority: postPriorityMap["testExecution"] || 60, enabled: true },
+                { name: "regressionTesting", type: "post", priority: postPriorityMap["regressionTesting"] || 65, enabled: true },
+                { name: "coverageAnalysis", type: "post", priority: postPriorityMap["coverageAnalysis"] || 70, enabled: true },
+                { name: "inferenceImprovement", type: "post", priority: postPriorityMap["inferenceImprovement"] || 75, enabled: true },
+                { name: "nudge", type: "post", priority: postPriorityMap["nudge"] || 78, enabled: true },
+                { name: "refactoringLogging", type: "post", priority: postPriorityMap["refactoringLogging"] || 80, enabled: true },
+                { name: "postProcessorChain", type: "post", priority: postPriorityMap["postProcessorChain"] || 140, enabled: true },
+                { name: "publishPreflight", type: "post", priority: postPriorityMap["publishPreflight"] || 125, enabled: true },
+                { name: "storytellingTrigger", type: "post", priority: postPriorityMap["storytellingTrigger"] || 5, enabled: true },
+                { name: "sessionSummary", type: "post", priority: postPriorityMap["sessionSummary"] || 10, enabled: true },
+                { name: "commitBatcher", type: "post", priority: postPriorityMap["commitBatcher"] || 85, enabled: true },
+            ];
+            for (const def of PROCESSOR_DEFS) {
+                this.processorManager.registerProcessor({
+                    name: def.name,
+                    type: def.type,
+                    priority: def.priority,
+                    enabled: def.enabled,
+                });
+                frameworkLogger.log("boot-orchestrator", `registered ${def.name} processor`, "success", { jobId });
+            }
+            // Note: refactoringLogging is registered but requires agentName/task/startTime in context
+            // to actually log. When running via tool execution, these fields may not be present.
+            // The sessionSummary processor handles emoji output for tool execution flows.
+            frameworkLogger.log("boot-orchestrator", "processors configured", "info", { jobId, postProcessorCount: PROCESSOR_DEFS.filter(p => p.type === "post").length });
+            const initSuccess = await this.processorManager.initializeProcessors();
+            if (!initSuccess) {
+                frameworkLogger.log("boot-orchestrator", "processor initialization failed", "error", { jobId });
+                throw new Error("Processor initialization failed");
+            }
+            frameworkLogger.log("boot-orchestrator", "processors initialized successfully", "success", { jobId });
+            this.stateManager.set("processor:manager", this.processorManager);
+            this.stateManager.set("processor:active", true);
+            frameworkLogger.log("boot-orchestrator", "processors activated and stored in state", "success", { jobId });
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "activateProcessors failed", "error", { jobId, error });
+            frameworkLogger.log("boot-orchestrator", "activate-processors-failed", "error", { error, message: "Failed to activate processors" });
+            return false;
+        }
+    }
+    /**
+     * Load remaining agents after orchestrator
+     */
+    async loadRemainingAgents(jobId) {
+        const agents = [
+            "enforcer",
+            "architect",
+            "bug-triage-specialist",
+            "code-reviewer",
+            "security-auditor",
+            "refactorer",
+            "testing-lead",
+        ];
+        const loadedAgents = [];
+        for (const agentName of agents) {
+            try {
+                await frameworkLogger.log("boot-orchestrator", "agent-loading", "info", { jobId, agentName });
+                const { getAgentEntry } = await import("../agents/registry.js");
+                const agentEntry = getAgentEntry(agentName);
+                if (agentEntry) {
+                    this.stateManager.set(`agent:${agentName}`, agentEntry);
+                    loadedAgents.push(agentName);
+                }
+                else {
+                    frameworkLogger.log("boot-orchestrator", "agent-not-found", "warning", { agentName });
+                }
+            }
+            catch (error) {
+                frameworkLogger.log("boot-orchestrator", "agent-load-failed", "warning", {
+                    agentName,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        this.stateManager.set("session:agents", loadedAgents);
+        return loadedAgents;
+    }
+    /**
+     * Enable automatic enforcement activation
+     */
+    async enableEnforcement() {
+        try {
+            // Load codex terms for enforcement
+            const loadResult = await this.contextLoader.loadCodexContext(process.cwd());
+            if (!loadResult.success || !loadResult.context) {
+                throw new Error("No codex terms loaded for enforcement");
+            }
+            const codexTerms = Array.from(loadResult.context.terms.values());
+            // Enable enforcement mechanisms
+            this.stateManager.set("enforcement:active", true);
+            this.stateManager.set("enforcement:codex_terms", codexTerms);
+            this.stateManager.set("enforcement:enabled_at", Date.now());
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "enforcement-failed", "error", { error, message: "Failed to enable enforcement" });
+            return false;
+        }
+    }
+    /**
+     * Activate codex compliance checking during boot
+     */
+    async activateCodexCompliance() {
+        try {
+            // Initialize codex injector if not already done
+            let codexInjector = this.stateManager.get("processor:codex_injector");
+            if (!codexInjector) {
+                // Import and initialize codex injector
+                // Try import with .js extension first (for Node.js/test environment)
+                let CodexInjector;
+                try {
+                    ({ CodexInjector } = await import("./codex-injector"));
+                }
+                catch (importError) {
+                    frameworkLogger.log("boot-orchestrator", "codex-injector-load-failed", "error", { error: importError, message: "Failed to load codex injector" });
+                    return false;
+                }
+                codexInjector = new CodexInjector();
+                this.stateManager.set("processor:codex_injector", codexInjector);
+            }
+            // Enable compliance validation
+            this.stateManager.set("compliance:active", true);
+            this.stateManager.set("compliance:validator", codexInjector);
+            this.stateManager.set("compliance:activated_at", Date.now());
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "codex-compliance-failed", "error", { error, message: "Failed to activate codex compliance" });
+            return false;
+        }
+    }
+    async initializeSecurityComponents() {
+        try {
+            this.stateManager.set("security:hardener", securityHardener);
+            this.stateManager.set("security:headers_middleware", securityHeadersMiddleware);
+            this.stateManager.set("security:initialized", true);
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "security-init-failed", "error", { error, message: "Failed to initialize security components" });
+            throw error;
+        }
+    }
+    async finalizeSecurityIntegration() {
+        try {
+            const auditResult = await this.runInitialSecurityAudit();
+            this.stateManager.set("security:initial_audit", auditResult);
+            const hardener = this.stateManager.get("security:hardener");
+            if (hardener?.config?.enableSecureHeaders) {
+                this.stateManager.set("security:headers_active", true);
+            }
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "security-finalize-failed", "error", { error, message: "Failed to finalize security integration" });
+        }
+    }
+    async runInitialSecurityAudit() {
+        try {
+            const securityAuditorPath = pathResolver.resolveModulePath("security/security-auditor");
+            const { SecurityAuditor } = await import(securityAuditorPath);
+            const auditor = new SecurityAuditor();
+            const result = await auditor.auditProject(process.cwd());
+            if (result.score < 80) {
+                frameworkLogger.log("boot-orchestrator", "low-security-score", "warning", {
+                    score: result.score,
+                    message: `Initial security score: ${result.score}/100 (target: 80+)`,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "security-audit-failed", "error", { error, message: "Failed to run initial security audit" });
+            return { score: 0, issues: [] };
+        }
+    }
+    /**
+     * Validate processor health during boot
+     */
+    async validateProcessorHealth() {
+        try {
+            const healthStatus = this.processorManager.getProcessorHealth();
+            const failedProcessors = healthStatus.filter((h) => h.status === "failed");
+            if (failedProcessors.length > 0) {
+                frameworkLogger.log("boot-orchestrator", "processor-health-failed", "error", {
+                    failedProcessors: failedProcessors.map((p) => p.name),
+                    message: `${failedProcessors.length} processors failed health check`,
+                });
+                return false;
+            }
+            const degradedProcessors = healthStatus.filter((h) => h.status === "degraded");
+            if (degradedProcessors.length > 0) {
+                frameworkLogger.log("boot-orchestrator", "processors-degraded", "warning", {
+                    degradedProcessors: degradedProcessors.map((p) => p.name),
+                    message: `${degradedProcessors.length} processors are degraded`,
+                });
+            }
+            return true;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "processor-health-validation-failed", "error", { error, message: "Processor health validation failed" });
+            return false;
+        }
+    }
+    /**
+     * Get current boot status information
+     */
+    getBootStatus() {
+        const agentsLoaded = this.stateManager.get("session:agents") || [];
+        const errors = [];
+        // Check for any stored errors
+        const storedErrors = this.stateManager.get("boot:errors");
+        if (Array.isArray(storedErrors)) {
+            errors.push(...storedErrors);
+        }
+        return {
+            success: this.stateManager.get("boot:success") || false,
+            orchestratorLoaded: !!this.stateManager.get("orchestrator"),
+            sessionManagementActive: this.stateManager.get("session:active") || false,
+            processorsActivated: this.stateManager.get("processor:active") || false,
+            enforcementEnabled: this.stateManager.get("enforcement:active") || false,
+            codexComplianceActive: this.stateManager.get("compliance:active") || false,
+            agentsLoaded: Array.isArray(agentsLoaded) ? agentsLoaded : [],
+            errors,
+        };
+    }
+    /**
+     * Set up comprehensive memory monitoring and alerting
+     */
+    setupMemoryMonitoring() {
+        // Start memory monitor
+        memoryMonitor.start();
+        advancedProfiler.start();
+        // CRITICAL FIX: Only add alert listener once to prevent memory leak
+        // Each BootOrchestrator instantiation was adding duplicate listeners
+        let currentListenerCount = 0;
+        try {
+            if (typeof memoryMonitor.listenerCount === "function") {
+                currentListenerCount = memoryMonitor.listenerCount("alert");
+            }
+            else if (memoryMonitor.listeners &&
+                typeof memoryMonitor.listeners === "function") {
+                currentListenerCount = memoryMonitor.listeners("alert").length;
+            }
+        }
+        catch (e) {
+            // Fallback: assume no listeners if we can't determine count
+            currentListenerCount = 0;
+        }
+        if (currentListenerCount === 0) {
+            // First time setup - add the memory alert handler
+            memoryMonitor.on("alert", (alert) => {
+                const level = alert.severity === "critical"
+                    ? "error"
+                    : alert.severity === "high"
+                        ? "warn"
+                        : "info";
+                frameworkLogger.log("boot-orchestrator", `🚨 MEMORY ALERT: ${alert.message}`, "error");
+                // Store alert in state for dashboard access
+                const alerts = this.stateManager.get("memory:alerts") || [];
+                alerts.push({
+                    ...alert,
+                    timestamp: Date.now(),
+                });
+                // Keep only last 100 alerts
+                if (alerts.length > 100) {
+                    alerts.shift();
+                }
+                this.stateManager.set("memory:alerts", alerts);
+                // Log recommendations
+                alert.details.recommendations.forEach((rec) => {
+                    frameworkLogger.log("boot-orchestrator", `💡 ${rec}`, "info");
+                });
+            });
+        }
+        // Log initial memory status
+        const initialStats = memoryMonitor.getCurrentStats();
+        frameworkLogger.log("boot-orchestrator", `🧠 Initial memory: ${initialStats.heapUsed.toFixed(1)}MB heap, ${initialStats.heapTotal.toFixed(1)}MB total`, "info");
+        // Store initial memory baseline
+        this.stateManager.set("memory:baseline", initialStats);
+    }
+    /**
+     * Perform comprehensive memory health check
+     */
+    getMemoryHealth() {
+        const summary = memoryMonitor.getSummary();
+        const issues = [];
+        // Check for memory issues
+        if (summary.current.heapUsed > 400) {
+            issues.push(`Critical heap usage: ${summary.current.heapUsed.toFixed(1)}MB`);
+        }
+        else if (summary.current.heapUsed > 200) {
+            issues.push(`High heap usage: ${summary.current.heapUsed.toFixed(1)}MB`);
+        }
+        if (summary.trend === "increasing") {
+            issues.push("Memory usage trending upward - potential leak detected");
+        }
+        if (summary.peak.heapUsed > 500) {
+            issues.push(`Peak usage exceeded safe limits: ${summary.peak.heapUsed.toFixed(1)}MB`);
+        }
+        return {
+            healthy: issues.length === 0,
+            issues,
+            metrics: summary,
+        };
+    }
+    /**
+     * Execute the boot sequence (internal framework initialization)
+     */
+    async executeBootSequence() {
+        const jobId = `boot-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        if (!this.shutdownInitialized) {
+            setupGracefulShutdown();
+            this.shutdownInitialized = true;
+        }
+        this.setupMemoryMonitoring();
+        frameworkLogger.log("boot-orchestrator", "executeBootSequence started", "info", { jobId });
+        const result = {
+            success: false,
+            orchestratorLoaded: false,
+            sessionManagementActive: false,
+            processorsActivated: false,
+            agentsLoaded: [],
+            enforcementEnabled: false,
+            codexComplianceActive: false,
+            errors: [],
+        };
+        try {
+            frameworkLogger.log("boot-orchestrator", "loading xray configuration", "info", { jobId });
+            // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks)
+            await this.loadXrayConfiguration(jobId);
+            frameworkLogger.log("boot-orchestrator", "xray configuration loaded", "success", { jobId });
+            // Phase 1: Initialize core systems
+            frameworkLogger.log("boot-orchestrator", "initializing core systems", "info", { jobId });
+            result.orchestratorLoaded = await this.loadOrchestrator();
+            if (!result.orchestratorLoaded) {
+                frameworkLogger.log("boot-orchestrator", "orchestrator loading failed", "error", { jobId });
+                result.errors.push("Failed to load orchestrator");
+                return result;
+            }
+            frameworkLogger.log("boot-orchestrator", "orchestrator loaded successfully", "success", { jobId });
+            const delegationInitialized = await this.initializeDelegationSystem();
+            if (!delegationInitialized) {
+                frameworkLogger.log("boot-orchestrator", "delegation system initialization failed", "error", { jobId });
+                result.errors.push("Failed to initialize delegation system");
+                return result;
+            }
+            frameworkLogger.log("boot-orchestrator", "delegation system initialized", "success", { jobId });
+            // Phase 2: Session management
+            if (this.config.sessionManagement) {
+                result.sessionManagementActive =
+                    await this.initializeSessionManagement();
+                if (!result.sessionManagementActive) {
+                    frameworkLogger.log("boot-orchestrator", "session management initialization failed", "error", { jobId });
+                }
+            }
+            // Phase 2.5: Initialize activity logging from features.json config
+            try {
+                const { initializeActivityLogger } = await import("./activity-logger.js");
+                const activityConfig = featuresConfigLoader.loadConfig().activity_logging;
+                if (activityConfig?.enabled !== false) {
+                    initializeActivityLogger({
+                        enabled: activityConfig?.enabled ?? true,
+                        log_path: activityConfig?.log_path,
+                    });
+                    frameworkLogger.log("boot-orchestrator", "activity logging initialized from config", "info", { jobId, enabled: activityConfig?.enabled ?? true });
+                }
+            }
+            catch (error) {
+                // Activity logger init failure is non-fatal
+                frameworkLogger.log("boot-orchestrator", "activity logging init skipped", "info", { jobId });
+            }
+            // Phase 3: Processors
+            if (this.config.processorActivation) {
+                frameworkLogger.log("boot-orchestrator", "activating processors", "info", { jobId });
+                result.processorsActivated = await this.activateProcessors(jobId);
+                if (!result.processorsActivated) {
+                    frameworkLogger.log("boot-orchestrator", "processor activation failed", "error", { jobId });
+                    result.errors.push("Failed to activate processors");
+                    return result;
+                }
+                else {
+                    frameworkLogger.log("boot-orchestrator", "processors activated successfully", "success", { jobId });
+                }
+                frameworkLogger.log("boot-orchestrator", "processors activated successfully", "success", { jobId });
+                // Validate processor health
+                const healthValid = await this.validateProcessorHealth();
+                if (!healthValid) {
+                    frameworkLogger.log("boot-orchestrator", "processor health validation failed", "error", { jobId });
+                    result.errors.push("Processor health validation failed");
+                    return result;
+                }
+                frameworkLogger.log("boot-orchestrator", "processor health validated", "success", { jobId });
+            }
+            // Phase 4: Load agents
+            if (this.config.agentLoading) {
+                result.agentsLoaded = await this.loadRemainingAgents(jobId);
+            }
+            // Phase 4.5: Initialize plugin system
+            if (await this.initializePluginSystem(jobId)) {
+                frameworkLogger.log("boot-orchestrator", "plugin system initialized", "success", { jobId });
+            }
+            else {
+                frameworkLogger.log("boot-orchestrator", "plugin system init failed", "warning", { jobId });
+            }
+            // Phase 5: Security & compliance
+            if (this.config.enableEnforcement) {
+                frameworkLogger.log("boot-orchestrator", "enabling enforcement", "info", { jobId });
+                result.enforcementEnabled = await this.enableEnforcement();
+                if (!result.enforcementEnabled) {
+                    frameworkLogger.log("boot-orchestrator", "enforcement enable failed", "error", { jobId });
+                    result.errors.push("Failed to enable enforcement");
+                    return result;
+                }
+                else {
+                    frameworkLogger.log("boot-orchestrator", "enforcement enabled successfully", "success", { jobId });
+                }
+            }
+            if (this.config.codexValidation) {
+                frameworkLogger.log("boot-orchestrator", "activating codex compliance", "info", { jobId });
+                result.codexComplianceActive = await this.activateCodexCompliance();
+                if (!result.codexComplianceActive) {
+                    frameworkLogger.log("boot-orchestrator", "codex compliance activation failed", "error", { jobId });
+                    result.errors.push("Failed to activate codex compliance");
+                    return result;
+                }
+                else {
+                    frameworkLogger.log("boot-orchestrator", "codex compliance activated successfully", "success", { jobId });
+                }
+            }
+            // Finalize security integration
+            await this.finalizeSecurityIntegration();
+            // Initialize governance (Dynamo Solar SSOT + GovernanceService)
+            // This must happen early so GovernanceService has the managed integration ready.
+            const govConfig = featuresConfigLoader.config?.governance ??
+                featuresConfigLoader.config?.inference_governance;
+            if (govConfig?.enabled !== false) {
+                try {
+                    await initializeGovernanceIntegration();
+                    frameworkLogger.log("boot-orchestrator", "governance-initialized", "info", {
+                        message: "Dynamo Solar SSOT integration initialized during boot",
+                    });
+                }
+                catch (err) {
+                    frameworkLogger.log("boot-orchestrator", "governance-init-warning", "warning", {
+                        message: "Failed to initialize governance integration during boot",
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            result.success = true;
+        }
+        catch (error) {
+            result.errors.push(`Boot sequence error: ${error}`);
+        }
+        // Store boot result in state manager for getBootStatus
+        this.stateManager.set("boot:success", result.success);
+        this.stateManager.set("boot:errors", result.errors);
+        return result;
+    }
+    // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks)
+    async loadXrayConfiguration(jobId) {
+        try {
+            // Consumer runtime compat shim from prior 0xRay releases (1-line min per Scope Rule; primary xray paths + .xray fallbacks)
+            const xrayConfig = {
+                version: (() => {
+                    try {
+                        return JSON.parse(readFileSync(path.join(process.cwd(), "package.json"), "utf-8")).version;
+                    }
+                    catch {
+                        return "unknown";
+                    }
+                })(),
+                codex_enabled: true,
+                codex_version: "v1.7.5",
+                codex_terms: [
+                    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+                    21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
+                    38, 39, 40, 41, 42, 43,
+                ],
+                monitoring_metrics: [
+                    "bundle-size",
+                    "test-coverage",
+                    "code-duplication",
+                    "build-time",
+                    "error-rate",
+                ],
+                monitoring_alerts: [
+                    "threshold-violations",
+                    "security-issues",
+                    "performance-degradation",
+                    "test-failures",
+                ],
+                agent_capabilities: {
+                    enforcer: [
+                        "compliance-monitoring",
+                        "threshold-enforcement",
+                        "automation-orchestration",
+                    ],
+                    architect: [
+                        "design-review",
+                        "architecture-validation",
+                        "dependency-analysis",
+                    ],
+                    orchestrator: [
+                        "task-coordination",
+                        "multi-agent-orchestration",
+                        "workflow-management",
+                    ],
+                    "bug-triage-specialist": [
+                        "error-analysis",
+                        "root-cause-identification",
+                        "fix-suggestions",
+                    ],
+                    "code-reviewer": [
+                        "code-quality-assessment",
+                        "best-practice-validation",
+                        "security-review",
+                    ],
+                    "security-auditor": [
+                        "vulnerability-detection",
+                        "threat-analysis",
+                        "security-validation",
+                    ],
+                    refactorer: ["code-modernization", "debt-reduction", "consolidation"],
+                    "testing-lead": [
+                        "test-strategy-design",
+                        "coverage-optimization",
+                        "behavioral-testing",
+                    ],
+                },
+            };
+            // Store configuration in state manager for use by other components
+            this.stateManager.set("xray:config", xrayConfig);
+            this.stateManager.set("xray:version", xrayConfig.version);
+            this.stateManager.set("xray:codex_enabled", xrayConfig.codex_enabled);
+            this.stateManager.set("xray:codex_terms", xrayConfig.codex_terms);
+            this.stateManager.set("xray:monitoring_metrics", xrayConfig.monitoring_metrics);
+            this.stateManager.set("xray:monitoring_alerts", xrayConfig.monitoring_alerts);
+            this.stateManager.set("xray:agent_capabilities", xrayConfig.agent_capabilities);
+            await frameworkLogger.log("boot-orchestrator", "configuration-loaded", "success", { jobId });
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "config-load-warning", "warning", { error, message: "Failed to load xray configuration" });
+            // Continue with defaults if loading fails
+        }
+    }
+}
+// Export singleton instance
+export const bootOrchestrator = new BootOrchestrator();