0xray 3.2.0 → 3.3.1

package/.opencode/codex.codex

@@ -1,5 +1,5 @@
 {
-  "version": "3.2.0",
+  "version": "3.3.1",
   "terms": [
     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60
   ],

package/dist/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://www.conventionalcommits.org/).
 
+## [3.3.0] - 2026-06-18
+
+### 🔄 Changes
+
+### 🔎 Other Changes
+- Wire orchestrator confidence gate into execution planning (d7910b610)
+- tweet: v3.3.0 release tweet — Pluggable Memory Routing (7fb6c9f70)
+
+---
+
+## [3.2.0] - 2026-06-17
+
+### 🔄 Changes
+
+### ✨ Features
+- Orphan file resolution: 5 dead files deleted, ~39 files integrated under typecheck
+- feat: 58 type errors fixed across 6 source files
+- feat: pre-existing e2e failures fixed (OpenClaw 9/9, Grok CLI 62/0)
+- feat: vitest config testTimeout added for processor-logger stability
+- feat: pre-tool-use hook rewritten from skeleton to full hook with resonance/decision-matrix/JSON
+- feat: SelfProposalEngine integrated under typecheck with metamorphosis type support
+
+### 🐛 Bug Fixes
+- fix: postinstall e2e version assertions (3.1.1 → 0.5.2)
+- fix: AGENTS.md session entry and test assertions cleaned
+- fix: enforcement-gate fallback dynamic imports `as string` cast
+
+### ♻️ Refactoring
+- chore: removed ~180 stale @version JSDoc tags from source files
+- chore: cleaned stale version badges from README, AGENTS.md, docs-site docs
+- chore: removed "xray 2.0" from command docs (26 files)
+- chore: release.mjs checks npm view 0xray version (was xray)
+- chore: release.mjs push target master → main
+
+---
+
 ## [3.1.1] - 2026-06-17
 
 ### 🔄 Changes

package/dist/core/features-config.js

@@ -472,6 +472,9 @@ export class FeaturesConfigLoader {
     getInference() {
         return this.loadConfig().inference;
     }
+    getMemoryRouting() {
+        return this.loadConfig().memory_routing;
+    }
     getPublish() {
         return this.loadConfig().publish;
     }

package/dist/integrations/grok/grok-cli.js

@@ -55,6 +55,12 @@ export async function installForGrokCLI(options = {}) {
             console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to Grok plugin\x1b[0m`);
         }
         frameworkLogger.log('grok-integration', 'skills-synced', 'info', { count: skillsCopied });
+        // Grok Build / Cursor also reads ~/.grok/skills/ for agent_skills
+        const globalSkillsDir = path.join(home, '.grok', 'skills');
+        const globalCopied = syncBuiltinSkills(globalSkillsDir);
+        if (globalCopied > 0) {
+            console.log(`\x1b[32m✓ Synced ${globalCopied} builtin skills to ~/.grok/skills/\x1b[0m`);
+        }
         // Attempt auto-trust (best effort)
         try {
             execSync(`grok plugins trust "${targetPluginDir}"`, { stdio: 'ignore' });

package/dist/mcps/index.js

@@ -40,6 +40,7 @@ export const MCP_SERVERS = [
     { serverName: "refactoring-strategies", sourceFile: "mcps/knowledge-skills/refactoring-strategies.server.ts", type: "knowledge-skill", registered: true, description: "Refactoring strategies" },
     { serverName: "security-audit", sourceFile: "mcps/knowledge-skills/security-audit.server.ts", type: "knowledge-skill", registered: true, description: "Security auditing" },
     { serverName: "seo-consultant", sourceFile: "mcps/knowledge-skills/seo-consultant.server.ts", type: "knowledge-skill", registered: false, description: "SEO consulting" },
+    { serverName: "storyteller", sourceFile: "mcps/knowledge-skills/storyteller.server.ts", type: "knowledge-skill", registered: false, description: "Reflections, sagas, and technical narratives" },
     { serverName: "session-management", sourceFile: "mcps/knowledge-skills/session-management.server.ts", type: "knowledge-skill", registered: true, description: "Session management" },
     { serverName: "skill-invocation", sourceFile: "mcps/knowledge-skills/skill-invocation.server.ts", type: "knowledge-skill", registered: true, description: "Skill invocation" },
     { serverName: "strategist", sourceFile: "mcps/knowledge-skills/strategist.server.ts", type: "knowledge-skill", registered: false, description: "Strategic planning" },

package/dist/mcps/knowledge-skills/skill-invocation.server.js

@@ -87,7 +87,7 @@ class SkillInvocationServer extends XrayKnowledgeSkillBase {
             "strategist", "skill-invocation",
         ];
         const knowledgeSkills = [
-            "architecture-patterns", "strategist", "tech-writer",
+            "architecture-patterns", "strategist", "tech-writer", "storyteller",
             "seo-consultant", "content-creator", "growth-strategist",
             "bug-triage-specialist", "log-monitor",
             "mobile-development", "git-workflow", "session-management",
@@ -132,6 +132,7 @@ class SkillInvocationServer extends XrayKnowledgeSkillBase {
             "tech-writer": "documentation-generation",
             "frontend-ui-ux-engineer": "ui-ux-design",
             "frontend-engineer": "project-analysis",
+            "storyteller": "storyteller",
         };
         const resolvedSkill = skillAliases[skillName] || skillName;
         const availableServers = [
@@ -147,7 +148,7 @@ class SkillInvocationServer extends XrayKnowledgeSkillBase {
             "git-workflow", "content-creator", "ui-ux-design",
             "multimodal-looker", "refactoring-strategies",
             "project-analysis", "testing-best-practices",
-            "architecture-patterns",
+            "architecture-patterns", "storyteller",
         ];
         if (!availableServers.includes(resolvedSkill)) {
             return {

package/dist/mcps/knowledge-skills/storyteller.server.js

@@ -0,0 +1,167 @@
+/**
+ * Storyteller MCP Server
+ *
+ * Returns storyteller SKILL.md guidance plus a session-aware writing prompt.
+ * The host LLM writes the story; this server supplies the contract.
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { XrayKnowledgeSkillBase } from '../shared/knowledge-skill-base.js';
+const STORY_TYPES = ['reflection', 'saga', 'journey', 'narrative'];
+function resolveSkillMd() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, '../../../skills/storyteller/SKILL.md'),
+        join(here, '../../skills/storyteller/SKILL.md'),
+        join(process.cwd(), 'node_modules/0xray/dist/skills/storyteller/SKILL.md'),
+        join(process.cwd(), 'node_modules/xray/dist/skills/storyteller/SKILL.md'),
+    ];
+    for (const path of candidates) {
+        if (existsSync(path)) {
+            return readFileSync(path, 'utf-8');
+        }
+    }
+    return '# Storyteller\n\nWrite warmly candid technical reflections with scene-first openings.';
+}
+function getStoryMeta(storyType) {
+    const defaults = {
+        reflection: {
+            location: 'docs/reflections/',
+            min_words: 2000,
+            ideal_words: 5000,
+            framework: 'three_act_structure',
+        },
+        saga: {
+            location: 'docs/reflections/deep/',
+            min_words: 5000,
+            ideal_words: 15000,
+            framework: 'hero_journey',
+        },
+        journey: {
+            location: 'docs/reflections/deep/',
+            min_words: 1500,
+            ideal_words: 4000,
+            framework: 'three_act_structure',
+        },
+        narrative: {
+            location: 'docs/reflections/',
+            min_words: 1000,
+            ideal_words: 3000,
+            framework: 'three_act_structure',
+        },
+    };
+    return defaults[storyType];
+}
+function gitContext() {
+    try {
+        const commits = execSync('git log --oneline -20 2>/dev/null', { encoding: 'utf-8' });
+        const files = execSync('git diff --name-only HEAD~10 2>/dev/null || git ls-files 2>/dev/null | head -50', { encoding: 'utf-8' });
+        return `Recent commits:\n${commits}\n\nRecent files:\n${files}`;
+    }
+    catch {
+        return 'No git context available in this workspace.';
+    }
+}
+function buildPrompt(storyType, title, meta, extraContext) {
+    const contextBlock = extraContext
+        ? `\n## Provided context\n${JSON.stringify(extraContext, null, 2)}\n`
+        : '';
+    return `Write a ${storyType} titled "${title}".
+
+## Requirements
+- Framework: ${meta.framework}
+- Target length: ${meta.ideal_words} words (minimum: ${meta.min_words})
+- Save to: ${meta.location}
+- Follow storyteller SKILL.md voice (warmly candid, scene-first, no executive summary)
+- Include Key Takeaways and What Next sections
+
+## Session / repo context
+${gitContext()}
+${contextBlock}
+
+Write the complete ${storyType} now.`;
+}
+function writeStoryTool(storyType, args) {
+    const meta = getStoryMeta(storyType);
+    if (args.framework)
+        meta.framework = args.framework;
+    const title = args.title ??
+        `${storyType.charAt(0).toUpperCase() + storyType.slice(1)} - ${new Date().toISOString().split('T')[0]}`;
+    const skillMd = resolveSkillMd();
+    const prompt = buildPrompt(storyType, title, meta, args.context);
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+    const filename = `${storyType}-${slug}-${new Date().toISOString().split('T')[0]}.md`;
+    const outputPath = args.output ?? join(meta.location, filename);
+    const outputDir = join(process.cwd(), dirname(outputPath));
+    if (!existsSync(outputDir))
+        mkdirSync(outputDir, { recursive: true });
+    const fullPath = join(process.cwd(), outputPath);
+    const frontmatter = `---
+story_type: ${storyType}
+title: "${title}"
+framework: ${meta.framework}
+target_words: ${meta.ideal_words}
+---
+
+`;
+    writeFileSync(fullPath, `${frontmatter}\n${prompt}\n`, 'utf-8');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: [
+                    `Storyteller ${storyType} brief prepared.`,
+                    `Output template: ${outputPath}`,
+                    '',
+                    '--- SKILL (excerpt) ---',
+                    skillMd.slice(0, 4000),
+                    skillMd.length > 4000 ? '\n...(truncated; full SKILL.md on disk)' : '',
+                    '',
+                    '--- WRITING PROMPT ---',
+                    prompt,
+                    '',
+                    'Host LLM: write the full story into the output path using the prompt above.',
+                ].join('\n'),
+            },
+        ],
+    };
+}
+class StorytellerServer extends XrayKnowledgeSkillBase {
+    constructor() {
+        super('storyteller', '1.0.0');
+        const writeSchema = {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Story title' },
+                context: { type: 'object', description: 'Session context (commits, changes, notes)' },
+                framework: { type: 'string', description: 'Storytelling framework override' },
+                output: { type: 'string', description: 'Relative output path' },
+            },
+        };
+        this.tools = STORY_TYPES.map((storyType) => ({
+            name: `write_${storyType}`,
+            description: `Prepare ${storyType} story brief using storyteller SKILL.md`,
+            inputSchema: writeSchema,
+        }));
+        this.handlers = {
+            write_reflection: async (args) => writeStoryTool('reflection', args),
+            write_saga: async (args) => writeStoryTool('saga', args),
+            write_journey: async (args) => writeStoryTool('journey', args),
+            write_narrative: async (args) => writeStoryTool('narrative', args),
+        };
+        this.setupToolHandlers();
+    }
+}
+if (import.meta.url === `file://${fileURLToPath(import.meta.url)}`) {
+    const server = new StorytellerServer();
+    server.run().catch((error) => {
+        process.stderr.write(`FATAL: ${String(error)}\n`);
+        process.exit(1);
+    });
+}
+export { StorytellerServer };

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
@@ -149,8 +159,15 @@ 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 complexity = this.calculateTaskComplexity(task);
+            const requiredCaps = [
+                task.type,
+                ...(task.metadata?.memorySignals ?? []),
+            ];
+            const operationDescription = task.metadata?.memoryHighConfidenceTrap
+                ? `${task.description} TYPE: ontological-trap`
+                : task.description;
+            const agent = this.capabilitiesManager.selectAgentForTask(requiredCaps, complexity, operationDescription) || 'orchestrator';
             if (!agentAssignments.has(agent)) {
                 agentAssignments.set(agent, []);
             }
@@ -188,7 +205,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, []);
             }
@@ -246,6 +267,15 @@ export class ExecutionPlanner {
         if (task.dependencies) {
             complexity += task.dependencies.length * 5;
         }
+        if (task.metadata?.memoryComplexityBoost !== undefined) {
+            complexity += task.metadata.memoryComplexityBoost;
+        }
+        else {
+            const provider = getProvider();
+            if (provider.id !== 'null' && provider.getTaskConfidence) {
+                complexity += provider.getTaskConfidence(toMemoryTask(task)).complexityBoost;
+            }
+        }
         return Math.min(Math.max(Math.round(complexity), 1), 100);
     }
     /**

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

@@ -6,7 +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 } from '../aside-context.js';
+import { addObservations, extractOrchestrationObservations, spawnAside } from '../aside-context.js';
+import { getProvider } from '../config/memory-routing-bridge.js';
 /**
  * Task Handler
  * Processes orchestrate-task requests
@@ -38,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;
@@ -82,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',
@@ -96,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, {
@@ -106,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,
@@ -120,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 = [];
@@ -141,6 +193,7 @@ export class TaskHandler {
             bottlenecks,
             recommendations,
             agentOutputs,
+            taskOutcomes,
         };
     }
     mapAgentToTool(agent) {