0xray 2.1.4 → 2.2.1

package/dist/inference/inference-cycle.js

@@ -2,31 +2,20 @@ import * as fs from "fs";
 import * as path from "path";
 import { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
 import { DeployVerifier } from "./deploy-verifier.js";
-import { VotingCoordinator } from "../delegation/voting-coordinator.js";
 import { XrayStateManager } from "../state/state-manager.js";
 import { frameworkLogger } from "../core/framework-logger.js";
-import { getGovernanceIntegration } from "../integrations/governance/index.js";
 import { featuresConfigLoader } from "../core/features-config.js";
 import { mcpClientManager } from "../mcps/mcp-client.js";
 import { getConfigDir } from "../core/config-paths.js";
 import { invokeViaOpencode as invokeOpencodeFromEngine } from "../execution/opencode-cli-invoker.js";
 import { ProposalApplier } from "../execution/proposal-applier.js";
-const CYCLE_STATE_FILE = "inference-cycle-state.json";
-const CYCLE_HISTORY_FILE = "inference-cycle-history.json";
-const GOVERNANCE_AGENTS = {
-    // Real individual knowledge-skill MCP servers (have analyze_proposal handlers)
-    fix: ["code-review", "security-audit", "researcher"],
-    refactor: ["code-review", "security-audit", "researcher"],
-    guard: ["code-review", "security-audit", "researcher"],
-    automate: ["code-review", "security-audit", "researcher"],
-    codify: ["code-review", "security-audit", "researcher"],
-};
+import { handleGovernRequest } from "../nucleus/govern-http.js";
+const CONSOLIDATED_STATE_FILE = "inference-state.json";
 export class InferenceCycle {
     // Singleton registry + state management to prevent recursive agent spawning
     static instances = new Map();
     static reEntryLock = false;
     static governedProposalIds = new Set();
-    static votingCoordinator = null;
     static getInstance(projectRoot, options) {
         const root = path.resolve(projectRoot || process.cwd());
         if (!InferenceCycle.instances.has(root)) {
@@ -38,7 +27,6 @@ export class InferenceCycle {
         InferenceCycle.instances.clear();
         InferenceCycle.reEntryLock = false;
         InferenceCycle.governedProposalIds.clear();
-        InferenceCycle.votingCoordinator = null;
     }
     inferenceDir;
     stateDir;
@@ -98,7 +86,6 @@ export class InferenceCycle {
                 InferenceCycle.governedProposalIds.add(p.id);
             this.setPhase("complete");
             this.saveCycleState(cycleId);
-            this.saveGovernanceState(this.getCoordinator());
             const result = this.buildResult(cycleId, true, "external proposals", startTime, undefined, proposals, votes);
             this.appendHistory(result);
             frameworkLogger.log("inference-cycle", "external-governance-complete", "info", {
@@ -124,7 +111,7 @@ export class InferenceCycle {
         const cycleId = `cycle-${Date.now()}`;
         try {
             this.setPhase("collecting");
-            const lastCycleFile = path.join(this.stateDir, CYCLE_STATE_FILE);
+            const lastCycleFile = path.join(this.stateDir, CONSOLIDATED_STATE_FILE);
             const threshold = this.options.force ? { trigger: true, reason: "force flag set" } : shouldTriggerCycle(this.inferenceDir, lastCycleFile);
             if (!threshold.trigger) {
                 this.setPhase("idle");
@@ -188,7 +175,6 @@ export class InferenceCycle {
                 }
                 this.setPhase("complete");
                 this.saveCycleState(cycleId);
-                this.saveGovernanceState(this.getCoordinator());
                 this.appendHistory(this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals, votes, deployResult));
                 return this.buildResult(cycleId, true, threshold.reason, startTime, corpus, proposals, votes, deployResult);
             }
@@ -270,19 +256,8 @@ export class InferenceCycle {
         this.adjustConfidenceFromHistory(proposals);
         proposals.sort((a, b) => b.confidence - a.confidence);
     }
-    getCoordinator() {
-        if (!InferenceCycle.votingCoordinator) {
-            const stateManager = this.getGovernanceStateManager();
-            InferenceCycle.votingCoordinator = new VotingCoordinator(stateManager);
-        }
-        return InferenceCycle.votingCoordinator;
-    }
     async applyProposals(proposals) {
-        const applier = new ProposalApplier(this.projectRoot, async (p) => this.applyProposalWork(p), async (p, prUrl) => {
-            if (this.options.skipResearcherReview)
-                return "go";
-            return this.researcherReview(p, prUrl);
-        });
+        const applier = new ProposalApplier(this.projectRoot);
         const results = await applier.applyProposals(proposals);
         for (const r of results) {
             const p = proposals.find(pr => pr.id === r.proposalId);
@@ -453,9 +428,36 @@ Respond with EXACTLY one of:
         }
     }
     async governProposals(proposals) {
-        // Primary path: Use the first-class Governance MCP (real skill servers + required Dynamo)
-        // This is the clean, centralized path (governance.server.ts + GovernanceService)
-        const useGovernanceMcp = (process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true' ||
+        // v3: Primary path through the nucleus kernel (handleGovernRequest)
+        // This gives ALL proposals the same contract: 3-agent + Dynamo governance,
+        // metamorphosis scoring, dynamic skills, and structured logging.
+        // The MCP governance server remains the standard external surface; this is the
+        // internal uniform path that the MCP server also delegates to.
+        try {
+            const governanceResponse = await this.governViaNucleus(proposals);
+            frameworkLogger.log("inference-cycle", "governance-nucleus-success", "info", {
+                proposalCount: proposals.length,
+                overall: governanceResponse.overallDecision,
+            });
+            return this.convertNucleusResponse(governanceResponse, proposals);
+        }
+        catch (err) {
+            frameworkLogger.log("inference-cycle", "governance-nucleus-failed", "warning", {
+                error: err instanceof Error ? err.message : String(err),
+                stack: err instanceof Error ? err.stack : undefined,
+            });
+            // In forced pure MCP mode we must not silently fall back
+            if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
+                throw err;
+            }
+            // Fallback: try the Governance MCP directly (the standard external surface)
+            frameworkLogger.log("inference-cycle", "governance-mcp-fallback", "warning", {
+                message: "Nucleus path failed; falling back to Governance MCP.",
+                originalError: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Fallback: MCP governance server
+        const useGovernanceMcp = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true' ||
             this.isGovernanceMcpPreferred();
         if (useGovernanceMcp) {
             try {
@@ -477,35 +479,79 @@ Respond with EXACTLY one of:
                 ]);
                 const text = result?.content?.[0]?.text || "";
                 const parsed = this.parseGovernanceMcpResponse(text, proposals);
-                frameworkLogger.log("inference-cycle", "governance-mcp-primary-path", "info", {
+                frameworkLogger.log("inference-cycle", "governance-mcp-fallback-success", "info", {
                     proposalCount: proposals.length,
                     overall: parsed.overallDecision,
                 });
                 return parsed.votes;
             }
             catch (err) {
-                frameworkLogger.log("inference-cycle", "governance-mcp-failed", "error", {
+                frameworkLogger.log("inference-cycle", "governance-mcp-fallback-failed", "error", {
                     error: err instanceof Error ? err.message : String(err),
                 });
-                // In forced pure MCP mode we must not silently fall back
-                if (process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true') {
-                    throw err;
-                }
-                // In normal mode, fall back to legacy path with deprecation warning.
-                // The legacy path will be removed once all consumers have migrated to the Governance MCP + Dynamo Solar SSOT model.
-                frameworkLogger.log("inference-cycle", "governance-legacy-fallback", "warning", {
-                    message: "Falling back to legacy governance path. This path is deprecated and will be removed in a future version.",
-                });
             }
         }
-        // Legacy internal path (deprecated)
-        const internalVotes = await this.governProposalsInternal(proposals);
-        const governanceIntegration = getGovernanceIntegration();
-        if (governanceIntegration?.isAvailable()) {
-            const externalVotes = await this.governProposalsExternal(proposals);
-            return this.mergeGovernanceVotes(internalVotes, externalVotes, proposals);
-        }
-        return internalVotes;
+        throw new Error("All governance paths exhausted: nucleus and MCP fallback both failed");
+    }
+    /**
+     * Map InferenceProposal.source to GovernanceProposal.source.
+     * Inference-specific sources (recurring_problem, recurring_pattern, wrong_turn)
+     * all normalize to 'inference'. Future tuning/mod-specific sources can be added here.
+     */
+    static SOURCE_MAP = {
+        'recurring_problem': 'inference',
+        'recurring_pattern': 'inference',
+        'wrong_turn': 'inference',
+    };
+    /**
+     * Convert InferenceProposal[] to GovernanceRequest and route through
+     * the nucleus kernel (handleGovernRequest). This is the v3 uniform path.
+     */
+    async governViaNucleus(proposals) {
+        const governanceRequest = {
+            proposals: proposals.map(p => ({
+                id: p.id,
+                type: p.type,
+                title: p.title,
+                description: p.description,
+                evidence: p.evidence,
+                source: InferenceCycle.SOURCE_MAP[p.source] || 'inference',
+                confidence: p.confidence,
+            })),
+            context: {
+                project: 'xray',
+                phase: 'inference-cycle',
+                source: 'inference-cycle',
+            },
+            options: {
+                requireExternalDynamo: true,
+            },
+        };
+        return handleGovernRequest(governanceRequest);
+    }
+    /**
+     * Convert a GovernanceResponse (nucleus kernel format) back to the
+     * InferenceCycleResult["votes"] format that the rest of the cycle expects.
+     */
+    convertNucleusResponse(response, proposals) {
+        return proposals.map((p, i) => {
+            const result = response.results[i];
+            if (!result) {
+                return {
+                    proposalId: p.id,
+                    decision: 'reject',
+                    confidence: 0,
+                    details: ['nucleus: no result returned'],
+                };
+            }
+            const decision = result.finalDecision === 'approve' ? 'approve' : result.finalDecision === 'reject' ? 'reject' : 'abstain';
+            return {
+                proposalId: p.id,
+                decision,
+                confidence: result.averageConfidence,
+                details: result.votes?.map((v) => `${v.server || v.agentName || 'agent'}: ${v.decision} (${v.confidence})`) || [result.reasoningSummary],
+            };
+        });
     }
     isGovernanceMcpPreferred() {
         try {
@@ -547,230 +593,6 @@ Respond with EXACTLY one of:
             return { votes, overallDecision: "needs_revision" };
         }
     }
-    /**
-     * Oscillator 1: Internal VotingCoordinator-based governance
-     */
-    async governProposalsInternal(proposals) {
-        // Defensive: if pure MCP mode is forced, use individual skill servers only
-        if ((process.env.XRAY_FORCE_MCP_GOVERNANCE) === 'true') {
-            return this.governProposalsWithIndividualSkills(proposals);
-        }
-        const coordinator = this.getCoordinator();
-        const sessionId = `inference-governance-${Date.now()}`;
-        const results = [];
-        const todoPrompt = [
-            `Vote on ${proposals.length} inference proposals. Output EXACTLY one PROPOSAL block per proposal.`,
-            ``,
-            `FORMAT (exact, no extra text, no markdown):`,
-            `PROPOSAL: <number>`,
-            `  AGENT: architect`,
-            `  DECISION: approve|reject|abstain`,
-            `  CONFIDENCE: 0.XX`,
-            `  REASONING: <brief reason>`,
-            ``,
-            `Example:`,
-            `PROPOSAL: 1`,
-            `  AGENT: architect`,
-            `  DECISION: approve`,
-            `  CONFIDENCE: 0.85`,
-            `  REASONING: Cleanup reduces maintenance burden`,
-            ``,
-            `PROPOSALS:`,
-        ];
-        for (let i = 0; i < proposals.length; i++) {
-            const p = proposals[i];
-            todoPrompt.push(`${i + 1}. [${p.type}] "${p.title}"`);
-        }
-        try {
-            const jsonOutput = await this.invokeAgentInternal("architect", todoPrompt.join("\n"));
-            const allVotes = this.parseSubagentVotes(jsonOutput, proposals);
-            for (const proposal of proposals) {
-                const agents = GOVERNANCE_AGENTS[proposal.type] ?? ["code-reviewer"];
-                const participants = ["architect", ...agents];
-                const voteId = await coordinator.initiateVoting(sessionId, proposal.title, proposal.description, participants, {
-                    complexity: Math.min(50, 10 + proposal.evidence.length * 5 + (proposal.confidence > 0.8 ? 10 : 0)),
-                    riskLevel: proposal.type === "fix" ? "low" : proposal.type === "guard" ? "high" : "medium",
-                    hasSecurityConcerns: proposal.type === "guard" || proposal.type === "fix",
-                    hasArchitecturalImpact: proposal.type === "codify" || proposal.type === "automate",
-                    participantCount: participants.length,
-                });
-                const proposalVotes = allVotes.filter((v) => v.proposalId === proposal.id);
-                for (const v of proposalVotes) {
-                    coordinator.submitVote(voteId, v.agentName, v.decision, v.confidence, v.reasoning);
-                }
-                const resolved = coordinator.resolveVoting(voteId);
-                if (resolved) {
-                    results.push({
-                        proposalId: proposal.id,
-                        decision: resolved.decision === "approve" ? "approve" : "reject",
-                        confidence: resolved.confidence,
-                        details: resolved.details?.map((d) => `${d.agentName}: vote=${d.vote}, weight=${d.weight.toFixed(2)}`) || [],
-                    });
-                    if (resolved.details) {
-                        for (const detail of resolved.details) {
-                            this.getCoordinator().getAggregator().updateAgentPerformance(detail.agentName, resolved.decision, detail.vote, detail.vote === resolved.decision, proposal.confidence);
-                        }
-                    }
-                }
-                else {
-                    results.push(this.rejectNoQuorum(proposal, "agents did not vote (no quorum)"));
-                }
-            }
-        }
-        catch (error) {
-            frameworkLogger.log("inference-cycle", "architect-governance-failed", "error", { error: String(error) });
-            for (const proposal of proposals) {
-                results.push(this.rejectNoQuorum(proposal, `agent invocation failed: ${error instanceof Error ? error.message : String(error)}`));
-            }
-        }
-        const metrics = coordinator.getMetrics();
-        frameworkLogger.log("inference-cycle", "governance-metrics", "info", {
-            totalVotes: metrics.totalVotes,
-            avgConfidence: metrics.averageConfidence.toFixed(2),
-            strategyUsage: metrics.strategyUsage,
-        });
-        return results;
-    }
-    /**
-     * Pure individual knowledge-skill MCP path for governance.
-     * Used when XRAY_FORCE_MCP_GOVERNANCE=true.
-     * Each proposal is evaluated directly by the relevant skill servers using analyze_proposal.
-     */
-    async governProposalsWithIndividualSkills(proposals) {
-        const results = [];
-        const GOVERNANCE_AGENTS = {
-            fix: ["code-review", "security-audit", "researcher"],
-            refactor: ["code-review", "security-audit", "researcher"],
-            guard: ["code-review", "security-audit", "researcher"],
-            automate: ["code-review", "security-audit", "researcher"],
-            codify: ["code-review", "security-audit", "researcher"],
-        };
-        for (const proposal of proposals) {
-            const agents = GOVERNANCE_AGENTS[proposal.type] ?? ["code-review", "security-audit"];
-            const skillVotes = [];
-            for (const agent of agents) {
-                try {
-                    const skillResult = await mcpClientManager.callServerTool(agent, "analyze_proposal", {
-                        proposalTitle: proposal.title,
-                        proposalDescription: proposal.description,
-                        evidence: proposal.evidence,
-                        proposalType: proposal.type,
-                    });
-                    let structured = "";
-                    const contents = skillResult?.content || [];
-                    for (const c of contents) {
-                        if (c?.text && c.text.includes("DECISION:")) {
-                            structured = c.text.trim();
-                            break;
-                        }
-                    }
-                    if (!structured) {
-                        const full = JSON.stringify(skillResult);
-                        const m = full.match(/DECISION:\s*(approve|reject|abstain)[\s\S]{0,300}?REASONING:[^\n"]*/i);
-                        if (m)
-                            structured = m[0].trim();
-                    }
-                    skillVotes.push({
-                        agent,
-                        toolUsed: "analyze_proposal",
-                        rawResponse: structured || JSON.stringify(skillResult),
-                        structuredVote: structured || null,
-                    });
-                }
-                catch (err) {
-                    skillVotes.push({
-                        agent,
-                        toolUsed: "analyze_proposal",
-                        rawResponse: `error: ${err}`,
-                        structuredVote: null,
-                    });
-                }
-            }
-            const approves = skillVotes.filter((v) => v.structuredVote && v.structuredVote.includes("DECISION: approve")).length;
-            const rejects = skillVotes.filter((v) => v.structuredVote && v.structuredVote.includes("DECISION: reject")).length;
-            const decision = approves > rejects ? "approve" : (rejects > approves ? "reject" : "abstain");
-            let avgConf = 0.75;
-            const confMatches = skillVotes.map((v) => {
-                if (!v.structuredVote)
-                    return 0.75;
-                const m = v.structuredVote.match(/CONFIDENCE:\s*([0-9.]+)/);
-                return m ? parseFloat(m[1]) : 0.75;
-            });
-            if (confMatches.length > 0)
-                avgConf = confMatches.reduce((a, b) => a + b, 0) / confMatches.length;
-            results.push({
-                proposalId: proposal.id,
-                decision: decision,
-                confidence: Math.round(avgConf * 100) / 100,
-                details: skillVotes.map((v) => `${v.agent}: ${v.structuredVote?.split('\n')[0] || 'no structured vote'}`),
-            });
-        }
-        return results;
-    }
-    /**
-     * Merge internal and external governance votes.
-     * A proposal passes both oscillators — must be approved by internal AND external.
-     */
-    mergeGovernanceVotes(internalVotes, externalVotes, proposals) {
-        const merged = [];
-        for (const proposal of proposals) {
-            const internal = internalVotes.find((v) => v.proposalId === proposal.id);
-            const external = externalVotes.find((v) => v.proposalId === proposal.id);
-            if (!internal) {
-                merged.push(this.rejectNoQuorum(proposal, "internal governance vote missing"));
-                continue;
-            }
-            const internalApproved = internal.decision === "approve";
-            const externalApproved = external?.decision === "approve";
-            const bothApproved = internalApproved && (!external || externalApproved);
-            merged.push({
-                proposalId: proposal.id,
-                decision: bothApproved ? "approve" : "reject",
-                confidence: internal.confidence * (external ? external.confidence : 1.0),
-                details: [
-                    ...internal.details,
-                    ...(external ? [`External governance: ${external.decision} (conf: ${external.confidence.toFixed(2)})`, ...external.details] : []),
-                ],
-            });
-        }
-        return merged;
-    }
-    // Removed: buildOrchestratorGovernancePrompt (replaced by inline TODO prompt in governProposals)
-    /**
-     * Govern proposals using external chrono-warp-drive Dynamo endpoint
-     */
-    async governProposalsExternal(proposals) {
-        const governanceIntegration = getGovernanceIntegration();
-        if (!governanceIntegration) {
-            throw new Error("Governance integration not available");
-        }
-        // Build agent reviews from proposal evidence
-        const agentReviews = proposals.flatMap((p) => p.evidence.slice(0, 2).map((e) => `[${p.type}] ${e}`));
-        try {
-            const batchResult = await governanceIntegration.checkProposals(proposals, agentReviews, []);
-            const votes = batchResult.results.map((result) => ({
-                proposalId: result.governanceResponse.proposalId,
-                decision: result.vote.toLowerCase() === "yes" ? "approve" : "reject",
-                confidence: result.governanceResponse.confidence,
-                details: [
-                    `Governance: ${result.governanceResponse.recommendation}`,
-                    `Isotope: ${result.governanceResponse.governanceIsotopeId}`,
-                    ...result.governanceResponse.reasons.slice(0, 2),
-                ],
-            }));
-            frameworkLogger.log("inference-cycle", "external-governance-complete", "info", {
-                proposalCount: proposals.length,
-                passedCount: batchResult.results.filter((r) => r.passed).length,
-            });
-            return votes;
-        }
-        catch (error) {
-            frameworkLogger.log("inference-cycle", "external-governance-failed", "error", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return proposals.map((p) => this.rejectNoQuorum(p, "external governance endpoint failed"));
-        }
-    }
     async invokeAgentInternal(agentName, prompt) {
         frameworkLogger.log("inference-cycle", "invoke-agent-internal", "info", {
             agentName,
@@ -921,13 +743,15 @@ Respond with EXACTLY one of:
         if (!fs.existsSync(this.stateDir)) {
             fs.mkdirSync(this.stateDir, { recursive: true });
         }
-        const stateFile = path.join(this.stateDir, "governance-state.json");
+        const statePath = path.join(this.stateDir, CONSOLIDATED_STATE_FILE);
         const stateManager = new XrayStateManager();
-        if (fs.existsSync(stateFile)) {
+        if (fs.existsSync(statePath)) {
             try {
-                const data = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
-                for (const [key, value] of Object.entries(data)) {
-                    stateManager.set(key, value);
+                const data = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+                if (data.governanceState) {
+                    for (const [key, value] of Object.entries(data.governanceState)) {
+                        stateManager.set(key, value);
+                    }
                 }
             }
             catch {
@@ -936,26 +760,6 @@ Respond with EXACTLY one of:
         }
         return stateManager;
     }
-    saveGovernanceState(coordinator) {
-        const stateFile = path.join(this.stateDir, "governance-state.json");
-        try {
-            // Export the coordinator's internal state (voting history, metrics, etc.)
-            const history = coordinator.getVotingHistory();
-            const metrics = coordinator.getMetrics();
-            const exportData = {
-                votingHistory: history,
-                metrics,
-                exportedAt: new Date().toISOString(),
-            };
-            if (!fs.existsSync(this.stateDir)) {
-                fs.mkdirSync(this.stateDir, { recursive: true });
-            }
-            fs.writeFileSync(stateFile, JSON.stringify(exportData, null, 2));
-        }
-        catch (error) {
-            frameworkLogger.log("inference-cycle", "governance-state-save-failed", "warning", { error: String(error) });
-        }
-    }
     extractTextFromNdjson(output) {
         const texts = [];
         for (const line of output.split("\n")) {
@@ -975,26 +779,9 @@ Respond with EXACTLY one of:
         return texts.join("\n").trim();
     }
     resolveOpencodeRoot() {
-        // Use the provider-agnostic config path resolver (prefers .xray/, falls back to .opencode/xray/)
+        // Use the provider-agnostic config path resolver (prefers .xray/ over legacy .opencode)
         const configDir = getConfigDir(this.projectRoot);
-        // If we resolved to a .xray or custom dir, use its parent as the "root"
-        if (configDir.includes(".xray") || configDir.includes("xray")) {
-            return path.dirname(configDir);
-        }
-        // Legacy fallback
-        let dir = this.projectRoot;
-        for (let i = 0; i < 10; i++) {
-            if (fs.existsSync(path.join(dir, ".opencode")))
-                return dir;
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-        const cwd = process.cwd();
-        if (fs.existsSync(path.join(cwd, ".opencode")))
-            return cwd;
-        return this.projectRoot;
+        return path.dirname(configDir);
     }
     rejectNoQuorum(proposal, reason) {
         return {
@@ -1062,37 +849,35 @@ Respond with EXACTLY one of:
         if (!fs.existsSync(this.stateDir)) {
             fs.mkdirSync(this.stateDir, { recursive: true });
         }
-        fs.writeFileSync(path.join(this.stateDir, CYCLE_STATE_FILE), JSON.stringify({
+        const statePath = path.join(this.stateDir, CONSOLIDATED_STATE_FILE);
+        const existing = fs.existsSync(statePath) ? JSON.parse(fs.readFileSync(statePath, "utf-8")) : {};
+        existing.cycleState = {
             cycleId,
             completedAt: new Date().toISOString(),
             phase: this.phase,
-        }));
+        };
+        fs.writeFileSync(statePath, JSON.stringify(existing, null, 2));
     }
     appendHistory(result) {
         if (!fs.existsSync(this.stateDir)) {
             fs.mkdirSync(this.stateDir, { recursive: true });
         }
-        const historyPath = path.join(this.stateDir, CYCLE_HISTORY_FILE);
-        let history = [];
-        if (fs.existsSync(historyPath)) {
-            try {
-                history = JSON.parse(fs.readFileSync(historyPath, "utf-8"));
-            }
-            catch {
-                history = [];
-            }
-        }
+        const statePath = path.join(this.stateDir, CONSOLIDATED_STATE_FILE);
+        const existing = fs.existsSync(statePath) ? JSON.parse(fs.readFileSync(statePath, "utf-8")) : {};
+        let history = existing.history || [];
         history.push(result);
         if (history.length > 50)
             history = history.slice(-50);
-        fs.writeFileSync(historyPath, JSON.stringify(history, null, 2));
+        existing.history = history;
+        fs.writeFileSync(statePath, JSON.stringify(existing, null, 2));
     }
     loadHistory() {
-        const historyPath = path.join(this.stateDir, CYCLE_HISTORY_FILE);
-        if (!fs.existsSync(historyPath))
+        const statePath = path.join(this.stateDir, CONSOLIDATED_STATE_FILE);
+        if (!fs.existsSync(statePath))
             return [];
         try {
-            return JSON.parse(fs.readFileSync(historyPath, "utf-8"));
+            const data = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            return data.history || [];
         }
         catch {
             return [];

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

@@ -9,4 +9,3 @@
 export * from "./types.js";
 export * from "./Integration.js";
 export * from "./registry.js";
-export * from "./ExampleIntegration.js";

package/dist/integrations/base/index.js

@@ -12,5 +12,3 @@ export * from "./types.js";
 export * from "./Integration.js";
 // Re-export registry
 export * from "./registry.js";
-// Re-export example (for documentation/testing)
-export * from "./ExampleIntegration.js";

package/dist/integrations/grok/hooks/pre-tool-use.js

@@ -16,7 +16,7 @@ function findGovernanceCore() {
   const here = path.dirname(new URL(import.meta.url).pathname);
 
   // Priority: explicit dev root
-  const devRoot = ;
+  const devRoot = process.env.XRAY_DEV_ROOT || '';
   if (devRoot) {
     const devCandidate = path.resolve(devRoot, 'dist/governance/governance-core.js');
     if (fs.existsSync(devCandidate)) return devCandidate;
@@ -92,23 +92,9 @@ async function main() {
     let govDetails = null;
 
     if (corePath) {
-      try {
-        const core = await import(`file://${corePath}`);
-        if (typeof core.applyDecisionMatrix === 'function') {
-          const result = core.applyDecisionMatrix({
-            resonance,
-            isotopicRatio: resonance > 0.8 ? 0.96 : 0.7,
-            vortexVolume: 1_000_000,
-            historicalCoherence: 0.82,
-            solarActivity: 'active',
-          });
-          govDetails = result;
-          recommendation = result.recommendation || 'NEEDS_REVISION';
-          log(`Solar decision: ${recommendation} (resonance=${resonance.toFixed(2)})`);
-        }
-      } catch (e) {
-        log(`Governance core error: ${e.message}`);
-      }
+      // Governance core no longer exposes the legacy PHI/TAU matrix (purged in v3).
+      // Resonance is still derived locally for logging/decision notes.
+      log(`Using local resonance derivation (core matrix purged)`);
     } else {
       log('Governance core not located — using safe default');
     }

package/dist/integrations/hermes-agent/bridge.mjs

@@ -42,6 +42,15 @@ import { homedir } from "os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+// Redirect console methods to stderr so only the final JSON result goes to stdout.
+// Any dynamically loaded module using console.log/info/debug/warn will then
+// write diagnostic output to stderr, keeping stdout clean for JSON.parse.
+const _stderrWrite = process.stderr.write.bind(process.stderr);
+console.log = (...args) => { _stderrWrite(args.join(' ') + '\n'); };
+console.info = (...args) => { _stderrWrite('[INFO] ' + args.join(' ') + '\n'); };
+console.debug = (...args) => { _stderrWrite('[DEBUG] ' + args.join(' ') + '\n'); };
+console.warn = (...args) => { _stderrWrite('[WARN] ' + args.join(' ') + '\n'); };
+
 // ── Framework components (lazy-loaded) ───────────────────────
 let ProcessorManager = null;
 let StrRayStateManager = null;

package/dist/mcps/config/server-config-registry.js

@@ -160,7 +160,7 @@ export class ServerConfigRegistry {
         this.register({
             serverName: 'orchestrator',
             command: 'node',
-            args: [`${basePath}/orchestrator.server.js`],
+            args: [`${basePath}/orchestrator/server.js`],
             timeout: 60000,
         });
         // Estimation Validator Server