0xray 3.4.8 → 3.4.10

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

@@ -5,6 +5,20 @@
  */
 import { getAgentCapabilitiesManager } from '../config/agent-capabilities.js';
 import { getProvider, toMemoryTask, fromMemoryTask, } from '../config/memory-routing-bridge.js';
+/** Dependency count from task-ID list or numeric hint from analyze-complexity */
+export function dependencyCount(deps) {
+    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) {
+    return Array.isArray(deps) && deps.length > 0;
+}
 /**
  * Execution Planner
  * Plans and optimizes task execution strategies
@@ -33,8 +47,8 @@ export class ExecutionPlanner {
             if (!task.type) {
                 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));
                 for (const depId of task.dependencies) {
                     if (!taskIds.has(depId)) {
@@ -117,11 +131,11 @@ export class ExecutionPlanner {
         const independentTasks = [];
         const dependentTasks = [];
         for (const task of sortedTasks) {
-            if (!task.dependencies || task.dependencies.length === 0) {
-                independentTasks.push(task);
+            if (isDependencyIdList(task.dependencies)) {
+                dependentTasks.push(task);
             }
             else {
-                dependentTasks.push(task);
+                independentTasks.push(task);
             }
         }
         // Assign independent tasks in parallel
@@ -140,7 +154,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)
@@ -167,7 +181,7 @@ export class ExecutionPlanner {
             const operationDescription = task.metadata?.memoryHighConfidenceTrap
                 ? `${task.description} TYPE: ontological-trap`
                 : task.description;
-            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, operationDescription) || 'orchestrator';
+            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, operationDescription, task.type) || 'orchestrator';
             if (!agentAssignments.has(agent)) {
                 agentAssignments.set(agent, []);
             }
@@ -209,7 +223,7 @@ export class ExecutionPlanner {
                 task.type,
                 ...(task.metadata?.memorySignals ?? []),
             ];
-            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, task.description) || 'orchestrator';
+            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, task.description, task.type) || 'orchestrator';
             if (!assignments.has(agent)) {
                 assignments.set(agent, []);
             }
@@ -263,10 +277,7 @@ export class ExecutionPlanner {
         if (task.estimatedComplexity) {
             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;
         }
@@ -295,7 +306,7 @@ export class ExecutionPlanner {
      */
     calculateParallelPotential(tasks) {
         // 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/dist/mcps/orchestrator/handlers/complexity-handler.d.ts

@@ -4,6 +4,17 @@
  * Handles complexity analysis requests
  */
 import type { OrchestrationTask } 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'];
+};
 /**
  * Complexity Handler
  * Processes analyze-complexity requests
@@ -14,7 +25,7 @@ export declare class ComplexityHandler {
      * Handle analyze-complexity request
      */
     handleAnalyzeComplexity(args: {
-        tasks: OrchestrationTask[];
+        tasks: AnalyzeComplexityInput[];
     }, asideId?: string): Promise<{
         content: Array<{
             type: string;
@@ -30,3 +41,4 @@ export declare class ComplexityHandler {
      */
     private formatComplexityResponse;
 }
+export {};

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

@@ -7,6 +7,34 @@ import { frameworkLogger } from '../../../core/framework-logger.js';
 import { buildLeadDevPlan, isLeadDevModeActive, persistLeadDevPlan, } from '../../../nucleus/autonomy-kernel.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { addObservations, extractComplexityObservations } from '../aside-context.js';
+function normalizeAnalyzeTasks(raw) {
+    return raw.map((task, index) => {
+        let deps;
+        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 = {
+            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
@@ -17,7 +45,7 @@ export class ComplexityHandler {
      * Handle analyze-complexity request
      */
     async handleAnalyzeComplexity(args, asideId) {
-        const { tasks = [] } = args;
+        const tasks = normalizeAnalyzeTasks(args.tasks ?? []);
         await frameworkLogger.log('orchestrator.server', 'analyze-complexity-start', 'info', { taskCount: tasks.length });
         try {
             const analysis = await this.planner.analyzeTaskComplexity(tasks);
@@ -27,12 +55,20 @@ export class ComplexityHandler {
             }
             const primaryDescription = tasks.map((t) => t.description).filter(Boolean).join(' ');
             const taskTypes = tasks.map((t) => t.type).filter(Boolean);
-            const leadDevPlan = isLeadDevModeActive() && primaryDescription
-                ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'])
+            const planTaskInputs = tasks
+                .filter((t) => t.description?.trim())
+                .map((t) => ({ description: t.description, type: t.type }));
+            const leadDevPlan = 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', 'lead-dev-plan-persist-failed', 'warning', { error: err instanceof Error ? err.message : String(err) });

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

@@ -49,7 +49,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)
             if (memoryProvider.ingestFeedback) {
@@ -74,6 +73,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;
@@ -111,6 +112,7 @@ export class TaskHandler {
         const agentUtilization = {};
         let completedTasks = 0;
         let failedTasks = 0;
+        let deferredTasks = 0;
         const agentOutputs = {};
         const taskOutcomes = [];
         const skillServers = new Set([
@@ -163,20 +165,23 @@ 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 });
                 }
             }
         }
         const recommendations = [];
         const bottlenecks = [];
+        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');
         }
@@ -186,9 +191,10 @@ export class TaskHandler {
             }
         }
         return {
-            success: failedTasks === 0,
+            success: failedTasks === 0 && deferredTasks === 0,
             completedTasks,
             failedTasks,
+            deferredTasks,
             agentUtilization,
             bottlenecks,
             recommendations,
@@ -232,9 +238,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/dist/mcps/orchestrator/server.js

@@ -117,7 +117,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/dist/mcps/orchestrator/types.d.ts

@@ -27,7 +27,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;
 }
@@ -43,6 +44,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/dist/mcps/researcher.server.js

@@ -397,7 +397,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/dist/nucleus/autonomy-kernel.d.ts

@@ -18,6 +18,10 @@ export interface LeadDevPhase {
     definitionOfDone: string;
     todos: LeadDevTodo[];
 }
+export interface LeadDevPlanTaskInput {
+    description: string;
+    type?: string;
+}
 export interface LeadDevPlan {
     active: boolean;
     rules: readonly string[];
@@ -37,7 +41,7 @@ export interface LeadDevPlan {
 export declare function isLeadDevModeActive(): boolean;
 export declare function routeSubagent(taskType: string): SubagentRoute;
 export declare function shouldFlagFullTestSuite(command: string): boolean;
-export declare function buildLeadDevPlan(description: string, taskTypes?: string[]): LeadDevPlan | null;
+export declare function buildLeadDevPlan(description: string, taskTypes?: string[], taskInputs?: LeadDevPlanTaskInput[], mcpOverallComplexity?: number): LeadDevPlan | null;
 export declare function buildSessionBootContext(): Record<string, unknown>;
 /** Persist plan for PreToolUse spawn_subagent gate */
 export declare function persistLeadDevPlan(plan: LeadDevPlan, projectRoot?: string): string;

package/dist/nucleus/autonomy-kernel.js

@@ -57,14 +57,33 @@ export function shouldFlagFullTestSuite(command) {
         /\btest:\w+/.test(cmd);
     return isTest && !hasFocusedTarget;
 }
-export function buildLeadDevPlan(description, taskTypes = ['implement']) {
+function buildImplementationTodos(description, taskTypes, taskInputs, idPrefix) {
+    if (taskInputs.length > 0) {
+        return taskInputs.map((t, i) => ({
+            id: `${idPrefix}.${i + 1}`,
+            task: t.description.slice(0, 200),
+            subagent: routeSubagent(t.type ?? 'implement'),
+            status: 'pending',
+        }));
+    }
+    return taskTypes.map((type, i) => ({
+        id: `${idPrefix}.${i + 1}`,
+        task: description.slice(0, 200),
+        subagent: routeSubagent(type),
+        status: 'pending',
+    }));
+}
+export function buildLeadDevPlan(description, taskTypes = ['implement'], taskInputs = [], mcpOverallComplexity) {
     if (!isLeadDevModeActive())
         return null;
     const cfg = orchestrationConfig();
     const threshold = cfg.phased_plan_threshold ?? 25;
     const score = scoreComplexity(description, { taskTypes });
-    const complexity = score.score;
-    const requiresPhasedPlan = complexity > threshold;
+    const mcpScore = mcpOverallComplexity !== undefined && Number.isFinite(mcpOverallComplexity)
+        ? Math.round(mcpOverallComplexity)
+        : 0;
+    const complexity = Math.max(score.score, mcpScore);
+    const requiresPhasedPlan = complexity > threshold || taskInputs.length > 1;
     const mandatoryConsults = cfg.auto_consult_major_work !== false && requiresPhasedPlan
         ? [...MANDATORY_MAJOR_CONSULTS]
         : [];
@@ -87,12 +106,7 @@ export function buildLeadDevPlan(description, taskTypes = ['implement']) {
                 name: 'Implementation',
                 goal: 'Execute with best subagent per todo',
                 definitionOfDone: 'Affected per-suite tests green',
-                todos: taskTypes.map((type, i) => ({
-                    id: `2.${i + 1}`,
-                    task: description.slice(0, 200),
-                    subagent: routeSubagent(type),
-                    status: 'pending',
-                })),
+                todos: buildImplementationTodos(description, taskTypes, taskInputs, '2'),
             },
             {
                 id: 'phase-3',
@@ -121,14 +135,7 @@ export function buildLeadDevPlan(description, taskTypes = ['implement']) {
                 name: 'Direct execution',
                 goal: description.slice(0, 120),
                 definitionOfDone: 'Task complete with tests green',
-                todos: [
-                    {
-                        id: '1.1',
-                        task: description.slice(0, 200),
-                        subagent: routeSubagent(taskTypes[0] ?? 'implement'),
-                        status: 'pending',
-                    },
-                ],
+                todos: buildImplementationTodos(description, taskTypes, taskInputs, '1'),
             },
         ];
     return {

package/dist/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 |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "3.4.8",
+  "version": "3.4.10",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",
@@ -125,7 +125,8 @@
     "pre-publish-guard": "node scripts/node/pre-publish-guard.js",
     "safe-publish": "npm run prepare-consumer && npm run build",
     "publish": "npm run release:gate && npm run safe-publish && npm publish --access public",
-    "release:patch": "node scripts/node/release.mjs patch"
+    "release:patch": "node scripts/node/release.mjs patch",
+    "verify:orchestrator-behavior": "npm run build && node scripts/mjs/verify-orchestrator-behavior.mjs"
   },
   "files": [
     "dist/",
@@ -137,6 +138,7 @@
     "scripts/mjs/test-mcp-functionality.mjs",
     "scripts/mjs/validate-mcp-connectivity.cjs",
     "scripts/mjs/validate-postinstall-config.mjs",
+    "scripts/mjs/verify-orchestrator-behavior.mjs",
     "src/opencode/",
     "src/opencode/codex.codex",
     "src/opencode/commands/",

package/scripts/mjs/verify-orchestrator-behavior.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * Consumer behavior verify — orchestrator honesty (ships in 0xray tarball).
+ * Run: node node_modules/0xray/scripts/mjs/verify-orchestrator-behavior.mjs
+ */
+import { dirname, join } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, '../..');
+const dist = (rel) => pathToFileURL(join(packageRoot, 'dist', rel)).href;
+
+let failed = 0;
+
+function pass(name) {
+  console.log(`✅ ${name}`);
+}
+
+function fail(name, detail = '') {
+  failed++;
+  console.error(`❌ ${name}${detail ? ` — ${detail}` : ''}`);
+}
+
+const { dependencyCount, getExecutionPlanner } = await import(
+  dist('mcps/orchestrator/execution/execution-planner.js')
+);
+const { buildLeadDevPlan } = await import(dist('nucleus/autonomy-kernel.js'));
+const { TaskHandler } = await import(
+  dist('mcps/orchestrator/handlers/task-handler.js')
+);
+
+const planner = getExecutionPlanner();
+
+// 1. numeric deps ≠ NaN
+const analysis = await planner.analyzeTaskComplexity([
+  {
+    id: 't1',
+    description: 'Jelly migration',
+    type: 'implement',
+    dependencies: 8,
+  },
+]);
+if (Number.isFinite(analysis.overallComplexity) && analysis.overallComplexity > 0) {
+  pass('numeric dependencyCount produces finite MCP complexity');
+} else {
+  fail('NaN guard', `overallComplexity=${analysis.overallComplexity}`);
+}
+
+// 2. multi-task → ≥3 todos
+const multiPlan = buildLeadDevPlan(
+  'G0 J1 J2',
+  ['implement'],
+  [
+    { description: 'Publish 0xray', type: 'release' },
+    { description: 'Jelly swap', type: 'migration' },
+    { description: 'Wire tests', type: 'test' },
+  ],
+  70,
+);
+const todoCount =
+  multiPlan?.phases.reduce((n, p) => n + p.todos.length, 0) ?? 0;
+if (multiPlan?.requiresPhasedPlan && todoCount >= 3) {
+  pass(`multi-task phased plan (${todoCount} todos)`);
+} else {
+  fail('multi-task plan', `requiresPhasedPlan=${multiPlan?.requiresPhasedPlan} todos=${todoCount}`);
+}
+
+// 3. implement → backend-engineer
+const implAnalysis = await planner.analyzeTaskComplexity([
+  { id: 'impl-1', description: 'swap deps', type: 'implement' },
+]);
+const implAgent = implAnalysis.agentAssignments[0]?.agent;
+if (implAgent === 'backend-engineer') {
+  pass('implement routes to backend-engineer');
+} else {
+  fail('implement routing', `got ${implAgent}`);
+}
+
+// 4. MCP complexity drives phased plan (single task, high MCP score)
+const singleHigh = buildLeadDevPlan(
+  'single complex migration',
+  ['implement'],
+  [{ description: 'single complex migration', type: 'implement' }],
+  70,
+);
+if (singleHigh?.requiresPhasedPlan && (singleHigh.phases.length ?? 0) > 1) {
+  pass('MCP overallComplexity 70 forces phased plan');
+} else {
+  fail('MCP phased plan', `requiresPhasedPlan=${singleHigh?.requiresPhasedPlan}`);
+}
+
+// 5. orchestrate-task defers implement (not fake-complete)
+const handler = new TaskHandler();
+const orch = await handler.handleOrchestrateTask(
+  {
+    description: 'implement feature',
+    sessionId: 'verify-behavior',
+    tasks: [
+      {
+        id: 'be-1',
+        description: 'implementation work',
+        type: 'implement',
+        estimatedComplexity: 40,
+      },
+    ],
+  },
+  { taskHistory: [], activeTasks: new Map() },
+);
+const text = orch.content[0]?.text ?? '';
+if (text.includes('Deferred') && text.includes('❌ FAILED')) {
+  pass('orchestrate-task defers implement (success: false)');
+} else {
+  fail('defer honesty', text.slice(0, 200));
+}
+
+console.log(
+  '\n' +
+    (failed === 0
+      ? '🎉 Orchestrator behavior verify passed (5/5).'
+      : `⚠️  ${failed} behavior check(s) failed.`),
+);
+process.exit(failed === 0 ? 0 : 1);

package/src/mcps/knowledge-skills/code-review.server.ts

@@ -448,7 +448,7 @@ class XrayCodeReviewServer extends XrayKnowledgeSkillBase {
         content: [
           {
             type: "text",
-            text: "DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: 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",
+            text: "DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: No LLM governance provider configured. Install Hermes on PATH (hermes -z) with xai-oauth, or set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT.",
           },
         ],
       };

package/src/mcps/knowledge-skills/security-audit.server.ts

@@ -1008,7 +1008,7 @@ class XraySecurityAuditServer extends XrayKnowledgeSkillBase {
         content: [
           {
             type: "text",
-            text: "DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: 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",
+            text: "DECISION: abstain\nCONFIDENCE: 0.50\nREASONING: No LLM governance provider configured. Install Hermes on PATH (hermes -z) with xai-oauth, or set XRAY_GOVERNANCE_LLM_ENABLED=true + XRAY_LLM_ENDPOINT.",
           },
         ],
       };

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/config/memory-routing-bridge.ts

@@ -39,7 +39,9 @@ export function toMemoryTask(task: OrchestrationTask): MemoryOrchestrationTask {
     type: task.type,
   };
   if (task.priority) result.priority = task.priority;
-  if (task.dependencies) result.dependencies = task.dependencies;
+  if (Array.isArray(task.dependencies) && task.dependencies.length > 0) {
+    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;