0xray 4.0.13 → 4.0.15

package/dist/governance/governance-core.js

@@ -0,0 +1,168 @@
+/**
+ * Pure governance decision logic.
+ * This module contains the PHI/TAU matrix and merging rules.
+ * 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.
+ */
+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)}%`);
+    }
+    // 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,
+        };
+    }
+    // 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'})`);
+    }
+    // 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)}%)`);
+    }
+    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,
+    };
+}
+/**
+ * Simple weighted merge of votes from multiple servers + external.
+ */
+export function mergeVotes(votes) {
+    if (votes.length === 0) {
+        return {
+            finalDecision: 'abstain',
+            averageConfidence: 0.5,
+            reasoningSummary: 'No votes received',
+        };
+    }
+    const approveWeight = votes
+        .filter(v => v.decision === 'approve')
+        .reduce((sum, v) => sum + (v.weight ?? 1) * v.confidence, 0);
+    const totalWeight = votes.reduce((sum, v) => sum + (v.weight ?? 1) * v.confidence, 0);
+    const avgConfidence = totalWeight > 0 ? totalWeight / votes.length : 0.5;
+    let finalDecision = 'needs_revision';
+    if (totalWeight > 0) {
+        const approveRatio = approveWeight / totalWeight;
+        if (approveRatio > 0.66) {
+            finalDecision = 'approve';
+        }
+        else if (approveRatio < 0.33) {
+            finalDecision = 'reject';
+        }
+    }
+    else {
+        // All votes had zero confidence — default to needs_revision
+        finalDecision = 'needs_revision';
+    }
+    const reasons = votes.map(v => `${v.server}: ${v.reasoning}`).join(' | ');
+    return {
+        finalDecision,
+        averageConfidence: Math.round(avgConfidence * 100) / 100,
+        reasoningSummary: reasons,
+    };
+}
+export function calculateMetamorphosisScore(input) {
+    let score = input.averageConfidence;
+    if (input.proposalType === 'automate' || input.proposalType === 'codify') {
+        score += 0.10;
+    }
+    else if (input.proposalType === 'compliance') {
+        score -= 0.15;
+    }
+    if (input.historicalCoherence != null && input.historicalCoherence >= 0.8) {
+        score += 0.05;
+    }
+    if (input.resonanceScore != null && input.resonanceScore >= 0.8) {
+        score += 0.05;
+    }
+    return Math.round(Math.min(1.0, Math.max(0.0, score)) * 100) / 100;
+}

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

@@ -0,0 +1,39 @@
+/**
+ * GovernanceService
+ *
+ * Central orchestrator for governance.
+ *
+ * Architecture:
+ *   - Internal Layer: 3 real skill MCPs (code-review, security-audit, researcher)
+ *     → Internal deliberation based on knowledge and code patterns.
+ *
+ *   - External Filter: Dynamo Solar SSOT
+ *     → Single Source of Truth governance signal based on sunlight physics,
+ *       a neural net, and temporal first principles. This is a required check.
+ *
+ *   - Merge Layer: governance-core.ts (weighted voting + PHI/TAU matrix)
+ *
+ * Dynamo Solar SSOT is treated as a mandatory external filter (not optional, not a fallback).
+ */
+import { GovernanceRequest, GovernanceResponse } from './governance-types.js';
+export declare class GovernanceService {
+    constructor();
+    /**
+     * Main entry point: Govern a set of proposals.
+     *
+     * Flow:
+     *   1. Internal deliberation → 3 real skill MCPs (code-review, security-audit, researcher)
+     *   2. External filter       → Dynamo Solar SSOT (via InferenceGovernanceIntegration)
+     *   3. Merge                 → governance-core.ts (weighted + PHI/TAU logic)
+     *
+     * Dynamo Solar SSOT is treated as a hard requirement by default.
+     */
+    govern(request: GovernanceRequest): Promise<GovernanceResponse>;
+    private resolveRequireExternalDynamo;
+    private runGovernanceWithTimeout;
+    private callSkillServer;
+    private callExternalDynamo;
+    private callInProcessSkillWithTimeout;
+    private parseVoteFromText;
+}
+export declare function getGovernanceService(): GovernanceService;

package/dist/governance/governance-service.js

@@ -0,0 +1,351 @@
+/**
+ * GovernanceService
+ *
+ * Central orchestrator for governance.
+ *
+ * Architecture:
+ *   - Internal Layer: 3 real skill MCPs (code-review, security-audit, researcher)
+ *     → Internal deliberation based on knowledge and code patterns.
+ *
+ *   - External Filter: Dynamo Solar SSOT
+ *     → Single Source of Truth governance signal based on sunlight physics,
+ *       a neural net, and temporal first principles. This is a required check.
+ *
+ *   - Merge Layer: governance-core.ts (weighted voting + PHI/TAU matrix)
+ *
+ * Dynamo Solar SSOT is treated as a mandatory external filter (not optional, not a fallback).
+ */
+import { mcpClientManager } from '../mcps/mcp-client.js';
+import { callInProcessSkill } from '../mcps/in-process-skill-registry.js';
+import { getGovernanceIntegration, } from '../integrations/governance/index.js';
+import { applyDecisionMatrix, calculateMetamorphosisScore, mergeVotes, } from './governance-core.js';
+import { frameworkLogger } from '../core/framework-logger.js';
+import { featuresConfigLoader } from '../core/features-config.js';
+export class GovernanceService {
+    constructor() {
+        // We deliberately do *not* cache the integration here.
+        // On Vercel / serverless, initializeGovernanceIntegration() may be called
+        // after the first getGovernanceService() instance is created.
+        // We always fetch fresh via getGovernanceIntegration() on each govern() call.
+    }
+    /**
+     * Main entry point: Govern a set of proposals.
+     *
+     * Flow:
+     *   1. Internal deliberation → 3 real skill MCPs (code-review, security-audit, researcher)
+     *   2. External filter       → Dynamo Solar SSOT (via InferenceGovernanceIntegration)
+     *   3. Merge                 → governance-core.ts (weighted + PHI/TAU logic)
+     *
+     * Dynamo Solar SSOT is treated as a hard requirement by default.
+     */
+    async govern(request) {
+        const { proposals, context, options } = request;
+        const requireExternal = this.resolveRequireExternalDynamo(options?.requireExternalDynamo);
+        const timeoutMs = options?.timeoutMs ?? 90000;
+        const maxAbstentionThreshold = options?.maxAbstentionThreshold ?? 1.0;
+        frameworkLogger.log('governance-service', 'govern-start', 'info', {
+            proposalCount: proposals.length,
+            context,
+            requireExternalDynamo: requireExternal,
+            timeoutMs,
+        });
+        // Early validation: Dynamo Solar SSOT is a hard requirement
+        if (requireExternal) {
+            const integration = getGovernanceIntegration();
+            if (!integration?.isAvailable?.()) {
+                const message = 'Dynamo Solar SSOT is required but InferenceGovernanceIntegration is not available. ' +
+                    'Call initializeGovernanceIntegration() early in application startup.';
+                frameworkLogger.log('governance-service', 'dynamo-solar-ssot-unavailable', 'error', { message });
+                throw new Error(message);
+            }
+        }
+        // Run governance with end-to-end timeout
+        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);
+            const abstentions = result.results.reduce((sum, r) => sum + r.votes.filter(v => v.decision === 'abstain').length, 0);
+            const abstentionRatio = totalVotes > 0 ? abstentions / totalVotes : 0;
+            if (abstentionRatio > maxAbstentionThreshold) {
+                const message = `Abstention ratio ${abstentionRatio.toFixed(2)} exceeds threshold ${maxAbstentionThreshold} — ` +
+                    'too many governance servers unavailable';
+                frameworkLogger.log('governance-service', 'abstention-threshold-exceeded', 'error', {
+                    abstentionRatio,
+                    maxAbstentionThreshold,
+                });
+                throw new Error(message);
+            }
+        }
+        const approved = result.results.filter(r => r.finalDecision === 'approve').length;
+        const needsRevision = result.results.filter(r => r.finalDecision === 'needs_revision').length;
+        const rejected = result.results.filter(r => r.finalDecision === 'reject').length;
+        return {
+            results: result.results,
+            overallDecision: approved > proposals.length * 0.6
+                ? 'approve'
+                : rejected > approved ? 'reject' : 'needs_revision',
+            summary: {
+                total: proposals.length,
+                approved,
+                needsRevision,
+                rejected,
+            },
+        };
+    }
+    resolveRequireExternalDynamo(explicit) {
+        if (explicit !== undefined)
+            return explicit;
+        if (process.env.XRAY_LOCAL_MODE === '1' || process.env.XRAY_LOCAL_MODE === 'true') {
+            return false;
+        }
+        try {
+            const config = featuresConfigLoader.loadConfig();
+            const ig = config.inference_governance;
+            if (ig?.require_external_dynamo === false)
+                return false;
+            if (ig?.local_mode === true)
+                return false;
+        }
+        catch {
+            /* default strict */
+        }
+        return true;
+    }
+    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, metamorphosisThreshold = 0.7) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            // 1. Call the three real skill MCPs (one call per server, returns array of votes, one per proposal)
+            const [codeReviewVotes, securityVotes, researcherVotes] = await Promise.all([
+                this.callSkillServer("code-review", proposals, context),
+                this.callSkillServer("security-audit", proposals, context),
+                this.callSkillServer("researcher", proposals, context),
+            ]);
+            // 2. Always call external Dynamo (required) - returns array of arrays (one inner array per proposal)
+            const externalVotes = await this.callExternalDynamo(proposals, requireExternal);
+            // 3. Merge everything
+            const results = proposals.map((proposal, index) => {
+                const votes = [
+                    codeReviewVotes[index] || { server: "code-review", decision: "abstain", confidence: 0.3, reasoning: "missing" },
+                    securityVotes[index] || { server: "security-audit", decision: "abstain", confidence: 0.3, reasoning: "missing" },
+                    researcherVotes[index] || { server: "researcher", decision: "abstain", confidence: 0.3, reasoning: "missing" },
+                    ...(externalVotes[index] || []),
+                ];
+                const merged = mergeVotes(votes);
+                const externalVote = votes.find((v) => v.server === 'external-dynamo');
+                let finalDecision = merged.finalDecision;
+                let averageConfidence = merged.averageConfidence;
+                let moralOverride = 'none';
+                if (externalVote?.moralTension ||
+                    externalVote?.moralScore != null ||
+                    externalVote?.moralFusion != null) {
+                    const matrixInput = {
+                        resonance: averageConfidence,
+                        isotopicRatio: externalVote.moralFusion ?? 0.5,
+                    };
+                    if (externalVote.moralTension != null) {
+                        matrixInput.moralTension = externalVote.moralTension;
+                    }
+                    if (externalVote.moralScore != null) {
+                        matrixInput.moralScore = externalVote.moralScore;
+                    }
+                    if (externalVote.moralFusion != null) {
+                        matrixInput.moralFusion = externalVote.moralFusion;
+                    }
+                    const matrix = applyDecisionMatrix(matrixInput);
+                    moralOverride = matrix.moralOverride ?? 'none';
+                    if (matrix.recommendation === 'REJECT') {
+                        finalDecision = 'reject';
+                    }
+                    else if (matrix.recommendation === 'NEEDS_REVISION' && finalDecision === 'approve') {
+                        finalDecision = 'needs_revision';
+                    }
+                    else if (matrix.recommendation === 'PASS' && finalDecision !== 'reject') {
+                        finalDecision = 'approve';
+                    }
+                    averageConfidence = matrix.confidence;
+                }
+                let metamorphosisScore;
+                if (proposal.type === 'metamorphosis' || proposal.source === 'metamorphosis') {
+                    const proposalType = proposal.type === 'compliance'
+                        ? 'compliance'
+                        : proposal.type === 'automate' || proposal.type === 'codify'
+                            ? proposal.type
+                            : 'fix';
+                    const metamorphosisInput = {
+                        averageConfidence,
+                        proposalType,
+                        resonanceScore: averageConfidence,
+                    };
+                    if (externalVote?.moralFusion != null) {
+                        metamorphosisInput.historicalCoherence = externalVote.moralFusion;
+                    }
+                    metamorphosisScore = calculateMetamorphosisScore(metamorphosisInput);
+                    if (metamorphosisScore < metamorphosisThreshold) {
+                        finalDecision = 'needs_revision';
+                    }
+                }
+                return {
+                    proposalId: proposal.id,
+                    finalDecision,
+                    averageConfidence,
+                    votes,
+                    reasoningSummary: merged.reasoningSummary,
+                    moralOverride,
+                    ...(metamorphosisScore != null ? { metamorphosisScore } : {}),
+                };
+            });
+            return { results };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async callSkillServer(serverName, proposals, context) {
+        const votes = [];
+        const useInProcess = process.env.VERCEL === '1' ||
+            !!process.env.RAILWAY_ENVIRONMENT ||
+            process.env.XRAY_GOVERNANCE_IN_PROCESS === '1';
+        for (const proposal of proposals) {
+            try {
+                let text = '';
+                if (useInProcess) {
+                    // Vercel / serverless path — use in-process skill instances (no child processes)
+                    const result = await this.callInProcessSkillWithTimeout(serverName, {
+                        proposalTitle: proposal.title,
+                        proposalDescription: proposal.description,
+                        evidence: proposal.evidence || [],
+                        proposalType: proposal.type,
+                        context,
+                    });
+                    text = result?.content?.[0]?.text || '';
+                }
+                else {
+                    // Normal path — real MCP transport
+                    const result = await mcpClientManager.callServerTool(serverName, 'analyze_proposal', {
+                        proposalTitle: proposal.title,
+                        proposalDescription: proposal.description,
+                        evidence: proposal.evidence || [],
+                        proposalType: proposal.type,
+                        context,
+                    });
+                    text = result?.content?.[0]?.text || '';
+                }
+                const vote = this.parseVoteFromText(serverName, text);
+                votes.push(vote);
+            }
+            catch (error) {
+                frameworkLogger.log('governance-service', 'skill-call-error', 'error', {
+                    server: serverName,
+                    proposal: proposal.title,
+                    error: error instanceof Error ? error.message : String(error),
+                    mode: useInProcess ? 'in-process' : 'mcp',
+                });
+                votes.push({
+                    server: serverName,
+                    decision: 'abstain',
+                    confidence: 0.3,
+                    reasoning: `Call to ${serverName} failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                });
+            }
+        }
+        return votes;
+    }
+    async callExternalDynamo(proposals, requireExternal) {
+        const results = [];
+        const integration = getGovernanceIntegration();
+        const integrationAvailable = integration?.isAvailable?.() === true;
+        if (!integrationAvailable) {
+            const message = 'Dynamo Solar SSOT is required but InferenceGovernanceIntegration is not available or not initialized. ' +
+                'Call initializeGovernanceIntegration() early during application bootstrap.';
+            frameworkLogger.log('governance-service', 'dynamo-solar-ssot-unavailable', 'error', {
+                requireExternal,
+                message,
+            });
+            if (requireExternal) {
+                throw new Error(message);
+            }
+            // If external is not strictly required, return abstain votes
+            for (const proposal of proposals) {
+                results.push([{
+                        server: 'external-dynamo',
+                        decision: 'abstain',
+                        confidence: 0.2,
+                        reasoning: 'InferenceGovernanceIntegration not available',
+                    }]);
+            }
+            return results;
+        }
+        // Integration is available — use it exclusively (no fallback)
+        for (const proposal of proposals) {
+            try {
+                const inferenceType = (proposal.type === 'strategic' || proposal.type === 'compliance'
+                    ? 'refactor'
+                    : proposal.type);
+                const inferenceProposal = {
+                    id: proposal.id,
+                    type: inferenceType,
+                    title: proposal.title,
+                    description: proposal.description,
+                    evidence: proposal.evidence || [],
+                    confidence: proposal.confidence || 0.8,
+                    source: 'recurring_pattern',
+                    status: 'pending',
+                };
+                const result = await integration.checkProposal(inferenceProposal);
+                results.push([{
+                        server: 'external-dynamo',
+                        decision: result.vote === 'YES' ? 'approve' : result.vote === 'NO' ? 'reject' : 'needs_revision',
+                        confidence: result.governanceResponse?.confidence ?? 0.85,
+                        reasoning: result.reason || 'Dynamo Solar SSOT filter decision',
+                        weight: 1.1,
+                        moralTension: result.moralTension,
+                        moralScore: result.moralScore,
+                        moralFusion: result.moralFusion,
+                        detectedVirtues: result.detectedVirtues,
+                        detectedConcerns: result.detectedConcerns,
+                    }]);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                frameworkLogger.log('governance-service', 'external-dynamo-error', 'error', { error: msg });
+                if (requireExternal) {
+                    throw new Error(`External Dynamo governance is required but failed: ${msg}`);
+                }
+                results.push([{
+                        server: 'external-dynamo',
+                        decision: 'abstain',
+                        confidence: 0.3,
+                        reasoning: `External governance call failed: ${msg}`,
+                    }]);
+            }
+        }
+        return results;
+    }
+    async callInProcessSkillWithTimeout(serverName, args, timeoutMs = 30000) {
+        const result = await Promise.race([
+            callInProcessSkill(serverName, 'analyze_proposal', args),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`In-process skill ${serverName} timed out after ${timeoutMs}ms`)), timeoutMs)),
+        ]);
+        return result;
+    }
+    parseVoteFromText(server, text) {
+        const decisionMatch = text.match(/DECISION:\s*(approve|reject|abstain|needs_revision)/i);
+        const confidenceMatch = text.match(/CONFIDENCE:\s*([0-9.]+)/);
+        const reasoningMatch = text.match(/REASONING:\s*([\s\S]+)/);
+        return {
+            server,
+            decision: decisionMatch?.[1]?.toLowerCase() || 'abstain',
+            confidence: parseFloat(confidenceMatch?.[1] || '0.5'),
+            reasoning: reasoningMatch?.[1]?.trim() || 'No reasoning provided',
+        };
+    }
+}
+// Singleton for convenience
+let governanceServiceInstance = null;
+export function getGovernanceService() {
+    if (!governanceServiceInstance) {
+        governanceServiceInstance = new GovernanceService();
+    }
+    return governanceServiceInstance;
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Core types for the 0xRay Governance System.
+ * These types are used by the GovernanceService, Governance MCP,
+ * and all integrations.
+ */
+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' | 'metamorphosis';
+    confidence?: number;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+}
+export interface GovernanceVote {
+    server: string;
+    decision: 'approve' | 'reject' | 'abstain' | 'needs_revision';
+    confidence: number;
+    reasoning: string;
+    weight?: number;
+    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical' | undefined;
+    moralScore?: number | undefined;
+    moralFusion?: number | undefined;
+    detectedVirtues?: string[] | undefined;
+    detectedConcerns?: string[] | undefined;
+}
+export interface GovernanceResult {
+    proposalId: string;
+    finalDecision: 'approve' | 'reject' | 'needs_revision' | 'abstain';
+    averageConfidence: number;
+    votes: GovernanceVote[];
+    reasoningSummary: string;
+    recommendedActions?: string[];
+    externalContext?: Record<string, unknown>;
+    moralOverride?: 'rejected_critical' | 'downgraded_significant' | 'none';
+    metamorphosisScore?: number;
+}
+export interface GovernanceContext {
+    project?: string;
+    phase?: string;
+    source?: string;
+    reflectionId?: string;
+    inferenceCycleId?: string;
+    tags?: string[];
+}
+export interface GovernOptions {
+    requireExternalDynamo?: boolean;
+    minConfidence?: number;
+    enableSolarAdjustment?: boolean;
+    timeoutMs?: number;
+    maxAbstentionThreshold?: number;
+    metamorphosisThreshold?: number;
+}
+export interface GovernanceRequest {
+    proposals: GovernanceProposal[];
+    context?: GovernanceContext;
+    options?: GovernOptions;
+}
+export interface GovernanceResponse {
+    results: GovernanceResult[];
+    overallDecision: 'approve' | 'needs_revision' | 'reject';
+    summary: {
+        total: number;
+        approved: number;
+        needsRevision: number;
+        rejected: number;
+    };
+}
+export interface ActiveCodexSnapshot {
+    source: string | null;
+    loaded_at: string;
+    term_count: number;
+    version: string;
+    last_updated?: string;
+    governance_ssot: boolean;
+    is_fallback: boolean;
+    note: string;
+    dynamo_required: boolean;
+    codex?: Record<string, unknown>;
+}
+export interface ICodexPolicyProvider {
+    getCurrentCodex(includeRaw?: boolean): Promise<ActiveCodexSnapshot>;
+    getTermCount(): Promise<number>;
+}
+export declare function normalizeProposalWithSource(proposal: GovernanceProposal): GovernanceProposal & {
+    source: string;
+};

package/dist/governance/governance-types.js

@@ -0,0 +1,11 @@
+/**
+ * Core types for the 0xRay Governance System.
+ * These types are used by the GovernanceService, Governance MCP,
+ * and all integrations.
+ */
+export function normalizeProposalWithSource(proposal) {
+    return {
+        ...proposal,
+        source: proposal.source || 'manual',
+    };
+}

package/dist/governance/llm-governance-provider.d.ts

@@ -0,0 +1,16 @@
+export type GovernanceRole = "code-review" | "security-audit" | "researcher";
+export interface GovernanceVote {
+    decision: "approve" | "reject" | "abstain";
+    confidence: number;
+    reasoning: string;
+}
+export declare function resolveHermesBin(): string;
+export declare function isGovernanceLlmConfigured(): boolean;
+export declare function hermesCliAvailable(): boolean;
+export declare function tryLLMGovernance(role: GovernanceRole, proposalTitle: string, proposalDescription: string, evidence: string[], proposalType: string): Promise<GovernanceVote | null>;
+export declare function checkHermesOAuthStatus(): {
+    configured: boolean;
+    endpoint?: string;
+    model?: string;
+    error?: string;
+};