0xray 3.4.9 → 3.5.0

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

@@ -13,6 +13,25 @@ import {
   toMemoryCapabilityMap,
   fromMemoryCapabilityMap,
 } from './memory-routing-bridge.js';
+import { routeSubagent } from '../../../nucleus/autonomy-kernel.js';
+
+/** routeSubagent names → AGENT_REGISTRY keys */
+const ROUTE_AGENT_ALIASES: Record<string, string> = {
+  'code-review': 'code-reviewer',
+  'security-audit': 'security-auditor',
+  'bug-triage': 'bug-triage-specialist',
+  'architect-tools': 'architect',
+};
+
+function resolveRoutedAgent(
+  routed: string,
+  capabilities: Map<string, AgentCapability>,
+): string | null {
+  const candidate = ROUTE_AGENT_ALIASES[routed] ?? routed;
+  if (capabilities.has(candidate)) return candidate;
+  if (capabilities.has(routed)) return routed;
+  return null;
+}
 
 const DEFAULT_AGENT_CAPABILITIES: Record<string, AgentCapability> = Object.fromEntries(
   Object.entries(AGENT_REGISTRY).map(([name, entry]) => [
@@ -81,7 +100,14 @@ export class AgentCapabilitiesManager {
     requiredCapabilities: string[],
     complexity: number,
     operationDescription = '',
+    taskType = '',
   ): string | null {
+    if (taskType.trim()) {
+      const routed = routeSubagent(taskType);
+      const resolved = resolveRoutedAgent(routed, this.capabilities);
+      if (resolved) return resolved;
+    }
+
     const provider = getProvider();
 
     if (provider.id !== 'null' && operationDescription) {

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

@@ -243,6 +243,7 @@ export class ExecutionPlanner {
         requiredCaps,
         complexity,
         operationDescription,
+        task.type,
       ) || 'orchestrator';
 
       if (!agentAssignments.has(agent)) {
@@ -298,6 +299,7 @@ export class ExecutionPlanner {
         requiredCaps,
         complexity,
         task.description,
+        task.type,
       ) || 'orchestrator';
 
       if (!assignments.has(agent)) {

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

@@ -10,6 +10,8 @@ import {
   isLeadDevModeActive,
   persistLeadDevPlan,
 } from '../../../nucleus/autonomy-kernel.js';
+import { bindPlanToSession } from '../../../nucleus/lead-dev-plan-persistence.js';
+import { clearPendingDelegations } from '../../../nucleus/pending-delegations.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { addObservations, extractComplexityObservations } from '../aside-context.js';
 import type { OrchestrationTask, ComplexityAnalysis } from '../types.js';
@@ -65,7 +67,7 @@ export class ComplexityHandler {
    * Handle analyze-complexity request
    */
   async handleAnalyzeComplexity(
-    args: { tasks: AnalyzeComplexityInput[] },
+    args: { tasks: AnalyzeComplexityInput[]; sessionId?: string },
     asideId?: string,
   ): Promise<{ content: Array<{ type: string; text: string }> }> {
     const tasks = normalizeAnalyzeTasks(args.tasks ?? []);
@@ -96,18 +98,24 @@ export class ComplexityHandler {
               primaryDescription,
               taskTypes.length ? taskTypes : ['implement'],
               planTaskInputs,
+              analysis.overallComplexity,
             )
           : null;
 
       if (leadDevPlan) {
         try {
+          const sessionId = args.sessionId ?? `analyze-${Date.now()}`;
+          clearPendingDelegations();
           const planPath = persistLeadDevPlan(leadDevPlan);
+          const bound = bindPlanToSession(sessionId);
           await frameworkLogger.log(
             'orchestrator.server',
             'lead-dev-plan-persisted',
             'info',
             {
               planPath,
+              sessionId,
+              planGeneration: bound?.planGeneration,
               phaseCount: leadDevPlan.phases.length,
               todoCount: leadDevPlan.phases.reduce((n, p) => n + p.todos.length, 0),
             },

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

@@ -9,6 +9,11 @@ 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';
+import {
+  delegationSummaryForResponse,
+  recordDeferredDelegations,
+  type PendingDelegation,
+} from '../../../nucleus/pending-delegations.js';
 import type { OrchestrationResult, OrchestrationTask } from '../types.js';
 
 export interface TaskHandlerDeps {
@@ -66,6 +71,7 @@ export class TaskHandler {
     };
 
     const startTime = Date.now();
+    let pendingDelegations: PendingDelegation[] = [];
 
     try {
       // Validate tasks
@@ -90,6 +96,16 @@ export class TaskHandler {
 
       const results = await this.executePlan(executionPlan, sessionId, timeout);
 
+      if (results.deferredRecords.length > 0) {
+        pendingDelegations = recordDeferredDelegations(sessionId, results.deferredRecords);
+        await frameworkLogger.log(
+          'orchestrator.task-handler',
+          'pending-delegations-recorded',
+          'info',
+          { count: pendingDelegations.length, sessionId },
+        );
+      }
+
       // Feed per-task outcomes back to memory provider (not aggregate session stats)
       if (memoryProvider.ingestFeedback) {
         const outcomeByKey = new Map(
@@ -150,7 +166,12 @@ export class TaskHandler {
 
     orchestrationResult.duration = Date.now() - startTime;
 
-    const response = this.formatOrchestrationResponse(description, orchestrationResult, executionMode);
+    const response = this.formatOrchestrationResponse(
+      description,
+      orchestrationResult,
+      executionMode,
+      pendingDelegations,
+    );
 
     return { content: [{ type: 'text', text: response }] };
   }
@@ -173,6 +194,12 @@ export class TaskHandler {
     bottlenecks: string[];
     recommendations: string[];
     agentOutputs?: Record<string, string>;
+    deferredRecords: Array<{
+      taskId: string;
+      agent: string;
+      description: string;
+      type?: string;
+    }>;
     taskOutcomes: Array<{
       taskId: string;
       agent: string;
@@ -185,6 +212,12 @@ export class TaskHandler {
     let failedTasks = 0;
     let deferredTasks = 0;
     const agentOutputs: Record<string, string> = {};
+    const deferredRecords: Array<{
+      taskId: string;
+      agent: string;
+      description: string;
+      type?: string;
+    }> = [];
     const taskOutcomes: Array<{
       taskId: string;
       agent: string;
@@ -245,6 +278,12 @@ export class TaskHandler {
       } else {
         for (const task of tasks) {
           deferredTasks++;
+          deferredRecords.push({
+            taskId: task.id,
+            agent,
+            description: task.description,
+            type: task.type,
+          });
           taskOutcomes.push({
             taskId: task.id,
             agent,
@@ -288,6 +327,7 @@ export class TaskHandler {
       bottlenecks,
       recommendations,
       agentOutputs,
+      deferredRecords,
       taskOutcomes,
     };
   }
@@ -329,8 +369,18 @@ export class TaskHandler {
   private formatOrchestrationResponse(
     description: string,
     result: OrchestrationResult,
-    executionMode: string
+    executionMode: string,
+    pendingDelegations: PendingDelegation[] = [],
   ): string {
+    const delegationsBlock =
+      pendingDelegations.length > 0
+        ? `\n**Delegations (host Task required):**\n\`\`\`json\n${JSON.stringify(
+            { delegations: delegationSummaryForResponse(pendingDelegations) },
+            null,
+            2,
+          )}\n\`\`\`\n`
+        : '';
+
     return `🎯 Orchestration Complete: "${description}"
 
 **Session ID:** ${result.sessionId}
@@ -355,6 +405,6 @@ ${result.recommendations.length > 0 ? result.recommendations.map((r) => `•
 
 ${result.agentOutputs && Object.keys(result.agentOutputs).length > 0 
   ? `**Agent Outputs (real MCP responses):**\n${Object.entries(result.agentOutputs).map(([k, v]) => `• ${k}: ${v.substring(0, 200)}${v.length > 200 ? '...' : ''}`).join('\n')}\n`
-  : ''}`;
+  : ''}${delegationsBlock}`;
   }
 }

package/xray/features.json

@@ -35,7 +35,8 @@
     "per_suite_test_triage": true,
     "phased_plan_threshold": 25,
     "auto_consult_major_work": true,
-    "no_new_surface": true
+    "no_new_surface": true,
+    "auto_chain_delegations": true
   },
   "autonomous_reporting": {
     "enabled": true,