0xray 2.0.0

package/dist/governance/governance-core.js

@@ -0,0 +1,152 @@
+/**
+ * Pure governance decision logic.
+ * 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',
+};
+/**
+ * The core PHI/TAU decision matrix.
+ * Extracted so it can be shared between local MCP and deployed HTTP versions.
+ */
+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)}%`);
+    }
+    // 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,
+        };
+    }
+    // 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'})`);
+    }
+    // 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');
+    }
+    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.
+ */
+export function mergeVotes(votes) {
+    if (votes.length === 0) {
+        return {
+            finalDecision: 'abstain',
+            averageConfidence: 0.5,
+            reasoningSummary: 'No votes received',
+        };
+    }
+    const approveWeight = votes
+        .filter(v => v.decision === 'approve')
+        .reduce((sum, v) => sum + (v.weight ?? 1) * v.confidence, 0);
+    const totalWeight = votes.reduce((sum, v) => sum + (v.weight ?? 1) * v.confidence, 0);
+    const avgConfidence = totalWeight > 0 ? totalWeight / votes.length : 0.5;
+    let finalDecision = 'needs_revision';
+    if (totalWeight > 0) {
+        const approveRatio = approveWeight / totalWeight;
+        if (approveRatio > 0.66) {
+            finalDecision = 'approve';
+        }
+        else if (approveRatio < 0.33) {
+            finalDecision = 'reject';
+        }
+    }
+    else {
+        // All votes had zero confidence — default to needs_revision
+        finalDecision = 'needs_revision';
+    }
+    const reasons = votes.map(v => `${v.server}: ${v.reasoning}`).join(' | ');
+    return {
+        finalDecision,
+        averageConfidence: Math.round(avgConfidence * 100) / 100,
+        reasoningSummary: reasons,
+    };
+}

package/dist/governance/governance-service.js

@@ -0,0 +1,274 @@
+/**
+ * GovernanceService
+ *
+ * Central orchestrator for governance.
+ *
+ * Architecture:
+ *   - Internal Layer: 3 real skill MCPs (code-review, security-audit, researcher)
+ *     → Internal deliberation based on knowledge and code patterns.
+ *
+ *   - External Filter: Dynamo Solar SSOT
+ *     → Single Source of Truth governance signal based on sunlight physics,
+ *       a neural net, and temporal first principles. This is a required check.
+ *
+ *   - Merge Layer: governance-core.ts (weighted voting + PHI/TAU matrix)
+ *
+ * Dynamo Solar SSOT is treated as a mandatory external filter (not optional, not a fallback).
+ */
+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() {
+        // We deliberately do *not* cache the integration here.
+        // On Vercel / serverless, initializeGovernanceIntegration() may be called
+        // after the first getGovernanceService() instance is created.
+        // We always fetch fresh via getGovernanceIntegration() on each govern() call.
+    }
+    /**
+     * Main entry point: Govern a set of proposals.
+     *
+     * Flow:
+     *   1. Internal deliberation → 3 real skill MCPs (code-review, security-audit, researcher)
+     *   2. External filter       → Dynamo Solar SSOT (via InferenceGovernanceIntegration)
+     *   3. Merge                 → governance-core.ts (weighted + PHI/TAU logic)
+     *
+     * Dynamo Solar SSOT is treated as a hard requirement by default.
+     */
+    async govern(request) {
+        const { proposals, context, options } = request;
+        const requireExternal = options?.requireExternalDynamo ?? true;
+        const timeoutMs = options?.timeoutMs ?? 90000;
+        const maxAbstentionThreshold = options?.maxAbstentionThreshold ?? 1.0;
+        frameworkLogger.log('governance-service', 'govern-start', 'info', {
+            proposalCount: proposals.length,
+            context,
+            requireExternalDynamo: requireExternal,
+            timeoutMs,
+        });
+        // Early validation: Dynamo Solar SSOT is a hard requirement
+        if (requireExternal) {
+            const integration = getGovernanceIntegration();
+            if (!integration?.isAvailable?.()) {
+                const message = 'Dynamo Solar SSOT is required but InferenceGovernanceIntegration is not available. ' +
+                    'Call initializeGovernanceIntegration() early in application startup.';
+                frameworkLogger.log('governance-service', 'dynamo-solar-ssot-unavailable', 'error', { message });
+                throw new Error(message);
+            }
+        }
+        // Run governance with end-to-end timeout
+        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);
+            const abstentions = result.results.reduce((sum, r) => sum + r.votes.filter(v => v.decision === 'abstain').length, 0);
+            const abstentionRatio = totalVotes > 0 ? abstentions / totalVotes : 0;
+            if (abstentionRatio > maxAbstentionThreshold) {
+                const message = `Abstention ratio ${abstentionRatio.toFixed(2)} exceeds threshold ${maxAbstentionThreshold} — ` +
+                    'too many governance servers unavailable';
+                frameworkLogger.log('governance-service', 'abstention-threshold-exceeded', 'error', {
+                    abstentionRatio,
+                    maxAbstentionThreshold,
+                });
+                throw new Error(message);
+            }
+        }
+        const approved = result.results.filter(r => r.finalDecision === 'approve').length;
+        const needsRevision = result.results.filter(r => r.finalDecision === 'needs_revision').length;
+        const rejected = result.results.filter(r => r.finalDecision === 'reject').length;
+        return {
+            results: result.results,
+            overallDecision: approved > proposals.length * 0.6
+                ? 'approve'
+                : rejected > approved ? 'reject' : 'needs_revision',
+            summary: {
+                total: proposals.length,
+                approved,
+                needsRevision,
+                rejected,
+            },
+        };
+    }
+    async runGovernanceWithTimeout(proposals, context, requireExternal, timeoutMs) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            // 1. Call the three real skill MCPs (one call per server, returns array of votes, one per proposal)
+            const [codeReviewVotes, securityVotes, researcherVotes] = await Promise.all([
+                this.callSkillServer("code-review", proposals, context),
+                this.callSkillServer("security-audit", proposals, context),
+                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);
+            // 3. Merge everything
+            const results = proposals.map((proposal, index) => {
+                const votes = [
+                    codeReviewVotes[index] || { server: "code-review", decision: "abstain", confidence: 0.3, reasoning: "missing" },
+                    securityVotes[index] || { server: "security-audit", decision: "abstain", confidence: 0.3, reasoning: "missing" },
+                    researcherVotes[index] || { server: "researcher", decision: "abstain", confidence: 0.3, reasoning: "missing" },
+                    ...(externalVotes[index] || []),
+                ];
+                const merged = mergeVotes(votes);
+                return {
+                    proposalId: proposal.id,
+                    finalDecision: merged.finalDecision,
+                    averageConfidence: merged.averageConfidence,
+                    votes,
+                    reasoningSummary: merged.reasoningSummary,
+                };
+            });
+            return { results };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async callSkillServer(serverName, proposals, context) {
+        const votes = [];
+        const useInProcess = process.env.VERCEL === '1';
+        for (const proposal of proposals) {
+            try {
+                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', 'skill-call-error', 'error', {
+                    server: serverName,
+                    proposal: proposal.title,
+                    error: error instanceof Error ? error.message : String(error),
+                    mode: useInProcess ? 'in-process' : 'mcp',
+                });
+                votes.push({
+                    server: serverName,
+                    decision: 'abstain',
+                    confidence: 0.3,
+                    reasoning: `Call to ${serverName} failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                });
+            }
+        }
+        return votes;
+    }
+    async callExternalDynamo(proposals, requireExternal) {
+        const results = [];
+        const integration = getGovernanceIntegration();
+        const integrationAvailable = integration?.isAvailable?.() === true;
+        if (!integrationAvailable) {
+            const message = 'Dynamo Solar SSOT is required but InferenceGovernanceIntegration is not available or not initialized. ' +
+                'Call initializeGovernanceIntegration() early during application bootstrap.';
+            frameworkLogger.log('governance-service', 'dynamo-solar-ssot-unavailable', 'error', {
+                requireExternal,
+                message,
+            });
+            if (requireExternal) {
+                throw new Error(message);
+            }
+            // If external is not strictly required, return abstain votes
+            for (const proposal of proposals) {
+                results.push([{
+                        server: 'external-dynamo',
+                        decision: 'abstain',
+                        confidence: 0.2,
+                        reasoning: 'InferenceGovernanceIntegration not available',
+                    }]);
+            }
+            return results;
+        }
+        // Integration is available — use it exclusively (no fallback)
+        for (const proposal of proposals) {
+            try {
+                const inferenceType = (proposal.type === 'strategic' || proposal.type === 'compliance'
+                    ? 'refactor'
+                    : proposal.type);
+                const inferenceProposal = {
+                    id: proposal.id,
+                    type: inferenceType,
+                    title: proposal.title,
+                    description: proposal.description,
+                    evidence: proposal.evidence || [],
+                    confidence: proposal.confidence || 0.8,
+                    source: 'recurring_pattern',
+                    status: 'pending',
+                };
+                const result = await integration.checkProposal(inferenceProposal);
+                results.push([{
+                        server: 'external-dynamo',
+                        decision: result.vote === 'YES' ? 'approve' : result.vote === 'NO' ? 'reject' : 'needs_revision',
+                        confidence: result.governanceResponse?.confidence ?? 0.85,
+                        reasoning: result.reason || 'Dynamo Solar SSOT filter decision',
+                        weight: 1.1,
+                        moralTension: result.moralTension,
+                        moralScore: result.moralScore,
+                        moralFusion: result.moralFusion,
+                        detectedVirtues: result.detectedVirtues,
+                        detectedConcerns: result.detectedConcerns,
+                    }]);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                frameworkLogger.log('governance-service', 'external-dynamo-error', 'error', { error: msg });
+                if (requireExternal) {
+                    throw new Error(`External Dynamo governance is required but failed: ${msg}`);
+                }
+                results.push([{
+                        server: 'external-dynamo',
+                        decision: 'abstain',
+                        confidence: 0.3,
+                        reasoning: `External governance call failed: ${msg}`,
+                    }]);
+            }
+        }
+        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.]+)/);
+        const reasoningMatch = text.match(/REASONING:\s*([\s\S]+)/);
+        return {
+            server,
+            decision: decisionMatch?.[1]?.toLowerCase() || 'abstain',
+            confidence: parseFloat(confidenceMatch?.[1] || '0.5'),
+            reasoning: reasoningMatch?.[1]?.trim() || 'No reasoning provided',
+        };
+    }
+}
+// Singleton for convenience
+let governanceServiceInstance = null;
+export function getGovernanceService() {
+    if (!governanceServiceInstance) {
+        governanceServiceInstance = new GovernanceService();
+    }
+    return governanceServiceInstance;
+}

package/dist/governance/governance-types.js

@@ -0,0 +1,6 @@
+/**
+ * Core types for the 0xRay Governance System.
+ * These types are used by the GovernanceService, Governance MCP,
+ * and all integrations.
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,24 @@
+/**
+ * 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 { defaultStringRayConfig } from "./core/index.js";
+export { defaultStringRayConfig };
+export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
+// 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",
+    };
+}

package/dist/inference/deploy-verifier.js

@@ -0,0 +1,161 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execSync } from "child_process";
+const E2E_TEST_PATTERNS = [
+    { name: "opencode-integration", pattern: "oh-my-opencode-integration" },
+    { name: "hermes-agent", pattern: "hermes-agent" },
+    { name: "openclaw-integration", pattern: "openclaw-integration" },
+    { name: "e2e-orchestration", pattern: "e2e-orchestration" },
+    { name: "framework-init", pattern: "framework-init" },
+    { name: "processor-integration", pattern: "processors.test" },
+    { name: "security-integration", pattern: "security-integration" },
+];
+export class DeployVerifier {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot || process.cwd();
+    }
+    verify() {
+        const startTime = Date.now();
+        const checks = [];
+        let tarballPath = "";
+        let installDir = "";
+        const pkg = this.readPackageJson();
+        const version = pkg.version;
+        const buildCheck = this.runCheck("build", () => {
+            this.exec("npm run build", this.projectRoot, 120000);
+            return "Build succeeded";
+        });
+        checks.push(buildCheck);
+        if (!buildCheck.passed) {
+            return this.result(false, version, tarballPath, installDir, checks, startTime);
+        }
+        const packCheck = this.runCheck("npm-pack", () => {
+            const output = this.exec("npm pack --pack-destination /tmp", this.projectRoot, 30000);
+            const match = output.match(/0xray-[\d.]+\.tgz/);
+            if (!match)
+                throw new Error("No tarball produced");
+            tarballPath = `/tmp/${match[0]}`;
+            return `Packed ${match[0]}`;
+        });
+        checks.push(packCheck);
+        if (!packCheck.passed) {
+            return this.result(false, version, tarballPath, installDir, checks, startTime);
+        }
+        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";
+        });
+        checks.push(installCheck);
+        if (!installCheck.passed) {
+            this.cleanup(installDir, tarballPath);
+            return this.result(false, version, tarballPath, installDir, checks, startTime);
+        }
+        const cliCheck = this.runCheck("cli-health", () => {
+            const cliPath = path.join(installDir, "node_modules", ".bin", "0xray");
+            if (!fs.existsSync(cliPath))
+                throw new Error("CLI not found in installed package");
+            const output = this.exec(`${cliPath} health`, installDir, 15000);
+            return `CLI health: ${output.substring(0, 100)}`;
+        });
+        checks.push(cliCheck);
+        for (const e2e of E2E_TEST_PATTERNS) {
+            const testCheck = this.runCheck(`e2e-${e2e.name}`, () => {
+                const output = this.exec(`npx vitest run --reporter=verbose -- ${e2e.pattern}`, this.projectRoot, 120000);
+                const passMatch = output.match(/(\d+) passed/);
+                const failMatch = output.match(/(\d+) failed/);
+                const fails = failMatch ? parseInt(failMatch[1], 10) : 0;
+                if (fails > 0)
+                    throw new Error(`${fails} tests failed`);
+                return passMatch ? `${passMatch[1]} tests passed` : "Tests ran";
+            });
+            checks.push(testCheck);
+        }
+        const allPassed = checks.every((c) => c.passed);
+        this.cleanup(installDir, tarballPath);
+        return this.result(allPassed, version, tarballPath, installDir, checks, startTime);
+    }
+    quickVerify() {
+        const startTime = Date.now();
+        const checks = [];
+        const pkg = this.readPackageJson();
+        const version = pkg.version;
+        if (!fs.existsSync(path.join(this.projectRoot, "package.json"))) {
+            checks.push({ name: "build", passed: false, output: "No package.json found", duration: 0 });
+            return this.result(false, version, "", "", checks, startTime);
+        }
+        const buildCheck = this.runCheck("build", () => {
+            this.exec("npm run build", this.projectRoot, 120000);
+            return "Build succeeded";
+        });
+        checks.push(buildCheck);
+        const testCheck = this.runCheck("test-suite", () => {
+            const output = this.exec("npm test", this.projectRoot, 120000);
+            const failMatch = output.match(/(\d+) failed/);
+            const fails = failMatch ? parseInt(failMatch[1], 10) : 0;
+            if (fails > 0)
+                throw new Error(`${fails} tests failed`);
+            return "All tests passed";
+        });
+        checks.push(testCheck);
+        const allPassed = checks.every((c) => c.passed);
+        return this.result(allPassed, version, "", "", checks, startTime);
+    }
+    runCheck(name, fn) {
+        const start = Date.now();
+        try {
+            const output = fn();
+            return { name, passed: true, output, duration: Date.now() - start };
+        }
+        catch (error) {
+            return {
+                name,
+                passed: false,
+                output: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - start,
+            };
+        }
+    }
+    exec(command, cwd, timeout) {
+        return execSync(command, {
+            cwd,
+            encoding: "utf-8",
+            stdio: "pipe",
+            timeout,
+        });
+    }
+    readPackageJson() {
+        const pkgPath = path.join(this.projectRoot, "package.json");
+        if (!fs.existsSync(pkgPath)) {
+            return { version: "0.0.0-test" };
+        }
+        const content = fs.readFileSync(pkgPath, "utf-8");
+        return JSON.parse(content);
+    }
+    cleanup(installDir, tarballPath) {
+        try {
+            if (installDir && fs.existsSync(installDir)) {
+                fs.rmSync(installDir, { recursive: true, force: true });
+            }
+            if (tarballPath && fs.existsSync(tarballPath)) {
+                fs.unlinkSync(tarballPath);
+            }
+        }
+        catch {
+            // best effort
+        }
+    }
+    result(success, version, tarballPath, installDir, checks, startTime) {
+        return {
+            success,
+            packageVersion: version,
+            tarballPath,
+            installDir,
+            checks,
+            duration: Date.now() - startTime,
+            timestamp: new Date().toISOString(),
+        };
+    }
+}

package/dist/inference/index.js

@@ -0,0 +1,5 @@
+export { analyzeStructuralPatterns } from "./semantic-patterns.js";
+export { captureSessionInference, saveSessionInference, } from "./session-capture.js";
+export { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
+export { InferenceCycle } from "./inference-cycle.js";
+export { DeployVerifier } from "./deploy-verifier.js";