feat: enable task routing and add comprehensive analytics logging

- Enable task routing in plugin (was commented out)
- Add TaskSkillRouter variable declarations
- Implement loadTaskSkillRouter() to dynamically load router
- Add RouterCore logging for all routing decisions (keyword, history, complexity, fallback)
- Add AgentDelegator logging for agent selection with complexity details
- Outcome tracking persists to disk (logs/framework/routing-outcomes.json)

Now analytics will capture:
- Task routing decisions with agent/skill/confidence
- Complexity scores for each task
- Agent selection rationale
- Historical outcomes for pattern analysis

Author: htafolla

src/delegation/agent-delegator.ts

@@ -636,9 +636,26 @@ export class AgentDelegator {
       });
     }
 
-    return agents.length > 0
+    const finalAgents = agents.length > 0
       ? agents
       : [{ name: "enforcer", confidence: 0.75, role: "validation" }];
+    
+    // Log complete agent selection for analytics
+    frameworkLogger.log(
+      "agent-delegator",
+      "agents-selected",
+      "info",
+      {
+        operation,
+        strategy: complexityScore.recommendedStrategy,
+        complexityLevel: complexityScore.level,
+        complexityScore: complexityScore.score,
+        agents: finalAgents.map(a => ({ name: a.name, role: a.role, confidence: a.confidence })),
+        agentCount: finalAgents.length,
+      }
+    );
+    
+    return finalAgents;
   }
 
   private mapOperationToType(

src/delegation/routing/router-core.ts

@@ -86,6 +86,11 @@ export class RouterCore {
 
     // Validate input
     if (!taskDescription || typeof taskDescription !== 'string') {
+      frameworkLogger.log('router-core', 'routing-fallback', 'info', {
+        reason: 'Invalid task description',
+        agent: DEFAULT_ROUTING.agent,
+        skill: DEFAULT_ROUTING.skill,
+      }, sessionId);
       return {
         ...DEFAULT_ROUTING,
         reason: 'Invalid task description',
@@ -95,6 +100,12 @@ export class RouterCore {
     // 0. SPECIAL CASE: Release/Publish detection
     const releaseDetection = this.keywordMatcher.detectReleaseWorkflow(taskDescription);
     if (releaseDetection.isRelease) {
+      frameworkLogger.log('router-core', 'release-workflow-detected', 'info', {
+        taskDescription: taskDescription.slice(0, 100),
+        agent: RELEASE_WORKFLOW_ROUTING.agent,
+        skill: RELEASE_WORKFLOW_ROUTING.skill,
+        confidence: RELEASE_WORKFLOW_ROUTING.confidence,
+      }, sessionId);
       return this.createReleaseRouting(taskDescription, releaseDetection, sessionId);
     }
 
@@ -103,6 +114,13 @@ export class RouterCore {
     // 1. Try keyword matching first (highest priority)
     const keywordResult = this.performKeywordMatching(descLower);
     if (keywordResult) {
+      frameworkLogger.log('router-core', 'keyword-match', 'info', {
+        taskDescription: taskDescription.slice(0, 100),
+        agent: keywordResult.agent,
+        skill: keywordResult.skill,
+        confidence: keywordResult.confidence,
+        matchedKeyword: keywordResult.matchedKeyword,
+      }, sessionId);
       return this.applyKernelInsights(keywordResult, taskDescription);
     }
 
@@ -111,6 +129,12 @@ export class RouterCore {
       const historyResult = this.historyMatcher.match(taskId);
       if (historyResult) {
         this.logHistoryMatch(taskId, historyResult, sessionId);
+        frameworkLogger.log('router-core', 'history-match', 'info', {
+          taskId,
+          agent: historyResult.agent,
+          skill: historyResult.skill,
+          confidence: historyResult.confidence,
+        }, sessionId);
         return historyResult;
       }
     }
@@ -119,11 +143,24 @@ export class RouterCore {
     if (complexity !== undefined) {
       const complexityResult = this.complexityRouter.route(complexity, options);
       if (complexityResult) {
+        frameworkLogger.log('router-core', 'complexity-match', 'info', {
+          taskDescription: taskDescription.slice(0, 100),
+          complexity,
+          agent: complexityResult.agent,
+          skill: complexityResult.skill,
+          confidence: complexityResult.confidence,
+        }, sessionId);
         return complexityResult;
       }
     }
 
     // 4. Default fallback
+    frameworkLogger.log('router-core', 'routing-fallback', 'info', {
+      taskDescription: taskDescription.slice(0, 100),
+      reason: 'No keyword match, no history, no complexity provided',
+      agent: DEFAULT_ROUTING.agent,
+      skill: DEFAULT_ROUTING.skill,
+    }, sessionId);
     return {
       ...DEFAULT_ROUTING,
       reason: 'No keyword match, no history, no complexity provided',

src/plugin/strray-codex-injection.ts

@@ -31,9 +31,8 @@ let ProcessorManager: any;
 let StrRayStateManager: any;
 let featuresConfigLoader: any;
 let detectTaskType: any;
-// TODO: Enable TaskSkillRouter after v1.11.0
-// let TaskSkillRouter: any;
-// let taskSkillSkillRouterInstance: any;
+let TaskSkillRouter: any;
+let taskSkillRouterInstance: any;
 
 async function loadStrRayComponents() {
   if (ProcessorManager && StrRayStateManager && featuresConfigLoader) {
@@ -102,8 +101,6 @@ async function loadStrRayComponents() {
 /**
  * Extract task description from tool input
  */
-// TODO: Enable after v1.11.0
-/*
 function extractTaskDescription(input: { tool: string; args?: Record<string, unknown> }): string | null {
   const { tool, args } = input;
 
@@ -124,11 +121,31 @@ function extractTaskDescription(input: { tool: string; args?: Record<string, unk
 
   return null;
 }
-*/
 
 async function loadTaskSkillRouter(): Promise<void> {
-  // Task routing will be available after framework is built and installed
-  // For now, tasks are routed based on explicit @agent syntax
+  if (taskSkillRouterInstance) {
+    return; // Already loaded
+  }
+
+  // Try local dist first (for development)
+  try {
+    const module = await import(
+      "../../dist/delegation/task-skill-router.js" as any
+    );
+    TaskSkillRouter = module.TaskSkillRouter;
+    taskSkillRouterInstance = new TaskSkillRouter();
+  } catch (distError) {
+    // Try node_modules (for consumer installs)
+    try {
+      const module = await import(
+        "strray-ai/dist/delegation/task-skill-router.js" as any
+      );
+      TaskSkillRouter = module.TaskSkillRouter;
+      taskSkillRouterInstance = new TaskSkillRouter();
+    } catch (nmError) {
+      // Task routing not available - continue without it
+    }
+  }
 }
 
 function spawnPromise(
@@ -567,46 +584,39 @@ export default async function strrayCodexPlugin(input: {
 
       // ============================================================
       // TASK ROUTING: Analyze task and route to best agent
-      // TODO: Enable after v1.11.0 - requires built framework
+      // Enabled in v1.10.5 - provides analytics data
       // ============================================================
-      /*
       const taskDescription = extractTaskDescription(input);
 
       if (taskDescription && featuresConfigLoader) {
         try {
           await loadTaskSkillRouter();
 
           if (taskSkillRouterInstance) {
-            const config = featuresConfigLoader.loadConfig();
+            const routingResult = taskSkillRouterInstance.routeTask(taskDescription, {
+              toolName: tool,
+            });
 
-            // Check if task routing is enabled (model_routing.enabled flag)
-            if (config.model_routing?.enabled) {
-              const routingResult = taskSkillRouterInstance.routeTask(taskDescription, {
-                toolName: tool,
-              });
+            if (routingResult && routingResult.agent) {
+              logger.log(
+                `🎯 Task routed: "${taskDescription.slice(0, 50)}..." → ${routingResult.agent} (confidence: ${routingResult.confidence})`,
+              );
+              
+              // Store routing result for downstream processing
+              output._strrayRouting = routingResult;
 
-              if (routingResult && routingResult.agent) {
+              // If complexity is high, log a warning
+              if (routingResult.context?.complexity > 50) {
                 logger.log(
-                  `🎯 Task routed: "${taskDescription.slice(0, 50)}..." → ${routingResult.agent} (confidence: ${routingResult.confidence})`,
+                  `⚠️ High complexity task detected (${routingResult.context.complexity}) - consider multi-agent orchestration`,
                 );
-                
-                // Store routing result for downstream processing
-                output._strrayRouting = routingResult;
-                
-                // If complexity is high, log a warning
-                if (routingResult.context?.complexity > 50) {
-                  logger.log(
-                    `⚠️ High complexity task detected (${routingResult.context.complexity}) - consider multi-agent orchestration`,
-                  );
-                }
               }
             }
           }
         } catch (e) {
           logger.error("Task routing error:", e);
         }
       }
-      */
 
       // ENFORCER QUALITY GATE CHECK - Block on violations
       const qualityGateResult = await runEnforcerQualityGate(input, logger);