0xray 3.4.8 → 3.4.10

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

@@ -17,6 +17,24 @@ import {
   fromMemoryTask,
 } from '../config/memory-routing-bridge.js';
 
+/** Dependency count from task-ID list or numeric hint from analyze-complexity */
+export function dependencyCount(
+  deps: OrchestrationTask['dependencies'] | undefined,
+): number {
+  if (deps == null) return 0;
+  if (typeof deps === 'number' && Number.isFinite(deps)) {
+    return Math.max(0, Math.round(deps));
+  }
+  if (Array.isArray(deps)) return deps.length;
+  return 0;
+}
+
+function isDependencyIdList(
+  deps: OrchestrationTask['dependencies'] | undefined,
+): deps is string[] {
+  return Array.isArray(deps) && deps.length > 0;
+}
+
 /**
  * Execution Planner
  * Plans and optimizes task execution strategies
@@ -51,8 +69,8 @@ export class ExecutionPlanner {
         errors.push(`Task ${i}: Missing required field 'type'`);
       }
 
-      // Check dependencies exist
-      if (task.dependencies && task.id) {
+      // Check task-ID dependencies exist (numeric hints skip graph validation)
+      if (isDependencyIdList(task.dependencies) && task.id) {
         const taskIds = new Set(tasks.map(t => t.id).filter((id): id is string => !!id));
         for (const depId of task.dependencies) {
           if (!taskIds.has(depId)) {
@@ -162,10 +180,10 @@ export class ExecutionPlanner {
     const dependentTasks: OrchestrationTask[] = [];
 
     for (const task of sortedTasks) {
-      if (!task.dependencies || task.dependencies.length === 0) {
-        independentTasks.push(task);
-      } else {
+      if (isDependencyIdList(task.dependencies)) {
         dependentTasks.push(task);
+      } else {
+        independentTasks.push(task);
       }
     }
 
@@ -188,7 +206,7 @@ export class ExecutionPlanner {
       if (visited.has(task.id)) return;
       visited.add(task.id);
 
-      if (task.dependencies) {
+      if (isDependencyIdList(task.dependencies)) {
         for (const depId of task.dependencies) {
           const depTask = taskMap.get(depId);
           if (depTask) visit(depTask);
@@ -225,6 +243,7 @@ export class ExecutionPlanner {
         requiredCaps,
         complexity,
         operationDescription,
+        task.type,
       ) || 'orchestrator';
 
       if (!agentAssignments.has(agent)) {
@@ -280,6 +299,7 @@ export class ExecutionPlanner {
         requiredCaps,
         complexity,
         task.description,
+        task.type,
       ) || 'orchestrator';
 
       if (!assignments.has(agent)) {
@@ -344,10 +364,7 @@ export class ExecutionPlanner {
       complexity = (complexity + task.estimatedComplexity) / 2;
     }
 
-    // Adjust based on dependencies
-    if (task.dependencies) {
-      complexity += task.dependencies.length * 5;
-    }
+    complexity += dependencyCount(task.dependencies) * 5;
 
     if (task.metadata?.memoryComplexityBoost !== undefined) {
       complexity += task.metadata.memoryComplexityBoost;
@@ -376,7 +393,7 @@ export class ExecutionPlanner {
    */
   private calculateParallelPotential(tasks: OrchestrationTask[]): number {
     // Tasks without dependencies can run in parallel
-    const independent = tasks.filter(t => !t.dependencies || t.dependencies.length === 0);
+    const independent = tasks.filter((t) => !isDependencyIdList(t.dependencies));
     return independent.length / tasks.length;
   }
 }

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

@@ -14,6 +14,46 @@ import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { addObservations, extractComplexityObservations } from '../aside-context.js';
 import type { OrchestrationTask, ComplexityAnalysis } from '../types.js';
 
+type AnalyzeComplexityInput = {
+  id?: string;
+  description?: string;
+  type?: string;
+  files?: string[];
+  dependencyCount?: number;
+  dependencies?: string[] | number;
+  riskLevel?: string;
+  estimatedComplexity?: number;
+  priority?: OrchestrationTask['priority'];
+};
+
+function normalizeAnalyzeTasks(raw: AnalyzeComplexityInput[]): OrchestrationTask[] {
+  return raw.map((task, index) => {
+    let deps: OrchestrationTask['dependencies'];
+    if (Array.isArray(task.dependencies)) {
+      deps = task.dependencies;
+    } else if (typeof task.dependencies === 'number' && Number.isFinite(task.dependencies)) {
+      deps = task.dependencies;
+    } else if (
+      typeof task.dependencyCount === 'number' &&
+      Number.isFinite(task.dependencyCount)
+    ) {
+      deps = task.dependencyCount;
+    }
+
+    const normalized: OrchestrationTask = {
+      id: task.id ?? `task-${index + 1}`,
+      description: task.description ?? '',
+      type: task.type ?? 'implement',
+    };
+    if (task.priority) normalized.priority = task.priority;
+    if (deps !== undefined) normalized.dependencies = deps;
+    if (task.estimatedComplexity !== undefined) {
+      normalized.estimatedComplexity = task.estimatedComplexity;
+    }
+    return normalized;
+  });
+}
+
 /**
  * Complexity Handler
  * Processes analyze-complexity requests
@@ -25,10 +65,10 @@ export class ComplexityHandler {
    * Handle analyze-complexity request
    */
   async handleAnalyzeComplexity(
-    args: { tasks: OrchestrationTask[] },
+    args: { tasks: AnalyzeComplexityInput[] },
     asideId?: string,
   ): Promise<{ content: Array<{ type: string; text: string }> }> {
-    const { tasks = [] } = args;
+    const tasks = normalizeAnalyzeTasks(args.tasks ?? []);
 
     await frameworkLogger.log(
       'orchestrator.server',
@@ -47,14 +87,32 @@ export class ComplexityHandler {
 
       const primaryDescription = tasks.map((t) => t.description).filter(Boolean).join(' ');
       const taskTypes = tasks.map((t) => t.type).filter(Boolean) as string[];
+      const planTaskInputs = tasks
+        .filter((t) => t.description?.trim())
+        .map((t) => ({ description: t.description, type: t.type }));
       const leadDevPlan =
-        isLeadDevModeActive() && primaryDescription
-          ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'])
+        isLeadDevModeActive() && (primaryDescription || planTaskInputs.length > 0)
+          ? buildLeadDevPlan(
+              primaryDescription,
+              taskTypes.length ? taskTypes : ['implement'],
+              planTaskInputs,
+              analysis.overallComplexity,
+            )
           : null;
 
       if (leadDevPlan) {
         try {
-          persistLeadDevPlan(leadDevPlan);
+          const planPath = persistLeadDevPlan(leadDevPlan);
+          await frameworkLogger.log(
+            'orchestrator.server',
+            'lead-dev-plan-persisted',
+            'info',
+            {
+              planPath,
+              phaseCount: leadDevPlan.phases.length,
+              todoCount: leadDevPlan.phases.reduce((n, p) => n + p.todos.length, 0),
+            },
+          );
         } catch (err) {
           await frameworkLogger.log(
             'orchestrator.server',

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

@@ -88,7 +88,6 @@ export class TaskHandler {
         });
       }
 
-      // 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)
@@ -118,6 +117,8 @@ export class TaskHandler {
       orchestrationResult.success = results.success;
       orchestrationResult.completedTasks = results.completedTasks;
       orchestrationResult.failedTasks = results.failedTasks;
+      orchestrationResult.deferredTasks = results.deferredTasks;
+      orchestrationResult.recommendations.push(...results.recommendations);
       orchestrationResult.agentUtilization = results.agentUtilization;
       orchestrationResult.bottlenecks = results.bottlenecks;
       orchestrationResult.recommendations = results.recommendations;
@@ -167,6 +168,7 @@ export class TaskHandler {
     success: boolean;
     completedTasks: number;
     failedTasks: number;
+    deferredTasks: number;
     agentUtilization: Record<string, number>;
     bottlenecks: string[];
     recommendations: string[];
@@ -181,6 +183,7 @@ export class TaskHandler {
     const agentUtilization: Record<string, number> = {};
     let completedTasks = 0;
     let failedTasks = 0;
+    let deferredTasks = 0;
     const agentOutputs: Record<string, string> = {};
     const taskOutcomes: Array<{
       taskId: string;
@@ -240,15 +243,20 @@ export class TaskHandler {
           }
         }
       } else {
-        // For non-MCP agents we still count them as "assigned" (they will be handled by the caller or legacy path)
         for (const task of tasks) {
-          completedTasks++;
+          deferredTasks++;
           taskOutcomes.push({
             taskId: task.id,
             agent,
-            success: true,
+            success: false,
             durationMs: 0,
           });
+          await frameworkLogger.log(
+            'orchestrator.task-handler',
+            'delegate-deferred',
+            'info',
+            { agent, taskId: task.id, sessionId },
+          );
         }
       }
     }
@@ -256,6 +264,12 @@ export class TaskHandler {
     const recommendations: string[] = [];
     const bottlenecks: string[] = [];
 
+    if (deferredTasks > 0) {
+      recommendations.push(
+        `${deferredTasks} task(s) require host delegation (Task/spawn_subagent per lead-dev-plan) — orchestrate-task only invokes MCP consult skills directly`,
+      );
+    }
+
     if (plan.agentAssignments.size > 5) {
       recommendations.push('Consider reducing the number of agents for better coordination');
     }
@@ -266,9 +280,10 @@ export class TaskHandler {
     }
 
     return {
-      success: failedTasks === 0,
+      success: failedTasks === 0 && deferredTasks === 0,
       completedTasks,
       failedTasks,
+      deferredTasks,
       agentUtilization,
       bottlenecks,
       recommendations,
@@ -321,9 +336,10 @@ export class TaskHandler {
 **Session ID:** ${result.sessionId}
 **Success:** ${result.success ? '✅ COMPLETED' : '❌ FAILED'}
 **Duration:** ${result.duration}ms
-**Tasks:** ${result.completedTasks + result.failedTasks} total
+**Tasks:** ${result.completedTasks + result.failedTasks + (result.deferredTasks ?? 0)} total
   - ✅ Completed: ${result.completedTasks}
   - ❌ Failed: ${result.failedTasks}
+  - ⏸ Deferred (host delegation required): ${result.deferredTasks ?? 0}
 
 **Agent Utilization:**
 ${Object.entries(result.agentUtilization)

package/src/mcps/orchestrator/server.ts

@@ -152,7 +152,15 @@ export class OrchestratorServer {
                       description: { type: 'string' },
                       type: { type: 'string' },
                       files: { type: 'array', items: { type: 'string' } },
-                      dependencies: { type: 'number' },
+                      dependencyCount: {
+                        type: 'number',
+                        description: 'Upstream dependency count (complexity hint only)',
+                      },
+                      dependencies: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Task IDs this task depends on',
+                      },
                       riskLevel: {
                         type: 'string',
                         enum: ['low', 'medium', 'high', 'critical'],

package/src/mcps/orchestrator/types.ts

@@ -30,7 +30,8 @@ export interface OrchestrationTask {
   description: string;
   type: string;
   priority?: 'critical' | 'high' | 'medium' | 'low';
-  dependencies?: string[];
+  /** Task IDs (orchestrate-task) or dependency count hint (analyze-complexity) */
+  dependencies?: string[] | number;
   estimatedComplexity?: number;
   metadata?: OrchestrationTaskMetadata;
 }
@@ -48,6 +49,8 @@ export interface OrchestrationResult {
   success: boolean;
   completedTasks: number;
   failedTasks: number;
+  /** Implementation agents not executed by orchestrate-task — lead must delegate via host Task */
+  deferredTasks?: number;
   duration: number;
   agentUtilization: Record<string, number>;
   agentOutputs?: Record<string, string>;

package/src/mcps/researcher.server.ts

@@ -488,7 +488,7 @@ class XrayLibrarianServer extends XrayKnowledgeSkillBase {
     if (!vote) {
       const abstainReason = memoryContext?.confidence.highConfidenceTrapPresent
         ? "No LLM governance provider configured. Repertoire detected a high-confidence ontological trap — route to the recommended agent before proceeding."
-        : "No LLM governance provider configured. Set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT, or install Hermes and run: hermes auth add xai-oauth --no-browser";
+        : "No LLM governance provider configured. Install Hermes on PATH (hermes -z) with xai-oauth, or set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT.";
 
       return {
         content: [

package/src/skills/orchestrator/SKILL.md

@@ -36,8 +36,9 @@ When `multi_agent_orchestration.lead_dev_mode` is true in `features.json` (defau
 
 | Step | MCP tool | Notes |
 |------|----------|-------|
-| **Intake + classify** | `analyze-complexity` | Pass `tasks` array; response includes **lead-dev plan JSON** when mode is on |
-| Delegate | `orchestrate-task` | Include agent + sessionId (codex 67) |
+| **Intake + classify** | `analyze-complexity` | Pass `tasks` array; persists `.xray/state/lead-dev-plan.json` when mode is on |
+| Delegate (consult) | `orchestrate-task` | Invokes MCP consult skills (code-review, researcher, security-audit, etc.) |
+| Delegate (implement) | **host `Task` / `spawn_subagent`** | `orchestrate-task` **defers** backend-engineer, frontend-engineer, bug-triage — lead must spawn |
 | Monitor | `get-orchestration-status` | Lead updates todos |
 | Major work | researcher + architect-tools + code-review | Auto-listed in plan when complexity > threshold |