0xray 3.0.12 → 3.1.0

package/dist/governance/governance-core.js

@@ -1,47 +1,117 @@
 /**
  * Pure governance decision logic.
- * This module contains the merging rules and metamorphosis scoring.
+ * 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',
+};
 /**
- * Calculate metamorphosis resonance score for self-evolution proposals.
- *
- * Evaluates whether a proposal increases the system's capacity to govern
- * complex future states. Uses the existing Dynamo resonance signal plus
- * checks for self-improvement indicators.
- *
- * Scoring rubric (0-1):
- * - Base: governance vote confidence (averageConfidence)
- * - Boost: +0.1 if proposal adds new capacity (type=automate/codify)
- * - Boost: +0.05 if historical coherence is strong (>0.8)
- * - Penalty: -0.15 if proposal removes existing capacity (type=compliance-only)
- * - Floor: 0.0, Ceiling: 1.0
- * - Threshold for approval: ≥ 0.7 (configurable via GovernOptions.metamorphosisThreshold)
- *
- * Only meaningful when proposal.type === 'metamorphosis' or source === 'metamorphosis'.
+ * The core PHI/TAU decision matrix.
+ * Extracted so it can be shared between local MCP and deployed HTTP versions.
  */
-export function calculateMetamorphosisScore(input) {
-    let score = input.averageConfidence;
-    // Self-improvement capacity: proposals that add automation or codification boost the score
-    if (input.proposalType === 'automate' || input.proposalType === 'codify') {
-        score += 0.10;
+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)}%`);
     }
-    // Compliance-only proposals (guard type with no new capacity) get a penalty
-    if (input.proposalType === 'compliance') {
-        score -= 0.15;
+    // 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,
+        };
     }
-    // Strong historical coherence means the system is stable enough for self-evolution
-    if (input.historicalCoherence != null && input.historicalCoherence > 0.8) {
-        score += 0.05;
+    // 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'})`);
     }
-    // High Dynamo resonance (Solar signal) supports self-evolution
-    if (input.resonanceScore != null && input.resonanceScore >= 0.82) {
-        score += 0.05;
+    // Aligned tension boosts confidence slightly
+    if (moralTension === 'Aligned' && moralScore != null) {
+        confidence += 0.03;
+        voteWeight *= 1.05;
+        reasons.push(`Moral alignment confirmed (score: ${(moralScore * 100).toFixed(0)}%)`);
+    }
+    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');
     }
-    return Math.min(1.0, Math.max(0.0, Math.round(score * 100) / 100));
+    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.
@@ -80,4 +150,19 @@ export function mergeVotes(votes) {
         reasoningSummary: reasons,
     };
 }
-//# sourceMappingURL=governance-core.js.map
+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.js

@@ -15,9 +15,10 @@
  *
  * Dynamo Solar SSOT is treated as a mandatory external filter (not optional, not a fallback).
  */
-import { pluginRegistry } from '../nucleus/plugin-registry.js';
-import { getGovernanceIntegration, initializeGovernanceIntegration, } from '../integrations/governance/index.js';
-import { mergeVotes, calculateMetamorphosisScore } from './governance-core.js';
+import { mcpClientManager } from '../mcps/mcp-client.js';
+import { callInProcessSkill } from '../mcps/in-process-skill-registry.js';
+import { getGovernanceIntegration, } from '../integrations/governance/index.js';
+import { mergeVotes } from './governance-core.js';
 import { frameworkLogger } from '../core/framework-logger.js';
 export class GovernanceService {
     constructor() {
@@ -38,7 +39,7 @@ export class GovernanceService {
      */
     async govern(request) {
         const { proposals, context, options } = request;
-        const requireExternal = options?.requireExternalDynamo ?? !process.env.XRAY_LOCAL_MODE;
+        const requireExternal = options?.requireExternalDynamo ?? true;
         const timeoutMs = options?.timeoutMs ?? 90000;
         const maxAbstentionThreshold = options?.maxAbstentionThreshold ?? 1.0;
         frameworkLogger.log('governance-service', 'govern-start', 'info', {
@@ -47,23 +48,6 @@ export class GovernanceService {
             requireExternalDynamo: requireExternal,
             timeoutMs,
         });
-        // Lazy init: seed the governance integration if not already initialized.
-        // This handles the case where govern() is called outside the full boot-orchestrator
-        // lifecycle (e.g., inference cycle triggered by CLI or session monitor).
-        if (!getGovernanceIntegration()) {
-            try {
-                await initializeGovernanceIntegration();
-                frameworkLogger.log('governance-service', 'governance-integration-lazy-init', 'info', {
-                    message: 'Governance integration initialized lazily during govern() call',
-                });
-            }
-            catch (initError) {
-                frameworkLogger.log('governance-service', 'governance-integration-lazy-init-failed', 'warning', {
-                    message: 'Failed to lazily initialize governance integration — proceeding without external Dynamo',
-                    error: initError instanceof Error ? initError.message : String(initError),
-                });
-            }
-        }
         // Early validation: Dynamo Solar SSOT is a hard requirement
         if (requireExternal) {
             const integration = getGovernanceIntegration();
@@ -75,7 +59,7 @@ export class GovernanceService {
             }
         }
         // Run governance with end-to-end timeout
-        const result = await this.runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, options?.metamorphosisThreshold);
+        const result = await this.runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs);
         // Check abstention threshold
         if (result.results.length > 0 && maxAbstentionThreshold < 1.0) {
             const totalVotes = result.results.reduce((sum, r) => sum + r.votes.length, 0);
@@ -107,7 +91,7 @@ export class GovernanceService {
             },
         };
     }
-    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs, metamorphosisThreshold) {
+    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
         try {
@@ -118,7 +102,7 @@ export class GovernanceService {
                 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, context);
+            const externalVotes = await this.callExternalDynamo(proposals, requireExternal);
             // 3. Merge everything
             const results = proposals.map((proposal, index) => {
                 const votes = [
@@ -128,33 +112,13 @@ export class GovernanceService {
                     ...(externalVotes[index] || []),
                 ];
                 const merged = mergeVotes(votes);
-                const isMetamorphosis = proposal.type === 'metamorphosis' || proposal.source === 'metamorphosis';
-                const result = {
+                return {
                     proposalId: proposal.id,
                     finalDecision: merged.finalDecision,
                     averageConfidence: merged.averageConfidence,
                     votes,
                     reasoningSummary: merged.reasoningSummary,
                 };
-                // Metamorphosis resonance scoring: only for self-evolution proposals
-                if (isMetamorphosis) {
-                    const threshold = metamorphosisThreshold ?? 0.7;
-                    const metaInput = {
-                        averageConfidence: merged.averageConfidence,
-                        proposalType: proposal.type,
-                    };
-                    const externalConfidence = externalVotes[index]?.[0]?.confidence;
-                    if (externalConfidence !== undefined) {
-                        metaInput.historicalCoherence = externalConfidence;
-                    }
-                    result.metamorphosisScore = calculateMetamorphosisScore(metaInput);
-                    // Reject metamorphosis proposals that don't meet the threshold
-                    if (result.metamorphosisScore < threshold && result.finalDecision === 'approve') {
-                        result.finalDecision = 'needs_revision';
-                        result.reasoningSummary += ` | Metamorphosis score ${result.metamorphosisScore} below threshold ${threshold}`;
-                    }
-                }
-                return result;
             });
             return { results };
         }
@@ -164,52 +128,53 @@ export class GovernanceService {
     }
     async callSkillServer(serverName, proposals, context) {
         const votes = [];
-        // Phase 4: all skills go through pluginRegistry. No MCP fallback.
-        if (!pluginRegistry.has(serverName)) {
-            frameworkLogger.log('governance-service', 'skill-not-registered', 'warning', {
-                server: serverName,
-                message: 'Skill not found in pluginRegistry — returning abstain',
-            });
-            for (const proposal of proposals) {
-                votes.push({
-                    server: serverName,
-                    decision: 'abstain',
-                    confidence: 0.3,
-                    reasoning: `No plugin registered for ${serverName}`,
-                });
-            }
-            return votes;
-        }
+        const useInProcess = process.env.VERCEL === '1';
         for (const proposal of proposals) {
             try {
-                const result = await pluginRegistry.callSkill(serverName, {
-                    proposalTitle: proposal.title,
-                    proposalDescription: proposal.description,
-                    evidence: proposal.evidence || [],
-                    proposalType: proposal.type,
-                });
-                const text = result?.content?.[0]?.text || '';
+                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', 'plugin-skill-error', 'error', {
+                frameworkLogger.log('governance-service', 'skill-call-error', 'error', {
                     server: serverName,
                     proposal: proposal.title,
                     error: error instanceof Error ? error.message : String(error),
-                    mode: 'plugin-registry',
+                    mode: useInProcess ? 'in-process' : 'mcp',
                 });
                 votes.push({
                     server: serverName,
                     decision: 'abstain',
                     confidence: 0.3,
-                    reasoning: `Plugin skill ${serverName} failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    reasoning: `Call to ${serverName} failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
                 });
             }
         }
         return votes;
     }
-    async callExternalDynamo(proposals, requireExternal, context) {
+    async callExternalDynamo(proposals, requireExternal) {
         const results = [];
         const integration = getGovernanceIntegration();
         const integrationAvailable = integration?.isAvailable?.() === true;
@@ -234,19 +199,6 @@ export class GovernanceService {
             }
             return results;
         }
-        // Derive Dynamo source classification from internal proposal source
-        function toDynamoSource(s) {
-            if (s === 'metamorphosis')
-                return 'system';
-            if (s === 'manual')
-                return 'human';
-            if (s === 'inference' || s === 'reflection' || s === 'ci' || s === 'phase-planning')
-                return 'agent';
-            throw new Error(`proposal.source="${s}" is not recognized. ` +
-                'Must be "inference", "reflection", "manual", "ci", "phase-planning", or "metamorphosis".');
-        }
-        // Merge tags from context and per-proposal tags
-        const contextTags = context?.tags ?? [];
         // Integration is available — use it exclusively (no fallback)
         for (const proposal of proposals) {
             try {
@@ -263,11 +215,7 @@ export class GovernanceService {
                     source: 'recurring_pattern',
                     status: 'pending',
                 };
-                const dynamoSource = toDynamoSource(proposal.source);
-                const mergedTags = [...contextTags, ...(proposal.tags ?? [])];
-                // onChain: explicit context flag wins, otherwise true if tags include '0xray' (framework proposals), else false
-                const onChain = context?.onChain ?? mergedTags.includes('0xray');
-                const result = await integration.checkProposal(inferenceProposal, [], [], dynamoSource, mergedTags, onChain);
+                const result = await integration.checkProposal(inferenceProposal);
                 results.push([{
                         server: 'external-dynamo',
                         decision: result.vote === 'YES' ? 'approve' : result.vote === 'NO' ? 'reject' : 'needs_revision',
@@ -297,6 +245,13 @@ export class GovernanceService {
         }
         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.]+)/);
@@ -311,18 +266,9 @@ export class GovernanceService {
 }
 // Singleton for convenience
 let governanceServiceInstance = null;
-/**
- * Get the singleton GovernanceService instance.
- *
- * @deprecated Use `handleGovernRequest` from `src/nucleus/index.js` instead.
- * All callers should go through the nucleus surface. Direct use of
- * GovernanceService bypasses nucleus lifecycle, logging, and future
- * governance pipeline enhancements.
- */
 export function getGovernanceService() {
     if (!governanceServiceInstance) {
         governanceServiceInstance = new GovernanceService();
     }
     return governanceServiceInstance;
 }
-//# sourceMappingURL=governance-service.js.map

package/dist/governance/governance-types.js

@@ -3,25 +3,9 @@
  * These types are used by the GovernanceService, Governance MCP,
  * and all integrations.
  */
-export function normalizeProposalWithSource(input) {
-    if (!input.source) {
-        throw new Error('All proposals must identify their source. ' +
-            'Set source to "inference", "reflection", "manual", "ci", "phase-planning", or "metamorphosis".');
-    }
-    const validSources = ['inference', 'reflection', 'manual', 'ci', 'phase-planning', 'metamorphosis'];
-    if (!validSources.includes(input.source)) {
-        throw new Error(`Invalid source "${input.source}". Must be one of: ${validSources.join(', ')}`);
-    }
+export function normalizeProposalWithSource(proposal) {
     return {
-        id: input.id || `prop-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-        type: input.type,
-        title: input.title,
-        description: input.description,
-        evidence: input.evidence || [],
-        source: input.source,
-        confidence: input.confidence ?? 0.8,
-        ...(input.metadata !== undefined ? { metadata: input.metadata } : {}),
-        ...(input.tags !== undefined ? { tags: input.tags } : {}),
+        ...proposal,
+        source: proposal.source || 'manual',
     };
 }
-//# sourceMappingURL=governance-types.js.map

package/dist/governance/llm-governance-provider.js

@@ -0,0 +1,210 @@
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { frameworkLogger } from "../core/framework-logger.js";
+const XAI_ENDPOINT = "https://api.x.ai/v1/chat/completions";
+const XAI_MODEL = "grok-4.3";
+const ROLE_PROMPTS = {
+    "code-review": `You are a senior code reviewer on a governance committee for a software project. Analyze the following proposal from a code quality, maintainability, readability, and engineering best practices perspective.
+
+Consider:
+- Does the proposal improve or degrade code quality?
+- Does it follow established design patterns?
+- Does it introduce technical debt?
+- Are there potential regressions or edge cases?
+
+Respond with a structured vote in exactly this format:
+DECISION: approve|reject|abstain
+CONFIDENCE: <0.0-1.0>
+REASONING: <2-4 sentence analysis of the proposal's code quality implications>`,
+    "security-audit": `You are a senior security engineer on a governance committee for a software project. Analyze the following proposal from a security, threat modeling, and compliance perspective.
+
+Consider:
+- Does the proposal introduce new attack surface?
+- Does it handle authentication, authorization, and data protection properly?
+- Are there compliance implications (GDPR, SOC2, PCI-DSS, etc.)?
+- Does it follow security best practices (input validation, least privilege, defense in depth)?
+
+Respond with a structured vote in exactly this format:
+DECISION: approve|reject|abstain
+CONFIDENCE: <0.0-1.0>
+REASONING: <2-4 sentence analysis of the proposal's security implications>`,
+    "researcher": `You are a senior architect and researcher on a governance committee for a software project. Analyze the following proposal from a codebase-wide architectural and historical perspective.
+
+Consider:
+- Does the proposal align with the project's observed architecture patterns?
+- Does it integrate well with existing systems and data flows?
+- Does it address recurring problems observed in the project history?
+- What is the broader impact on the codebase ecosystem?
+
+Respond with a structured vote in exactly this format:
+DECISION: approve|reject|abstain
+CONFIDENCE: <0.0-1.0>
+REASONING: <2-4 sentence analysis of the proposal's broader project impact>`,
+};
+function readHermesOAuthToken() {
+    try {
+        const authPath = join(homedir(), ".hermes", "auth.json");
+        if (!existsSync(authPath))
+            return null;
+        const raw = readFileSync(authPath, "utf-8");
+        const data = JSON.parse(raw);
+        let entry;
+        if (data && typeof data === "object" && !Array.isArray(data)) {
+            entry = data["xai-oauth"];
+            if (!entry?.access_token && data.access_token) {
+                entry = data;
+            }
+        }
+        if (!entry?.access_token && Array.isArray(data)) {
+            entry = data.find((e) => e.provider === "xai-oauth" || !!e.access_token);
+        }
+        if (!entry?.access_token)
+            return null;
+        if (entry.expires_at && Date.now() / 1000 > entry.expires_at) {
+            frameworkLogger.log("llm-governance", "hermes-token-expired", "warning", { expiresAt: entry.expires_at });
+            return null;
+        }
+        return entry.access_token;
+    }
+    catch (err) {
+        frameworkLogger.log("llm-governance", "hermes-auth-read-error", "warning", { error: String(err) });
+        return null;
+    }
+}
+function getConfig() {
+    const directEndpoint = process.env.XRAY_LLM_ENDPOINT ||
+        process.env.XRAY_GOVERNANCE_LLM_ENDPOINT ||
+        "";
+    const directApiKey = process.env.XRAY_LLM_API_KEY ||
+        process.env.XRAY_GOVERNANCE_LLM_API_KEY ||
+        "";
+    const directModel = process.env.XRAY_LLM_MODEL ||
+        process.env.XRAY_GOVERNANCE_LLM_MODEL ||
+        "gpt-4o";
+    const directEnabled = process.env.XRAY_GOVERNANCE_LLM_ENABLED === "true" ||
+        process.env.XRAY_LLM_ENABLED === "true";
+    if (directEnabled && directEndpoint && directApiKey) {
+        return { endpoint: directEndpoint, apiKey: directApiKey, model: directModel };
+    }
+    const hermesToken = readHermesOAuthToken();
+    if (hermesToken) {
+        frameworkLogger.log("llm-governance", "using-hermes-oauth", "info", { provider: "xai-oauth", endpoint: XAI_ENDPOINT, model: XAI_MODEL });
+        return { endpoint: XAI_ENDPOINT, apiKey: hermesToken, model: XAI_MODEL };
+    }
+    return null;
+}
+function parseVote(text) {
+    const decisionMatch = text.match(/DECISION:\s*(approve|reject|abstain)/i);
+    const confidenceMatch = text.match(/CONFIDENCE:\s*([0-9.]+)/i);
+    const reasoningMatch = text.match(/REASONING:\s*(.+)/is);
+    if (!decisionMatch || !decisionMatch[1])
+        return null;
+    const rawConfidence = confidenceMatch?.[1];
+    const confidence = rawConfidence ? parseFloat(rawConfidence) : 0.5;
+    return {
+        decision: decisionMatch[1].toLowerCase(),
+        confidence: isNaN(confidence) ? 0.5 : Math.min(1, Math.max(0, confidence)),
+        reasoning: reasoningMatch?.[1]?.trim() || "No reasoning provided",
+    };
+}
+export async function tryLLMGovernance(role, proposalTitle, proposalDescription, evidence, proposalType) {
+    const config = getConfig();
+    if (!config) {
+        return null;
+    }
+    const systemPrompt = ROLE_PROMPTS[role];
+    const userMessage = `## Proposal
+
+**Title:** ${proposalTitle}
+
+**Description:** ${proposalDescription}
+
+**Type:** ${proposalType}
+
+${evidence.length > 0 ? `**Supporting Evidence:**\n${evidence.map((e, i) => `${i + 1}. ${e}`).join("\n")}` : ""}
+
+---
+
+Please provide your structured vote.`;
+    try {
+        const response = await fetch(config.endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: config.model,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userMessage },
+                ],
+                temperature: 0.3,
+                max_tokens: 500,
+            }),
+        });
+        if (!response.ok) {
+            frameworkLogger.log("llm-governance", "api-call", "error", {
+                status: response.status,
+                statusText: response.statusText,
+                role,
+            });
+            return null;
+        }
+        const data = (await response.json());
+        const choices = data?.choices;
+        const message = choices?.[0]?.message;
+        const content = message?.content;
+        if (!content) {
+            frameworkLogger.log("llm-governance", "parse", "warning", {
+                issue: "missing content in response",
+                role,
+            });
+            return null;
+        }
+        const vote = parseVote(content);
+        if (!vote) {
+            frameworkLogger.log("llm-governance", "parse", "warning", {
+                issue: "unparseable response",
+                snippet: content.slice(0, 200),
+                role,
+            });
+            return null;
+        }
+        frameworkLogger.log("llm-governance", "vote", "success", {
+            role,
+            decision: vote.decision,
+            confidence: vote.confidence,
+        });
+        return vote;
+    }
+    catch (error) {
+        frameworkLogger.log("llm-governance", "error", "error", {
+            error: String(error),
+            role,
+        });
+        return null;
+    }
+}
+export function checkHermesOAuthStatus() {
+    const config = getConfig();
+    if (!config) {
+        const hermesPath = join(homedir(), ".hermes", "auth.json");
+        if (existsSync(hermesPath)) {
+            return {
+                configured: false,
+                error: "Hermes auth file found but no valid xai-oauth token. Run: hermes auth add xai-oauth --no-browser",
+            };
+        }
+        return {
+            configured: false,
+            error: "No Hermes auth file found (~/.hermes/auth.json). Install Hermes and run: hermes auth add xai-oauth --no-browser",
+        };
+    }
+    return {
+        configured: true,
+        endpoint: XAI_ENDPOINT,
+        model: XAI_MODEL,
+    };
+}