0xray 3.1.1 → 3.3.0

package/dist/mcps/orchestrator/aside-context.js

@@ -0,0 +1,207 @@
+/**
+ * AsideContext — bounded subcontext for depth, continuity, and layered exploration
+ *
+ * Enables the orchestrator to spawn sub-investigations that inherit session context,
+ * accumulate structured observations from v3 subsystems (governance, orchestration,
+ * complexity analysis), and feed results back into the governance loop.
+ */
+import { frameworkLogger } from "../../core/framework-logger.js";
+let asideCounter = 0;
+const activeAsides = new Map();
+export function getActiveAsideCount() {
+    return activeAsides.size;
+}
+export function getActiveAsideIds() {
+    return Array.from(activeAsides.keys());
+}
+export function getAsideState(asideId) {
+    return activeAsides.get(asideId);
+}
+export function addObservations(asideId, observations) {
+    const aside = activeAsides.get(asideId);
+    if (!aside)
+        return false;
+    aside.observations.push(...observations);
+    return true;
+}
+export function extractGovernanceObservations(result) {
+    const obs = [];
+    obs.push({
+        key: "governanceCycleId",
+        value: result.cycleId,
+        source: "inference/inference-cycle.ts",
+    });
+    obs.push({
+        key: "governanceVoteCount",
+        value: String(result.votes.length),
+        source: "inference/inference-cycle.ts",
+    });
+    const approved = result.votes.filter((v) => v.decision === "approve").length;
+    const rejected = result.votes.filter((v) => v.decision === "reject").length;
+    obs.push({
+        key: "governanceApprovedCount",
+        value: String(approved),
+        source: "inference/inference-cycle.ts",
+    });
+    obs.push({
+        key: "governanceRejectedCount",
+        value: String(rejected),
+        source: "inference/inference-cycle.ts",
+    });
+    if (result.corpusSummary) {
+        obs.push({
+            key: "corpusSessionCount",
+            value: String(result.corpusSummary.sessions),
+            source: "inference/inference-cycle.ts",
+        });
+        obs.push({
+            key: "corpusPatternCount",
+            value: String(result.corpusSummary.recurringPatterns),
+            source: "inference/inference-cycle.ts",
+        });
+    }
+    return obs;
+}
+export function extractOrchestrationObservations(result) {
+    const obs = [];
+    obs.push({
+        key: "orchestrationSuccess",
+        value: String(result.success),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "tasksCompleted",
+        value: String(result.completedTasks),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "tasksFailed",
+        value: String(result.failedTasks),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "orchestrationDuration",
+        value: `${result.duration}ms`,
+        source: "mcps/orchestrator/types.ts",
+    });
+    for (const b of result.bottlenecks) {
+        obs.push({
+            key: "bottleneck",
+            value: b.substring(0, 200),
+            source: "mcps/orchestrator/types.ts",
+        });
+    }
+    for (const r of result.recommendations) {
+        obs.push({
+            key: "recommendation",
+            value: r.substring(0, 200),
+            source: "mcps/orchestrator/types.ts",
+        });
+    }
+    return obs;
+}
+export function extractComplexityObservations(analysis) {
+    const obs = [];
+    obs.push({
+        key: "complexityScore",
+        value: String(analysis.overallComplexity),
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "recommendedStrategy",
+        value: analysis.recommendedStrategy,
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "parallelPotential",
+        value: String(analysis.parallelPotential),
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "estimatedDuration",
+        value: `${analysis.estimatedDuration}ms`,
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    for (const tc of analysis.taskComplexity) {
+        obs.push({
+            key: `taskComplexity`,
+            value: `${tc.complexity} (${tc.category})`,
+            source: "mcps/orchestrator/execution/execution-planner.ts",
+        });
+    }
+    return obs;
+}
+export async function spawnAside(options) {
+    const asideId = options.parentAsideId
+        ? `${options.parentAsideId}.aside-${++asideCounter}`
+        : `aside-${++asideCounter}-${Date.now()}`;
+    const startTime = Date.now();
+    const aside = {
+        asideId,
+        description: options.description,
+        startedAt: startTime,
+        observations: [],
+        ...(options.inheritedContext !== undefined ? { inheritedContext: options.inheritedContext } : {}),
+        ...(options.parentAsideId !== undefined ? { parentAsideId: options.parentAsideId } : {}),
+        ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
+        ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+    };
+    activeAsides.set(asideId, aside);
+    frameworkLogger.log("aside-context", "aside-spawn", "info", {
+        asideId,
+        description: options.description,
+        sessionId: options.sessionId,
+        parentAsideId: options.parentAsideId,
+        activeAsideCount: activeAsides.size,
+    });
+    if (options.priorVerdictContext) {
+        const decision = options.priorVerdictContext["decision"];
+        if (decision) {
+            aside.observations.push({
+                key: "governanceDecision",
+                value: String(decision),
+                source: "priorVerdictContext",
+            });
+        }
+    }
+    const duration = Date.now() - startTime;
+    const result = {
+        asideId,
+        description: options.description,
+        success: true,
+        duration,
+        observations: aside.observations,
+        ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+    };
+    frameworkLogger.log("aside-context", "aside-complete", "info", {
+        asideId,
+        duration,
+        observationCount: aside.observations.length,
+        activeAsideCount: activeAsides.size,
+    });
+    return result;
+}
+export function closeAside(asideId) {
+    const aside = activeAsides.get(asideId);
+    if (!aside)
+        return false;
+    activeAsides.delete(asideId);
+    frameworkLogger.log("aside-context", "aside-closed", "info", {
+        asideId,
+        duration: Date.now() - aside.startedAt,
+        remainingActive: activeAsides.size,
+    });
+    return true;
+}
+export function closeAllAsides() {
+    const count = activeAsides.size;
+    activeAsides.clear();
+    frameworkLogger.log("aside-context", "aside-close-all", "info", {
+        closedCount: count,
+    });
+    return count;
+}
+export function resetAsideContext() {
+    activeAsides.clear();
+    asideCounter = 0;
+}

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

@@ -5,6 +5,7 @@
  */
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
+import { addObservations, extractComplexityObservations } from '../aside-context.js';
 /**
  * Complexity Handler
  * Processes analyze-complexity requests
@@ -14,12 +15,15 @@ export class ComplexityHandler {
     /**
      * Handle analyze-complexity request
      */
-    async handleAnalyzeComplexity(args) {
+    async handleAnalyzeComplexity(args, asideId) {
         const { tasks = [] } = args;
         await frameworkLogger.log('orchestrator.server', 'analyze-complexity-start', 'info', { taskCount: tasks.length });
         try {
             const analysis = await this.planner.analyzeTaskComplexity(tasks);
             const recommendations = this.generateRecommendations(analysis);
+            if (asideId) {
+                addObservations(asideId, extractComplexityObservations(analysis));
+            }
             return {
                 content: [
                     {

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

@@ -41,7 +41,14 @@ export class StatusHandler {
                 // Overall status
                 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/dist/mcps/orchestrator/handlers/task-handler.js

@@ -6,6 +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, spawnAside } from '../aside-context.js';
+import { getProvider } from '../config/memory-routing-bridge.js';
 /**
  * Task Handler
  * Processes orchestrate-task requests
@@ -37,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;
@@ -49,6 +80,10 @@ export class TaskHandler {
             if (results.agentOutputs) {
                 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,
@@ -77,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',
@@ -91,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, {
@@ -101,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,
@@ -115,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 = [];
@@ -136,6 +193,7 @@ export class TaskHandler {
             bottlenecks,
             recommendations,
             agentOutputs,
+            taskOutcomes,
         };
     }
     mapAgentToTool(agent) {

package/dist/mcps/orchestrator/index.js

@@ -0,0 +1,5 @@
+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';