0xray 3.4.2 → 3.4.3

package/dist/utils/task-graph.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Task graph utilities — pure functions for dependency resolution,
+ * topological sorting, and conflict resolution.
+ *
+ * Extracted from KernelOrchestrator for neutral access.
+ */
+import type { TaskDefinition } from "../agents/types.js";
+/**
+ * DFS-based topological sort with circular dependency detection.
+ */
+export declare function topologicalSort(tasks: TaskDefinition[]): TaskDefinition[];
+/**
+ * Validates that all task dependencies are within the current task batch.
+ * Throws a descriptive error listing cross-orchestrator dependencies.
+ */
+export declare function validateTaskDependencies(tasks: TaskDefinition[]): void;
+export interface ConflictInput {
+    response?: unknown;
+    proposed?: unknown;
+    expertiseScore?: number;
+}
+export interface ConflictResult {
+    response: string;
+    expertiseScore: number;
+}
+/**
+ * Resolve conflicts by majority vote or highest expertise score.
+ */
+export declare function resolveConflicts(conflicts: ConflictInput[], strategy?: "majority_vote" | "expert_priority"): ConflictResult;

package/dist/utils/test-template-generator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Test Template Generator for 0xRay Framework
+ *
+ * Automatically generates test templates for different file types
+ * to ensure consistent test coverage and structure.
+ */
+export interface TestTemplateOptions {
+    filePath: string;
+    componentName?: string;
+    exports?: string[];
+    isReact?: boolean;
+    isTypeScript?: boolean;
+}
+/**
+ * Generate a test template based on file type and structure
+ */
+export declare function generateTestTemplate(options: TestTemplateOptions): string;
+/**
+ * Analyze a source file to extract exports for test generation
+ */
+export declare function analyzeSourceFile(filePath: string): {
+    exports: string[];
+    isReact: boolean;
+    isTypeScript: boolean;
+};

package/dist/utils/token-manager.d.ts

@@ -0,0 +1,48 @@
+export interface TokenLimits {
+    maxPromptTokens: number;
+    warningThreshold: number;
+    modelLimits: Record<string, number>;
+}
+export interface ContextPruningConfig {
+    enabled: boolean;
+    aggressivePruning: boolean;
+    preserveCriticalContext: boolean;
+}
+export declare class TokenManager {
+    private config;
+    constructor(configPath?: string);
+    private loadConfig;
+    /**
+     * Estimate token count for text (rough approximation)
+     * Uses 4 characters per token as a conservative estimate
+     */
+    estimateTokens(text: string): number;
+    /**
+     * Check if prompt exceeds limits
+     */
+    checkLimits(prompt: string, modelName?: string): {
+        withinLimit: boolean;
+        currentTokens: number;
+        maxTokens: number;
+        needsPruning: boolean;
+        warning: boolean;
+    };
+    /**
+     * Prune context to fit within token limits
+     */
+    pruneContext(context: string, targetTokens?: number): string;
+    private extractCriticalSections;
+    private extractSection;
+    private extractNonCriticalContent;
+    private pruneNonCriticalContent;
+    /**
+     * Generate warning message for token limits
+     */
+    generateWarning(limitCheck: ReturnType<TokenManager["checkLimits"]>): string;
+    /**
+     * Get current configuration
+     */
+    getConfig(): TokenLimits & {
+        contextPruning: ContextPruningConfig;
+    };
+}

package/dist/validation/agent-config-validator.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Agent Configuration Validator
+ *
+ * Validates agent configuration files for correctness and completeness
+ * ensuring all required fields are present and properly formatted.
+ *
+ * @since 2026-01-23
+ */
+export interface AgentConfig {
+    name: string;
+    description: string;
+    version: string;
+    model: string;
+    mode: "primary" | "subagent";
+    logging?: {
+        level: string;
+        format: string;
+        destinations: string[];
+        retention_days?: number;
+        sensitive_data_filtering?: boolean;
+        audit_trail?: boolean;
+    };
+    processor_pipeline?: Array<{
+        name: string;
+        type: string;
+        priority: "low" | "medium" | "high" | "critical";
+        timeout_ms?: number;
+        retry_attempts?: number;
+    }>;
+    capabilities?: string[];
+    error_handling?: {
+        retry_attempts?: number;
+        circuit_breaker?: {
+            enabled?: boolean;
+            failure_threshold?: number;
+            recovery_timeout_ms?: number;
+        };
+        fallback_strategy?: string;
+        alert_on_failure?: boolean;
+    };
+    performance?: {
+        timeout_ms?: number;
+        concurrency_limit?: number;
+        memory_limit_mb?: number;
+        cpu_limit_percent?: number;
+    };
+    security?: {
+        sandboxed_execution?: boolean;
+        permission_level?: string;
+        data_classification?: string;
+        encryption_required?: boolean;
+    };
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    config: AgentConfig | null;
+}
+export declare class AgentConfigValidator {
+    private readonly requiredFields;
+    private readonly validModes;
+    private readonly validLogLevels;
+    private readonly validLogFormats;
+    private readonly validPriorities;
+    private readonly validProcessorTypes;
+    /**
+     * Validate agent configuration from file
+     */
+    validateConfigFile(filePath: string): Promise<ValidationResult>;
+    /**
+     * Validate agent configuration object
+     */
+    validateConfig(config: AgentConfig): ValidationResult;
+    /**
+     * Validate logging configuration
+     */
+    private validateLoggingConfig;
+    /**
+     * Validate processor pipeline configuration
+     */
+    private validateProcessorPipeline;
+    /**
+     * Validate performance configuration
+     */
+    private validatePerformanceConfig;
+    /**
+     * Validate security configuration
+     */
+    private validateSecurityConfig;
+    /**
+     * Validate error handling configuration
+     */
+    private validateErrorHandlingConfig;
+    /**
+     * Validate all agent configurations in a directory
+     */
+    validateAllAgentConfigs(agentConfigDir?: string): Promise<{
+        results: Array<{
+            file: string;
+            result: ValidationResult;
+        }>;
+        summary: {
+            total: number;
+            valid: number;
+            invalid: number;
+        };
+    }>;
+}
+export declare const agentConfigValidator: AgentConfigValidator;

package/dist/validation/estimation-validator.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Estimation Validator
+ *
+ * Tracks estimates vs. actuals and provides calibrated estimates
+ * Prevents the "always estimate high" syndrome by learning from history
+ */
+/**
+ * Estimation Validator
+ * Tracks estimates and learns from actuals to improve future predictions
+ */
+export declare class EstimationValidator {
+    private estimations;
+    private calibrations;
+    private readonly STORAGE_KEY;
+    constructor();
+    /**
+     * Start tracking an estimate
+     */
+    startEstimate(taskId: string, description: string, category: string, estimatedMinutes: number, confidence?: 'high' | 'medium' | 'low'): void;
+    /**
+     * Complete tracking and record actual time
+     */
+    completeEstimate(taskId: string): void;
+    /**
+     * Get calibrated estimate based on historical data
+     */
+    getCalibratedEstimate(category: string, baseEstimate: number, confidence?: 'high' | 'medium' | 'low'): {
+        calibratedEstimate: number;
+        calibrationFactor: number;
+        confidence: number;
+    };
+    /**
+     * Check if an estimate needs adjustment
+     */
+    validateEstimate(category: string, estimate: number): {
+        isReasonable: boolean;
+        suggestedEstimate: number;
+        warning?: string;
+    };
+    /**
+     * Get estimation accuracy report
+     */
+    getAccuracyReport(): {
+        overallAccuracy: number;
+        categoryBreakdown: Array<{
+            category: string;
+            sampleSize: number;
+            avgRatio: number;
+            trend: 'over' | 'under' | 'accurate';
+        }>;
+        recommendations: string[];
+    };
+    private updateCalibration;
+    private loadFromStorage;
+    private saveToStorage;
+}
+export declare function getEstimationValidator(): EstimationValidator;
+/**
+ * Decorator for async functions to track estimates
+ */
+export declare function trackEstimate(taskId: string, description: string, category: string, estimatedMinutes: number): (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/dist/validation/orchestration-flow-validator.d.ts

@@ -0,0 +1,87 @@
+/**
+ * COMPREHENSIVE ORCHESTRATION FLOW VALIDATION SUITE
+ * Validates the complete end-to-end orchestration pipeline
+ */
+interface TestResult {
+    testName: string;
+    success: boolean;
+    duration: number;
+    error?: string;
+    metrics: {
+        agentsSpawned: number;
+        agentsCompleted: number;
+        agentsFailed: number;
+        dependenciesResolved: number;
+        monitoringUpdates: number;
+    };
+    validationSteps: ValidationStep[];
+}
+interface ValidationStep {
+    step: string;
+    success: boolean;
+    timestamp: number;
+    details?: unknown;
+}
+declare class OrchestrationFlowValidator {
+    private orchestrator;
+    private stateManager;
+    private agentDelegator;
+    private testResults;
+    constructor();
+    /**
+     * SIMULATION 1: Basic Orchestration Flow
+     * Tests the fundamental orchestration pipeline
+     */
+    testBasicOrchestrationFlow(): Promise<TestResult>;
+    /**
+     * SIMULATION 2: Dependency Management Flow
+     * Tests complex task dependencies and sequencing
+     */
+    testDependencyManagementFlow(): Promise<TestResult>;
+    /**
+     * SIMULATION 3: Error Handling & Recovery Flow
+     * Tests system resilience and fallback mechanisms
+     */
+    testErrorHandlingFlow(): Promise<TestResult>;
+    /**
+     * SIMULATION 4: Performance & Scalability Flow
+     * Tests system performance under load
+     */
+    testPerformanceFlow(): Promise<TestResult>;
+    /**
+     * SIMULATION 5: Monitoring & Cleanup Flow
+     * Tests the complete monitoring and cleanup lifecycle
+     */
+    testMonitoringCleanupFlow(): Promise<TestResult>;
+    /**
+     * Run all orchestration flow validations
+     */
+    runCompleteValidationSuite(): Promise<ValidationSuiteResults>;
+    /**
+     * Generate comprehensive validation report
+     */
+    private generateValidationReport;
+    /**
+     * Generate recommendations based on test results
+     */
+    private generateRecommendations;
+}
+interface ValidationSuiteResults {
+    summary: {
+        totalTests: number;
+        passedTests: number;
+        failedTests: number;
+        successRate: number;
+        totalDuration: number;
+        avgDuration: number;
+    };
+    metrics: {
+        totalAgentsSpawned: number;
+        totalAgentsCompleted: number;
+        totalDependenciesResolved: number;
+        totalMonitoringUpdates: number;
+    };
+    testResults: TestResult[];
+    recommendations: string[];
+}
+export { OrchestrationFlowValidator };

package/dist/validation/report-content-validator.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Report Content Validator
+ * Reads and analyzes full report content to detect hidden errors and inconsistencies
+ */
+export declare class ReportContentValidator {
+    private reportPatterns;
+    /**
+     * Validate full report content for hidden errors
+     */
+    validateReportContent(reportPath: string, reportType: "session" | "framework" | "validation" | "simulation"): Promise<{
+        valid: boolean;
+        issues: string[];
+        summary: {
+            errorCount: number;
+            warningCount: number;
+            falsePositiveCount: number;
+            inconsistencyCount: number;
+            riskLevel: "low" | "medium" | "high" | "critical";
+        };
+        details: {
+            criticalErrors: string[];
+            warnings: string[];
+            falsePositives: string[];
+            inconsistencies: string[];
+        };
+    }>;
+    private validateReportTypeSpecific;
+    private createValidationResult;
+    /**
+     * Get validation patterns for debugging
+     */
+    getValidationPatterns(): {
+        criticalErrors: RegExp[];
+        warnings: RegExp[];
+        falsePositives: RegExp[];
+        inconsistencies: RegExp[];
+    };
+    /**
+     * Add custom validation pattern
+     */
+    addValidationPattern(category: keyof typeof this.reportPatterns, pattern: RegExp): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "3.4.2",
+  "version": "3.4.3",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -60,7 +60,7 @@
     "mcpServersPath": "dist/mcps"
   },
   "scripts": {
-    "prepublishOnly": "node scripts/node/reconcile-version.mjs --check && npm run prepare-consumer && npm run build:all && find dist -name '*.d.ts' -o -name '*.d.ts.map' -o -name '*.js.map' | xargs rm -f",
+    "prepublishOnly": "node scripts/node/reconcile-version.mjs --check && npm run prepare-consumer && npm run build:all && find dist -name '*.js.map' -o -name '*.d.ts.map' | xargs rm -f 2>/dev/null || true",
     "version:bump": "node scripts/node/version-manager.mjs",
     "version": "node scripts/node/version-manager.mjs",
     "prebuild": "rm -rf dist tsconfig.tsbuildinfo tsconfig.*.tsbuildinfo",

package/scripts/node/consumer-install-smoke.mjs

@@ -132,7 +132,18 @@ function main() {
     if (!features.memory_routing) {
       throw new Error("Deployed features.json missing memory_routing block");
     }
-    console.log("  ✅ .xray/features.json deployed with memory_routing");
+    if (features.memory_routing.enabled !== false) {
+      throw new Error(
+        `Shipped template must default memory_routing.enabled=false (got ${features.memory_routing.enabled})`,
+      );
+    }
+    if (!features.inference_governance) {
+      throw new Error("Deployed features.json missing inference_governance block");
+    }
+    if (features.inference_governance.enabled !== false) {
+      throw new Error("Shipped template must default inference_governance.enabled=false");
+    }
+    console.log("  ✅ .xray/features.json deployed (memory_routing + inference_governance opt-in defaults)");
 
     const schemaInPackage = path.join(nmRoot, "xray", "features.schema.json");
     if (!fs.existsSync(schemaInPackage)) {

package/scripts/node/install-bridges.cjs

@@ -400,10 +400,11 @@ function installOpenclawBridge(targetDir, packageRoot, log) {
 const XRAY_CONFIG_FILES = ["codex.json", "features.json", "features.schema.json", "config.json"];
 
 function resolveXrayConfigSource(packageRoot, file) {
-  const dotXray = path.join(packageRoot, ".xray", file);
-  if (fs.existsSync(dotXray)) return dotXray;
+  // Shipped SSOT: xray/ template wins over dev .xray/ runtime copy (P0.2)
   const xrayDir = path.join(packageRoot, "xray", file);
   if (fs.existsSync(xrayDir)) return xrayDir;
+  const dotXray = path.join(packageRoot, ".xray", file);
+  if (fs.existsSync(dotXray)) return dotXray;
   return null;
 }
 

package/src/mcps/governance.server.ts

@@ -23,6 +23,7 @@ import {
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 import { mcpClientManager } from "./mcp-client.js";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { featuresConfigLoader } from "../core/features-config.js";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
@@ -30,7 +31,6 @@ import { randomUUID } from "crypto";
 import { getGovernanceService } from "../governance/governance-service.js";
 import { getCodexPolicyService } from "../governance/codex-policy.service.js";
 import { initializeGovernanceIntegration, shutdownGovernanceIntegration } from "../integrations/governance/index.js";
-import { featuresConfigLoader } from "../core/features-config.js";
 import type { GovernanceRequest } from "../governance/governance-types.js";
 
 interface GovernanceProposalInput {
@@ -231,6 +231,19 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
     });
   }
 
+  /** Align tool default with features.json inference_governance.enabled (P0.2). */
+  private resolveRequireExternal(explicit?: boolean): boolean {
+    if (explicit !== undefined) return explicit;
+    try {
+      const config = featuresConfigLoader.loadConfig() as {
+        inference_governance?: { enabled?: boolean };
+      };
+      return config?.inference_governance?.enabled === true;
+    } catch {
+      return false;
+    }
+  }
+
   private async handleGovernProposals(args: GovernProposalsArgs): Promise<CallToolResult> {
     const service = getGovernanceService();
 
@@ -246,7 +259,7 @@ class GovernanceServer extends XrayKnowledgeSkillBase {
       })),
       context: args.context || {},
       options: {
-        requireExternalDynamo: args.options?.require_external ?? true,
+        requireExternalDynamo: this.resolveRequireExternal(args.options?.require_external),
       },
     };
 

package/xray/features.json

@@ -1,5 +1,6 @@
 {
   "$schema": "./features.schema.json",
+  "version": "3.4.3",
   "description": "0xRay Framework - Unified Feature Configuration",
   "token_optimization": {
     "enabled": true,
@@ -134,13 +135,18 @@
     "min_success_rate": 0.7
   },
   "memory_routing": {
-    "enabled": true,
-    "provider": "repertoire",
-    "module_path": "../repertoire/dist/provider/memory-routing-provider.js",
-    "config": {
-      "dataDir": "../repertoire/data",
-      "signalsPath": "../repertoire/data/curated_signals.json",
-      "logDir": "../repertoire/logs/groover-inference"
+    "enabled": false,
+    "provider": "null",
+    "module_path": "",
+    "config": {}
+  },
+  "inference_governance": {
+    "enabled": false,
+    "request_timeout_ms": 10000,
+    "min_confidence_threshold": 0.5,
+    "proposal_defaults": {
+      "source": "agent",
+      "onChain": false
     }
   }
 }