0xray 2.0.0 → 2.1.0

package/dist/cli/commands/grok-install.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI command: 0xray grok install
+ *
+ * Helps users register 0xRay MCP servers with the Grok CLI.
+ */
+import { Command } from 'commander';
+export declare function registerGrokCommands(grokCmd: Command): void;

package/dist/cli/commands/hermes-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerHermesCommands(hermesCmd: Command): void;

package/dist/cli/commands/hermes-install.js

@@ -16,14 +16,14 @@ export function registerHermesCommands(hermesCmd) {
 async function installForHermes(options = {}) {
     frameworkLogger.log('hermes-integration', 'install-start', 'info', { options });
     const home = homedir();
-    const targetPluginDir = path.join(home, '.hermes/plugins/strray-hermes');
+    const targetPluginDir = path.join(home, '.hermes/plugins/xray-hermes');
     const possibleSources = [
         path.join(__dirname, '..', '..', '..', 'dist/integrations/hermes-agent'),
         path.join(__dirname, '..', '..', '..', 'src/integrations/hermes-agent'),
     ];
     let sourceDir = possibleSources.find(p => fs.existsSync(p));
     if (!sourceDir) {
-        console.error('[Hermes] Could not locate the strray-hermes plugin inside the package.');
+        console.error('[Hermes] Could not locate the xray-hermes plugin inside the package.');
         return;
     }
     if (options.dryRun) {
@@ -32,7 +32,7 @@ async function installForHermes(options = {}) {
     }
     try {
         if (fs.existsSync(targetPluginDir) && !options.force) {
-            console.log('[Hermes] strray-hermes plugin is already installed.');
+            console.log('[Hermes] xray-hermes plugin is already installed.');
             console.log('Use --force to reinstall.');
             return;
         }
@@ -56,7 +56,7 @@ async function installForHermes(options = {}) {
         }
         console.log('\n✅ 0xRay is now installed as a Hermes Agent plugin!');
         console.log('Restart Hermes to load the plugin and its tools.');
-        console.log('  Run: /strray status  (to verify)');
+        console.log('  Run: npx 0xray status  (to verify)');
     }
     catch (err) {
         frameworkLogger.log('hermes-integration', 'install-error', 'error', { error: err.message });

package/dist/cli/commands/mcp-install.d.ts

@@ -0,0 +1,4 @@
+export declare function listMCPsCommand(): void;
+export declare function showMCPStatusCommand(): void;
+export declare function installMCPCommand(name: string): Promise<void>;
+export declare function removeMCPCommand(name: string): void;

package/dist/cli/commands/mcp-install.js

@@ -3,7 +3,7 @@ import { join, dirname } from "path";
 import { execSync } from "child_process";
 import { getConfigDir } from "../../core/config-paths.js";
 function getMCPConfigPath() {
-    return join(process.cwd(), ".opencode", "strray", "mcp-registry.json");
+    return join(process.cwd(), ".opencode", "xray", "mcp-registry.json");
 }
 function getBundledMCPRegistry() {
     const paths = [

package/dist/cli/commands/openclaw-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerOpenClawCommands(openclawCmd: Command): void;

package/dist/cli/commands/openclaw-install.js

@@ -14,7 +14,7 @@ export function registerOpenClawCommands(openclawCmd) {
 }
 async function installForOpenClaw(options = {}) {
     frameworkLogger.log('openclaw-integration', 'install-start', 'info', { options });
-    const configPath = path.join(process.cwd(), '.strray', 'config', 'openclaw.json');
+    const configPath = path.join(process.cwd(), '.xray', 'config', 'openclaw.json');
     if (options.dryRun) {
         console.log(`[OpenClaw] Dry run: Would create config at ${configPath}`);
         return;

package/dist/cli/commands/opencode-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerOpencodeCommands(opencodeCmd: Command): void;

package/dist/cli/commands/plugin-commands.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Plugin CLI Commands
+ *
+ * CLI commands for plugin management:
+ * - plugin list
+ * - plugin install (from npm or local)
+ * - plugin enable
+ * - plugin disable
+ * - plugin status
+ * - plugin uninstall
+ *
+ * @version 1.1.0
+ */
+export declare function pluginListCommand(): Promise<void>;
+export declare function pluginInstallCommand(pluginName: string): Promise<void>;
+export declare function pluginEnableCommand(pluginName: string): Promise<void>;
+export declare function pluginDisableCommand(pluginName: string): Promise<void>;
+export declare function pluginStatusCommand(pluginName: string): Promise<void>;
+export declare function pluginUninstallCommand(pluginName: string): Promise<void>;

package/dist/cli/commands/plugin-commands.js

@@ -14,8 +14,8 @@
 import * as fs from "fs";
 import * as path from "path";
 import { spawnSync } from "child_process";
-const PLUGINS_DIR = ".strray/plugins";
-const CONFIG_PATH = ".strray/config/plugin-config.json";
+const PLUGINS_DIR = ".xray/plugins";
+const CONFIG_PATH = ".xray/config/plugin-config.json";
 export async function pluginListCommand() {
     console.log("\n📦 0xRay Plugins\n");
     console.log("═".repeat(60));

package/dist/cli/commands/publish-agent.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Publish Agent CLI Command
+ *
+ * Packages and publishes agents to AgentStore for sharing.
+ *
+ * Usage: npx 0xray publish-agent [options]
+ * Options:
+ *   --agent <name>    Agent name to publish (required)
+ *   --version <ver>   Version (optional, auto-detected)
+ *   --dry-run         Preview package without publishing
+ *
+ * Example: npx 0xray publish-agent --agent orchestrator --dry-run
+ */
+export declare function publishAgentCommand(): Promise<void>;
+export default publishAgentCommand;

package/dist/cli/commands/publish-agent.js

@@ -69,10 +69,10 @@ function getPackageVersion(cwd) {
         }
     }
     catch { /* ignore */ }
-    const strrayPkgPath = join(cwd, ".opencode", "package.json");
+    const xrayPkgPath = join(cwd, ".opencode", "package.json");
     try {
-        if (existsSync(strrayPkgPath)) {
-            const pkg = JSON.parse(readFileSync(strrayPkgPath, "utf-8"));
+        if (existsSync(xrayPkgPath)) {
+            const pkg = JSON.parse(readFileSync(xrayPkgPath, "utf-8"));
             if (pkg.version)
                 return pkg.version;
         }
@@ -89,7 +89,7 @@ function createAgentManifest(agentName, configPath, version, cwd) {
         author: extractYamlField(content, "author") || extractYamlField(content, "maintainer") || "0xRay User",
         license: extractYamlField(content, "license") || "MIT",
         source: extractYamlField(content, "source") || "custom",
-        framework: "stringray",
+        framework: "xray",
         frameworkVersion: getPackageVersion(cwd),
         publishedAt: new Date().toISOString(),
         skills: [],
@@ -98,7 +98,7 @@ function createAgentManifest(agentName, configPath, version, cwd) {
     };
 }
 function packageAgent(agentName, configPath, version, cwd) {
-    const outputDir = join(cwd, ".strray", "publish", agentName);
+    const outputDir = join(cwd, ".xray", "publish", agentName);
     mkdirSync(outputDir, { recursive: true });
     const manifest = createAgentManifest(agentName, configPath, version, cwd);
     writeFileSync(join(outputDir, "agent.json"), JSON.stringify(manifest, null, 2));

package/dist/cli/commands/security-audit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Security Audit CLI Command
+ *
+ * Comprehensive security audit with vulnerability scanning,
+ * compliance checking, and weighted voting for architectural decisions.
+ *
+ * Usage:
+ *   npx 0xray security-audit           # Quick audit
+ *   npx 0xray security-audit --deep    # Deep audit with all standards
+ *   npx 0xray security-audit --output ./reports/security.md
+ *   npx 0xray security-audit --no-remediation
+ *   npx 0xray security-audit --no-voting
+ *
+ * Options:
+ *   --deep           Deep scan with all compliance standards (OWASP, CWE, NIST, ISO, PCI)
+ *   --output <path>  Output report to file (JSON or Markdown)
+ *   --format <fmt>   Output format: json, markdown (default: markdown)
+ *   --no-remediation Skip automated remediation analysis
+ *   --no-voting      Disable weighted voting for architectural decisions
+ *   --project <path> Project path to audit (default: current directory)
+ */
+export declare function securityAuditCommand(args?: string[]): Promise<void>;
+export default securityAuditCommand;

package/dist/cli/commands/skill-install.d.ts

@@ -0,0 +1,5 @@
+export declare function skillInstallCommand(sourceArg?: string, options?: {
+    force?: boolean;
+    path?: string;
+}): Promise<void>;
+export declare function skillRegistryCommand(action?: string, args?: Record<string, string>): Promise<void>;

package/dist/cli/commands/skill-install.js

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync
 import { join, basename, dirname } from "path";
 import { execSync } from "child_process";
 function getLocalRegistryPath() {
-    return join(process.cwd(), ".opencode", "strray", "skill-registry.json");
+    return join(process.cwd(), ".opencode", "xray", "skill-registry.json");
 }
 function getBundledRegistry() {
     const paths = [

package/dist/cli/commands/status.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Status CLI Command
+ *
+ * Shows comprehensive framework status including:
+ * - OpenCode installation status
+ * - Installed skills
+ * - Configured agents
+ * - Health metrics
+ * - Inference engine status
+ *
+ * Usage: npx 0xray status
+ */
+interface StatusReport {
+    opencode: {
+        installed: boolean;
+        configFound: boolean;
+    };
+    skills: {
+        count: number;
+        names: string[];
+    };
+    agents: {
+        count: number;
+        names: string[];
+    };
+    health: {
+        logPath: string;
+        logExists: boolean;
+        recentEntries: number;
+    };
+    inference: {
+        active: boolean;
+        lastTuning: string | null;
+        outcomesCount: number;
+        patternsCount: number;
+    };
+}
+export declare function getStatusReport(cwd?: string): StatusReport;
+export declare function printStatus(report: StatusReport): void;
+export declare function statusCommand(): Promise<void>;
+export default statusCommand;

package/dist/cli/commands/status.js

@@ -41,7 +41,7 @@ function getAgentsList(cwd) {
     ];
     const configuredAgents = [];
     const configDir = getConfigDir(cwd);
-    const agentsConfigPath = join(configDir, "strray", "agents.json");
+    const agentsConfigPath = join(configDir, "xray", "agents.json");
     if (existsSync(agentsConfigPath)) {
         try {
             const config = JSON.parse(readFileSync(agentsConfigPath, "utf-8"));
@@ -51,7 +51,7 @@ function getAgentsList(cwd) {
         }
         catch { /* ignore */ }
     }
-    const featuresPath = join(configDir, "strray", "features.json");
+    const featuresPath = join(configDir, "xray", "features.json");
     if (existsSync(featuresPath)) {
         try {
             const features = JSON.parse(readFileSync(featuresPath, "utf-8"));
@@ -93,7 +93,7 @@ function getInferenceStatus(cwd) {
     let outcomesCount = 0;
     let patternsCount = 0;
     try {
-        const inferenceDir = join(getConfigDir(cwd), "strray", "inference");
+        const inferenceDir = join(getConfigDir(cwd), "xray", "inference");
         const tunerStatusPath = join(inferenceDir, "tuner-status.json");
         if (existsSync(tunerStatusPath)) {
             const status = JSON.parse(readFileSync(tunerStatusPath, "utf-8"));

package/dist/cli/commands/storyteller.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Storyteller CLI Command
+ *
+ * Invokes the storyteller skill to write reflections, sagas, journeys, or narratives.
+ * Automatically determines story type based on context if not specified.
+ *
+ * Usage:
+ *   npx 0xray storyteller reflection
+ *   npx 0xray storyteller saga "v1.18.0 Release Journey"
+ *   npx 0xray storyteller journey --title "API Migration"
+ *   npx 0xray storyteller narrative --framework hero_journey
+ */
+export declare function storytellerCommand(storyType?: string, options?: {
+    title?: string;
+    framework?: string;
+    output?: string;
+    dryRun?: boolean;
+}): Promise<void>;
+export default storytellerCommand;

package/dist/cli/commands/storyteller.js

@@ -16,8 +16,8 @@ import { execSync } from "child_process";
 const STORY_TYPES = ["reflection", "saga", "journey", "narrative"];
 function loadConfig(cwd) {
     const candidates = [
-        join(cwd, ".opencode", "strray", "features.json"),
-        join(cwd, ".strray", "features.json"),
+        join(cwd, ".opencode", "xray", "features.json"),
+        join(cwd, ".xray", "features.json"),
     ];
     for (const path of candidates) {
         if (existsSync(path)) {

package/dist/cli/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * xray CLI - Command Line Interface
+ *
+ * Provides commands for installing and managing xray framework
+ */
+export {};

package/dist/cli/index.js

@@ -385,7 +385,7 @@ program
         const path = await import("path");
         let defaultLimit = 500;
         try {
-            const featuresPath = path.join(process.cwd(), ".opencode", "plugins", "features.json"); // plain xray primary (min compat .strray/ handled in getConfigDir per Scope Rule)
+            const featuresPath = path.join(process.cwd(), ".opencode", "plugins", "features.json"); // plain xray primary (min compat .xray/ handled in getConfigDir per Scope Rule)
             if (fs.existsSync(featuresPath)) {
                 const features = JSON.parse(fs.readFileSync(featuresPath, "utf-8"));
                 defaultLimit = features.analytics?.default_limit || 500;
@@ -450,17 +450,17 @@ program
         else {
             console.log("✅ xray package installed");
         }
-        // Check configuration - check for opencode.json or .strray/ (min compat .strray/ fallback for prior StringRay consumer runtime per Scope Rule; plain xray primary)
+        // Check configuration - check for opencode.json or .xray/ (min compat .xray/ fallback for prior StringRay consumer runtime per Scope Rule; plain xray primary)
         const cwd = process.cwd();
         const opencodeConfigPath = path.join(cwd, "opencode.json");
-        const strrayDir = getConfigDir(cwd);
+        const xrayDir = getConfigDir(cwd);
         const opencodeExists = fs.existsSync(opencodeConfigPath);
-        const strrayDirExists = fs.existsSync(strrayDir);
+        const xrayDirExists = fs.existsSync(xrayDir);
         if (opencodeExists) {
             console.log("✅ opencode configuration found");
         }
-        else if (strrayDirExists) {
-            console.log(`✅ Configuration directory found: ${strrayDir}`);
+        else if (xrayDirExists) {
+            console.log(`✅ Configuration directory found: ${xrayDir}`);
         }
         else {
             console.log("ℹ️  No opencode.json or config directory found (run: npx xray fix to create)");
@@ -684,13 +684,13 @@ program
         }
         else {
             console.log('Inference feature is disabled in features.json.');
-            console.log('Enable it by setting inference.enabled = true in .opencode/plugins/features.json (min compat .strray/ fallback for prior StringRay consumer runtime per Scope Rule)');
+            console.log('Enable it by setting inference.enabled = true in .opencode/plugins/features.json (min compat .xray/ fallback for prior StringRay consumer runtime per Scope Rule)');
         }
         return;
     }
     const projectRoot = process.cwd();
     const inferenceDir = `${projectRoot}/docs/inference`;
-    const stateDir = `${projectRoot}/.strray/inference`;
+    const stateDir = `${projectRoot}/.xray/inference`;
     const stateFile = `${stateDir}/inference-cycle-state.json`;
     if (!options.json) {
         console.log('xray Inference Cycle');

package/dist/cli/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/server.js

@@ -112,7 +112,7 @@ app.get("/", (req, res) => {
 });
 // Add route for refactoring logs
 app.get("/logs", requireAuth, async (req, res) => {
-    const logPath = resolveConfigPath("REFACTORING_LOG.md") || join(__dirname, "..", ".strray", "REFACTORING_LOG.md");
+    const logPath = resolveConfigPath("REFACTORING_LOG.md") || join(__dirname, "..", ".xray", "REFACTORING_LOG.md");
     // Server debug logging - remove for production
     try {
         if (fs.existsSync(logPath)) {

package/dist/config/default-agents.d.ts

@@ -0,0 +1,12 @@
+export interface DefaultAgentConfig {
+    name: string;
+    capabilities: string[];
+    status: "active" | "inactive";
+    expertise: string;
+    capacity: number;
+    performance: number;
+    specialties: string[];
+}
+export declare const DEFAULT_AGENTS: DefaultAgentConfig[];
+export declare function getDefaultAgents(): DefaultAgentConfig[];
+export declare function getDefaultAgentByName(name: string): DefaultAgentConfig | undefined;

package/dist/core/activity-logger.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Activity Logger
+ *
+ * Comprehensive logging for all 0xRay activities including:
+ * - Framework operations
+ * - Development sessions
+ * - Script executions
+ * - File operations
+ * - Test results
+ *
+ * Enable/Disable via:
+ *   STRRAY_ACTIVITY_LOGGING=true  (enable)
+ *   STRRAY_ACTIVITY_LOGGING=false (disable, default)
+ *
+ * @module core/activity-logger
+ * @version 1.0.0
+ */
+export type ActivityCategory = "framework" | "development" | "script" | "file" | "test" | "commit" | "session" | "agent" | "processor" | "config";
+export type ActivityLevel = "debug" | "info" | "warn" | "error" | "success";
+export interface ActivityRecord {
+    timestamp: string;
+    id: string;
+    category: ActivityCategory;
+    level: ActivityLevel;
+    action: string;
+    message: string;
+    details?: Record<string, unknown>;
+    sessionId?: string;
+    jobId?: string;
+}
+/**
+ * Initialize activity logger with config from features.json
+ * Called by boot-orchestrator during initialization
+ */
+export declare function initializeActivityLogger(config?: {
+    enabled?: boolean;
+    log_path?: string;
+}): void;
+/**
+ * Check if activity logging is enabled
+ */
+export declare function isActivityLoggingEnabled(): boolean;
+/**
+ * Enable or disable activity logging
+ */
+export declare function setActivityLoggingEnabled(enabled: boolean): void;
+/**
+ * Get current session ID
+ */
+export declare function getSessionId(): string;
+/**
+ * Log an activity
+ */
+export declare function logActivity(category: ActivityCategory, level: ActivityLevel, action: string, message: string, details?: Record<string, unknown>, options?: {
+    sessionId?: string;
+    jobId?: string;
+}): void;
+export declare const activity: {
+    framework: (action: string, message: string, details?: Record<string, unknown>) => void;
+    development: (action: string, message: string, details?: Record<string, unknown>) => void;
+    script: (action: string, message: string, details?: Record<string, unknown>) => void;
+    file: (action: string, message: string, details?: Record<string, unknown>) => void;
+    test: (action: string, message: string, details?: Record<string, unknown>) => void;
+    commit: (action: string, message: string, details?: Record<string, unknown>) => void;
+    session: (action: string, message: string, details?: Record<string, unknown>) => void;
+    agent: (action: string, message: string, details?: Record<string, unknown>) => void;
+    processor: (action: string, message: string, details?: Record<string, unknown>) => void;
+    config: (action: string, message: string, details?: Record<string, unknown>) => void;
+    success: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+    error: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+    warn: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+};

package/dist/core/adaptive-kernel.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Adaptive Kernel Extension for P9 - ADAPTIVE_PATTERN_LEARNING
+ *
+ * Composes with existing Kernel to add self-modifying pattern learning capabilities.
+ * Enables continuous pattern improvement based on performance data.
+ *
+ * @version 1.0.0
+ * @since 2026-03-05
+ */
+import { type KernelInferenceResult, type AdaptiveThresholds, type EmergentPattern, type PatternUpdate } from "../core/kernel-patterns.js";
+import { patternPerformanceTracker } from "../analytics/pattern-performance-tracker.js";
+import { emergingPatternDetector } from "../analytics/emerging-pattern-detector.js";
+import { patternLearningEngine } from "../analytics/pattern-learning-engine.js";
+export interface AdaptiveKernelConfig {
+    enabled: boolean;
+    enableP9Learning: boolean;
+    learningIntervalMs: number;
+    autoApplyThreshold: number;
+    confidenceThreshold: number;
+    maxPatternsPerAnalysis: number;
+}
+export interface P9AnalysisResult extends KernelInferenceResult {
+    patternDriftDetected: boolean;
+    driftAnalyses: Array<{
+        patternId: string;
+        driftMagnitude: number;
+        driftDirection: 'increasing' | 'decreasing' | 'unstable';
+        recommendedAction: string;
+    }>;
+    emergentPatterns: EmergentPattern[];
+    suggestedUpdates: PatternUpdate[];
+    adaptiveThresholds?: AdaptiveThresholds;
+    learningApplied: boolean;
+}
+export declare class AdaptiveKernelAnalyzer {
+    private adaptiveConfig;
+    private baseKernel;
+    private lastLearningRun;
+    private cachedP9Analysis;
+    private cacheValidMs;
+    constructor(config?: Partial<AdaptiveKernelConfig>);
+    /**
+     * Analyze observation using base kernel enhanced with P9 learning
+     */
+    analyze(observation: string): KernelInferenceResult;
+    /**
+     * Enhanced analyze with P9 learning capabilities
+     */
+    analyzeWithP9(observation: string): P9AnalysisResult;
+    /**
+     * Perform P9 adaptive pattern learning analysis
+     */
+    private performP9Analysis;
+    /**
+     * Get current adaptive thresholds
+     */
+    getAdaptiveThresholds(): AdaptiveThresholds;
+    /**
+     * Get pattern drift analyses
+     */
+    getPatternDrift(): Array<{
+        patternId: string;
+        driftMagnitude: number;
+        driftDirection: 'increasing' | 'decreasing' | 'unstable';
+        recommendedAction: string;
+    }>;
+    /**
+     * Manually trigger learning cycle
+     */
+    triggerLearning(outcomes: Array<{
+        taskId: string;
+        taskDescription: string;
+        routedAgent: string;
+        routedSkill: string;
+        confidence: number;
+        success: boolean;
+    }>, existingMappings: Array<{
+        keywords: string[];
+        skill: string;
+        agent: string;
+        confidence: number;
+    }>): {
+        newPatterns: number;
+        modifiedPatterns: number;
+        removedPatterns: number;
+        thresholdUpdates: number;
+        recommendations: string[];
+    };
+    /**
+     * Get learning statistics
+     */
+    getLearningStats(): {
+        lastLearningRun: Date;
+        cacheValid: boolean;
+        patternsTracked: number;
+        driftDetected: number;
+        thresholdsCalibrated: boolean;
+    };
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig: Partial<AdaptiveKernelConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): AdaptiveKernelConfig;
+}
+export declare function getAdaptiveKernel(config?: Partial<AdaptiveKernelConfig>): AdaptiveKernelAnalyzer;
+export { patternPerformanceTracker, emergingPatternDetector, patternLearningEngine };

package/dist/core/agent-spawn-gate.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Agent Spawn Gate — Singleton (provider-agnostic)
+ *
+ * CENTRALIZED CONTROL for all agent process spawning across Xray
+ * (OpenCode, Hermes, or any other MCP-compatible host).
+ *
+ * Purpose:
+ *   Prevent runaway recursive agent spawning.
+ *
+ * Design:
+ *   - Singleton instance shared across all modules
+ *   - Explicit enable/disable with state persistence
+ *   - Tracks all active spawned processes for cleanup
+ *   - Gates every spawn path: inference, orchestrator, scripts, tests
+ *
+ * Usage:
+ *   import { spawnGate } from "./agent-spawn-gate.js";
+ *
+ *   // Before spawning
+ *   spawnGate.assertAllowed("inference-cycle");
+ *
+ *   // Global disable (emergency brake)
+ *   spawnGate.disable("emergency: runaway processes detected");
+ */
+declare class AgentSpawnGate {
+    private static instance;
+    private state;
+    private constructor();
+    static getInstance(): AgentSpawnGate;
+    /** Check if spawning is globally allowed */
+    isAllowed(): boolean;
+    /** Enable spawning (opt-in, not default) */
+    enable(reason: string): void;
+    /** Disable spawning globally */
+    disable(reason: string): void;
+    /** Assert spawning is allowed or throw */
+    assertAllowed(module: string): void;
+    /** Register a spawned process PID for tracking */
+    trackProcess(pid: number, module: string, description: string): void;
+    /** Unregister a process when it exits */
+    untrackProcess(pid: number): void;
+    /** Kill all tracked processes (emergency cleanup) */
+    killAllProcesses(signal?: NodeJS.Signals): Promise<number>;
+    /** Get current gate status */
+    getStatus(): {
+        enabled: boolean;
+        reason: string | undefined;
+        disabledAt: number | undefined;
+        activeProcesses: number;
+        totalSpawned: number;
+        totalBlocked: number;
+    };
+}
+/** Singleton export — use this everywhere (provider-agnostic) */
+export declare const spawnGate: AgentSpawnGate;
+export default spawnGate;

package/dist/core/agent-spawn-gate.js

@@ -1,7 +1,7 @@
 /**
  * Agent Spawn Gate — Singleton (provider-agnostic)
  *
- * CENTRALIZED CONTROL for all agent process spawning across StringRay
+ * CENTRALIZED CONTROL for all agent process spawning across Xray
  * (OpenCode, Hermes, or any other MCP-compatible host).
  *
  * Purpose: