0xray 2.1.4 → 2.2.1

package/dist/nucleus/plugin-registry.js

@@ -0,0 +1,147 @@
+/**
+ * PluginRegistry — Phase 1.2 dynamic skill loading + Phase 3 generic tool dispatch
+ *
+ * Allows skills to be registered after boot, loaded from config, or discovered
+ * at runtime. Wraps the existing in-process-skill-registry for backward compat.
+ *
+ * Phase 3 extension: SkillToolPlugin interface for multi-tool skills (knowledge-skill
+ * servers). Each server registers as a SkillToolPlugin, exposing arbitrary tools
+ * that can be dispatched via callSkillTool().
+ *
+ * Goals:
+ * - New skills can be registered post-boot via register()
+ * - Skills are discoverable by name without importing server constructors
+ * - Default set loads automatically from the existing 3 governance skills
+ * - Multi-tool skills can be registered and dispatched via callSkillTool()
+ * - Backward compatible: callInProcessSkill still works as before
+ */
+import { callInProcessSkill } from '../mcps/in-process-skill-registry.js';
+import { frameworkLogger } from '../core/framework-logger.js';
+class PluginRegistryImpl {
+    skills = new Map();
+    /** Phase 3: multi-tool skill plugins (knowledge-skill servers) */
+    toolPlugins = new Map();
+    initialized = false;
+    /**
+     * Register a skill plugin. Can be called after boot.
+     */
+    register(skill) {
+        if (this.skills.has(skill.name)) {
+            frameworkLogger.log('plugin-registry', 'register-overwrite', 'warning', {
+                skillName: skill.name,
+                message: 'Overwriting existing skill registration',
+            });
+        }
+        this.skills.set(skill.name, (args) => skill.analyzeProposal(args));
+        frameworkLogger.log('plugin-registry', 'register', 'info', {
+            skillName: skill.name,
+            totalSkills: this.skills.size,
+        });
+    }
+    /**
+     * Register a multi-tool skill plugin (knowledge-skill server).
+     * Tools can be dispatched via callSkillTool().
+     */
+    registerToolPlugin(skill) {
+        if (this.toolPlugins.has(skill.name)) {
+            frameworkLogger.log('plugin-registry', 'register-tool-overwrite', 'warning', {
+                skillName: skill.name,
+                message: 'Overwriting existing tool plugin registration',
+            });
+        }
+        this.toolPlugins.set(skill.name, (toolName, args) => skill.callTool(toolName, args));
+        frameworkLogger.log('plugin-registry', 'register-tool', 'info', {
+            skillName: skill.name,
+            totalToolPlugins: this.toolPlugins.size,
+        });
+    }
+    /**
+     * Call a named tool on a registered multi-tool skill plugin.
+     */
+    async callSkillTool(skillName, toolName, args) {
+        const handler = this.toolPlugins.get(skillName);
+        if (!handler) {
+            throw new Error(`No tool plugin registered: ${skillName}. Available: ${Array.from(this.toolPlugins.keys()).join(', ')}`);
+        }
+        return handler(toolName, args);
+    }
+    /**
+     * Check if a tool plugin is registered.
+     */
+    hasToolPlugin(name) {
+        return this.toolPlugins.has(name);
+    }
+    /**
+     * List all registered tool plugin names.
+     */
+    listToolPlugins() {
+        return Array.from(this.toolPlugins.keys());
+    }
+    /**
+     * Get a skill handler by name. Falls back to the in-process registry
+     * for the built-in governance skills (code-review, security-audit, researcher).
+     */
+    get(name) {
+        const handler = this.skills.get(name);
+        if (handler)
+            return handler;
+        // Fall back to the built-in registry for the 3 governance skills
+        const builtInNames = ['code-review', 'security-audit', 'researcher'];
+        if (builtInNames.includes(name)) {
+            return async (args) => {
+                const result = await callInProcessSkill(name, 'analyze_proposal', args);
+                return result;
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Check if a skill is registered (either in the plugin registry or the built-in registry).
+     */
+    has(name) {
+        return this.skills.has(name) || ['code-review', 'security-audit', 'researcher'].includes(name);
+    }
+    /**
+     * List all registered skill names (plugins + built-in).
+     */
+    list() {
+        const builtIn = ['code-review', 'security-audit', 'researcher'];
+        const pluginNames = Array.from(this.skills.keys());
+        return [...new Set([...builtIn, ...pluginNames])];
+    }
+    /**
+     * Call a skill by name. Delegates to the plugin registry first,
+     * then falls back to the built-in in-process registry.
+     */
+    async callSkill(name, args) {
+        const handler = this.get(name);
+        if (!handler) {
+            throw new Error(`No skill registered: ${name}. Available: ${this.list().join(', ')}`);
+        }
+        return handler(args);
+    }
+    /**
+     * Initialize with default governance skills. Called once at boot.
+     * The 3 governance skills are always available via the built-in registry.
+     */
+    initializeDefaults() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        frameworkLogger.log('plugin-registry', 'initialize-defaults', 'info', {
+            builtInSkills: ['code-review', 'security-audit', 'researcher'],
+            message: 'Default governance skills available via built-in registry',
+        });
+    }
+    /**
+     * Reset the registry for testing. Removes all registered plugins
+     * (built-in governance skills remain available via fallback).
+     */
+    resetForTest() {
+        this.skills.clear();
+        this.toolPlugins.clear();
+        this.initialized = false;
+    }
+}
+/** Singleton plugin registry */
+export const pluginRegistry = new PluginRegistryImpl();

package/dist/orchestrator/orchestrator.d.ts

@@ -64,7 +64,6 @@ export declare class XrayOrchestrator {
     private config;
     private activeTasks;
     private taskToAgentMap;
-    private votingCoordinator;
     constructor(config?: Partial<OrchestratorConfig>);
     /**
      * Load orchestrator config from features.json

package/dist/orchestrator/orchestrator.js

@@ -11,15 +11,12 @@ 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 = {
@@ -28,7 +25,6 @@ export class XrayOrchestrator {
             conflictResolutionStrategy: loadedConfig?.conflictResolutionStrategy ?? "majority_vote",
             ...config,
         };
-        this.votingCoordinator = new VotingCoordinator(new XrayStateManager());
     }
     /**
      * Load orchestrator config from features.json
@@ -513,23 +509,6 @@ 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) {

package/dist/postprocessor/PostProcessor.d.ts

@@ -10,6 +10,7 @@
 import { XrayStateManager } from "../state/state-manager.js";
 import { SessionMonitor } from "../session/session-monitor.js";
 import { PostProcessorConfig, PostProcessorResult, PostProcessorContext } from "./types.js";
+import type { MetamorphosisEngine } from "./metamorphosis/MetamorphosisEngine.js";
 export declare class PostProcessor {
     private stateManager;
     private sessionMonitor;
@@ -28,7 +29,18 @@ export declare class PostProcessor {
     private successHandler;
     private triggers;
     private complianceChecker;
-    constructor(stateManager: XrayStateManager, sessionMonitor?: SessionMonitor | null, config?: Partial<PostProcessorConfig>);
+    private metamorphosisEngines;
+    constructor(stateManager: XrayStateManager, sessionMonitor?: SessionMonitor | null, config?: Partial<PostProcessorConfig>, metamorphosisEngines?: MetamorphosisEngine[]);
+    /**
+     * Notify metamorphosis engines of a lifecycle phase.
+     * No-op when no engines are configured.
+     */
+    private notifyPhase;
+    /**
+     * Notify metamorphosis engines of a generated proposal.
+     * No-op when no engines are configured.
+     */
+    private notifyProposal;
     /**
      * Initialize the post-processor system
      */

package/dist/postprocessor/PostProcessor.js

@@ -44,10 +44,12 @@ export class PostProcessor {
     successHandler;
     triggers;
     complianceChecker;
-    constructor(stateManager, sessionMonitor = null, config = {}) {
+    metamorphosisEngines;
+    constructor(stateManager, sessionMonitor = null, config = {}, metamorphosisEngines) {
         this.stateManager = stateManager;
         this.sessionMonitor = sessionMonitor;
         this.config = { ...defaultConfig, ...config };
+        this.metamorphosisEngines = metamorphosisEngines ?? [];
         // Initialize monitoring engine
         this.monitoringEngine = new PostProcessorMonitoringEngine(this.stateManager, this.sessionMonitor || undefined);
         // Initialize failure analysis and auto-fix engines
@@ -73,6 +75,42 @@ export class PostProcessor {
         // Initialize architectural compliance checker
         this.complianceChecker = new ArchitecturalComplianceChecker();
     }
+    /**
+     * Notify metamorphosis engines of a lifecycle phase.
+     * No-op when no engines are configured.
+     */
+    async notifyPhase(phase, context) {
+        for (const engine of this.metamorphosisEngines) {
+            try {
+                await engine.onPhase?.(phase, context);
+            }
+            catch (err) {
+                await frameworkLogger.log("postprocessor", "metamorphosis-phase-error", "error", {
+                    engine: engine.name,
+                    phase,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    /**
+     * Notify metamorphosis engines of a generated proposal.
+     * No-op when no engines are configured.
+     */
+    async notifyProposal(proposal) {
+        for (const engine of this.metamorphosisEngines) {
+            try {
+                await engine.onProposal?.(proposal);
+            }
+            catch (err) {
+                await frameworkLogger.log("postprocessor", "metamorphosis-proposal-error", "error", {
+                    engine: engine.name,
+                    proposalId: proposal.id,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
     /**
      * Initialize the post-processor system
      */
@@ -253,6 +291,7 @@ export class PostProcessor {
             await frameworkLogger.log("postprocessor", "loop-completed", "success", {
                 message: `✅ Post-processor loop completed: ${result.success ? "SUCCESS" : "FAILED"}`,
             });
+            await this.notifyPhase('post-process-complete', { context, result });
             return result;
         }
         catch (error) {
@@ -291,6 +330,7 @@ export class PostProcessor {
             monitoringResults.push(monitoringResult);
             if (monitoringResult.overallStatus === "success") {
                 await frameworkLogger.log("postprocessor", "pipeline-success", "success", { message: "✅ CI/CD pipeline successful - post-processor complete" });
+                await this.notifyPhase('monitoring-complete', { context, monitoringResult });
                 const result = {
                     success: true,
                     commitSha: context.commitSha,

package/dist/postprocessor/autofix/AutoFixEngine.d.ts

@@ -33,14 +33,6 @@ export declare class AutoFixEngine {
      * Apply test regeneration fixes
      */
     private applyTestRegeneration;
-    /**
-     * Validate that applied fixes resolve the issue
-     */
-    validateFixes(fixes: AppliedFixRecord[], originalFailure: FailureAnalysis, context: PostProcessorContext): Promise<boolean>;
-    /**
-     * Rollback applied fixes if validation fails
-     */
-    rollbackFixes(fixes: AppliedFixRecord[]): Promise<void>;
     /**
      * Get the list of applied fixes
      */

package/dist/postprocessor/autofix/AutoFixEngine.js

@@ -191,60 +191,6 @@ export class AutoFixEngine {
             };
         }
     }
-    /**
-     * Validate that applied fixes resolve the issue
-     */
-    async validateFixes(fixes, originalFailure, context) {
-        const jobId = `fix-validation-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        await frameworkLogger.log("-auto-fix-engine", "-validating-applied-fixes-", "success", { message: "✅ Validating applied fixes..." });
-        try {
-            // Run relevant tests based on failure type
-            switch (originalFailure.category) {
-                case "test-failure":
-                    execSync("npm test", { stdio: "pipe", timeout: 120000 });
-                    break;
-                case "build-failure":
-                    execSync("npm run build", { stdio: "pipe", timeout: 120000 });
-                    break;
-                case "code-quality-failure":
-                    execSync("npm run lint", { stdio: "pipe", timeout: 60000 });
-                    break;
-                case "security-failure":
-                    execSync("npm run security-audit", { stdio: "pipe", timeout: 60000 });
-                    break;
-                case "performance-regression":
-                    execSync("npm run test:performance", {
-                        stdio: "pipe",
-                        timeout: 120000,
-                    });
-                    break;
-                default:
-                    // Run a basic validation
-                    execSync("npm run typecheck", { stdio: "pipe", timeout: 60000 });
-            }
-            await frameworkLogger.log("-auto-fix-engine", "-fix-validation-passed-", "success", { message: "✅ Fix validation passed" });
-            return true;
-        }
-        catch (error) {
-            await frameworkLogger.log("auto-fix-engine", "validation-failed", "error", { jobId });
-            return false;
-        }
-    }
-    /**
-     * Rollback applied fixes if validation fails
-     */
-    async rollbackFixes(fixes) {
-        await frameworkLogger.log("-auto-fix-engine", "-rolling-back-applied-fixes-", "info", { message: "🔄 Rolling back applied fixes..." });
-        try {
-            // Simple git reset for now
-            execSync("git reset --hard HEAD~1", { stdio: "inherit" });
-            await frameworkLogger.log("-auto-fix-engine", "-fixes-rolled-back-", "success", { message: "✅ Fixes rolled back" });
-        }
-        catch (error) {
-            await frameworkLogger.log("autofix-engine", "rollback-failed", "error", { error: error instanceof Error ? error.message : String(error) });
-            throw error;
-        }
-    }
     /**
      * Get the list of applied fixes
      */

package/dist/postprocessor/metamorphosis/MetamorphosisEngine.d.ts

@@ -0,0 +1,25 @@
+/**
+ * MetamorphosisEngine — Phase 0.5 skeleton
+ *
+ * Plug into PostProcessor lifecycle hooks to observe phases and proposals.
+ * No-op when none configured. Concrete engines will be built in Phase 2.
+ *
+ * Integration: PostProcessor accepts optional MetamorphosisEngine[] in constructor.
+ * Each engine receives onPhase/onProposal lifecycle notifications.
+ */
+export interface MetamorphosisProposal {
+    id: string;
+    type: 'add' | 'modify' | 'remove';
+    target: string;
+    description: string;
+    rationale: string;
+    impact: 'low' | 'medium' | 'high';
+}
+export interface MetamorphosisEngine {
+    /** Human-readable engine name (for logging) */
+    name: string;
+    /** Called when PostProcessor enters a phase */
+    onPhase?(phase: string, context: unknown): Promise<void>;
+    /** Called when a metamorphosis proposal is generated */
+    onProposal?(proposal: MetamorphosisProposal): Promise<void>;
+}

package/dist/postprocessor/metamorphosis/MetamorphosisEngine.js

@@ -0,0 +1,10 @@
+/**
+ * MetamorphosisEngine — Phase 0.5 skeleton
+ *
+ * Plug into PostProcessor lifecycle hooks to observe phases and proposals.
+ * No-op when none configured. Concrete engines will be built in Phase 2.
+ *
+ * Integration: PostProcessor accepts optional MetamorphosisEngine[] in constructor.
+ * Each engine receives onPhase/onProposal lifecycle notifications.
+ */
+export {};

package/dist/postprocessor/metamorphosis/SelfProposalEngine.d.ts

@@ -0,0 +1,68 @@
+/**
+ * SelfProposalEngine — Phase 2.2
+ *
+ * Concrete MetamorphosisEngine that reads activity.log, parses structured
+ * log entries, detects semantic patterns, generates governance proposals
+ * (type: 'metamorphosis'), and submits them through the full 3-agent +
+ * Dynamo governance pipeline.
+ *
+ * Safety constraints:
+ * - Max proposals per hour (default 1, configurable)
+ * - Circuit breaker: after N consecutive failures, halt for cooldown (default 3/24h)
+ * - Only proposes changes to whitelisted targets
+ * - All proposals go through full governance with metamorphosisThreshold (default 0.7)
+ * - Detection thresholds are configurable (not hard-coded)
+ *
+ * Coupling note: currently triggered by PostProcessor.onPhase(). A future
+ * refactor should extract log-reading into a dedicated LogReader that can
+ * run on its own schedule or fs.watch, decoupling from PostProcessor lifecycle.
+ */
+import type { MetamorphosisEngine, MetamorphosisProposal } from './MetamorphosisEngine.js';
+export interface SelfProposalConfig {
+    maxProposalsPerHour?: number;
+    circuitBreakerThreshold?: number;
+    circuitBreakerCooldownHours?: number;
+    activityLogPath?: string;
+    whitelistedTargets?: string[];
+    /** Number of recent log lines to analyze (default: 100) */
+    maxLogLines?: number;
+    /** Minimum error entries to trigger an error-handling proposal (default: 5) */
+    errorThreshold?: number;
+    /** Minimum warning entries to trigger a monitoring proposal (default: 10) */
+    warningThreshold?: number;
+    /** Minimum governance rejections of same type to trigger a pattern proposal (default: 3) */
+    governanceRejectionThreshold?: number;
+    /** Minimum confidence for generated proposals (default: 0.7) */
+    proposalConfidence?: number;
+    /** Metamorphosis score threshold for approval (default: 0.7) */
+    metamorphosisThreshold?: number;
+    /** Project root for resolving whitelisted target paths (default: process.cwd()) */
+    projectRoot?: string;
+}
+export declare class SelfProposalEngine implements MetamorphosisEngine {
+    readonly name = "self-proposal";
+    private config;
+    private proposalHistory;
+    private consecutiveFailures;
+    private circuitBreakerUntil;
+    constructor(config?: SelfProposalConfig);
+    onPhase(phase: string, context: unknown): Promise<void>;
+    onProposal(proposal: MetamorphosisProposal): Promise<void>;
+    private isCircuitBreakerActive;
+    private isRateLimited;
+    private evaluateAndPropose;
+    /**
+     * Detect actionable patterns from parsed activity log entries.
+     * Uses structured parsing instead of raw string matching to handle
+     * the actual xray log format:
+     *   ISO_TIMESTAMP [jobId] [traceId.spanId] [component] action - STATUS | {details}
+     */
+    detectPatterns(entries: string[]): MetamorphosisProposal[];
+    /**
+     * Apply an approved self-evolution proposal by recording the change
+     * in a state file within the first matching whitelisted target directory.
+     * Returns true if the change was written and verified, false otherwise.
+     */
+    private applySelfProposal;
+    private submitProposal;
+}