0xray 4.0.13 → 4.0.14

package/dist/integrations/governance/governance-client.js

@@ -0,0 +1,315 @@
+/**
+ * Governance HTTP Client
+ *
+ * Client for calling the chrono-warp-drive Dynamo governance endpoint.
+ * Handles HTTP requests, retries, and response validation.
+ *
+ * @since 2026-05-11
+ */
+import { GovernanceError, GovernanceErrorCode, GovernanceTimeoutError, GovernanceNetworkError, } from './types.js';
+import { frameworkLogger } from '../../core/framework-logger.js';
+/**
+ * HTTP client for governance endpoint
+ */
+export class GovernanceClient {
+    config;
+    stats;
+    constructor(config = {}) {
+        this.config = {
+            baseUrl: process.env.GOVERNANCE_ENDPOINT || '',
+            timeoutMs: 10000,
+            retryAttempts: 3,
+            retryDelayMs: 1000,
+            ...config,
+        };
+        this.stats = {
+            requestsTotal: 0,
+            requestsSucceeded: 0,
+            requestsFailed: 0,
+            averageResponseTimeMs: 0,
+            errors: 0,
+        };
+    }
+    /**
+     * Call any Dynamo MCP tool via call_connected_tool proxy
+     */
+    async callTool(toolName, params) {
+        const url = `${this.config.baseUrl}/call_connected_tool`;
+        return this.makeJsonRequest(url, { tool_name: toolName, params });
+    }
+    /**
+     * Check a proposal with solar-enhanced governance (govern_with_solar tool)
+     *
+     * Brings real-time solar context from NOAA GOES into governance decisions,
+     * automatically adjusting vote weight and adding warnings based on current
+     * solar activity (quiet / moderate / active / storm).
+     */
+    async governWithSolar(request) {
+        const startTime = Date.now();
+        this.stats.requestsTotal++;
+        frameworkLogger.log('governance-client', 'solar-check-start', 'info', {
+            proposalPreview: request.proposal.slice(0, 80),
+            baseVoteWeight: request.baseVoteWeight ?? 1.0,
+        });
+        try {
+            const raw = await this.callTool('govern_with_solar', {
+                proposal: request.proposal,
+                baseVoteWeight: request.baseVoteWeight ?? 1.0,
+                ...(request.sharePublicly !== undefined && { sharePublicly: request.sharePublicly }),
+                ...(request.spectralQuality !== undefined && { spectralQuality: request.spectralQuality }),
+            });
+            const result = raw.result;
+            frameworkLogger.log('governance-client', 'solar-governance-raw', 'debug', { rawResponse: JSON.stringify(raw) });
+            const response = {
+                originalRecommendation: result.originalRecommendation,
+                solarContext: result.solarContext,
+                adjustedVoteWeight: result.adjustedVoteWeight,
+                finalRecommendation: result.finalRecommendation,
+                confidenceAdjustment: result.confidenceAdjustment,
+                trinitariumMoralScore: result.trinitariumMoralScore,
+                moralTension: result.moralNumerologicalTension,
+                trinitariumGematriaFusion: result.trinitariumGematriaFusion,
+                detectedVirtues: Array.isArray(result.trinitariumDetectedVirtues) ? result.trinitariumDetectedVirtues : undefined,
+                detectedConcerns: Array.isArray(result.trinitariumDetectedConcerns) ? result.trinitariumDetectedConcerns : undefined,
+                ...(result.recommendation !== undefined && { recommendation: result.recommendation }),
+                ...(result.confidence !== undefined && { confidence: result.confidence }),
+                ...(result.resonanceScore !== undefined && { resonanceScore: result.resonanceScore }),
+                ...(result.structuralResonance !== undefined && { structuralResonance: result.structuralResonance }),
+                ...(result.proximity !== undefined && { proximity: result.proximity }),
+                ...(result.phaseAlignment !== undefined && { phaseAlignment: result.phaseAlignment }),
+                ...(result.vortexAlignment !== undefined && { vortexAlignment: result.vortexAlignment }),
+                ...(result.synchronization !== undefined && { synchronization: result.synchronization }),
+                ...(result.signalTiming !== undefined && { signalTiming: result.signalTiming }),
+                ...(result.hammerReason !== undefined && { hammerReason: result.hammerReason }),
+                ...(result.neuralContextUsed !== undefined && { neuralContextUsed: result.neuralContextUsed }),
+                ...(result.spectralQuality !== undefined && { spectralQuality: result.spectralQuality }),
+            };
+            if (!this.isValidSolarResponse(response)) {
+                throw new GovernanceError('Invalid solar governance response structure', GovernanceErrorCode.INVALID_RESPONSE, false, { response });
+            }
+            const duration = Date.now() - startTime;
+            this.updateResponseTime(duration);
+            this.stats.requestsSucceeded++;
+            this.stats.lastRequestAt = Date.now();
+            frameworkLogger.log('governance-client', 'solar-check-success', 'info', {
+                solarActivityLevel: response.solarContext.solarActivityLevel,
+                adjustedVoteWeight: response.adjustedVoteWeight,
+                confidenceAdjustment: response.confidenceAdjustment,
+                durationMs: duration,
+            });
+            return response;
+        }
+        catch (error) {
+            this.stats.requestsFailed++;
+            this.stats.errors++;
+            frameworkLogger.log('governance-client', 'solar-check-error', 'error', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Evaluate a proposal with standard governance (evaluate_governance tool)
+     *
+     * For purely technical or low-level protocol decisions where external
+     * solar modifiers are undesired.
+     */
+    async evaluateGovernance(params) {
+        const startTime = Date.now();
+        this.stats.requestsTotal++;
+        frameworkLogger.log('governance-client', 'evaluate-start', 'info', {
+            proposalId: params.proposalId,
+            proposalPreview: params.proposalText.slice(0, 80),
+            agentReviewCount: params.agentReviews.length,
+        });
+        try {
+            const raw = await this.callTool('evaluate_governance', {
+                proposalId: params.proposalId,
+                proposalText: params.proposalText,
+                agentReviews: params.agentReviews,
+                ...(params.codeDiff ? { codeDiff: params.codeDiff } : {}),
+                ...(params.historicalSignalIds ? { historicalSignalIds: params.historicalSignalIds } : {}),
+            });
+            const result = raw.result;
+            const diagnostics = result.diagnostics;
+            const response = {
+                success: true,
+                proposalId: result.proposalId || '',
+                governanceIsotopeId: result.governanceIsotopeId || `evaluate-${Date.now()}`,
+                resonanceScore: result.resonanceScore ?? 0,
+                isotopicRatio: diagnostics?.isotopicRatio ?? result.isotopicRatio ?? 0,
+                vortexVolume: diagnostics?.vortexVolume ?? result.vortexVolume ?? 0,
+                historicalCoherence: diagnostics?.historicalCoherence ?? result.historicalCoherence ?? 0,
+                recommendation: result.recommendation,
+                confidence: result.confidence,
+                voteWeight: result.voteWeight,
+                reasons: Array.isArray(result.reasons)
+                    ? result.reasons
+                    : [result.reason, result.reasoning].filter(Boolean),
+            };
+            if (!this.isValidResponse(response)) {
+                throw new GovernanceError('Invalid evaluate governance response structure', GovernanceErrorCode.INVALID_RESPONSE, false, { response });
+            }
+            const duration = Date.now() - startTime;
+            this.updateResponseTime(duration);
+            this.stats.requestsSucceeded++;
+            this.stats.lastRequestAt = Date.now();
+            frameworkLogger.log('governance-client', 'evaluate-success', 'info', {
+                recommendation: response.recommendation,
+                confidence: response.confidence,
+                voteWeight: response.voteWeight,
+                durationMs: duration,
+            });
+            return response;
+        }
+        catch (error) {
+            this.stats.requestsFailed++;
+            this.stats.errors++;
+            frameworkLogger.log('governance-client', 'evaluate-error', 'error', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Make HTTP request with retries and exponential backoff
+     */
+    async makeJsonRequest(url, body) {
+        let lastError;
+        if (!this.config.baseUrl) {
+            throw new GovernanceError('Governance endpoint not configured. Set GOVERNANCE_ENDPOINT environment variable.', GovernanceErrorCode.CONFIG_INVALID, false, { hint: 'export GOVERNANCE_ENDPOINT=https://your-governance-endpoint.com' });
+        }
+        for (let attempt = 0; attempt < (this.config.retryAttempts || 1); attempt++) {
+            try {
+                return await this.doJsonRequest(url, body);
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (error instanceof GovernanceError && !error.recoverable) {
+                    throw error;
+                }
+                if (attempt < (this.config.retryAttempts || 1) - 1) {
+                    const delay = (this.config.retryDelayMs || 1000) * Math.pow(2, attempt);
+                    await this.delay(delay);
+                }
+            }
+        }
+        throw lastError || new GovernanceError('All request attempts failed', GovernanceErrorCode.REQUEST_FAILED, false);
+    }
+    /**
+     * Validate solar governance response structure with range checks
+     */
+    isValidSolarResponse(response) {
+        if (typeof response !== 'object' || response === null)
+            return false;
+        const r = response;
+        const hasSolarContext = typeof r.solarContext === 'object' && r.solarContext !== null;
+        if (!hasSolarContext)
+            return false;
+        const sc = r.solarContext;
+        const validLevels = ['quiet', 'moderate', 'active', 'storm'];
+        return (typeof r.originalRecommendation === 'string' &&
+            typeof sc.solarActivityLevel === 'string' &&
+            validLevels.includes(sc.solarActivityLevel) &&
+            ((typeof sc.solarIsotopicResonance === 'number' &&
+                sc.solarIsotopicResonance >= 0 &&
+                sc.solarIsotopicResonance <= 1) ||
+                typeof sc.solarResonance === 'number') &&
+            typeof sc.solarActivityModifier === 'number' &&
+            sc.solarActivityModifier >= -1 &&
+            sc.solarActivityModifier <= 1 &&
+            typeof sc.recommendation === 'string' &&
+            typeof r.adjustedVoteWeight === 'number' &&
+            r.adjustedVoteWeight >= 0.5 &&
+            r.adjustedVoteWeight <= 1.5 &&
+            typeof r.finalRecommendation === 'string' &&
+            typeof r.confidenceAdjustment === 'number');
+    }
+    async doJsonRequest(url, body) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new GovernanceError(`HTTP ${response.status}: ${response.statusText}`, GovernanceErrorCode.REQUEST_FAILED, response.status >= 500, { status: response.status, statusText: response.statusText });
+            }
+            return await response.json();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof GovernanceError)
+                throw error;
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new GovernanceTimeoutError(this.config.timeoutMs);
+                }
+                throw new GovernanceNetworkError(url, error);
+            }
+            throw new GovernanceError(String(error), GovernanceErrorCode.REQUEST_FAILED, true);
+        }
+    }
+    /**
+     * Validate governance response structure
+     */
+    isValidResponse(response) {
+        if (typeof response !== 'object' || response === null)
+            return false;
+        const r = response;
+        return (typeof r.proposalId === 'string' &&
+            typeof r.governanceIsotopeId === 'string' &&
+            typeof r.resonanceScore === 'number' &&
+            typeof r.recommendation === 'string' &&
+            ['PASS', 'NEEDS_REVISION', 'REJECT'].includes(r.recommendation) &&
+            typeof r.confidence === 'number' &&
+            typeof r.voteWeight === 'number' &&
+            Array.isArray(r.reasons) &&
+            r.reasons.every((r) => typeof r === 'string'));
+    }
+    /**
+     * Update average response time
+     */
+    updateResponseTime(durationMs) {
+        const total = this.stats.requestsSucceeded;
+        this.stats.averageResponseTimeMs =
+            (this.stats.averageResponseTimeMs * (total - 1) + durationMs) / total;
+    }
+    /**
+     * Delay utility
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Get client statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Update client configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            requestsTotal: 0,
+            requestsSucceeded: 0,
+            requestsFailed: 0,
+            averageResponseTimeMs: 0,
+            errors: 0,
+        };
+    }
+}

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

@@ -0,0 +1,98 @@
+/**
+ * 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 type { GovernanceIntegrationConfig, GovernanceVoteResult, BatchGovernanceCheck } from './types.js';
+import type { InferenceProposal } from '../../inference/inference-cycle.js';
+/**
+ * Main Governance Integration class
+ *
+ * Provides external governance checking for inference proposals via the
+ * chrono-warp-drive Dynamo /governance endpoint.
+ */
+export declare class InferenceGovernanceIntegration extends BaseIntegration {
+    private client;
+    private configData;
+    constructor();
+    /**
+     * Perform integration-specific initialization
+     */
+    protected performInitialization(): Promise<void>;
+    /**
+     * Perform integration-specific shutdown
+     */
+    protected performShutdown(): Promise<void>;
+    /**
+     * Perform health check
+     */
+    protected performHealthCheck(): Promise<{
+        healthy: boolean;
+        message: string;
+        details?: Record<string, unknown>;
+    }>;
+    /**
+     * Check if governance is enabled and available
+     */
+    isAvailable(): boolean;
+    /**
+     * 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.
+     */
+    checkProposal(proposal: InferenceProposal, agentReviews?: string[], historicalIds?: string[]): Promise<GovernanceVoteResult>;
+    /**
+     * Route: evaluate_governance — for purely technical proposals (fix, guard)
+     */
+    private evaluateProposal;
+    /**
+     * 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.
+     */
+    private governWithSolarProposal;
+    /**
+     * Check multiple proposals with external governance
+     */
+    checkProposals(proposals: InferenceProposal[], agentReviews?: string[], historicalIds?: string[]): Promise<BatchGovernanceCheck>;
+    /**
+     * Apply decision logic based on governance response
+     */
+    private applyDecisionLogic;
+    /**
+     * Create fallback vote when governance is unavailable
+     */
+    private createFallbackVote;
+    /**
+     * Load configuration from features.json
+     */
+    private loadConfig;
+    /**
+     * Get governance-specific configuration
+     */
+    getGovernanceConfig(): GovernanceIntegrationConfig;
+    /**
+     * Get client statistics
+     */
+    getClientStats(): import("./types.js").GovernanceClientStats;
+}
+/**
+ * Initialize the global governance integration
+ */
+export declare function initializeGovernanceIntegration(): Promise<InferenceGovernanceIntegration>;
+/**
+ * Get the global governance integration
+ */
+export declare function getGovernanceIntegration(): InferenceGovernanceIntegration | null;
+/**
+ * Shutdown the global governance integration
+ */
+export declare function shutdownGovernanceIntegration(): Promise<void>;
+export * from './types.js';
+export * from './governance-client.js';