0xray 4.0.12 → 4.0.13

package/dist/integrations/governance/index.js

@@ -1,365 +0,0 @@
-/**
- * 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

@@ -1,238 +0,0 @@
-/**
- * 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

@@ -1,96 +0,0 @@
-/**
- * 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'));
-}