0xray 3.1.1 → 3.3.0

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/complexity-handler.ts

@@ -6,6 +6,7 @@
 
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
+import { addObservations, extractComplexityObservations } from '../aside-context.js';
 import type { OrchestrationTask, ComplexityAnalysis } from '../types.js';
 
 /**
@@ -18,9 +19,10 @@ export class ComplexityHandler {
   /**
    * Handle analyze-complexity request
    */
-  async handleAnalyzeComplexity(args: {
-    tasks: OrchestrationTask[];
-  }): Promise<{ content: Array<{ type: string; text: string }> }> {
+  async handleAnalyzeComplexity(
+    args: { tasks: OrchestrationTask[] },
+    asideId?: string,
+  ): Promise<{ content: Array<{ type: string; text: string }> }> {
     const { tasks = [] } = args;
 
     await frameworkLogger.log(
@@ -34,6 +36,10 @@ export class ComplexityHandler {
       const analysis = await this.planner.analyzeTaskComplexity(tasks);
       const recommendations = this.generateRecommendations(analysis);
 
+      if (asideId) {
+        addObservations(asideId, extractComplexityObservations(analysis));
+      }
+
       return {
         content: [
           {

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

@@ -18,6 +18,8 @@ interface HistoryItem {
 interface StatusHandlerDeps {
   activeTasks: Map<string, unknown>;
   taskHistory: HistoryItem[];
+  asideCount?: number;
+  asideIds?: string[];
 }
 
 /**
@@ -68,7 +70,15 @@ export class StatusHandler {
         status = this.getOverallStatus(deps);
       }
 
-      const response = this.formatStatusResponse(status, detailed);
+      let response = this.formatStatusResponse(status, detailed);
+
+      if (detailed && deps.asideCount !== undefined) {
+        response += `\n\n**Active Aside Contexts:**`;
+        response += `\n• Count: ${deps.asideCount}`;
+        if (deps.asideIds && deps.asideIds.length > 0) {
+          response += `\n• IDs: ${deps.asideIds.join(', ')}`;
+        }
+      }
 
       return { content: [{ type: 'text', text: response }] };
     } catch (error) {

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

@@ -7,11 +7,14 @@
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { mcpClientManager } from '../../../mcps/mcp-client.js';
-import type { OrchestrationResult, OrchestrationTask, TaskExecutionResult } from '../types.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 {
   taskHistory: OrchestrationHistoryItem[];
   activeTasks: Map<string, unknown>;
+  asideId?: string;
 }
 
 interface OrchestrationHistoryItem {
@@ -74,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;
@@ -88,6 +125,11 @@ export class TaskHandler {
         orchestrationResult.agentOutputs = results.agentOutputs;
       }
 
+      // Push observations into aside context if active
+      if (deps.asideId) {
+        addObservations(deps.asideId, extractOrchestrationObservations(orchestrationResult));
+      }
+
       // Store in history
       deps.taskHistory.push({
         sessionId,
@@ -129,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',
@@ -151,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, {
@@ -162,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,
@@ -174,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,
+          });
+        }
       }
     }
 
@@ -198,6 +273,7 @@ export class TaskHandler {
       bottlenecks,
       recommendations,
       agentOutputs,
+      taskOutcomes,
     };
   }
 

package/src/mcps/orchestrator/index.ts

@@ -0,0 +1,29 @@
+export { OrchestratorServer, createOrchestratorServer } from './server.js';
+export { TaskHandler } from './handlers/task-handler.js';
+export { ComplexityHandler } from './handlers/complexity-handler.js';
+export { StatusHandler } from './handlers/status-handler.js';
+export {
+  spawnAside,
+  closeAside,
+  closeAllAsides,
+  addObservations,
+  getActiveAsideCount,
+  getActiveAsideIds,
+  getAsideState,
+  resetAsideContext,
+  extractGovernanceObservations,
+  extractOrchestrationObservations,
+  extractComplexityObservations,
+} from './aside-context.js';
+export type {
+  AsideContextOptions,
+  AsideObservation,
+  AsideResult,
+  ActiveAside,
+  OrchestrationTask,
+  OrchestrationResult,
+  OrchestrationStatus,
+  ComplexityAnalysis,
+  TaskExecutionResult,
+  ExecutionPlan,
+} from './types.js';

package/src/mcps/orchestrator/server.ts

@@ -20,6 +20,16 @@ import { TaskHandler } from './handlers/task-handler.js';
 import { ComplexityHandler } from './handlers/complexity-handler.js';
 import { StatusHandler } from './handlers/status-handler.js';
 import type { OrchestrationTask, OrchestrationResult } from './types.js';
+import {
+  spawnAside,
+  closeAside,
+  closeAllAsides,
+  addObservations,
+  getActiveAsideCount,
+  getActiveAsideIds,
+  getAsideState,
+  extractGovernanceObservations,
+} from './aside-context.js';
 
 /**
  * Orchestrator MCP Server
@@ -234,33 +244,65 @@ export class OrchestratorServer {
         const { name, arguments: args } = request.params;
 
         switch (name) {
-          case 'orchestrate-task':
-            return await this.taskHandler.handleOrchestrateTask(args as {
+          case 'orchestrate-task': {
+            const orchArgs = args as {
               description: string;
               tasks?: OrchestrationTask[];
               sessionId?: string;
               executionMode?: string;
               timeout?: number;
-            }, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
-            
-          case 'analyze-complexity':
-            return await this.complexityHandler.handleAnalyzeComplexity(args as {
-              tasks: OrchestrationTask[];
+            };
+            const aside = await spawnAside({
+              description: `Orchestration: ${orchArgs.description}`,
+              ...(orchArgs.sessionId ? { sessionId: orchArgs.sessionId } : {}),
+              inheritedContext: { taskCount: orchArgs.tasks?.length ?? 0, executionMode: orchArgs.executionMode ?? 'optimized' },
             });
-            
+            try {
+              const result = await this.taskHandler.handleOrchestrateTask(
+                orchArgs,
+                { taskHistory: this.taskHistory, activeTasks: this.activeTasks, asideId: aside.asideId },
+              );
+              return result;
+            } finally {
+              closeAside(aside.asideId);
+            }
+          }
+          case 'analyze-complexity': {
+            const complexityArgs = args as { tasks: OrchestrationTask[] };
+            const aside = await spawnAside({
+              description: `Complexity analysis: ${complexityArgs.tasks.length} tasks`,
+            });
+            try {
+              return await this.complexityHandler.handleAnalyzeComplexity(complexityArgs, aside.asideId);
+            } finally {
+              closeAside(aside.asideId);
+            }
+          }
           case 'get-orchestration-status':
             return await this.statusHandler.handleGetOrchestrationStatus(args as {
               sessionId?: string;
               detailed?: boolean;
-            }, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
-            
-          case 'cancel-orchestration':
-            return await this.statusHandler.handleCancelOrchestration(args as {
-              sessionId?: string;
-              taskId?: string;
-              force?: boolean;
-            }, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
-            
+            }, {
+              taskHistory: this.taskHistory,
+              activeTasks: this.activeTasks,
+              asideCount: getActiveAsideCount(),
+              asideIds: getActiveAsideIds(),
+            });
+          case 'cancel-orchestration': {
+            const cancelArgs = args as { sessionId?: string; taskId?: string; force?: boolean };
+            if (cancelArgs.force || (!cancelArgs.sessionId && !cancelArgs.taskId)) {
+              closeAllAsides();
+            } else if (cancelArgs.sessionId) {
+              const asideIds = getActiveAsideIds().filter(
+                (id) => getAsideState(id)?.sessionId === cancelArgs.sessionId,
+              );
+              for (const id of asideIds) closeAside(id);
+            }
+            return await this.statusHandler.handleCancelOrchestration(cancelArgs, {
+              taskHistory: this.taskHistory,
+              activeTasks: this.activeTasks,
+            });
+          }
           case 'optimize-orchestration':
             return await this.statusHandler.handleOptimizeOrchestration(args as {
               history?: boolean;
@@ -311,26 +353,38 @@ export class OrchestratorServer {
         skipApply: args.skipApply ?? false,
       });
 
-      const result = await cycle.governExternalProposals(args.proposals as any);
+      const aside = await spawnAside({
+        description: `Governance cycle: ${args.proposals.length} proposals`,
+        priorVerdictContext: { proposalCount: args.proposals.length },
+      });
+
+      let result: import('../../inference/inference-cycle.js').InferenceCycleResult;
+      try {
+        result = await cycle.governExternalProposals(args.proposals as any);
+        addObservations(aside.asideId, extractGovernanceObservations(result));
+      } finally {
+        closeAside(aside.asideId);
+      }
 
-      const approved = result.votes.filter((v) => v.decision === 'approve').length;
-      const rejected = result.votes.length - approved;
+      const approved = result!.votes.filter((v) => v.decision === 'approve').length;
+      const rejected = result!.votes.length - approved;
 
       return {
         content: [{
           type: 'text' as const,
           text: JSON.stringify({
-            cycleId: result.cycleId,
+            cycleId: result!.cycleId,
+            asideId: aside.asideId,
             approved,
             rejected,
-            votes: result.votes,
-            proposals: result.proposals.map((p) => ({
+            votes: result!.votes,
+            proposals: result!.proposals.map((p) => ({
               id: p.id,
               title: p.title,
               type: p.type,
               status: p.status,
             })),
-            duration: result.duration,
+            duration: result!.duration,
           }, null, 2),
         }],
       };
@@ -360,6 +414,7 @@ export class OrchestratorServer {
    * Stop the server
    */
   async stop(): Promise<void> {
+    closeAllAsides();
     await frameworkLogger.log('orchestrator.server', 'shutdown', 'info', {
       message: '0xRay Orchestrator MCP Server shutting down',
     });

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 {
@@ -52,6 +65,41 @@ export interface TaskValidation {
   errors: string[];
 }
 
+export interface ActiveAside {
+  asideId: string;
+  description: string;
+  sessionId?: string;
+  parentAsideId?: string;
+  startedAt: number;
+  inheritedContext?: Record<string, unknown>;
+  priorVerdictContext?: Record<string, unknown>;
+  observations: AsideObservation[];
+}
+
+export interface AsideObservation {
+  key: string;
+  value: string;
+  source: string;
+}
+
+export interface AsideContextOptions {
+  description: string;
+  inheritedContext?: Record<string, unknown>;
+  priorVerdictContext?: Record<string, unknown>;
+  sessionId?: string;
+  parentAsideId?: string;
+}
+
+export interface AsideResult {
+  asideId: string;
+  description: string;
+  success: boolean;
+  duration: number;
+  observations: AsideObservation[];
+  priorVerdictContext?: Record<string, unknown>;
+  error?: string;
+}
+
 export interface OrchestrationStatus {
   activeSessions: number;
   totalTasks: number;
@@ -62,6 +110,8 @@ export interface OrchestrationStatus {
     tasks: number;
     duration: number;
   }>;
+  activeAsideCount?: number;
+  activeAsideIds?: string[];
 }
 
 export interface TaskExecutionContext {