0xray 3.4.2 → 3.4.3

package/dist/benchmark/performance-benchmark.d.ts

@@ -0,0 +1,103 @@
+export interface BenchmarkResult {
+    operation: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    success: boolean;
+    metadata: Record<string, any>;
+    error?: string | undefined;
+}
+export interface PerformanceMetrics {
+    totalOperations: number;
+    successfulOperations: number;
+    failedOperations: number;
+    averageDuration: number;
+    medianDuration: number;
+    p95Duration: number;
+    p99Duration: number;
+    minDuration: number;
+    maxDuration: number;
+    throughput: number;
+}
+export interface BootBenchmarkResult {
+    totalBootTime: number;
+    phaseTimings: Record<string, number>;
+    componentLoadTimes: Record<string, number>;
+    memoryUsage: {
+        beforeBoot: number;
+        afterBoot: number;
+        peakDuringBoot: number;
+    };
+    success: boolean;
+    errors: string[];
+    orchestratorLoadTime?: number;
+    delegationInitTime?: number;
+    sessionManagementInitTime?: number;
+    processorActivationTime?: number;
+    agentLoadingTime?: number;
+    enforcementActivationTime?: number;
+    codexComplianceActivationTime?: number;
+}
+export interface OrchestratorBenchmarkResult {
+    taskExecutionTimes: number[];
+    delegationLatencies: number[];
+    conflictResolutionTimes: number[];
+    concurrentTaskThroughput: number;
+    dependencyResolutionTime: number;
+    overallSuccess: boolean;
+}
+export interface SessionBenchmarkResult {
+    stateShareLatencies: number[];
+    dependencyUpdateTimes: number[];
+    groupOperationTimes: number[];
+    migrationTimes: number[];
+    failoverTimes: number[];
+    concurrentSessionOperations: number;
+}
+export declare class XrayPerformanceBenchmark {
+    private results;
+    private activeBenchmarks;
+    /**
+     * Start a benchmark measurement
+     */
+    startBenchmark(operation: string, metadata?: Record<string, any>): string;
+    /**
+     * End a benchmark measurement
+     */
+    endBenchmark(benchmarkId: string, success?: boolean, error?: string): BenchmarkResult | null;
+    /**
+     * Benchmark boot sequence performance
+     */
+    benchmarkBootSequence(_bootOrchestrator: unknown): Promise<BootBenchmarkResult>;
+    /**
+     * Benchmark orchestrator task execution
+     */
+    benchmarkOrchestratorTasks(_orchestrator: unknown, taskCount?: number, concurrentTasks?: number): Promise<OrchestratorBenchmarkResult>;
+    /**
+     * Benchmark session management operations
+     */
+    benchmarkSessionOperations(_sessionStateManager: unknown, operationCount?: number): Promise<SessionBenchmarkResult>;
+    /**
+     * Calculate performance metrics from benchmark results
+     */
+    calculateMetrics(operationFilter?: string): PerformanceMetrics;
+    /**
+     * Generate comprehensive benchmark report
+     */
+    generateReport(): {
+        summary: PerformanceMetrics;
+        bootBenchmark?: BootBenchmarkResult;
+        orchestratorBenchmark?: OrchestratorBenchmarkResult;
+        sessionBenchmark?: SessionBenchmarkResult;
+        recommendations: string[];
+    };
+    /**
+     * Clear all benchmark results
+     */
+    clearResults(): void;
+    /**
+     * Export results for external analysis
+     */
+    exportResults(): BenchmarkResult[];
+}
+export declare const performanceBenchmark: XrayPerformanceBenchmark;

package/dist/cli/commands/analytics-disable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics Disable CLI Command
+ *
+ * Disables 0xRay Central Analytics with immediate opt-out
+ *
+ * Usage: npx 0xray analytics disable
+ */
+export declare const analyticsDisableCommand: import("commander").Command;
+export default analyticsDisableCommand;

package/dist/cli/commands/analytics-enable-action.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Analytics Enable Action
+ *
+ * Enables 0xRay Central Analytics with opt-in consent
+ *
+ * Usage: npx 0xray analytics enable [--categories reflections,logs,metrics,patterns]
+ */
+export declare function analyticsEnableAction(options: any): Promise<void>;

package/dist/cli/commands/analytics-preview.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics Preview CLI Command
+ *
+ * Shows what data would be submitted without actually submitting it
+ *
+ * Usage: npx 0xray analytics preview [--type reflections|logs|metrics|patterns] [--all]
+ */
+export declare const analyticsPreviewCommand: import("commander").Command;
+export default analyticsPreviewCommand;

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

@@ -0,0 +1,9 @@
+/**
+ * Analytics Status CLI Command
+ *
+ * Shows current consent and analytics status
+ *
+ * Usage: npx 0xray analytics status
+ */
+export declare const analyticsStatusCommand: import("commander").Command;
+export default analyticsStatusCommand;

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

@@ -0,0 +1,9 @@
+/**
+ * Antigravity Status CLI Command
+ *
+ * Shows status of all installed skills.
+ *
+ * Usage: npx 0xray antigravity status
+ */
+export declare function antigravityStatusCommand(): Promise<void>;
+export default antigravityStatusCommand;

package/dist/cli/commands/archive-logs.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Standalone Log Archive CLI
+ *
+ * Archives log files without requiring framework boot.
+ * Used by git hooks to prevent log truncation.
+ *
+ */
+interface ArchiveResult {
+    archived: number;
+    errors: string[];
+}
+interface LogArchiveConfig {
+    maxFileSizeMB: number;
+    rotationIntervalHours: number;
+    compressionEnabled: boolean;
+    maxArchives: number;
+}
+/**
+ * Archive log files without framework dependencies
+ */
+export declare function archiveLogFiles(config?: LogArchiveConfig, jobId?: string): Promise<ArchiveResult>;
+export {};

package/dist/cli/commands/credible-init.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Credible Init CLI Command
+ *
+ * Initializes a Credible Pod - a self-contained agent environment.
+ *
+ * Usage: npx 0xray credible init [options]
+ *
+ * Status: PLANNED - Not yet implemented
+ */
+export declare function credibleInitCommand(): Promise<void>;
+export default credibleInitCommand;

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

@@ -0,0 +1,12 @@
+interface EnforceOptions {
+    phase: string;
+    tool?: string;
+    args?: string;
+    result?: string;
+    error?: string;
+    files?: string;
+    code?: string;
+    focusAreas?: string;
+}
+export declare function enforceCommand(options: EnforceOptions): Promise<void>;
+export {};

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

@@ -0,0 +1,29 @@
+/**
+ * xray govern — the primary CLI command for the v3 nucleus
+ *
+ * Usage:
+ *   xray govern [options]
+ *
+ * All existing direct commands still work (backward compat with deprecation notice).
+ */
+interface GovernOptions {
+    status?: boolean;
+    audit?: boolean;
+    mcp?: string;
+    pluginInstall?: string;
+    proposals?: string;
+    skillInstall?: string;
+    skillRegistry?: string;
+    storyteller?: string;
+    mcpList?: boolean;
+    mcpStatus?: boolean;
+    mcpInstall?: string;
+    mcpRemove?: string;
+    publishAgent?: boolean;
+    archiveLogs?: boolean;
+    credibleInit?: string;
+    antigravityStatus?: boolean;
+    [key: string]: unknown;
+}
+export declare function governCommand(options: GovernOptions): Promise<void>;
+export {};

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/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/openclaw-install.d.ts

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

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,18 @@
+/**
+ * Plugin CLI Commands
+ *
+ * CLI commands for plugin management:
+ * - plugin list
+ * - plugin install (from npm or local)
+ * - plugin enable
+ * - plugin disable
+ * - plugin status
+ * - plugin uninstall
+ *
+ */
+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/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/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,6 @@
+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>;
+export declare function syncBuiltinSkills(targetSkillsDir: string, packageRoot?: string): number;

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/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/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/server.d.ts

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

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/config/routing-mappings.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Routing Mappings — Shared keyword→agent+skill lookup table.
+ *
+ * Extracted from enforcer-tools.ts to be queryable at runtime
+ * by the main AI delegation decision tools.
+ */
+export interface RoutingMappingEntry {
+    keywords: string[];
+    skill: string;
+    agent: string;
+    confidence: number;
+}
+export declare const ROUTING_MAPPINGS: RoutingMappingEntry[];
+export interface RoutingMatch {
+    agent: string;
+    skill: string;
+    confidence: number;
+    matchedKeywords: string[];
+}
+export declare function queryRoutingMappings(keywords: string[]): RoutingMatch[];
+export declare function getAllRoutingMappings(): RoutingMappingEntry[];
+/**
+ * Validate that all agent names in routing mappings exist in the SSOT.
+ * Call at boot to detect drift.
+ */
+export declare function validateRoutingMappings(validAgents: string[]): string[];

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

@@ -0,0 +1,71 @@
+/**
+ * Activity Logger
+ *
+ * Comprehensive logging for all 0xRay activities including:
+ * - Framework operations
+ * - Development sessions
+ * - Script executions
+ * - File operations
+ * - Test results
+ *
+ * Enable/Disable via:
+ *   XRAY_ACTIVITY_LOGGING=true  (enable)
+ *   XRAY_ACTIVITY_LOGGING=false (disable, default)
+ *
+ * @module core/activity-logger
+ */
+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,108 @@
+/**
+ * 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.
+ *
+ * @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 };