0xray 3.0.12 → 3.0.14

package/dist/execution/opencode-cli-invoker.js

@@ -5,6 +5,7 @@
  * Owned by Autonomous Engine. All direct child_process and agent spawn execution here.
  * InferenceCycle is pure sensing + proposal + governance orchestration.
  */
+import * as fs from "fs";
 import * as path from "path";
 import { execSync, spawn } from "child_process";
 import { frameworkLogger } from "../core/framework-logger.js";
@@ -15,6 +16,10 @@ import { getConfigDir } from "../core/config-paths.js";
 // Module-level cache for opencode availability check
 let opencodeAvailable = null;
 export async function invokeViaOpencode(agentName, prompt, projectRoot = process.cwd()) {
+    // In pure MCP mode we must never reach here
+    if (process.env.STRRAY_FORCE_MCP_GOVERNANCE === "true") {
+        throw new Error(`[PURE MCP] invokeViaOpencode called for "${agentName}" — this path is forbidden.`);
+    }
     // GATE: Centralized spawn gate — blocks all agent spawning by default
     spawnGate.assertAllowed("opencode-cli-invoker");
     // BLOCKED: Never spawn real opencode processes during tests — causes
@@ -54,8 +59,8 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
             await agentSpawnGovernor.failSpawn(trackingId, new Error("opencode CLI not available"));
         throw new Error("opencode CLI is not available in PATH");
     }
-    // Resolve project root via the canonical config-path resolver
-    const opencodeRoot = path.dirname(getConfigDir(projectRoot));
+    // Resolve the actual opencode project root (where .opencode/ config lives)
+    const opencodeRoot = resolveOpencodeRoot(projectRoot);
     frameworkLogger.log("inference-cycle", "opencode-spawn-start", "info", {
         agentName,
         trackingId,
@@ -74,7 +79,7 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
                 settled = true;
                 child.kill("SIGKILL");
                 if (trackingId) {
-                    agentSpawnGovernor.failSpawn(trackingId, new Error(`opencode ${agentName} timed out`)).catch((err) => frameworkLogger.log("opencode-cli-invoker", "spawn-governor-error", "error", { error: String(err) }));
+                    agentSpawnGovernor.failSpawn(trackingId, new Error(`opencode ${agentName} timed out`)).catch(() => { });
                 }
                 reject(new Error(`opencode ${agentName} timed out`));
             }
@@ -98,7 +103,7 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
             settled = true;
             if (code === 0 && stdout.trim()) {
                 if (trackingId) {
-                    await agentSpawnGovernor.completeSpawn(trackingId, true).catch((err) => frameworkLogger.log("opencode-cli-invoker", "spawn-governor-error", "error", { error: String(err) }));
+                    await agentSpawnGovernor.completeSpawn(trackingId, true).catch(() => { });
                 }
                 frameworkLogger.log("inference-cycle", "opencode-spawn-success", "info", { agentName, trackingId });
                 const textResponse = extractTextFromNdjson(stdout.trim());
@@ -112,7 +117,7 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
             else {
                 const error = new Error(`${agentName} exited ${code}`);
                 if (trackingId) {
-                    await agentSpawnGovernor.failSpawn(trackingId, error).catch((err) => frameworkLogger.log("opencode-cli-invoker", "spawn-governor-error", "error", { error: String(err) }));
+                    await agentSpawnGovernor.failSpawn(trackingId, error).catch(() => { });
                 }
                 frameworkLogger.log("inference-cycle", "opencode-spawn-failed", "error", { agentName, trackingId, code });
                 reject(error);
@@ -123,7 +128,7 @@ export async function invokeViaOpencode(agentName, prompt, projectRoot = process
             if (!settled) {
                 settled = true;
                 if (trackingId) {
-                    await agentSpawnGovernor.failSpawn(trackingId, err).catch((e) => frameworkLogger.log("opencode-cli-invoker", "spawn-governor-error", "error", { error: String(e) }));
+                    await agentSpawnGovernor.failSpawn(trackingId, err).catch(() => { });
                 }
                 frameworkLogger.log("inference-cycle", "opencode-spawn-error", "error", { agentName, trackingId, error: err.message });
                 reject(err);
@@ -149,8 +154,20 @@ function extractTextFromNdjson(output) {
     }
     return texts.join("\n").trim();
 }
+function resolveOpencodeRoot(projectRoot) {
+    const configDir = getConfigDir(projectRoot);
+    let dir = 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 projectRoot;
+}
 // OpenCode execution owned by Autonomous Engine (thin fallback).
-// Kept as a standalone execution helper — InferenceCycle calls this directly
-// via invokeOpencodeFromEngine import. The separation is clean: this file owns
-// child_process spawn + lifecycle; InferenceCycle owns sensing + governance.
-//# sourceMappingURL=opencode-cli-invoker.js.map

package/dist/execution/proposal-applier.js

@@ -1,10 +1,21 @@
 import * as fs from "fs";
 import * as path from "path";
+import { spawnSync } from "child_process";
 import { frameworkLogger } from "../core/framework-logger.js";
+function sanitizeGitArgument(s) {
+    if (!/^[a-zA-Z0-9 \-_.\/@]+$/.test(s)) {
+        throw new Error("Invalid git argument: contains disallowed characters");
+    }
+    return s;
+}
 export class ProposalApplier {
     projectRoot;
-    constructor(projectRoot = process.cwd()) {
+    codeChangeCallback;
+    reviewCallback;
+    constructor(projectRoot = process.cwd(), codeChangeCallback, reviewCallback) {
         this.projectRoot = projectRoot;
+        this.codeChangeCallback = codeChangeCallback;
+        this.reviewCallback = reviewCallback;
     }
     async applyProposals(proposals) {
         frameworkLogger.log("execution", "proposal-applier-start", "info", {
@@ -12,26 +23,112 @@ export class ProposalApplier {
         });
         const results = [];
         for (const proposal of proposals) {
-            if (proposal.type === "codify") {
-                results.push(this.applyCodification(proposal));
+            const result = await this.applyProposal(proposal);
+            results.push(result);
+        }
+        return results;
+    }
+    async applyProposal(p) {
+        frameworkLogger.log("execution", "apply-proposal", "info", {
+            proposalId: p.id,
+            type: p.type,
+        });
+        if (p.type === "codify") {
+            return this.applyCodification(p);
+        }
+        const branchName = `inference/${p.type}-${Date.now()}`;
+        const isGit = this.isInsideGitRepo();
+        try {
+            this.recordAppliedProposal(p);
+            const changedFiles = [
+                path.relative(this.projectRoot, this.getAppliedMarkerPath(p)),
+            ];
+            if (isGit) {
+                const branchR = spawnSync('git', ['checkout', '-b', branchName], { cwd: this.projectRoot, stdio: 'pipe' });
+                if (branchR.status !== 0) {
+                    throw new Error(`git checkout -b failed: ${(branchR.stderr || '').toString().trim()}`);
+                }
             }
-            else {
-                this.recordAppliedProposal(proposal);
-                const changedFiles = [
-                    path.relative(this.projectRoot, this.getAppliedMarkerPath(proposal)),
-                ];
-                results.push({
-                    proposalId: proposal.id,
-                    success: true,
-                    filesChanged: changedFiles,
-                    details: [
-                        "Proposal recorded by Autonomous Engine (ProposalApplier)",
-                        `type=${proposal.type}`,
-                    ],
-                });
+            if (this.codeChangeCallback) {
+                const changed = await this.codeChangeCallback(p);
+                if (!changed) {
+                    if (isGit) {
+                        spawnSync('git', ['checkout', 'master'], { cwd: this.projectRoot, stdio: 'pipe' });
+                        spawnSync('git', ['branch', '-D', branchName], { cwd: this.projectRoot, stdio: 'pipe' });
+                    }
+                    return {
+                        proposalId: p.id,
+                        success: false,
+                        error: "Code change returned false (no changes applied)",
+                    };
+                }
             }
+            if (isGit) {
+                const addR = spawnSync('git', ['add', '-A'], { cwd: this.projectRoot, stdio: 'pipe' });
+                if (addR.status !== 0) {
+                    throw new Error(`git add failed: ${(addR.stderr || '').toString().trim()}`);
+                }
+                const commitR = spawnSync('git', ['commit', '-m', p.title], { cwd: this.projectRoot, stdio: 'pipe' });
+                if (commitR.status !== 0) {
+                    throw new Error(`git commit failed: ${(commitR.stderr || '').toString().trim()}`);
+                }
+                const prUrl = this.createPR(p, branchName);
+                if (prUrl) {
+                    frameworkLogger.log("execution", "pr-created", "info", {
+                        prUrl,
+                        proposalId: p.id,
+                    });
+                }
+                if (this.reviewCallback && prUrl) {
+                    const review = await this.reviewCallback(p, prUrl);
+                    if (review === "no-go") {
+                        frameworkLogger.log("execution", "review-no-go", "warning", {
+                            proposalId: p.id,
+                            prUrl,
+                        });
+                        spawnSync('git', ['checkout', 'master'], { cwd: this.projectRoot, stdio: 'pipe' });
+                        spawnSync('git', ['branch', '-D', branchName], { cwd: this.projectRoot, stdio: 'pipe' });
+                        return {
+                            proposalId: p.id,
+                            success: false,
+                            error: "Researcher review rejected proposal",
+                        };
+                    }
+                }
+                spawnSync('git', ['checkout', 'master'], { cwd: this.projectRoot, stdio: 'pipe' });
+            }
+            return {
+                proposalId: p.id,
+                success: true,
+                filesChanged: changedFiles,
+                details: [
+                    "Proposal applied by Autonomous Engine (ProposalApplier)",
+                    isGit ? `branch=${branchName}` : "non-git (marker only)",
+                    `type=${p.type}`,
+                ],
+            };
+        }
+        catch (err) {
+            const errorMsg = err.message;
+            frameworkLogger.log("execution", "apply-proposal-error", "error", {
+                proposalId: p.id,
+                error: errorMsg,
+            });
+            if (isGit) {
+                try {
+                    spawnSync('git', ['checkout', 'master'], { cwd: this.projectRoot, stdio: 'pipe' });
+                    spawnSync('git', ['branch', '-D', branchName], { cwd: this.projectRoot, stdio: 'pipe' });
+                }
+                catch {
+                    // ignore cleanup
+                }
+            }
+            return {
+                proposalId: p.id,
+                success: false,
+                error: errorMsg,
+            };
         }
-        return results;
     }
     applyCodification(p) {
         try {
@@ -62,6 +159,19 @@ export class ProposalApplier {
             return { proposalId: p.id, success: false, error: errorMsg };
         }
     }
+    isInsideGitRepo() {
+        try {
+            const r = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
+                cwd: this.projectRoot,
+                stdio: 'pipe',
+                timeout: 2000,
+            });
+            return r.status === 0;
+        }
+        catch {
+            return false;
+        }
+    }
     getAppliedMarkerPath(p) {
         const appliedDir = path.join(this.projectRoot, "docs", "inference", "applied");
         if (!fs.existsSync(appliedDir)) {
@@ -96,5 +206,49 @@ export class ProposalApplier {
             module: "v2-refactor",
         });
     }
+    createPR(p, branchName) {
+        try {
+            sanitizeGitArgument(p.title);
+            sanitizeGitArgument(branchName);
+            const pushR = spawnSync('git', ['push', '-u', 'origin', branchName], {
+                cwd: this.projectRoot,
+                stdio: 'pipe',
+                timeout: 30000,
+            });
+            if (pushR.status !== 0) {
+                throw new Error(`git push failed: ${(pushR.stderr || '').toString().trim()}`);
+            }
+            const body = [
+                "## Inference Proposal (Autonomous Engine)",
+                "",
+                p.description,
+                "",
+                `**Type:** ${p.type}  **Confidence:** ${(p.confidence * 100).toFixed(0)}%`,
+                "",
+                "## Evidence",
+                p.evidence.slice(0, 5).join("\n"),
+                "",
+                "Executed by ProposalApplier (Engine-owned) — V2 Phase 1.",
+            ].join("\n");
+            const ghR = spawnSync('gh', ['pr', 'create', '--head', branchName, '--title', p.title, '--body', body], {
+                cwd: this.projectRoot,
+                encoding: 'utf-8',
+                stdio: 'pipe',
+                timeout: 30000,
+            });
+            if (ghR.status !== 0) {
+                throw new Error(`gh pr create failed: ${ghR.stderr || 'unknown error'}`);
+            }
+            return (ghR.stdout || '').trim();
+        }
+        catch (err) {
+            frameworkLogger.log("execution", "pr-create-failed", "warning", {
+                error: String(err),
+                proposalId: p.id,
+                module: "v2-refactor",
+            });
+            return "";
+        }
+    }
 }
-//# sourceMappingURL=proposal-applier.js.map
+export const proposalApplier = new ProposalApplier();

package/dist/governance/codex-policy.service.js

@@ -1,15 +1,32 @@
 /**
  * CodexPolicyService
  *
- * Governance-owned Single Source of Truth (SSOT) for Codex / policy loading.
+ * The initial Governance-owned Single Source of Truth (SSOT) for Codex / policy loading.
+ * This is the V2-P1-S02-REAL first concrete migration slice.
  *
- * Role: External Governance owns "what the policy is".
- * Consumers (enforcers, injectors, formatters, MCPs, plugins) should ask here
- * instead of direct fs reads or scattered loaders.
+ * Role (per 3-subsystem architecture + researcher mapping):
+ *   - External Governance (Decision Layer & SSOT) owns "what the policy is".
+ *   - All consumers (enforcement CodexLoader, injectors, formatters, MCP surfaces, plugins)
+ *     will eventually ask here instead of performing direct fs reads.
  *
- * Provides read-only ActiveCodexSnapshot and term count.
- * Uses canonical resolveCodexPath.
- * Full frameworkLogger on all paths.
+ * Current scope (minimal safe skeleton):
+ *   - Read-only query surface.
+ *   - Uses canonical resolveCodexPath + async file load (no duplication of resolution logic).
+ *   - Returns ActiveCodexSnapshot compatible with the existing get_active_codex MCP tool.
+ *   - Provides getTermCount() with safe 60-term fallback (preserves prior behavior of bypasses).
+ *   - Full frameworkLogger discipline on every load/decision/error.
+ *   - No caching in v1 skeleton (additive later); no mutation; no enforcement.
+ *
+ * First wired consumer: src/mcps/enforcer-tools.server.ts (getCodexTermCount bypass removed;
+ * now delegates through this service).
+ *
+ * Next recommended slices (documented in researcher mapping append):
+ *   - Wire governance.server.ts handleGetActiveCodex to delegate (remove its direct read).
+ *   - S02b/S02c follow-ups: update codex-injector, context-loader, codex-formatter, plugin.
+ *   - Make CodexLoader delegate its raw data load here, then re-export from governance.
+ *
+ * @module governance/codex-policy.service
+ * @version 2.0.0-s02-real
  */
 import { frameworkLogger } from '../core/framework-logger.js';
 import { resolveCodexPath } from '../core/config-paths.js';
@@ -103,7 +120,7 @@ export class CodexPolicyService {
             is_fallback: isFallback,
             note: isFallback
                 ? 'Governance CodexPolicyService — builtin fallback (no external codex.json resolved)'
-                : 'Returned via Governance CodexPolicyService',
+                : 'Returned via Governance CodexPolicyService — V2 Single Source of Truth (S02-REAL)',
             dynamo_required: true,
             ...(includeRaw ? { codex: data } : {}),
         };
@@ -147,4 +164,4 @@ export function getCodexPolicyService() {
     return codexPolicyServiceInstance;
 }
 // Also export the class for direct construction in tests / advanced wiring
-//# sourceMappingURL=codex-policy.service.js.map
+export { CodexPolicyService as default };

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;
+}