0xray 2.1.4 → 2.2.0

package/dist/execution/proposal-applier.js

@@ -1,21 +1,10 @@
 import * as fs from "fs";
 import * as path from "path";
-import { spawnSync } from "child_process";
 import { frameworkLogger } from "../core/framework-logger.js";
-function sanitizeGitArgument(s) {
-    if (!/^[a-zA-Z0-9 \-_.\/@]+$/.test(s)) {
-        throw new Error("Invalid git argument: contains disallowed characters");
-    }
-    return s;
-}
 export class ProposalApplier {
     projectRoot;
-    codeChangeCallback;
-    reviewCallback;
-    constructor(projectRoot = process.cwd(), codeChangeCallback, reviewCallback) {
+    constructor(projectRoot = process.cwd()) {
         this.projectRoot = projectRoot;
-        this.codeChangeCallback = codeChangeCallback;
-        this.reviewCallback = reviewCallback;
     }
     async applyProposals(proposals) {
         frameworkLogger.log("execution", "proposal-applier-start", "info", {
@@ -23,112 +12,26 @@ export class ProposalApplier {
         });
         const results = [];
         for (const proposal of proposals) {
-            const result = await this.applyProposal(proposal);
-            results.push(result);
-        }
-        return results;
-    }
-    async applyProposal(p) {
-        frameworkLogger.log("execution", "apply-proposal", "info", {
-            proposalId: p.id,
-            type: p.type,
-        });
-        if (p.type === "codify") {
-            return this.applyCodification(p);
-        }
-        const branchName = `inference/${p.type}-${Date.now()}`;
-        const isGit = this.isInsideGitRepo();
-        try {
-            this.recordAppliedProposal(p);
-            const changedFiles = [
-                path.relative(this.projectRoot, this.getAppliedMarkerPath(p)),
-            ];
-            if (isGit) {
-                const branchR = spawnSync('git', ['checkout', '-b', branchName], { cwd: this.projectRoot, stdio: 'pipe' });
-                if (branchR.status !== 0) {
-                    throw new Error(`git checkout -b failed: ${(branchR.stderr || '').toString().trim()}`);
-                }
+            if (proposal.type === "codify") {
+                results.push(this.applyCodification(proposal));
             }
-            if (this.codeChangeCallback) {
-                const changed = await this.codeChangeCallback(p);
-                if (!changed) {
-                    if (isGit) {
-                        spawnSync('git', ['checkout', 'master'], { cwd: this.projectRoot, stdio: 'pipe' });
-                        spawnSync('git', ['branch', '-D', branchName], { cwd: this.projectRoot, stdio: 'pipe' });
-                    }
-                    return {
-                        proposalId: p.id,
-                        success: false,
-                        error: "Code change returned false (no changes applied)",
-                    };
-                }
+            else {
+                this.recordAppliedProposal(proposal);
+                const changedFiles = [
+                    path.relative(this.projectRoot, this.getAppliedMarkerPath(proposal)),
+                ];
+                results.push({
+                    proposalId: proposal.id,
+                    success: true,
+                    filesChanged: changedFiles,
+                    details: [
+                        "Proposal recorded by Autonomous Engine (ProposalApplier)",
+                        `type=${proposal.type}`,
+                    ],
+                });
             }
-            if (isGit) {
-                const addR = spawnSync('git', ['add', '-A'], { cwd: this.projectRoot, stdio: 'pipe' });
-                if (addR.status !== 0) {
-                    throw new Error(`git add failed: ${(addR.stderr || '').toString().trim()}`);
-                }
-                const commitR = spawnSync('git', ['commit', '-m', p.title], { cwd: this.projectRoot, stdio: 'pipe' });
-                if (commitR.status !== 0) {
-                    throw new Error(`git commit failed: ${(commitR.stderr || '').toString().trim()}`);
-                }
-                const prUrl = this.createPR(p, branchName);
-                if (prUrl) {
-                    frameworkLogger.log("execution", "pr-created", "info", {
-                        prUrl,
-                        proposalId: p.id,
-                    });
-                }
-                if (this.reviewCallback && prUrl) {
-                    const review = await this.reviewCallback(p, prUrl);
-                    if (review === "no-go") {
-                        frameworkLogger.log("execution", "review-no-go", "warning", {
-                            proposalId: p.id,
-                            prUrl,
-                        });
-                        spawnSync('git', ['checkout', 'master'], { cwd: this.projectRoot, stdio: 'pipe' });
-                        spawnSync('git', ['branch', '-D', branchName], { cwd: this.projectRoot, stdio: 'pipe' });
-                        return {
-                            proposalId: p.id,
-                            success: false,
-                            error: "Researcher review rejected proposal",
-                        };
-                    }
-                }
-                spawnSync('git', ['checkout', 'master'], { cwd: this.projectRoot, stdio: 'pipe' });
-            }
-            return {
-                proposalId: p.id,
-                success: true,
-                filesChanged: changedFiles,
-                details: [
-                    "Proposal applied by Autonomous Engine (ProposalApplier)",
-                    isGit ? `branch=${branchName}` : "non-git (marker only)",
-                    `type=${p.type}`,
-                ],
-            };
-        }
-        catch (err) {
-            const errorMsg = err.message;
-            frameworkLogger.log("execution", "apply-proposal-error", "error", {
-                proposalId: p.id,
-                error: errorMsg,
-            });
-            if (isGit) {
-                try {
-                    spawnSync('git', ['checkout', 'master'], { cwd: this.projectRoot, stdio: 'pipe' });
-                    spawnSync('git', ['branch', '-D', branchName], { cwd: this.projectRoot, stdio: 'pipe' });
-                }
-                catch {
-                    // ignore cleanup
-                }
-            }
-            return {
-                proposalId: p.id,
-                success: false,
-                error: errorMsg,
-            };
         }
+        return results;
     }
     applyCodification(p) {
         try {
@@ -159,19 +62,6 @@ export class ProposalApplier {
             return { proposalId: p.id, success: false, error: errorMsg };
         }
     }
-    isInsideGitRepo() {
-        try {
-            const r = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
-                cwd: this.projectRoot,
-                stdio: 'pipe',
-                timeout: 2000,
-            });
-            return r.status === 0;
-        }
-        catch {
-            return false;
-        }
-    }
     getAppliedMarkerPath(p) {
         const appliedDir = path.join(this.projectRoot, "docs", "inference", "applied");
         if (!fs.existsSync(appliedDir)) {
@@ -206,49 +96,4 @@ export class ProposalApplier {
             module: "v2-refactor",
         });
     }
-    createPR(p, branchName) {
-        try {
-            sanitizeGitArgument(p.title);
-            sanitizeGitArgument(branchName);
-            const pushR = spawnSync('git', ['push', '-u', 'origin', branchName], {
-                cwd: this.projectRoot,
-                stdio: 'pipe',
-                timeout: 30000,
-            });
-            if (pushR.status !== 0) {
-                throw new Error(`git push failed: ${(pushR.stderr || '').toString().trim()}`);
-            }
-            const body = [
-                "## Inference Proposal (Autonomous Engine)",
-                "",
-                p.description,
-                "",
-                `**Type:** ${p.type}  **Confidence:** ${(p.confidence * 100).toFixed(0)}%`,
-                "",
-                "## Evidence",
-                p.evidence.slice(0, 5).join("\n"),
-                "",
-                "Executed by ProposalApplier (Engine-owned) — V2 Phase 1.",
-            ].join("\n");
-            const ghR = spawnSync('gh', ['pr', 'create', '--head', branchName, '--title', p.title, '--body', body], {
-                cwd: this.projectRoot,
-                encoding: 'utf-8',
-                stdio: 'pipe',
-                timeout: 30000,
-            });
-            if (ghR.status !== 0) {
-                throw new Error(`gh pr create failed: ${ghR.stderr || 'unknown error'}`);
-            }
-            return (ghR.stdout || '').trim();
-        }
-        catch (err) {
-            frameworkLogger.log("execution", "pr-create-failed", "warning", {
-                error: String(err),
-                proposalId: p.id,
-                module: "v2-refactor",
-            });
-            return "";
-        }
-    }
 }
-export const proposalApplier = new ProposalApplier();

package/dist/governance/codex-policy.service.d.ts

@@ -1,32 +1,15 @@
 /**
  * CodexPolicyService
  *
- * The initial Governance-owned Single Source of Truth (SSOT) for Codex / policy loading.
- * This is the V2-P1-S02-REAL first concrete migration slice.
+ * Governance-owned Single Source of Truth (SSOT) for Codex / policy loading.
  *
- * Role (per 3-subsystem architecture + researcher mapping):
- *   - External Governance (Decision Layer & SSOT) owns "what the policy is".
- *   - All consumers (enforcement CodexLoader, injectors, formatters, MCP surfaces, plugins)
- *     will eventually ask here instead of performing direct fs reads.
+ * Role: External Governance owns "what the policy is".
+ * Consumers (enforcers, injectors, formatters, MCPs, plugins) should ask here
+ * instead of direct fs reads or scattered loaders.
  *
- * Current scope (minimal safe skeleton):
- *   - Read-only query surface.
- *   - Uses canonical resolveCodexPath + async file load (no duplication of resolution logic).
- *   - Returns ActiveCodexSnapshot compatible with the existing get_active_codex MCP tool.
- *   - Provides getTermCount() with safe 60-term fallback (preserves prior behavior of bypasses).
- *   - Full frameworkLogger discipline on every load/decision/error.
- *   - No caching in v1 skeleton (additive later); no mutation; no enforcement.
- *
- * First wired consumer: src/mcps/enforcer-tools.server.ts (getCodexTermCount bypass removed;
- * now delegates through this service).
- *
- * Next recommended slices (documented in researcher mapping append):
- *   - Wire governance.server.ts handleGetActiveCodex to delegate (remove its direct read).
- *   - S02b/S02c follow-ups: update codex-injector, context-loader, codex-formatter, plugin.
- *   - Make CodexLoader delegate its raw data load here, then re-export from governance.
- *
- * @module governance/codex-policy.service
- * @version 2.0.0-s02-real
+ * Provides read-only ActiveCodexSnapshot and term count.
+ * Uses canonical resolveCodexPath.
+ * Full frameworkLogger on all paths.
  */
 import type { ActiveCodexSnapshot, ICodexPolicyProvider } from './governance-types.js';
 /**
@@ -54,4 +37,3 @@ export declare class CodexPolicyService implements ICodexPolicyProvider {
     getTermCount(): Promise<number>;
 }
 export declare function getCodexPolicyService(): CodexPolicyService;
-export { CodexPolicyService as default };

package/dist/governance/codex-policy.service.js

@@ -1,32 +1,15 @@
 /**
  * CodexPolicyService
  *
- * The initial Governance-owned Single Source of Truth (SSOT) for Codex / policy loading.
- * This is the V2-P1-S02-REAL first concrete migration slice.
+ * Governance-owned Single Source of Truth (SSOT) for Codex / policy loading.
  *
- * Role (per 3-subsystem architecture + researcher mapping):
- *   - External Governance (Decision Layer & SSOT) owns "what the policy is".
- *   - All consumers (enforcement CodexLoader, injectors, formatters, MCP surfaces, plugins)
- *     will eventually ask here instead of performing direct fs reads.
+ * Role: External Governance owns "what the policy is".
+ * Consumers (enforcers, injectors, formatters, MCPs, plugins) should ask here
+ * instead of direct fs reads or scattered loaders.
  *
- * Current scope (minimal safe skeleton):
- *   - Read-only query surface.
- *   - Uses canonical resolveCodexPath + async file load (no duplication of resolution logic).
- *   - Returns ActiveCodexSnapshot compatible with the existing get_active_codex MCP tool.
- *   - Provides getTermCount() with safe 60-term fallback (preserves prior behavior of bypasses).
- *   - Full frameworkLogger discipline on every load/decision/error.
- *   - No caching in v1 skeleton (additive later); no mutation; no enforcement.
- *
- * First wired consumer: src/mcps/enforcer-tools.server.ts (getCodexTermCount bypass removed;
- * now delegates through this service).
- *
- * Next recommended slices (documented in researcher mapping append):
- *   - Wire governance.server.ts handleGetActiveCodex to delegate (remove its direct read).
- *   - S02b/S02c follow-ups: update codex-injector, context-loader, codex-formatter, plugin.
- *   - Make CodexLoader delegate its raw data load here, then re-export from governance.
- *
- * @module governance/codex-policy.service
- * @version 2.0.0-s02-real
+ * Provides read-only ActiveCodexSnapshot and term count.
+ * Uses canonical resolveCodexPath.
+ * Full frameworkLogger on all paths.
  */
 import { frameworkLogger } from '../core/framework-logger.js';
 import { resolveCodexPath } from '../core/config-paths.js';
@@ -120,7 +103,7 @@ export class CodexPolicyService {
             is_fallback: isFallback,
             note: isFallback
                 ? 'Governance CodexPolicyService — builtin fallback (no external codex.json resolved)'
-                : 'Returned via Governance CodexPolicyService — V2 Single Source of Truth (S02-REAL)',
+                : 'Returned via Governance CodexPolicyService',
             dynamo_required: true,
             ...(includeRaw ? { codex: data } : {}),
         };
@@ -164,4 +147,3 @@ export function getCodexPolicyService() {
     return codexPolicyServiceInstance;
 }
 // Also export the class for direct construction in tests / advanced wiring
-export { CodexPolicyService as default };

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

@@ -1,41 +1,35 @@
 /**
  * Pure governance decision logic.
- * This module contains the PHI/TAU matrix and merging rules.
+ * This module contains the merging rules and metamorphosis scoring.
  * It has no side effects and does not call any MCPs.
  *
  * This is the shared "pure logic" that both the Governance MCP
  * and any HTTP deployment (Vercel) can use.
  */
 import type { GovernanceVote, GovernanceResult } from './governance-types.js';
-export interface DecisionMatrixInput {
-    resonance: number;
-    isotopicRatio: number;
-    vortexVolume?: number;
-    historicalCoherence?: number;
-    solarActivity?: 'quiet' | 'moderate' | 'active' | 'storm';
-    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical';
-    moralScore?: number;
-    moralFusion?: number;
-}
-export interface DecisionMatrixOutput {
-    recommendation: 'PASS' | 'NEEDS_REVISION' | 'REJECT';
-    confidence: number;
-    voteWeight: number;
-    reasons: string[];
-    moralOverride?: 'rejected_critical' | 'downgraded_significant' | 'none';
-}
-export declare const MORAL_OVERRIDE_LEVELS: {
-    Critical: "rejected_critical";
-    Significant: "downgraded_significant";
-    Mild: "none";
-    Aligned: "none";
-};
-export type MoralOverrideThreshold = 'Critical' | 'Significant' | 'Mild' | 'Aligned' | 'disabled';
 /**
- * The core PHI/TAU decision matrix.
- * Extracted so it can be shared between local MCP and deployed HTTP versions.
+ * Calculate metamorphosis resonance score for self-evolution proposals.
+ *
+ * Evaluates whether a proposal increases the system's capacity to govern
+ * complex future states. Uses the existing Dynamo resonance signal plus
+ * checks for self-improvement indicators.
+ *
+ * Scoring rubric (0-1):
+ * - Base: governance vote confidence (averageConfidence)
+ * - Boost: +0.1 if proposal adds new capacity (type=automate/codify)
+ * - Boost: +0.05 if historical coherence is strong (>0.8)
+ * - Penalty: -0.15 if proposal removes existing capacity (type=compliance-only)
+ * - Floor: 0.0, Ceiling: 1.0
+ * - Threshold for approval: ≥ 0.7 (configurable via GovernOptions.metamorphosisThreshold)
+ *
+ * Only meaningful when proposal.type === 'metamorphosis' or source === 'metamorphosis'.
  */
-export declare function applyDecisionMatrix(input: DecisionMatrixInput): DecisionMatrixOutput;
+export declare function calculateMetamorphosisScore(input: {
+    averageConfidence: number;
+    proposalType: string;
+    historicalCoherence?: number;
+    resonanceScore?: number;
+}): number;
 /**
  * Simple weighted merge of votes from multiple servers + external.
  */

package/dist/governance/governance-core.js

@@ -1,117 +1,47 @@
 /**
  * Pure governance decision logic.
- * This module contains the PHI/TAU matrix and merging rules.
+ * This module contains the merging rules and metamorphosis scoring.
  * It has no side effects and does not call any MCPs.
  *
  * This is the shared "pure logic" that both the Governance MCP
  * and any HTTP deployment (Vercel) can use.
  */
-// Blurrn constants (from chrono-warp-drive)
-const PHI = 1.666;
-const TAU = 0.865;
-export const MORAL_OVERRIDE_LEVELS = {
-    Critical: 'rejected_critical',
-    Significant: 'downgraded_significant',
-    Mild: 'none',
-    Aligned: 'none',
-};
 /**
- * The core PHI/TAU decision matrix.
- * Extracted so it can be shared between local MCP and deployed HTTP versions.
+ * Calculate metamorphosis resonance score for self-evolution proposals.
+ *
+ * Evaluates whether a proposal increases the system's capacity to govern
+ * complex future states. Uses the existing Dynamo resonance signal plus
+ * checks for self-improvement indicators.
+ *
+ * Scoring rubric (0-1):
+ * - Base: governance vote confidence (averageConfidence)
+ * - Boost: +0.1 if proposal adds new capacity (type=automate/codify)
+ * - Boost: +0.05 if historical coherence is strong (>0.8)
+ * - Penalty: -0.15 if proposal removes existing capacity (type=compliance-only)
+ * - Floor: 0.0, Ceiling: 1.0
+ * - Threshold for approval: ≥ 0.7 (configurable via GovernOptions.metamorphosisThreshold)
+ *
+ * Only meaningful when proposal.type === 'metamorphosis' or source === 'metamorphosis'.
  */
-export function applyDecisionMatrix(input) {
-    const { resonance, isotopicRatio, vortexVolume = Number.MAX_VALUE, // large default so the low-mass check only triggers on explicit small values
-    historicalCoherence = 0.8, solarActivity = 'quiet', moralTension, moralScore, moralFusion, } = input;
-    const reasons = [];
-    let recommendation = 'NEEDS_REVISION';
-    let confidence = 0.75;
-    let voteWeight = 1.0;
-    let moralOverride = 'none';
-    // Log moral fusion if present — weighted signal for transparency
-    if (moralFusion != null) {
-        reasons.push(`Moral-numerological fusion: ${(moralFusion * 100).toFixed(0)}%`);
+export function calculateMetamorphosisScore(input) {
+    let score = input.averageConfidence;
+    // Self-improvement capacity: proposals that add automation or codification boost the score
+    if (input.proposalType === 'automate' || input.proposalType === 'codify') {
+        score += 0.10;
     }
-    // Trinitarium Moral Overlay override
-    // Critical tension always rejects — proposal violates moral alignment regardless of physics
-    if (moralTension === 'Critical') {
-        recommendation = 'REJECT';
-        confidence = 0.92;
-        voteWeight = 1.6;
-        moralOverride = 'rejected_critical';
-        reasons.push(`Critical moral tension — proposal violates moral alignment (score: ${moralScore != null ? (moralScore * 100).toFixed(0) + '%' : 'unknown'})`);
-        return {
-            recommendation,
-            confidence: Math.min(0.99, Math.max(0.5, confidence)),
-            voteWeight: Math.max(0.5, Math.min(1.8, voteWeight)),
-            reasons,
-            moralOverride,
-        };
+    // Compliance-only proposals (guard type with no new capacity) get a penalty
+    if (input.proposalType === 'compliance') {
+        score -= 0.15;
     }
-    // Significant tension downgrades PASS → NEEDS_REVISION
-    let moralDowngrade = false;
-    if (moralTension === 'Significant') {
-        moralDowngrade = true;
-        moralOverride = 'downgraded_significant';
-        voteWeight *= 0.85;
-        reasons.push(`Significant moral tension — proceed with caution (score: ${moralScore != null ? (moralScore * 100).toFixed(0) + '%' : 'unknown'})`);
+    // Strong historical coherence means the system is stable enough for self-evolution
+    if (input.historicalCoherence != null && input.historicalCoherence > 0.8) {
+        score += 0.05;
     }
-    // Aligned tension boosts confidence slightly
-    if (moralTension === 'Aligned' && moralScore != null) {
-        confidence += 0.03;
-        voteWeight *= 1.05;
-        reasons.push(`Moral alignment confirmed (score: ${(moralScore * 100).toFixed(0)}%)`);
+    // High Dynamo resonance (Solar signal) supports self-evolution
+    if (input.resonanceScore != null && input.resonanceScore >= 0.82) {
+        score += 0.05;
     }
-    if (resonance >= 0.92 && isotopicRatio >= 0.95) {
-        recommendation = 'PASS';
-        confidence = 0.97;
-        voteWeight = 1.4;
-        reasons.push('High symbiotic resonance (PHI-aligned)');
-    }
-    else if (resonance >= 0.82 && isotopicRatio >= 0.88) {
-        recommendation = 'PASS';
-        confidence = 0.89;
-        voteWeight = 1.15;
-        reasons.push('Solid alignment above TAU threshold');
-    }
-    else if (resonance < 0.75 || isotopicRatio < 0.80) {
-        recommendation = 'REJECT';
-        confidence = 0.84;
-        reasons.push('Signal below critical threshold (1 - TAU)');
-    }
-    else {
-        reasons.push('Moderate resonance - requires refinement');
-    }
-    // Moral downgrade: Significant tension demotes PASS → NEEDS_REVISION
-    if (moralDowngrade && recommendation === 'PASS') {
-        recommendation = 'NEEDS_REVISION';
-        reasons.push('Moral tension downgraded recommendation from PASS to NEEDS_REVISION');
-    }
-    if (vortexVolume < 2.5e25) {
-        reasons.push('Low inertial mass (W x M = V)');
-        if (recommendation === 'PASS')
-            recommendation = 'NEEDS_REVISION';
-    }
-    if (historicalCoherence < 0.70) {
-        reasons.push('Weak historical alignment with past decisions');
-        if (recommendation === 'PASS')
-            recommendation = 'NEEDS_REVISION';
-    }
-    else if (historicalCoherence > 0.90) {
-        reasons.push('Strong continuity with previous governance');
-        voteWeight *= 1.1;
-    }
-    // Solar adjustment (from chrono-warp-drive)
-    if (solarActivity === 'active' || solarActivity === 'storm') {
-        voteWeight *= 0.92;
-        reasons.push('Elevated solar activity - increased caution applied');
-    }
-    return {
-        recommendation,
-        confidence: Math.min(0.99, Math.max(0.5, confidence)),
-        voteWeight: Math.max(0.5, Math.min(1.8, voteWeight)),
-        reasons,
-        moralOverride,
-    };
+    return Math.min(1.0, Math.max(0.0, Math.round(score * 100) / 100));
 }
 /**
  * Simple weighted merge of votes from multiple servers + external.

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

@@ -34,5 +34,6 @@ export declare class GovernanceService {
     private callExternalDynamo;
     private callInProcessSkillWithTimeout;
     private parseVoteFromText;
+    private isBuiltInSkill;
 }
 export declare function getGovernanceService(): GovernanceService;

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;