0xray 4.0.13 → 4.0.15

package/dist/integrations/governance/index.js

@@ -0,0 +1,365 @@
+/**
+ * Inference Governance Integration
+ *
+ * Integrates chrono-warp-drive Dynamo governance endpoint for external
+ * inference checking in governance decision-making.
+ *
+ * @since 2026-05-11
+ */
+import { BaseIntegration } from '../base/index.js';
+import { DEFAULT_GOVERNANCE_CONFIG } from './types.js';
+import { GovernanceClient } from './governance-client.js';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import { featuresConfigLoader } from '../../core/features-config.js';
+/**
+ * Main Governance Integration class
+ *
+ * Provides external governance checking for inference proposals via the
+ * chrono-warp-drive Dynamo /governance endpoint.
+ */
+export class InferenceGovernanceIntegration extends BaseIntegration {
+    client = null;
+    configData = DEFAULT_GOVERNANCE_CONFIG;
+    constructor() {
+        super('inference-governance', '1.0.0', {
+            enabled: false,
+            debug: false,
+            logLevel: 'info'
+        });
+    }
+    /**
+     * Perform integration-specific initialization
+     */
+    async performInitialization() {
+        await this.loadConfig();
+        if (!this.configData.enabled) {
+            await this.log('info', 'Governance integration disabled in configuration');
+            return;
+        }
+        await this.log('info', 'Initializing governance client...');
+        this.client = new GovernanceClient({
+            baseUrl: this.configData.endpointUrl.replace(/\/governance$/, ''),
+            timeoutMs: this.configData.requestTimeoutMs,
+        });
+        await this.log('success', 'Governance client initialized', {
+            endpoint: this.configData.endpointUrl,
+            timeout: this.configData.requestTimeoutMs,
+        });
+    }
+    /**
+     * Perform integration-specific shutdown
+     */
+    async performShutdown() {
+        await this.log('info', 'Shutting down governance integration');
+        this.client = null;
+    }
+    /**
+     * Perform health check
+     */
+    async performHealthCheck() {
+        if (!this.client) {
+            return {
+                healthy: false,
+                message: 'Governance client not initialized',
+            };
+        }
+        const stats = this.client.getStats();
+        // Healthy if we have no recent errors
+        const isHealthy = stats.errors === 0 || stats.requestsSucceeded > stats.errors;
+        return {
+            healthy: isHealthy,
+            message: isHealthy
+                ? 'Governance client healthy'
+                : 'Governance client has errors',
+            details: {
+                requestsTotal: stats.requestsTotal,
+                requestsSucceeded: stats.requestsSucceeded,
+                requestsFailed: stats.requestsFailed,
+                errors: stats.errors,
+                averageResponseTimeMs: stats.averageResponseTimeMs,
+            },
+        };
+    }
+    /**
+     * Check if governance is enabled and available
+     */
+    isAvailable() {
+        return this.configData.enabled && this.client !== null && this.status === 'initialized';
+    }
+    /**
+     * Check a single inference proposal via the appropriate governance tool
+     *
+     * Routes to govern_with_solar (strategic proposals) or evaluate_governance
+     * (technical proposals) based on proposal type.
+     */
+    async checkProposal(proposal, agentReviews = [], historicalIds = []) {
+        if (!this.isAvailable()) {
+            throw new Error('Governance integration not available');
+        }
+        const isTechnical = proposal.type === 'fix' || proposal.type === 'guard';
+        if (isTechnical) {
+            return this.evaluateProposal(proposal, agentReviews, historicalIds);
+        }
+        return this.governWithSolarProposal(proposal);
+    }
+    /**
+     * Route: evaluate_governance — for purely technical proposals (fix, guard)
+     */
+    async evaluateProposal(proposal, agentReviews, historicalIds) {
+        const response = await this.client.evaluateGovernance({
+            proposalId: proposal.id,
+            proposalText: `${proposal.title}\n\n${proposal.description}`,
+            agentReviews,
+            historicalSignalIds: historicalIds,
+        });
+        return this.applyDecisionLogic(response);
+    }
+    /**
+     * Route: govern_with_solar — for strategic proposals (refactor, codify, automate)
+     *
+     * Brings real-time NOAA GOES solar context into the decision, adjusting
+     * vote weight and adding warnings based on current solar activity.
+     */
+    async governWithSolarProposal(proposal) {
+        frameworkLogger.log('inference-governance', 'solar-check-start', 'info', {
+            proposalId: proposal.id,
+            proposalTitle: proposal.title,
+        });
+        const solarResponse = await this.client.governWithSolar({
+            proposal: `${proposal.title}\n\n${proposal.description}`,
+            baseVoteWeight: this.configData.decisionLogic.voteWeightMultiplier,
+        });
+        const adjustment = solarResponse.confidenceAdjustment;
+        const recommendation = adjustment <= -0.10 ? 'NEEDS_REVISION' : 'PASS';
+        const reasons = [
+            solarResponse.solarContext.recommendation,
+            `Solar activity: ${solarResponse.solarContext.solarActivityLevel} (adjustment: ${(adjustment * 100).toFixed(0)}%, resonance: ${(solarResponse.solarContext.solarIsotopicResonance ?? solarResponse.solarContext.solarResonance ?? 0).toFixed(4)})`,
+        ];
+        if (solarResponse.finalRecommendation && solarResponse.finalRecommendation !== solarResponse.originalRecommendation) {
+            reasons.push(solarResponse.finalRecommendation);
+        }
+        // Trinitarium Moral Overlay — add moral tension to reasoning
+        if (solarResponse.moralTension) {
+            reasons.push(`Moral tension: ${solarResponse.moralTension}${solarResponse.trinitariumMoralScore != null ? ` (${(solarResponse.trinitariumMoralScore * 100).toFixed(0)}%)` : ''}`);
+            if (solarResponse.detectedConcerns && solarResponse.detectedConcerns.length > 0) {
+                reasons.push(`Moral concerns: ${solarResponse.detectedConcerns.join(', ')}`);
+            }
+        }
+        const mappedResponse = {
+            success: true,
+            proposalId: proposal.id,
+            governanceIsotopeId: `solar-${solarResponse.solarContext.solarActivityLevel}`,
+            resonanceScore: solarResponse.solarContext.solarIsotopicResonance ?? solarResponse.solarContext.solarResonance ?? 0,
+            isotopicRatio: 0,
+            vortexVolume: 0,
+            historicalCoherence: 0,
+            recommendation,
+            confidence: Math.max(0, Math.min(1, proposal.confidence + adjustment)),
+            voteWeight: solarResponse.adjustedVoteWeight,
+            reasons,
+        };
+        const baseResult = this.applyDecisionLogic(mappedResponse);
+        const solarResult = {
+            ...baseResult,
+            solarContext: solarResponse.solarContext,
+            solarConfidenceAdjustment: solarResponse.confidenceAdjustment,
+            moralTension: solarResponse.moralTension,
+            moralScore: solarResponse.trinitariumMoralScore,
+            moralFusion: solarResponse.trinitariumGematriaFusion,
+            detectedVirtues: solarResponse.detectedVirtues,
+            detectedConcerns: solarResponse.detectedConcerns,
+        };
+        frameworkLogger.log('inference-governance', 'solar-check-complete', 'info', {
+            proposalId: proposal.id,
+            solarActivityLevel: solarResponse.solarContext.solarActivityLevel,
+            adjustedVoteWeight: solarResponse.adjustedVoteWeight,
+            confidenceAdjustment: solarResponse.confidenceAdjustment,
+            passed: solarResult.passed,
+        });
+        return solarResult;
+    }
+    /**
+     * Check multiple proposals with external governance
+     */
+    async checkProposals(proposals, agentReviews = [], historicalIds = []) {
+        if (!this.isAvailable()) {
+            throw new Error('Governance integration not available');
+        }
+        const batchId = `governance-batch-${Date.now()}`;
+        const timestamp = Date.now();
+        frameworkLogger.log('inference-governance', 'batch-check-start', 'info', { batchId, proposalCount: proposals.length });
+        const results = [];
+        for (const proposal of proposals) {
+            try {
+                const result = await this.checkProposal(proposal, agentReviews, historicalIds);
+                results.push(result);
+            }
+            catch (error) {
+                frameworkLogger.log('inference-governance', 'check-proposal-error', 'warning', {
+                    proposalId: proposal.id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // Fallback to local decision
+                results.push(this.createFallbackVote(proposal));
+            }
+        }
+        frameworkLogger.log('inference-governance', 'batch-check-complete', 'info', {
+            batchId,
+            proposalCount: proposals.length,
+            passedCount: results.filter(r => r.passed).length,
+        });
+        return {
+            proposals,
+            results,
+            batchId,
+            timestamp,
+        };
+    }
+    /**
+     * Apply decision logic based on governance response
+     */
+    applyDecisionLogic(response) {
+        const { decisionLogic } = this.configData;
+        let vote;
+        let passed;
+        switch (response.recommendation) {
+            case 'PASS':
+                vote = 'YES';
+                passed = true;
+                break;
+            case 'REJECT':
+                vote = 'NO';
+                passed = false;
+                break;
+            case 'NEEDS_REVISION':
+            default:
+                vote = 'ABSTAIN';
+                passed = false;
+                break;
+        }
+        // Calculate weighted vote
+        const weight = response.voteWeight * decisionLogic.voteWeightMultiplier;
+        // Build reason string
+        const reason = [
+            `Governance ${response.recommendation} (confidence: ${(response.confidence * 100).toFixed(1)}%)`,
+            ...response.reasons.slice(0, 2), // Include up to 2 reasons
+        ].join('; ');
+        return {
+            vote,
+            weight,
+            reason,
+            governanceResponse: response,
+            passed,
+        };
+    }
+    /**
+     * Create fallback vote when governance is unavailable
+     */
+    createFallbackVote(proposal) {
+        return {
+            vote: proposal.confidence >= 0.7 ? 'YES' : 'ABSTAIN',
+            weight: 1.0,
+            reason: 'Fallback: governance endpoint unavailable',
+            governanceResponse: {
+                success: false,
+                proposalId: proposal.id,
+                governanceIsotopeId: 'fallback',
+                resonanceScore: 0,
+                isotopicRatio: 0,
+                vortexVolume: 0,
+                historicalCoherence: 0,
+                recommendation: 'NEEDS_REVISION',
+                confidence: proposal.confidence,
+                voteWeight: 1.0,
+                reasons: ['Governance endpoint unavailable, using local confidence'],
+            },
+            passed: proposal.confidence >= 0.7,
+        };
+    }
+    /**
+     * Load configuration from features.json
+     */
+    async loadConfig() {
+        try {
+            const features = featuresConfigLoader.loadConfig();
+            const inferenceGovernance = features.inference_governance;
+            if (inferenceGovernance) {
+                this.configData = {
+                    ...DEFAULT_GOVERNANCE_CONFIG,
+                    enabled: inferenceGovernance.enabled ?? false,
+                    endpointUrl: inferenceGovernance.endpoint_url ?? DEFAULT_GOVERNANCE_CONFIG.endpointUrl,
+                    requestTimeoutMs: inferenceGovernance.request_timeout_ms ?? DEFAULT_GOVERNANCE_CONFIG.requestTimeoutMs,
+                    minConfidenceThreshold: inferenceGovernance.min_confidence_threshold ?? DEFAULT_GOVERNANCE_CONFIG.minConfidenceThreshold,
+                    decisionLogic: {
+                        passConfidenceMin: inferenceGovernance.decision_logic?.pass_confidence_min ?? DEFAULT_GOVERNANCE_CONFIG.decisionLogic.passConfidenceMin,
+                        revisionConfidenceMax: inferenceGovernance.decision_logic?.revision_confidence_max ?? DEFAULT_GOVERNANCE_CONFIG.decisionLogic.revisionConfidenceMax,
+                        voteWeightMultiplier: inferenceGovernance.decision_logic?.vote_weight_multiplier ?? DEFAULT_GOVERNANCE_CONFIG.decisionLogic.voteWeightMultiplier,
+                    },
+                };
+            }
+            await this.log('info', 'Configuration loaded', {
+                enabled: this.configData.enabled,
+                endpoint: this.configData.endpointUrl,
+            });
+        }
+        catch (error) {
+            await this.log('error', 'Failed to load configuration', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.configData = DEFAULT_GOVERNANCE_CONFIG;
+        }
+    }
+    /**
+     * Get governance-specific configuration
+     */
+    getGovernanceConfig() {
+        return { ...this.configData };
+    }
+    /**
+     * Get client statistics
+     */
+    getClientStats() {
+        return this.client?.getStats() ?? {
+            requestsTotal: 0,
+            requestsSucceeded: 0,
+            requestsFailed: 0,
+            averageResponseTimeMs: 0,
+            errors: 0,
+        };
+    }
+}
+// ============================================================================
+// Global Integration Instance
+// ============================================================================
+let globalIntegration = null;
+/**
+ * Initialize the global governance integration
+ */
+export async function initializeGovernanceIntegration() {
+    if (globalIntegration) {
+        return globalIntegration;
+    }
+    globalIntegration = new InferenceGovernanceIntegration();
+    await globalIntegration.initialize();
+    return globalIntegration;
+}
+/**
+ * Get the global governance integration
+ */
+export function getGovernanceIntegration() {
+    return globalIntegration;
+}
+/**
+ * Shutdown the global governance integration
+ */
+export async function shutdownGovernanceIntegration() {
+    if (globalIntegration) {
+        await globalIntegration.shutdown();
+        globalIntegration = null;
+    }
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export * from './types.js';
+export * from './governance-client.js';

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

@@ -0,0 +1,238 @@
+/**
+ * Inference Governance Integration Types
+ *
+ * Type definitions for the chrono-warp-drive Dynamo governance endpoint integration.
+ * Provides external governance checking for inference-driven proposals.
+ *
+ * @since 2026-05-11
+ */
+import type { InferenceProposal } from '../../inference/inference-cycle.js';
+/**
+ * Governance check request payload
+ * Matches the Dynamo /governance endpoint format
+ */
+export interface GovernanceCheckRequest {
+    proposalId: string;
+    proposalText: string;
+    codeDiff?: string;
+    agentReviews: string[];
+    historicalSignalIds?: string[];
+}
+/**
+ * Governance check response from Dynamo endpoint
+ */
+export interface GovernanceCheckResponse {
+    success: boolean;
+    proposalId: string;
+    governanceIsotopeId: string;
+    resonanceScore: number;
+    isotopicRatio: number;
+    vortexVolume: number;
+    historicalCoherence: number;
+    recommendation: 'PASS' | 'NEEDS_REVISION' | 'REJECT';
+    confidence: number;
+    voteWeight: number;
+    reasons: string[];
+}
+/**
+ * Governance integration configuration
+ */
+export interface GovernanceIntegrationConfig {
+    /** Whether the integration is enabled */
+    enabled: boolean;
+    /** Governance endpoint URL */
+    endpointUrl: string;
+    /** Request timeout in milliseconds */
+    requestTimeoutMs: number;
+    /** Minimum confidence threshold for proposals */
+    minConfidenceThreshold: number;
+    /** Decision logic configuration */
+    decisionLogic: {
+        /** Minimum confidence for PASS recommendation */
+        passConfidenceMin: number;
+        /** Maximum confidence for NEEDS_REVISION (below this is PASS, above is REJECT) */
+        revisionConfidenceMax: number;
+        /** Multiplier for vote weight from governance */
+        voteWeightMultiplier: number;
+    };
+}
+/**
+ * Default governance configuration
+ */
+export declare const DEFAULT_GOVERNANCE_CONFIG: GovernanceIntegrationConfig;
+/**
+ * Solar activity levels from NOAA GOES data
+ */
+export type SolarActivityLevel = 'quiet' | 'moderate' | 'active' | 'storm';
+/**
+ * Solar context returned by govern_with_solar
+ */
+export interface SolarContext {
+    /** Current solar activity level */
+    solarActivityLevel: SolarActivityLevel;
+    /** Solar isotopic resonance score (0-1) — canonical field */
+    solarIsotopicResonance: number;
+    /** Alias for backward compatibility */
+    solarResonance?: number;
+    /** Modifier applied to vote weight based on solar activity */
+    solarActivityModifier: number;
+    /** Human-readable recommendation based on solar conditions */
+    recommendation: string;
+}
+/**
+ * Solar-enhanced governance check request
+ */
+export interface SolarGovernanceCheckRequest {
+    /** The proposal text to evaluate */
+    proposal: string;
+    /** Starting vote weight (0.5 - 1.5) */
+    baseVoteWeight?: number;
+    /** Whether to share the governance result publicly */
+    sharePublicly?: boolean;
+    /** Spectral quality score for resonance analysis */
+    spectralQuality?: number;
+}
+/**
+ * Solar-enhanced governance check response
+ */
+export interface SolarGovernanceCheckResponse {
+    /** Original recommendation before solar adjustments */
+    originalRecommendation: string;
+    /** Real-time solar context from NOAA GOES */
+    solarContext: SolarContext;
+    /** Vote weight after solar adjustment */
+    adjustedVoteWeight: number;
+    /** Final recommendation with solar warning appended if applicable */
+    finalRecommendation: string;
+    /** Confidence adjustment applied due to solar activity */
+    confidenceAdjustment: number;
+    /** Trinitarium Moral Overlay — moral alignment score (0-1) */
+    trinitariumMoralScore?: number | undefined;
+    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical' | undefined;
+    trinitariumGematriaFusion?: number | undefined;
+    detectedVirtues?: string[] | undefined;
+    detectedConcerns?: string[] | undefined;
+    /** Server-side authoritative recommendation */
+    recommendation?: string;
+    /** Confidence score from governance */
+    confidence?: number;
+    /** Resonance score */
+    resonanceScore?: number;
+    /** Structural resonance metric */
+    structuralResonance?: number;
+    /** Proximity metric */
+    proximity?: number;
+    /** Phase alignment metric */
+    phaseAlignment?: number;
+    /** Vortex alignment metric */
+    vortexAlignment?: number;
+    /** Synchronization metric */
+    synchronization?: number;
+    /** Signal timing indicator */
+    signalTiming?: string;
+    /** Human-readable hammer reason */
+    hammerReason?: string;
+    /** Whether neural context was used */
+    neuralContextUsed?: boolean;
+    /** Spectral quality score */
+    spectralQuality?: number;
+}
+/**
+ * Solar-enhanced vote result — extends standard vote with solar context
+ */
+export interface SolarGovernanceVoteResult extends GovernanceVoteResult {
+    /** Solar context that influenced the decision */
+    solarContext: SolarContext;
+    /** Confidence adjustment from solar activity */
+    solarConfidenceAdjustment: number;
+}
+/**
+ * Governance vote result after applying decision logic
+ */
+export interface GovernanceVoteResult {
+    /** Final vote decision */
+    vote: 'YES' | 'NO' | 'ABSTAIN';
+    /** Vote weight (affected by governance confidence) */
+    weight: number;
+    /** Human-readable reason for the vote */
+    reason: string;
+    /** Raw governance response for audit trail */
+    governanceResponse: GovernanceCheckResponse;
+    /** Whether the proposal passed governance */
+    passed: boolean;
+    /** Moral-Numerological Tension from Trinitarium Moral Overlay */
+    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical' | undefined;
+    moralScore?: number | undefined;
+    moralFusion?: number | undefined;
+    detectedVirtues?: string[] | undefined;
+    detectedConcerns?: string[] | undefined;
+}
+/**
+ * Batch governance check for multiple proposals
+ */
+export interface BatchGovernanceCheck {
+    proposals: InferenceProposal[];
+    results: GovernanceVoteResult[];
+    batchId: string;
+    timestamp: number;
+}
+/**
+ * HTTP client configuration
+ */
+export interface GovernanceClientConfig {
+    baseUrl: string;
+    timeoutMs: number;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+}
+/**
+ * Client statistics
+ */
+export interface GovernanceClientStats {
+    requestsTotal: number;
+    requestsSucceeded: number;
+    requestsFailed: number;
+    averageResponseTimeMs: number;
+    lastRequestAt?: number;
+    errors: number;
+}
+/**
+ * Governance error codes
+ */
+export declare enum GovernanceErrorCode {
+    REQUEST_FAILED = "REQUEST_FAILED",
+    TIMEOUT = "TIMEOUT",
+    INVALID_RESPONSE = "INVALID_RESPONSE",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    CONFIG_INVALID = "CONFIG_INVALID",
+    NOT_INITIALIZED = "NOT_INITIALIZED"
+}
+/**
+ * Base governance error
+ */
+export declare class GovernanceError extends Error {
+    code: GovernanceErrorCode;
+    recoverable: boolean;
+    context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: GovernanceErrorCode, recoverable: boolean, context?: Record<string, unknown> | undefined);
+}
+/**
+ * Request timeout error
+ */
+export declare class GovernanceTimeoutError extends GovernanceError {
+    constructor(timeoutMs: number);
+}
+/**
+ * Network error
+ */
+export declare class GovernanceNetworkError extends GovernanceError {
+    constructor(url: string, originalError: Error);
+}
+/**
+ * Type guard for valid governance response
+ */
+export declare function isValidGovernanceResponse(response: unknown): response is GovernanceCheckResponse;
+/**
+ * Type guard for governance error
+ */
+export declare function isGovernanceError(error: unknown): error is GovernanceError;

package/dist/integrations/governance/types.js

@@ -0,0 +1,96 @@
+/**
+ * Inference Governance Integration Types
+ *
+ * Type definitions for the chrono-warp-drive Dynamo governance endpoint integration.
+ * Provides external governance checking for inference-driven proposals.
+ *
+ * @since 2026-05-11
+ */
+/**
+ * Default governance configuration
+ */
+export const DEFAULT_GOVERNANCE_CONFIG = {
+    enabled: false,
+    endpointUrl: process.env.GOVERNANCE_ENDPOINT || '',
+    requestTimeoutMs: 10000,
+    minConfidenceThreshold: 0.5,
+    decisionLogic: {
+        passConfidenceMin: 0.9,
+        revisionConfidenceMax: 0.89,
+        voteWeightMultiplier: 1.0,
+    },
+};
+// ============================================================================
+// Error Types
+// ============================================================================
+/**
+ * Governance error codes
+ */
+export var GovernanceErrorCode;
+(function (GovernanceErrorCode) {
+    GovernanceErrorCode["REQUEST_FAILED"] = "REQUEST_FAILED";
+    GovernanceErrorCode["TIMEOUT"] = "TIMEOUT";
+    GovernanceErrorCode["INVALID_RESPONSE"] = "INVALID_RESPONSE";
+    GovernanceErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+    GovernanceErrorCode["CONFIG_INVALID"] = "CONFIG_INVALID";
+    GovernanceErrorCode["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+})(GovernanceErrorCode || (GovernanceErrorCode = {}));
+/**
+ * Base governance error
+ */
+export class GovernanceError extends Error {
+    code;
+    recoverable;
+    context;
+    constructor(message, code, recoverable, context) {
+        super(message);
+        this.code = code;
+        this.recoverable = recoverable;
+        this.context = context;
+        this.name = 'GovernanceError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+/**
+ * Request timeout error
+ */
+export class GovernanceTimeoutError extends GovernanceError {
+    constructor(timeoutMs) {
+        super(`Governance request timed out after ${timeoutMs}ms`, GovernanceErrorCode.TIMEOUT, true, { timeoutMs });
+        this.name = 'GovernanceTimeoutError';
+    }
+}
+/**
+ * Network error
+ */
+export class GovernanceNetworkError extends GovernanceError {
+    constructor(url, originalError) {
+        super(`Network error calling governance endpoint: ${originalError.message}`, GovernanceErrorCode.NETWORK_ERROR, true, { url, originalError: originalError.message });
+        this.name = 'GovernanceNetworkError';
+    }
+}
+// ============================================================================
+// Utility Types
+// ============================================================================
+/**
+ * Type guard for valid governance response
+ */
+export function isValidGovernanceResponse(response) {
+    if (typeof response !== 'object' || response === null)
+        return false;
+    const r = response;
+    return (typeof r.success === 'boolean' &&
+        typeof r.proposalId === 'string' &&
+        typeof r.governanceIsotopeId === 'string' &&
+        typeof r.recommendation === 'string' &&
+        ['PASS', 'NEEDS_REVISION', 'REJECT'].includes(r.recommendation) &&
+        typeof r.confidence === 'number' &&
+        typeof r.voteWeight === 'number');
+}
+/**
+ * Type guard for governance error
+ */
+export function isGovernanceError(error) {
+    return (error instanceof GovernanceError ||
+        (error instanceof Error && error.name === 'GovernanceError'));
+}