0xray 2.1.3 → 2.2.0

package/dist/governance/governance-service.js

@@ -17,8 +17,9 @@
  */
 import { mcpClientManager } from '../mcps/mcp-client.js';
 import { callInProcessSkill } from '../mcps/in-process-skill-registry.js';
+import { pluginRegistry } from '../nucleus/plugin-registry.js';
 import { getGovernanceIntegration, } from '../integrations/governance/index.js';
-import { mergeVotes } from './governance-core.js';
+import { mergeVotes, calculateMetamorphosisScore } from './governance-core.js';
 import { frameworkLogger } from '../core/framework-logger.js';
 export class GovernanceService {
     constructor() {
@@ -59,7 +60,7 @@ export class GovernanceService {
             }
         }
         // Run governance with end-to-end timeout
-        const result = await this.runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs);
+        const result = await this.runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, options?.metamorphosisThreshold);
         // Check abstention threshold
         if (result.results.length > 0 && maxAbstentionThreshold < 1.0) {
             const totalVotes = result.results.reduce((sum, r) => sum + r.votes.length, 0);
@@ -91,7 +92,7 @@ export class GovernanceService {
             },
         };
     }
-    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs) {
+    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, metamorphosisThreshold) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
         try {
@@ -112,13 +113,33 @@ export class GovernanceService {
                     ...(externalVotes[index] || []),
                 ];
                 const merged = mergeVotes(votes);
-                return {
+                const isMetamorphosis = proposal.type === 'metamorphosis' || proposal.source === 'metamorphosis';
+                const result = {
                     proposalId: proposal.id,
                     finalDecision: merged.finalDecision,
                     averageConfidence: merged.averageConfidence,
                     votes,
                     reasoningSummary: merged.reasoningSummary,
                 };
+                // Metamorphosis resonance scoring: only for self-evolution proposals
+                if (isMetamorphosis) {
+                    const threshold = metamorphosisThreshold ?? 0.7;
+                    const metaInput = {
+                        averageConfidence: merged.averageConfidence,
+                        proposalType: proposal.type,
+                    };
+                    const externalConfidence = externalVotes[index]?.[0]?.confidence;
+                    if (externalConfidence !== undefined) {
+                        metaInput.historicalCoherence = externalConfidence;
+                    }
+                    result.metamorphosisScore = calculateMetamorphosisScore(metaInput);
+                    // Reject metamorphosis proposals that don't meet the threshold
+                    if (result.metamorphosisScore < threshold && result.finalDecision === 'approve') {
+                        result.finalDecision = 'needs_revision';
+                        result.reasoningSummary += ` | Metamorphosis score ${result.metamorphosisScore} below threshold ${threshold}`;
+                    }
+                }
+                return result;
             });
             return { results };
         }
@@ -129,6 +150,45 @@ export class GovernanceService {
     async callSkillServer(serverName, proposals, context) {
         const votes = [];
         const useInProcess = process.env.VERCEL === '1';
+        // v3: Try pluginRegistry first for dynamically registered skills.
+        // Built-in skills (code-review, security-audit, researcher) fall through
+        // to MCP or in-process paths. Custom plugins registered via
+        // pluginRegistry.register() are resolved here.
+        if (pluginRegistry.has(serverName) && !this.isBuiltInSkill(serverName)) {
+            frameworkLogger.log('governance-service', 'plugin-skill-resolved', 'info', {
+                server: serverName,
+                mode: 'plugin-registry',
+            });
+            for (const proposal of proposals) {
+                try {
+                    const result = await pluginRegistry.callSkill(serverName, {
+                        proposalTitle: proposal.title,
+                        proposalDescription: proposal.description,
+                        evidence: proposal.evidence || [],
+                        proposalType: proposal.type,
+                    });
+                    const text = result?.content?.[0]?.text || '';
+                    const vote = this.parseVoteFromText(serverName, text);
+                    votes.push(vote);
+                }
+                catch (error) {
+                    frameworkLogger.log('governance-service', 'plugin-skill-error', 'error', {
+                        server: serverName,
+                        proposal: proposal.title,
+                        error: error instanceof Error ? error.message : String(error),
+                        mode: 'plugin-registry',
+                    });
+                    votes.push({
+                        server: serverName,
+                        decision: 'abstain',
+                        confidence: 0.3,
+                        reasoning: `Plugin skill ${serverName} failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    });
+                }
+            }
+            return votes;
+        }
+        // Built-in skills: use MCP (standard surface) or in-process (Vercel)
         for (const proposal of proposals) {
             try {
                 let text = '';
@@ -263,6 +323,9 @@ export class GovernanceService {
             reasoning: reasoningMatch?.[1]?.trim() || 'No reasoning provided',
         };
     }
+    isBuiltInSkill(name) {
+        return name === 'code-review' || name === 'security-audit' || name === 'researcher';
+    }
 }
 // Singleton for convenience
 let governanceServiceInstance = null;

package/dist/governance/governance-types.d.ts

@@ -3,14 +3,14 @@
  * These types are used by the GovernanceService, Governance MCP,
  * and all integrations.
  */
-export type ProposalType = 'fix' | 'refactor' | 'guard' | 'automate' | 'codify' | 'strategic' | 'compliance';
+export type ProposalType = 'fix' | 'refactor' | 'guard' | 'automate' | 'codify' | 'strategic' | 'compliance' | 'metamorphosis';
 export interface GovernanceProposal {
     id: string;
     type: ProposalType;
     title: string;
     description: string;
     evidence?: string[];
-    source?: 'inference' | 'reflection' | 'manual' | 'ci' | 'phase-planning';
+    source?: 'inference' | 'reflection' | 'manual' | 'ci' | 'phase-planning' | 'metamorphosis';
     confidence?: number;
     metadata?: Record<string, unknown>;
 }
@@ -35,6 +35,8 @@ export interface GovernanceResult {
     recommendedActions?: string[];
     externalContext?: Record<string, unknown>;
     moralOverride?: 'rejected_critical' | 'downgraded_significant' | 'none';
+    /** Metamorphosis resonance score: does this change increase the system's ability to govern complex future states? 0-1. Only present when proposal.type === 'metamorphosis'. */
+    metamorphosisScore?: number;
 }
 export interface GovernanceContext {
     project?: string;
@@ -49,6 +51,7 @@ export interface GovernOptions {
     enableSolarAdjustment?: boolean;
     timeoutMs?: number;
     maxAbstentionThreshold?: number;
+    metamorphosisThreshold?: number;
 }
 export interface GovernanceRequest {
     proposals: GovernanceProposal[];

package/dist/inference/index.d.ts

@@ -1,10 +1,9 @@
 export { analyzeStructuralPatterns } from "./semantic-patterns.js";
 export type { StructuralPattern } from "./semantic-patterns.js";
 export { captureSessionInference, saveSessionInference, } from "./session-capture.js";
-export type { SessionInference, ReasoningLink, SessionMetrics, } from "./session-capture.js";
+export type { SessionInference, SessionMetrics, } from "./session-capture.js";
 export { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
-export type { InferenceCorpus, RecurringPattern, RecurringProblem } from "./inference-accumulator.js";
 export { InferenceCycle } from "./inference-cycle.js";
-export type { InferenceProposal, InferenceCycleResult, CyclePhase } from "./inference-cycle.js";
+export type { InferenceProposal, InferenceCycleResult } from "./inference-cycle.js";
 export { DeployVerifier } from "./deploy-verifier.js";
-export type { DeployVerificationResult, DeployCheck } from "./deploy-verifier.js";
+export type { DeployVerificationResult } from "./deploy-verifier.js";

package/dist/inference/inference-accumulator.js

@@ -108,7 +108,7 @@ function loadLastCycleDate(filePath) {
         return null;
     try {
         const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-        return data.completedAt || data.timestamp || null;
+        return data.completedAt || data.cycleState?.completedAt || data.timestamp || null;
     }
     catch {
         return null;

package/dist/inference/inference-cycle.d.ts

@@ -43,7 +43,6 @@ export declare class InferenceCycle {
     private static instances;
     private static reEntryLock;
     private static governedProposalIds;
-    private static votingCoordinator;
     static getInstance(projectRoot?: string, options?: InferenceCycleOptions): InferenceCycle;
     static resetInstance(): void;
     private inferenceDir;
@@ -58,7 +57,6 @@ export declare class InferenceCycle {
     maybeRunCycle(): Promise<InferenceCycleResult>;
     private generateProposals;
     private adjustFromHistory;
-    private getCoordinator;
     private applyProposals;
     private applyProposalWork;
     private applyCodeChange;
@@ -67,32 +65,28 @@ export declare class InferenceCycle {
     private extractTargetFiles;
     private researcherReview;
     private governProposals;
-    private isGovernanceMcpPreferred;
-    private parseGovernanceMcpResponse;
-    /**
-     * Oscillator 1: Internal VotingCoordinator-based governance
-     */
-    private governProposalsInternal;
     /**
-     * Pure individual knowledge-skill MCP path for governance.
-     * Used when XRAY_FORCE_MCP_GOVERNANCE=true.
-     * Each proposal is evaluated directly by the relevant skill servers using analyze_proposal.
+     * Map InferenceProposal.source to GovernanceProposal.source.
+     * Inference-specific sources (recurring_problem, recurring_pattern, wrong_turn)
+     * all normalize to 'inference'. Future tuning/mod-specific sources can be added here.
      */
-    private governProposalsWithIndividualSkills;
+    private static readonly SOURCE_MAP;
     /**
-     * Merge internal and external governance votes.
-     * A proposal passes both oscillators — must be approved by internal AND external.
+     * Convert InferenceProposal[] to GovernanceRequest and route through
+     * the nucleus kernel (handleGovernRequest). This is the v3 uniform path.
      */
-    private mergeGovernanceVotes;
+    private governViaNucleus;
     /**
-     * Govern proposals using external chrono-warp-drive Dynamo endpoint
+     * Convert a GovernanceResponse (nucleus kernel format) back to the
+     * InferenceCycleResult["votes"] format that the rest of the cycle expects.
      */
-    private governProposalsExternal;
+    private convertNucleusResponse;
+    private isGovernanceMcpPreferred;
+    private parseGovernanceMcpResponse;
     private invokeAgentInternal;
     private invokeViaOpencode;
     private parseSubagentVotes;
     private getGovernanceStateManager;
-    private saveGovernanceState;
     private extractTextFromNdjson;
     private resolveOpencodeRoot;
     private rejectNoQuorum;