0xray 3.2.0 → 3.3.0

package/.opencode/codex.codex

@@ -1,5 +1,5 @@
 {
-  "version": "3.2.0",
+  "version": "3.3.0",
   "terms": [
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60
   ],

package/dist/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://www.conventionalcommits.org/).
 
+## [3.2.0] - 2026-06-17
+
+### 🔄 Changes
+
+### ✨ Features
+- Orphan file resolution: 5 dead files deleted, ~39 files integrated under typecheck
+- feat: 58 type errors fixed across 6 source files
+- feat: pre-existing e2e failures fixed (OpenClaw 9/9, Grok CLI 62/0)
+- feat: vitest config testTimeout added for processor-logger stability
+- feat: pre-tool-use hook rewritten from skeleton to full hook with resonance/decision-matrix/JSON
+- feat: SelfProposalEngine integrated under typecheck with metamorphosis type support
+
+### 🐛 Bug Fixes
+- fix: postinstall e2e version assertions (3.1.1 → 0.5.2)
+- fix: AGENTS.md session entry and test assertions cleaned
+- fix: enforcement-gate fallback dynamic imports `as string` cast
+
+### ♻️ Refactoring
+- chore: removed ~180 stale @version JSDoc tags from source files
+- chore: cleaned stale version badges from README, AGENTS.md, docs-site docs
+- chore: removed "xray 2.0" from command docs (26 files)
+- chore: release.mjs checks npm view 0xray version (was xray)
+- chore: release.mjs push target master → main
+
+---
+
 ## [3.1.1] - 2026-06-17
 
 ### 🔄 Changes

package/dist/core/features-config.js

@@ -472,6 +472,9 @@ export class FeaturesConfigLoader {
     getInference() {
         return this.loadConfig().inference;
     }
+    getMemoryRouting() {
+        return this.loadConfig().memory_routing;
+    }
     getPublish() {
         return this.loadConfig().publish;
     }

package/dist/mcps/orchestrator/config/agent-capabilities.js

@@ -1,9 +1,12 @@
 /**
  * Agent Capabilities Configuration
  *
- * Centralized agent capability definitions for orchestration decisions
+ * Centralized agent capability definitions for orchestration decisions.
+ * Enriched at runtime by the active MemoryRoutingProvider (Repertoire, etc.).
  */
 import { AGENT_REGISTRY } from "../../../agents/registry.js";
+import { initializeMemoryRouting } from '../../../memory-routing/index.js';
+import { getProvider, toMemoryCapabilityMap, fromMemoryCapabilityMap, } from './memory-routing-bridge.js';
 const DEFAULT_AGENT_CAPABILITIES = Object.fromEntries(Object.entries(AGENT_REGISTRY).map(([name, entry]) => [
     name,
     {
@@ -12,17 +15,28 @@ const DEFAULT_AGENT_CAPABILITIES = Object.fromEntries(Object.entries(AGENT_REGIS
         concurrentTasks: entry.concurrentTasks,
     },
 ]));
+initializeMemoryRouting();
 /**
  * Agent Capabilities Manager
  * Manages agent capabilities for orchestration decisions
  */
 export class AgentCapabilitiesManager {
     capabilities = new Map();
+    enriched = false;
     constructor() {
-        // Initialize with default capabilities
         Object.entries(DEFAULT_AGENT_CAPABILITIES).forEach(([agent, config]) => {
             this.capabilities.set(agent, config);
         });
+        this.applyMemoryRoutingEnrichment();
+    }
+    applyMemoryRoutingEnrichment() {
+        const provider = getProvider();
+        if (provider.id === 'null')
+            return;
+        const memoryCaps = toMemoryCapabilityMap(this.capabilities);
+        const enriched = provider.enhanceAgentCapabilities(memoryCaps);
+        this.capabilities = fromMemoryCapabilityMap(enriched);
+        this.enriched = true;
     }
     /**
      * Get capabilities for a specific agent
@@ -34,6 +48,8 @@ export class AgentCapabilitiesManager {
      * Get all registered agent capabilities
      */
     getAllCapabilities() {
+        if (!this.enriched)
+            this.applyMemoryRoutingEnrichment();
         return new Map(this.capabilities);
     }
     /**
@@ -43,19 +59,20 @@ export class AgentCapabilitiesManager {
         this.capabilities.set(agentType, capability);
     }
     /**
-     * Select the best agent for a task based on complexity and capabilities
+     * Select the best agent for a task based on complexity, capabilities, and memory routing.
      */
-    selectAgentForTask(requiredCapabilities, complexity) {
+    selectAgentForTask(requiredCapabilities, complexity, operationDescription = '') {
+        const provider = getProvider();
+        if (provider.id !== 'null' && operationDescription) {
+            const memoryCaps = toMemoryCapabilityMap(this.getAllCapabilities());
+            return provider.selectAgent(memoryCaps, requiredCapabilities, complexity, operationDescription);
+        }
         let bestAgent = null;
         let bestScore = -1;
         for (const [agent, caps] of this.capabilities) {
-            // Check if agent can handle the complexity
-            if (complexity > caps.complexityThreshold) {
+            if (complexity > caps.complexityThreshold)
                 continue;
-            }
-            // Calculate capability match score
-            const matchCount = requiredCapabilities.filter(cap => caps.capabilities.includes(cap)).length;
-            // Prefer agents with more concurrent tasks available
+            const matchCount = requiredCapabilities.filter((cap) => caps.capabilities.includes(cap)).length;
             const score = matchCount * 10 + caps.concurrentTasks;
             if (score > bestScore) {
                 bestScore = score;
@@ -77,7 +94,6 @@ export class AgentCapabilitiesManager {
         return available;
     }
 }
-// Singleton instance
 let capabilitiesManagerInstance = null;
 export function getAgentCapabilitiesManager() {
     if (!capabilitiesManagerInstance) {
@@ -85,3 +101,6 @@ export function getAgentCapabilitiesManager() {
     }
     return capabilitiesManagerInstance;
 }
+export function resetAgentCapabilitiesManager() {
+    capabilitiesManagerInstance = null;
+}

package/dist/mcps/orchestrator/config/memory-routing-bridge.js

@@ -0,0 +1,70 @@
+/**
+ * Bridge between orchestrator types and the pluggable MemoryRoutingProvider.
+ */
+import { getMemoryRoutingProviderSync, } from '../../../memory-routing/index.js';
+export function toMemoryCapability(caps) {
+    const result = {
+        capabilities: caps.capabilities,
+        complexityThreshold: caps.complexityThreshold,
+        concurrentTasks: caps.concurrentTasks,
+    };
+    if (caps.memorySignals)
+        result.memorySignals = caps.memorySignals;
+    if (caps.memoryTags)
+        result.memoryTags = caps.memoryTags;
+    return result;
+}
+export function fromMemoryCapability(caps) {
+    const result = {
+        capabilities: caps.capabilities,
+        complexityThreshold: caps.complexityThreshold,
+        concurrentTasks: caps.concurrentTasks,
+    };
+    if (caps.memorySignals)
+        result.memorySignals = caps.memorySignals;
+    if (caps.memoryTags)
+        result.memoryTags = caps.memoryTags;
+    return result;
+}
+export function toMemoryTask(task) {
+    const result = {
+        id: task.id,
+        description: task.description,
+        type: task.type,
+    };
+    if (task.priority)
+        result.priority = task.priority;
+    if (task.dependencies)
+        result.dependencies = task.dependencies;
+    if (task.estimatedComplexity !== undefined)
+        result.estimatedComplexity = task.estimatedComplexity;
+    if (task.metadata)
+        result.metadata = task.metadata;
+    return result;
+}
+export function fromMemoryTask(task) {
+    const result = {
+        id: task.id,
+        description: task.description,
+        type: task.type,
+    };
+    if (task.priority)
+        result.priority = task.priority;
+    if (task.dependencies)
+        result.dependencies = task.dependencies;
+    if (task.estimatedComplexity !== undefined)
+        result.estimatedComplexity = task.estimatedComplexity;
+    const metadata = task.metadata;
+    if (metadata)
+        result.metadata = metadata;
+    return result;
+}
+export function toMemoryCapabilityMap(caps) {
+    return new Map(Array.from(caps.entries()).map(([k, v]) => [k, toMemoryCapability(v)]));
+}
+export function fromMemoryCapabilityMap(caps) {
+    return new Map(Array.from(caps.entries()).map(([k, v]) => [k, fromMemoryCapability(v)]));
+}
+export function getProvider() {
+    return getMemoryRoutingProviderSync();
+}

package/dist/mcps/orchestrator/execution/execution-planner.js

@@ -4,6 +4,7 @@
  * Creates optimized execution plans for orchestration tasks
  */
 import { getAgentCapabilitiesManager } from '../config/agent-capabilities.js';
+import { getProvider, toMemoryTask, fromMemoryTask, } from '../config/memory-routing-bridge.js';
 /**
  * Execution Planner
  * Plans and optimizes task execution strategies
@@ -48,26 +49,35 @@ export class ExecutionPlanner {
      * Create an execution plan based on tasks and mode
      */
     async createExecutionPlan(tasks, executionMode) {
+        const provider = getProvider();
+        const memoryTasks = provider.enrichTasks(tasks.map(toMemoryTask));
+        const enrichedTasks = memoryTasks.map(fromMemoryTask);
         const agentAssignments = new Map();
         switch (executionMode) {
             case 'parallel':
-                this.createParallelPlan(tasks, agentAssignments);
+                this.createParallelPlan(enrichedTasks, agentAssignments);
                 break;
             case 'sequential':
-                this.createSequentialPlan(tasks, agentAssignments);
+                this.createSequentialPlan(enrichedTasks, agentAssignments);
                 break;
             case 'optimized':
             default:
-                await this.createOptimizedPlan(tasks, agentAssignments);
+                await this.createOptimizedPlan(enrichedTasks, agentAssignments);
                 break;
         }
         const estimatedDuration = this.estimateExecutionDuration(agentAssignments);
-        return {
-            tasks,
+        const plan = {
+            tasks: enrichedTasks,
             strategy: executionMode,
             agentAssignments,
             estimatedDuration,
         };
+        if (provider.id !== 'null') {
+            plan.memoryContext = {
+                ...provider.buildInheritedContext(memoryTasks),
+            };
+        }
+        return plan;
     }
     /**
      * Create a parallel execution plan
@@ -150,7 +160,11 @@ export class ExecutionPlanner {
     assignTasksToAgents(tasks, agentAssignments) {
         for (const task of tasks) {
             const complexity = task.estimatedComplexity || 30;
-            const agent = this.capabilitiesManager.selectAgentForTask([task.type], complexity) || 'orchestrator';
+            const requiredCaps = [
+                task.type,
+                ...(task.metadata?.memorySignals ?? []),
+            ];
+            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, task.description) || 'orchestrator';
             if (!agentAssignments.has(agent)) {
                 agentAssignments.set(agent, []);
             }
@@ -188,7 +202,11 @@ export class ExecutionPlanner {
                 category: task.type,
             });
             // Assign to agent
-            const agent = this.capabilitiesManager.selectAgentForTask([task.type], complexity) || 'orchestrator';
+            const requiredCaps = [
+                task.type,
+                ...(task.metadata?.memorySignals ?? []),
+            ];
+            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, task.description) || 'orchestrator';
             if (!assignments.has(agent)) {
                 assignments.set(agent, []);
             }

package/dist/mcps/orchestrator/handlers/task-handler.js

@@ -6,7 +6,8 @@
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { mcpClientManager } from '../../../mcps/mcp-client.js';
-import { addObservations, extractOrchestrationObservations } from '../aside-context.js';
+import { addObservations, extractOrchestrationObservations, spawnAside } from '../aside-context.js';
+import { getProvider } from '../config/memory-routing-bridge.js';
 /**
  * Task Handler
  * Processes orchestrate-task requests
@@ -38,8 +39,37 @@ export class TaskHandler {
             }
             // Analyze complexity and create execution plan
             const executionPlan = await this.planner.createExecutionPlan(tasks, executionMode);
+            const memoryProvider = getProvider();
+            if (memoryProvider.id !== 'null' && executionPlan.memoryContext) {
+                await spawnAside({
+                    description: `Orchestrate: ${description}`,
+                    sessionId,
+                    inheritedContext: {
+                        memoryRouting: executionPlan.memoryContext,
+                    },
+                });
+            }
             // Execute orchestration (simulated for MCP server)
             const results = await this.executePlan(executionPlan, sessionId, timeout);
+            // Feed per-task outcomes back to memory provider (not aggregate session stats)
+            if (memoryProvider.ingestFeedback) {
+                const outcomeByKey = new Map(results.taskOutcomes.map((o) => [`${o.agent}:${o.taskId}`, o]));
+                for (const [agent, assignedTasks] of executionPlan.agentAssignments) {
+                    for (const task of assignedTasks) {
+                        const outcome = outcomeByKey.get(`${agent}:${task.id}`);
+                        memoryProvider.ingestFeedback({
+                            timestamp: new Date().toISOString(),
+                            sessionId,
+                            taskId: task.id,
+                            assignedAgent: agent,
+                            memorySignals: task.metadata?.memorySignals ?? [],
+                            complexity: task.estimatedComplexity ?? 30,
+                            success: outcome?.success ?? false,
+                            durationMs: outcome?.durationMs ?? 0,
+                        });
+                    }
+                }
+            }
             // Update result
             orchestrationResult.success = results.success;
             orchestrationResult.completedTasks = results.completedTasks;
@@ -82,6 +112,7 @@ export class TaskHandler {
         let completedTasks = 0;
         let failedTasks = 0;
         const agentOutputs = {};
+        const taskOutcomes = [];
         const skillServers = new Set([
             'code-review', 'code-reviewer',
             'security-audit', 'security-auditor',
@@ -96,6 +127,7 @@ export class TaskHandler {
             agentUtilization[agent] = tasks.length;
             if (skillServers.has(agent)) {
                 for (const task of tasks) {
+                    const taskStart = Date.now();
                     try {
                         const toolName = this.mapAgentToTool(agent);
                         const result = await mcpClientManager.callServerTool(agent, toolName, {
@@ -106,10 +138,22 @@ export class TaskHandler {
                         const outputText = this.extractTextFromMcpResult(result);
                         agentOutputs[`${agent}:${task.id}`] = outputText;
                         completedTasks++;
+                        taskOutcomes.push({
+                            taskId: task.id,
+                            agent,
+                            success: true,
+                            durationMs: Date.now() - taskStart,
+                        });
                     }
                     catch (err) {
                         failedTasks++;
                         agentOutputs[`${agent}:${task.id}`] = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                        taskOutcomes.push({
+                            taskId: task.id,
+                            agent,
+                            success: false,
+                            durationMs: Date.now() - taskStart,
+                        });
                         frameworkLogger.log('orchestrator.task-handler', 'task-execution-failed', 'warning', {
                             agent,
                             taskId: task.id,
@@ -120,7 +164,15 @@ export class TaskHandler {
             }
             else {
                 // For non-MCP agents we still count them as "assigned" (they will be handled by the caller or legacy path)
-                completedTasks += tasks.length;
+                for (const task of tasks) {
+                    completedTasks++;
+                    taskOutcomes.push({
+                        taskId: task.id,
+                        agent,
+                        success: true,
+                        durationMs: 0,
+                    });
+                }
             }
         }
         const recommendations = [];
@@ -141,6 +193,7 @@ export class TaskHandler {
             bottlenecks,
             recommendations,
             agentOutputs,
+            taskOutcomes,
         };
     }
     mapAgentToTool(agent) {

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,51 @@
+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 },
+        };
+    }
+}
+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.0",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",

package/src/mcps/orchestrator/config/agent-capabilities.ts

@@ -1,11 +1,18 @@
 /**
  * Agent Capabilities Configuration
- * 
- * Centralized agent capability definitions for orchestration decisions
+ *
+ * Centralized agent capability definitions for orchestration decisions.
+ * Enriched at runtime by the active MemoryRoutingProvider (Repertoire, etc.).
  */
 
 import type { AgentCapability } from '../types.js';
 import { AGENT_REGISTRY } from "../../../agents/registry.js";
+import { initializeMemoryRouting } from '../../../memory-routing/index.js';
+import {
+  getProvider,
+  toMemoryCapabilityMap,
+  fromMemoryCapabilityMap,
+} from './memory-routing-bridge.js';
 
 const DEFAULT_AGENT_CAPABILITIES: Record<string, AgentCapability> = Object.fromEntries(
   Object.entries(AGENT_REGISTRY).map(([name, entry]) => [
@@ -18,18 +25,31 @@ const DEFAULT_AGENT_CAPABILITIES: Record<string, AgentCapability> = Object.fromE
   ]),
 );
 
+initializeMemoryRouting();
+
 /**
  * Agent Capabilities Manager
  * Manages agent capabilities for orchestration decisions
  */
 export class AgentCapabilitiesManager {
   private capabilities: Map<string, AgentCapability> = new Map();
+  private enriched = false;
 
   constructor() {
-    // Initialize with default capabilities
     Object.entries(DEFAULT_AGENT_CAPABILITIES).forEach(([agent, config]) => {
       this.capabilities.set(agent, config);
     });
+    this.applyMemoryRoutingEnrichment();
+  }
+
+  private applyMemoryRoutingEnrichment(): void {
+    const provider = getProvider();
+    if (provider.id === 'null') return;
+
+    const memoryCaps = toMemoryCapabilityMap(this.capabilities);
+    const enriched = provider.enhanceAgentCapabilities(memoryCaps);
+    this.capabilities = fromMemoryCapabilityMap(enriched);
+    this.enriched = true;
   }
 
   /**
@@ -43,6 +63,7 @@ export class AgentCapabilitiesManager {
    * Get all registered agent capabilities
    */
   getAllCapabilities(): Map<string, AgentCapability> {
+    if (!this.enriched) this.applyMemoryRoutingEnrichment();
     return new Map(this.capabilities);
   }
 
@@ -54,24 +75,35 @@ export class AgentCapabilitiesManager {
   }
 
   /**
-   * Select the best agent for a task based on complexity and capabilities
+   * Select the best agent for a task based on complexity, capabilities, and memory routing.
    */
-  selectAgentForTask(requiredCapabilities: string[], complexity: number): string | null {
+  selectAgentForTask(
+    requiredCapabilities: string[],
+    complexity: number,
+    operationDescription = '',
+  ): string | null {
+    const provider = getProvider();
+
+    if (provider.id !== 'null' && operationDescription) {
+      const memoryCaps = toMemoryCapabilityMap(this.getAllCapabilities());
+      return provider.selectAgent(
+        memoryCaps,
+        requiredCapabilities,
+        complexity,
+        operationDescription,
+      );
+    }
+
     let bestAgent: string | null = null;
     let bestScore = -1;
 
     for (const [agent, caps] of this.capabilities) {
-      // Check if agent can handle the complexity
-      if (complexity > caps.complexityThreshold) {
-        continue;
-      }
+      if (complexity > caps.complexityThreshold) continue;
 
-      // Calculate capability match score
-      const matchCount = requiredCapabilities.filter(cap =>
-        caps.capabilities.includes(cap)
+      const matchCount = requiredCapabilities.filter((cap) =>
+        caps.capabilities.includes(cap),
       ).length;
 
-      // Prefer agents with more concurrent tasks available
       const score = matchCount * 10 + caps.concurrentTasks;
 
       if (score > bestScore) {
@@ -97,7 +129,6 @@ export class AgentCapabilitiesManager {
   }
 }
 
-// Singleton instance
 let capabilitiesManagerInstance: AgentCapabilitiesManager | null = null;
 
 export function getAgentCapabilitiesManager(): AgentCapabilitiesManager {
@@ -106,3 +137,7 @@ export function getAgentCapabilitiesManager(): AgentCapabilitiesManager {
   }
   return capabilitiesManagerInstance;
 }
+
+export function resetAgentCapabilitiesManager(): void {
+  capabilitiesManagerInstance = null;
+}

package/src/mcps/orchestrator/config/memory-routing-bridge.ts

@@ -0,0 +1,80 @@
+/**
+ * Bridge between orchestrator types and the pluggable MemoryRoutingProvider.
+ */
+
+import {
+  getMemoryRoutingProviderSync,
+  type MemoryAgentCapability,
+  type MemoryOrchestrationTask,
+  type MemoryRoutingProvider,
+} from '../../../memory-routing/index.js';
+import type { AgentCapability, OrchestrationTask } from '../types.js';
+
+export function toMemoryCapability(caps: AgentCapability): MemoryAgentCapability {
+  const result: MemoryAgentCapability = {
+    capabilities: caps.capabilities,
+    complexityThreshold: caps.complexityThreshold,
+    concurrentTasks: caps.concurrentTasks,
+  };
+  if (caps.memorySignals) result.memorySignals = caps.memorySignals;
+  if (caps.memoryTags) result.memoryTags = caps.memoryTags;
+  return result;
+}
+
+export function fromMemoryCapability(caps: MemoryAgentCapability): AgentCapability {
+  const result: AgentCapability = {
+    capabilities: caps.capabilities,
+    complexityThreshold: caps.complexityThreshold,
+    concurrentTasks: caps.concurrentTasks,
+  };
+  if (caps.memorySignals) result.memorySignals = caps.memorySignals;
+  if (caps.memoryTags) result.memoryTags = caps.memoryTags;
+  return result;
+}
+
+export function toMemoryTask(task: OrchestrationTask): MemoryOrchestrationTask {
+  const result: MemoryOrchestrationTask = {
+    id: task.id,
+    description: task.description,
+    type: task.type,
+  };
+  if (task.priority) result.priority = task.priority;
+  if (task.dependencies) result.dependencies = task.dependencies;
+  if (task.estimatedComplexity !== undefined) result.estimatedComplexity = task.estimatedComplexity;
+  if (task.metadata) result.metadata = task.metadata as Record<string, unknown>;
+  return result;
+}
+
+export function fromMemoryTask(task: MemoryOrchestrationTask): OrchestrationTask {
+  const result: OrchestrationTask = {
+    id: task.id,
+    description: task.description,
+    type: task.type,
+  };
+  if (task.priority) result.priority = task.priority;
+  if (task.dependencies) result.dependencies = task.dependencies;
+  if (task.estimatedComplexity !== undefined) result.estimatedComplexity = task.estimatedComplexity;
+  const metadata = task.metadata as OrchestrationTask['metadata'];
+  if (metadata) result.metadata = metadata;
+  return result;
+}
+
+export function toMemoryCapabilityMap(
+  caps: Map<string, AgentCapability>,
+): Map<string, MemoryAgentCapability> {
+  return new Map(
+    Array.from(caps.entries()).map(([k, v]) => [k, toMemoryCapability(v)]),
+  );
+}
+
+export function fromMemoryCapabilityMap(
+  caps: Map<string, MemoryAgentCapability>,
+): Map<string, AgentCapability> {
+  return new Map(
+    Array.from(caps.entries()).map(([k, v]) => [k, fromMemoryCapability(v)]),
+  );
+}
+
+export function getProvider(): MemoryRoutingProvider {
+  return getMemoryRoutingProviderSync();
+}

package/src/mcps/orchestrator/execution/execution-planner.ts

@@ -11,6 +11,11 @@ import type {
   TaskValidation 
 } from '../types.js';
 import { getAgentCapabilitiesManager } from '../config/agent-capabilities.js';
+import {
+  getProvider,
+  toMemoryTask,
+  fromMemoryTask,
+} from '../config/memory-routing-bridge.js';
 
 /**
  * Execution Planner
@@ -67,29 +72,41 @@ export class ExecutionPlanner {
     tasks: OrchestrationTask[],
     executionMode: string
   ): Promise<ExecutionPlan> {
+    const provider = getProvider();
+    const memoryTasks = provider.enrichTasks(tasks.map(toMemoryTask));
+    const enrichedTasks = memoryTasks.map(fromMemoryTask);
+
     const agentAssignments = new Map<string, OrchestrationTask[]>();
 
     switch (executionMode) {
       case 'parallel':
-        this.createParallelPlan(tasks, agentAssignments);
+        this.createParallelPlan(enrichedTasks, agentAssignments);
         break;
       case 'sequential':
-        this.createSequentialPlan(tasks, agentAssignments);
+        this.createSequentialPlan(enrichedTasks, agentAssignments);
         break;
       case 'optimized':
       default:
-        await this.createOptimizedPlan(tasks, agentAssignments);
+        await this.createOptimizedPlan(enrichedTasks, agentAssignments);
         break;
     }
 
     const estimatedDuration = this.estimateExecutionDuration(agentAssignments);
 
-    return {
-      tasks,
+    const plan: ExecutionPlan = {
+      tasks: enrichedTasks,
       strategy: executionMode as 'parallel' | 'sequential' | 'optimized',
       agentAssignments,
       estimatedDuration,
     };
+
+    if (provider.id !== 'null') {
+      plan.memoryContext = {
+        ...provider.buildInheritedContext(memoryTasks),
+      } as Record<string, unknown>;
+    }
+
+    return plan;
   }
 
   /**
@@ -197,9 +214,14 @@ export class ExecutionPlanner {
   ): void {
     for (const task of tasks) {
       const complexity = task.estimatedComplexity || 30;
+      const requiredCaps = [
+        task.type,
+        ...(task.metadata?.memorySignals ?? []),
+      ];
       const agent = this.capabilitiesManager.selectAgentForTask(
-        [task.type],
-        complexity
+        requiredCaps,
+        complexity,
+        task.description,
       ) || 'orchestrator';
 
       if (!agentAssignments.has(agent)) {
@@ -247,9 +269,14 @@ export class ExecutionPlanner {
       });
 
       // Assign to agent
+      const requiredCaps = [
+        task.type,
+        ...(task.metadata?.memorySignals ?? []),
+      ];
       const agent = this.capabilitiesManager.selectAgentForTask(
-        [task.type],
-        complexity
+        requiredCaps,
+        complexity,
+        task.description,
       ) || 'orchestrator';
 
       if (!assignments.has(agent)) {

package/src/mcps/orchestrator/handlers/task-handler.ts

@@ -7,7 +7,8 @@
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { mcpClientManager } from '../../../mcps/mcp-client.js';
-import { addObservations, extractOrchestrationObservations } from '../aside-context.js';
+import { addObservations, extractOrchestrationObservations, spawnAside } from '../aside-context.js';
+import { getProvider } from '../config/memory-routing-bridge.js';
 import type { OrchestrationResult, OrchestrationTask } from '../types.js';
 
 export interface TaskHandlerDeps {
@@ -76,9 +77,43 @@ export class TaskHandler {
       // Analyze complexity and create execution plan
       const executionPlan = await this.planner.createExecutionPlan(tasks, executionMode);
 
+      const memoryProvider = getProvider();
+      if (memoryProvider.id !== 'null' && executionPlan.memoryContext) {
+        await spawnAside({
+          description: `Orchestrate: ${description}`,
+          sessionId,
+          inheritedContext: {
+            memoryRouting: executionPlan.memoryContext,
+          },
+        });
+      }
+
       // Execute orchestration (simulated for MCP server)
       const results = await this.executePlan(executionPlan, sessionId, timeout);
 
+      // Feed per-task outcomes back to memory provider (not aggregate session stats)
+      if (memoryProvider.ingestFeedback) {
+        const outcomeByKey = new Map(
+          results.taskOutcomes.map((o) => [`${o.agent}:${o.taskId}`, o]),
+        );
+
+        for (const [agent, assignedTasks] of executionPlan.agentAssignments) {
+          for (const task of assignedTasks) {
+            const outcome = outcomeByKey.get(`${agent}:${task.id}`);
+            memoryProvider.ingestFeedback({
+              timestamp: new Date().toISOString(),
+              sessionId,
+              taskId: task.id,
+              assignedAgent: agent,
+              memorySignals: task.metadata?.memorySignals ?? [],
+              complexity: task.estimatedComplexity ?? 30,
+              success: outcome?.success ?? false,
+              durationMs: outcome?.durationMs ?? 0,
+            });
+          }
+        }
+      }
+
       // Update result
       orchestrationResult.success = results.success;
       orchestrationResult.completedTasks = results.completedTasks;
@@ -136,11 +171,23 @@ export class TaskHandler {
     bottlenecks: string[];
     recommendations: string[];
     agentOutputs?: Record<string, string>;
+    taskOutcomes: Array<{
+      taskId: string;
+      agent: string;
+      success: boolean;
+      durationMs: number;
+    }>;
   }> {
     const agentUtilization: Record<string, number> = {};
     let completedTasks = 0;
     let failedTasks = 0;
     const agentOutputs: Record<string, string> = {};
+    const taskOutcomes: Array<{
+      taskId: string;
+      agent: string;
+      success: boolean;
+      durationMs: number;
+    }> = [];
 
     const skillServers = new Set([
       'code-review', 'code-reviewer',
@@ -158,6 +205,7 @@ export class TaskHandler {
 
       if (skillServers.has(agent)) {
         for (const task of tasks) {
+          const taskStart = Date.now();
           try {
             const toolName = this.mapAgentToTool(agent);
             const result = await mcpClientManager.callServerTool(agent, toolName, {
@@ -169,9 +217,21 @@ export class TaskHandler {
             const outputText = this.extractTextFromMcpResult(result);
             agentOutputs[`${agent}:${task.id}`] = outputText;
             completedTasks++;
+            taskOutcomes.push({
+              taskId: task.id,
+              agent,
+              success: true,
+              durationMs: Date.now() - taskStart,
+            });
           } catch (err) {
             failedTasks++;
             agentOutputs[`${agent}:${task.id}`] = `Error: ${err instanceof Error ? err.message : String(err)}`;
+            taskOutcomes.push({
+              taskId: task.id,
+              agent,
+              success: false,
+              durationMs: Date.now() - taskStart,
+            });
             frameworkLogger.log('orchestrator.task-handler', 'task-execution-failed', 'warning', {
               agent,
               taskId: task.id,
@@ -181,7 +241,15 @@ export class TaskHandler {
         }
       } else {
         // For non-MCP agents we still count them as "assigned" (they will be handled by the caller or legacy path)
-        completedTasks += tasks.length;
+        for (const task of tasks) {
+          completedTasks++;
+          taskOutcomes.push({
+            taskId: task.id,
+            agent,
+            success: true,
+            durationMs: 0,
+          });
+        }
       }
     }
 
@@ -205,6 +273,7 @@ export class TaskHandler {
       bottlenecks,
       recommendations,
       agentOutputs,
+      taskOutcomes,
     };
   }
 

package/src/mcps/orchestrator/types.ts

@@ -8,6 +8,17 @@ export interface AgentCapability {
   capabilities: string[];
   complexityThreshold: number;
   concurrentTasks: number;
+  /** Populated by active MemoryRoutingProvider (e.g. Repertoire) */
+  memorySignals?: string[];
+  memoryTags?: string[];
+}
+
+export interface OrchestrationTaskMetadata {
+  memorySignals?: string[];
+  matchedPrimitives?: string[];
+  synthesisContext?: string;
+  ontologicalTrapDetected?: boolean;
+  memoryProviderId?: string;
 }
 
 export interface OrchestrationTask {
@@ -17,6 +28,7 @@ export interface OrchestrationTask {
   priority?: 'critical' | 'high' | 'medium' | 'low';
   dependencies?: string[];
   estimatedComplexity?: number;
+  metadata?: OrchestrationTaskMetadata;
 }
 
 export interface ExecutionPlan {
@@ -24,6 +36,7 @@ export interface ExecutionPlan {
   strategy: 'parallel' | 'sequential' | 'optimized';
   agentAssignments: Map<string, OrchestrationTask[]>;
   estimatedDuration: number;
+  memoryContext?: Record<string, unknown>;
 }
 
 export interface OrchestrationResult {

package/src/opencode/codex.codex

@@ -1,5 +1,5 @@
 {
-  "version": "3.2.0",
+  "version": "3.3.0",
   "terms": [
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60
   ],