0xray 3.2.0 → 3.3.1

package/dist/mcps/researcher-confidence.js

@@ -0,0 +1,92 @@
+import { frameworkLogger } from '../core/framework-logger.js';
+import { getMemoryRoutingProviderSync } from '../memory-routing/index.js';
+const TRAP_LANGUAGE = /TYPE:\s*ontological-trap|ontological[- ]trap/i;
+const DEFAULT_MIN_CONFIDENCE_GATE = 0.55;
+export function shouldQueryRepertoireConfidence(description, proposalType = '') {
+    const text = `${description} ${proposalType}`.trim();
+    return TRAP_LANGUAGE.test(text);
+}
+export function hasHighConfidencePrimitiveMatch(routingContext, minConfidence = DEFAULT_MIN_CONFIDENCE_GATE) {
+    const confidences = routingContext.signalConfidences ?? {};
+    return Object.values(confidences).some((confidence) => confidence >= minConfidence);
+}
+function buildTaskText(proposalTitle, proposalDescription, proposalType) {
+    return [proposalTitle, proposalDescription, proposalType].filter(Boolean).join('\n');
+}
+/**
+ * Resolve Repertoire task confidence for researcher proposal analysis.
+ * Triggered by ontological-trap language or high-confidence primitive matches.
+ */
+export function resolveResearcherMemoryContext(input) {
+    const proposalTitle = input.proposalTitle ?? '';
+    const proposalDescription = input.proposalDescription ?? '';
+    const proposalType = input.proposalType ?? '';
+    const taskText = buildTaskText(proposalTitle, proposalDescription, proposalType);
+    const provider = getMemoryRoutingProviderSync();
+    if (provider.id === 'null' || !provider.getTaskConfidence) {
+        return null;
+    }
+    const trapLanguageDetected = shouldQueryRepertoireConfidence(proposalDescription, proposalType);
+    const routingContext = provider.buildRoutingContext(taskText);
+    const primitiveMatchDetected = hasHighConfidencePrimitiveMatch(routingContext);
+    if (!trapLanguageDetected && !primitiveMatchDetected) {
+        return null;
+    }
+    const confidence = provider.getTaskConfidence({
+        id: 'researcher-proposal',
+        description: taskText,
+        type: proposalType || 'governance',
+    });
+    const matchedSignals = confidence.matchedSignals.length > 0
+        ? confidence.matchedSignals
+        : routingContext.matchedSignals;
+    const context = {
+        providerId: provider.id,
+        confidence,
+        matchedSignals,
+        recommendedAgent: confidence.recommendedAgent,
+        triggeredBy: trapLanguageDetected ? 'trap-language' : 'high-confidence-primitives',
+    };
+    if (confidence.highConfidenceTrapPresent) {
+        frameworkLogger.log('mcps/researcher', 'repertoire-trap-detected', 'info', {
+            providerId: provider.id,
+            matchedSignals,
+            complexityBoost: confidence.complexityBoost,
+            recommendedAgent: confidence.recommendedAgent,
+            triggeredBy: context.triggeredBy,
+        });
+    }
+    return context;
+}
+export function buildMemoryRoutingEvidence(context) {
+    const { confidence, matchedSignals, recommendedAgent } = context;
+    const signalSummary = confidence.signals
+        .map((entry) => `${entry.name} (${entry.confidence.toFixed(2)})`)
+        .join(', ');
+    const lines = [
+        `Repertoire memory routing (${context.providerId}, trigger: ${context.triggeredBy})`,
+        `Matched signals: ${matchedSignals.join(', ') || 'none'}`,
+        `Signal confidences: ${signalSummary || 'none'}`,
+        `High-confidence trap present: ${confidence.highConfidenceTrapPresent}`,
+        `Complexity boost: ${confidence.complexityBoost}`,
+    ];
+    if (recommendedAgent) {
+        lines.push(`Recommended agent for trap handling: ${recommendedAgent}`);
+    }
+    return lines;
+}
+export function formatMemoryRoutingBlock(context) {
+    const { confidence, matchedSignals, recommendedAgent } = context;
+    const lines = [
+        'MEMORY_ROUTING:',
+        `  provider: ${context.providerId}`,
+        `  trigger: ${context.triggeredBy}`,
+        `  matchedSignals: ${matchedSignals.join(', ') || 'none'}`,
+        `  highConfidenceTrapPresent: ${confidence.highConfidenceTrapPresent}`,
+        `  complexityBoost: ${confidence.complexityBoost}`,
+    ];
+    if (recommendedAgent) {
+        lines.push(`  recommendedAgent: ${recommendedAgent}`);
+    }
+    return lines.join('\n');
+}

package/dist/mcps/researcher.server.js

@@ -11,6 +11,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { tryLLMGovernance } from "../governance/llm-governance-provider.js";
+import { buildMemoryRoutingEvidence, formatMemoryRoutingBlock, resolveResearcherMemoryContext, } from "./researcher-confidence.js";
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 class XrayLibrarianServer extends XrayKnowledgeSkillBase {
     constructor() {
@@ -377,13 +378,28 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
      */
     async analyzeProposal(args) {
         const { proposalTitle = "", proposalDescription = "", evidence = [], proposalType = "" } = args || {};
-        const vote = await tryLLMGovernance("researcher", proposalTitle || "", proposalDescription || "", evidence || [], proposalType || "");
+        const memoryContext = resolveResearcherMemoryContext({
+            proposalTitle,
+            proposalDescription,
+            proposalType,
+        });
+        const enrichedEvidence = [...(evidence || [])];
+        if (memoryContext?.confidence.highConfidenceTrapPresent) {
+            enrichedEvidence.push(...buildMemoryRoutingEvidence(memoryContext));
+        }
+        const vote = await tryLLMGovernance("researcher", proposalTitle || "", proposalDescription || "", enrichedEvidence, proposalType || "");
+        const memoryRoutingBlock = memoryContext?.confidence.highConfidenceTrapPresent
+            ? `\n${formatMemoryRoutingBlock(memoryContext)}`
+            : "";
         if (!vote) {
+            const abstainReason = memoryContext?.confidence.highConfidenceTrapPresent
+                ? "No LLM governance provider configured. Repertoire detected a high-confidence ontological trap — route to the recommended agent before proceeding."
+                : "No LLM governance provider configured. Set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT, or install Hermes and run: hermes auth add xai-oauth --no-browser";
             return {
                 content: [
                     {
                         type: "text",
-                        text: "DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: No LLM governance provider configured. Set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT, or install Hermes and run: hermes auth add xai-oauth --no-browser",
+                        text: `DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: ${abstainReason}${memoryRoutingBlock}`,
                     },
                 ],
             };
@@ -392,7 +408,7 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
             content: [
                 {
                     type: "text",
-                    text: `DECISION: ${vote.decision}\nCONFIDENCE: ${vote.confidence.toFixed(2)}\nREASONING: ${vote.reasoning}`,
+                    text: `DECISION: ${vote.decision}\nCONFIDENCE: ${vote.confidence.toFixed(2)}\nREASONING: ${vote.reasoning}${memoryRoutingBlock}`,
                 },
             ],
         };

package/dist/memory-routing/index.js

@@ -0,0 +1,4 @@
+export { getMemoryRoutingProvider, getMemoryRoutingProviderSync, getMemoryRoutingConfig, resetMemoryRoutingProvider, initializeMemoryRouting, } from './provider-registry.js';
+export { NullMemoryRoutingProvider, createMemoryRoutingProvider } from './null-provider.js';
+export { loadMemoryRoutingProvider } from './provider-loader.js';
+export { validateMemoryRoutingConfig } from './validate-config.js';

package/dist/memory-routing/null-provider.js

@@ -0,0 +1,63 @@
+const EMPTY_CONTEXT = {
+    providerId: 'null',
+    matchedSignals: [],
+    matchedTags: [],
+    flags: {},
+    synthesisAvailable: false,
+};
+export class NullMemoryRoutingProvider {
+    id = 'null';
+    name = 'Null (no memory routing)';
+    isAvailable() {
+        return true;
+    }
+    buildRoutingContext() {
+        return { ...EMPTY_CONTEXT };
+    }
+    enhanceAgentCapabilities(base) {
+        return new Map(base);
+    }
+    enrichTasks(tasks) {
+        return tasks;
+    }
+    buildInheritedContext() {
+        return { providerId: 'null', matchedSignals: [], flags: {} };
+    }
+    selectAgent(capabilities, requiredCapabilities, complexity) {
+        let bestAgent = null;
+        let bestScore = -1;
+        for (const [agent, caps] of capabilities) {
+            if (complexity > caps.complexityThreshold)
+                continue;
+            const matchCount = requiredCapabilities.filter((c) => caps.capabilities.includes(c)).length;
+            const score = matchCount * 10 + caps.concurrentTasks;
+            if (score > bestScore) {
+                bestScore = score;
+                bestAgent = agent;
+            }
+        }
+        return bestAgent;
+    }
+    resolveThinDispatch(baseAgent, _operation, complexityScore) {
+        return {
+            agent: baseAgent,
+            adjustedScore: complexityScore,
+            context: { ...EMPTY_CONTEXT },
+        };
+    }
+    getTaskConfidence() {
+        return {
+            signals: [],
+            matchedSignals: [],
+            avgConfidence: 0,
+            maxConfidence: 0,
+            highConfidenceTrapPresent: false,
+            ontologicalTrapDetected: false,
+            complexityBoost: 0,
+            recommendedAgent: null,
+        };
+    }
+}
+export function createMemoryRoutingProvider() {
+    return new NullMemoryRoutingProvider();
+}

package/dist/memory-routing/provider-loader.js

@@ -0,0 +1,91 @@
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { frameworkLogger } from '../core/framework-logger.js';
+import { createMemoryRoutingProvider as createNullProvider } from './null-provider.js';
+import { validateMemoryRoutingConfig } from './validate-config.js';
+const REPERTOIRE_CANDIDATE_PATHS = [
+    '../repertoire/dist/provider/memory-routing-provider.js',
+    '../../repertoire/dist/provider/memory-routing-provider.js',
+    '../../../repertoire/dist/provider/memory-routing-provider.js',
+];
+/**
+ * SECURITY: features.json is a trusted configuration boundary.
+ * module_path is resolved from disk and dynamically imported without signature
+ * verification. Only grant write access to features.json to trusted operators.
+ */
+function resolveModulePath(configuredPath, cwd) {
+    if (!configuredPath)
+        return null;
+    const candidates = [
+        resolve(cwd, configuredPath),
+        configuredPath,
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function defaultPathForProvider(provider, cwd) {
+    if (provider !== 'repertoire')
+        return null;
+    for (const rel of REPERTOIRE_CANDIDATE_PATHS) {
+        const abs = resolve(cwd, rel);
+        if (existsSync(abs))
+            return abs;
+    }
+    return null;
+}
+export async function loadMemoryRoutingProvider(config, cwd = process.cwd()) {
+    const validation = validateMemoryRoutingConfig(config);
+    if (!validation.valid) {
+        await frameworkLogger.log('memory-routing', 'config-invalid', 'error', { errors: validation.errors, provider: config.provider });
+        return createNullProvider();
+    }
+    const effective = validation.normalized;
+    if (!effective.enabled || effective.provider === 'null') {
+        return createNullProvider();
+    }
+    const modulePath = resolveModulePath(effective.module_path, cwd) ??
+        defaultPathForProvider(effective.provider, cwd);
+    if (!modulePath) {
+        await frameworkLogger.log('memory-routing', 'provider-not-found', 'error', {
+            provider: effective.provider,
+            module_path: effective.module_path,
+            message: `Provider "${effective.provider}" is configured but module_path could not be resolved. Falling back to null provider.`,
+        });
+        return createNullProvider();
+    }
+    try {
+        const mod = await import(pathToFileURL(modulePath).href);
+        const factory = mod.createMemoryRoutingProvider ??
+            mod.default?.createMemoryRoutingProvider;
+        if (typeof factory !== 'function') {
+            throw new Error(`Module ${modulePath} must export createMemoryRoutingProvider()`);
+        }
+        const provider = factory((effective.config ?? {}));
+        if (!provider?.id || typeof provider.isAvailable !== 'function') {
+            throw new Error(`Invalid memory routing provider from ${modulePath}`);
+        }
+        if (!provider.isAvailable()) {
+            await frameworkLogger.log('memory-routing', 'provider-unavailable', 'error', {
+                providerId: provider.id,
+                modulePath,
+                message: `Provider "${provider.id}" loaded but isAvailable() returned false. Falling back to null provider.`,
+            });
+            return createNullProvider();
+        }
+        await frameworkLogger.log('memory-routing', 'provider-loaded', 'info', { providerId: provider.id, name: provider.name, modulePath });
+        return provider;
+    }
+    catch (err) {
+        await frameworkLogger.log('memory-routing', 'provider-load-failed', 'error', {
+            modulePath,
+            error: err instanceof Error ? err.message : String(err),
+            cwd,
+            configDir: dirname(modulePath),
+        });
+        return createNullProvider();
+    }
+}

package/dist/memory-routing/provider-registry.js

@@ -0,0 +1,40 @@
+import { featuresConfigLoader } from '../core/features-config.js';
+import { NullMemoryRoutingProvider } from './null-provider.js';
+import { loadMemoryRoutingProvider } from './provider-loader.js';
+import { validateMemoryRoutingConfig } from './validate-config.js';
+let cachedProvider = null;
+let loadPromise = null;
+const nullProviderSingleton = new NullMemoryRoutingProvider();
+export function getMemoryRoutingConfig() {
+    const raw = featuresConfigLoader.loadConfig().memory_routing;
+    const validation = validateMemoryRoutingConfig(raw ?? { enabled: false, provider: 'null' });
+    return validation.normalized;
+}
+export async function getMemoryRoutingProvider(forceReload = false) {
+    if (!forceReload && cachedProvider)
+        return cachedProvider;
+    if (!forceReload && loadPromise)
+        return loadPromise;
+    const config = getMemoryRoutingConfig();
+    loadPromise = loadMemoryRoutingProvider(config).then((provider) => {
+        cachedProvider = provider;
+        loadPromise = null;
+        return provider;
+    });
+    return loadPromise;
+}
+/** Synchronous accessor — returns shared null singleton until async load completes. */
+export function getMemoryRoutingProviderSync() {
+    return cachedProvider ?? nullProviderSingleton;
+}
+export function resetMemoryRoutingProvider() {
+    cachedProvider = null;
+    loadPromise = null;
+}
+/** Kick off background load at module init. */
+export function initializeMemoryRouting() {
+    const config = getMemoryRoutingConfig();
+    if (config.enabled) {
+        void getMemoryRoutingProvider();
+    }
+}

package/dist/memory-routing/types.js

@@ -0,0 +1,7 @@
+/**
+ * Memory Routing Provider — pluggable contract for long-term memory enrichment.
+ *
+ * Repertoire is one implementation. Any provider exposing createMemoryRoutingProvider()
+ * can be loaded via features.json memory_routing.module_path.
+ */
+export {};

package/dist/memory-routing/validate-config.js

@@ -0,0 +1,32 @@
+const VALID_PROVIDERS = new Set(['null', 'repertoire', 'custom']);
+export function validateMemoryRoutingConfig(raw) {
+    const errors = [];
+    const input = (raw ?? {});
+    const enabled = input.enabled === true;
+    const provider = typeof input.provider === 'string' ? input.provider : 'null';
+    if (!VALID_PROVIDERS.has(provider)) {
+        errors.push(`Invalid memory_routing.provider "${provider}". Must be one of: null, repertoire, custom.`);
+    }
+    if (enabled && provider !== 'null' && !input.module_path) {
+        errors.push(`memory_routing.provider "${provider}" requires module_path when enabled.`);
+    }
+    if (input.module_path !== undefined && typeof input.module_path !== 'string') {
+        errors.push('memory_routing.module_path must be a string.');
+    }
+    if (input.config !== undefined && (typeof input.config !== 'object' || input.config === null)) {
+        errors.push('memory_routing.config must be an object.');
+    }
+    const normalized = {
+        enabled,
+        provider: VALID_PROVIDERS.has(provider)
+            ? provider
+            : 'null',
+    };
+    if (typeof input.module_path === 'string') {
+        normalized.module_path = input.module_path;
+    }
+    if (input.config && typeof input.config === 'object') {
+        normalized.config = input.config;
+    }
+    return { valid: errors.length === 0, errors, normalized };
+}

package/dist/nucleus/thin-dispatch.js

@@ -9,6 +9,8 @@
 import { frameworkLogger } from "../core/framework-logger.js";
 import { getLevelFromScore, getAgentForTier, levelToTier, } from "../delegation/complexity-core.js";
 import { ComplexityAnalyzer } from "../delegation/complexity-analyzer.js";
+import { getMemoryRoutingProviderSync, initializeMemoryRouting, } from "../memory-routing/index.js";
+initializeMemoryRouting();
 export const NUCLEUS_THIN_DISPATCH_VERSION = "0.1.0";
 /**
  * Score the complexity of an operation given its description and context.
@@ -52,6 +54,32 @@ export function routeToAgent(scoreOrLevel, level) {
  */
 export function scoreAndRoute(operation, context, thresholds) {
     const score = scoreComplexity(operation, context, thresholds);
-    const agent = routeToAgent(score);
+    let agent = routeToAgent(score);
+    const provider = getMemoryRoutingProviderSync();
+    let memoryRouting;
+    if (provider.id !== "null") {
+        const resolved = provider.resolveThinDispatch(agent, operation, score.score);
+        agent = resolved.agent;
+        memoryRouting = {
+            providerId: resolved.context.providerId,
+            adjustedScore: resolved.adjustedScore,
+            signals: resolved.context.matchedSignals,
+        };
+        const adjustedLevel = getLevelFromScore(resolved.adjustedScore, thresholds);
+        frameworkLogger.log("nucleus-thin-dispatch", "memory-routing", "info", {
+            providerId: resolved.context.providerId,
+            baseAgent: routeToAgent(score),
+            resolvedAgent: agent,
+            baseScore: score.score,
+            adjustedScore: resolved.adjustedScore,
+            level: adjustedLevel,
+            signals: resolved.context.matchedSignals,
+        });
+        return {
+            score: { ...score, score: resolved.adjustedScore, level: adjustedLevel },
+            agent,
+            memoryRouting,
+        };
+    }
     return { score, agent };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "3.2.0",
+  "version": "3.3.1",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",