0xray 2.0.0

package/dist/integrations/governance/index.js

@@ -0,0 +1,373 @@
+/**
+ * Inference Governance Integration
+ *
+ * Integrates chrono-warp-drive Dynamo governance endpoint for external
+ * inference checking in governance decision-making.
+ *
+ * @version 1.0.0
+ * @since 2026-05-11
+ */
+import { BaseIntegration } from '../base/index.js';
+import { DEFAULT_GOVERNANCE_CONFIG } from './types.js';
+import { GovernanceClient } from './governance-client.js';
+import { frameworkLogger } from '../../core/framework-logger.js';
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Main Governance Integration class
+ *
+ * Provides external governance checking for inference proposals via the
+ * chrono-warp-drive Dynamo /governance endpoint.
+ */
+export class InferenceGovernanceIntegration extends BaseIntegration {
+    client = null;
+    configData = DEFAULT_GOVERNANCE_CONFIG;
+    constructor() {
+        super('inference-governance', '1.0.0', {
+            enabled: false,
+            debug: false,
+            logLevel: 'info'
+        });
+    }
+    /**
+     * Perform integration-specific initialization
+     */
+    async performInitialization() {
+        await this.loadConfig();
+        if (!this.configData.enabled) {
+            await this.log('info', 'Governance integration disabled in configuration');
+            return;
+        }
+        await this.log('info', 'Initializing governance client...');
+        this.client = new GovernanceClient({
+            baseUrl: this.configData.endpointUrl.replace(/\/governance$/, ''),
+            timeoutMs: this.configData.requestTimeoutMs,
+        });
+        await this.log('success', 'Governance client initialized', {
+            endpoint: this.configData.endpointUrl,
+            timeout: this.configData.requestTimeoutMs,
+        });
+    }
+    /**
+     * Perform integration-specific shutdown
+     */
+    async performShutdown() {
+        await this.log('info', 'Shutting down governance integration');
+        this.client = null;
+    }
+    /**
+     * Perform health check
+     */
+    async performHealthCheck() {
+        if (!this.client) {
+            return {
+                healthy: false,
+                message: 'Governance client not initialized',
+            };
+        }
+        const stats = this.client.getStats();
+        // Healthy if we have no recent errors
+        const isHealthy = stats.errors === 0 || stats.requestsSucceeded > stats.errors;
+        return {
+            healthy: isHealthy,
+            message: isHealthy
+                ? 'Governance client healthy'
+                : 'Governance client has errors',
+            details: {
+                requestsTotal: stats.requestsTotal,
+                requestsSucceeded: stats.requestsSucceeded,
+                requestsFailed: stats.requestsFailed,
+                errors: stats.errors,
+                averageResponseTimeMs: stats.averageResponseTimeMs,
+            },
+        };
+    }
+    /**
+     * Check if governance is enabled and available
+     */
+    isAvailable() {
+        return this.configData.enabled && this.client !== null && this.status === 'initialized';
+    }
+    /**
+     * Check a single inference proposal via the appropriate governance tool
+     *
+     * Routes to govern_with_solar (strategic proposals) or evaluate_governance
+     * (technical proposals) based on proposal type.
+     */
+    async checkProposal(proposal, agentReviews = [], historicalIds = []) {
+        if (!this.isAvailable()) {
+            throw new Error('Governance integration not available');
+        }
+        const isTechnical = proposal.type === 'fix' || proposal.type === 'guard';
+        if (isTechnical) {
+            return this.evaluateProposal(proposal, agentReviews, historicalIds);
+        }
+        return this.governWithSolarProposal(proposal);
+    }
+    /**
+     * Route: evaluate_governance — for purely technical proposals (fix, guard)
+     */
+    async evaluateProposal(proposal, agentReviews, historicalIds) {
+        const response = await this.client.evaluateGovernance({
+            proposalId: proposal.id,
+            proposalText: `${proposal.title}\n\n${proposal.description}`,
+            agentReviews,
+            historicalSignalIds: historicalIds,
+        });
+        return this.applyDecisionLogic(response);
+    }
+    /**
+     * Route: govern_with_solar — for strategic proposals (refactor, codify, automate)
+     *
+     * Brings real-time NOAA GOES solar context into the decision, adjusting
+     * vote weight and adding warnings based on current solar activity.
+     */
+    async governWithSolarProposal(proposal) {
+        frameworkLogger.log('inference-governance', 'solar-check-start', 'info', {
+            proposalId: proposal.id,
+            proposalTitle: proposal.title,
+        });
+        const solarResponse = await this.client.governWithSolar({
+            proposal: `${proposal.title}\n\n${proposal.description}`,
+            baseVoteWeight: this.configData.decisionLogic.voteWeightMultiplier,
+        });
+        const adjustment = solarResponse.confidenceAdjustment;
+        const recommendation = adjustment <= -0.10 ? 'NEEDS_REVISION' : 'PASS';
+        const reasons = [
+            solarResponse.solarContext.recommendation,
+            `Solar activity: ${solarResponse.solarContext.solarActivityLevel} (adjustment: ${(adjustment * 100).toFixed(0)}%, resonance: ${(solarResponse.solarContext.solarIsotopicResonance ?? solarResponse.solarContext.solarResonance ?? 0).toFixed(4)})`,
+        ];
+        if (solarResponse.finalRecommendation && solarResponse.finalRecommendation !== solarResponse.originalRecommendation) {
+            reasons.push(solarResponse.finalRecommendation);
+        }
+        // Trinitarium Moral Overlay — add moral tension to reasoning
+        if (solarResponse.moralTension) {
+            reasons.push(`Moral tension: ${solarResponse.moralTension}${solarResponse.trinitariumMoralScore != null ? ` (${(solarResponse.trinitariumMoralScore * 100).toFixed(0)}%)` : ''}`);
+            if (solarResponse.detectedConcerns && solarResponse.detectedConcerns.length > 0) {
+                reasons.push(`Moral concerns: ${solarResponse.detectedConcerns.join(', ')}`);
+            }
+        }
+        const mappedResponse = {
+            success: true,
+            proposalId: proposal.id,
+            governanceIsotopeId: `solar-${solarResponse.solarContext.solarActivityLevel}`,
+            resonanceScore: solarResponse.solarContext.solarIsotopicResonance ?? solarResponse.solarContext.solarResonance ?? 0,
+            isotopicRatio: 0,
+            vortexVolume: 0,
+            historicalCoherence: 0,
+            recommendation,
+            confidence: Math.max(0, Math.min(1, proposal.confidence + adjustment)),
+            voteWeight: solarResponse.adjustedVoteWeight,
+            reasons,
+        };
+        const baseResult = this.applyDecisionLogic(mappedResponse);
+        const solarResult = {
+            ...baseResult,
+            solarContext: solarResponse.solarContext,
+            solarConfidenceAdjustment: solarResponse.confidenceAdjustment,
+            moralTension: solarResponse.moralTension,
+            moralScore: solarResponse.trinitariumMoralScore,
+            moralFusion: solarResponse.trinitariumGematriaFusion,
+            detectedVirtues: solarResponse.detectedVirtues,
+            detectedConcerns: solarResponse.detectedConcerns,
+        };
+        frameworkLogger.log('inference-governance', 'solar-check-complete', 'info', {
+            proposalId: proposal.id,
+            solarActivityLevel: solarResponse.solarContext.solarActivityLevel,
+            adjustedVoteWeight: solarResponse.adjustedVoteWeight,
+            confidenceAdjustment: solarResponse.confidenceAdjustment,
+            passed: solarResult.passed,
+        });
+        return solarResult;
+    }
+    /**
+     * Check multiple proposals with external governance
+     */
+    async checkProposals(proposals, agentReviews = [], historicalIds = []) {
+        if (!this.isAvailable()) {
+            throw new Error('Governance integration not available');
+        }
+        const batchId = `governance-batch-${Date.now()}`;
+        const timestamp = Date.now();
+        frameworkLogger.log('inference-governance', 'batch-check-start', 'info', { batchId, proposalCount: proposals.length });
+        const results = [];
+        for (const proposal of proposals) {
+            try {
+                const result = await this.checkProposal(proposal, agentReviews, historicalIds);
+                results.push(result);
+            }
+            catch (error) {
+                frameworkLogger.log('inference-governance', 'check-proposal-error', 'warning', {
+                    proposalId: proposal.id,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // Fallback to local decision
+                results.push(this.createFallbackVote(proposal));
+            }
+        }
+        frameworkLogger.log('inference-governance', 'batch-check-complete', 'info', {
+            batchId,
+            proposalCount: proposals.length,
+            passedCount: results.filter(r => r.passed).length,
+        });
+        return {
+            proposals,
+            results,
+            batchId,
+            timestamp,
+        };
+    }
+    /**
+     * Apply decision logic based on governance response
+     */
+    applyDecisionLogic(response) {
+        const { decisionLogic } = this.configData;
+        let vote;
+        let passed;
+        switch (response.recommendation) {
+            case 'PASS':
+                vote = 'YES';
+                passed = true;
+                break;
+            case 'REJECT':
+                vote = 'NO';
+                passed = false;
+                break;
+            case 'NEEDS_REVISION':
+            default:
+                vote = 'ABSTAIN';
+                passed = false;
+                break;
+        }
+        // Calculate weighted vote
+        const weight = response.voteWeight * decisionLogic.voteWeightMultiplier;
+        // Build reason string
+        const reason = [
+            `Governance ${response.recommendation} (confidence: ${(response.confidence * 100).toFixed(1)}%)`,
+            ...response.reasons.slice(0, 2), // Include up to 2 reasons
+        ].join('; ');
+        return {
+            vote,
+            weight,
+            reason,
+            governanceResponse: response,
+            passed,
+        };
+    }
+    /**
+     * Create fallback vote when governance is unavailable
+     */
+    createFallbackVote(proposal) {
+        return {
+            vote: proposal.confidence >= 0.7 ? 'YES' : 'ABSTAIN',
+            weight: 1.0,
+            reason: 'Fallback: governance endpoint unavailable',
+            governanceResponse: {
+                success: false,
+                proposalId: proposal.id,
+                governanceIsotopeId: 'fallback',
+                resonanceScore: 0,
+                isotopicRatio: 0,
+                vortexVolume: 0,
+                historicalCoherence: 0,
+                recommendation: 'NEEDS_REVISION',
+                confidence: proposal.confidence,
+                voteWeight: 1.0,
+                reasons: ['Governance endpoint unavailable, using local confidence'],
+            },
+            passed: proposal.confidence >= 0.7,
+        };
+    }
+    /**
+     * Load configuration from features.json
+     */
+    async loadConfig() {
+        try {
+            const configPath = path.join(process.cwd(), '.opencode', 'strray', 'features.json');
+            if (!fs.existsSync(configPath)) {
+                await this.log('warning', 'features.json not found, using defaults');
+                return;
+            }
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const features = JSON.parse(content);
+            if (features.inference_governance) {
+                this.configData = {
+                    ...DEFAULT_GOVERNANCE_CONFIG,
+                    enabled: features.inference_governance.enabled ?? false,
+                    endpointUrl: features.inference_governance.endpoint_url ?? DEFAULT_GOVERNANCE_CONFIG.endpointUrl,
+                    requestTimeoutMs: features.inference_governance.request_timeout_ms ?? DEFAULT_GOVERNANCE_CONFIG.requestTimeoutMs,
+                    minConfidenceThreshold: features.inference_governance.min_confidence_threshold ?? DEFAULT_GOVERNANCE_CONFIG.minConfidenceThreshold,
+                    decisionLogic: {
+                        passConfidenceMin: features.inference_governance.decision_logic?.pass_confidence_min ?? DEFAULT_GOVERNANCE_CONFIG.decisionLogic.passConfidenceMin,
+                        revisionConfidenceMax: features.inference_governance.decision_logic?.revision_confidence_max ?? DEFAULT_GOVERNANCE_CONFIG.decisionLogic.revisionConfidenceMax,
+                        voteWeightMultiplier: features.inference_governance.decision_logic?.vote_weight_multiplier ?? DEFAULT_GOVERNANCE_CONFIG.decisionLogic.voteWeightMultiplier,
+                    },
+                };
+            }
+            await this.log('info', 'Configuration loaded', {
+                enabled: this.configData.enabled,
+                endpoint: this.configData.endpointUrl,
+            });
+        }
+        catch (error) {
+            await this.log('error', 'Failed to load configuration', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Use defaults on error
+            this.configData = DEFAULT_GOVERNANCE_CONFIG;
+        }
+    }
+    /**
+     * Get governance-specific configuration
+     */
+    getGovernanceConfig() {
+        return { ...this.configData };
+    }
+    /**
+     * Get client statistics
+     */
+    getClientStats() {
+        return this.client?.getStats() ?? {
+            requestsTotal: 0,
+            requestsSucceeded: 0,
+            requestsFailed: 0,
+            averageResponseTimeMs: 0,
+            errors: 0,
+        };
+    }
+}
+// ============================================================================
+// Global Integration Instance
+// ============================================================================
+let globalIntegration = null;
+/**
+ * Initialize the global governance integration
+ */
+export async function initializeGovernanceIntegration() {
+    if (globalIntegration) {
+        return globalIntegration;
+    }
+    globalIntegration = new InferenceGovernanceIntegration();
+    await globalIntegration.initialize();
+    return globalIntegration;
+}
+/**
+ * Get the global governance integration
+ */
+export function getGovernanceIntegration() {
+    return globalIntegration;
+}
+/**
+ * Shutdown the global governance integration
+ */
+export async function shutdownGovernanceIntegration() {
+    if (globalIntegration) {
+        await globalIntegration.shutdown();
+        globalIntegration = null;
+    }
+}
+// ============================================================================
+// Exports
+// ============================================================================
+export * from './types.js';
+export * from './governance-client.js';

package/dist/integrations/governance/types.js

@@ -0,0 +1,97 @@
+/**
+ * Inference Governance Integration Types
+ *
+ * Type definitions for the chrono-warp-drive Dynamo governance endpoint integration.
+ * Provides external governance checking for inference-driven proposals.
+ *
+ * @version 1.0.0
+ * @since 2026-05-11
+ */
+/**
+ * Default governance configuration
+ */
+export const DEFAULT_GOVERNANCE_CONFIG = {
+    enabled: false,
+    endpointUrl: process.env.GOVERNANCE_ENDPOINT || '',
+    requestTimeoutMs: 10000,
+    minConfidenceThreshold: 0.5,
+    decisionLogic: {
+        passConfidenceMin: 0.9,
+        revisionConfidenceMax: 0.89,
+        voteWeightMultiplier: 1.0,
+    },
+};
+// ============================================================================
+// Error Types
+// ============================================================================
+/**
+ * Governance error codes
+ */
+export var GovernanceErrorCode;
+(function (GovernanceErrorCode) {
+    GovernanceErrorCode["REQUEST_FAILED"] = "REQUEST_FAILED";
+    GovernanceErrorCode["TIMEOUT"] = "TIMEOUT";
+    GovernanceErrorCode["INVALID_RESPONSE"] = "INVALID_RESPONSE";
+    GovernanceErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+    GovernanceErrorCode["CONFIG_INVALID"] = "CONFIG_INVALID";
+    GovernanceErrorCode["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+})(GovernanceErrorCode || (GovernanceErrorCode = {}));
+/**
+ * Base governance error
+ */
+export class GovernanceError extends Error {
+    code;
+    recoverable;
+    context;
+    constructor(message, code, recoverable, context) {
+        super(message);
+        this.code = code;
+        this.recoverable = recoverable;
+        this.context = context;
+        this.name = 'GovernanceError';
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+/**
+ * Request timeout error
+ */
+export class GovernanceTimeoutError extends GovernanceError {
+    constructor(timeoutMs) {
+        super(`Governance request timed out after ${timeoutMs}ms`, GovernanceErrorCode.TIMEOUT, true, { timeoutMs });
+        this.name = 'GovernanceTimeoutError';
+    }
+}
+/**
+ * Network error
+ */
+export class GovernanceNetworkError extends GovernanceError {
+    constructor(url, originalError) {
+        super(`Network error calling governance endpoint: ${originalError.message}`, GovernanceErrorCode.NETWORK_ERROR, true, { url, originalError: originalError.message });
+        this.name = 'GovernanceNetworkError';
+    }
+}
+// ============================================================================
+// Utility Types
+// ============================================================================
+/**
+ * Type guard for valid governance response
+ */
+export function isValidGovernanceResponse(response) {
+    if (typeof response !== 'object' || response === null)
+        return false;
+    const r = response;
+    return (typeof r.success === 'boolean' &&
+        typeof r.proposalId === 'string' &&
+        typeof r.governanceIsotopeId === 'string' &&
+        typeof r.recommendation === 'string' &&
+        ['PASS', 'NEEDS_REVISION', 'REJECT'].includes(r.recommendation) &&
+        typeof r.confidence === 'number' &&
+        typeof r.voteWeight === 'number');
+}
+/**
+ * Type guard for governance error
+ */
+export function isGovernanceError(error) {
+    return (error instanceof GovernanceError ||
+        (error instanceof Error && error.name === 'GovernanceError'));
+}

package/dist/integrations/grok/grok-cli.js

@@ -0,0 +1,83 @@
+/**
+ * Grok CLI Integration for StringRay / 0xRay
+ *
+ * This module provides the integration points for using 0xRay with the official Grok CLI.
+ *
+ * Primary mechanism: MCP (Model Context Protocol)
+ * Grok CLI can consume MCP servers. By registering the 0xRay MCP servers,
+ * users get access to Governance, skills, and other capabilities directly inside Grok conversations.
+ *
+ * Recommended registration (via npx or Grok's tooling):
+ *   npx 0xray grok install
+ *
+ * This will help configure the user's Grok CLI to include the following MCP servers:
+ * - governance (Dynamo Solar SSOT + real skill deliberation)
+ * - All knowledge-skill MCP servers (code-review, security-audit, researcher, etc.)
+ */
+import { frameworkLogger } from '../../core/framework-logger.js';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+// ESM-compatible __dirname (this file is compiled to ESM)
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+export async function installForGrokCLI(options = {}) {
+    frameworkLogger.log('grok-integration', 'install-start', 'info', { options });
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    const targetPluginDir = path.join(home, '.grok/plugins/0xray');
+    // Try to find the plugin source from the installed package
+    const possibleSources = [
+        path.join(__dirname, '..', '..', '..', 'src/integrations/grok/plugin/0xray'), // dev
+        path.join(__dirname, '..', '..', '..', '.grok/plugins/0xray'), // after build
+    ];
+    let sourceDir = possibleSources.find(p => fs.existsSync(p));
+    if (!sourceDir) {
+        console.error('[Grok] Could not locate the 0xray Grok plugin inside the package.');
+        return;
+    }
+    if (options.dryRun) {
+        console.log(`[Grok] Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`);
+        return;
+    }
+    try {
+        if (fs.existsSync(targetPluginDir) && !options.force) {
+            console.log('[Grok] 0xray Grok plugin is already installed.');
+            console.log('Use --force to reinstall.');
+            return;
+        }
+        fs.cpSync(sourceDir, targetPluginDir, { recursive: true, force: true });
+        frameworkLogger.log('grok-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
+        console.log(`\x1b[32m✓ Copied Grok plugin to ${targetPluginDir}\x1b[0m`);
+        // Attempt auto-trust (best effort)
+        try {
+            execSync(`grok plugins trust "${targetPluginDir}"`, { stdio: 'ignore' });
+            console.log('\x1b[32m✓ Auto-trusted the 0xray plugin with Grok CLI\x1b[0m');
+        }
+        catch {
+            console.log('\nPlease run this command to fully trust the plugin:');
+            console.log(`  grok plugins trust "${targetPluginDir}"`);
+        }
+        // Register MCP servers via grok mcp add (most reliable mechanism)
+        const govMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/governance.server.js');
+        const skillsMcpPath = path.resolve(__dirname, '..', '..', '..', 'dist/mcps/knowledge-skills/skill-invocation.server.js');
+        try {
+            execSync(`grok mcp add strray-governance --command node --args "${govMcpPath}" --env "STRRAY_FORCE_MCP_GOVERNANCE=true" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            execSync(`grok mcp add strray-skills --command node --args "${skillsMcpPath}" --env "STRRAY_ROOT=${process.cwd()}"`, { stdio: 'pipe' });
+            console.log('\x1b[32m✓ Registered strray MCP servers with Grok CLI\x1b[0m');
+        }
+        catch {
+            console.log('\nCould not auto-register MCP servers. Run manually:');
+            console.log(`  grok mcp add strray-governance --command node --args "${govMcpPath}"`);
+            console.log(`  grok mcp add strray-skills --command node --args "${skillsMcpPath}"`);
+        }
+        console.log('\n✅ 0xRay is now installed as a first-class Grok CLI plugin!');
+        console.log('Restart Grok or run `grok` to load the new hooks and MCP servers.');
+    }
+    catch (err) {
+        frameworkLogger.log('grok-integration', 'install-error', 'error', { error: err.message });
+        console.error('Failed to install Grok plugin:', err.message);
+    }
+    frameworkLogger.log('grok-integration', 'install-complete', 'info', {});
+}
+export default {
+    installForGrokCLI,
+};

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

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Grok CLI PreToolUse Hook Handler for StringRay (0xRay) — First Class Citizen
+ *
+ * Real governance enforcement hook.
+ * When Grok is about to execute a tool (write_file, edit, terminal cmd, etc.),
+ * this script is spawned and runs the Dynamo Solar SSOT decision matrix.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const log = (msg) => { try { console.error(`[0xRay:GrokHook] ${msg}`); } catch { /* noop */ } };
+
+function findGovernanceCore() {
+  const here = path.dirname(new URL(import.meta.url).pathname);
+
+  // Priority: explicit dev root
+  const devRoot = process.env.STRRAY_ROOT;
+  if (devRoot) {
+    const devCandidate = path.resolve(devRoot, 'dist/governance/governance-core.js');
+    if (fs.existsSync(devCandidate)) return devCandidate;
+  }
+
+  const candidates = [
+    // Published package layout
+    path.resolve(here, '../../../governance/governance-core.js'),
+    path.resolve(here, '../../../../governance/governance-core.js'),
+    // node_modules installed layout
+    path.resolve(process.cwd(), 'node_modules/0xray/dist/governance/governance-core.js'),
+    // Dev layout fallbacks (no extra dist/)
+    path.resolve(here, '../../../../../governance/governance-core.js'),
+    path.resolve(process.cwd(), 'dist/governance/governance-core.js'),
+    // Strong dev fallback: walk up looking for package.json
+    ...walkUpForCore(here),
+  ];
+
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+function walkUpForCore(startDir, maxLevels = 8) {
+  const results = [];
+  let current = startDir;
+  for (let i = 0; i < maxLevels; i++) {
+    const pkgPath = path.resolve(current, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        if (pkg.name === 'strray-ai' || pkg.name === 'stringray' || pkg.name === '0xray') {
+          results.push(path.resolve(current, 'dist/governance/governance-core.js'));
+          results.push(path.resolve(current, 'governance/governance-core.js'));
+        }
+      } catch {}
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return results;
+}
+
+function deriveResonance(toolName, extra = '') {
+  const text = (toolName + ' ' + extra).toLowerCase();
+  let score = 0.85; // baseline good
+  const penalties = [
+    ['any', -0.25],
+    ['eval(', -0.35],
+    ['console.log', -0.15],
+    ['// @ts-ignore', -0.2],
+    ['require(', -0.1],
+  ];
+  for (const [pat, pen] of penalties) {
+    if (text.includes(pat)) score += pen;
+  }
+  return Math.max(0.1, Math.min(0.99, score));
+}
+
+async function main() {
+  try {
+    const toolName = process.env.TOOL_NAME || process.env.HOOK_TOOL || 'unknown_tool';
+    const cwd = process.env.PWD || process.cwd();
+    const extraContext = process.env.HOOK_ARGS || process.env.TOOL_ARGS || '';
+
+    log(`PreToolUse: ${toolName}`);
+
+    const corePath = findGovernanceCore();
+    let recommendation = 'ALLOW';
+    let resonance = deriveResonance(toolName, extraContext);
+    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}`);
+      }
+    } else {
+      log('Governance core not located — using safe default');
+    }
+
+    const decision = {
+      tool: toolName,
+      decision: recommendation === 'PASS' ? 'allow' : 'allow_with_governance_note',
+      resonance: Number(resonance.toFixed(3)),
+      solar_recommendation: recommendation,
+      gov: govDetails,
+      timestamp: new Date().toISOString(),
+      source: '0xray/grok-pre-tool-use',
+    };
+
+    console.log(JSON.stringify(decision));
+    process.exit(0); // non-blocking rollout; future versions can exit(1) on strong reject
+  } catch (err) {
+    log(`Hook failure (non-fatal): ${err.message}`);
+    process.exit(0);
+  }
+}
+
+main();