0xray 3.0.12 → 3.0.14

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/index.js

@@ -1,15 +1,24 @@
-export { XrayOrchestrator } from "./orchestrator/orchestrator.js";
-export { XrayStateManager } from "./state/index.js";
+/**
+ * 0xRay Framework - Main Entry Point
+ *
+ * This is the main entry point for the 0xRay framework.
+ * It exports the core initialization function and key components.
+ */
+export { StringRayOrchestrator } from "./orchestrator/orchestrator.js";
+export { StringRayStateManager } from "./state/index.js";
 export { AgentDelegator } from "./delegation/index.js";
 export { frameworkLogger } from "./core/framework-logger.js";
 export { BUILTIN_CODEX } from "./core/codex-formatter.js";
-import { defaultXrayConfig } from "./core/index.js";
-export { defaultXrayConfig };
+import { defaultStringRayConfig } from "./core/index.js";
+export { defaultStringRayConfig };
 export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
-export { XrayService } from "./public/XrayService.js";
-export { beforeToolHook, afterToolHook } from "./integrations/enforcement-gate.js";
-export function initializeXray(config = {}) {
-    const mergedConfig = { ...defaultXrayConfig, ...config };
-    return { success: true, config: mergedConfig, message: "0xRay framework initialized successfully" };
+// Main initialization function
+export function initializeStringRay(config = {}) {
+    const mergedConfig = { ...defaultStringRayConfig, ...config };
+    // Return a standardized initialization result
+    return {
+        success: true,
+        config: mergedConfig,
+        message: "0xRay framework initialized successfully",
+    };
 }
-//# sourceMappingURL=index.js.map

package/dist/inference/deploy-verifier.js

@@ -43,7 +43,7 @@ export class DeployVerifier {
         if (!packCheck.passed) {
             return this.result(false, version, tarballPath, installDir, checks, startTime);
         }
-        installDir = fs.mkdtempSync(path.join(os.tmpdir(), "xray-deploy-verify-"));
+        installDir = fs.mkdtempSync(path.join(os.tmpdir(), "strray-deploy-verify-"));
         const installCheck = this.runCheck("npm-install-fresh", () => {
             this.exec(`npm install ${tarballPath} --no-save`, installDir, 60000);
             return "Fresh install succeeded";
@@ -159,4 +159,3 @@ export class DeployVerifier {
         };
     }
 }
-//# sourceMappingURL=deploy-verifier.js.map

package/dist/inference/index.js

@@ -3,4 +3,3 @@ export { captureSessionInference, saveSessionInference, } from "./session-captur
 export { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
 export { InferenceCycle } from "./inference-cycle.js";
 export { DeployVerifier } from "./deploy-verifier.js";
-//# sourceMappingURL=index.js.map

package/dist/inference/inference-accumulator.js

@@ -108,7 +108,7 @@ function loadLastCycleDate(filePath) {
         return null;
     try {
         const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-        return data.completedAt || data.cycleState?.completedAt || data.timestamp || null;
+        return data.completedAt || data.timestamp || null;
     }
     catch {
         return null;
@@ -124,4 +124,3 @@ function normalizeProblem(problem) {
 function daysBetween(a, b) {
     return (b.getTime() - a.getTime()) / (1000 * 60 * 60 * 24);
 }
-//# sourceMappingURL=inference-accumulator.js.map