0xray 4.0.36 → 4.0.38

package/.grok-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "4.0.36",
+  "version": "4.0.38",
   "description": "0xRay suit for Grok, Hermes, OpenClaw, OpenCode: mill+inspect, Codex, 7 MCP servers. Costume 45/42 is opt-in foundry, not the default wear.",
   "author": {
     "name": "0xRay AI",

package/.xray/features.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./features.schema.json",
-  "version": "4.0.36",
+  "version": "4.0.38",
   "description": "0xRay Framework - Unified Feature Configuration",
   "suit_temperament": {
     "profile": "auto",

package/dist/CHANGELOG.md

@@ -42,6 +42,34 @@ The format is based on [Conventional Commits](https://www.conventionalcommits.or
 - Archive root `integrations/` costume SKILL dump → `docs/archive/integrations-costume/`. Live wear is `src/integrations`.
 - Archive root `commands/` stale copy → `docs/archive/commands-copy/`. Live wear is `src/opencode/commands`.
 
+## [4.0.38] - 2026-10-03
+
+### 🔄 Changes
+
+### 🔎 Other Changes
+- Merge pull request #171 from 0xRayAI/fix/solar-verdict-decides (7b6ac081a)
+- Merge remote-tracking branch 'origin/main' into fix/solar-verdict-decides (a342e0b0d)
+- fix(types): declare work-freshness so the Codex 70 import typechecks (16b2db194)
+- feat(codex): term 70 requires current source and worn npm (dacecc916)
+- fix(governance): honor Dynamo's recommendation (968cd6a14)
+
+---
+
+## [4.0.37] - 2026-10-02
+
+### 🔄 Changes
+
+### 🐛 Bug Fixes
+- fix: a naked checkout wakes with repertoire on (7b75bedbc)
+
+### ⚡ Performance
+- perf: cut repeated work on the processor data path (baadb4d35)
+
+### 📚 Documentation
+- docs: move fleet house SSOT out of the kit (7dcf08e94)
+
+---
+
 ## [4.0.36] - 2026-10-02
 
 ### 🔄 Changes

package/dist/analytics/emerging-pattern-detector.d.ts

@@ -32,6 +32,10 @@ export declare class EmergingPatternDetector {
      * Extract meaningful keywords from task description
      */
     private extractKeywords;
+    /**
+     * Jaccard |A ∩ B| / |A ∪ B| without copying either set.
+     */
+    private jaccard;
     /**
      * Calculate Jaccard similarity between two keyword sets
      */
@@ -43,7 +47,14 @@ export declare class EmergingPatternDetector {
     /**
      * Detect emergent patterns from recent routing outcomes
      */
-    detectEmergingPatterns(outcomes: RoutingOutcome[]): PatternDiscoveryResult;
+    detectEmergingPatterns(outcomes: ReadonlyArray<{
+        taskId: string;
+        taskDescription?: string;
+        routedAgent: string;
+        routedSkill: string;
+        success?: boolean;
+        confidence: number;
+    }>): PatternDiscoveryResult;
     /**
      * Check if a specific pattern is emerging
      */

package/dist/analytics/emerging-pattern-detector.js

@@ -26,21 +26,32 @@ export class EmergingPatternDetector {
         const words = text.toLowerCase()
             .replace(/[^\w\s]/g, ' ')
             .split(/\s+/)
-            .filter(word => word.length > 2)
-            .filter(word => !this.stopWords.has(word));
+            .filter(word => word.length > 2 && !this.stopWords.has(word));
         return [...new Set(words)];
     }
+    /**
+     * Jaccard |A ∩ B| / |A ∪ B| without copying either set.
+     */
+    jaccard(left, right) {
+        if (left.size === 0 || right.size === 0)
+            return 0;
+        let intersection = 0;
+        const small = left.size <= right.size ? left : right;
+        const large = small === left ? right : left;
+        for (const word of small) {
+            if (large.has(word))
+                intersection++;
+        }
+        const union = left.size + right.size - intersection;
+        return union === 0 ? 0 : intersection / union;
+    }
     /**
      * Calculate Jaccard similarity between two keyword sets
      */
     calculateSimilarity(keywords1, keywords2) {
         if (keywords1.length === 0 || keywords2.length === 0)
             return 0;
-        const set1 = new Set(keywords1);
-        const set2 = new Set(keywords2);
-        const intersection = new Set([...set1].filter(x => set2.has(x)));
-        const union = new Set([...set1, ...set2]);
-        return intersection.size / union.size;
+        return this.jaccard(new Set(keywords1), new Set(keywords2));
     }
     /**
      * Cluster similar task descriptions
@@ -48,6 +59,10 @@ export class EmergingPatternDetector {
     clusterTasks(tasks) {
         const clusters = [];
         const assigned = new Set();
+        const keywordSets = new Map();
+        for (const task of tasks) {
+            keywordSets.set(task, new Set(task.keywords));
+        }
         // Sort by frequency (most frequent first)
         const sortedTasks = [...tasks].sort((a, b) => b.keywords.length - a.keywords.length);
         for (const task of sortedTasks) {
@@ -62,7 +77,7 @@ export class EmergingPatternDetector {
             for (const otherTask of sortedTasks) {
                 if (assigned.has(otherTask.id) || otherTask.id === task.id)
                     continue;
-                const similarity = this.calculateSimilarity([...clusterKeywords], otherTask.keywords);
+                const similarity = this.jaccard(clusterKeywords, keywordSets.get(otherTask) ?? new Set(otherTask.keywords));
                 if (similarity >= this.clusterSimilarityThreshold) {
                     otherTask.keywords.forEach(kw => clusterKeywords.add(kw));
                     clusterDescriptions.push(otherTask.description);
@@ -124,12 +139,22 @@ export class EmergingPatternDetector {
                 continue;
             if (cluster.confidence < this.minConfidenceThreshold)
                 continue;
-            // Get success metrics for this cluster
-            const clusterOutcomes = taskData.filter(t => cluster.patterns.includes(t.description));
-            const successCount = clusterOutcomes.filter(t => t.success).length;
+            // Same membership as description includes, in taskData order.
+            const patternDescriptions = new Set(cluster.patterns);
+            const clusterOutcomes = [];
+            let successCount = 0;
+            let confidenceSum = 0;
+            for (const task of taskData) {
+                if (!patternDescriptions.has(task.description))
+                    continue;
+                clusterOutcomes.push(task);
+                if (task.success)
+                    successCount++;
+                confidenceSum += task.confidence;
+            }
             const successRate = clusterOutcomes.length > 0 ? successCount / clusterOutcomes.length : 0;
             const avgConfidence = clusterOutcomes.length > 0
-                ? clusterOutcomes.reduce((sum, t) => sum + t.confidence, 0) / clusterOutcomes.length
+                ? confidenceSum / clusterOutcomes.length
                 : 0;
             // Determine suggested agent/skill based on most common
             const agentCounts = new Map();

package/dist/analytics/pattern-learning-engine.js

@@ -78,15 +78,7 @@ export class PatternLearningEngine {
         }
         // Detect emerging patterns for new additions
         if (this.config.enableAutoAddition) {
-            const emergentResult = emergingPatternDetector.detectEmergingPatterns(outcomes.map(o => ({
-                taskId: o.taskId,
-                taskDescription: o.taskDescription,
-                routedAgent: o.routedAgent,
-                routedSkill: o.routedSkill,
-                confidence: o.confidence,
-                timestamp: new Date(),
-                success: o.success
-            })));
+            const emergentResult = emergingPatternDetector.detectEmergingPatterns(outcomes);
             result.newPatterns = this.generateNewPatterns(emergentResult.emergentPatterns, existingMappings);
         }
         // Generate recommendations

package/dist/analytics/predictive-analytics.js

@@ -16,11 +16,16 @@ function keywordOverlapScore(description, historicalDescriptions) {
         return 0;
     let totalScore = 0;
     let matchCount = 0;
+    const histWords = new Set();
     for (const hist of historicalDescriptions) {
-        const histWords = new Set(hist.toLowerCase().split(/\W+/).filter(w => w.length > 2));
+        histWords.clear();
+        for (const word of hist.toLowerCase().split(/\W+/)) {
+            if (word.length > 2)
+                histWords.add(word);
+        }
         let overlap = 0;
-        for (const w of descWords) {
-            if (histWords.has(w))
+        for (const word of descWords) {
+            if (histWords.has(word))
                 overlap++;
         }
         if (overlap > 0) {
@@ -64,42 +69,50 @@ function estimateTaskDuration(agentOutcomes) {
  */
 function buildAgentMetrics(agentOutcomes) {
     const totalTasks = agentOutcomes.length;
-    const successfulTasks = agentOutcomes.filter(o => o.success).length;
-    const failedTasks = totalTasks - successfulTasks;
-    // Calculate average execution time
-    const durations = agentOutcomes
-        .filter(o => o.executionTimeMs !== undefined)
-        .map(o => o.executionTimeMs);
-    const averageExecutionTime = durations.length > 0
-        ? durations.reduce((a, b) => a + b, 0) / durations.length
-        : 0;
-    // Recent performance (last 20 tasks)
-    const recentPerformance = agentOutcomes
-        .slice(-20)
-        .map(o => o.success ? 1 : 0);
-    // Task type breakdown
-    const taskTypeBreakdown = {};
-    for (const outcome of agentOutcomes) {
+    let successfulTasks = 0;
+    let durationSum = 0;
+    let durationCount = 0;
+    const recentStart = Math.max(0, totalTasks - 20);
+    const recentPerformance = [];
+    const taskCounts = new Map();
+    for (let i = 0; i < agentOutcomes.length; i++) {
+        const outcome = agentOutcomes[i];
+        if (!outcome)
+            continue;
+        if (outcome.success)
+            successfulTasks++;
+        if (outcome.executionTimeMs !== undefined) {
+            durationSum += outcome.executionTimeMs;
+            durationCount++;
+        }
         const taskType = outcome.taskType || "unknown";
-        if (!taskTypeBreakdown[taskType]) {
-            taskTypeBreakdown[taskType] = { count: 0, successRate: 0 };
+        const bucket = taskCounts.get(taskType);
+        if (bucket) {
+            bucket.count++;
+            if (outcome.success)
+                bucket.successes++;
         }
-        taskTypeBreakdown[taskType].count++;
-    }
-    // Calculate per-task-type success rates
-    for (const taskType of Object.keys(taskTypeBreakdown)) {
-        const taskOutcomes = agentOutcomes.filter(o => (o.taskType || "unknown") === taskType);
-        const successes = taskOutcomes.filter(o => o.success).length;
-        const entry = taskTypeBreakdown[taskType];
-        if (entry) {
-            entry.successRate = successes / taskOutcomes.length;
+        else {
+            taskCounts.set(taskType, {
+                count: 1,
+                successes: outcome.success ? 1 : 0,
+            });
         }
+        if (i >= recentStart)
+            recentPerformance.push(outcome.success ? 1 : 0);
+    }
+    const taskTypeBreakdown = {};
+    for (const [taskType, bucket] of taskCounts) {
+        taskTypeBreakdown[taskType] = {
+            count: bucket.count,
+            successRate: bucket.count > 0 ? bucket.successes / bucket.count : 0,
+        };
     }
     return {
         totalTasks,
         successfulTasks,
-        failedTasks,
-        averageExecutionTime,
+        failedTasks: totalTasks - successfulTasks,
+        averageExecutionTime: durationCount > 0 ? durationSum / durationCount : 0,
         successRate: totalTasks > 0 ? successfulTasks / totalTasks : 0,
         recentPerformance,
         taskTypeBreakdown,
@@ -200,6 +213,11 @@ export const predictiveAnalytics = {
         const outcomes = routingOutcomeTracker.getOutcomes();
         if (stats.length === 0 || outcomes.length === 0)
             return null;
+        const statByAgent = new Map();
+        for (const stat of stats) {
+            if (!statByAgent.has(stat.agent))
+                statByAgent.set(stat.agent, stat);
+        }
         // Group outcomes by agent
         const byAgent = new Map();
         for (const o of outcomes) {
@@ -215,7 +233,7 @@ export const predictiveAnalytics = {
         for (const [agent, agentOutcomes] of byAgent) {
             const descriptions = agentOutcomes.map(o => o.taskDescription);
             const overlap = keywordOverlapScore(taskDescription, descriptions);
-            const agentStat = stats.find(s => s.agent === agent);
+            const agentStat = statByAgent.get(agent);
             const successRate = agentStat?.successRate ?? 0;
             const total = agentStat?.total ?? 0;
             // Weighted score: 70% keyword overlap + 30% historical success rate

package/dist/analytics/prompt-pattern-analyzer.d.ts

@@ -66,6 +66,7 @@ declare class PromptPatternAnalyzer {
     /**
      * Detect gaps where templates don't match user requests
      */
+    private indexOutcomes;
     private detectTemplateGaps;
     /**
      * Identify emerging patterns from real usage

package/dist/analytics/prompt-pattern-analyzer.js

@@ -20,17 +20,22 @@ class PromptPatternAnalyzer {
         if (promptData.length === 0) {
             return this.emptyComparisonResult();
         }
-        const templateMatches = promptData.filter((p) => p.templatePrompt && p.templatePrompt.length > 0);
-        const nonTemplatePrompts = promptData.filter((p) => !p.templatePrompt || p.templatePrompt.length === 0);
-        const gaps = this.detectTemplateGaps(promptData, outcomes);
-        const emergingPatterns = this.identifyEmergingPatterns(promptData, outcomes);
-        const topMissedKeywords = this.analyzeMissedKeywords(promptData);
+        let templateMatchCount = 0;
+        for (const prompt of promptData) {
+            if (prompt.templatePrompt && prompt.templatePrompt.length > 0)
+                templateMatchCount++;
+        }
+        const keywordsByPrompt = promptData.map((prompt) => this.extractKeywords(prompt.userRequest || ""));
+        const outcomeByTask = this.indexOutcomes(outcomes);
+        const gaps = this.detectTemplateGaps(promptData, outcomeByTask);
+        const emergingPatterns = this.identifyEmergingPatterns(promptData, keywordsByPrompt, outcomeByTask);
+        const topMissedKeywords = this.analyzeMissedKeywords(promptData, keywordsByPrompt);
         const agentCoverage = this.calculateAgentCoverage(promptData);
         return {
             totalPrompts: promptData.length,
-            templateMatches: templateMatches.length,
-            nonTemplatePrompts: nonTemplatePrompts.length,
-            templateMatchRate: promptData.length > 0 ? templateMatches.length / promptData.length : 0,
+            templateMatches: templateMatchCount,
+            nonTemplatePrompts: promptData.length - templateMatchCount,
+            templateMatchRate: promptData.length > 0 ? templateMatchCount / promptData.length : 0,
             gaps,
             emergingPatterns,
             topMissedKeywords,
@@ -40,7 +45,15 @@ class PromptPatternAnalyzer {
     /**
      * Detect gaps where templates don't match user requests
      */
-    detectTemplateGaps(promptData, outcomes) {
+    indexOutcomes(outcomes) {
+        const indexed = new Map();
+        for (const outcome of outcomes) {
+            if (!indexed.has(outcome.taskId))
+                indexed.set(outcome.taskId, outcome);
+        }
+        return indexed;
+    }
+    detectTemplateGaps(promptData, outcomeByTask) {
         const gaps = [];
         const gapMap = new Map();
         for (const prompt of promptData) {
@@ -54,7 +67,7 @@ class PromptPatternAnalyzer {
                     }
                 }
                 else {
-                    const outcome = outcomes.find((o) => o.taskId === prompt.taskId);
+                    const outcome = outcomeByTask.get(prompt.taskId);
                     gaps.push({
                         gapType: this.classifyGapType(prompt, outcome),
                         userRequest: prompt.userRequest || '',
@@ -79,11 +92,10 @@ class PromptPatternAnalyzer {
     /**
      * Identify emerging patterns from real usage
      */
-    identifyEmergingPatterns(promptData, outcomes) {
+    identifyEmergingPatterns(promptData, keywordsByPrompt, outcomeByTask) {
         const patternMap = new Map();
         const keywordFrequency = new Map();
-        for (const prompt of promptData) {
-            const keywords = this.extractKeywords(prompt.userRequest || '');
+        for (const keywords of keywordsByPrompt) {
             for (const keyword of keywords) {
                 keywordFrequency.set(keyword, (keywordFrequency.get(keyword) || 0) + 1);
             }
@@ -92,13 +104,17 @@ class PromptPatternAnalyzer {
             .filter(([, count]) => count >= this.minFrequencyThreshold)
             .sort((a, b) => b[1] - a[1])
             .slice(0, 50);
-        for (const prompt of promptData) {
-            const keywords = this.extractKeywords(prompt.userRequest || '');
-            const significantKeywordsInPrompt = keywords.filter((kw) => significantKeywords.some(([sigKw]) => kw === sigKw));
+        const significantSet = new Set(significantKeywords.map(([keyword]) => keyword));
+        for (let i = 0; i < promptData.length; i++) {
+            const prompt = promptData[i];
+            const keywords = keywordsByPrompt[i];
+            if (!prompt || !keywords)
+                continue;
+            const significantKeywordsInPrompt = keywords.filter((kw) => significantSet.has(kw));
             if (significantKeywordsInPrompt.length === 0)
                 continue;
             const patternKey = significantKeywordsInPrompt.sort().join("|");
-            const outcome = outcomes.find((o) => o.taskId === prompt.taskId);
+            const outcome = outcomeByTask.get(prompt.taskId);
             if (!outcome)
                 continue;
             if (patternMap.has(patternKey)) {
@@ -139,12 +155,15 @@ class PromptPatternAnalyzer {
     /**
      * Analyze frequently missed keywords
      */
-    analyzeMissedKeywords(promptData) {
+    analyzeMissedKeywords(promptData, keywordsByPrompt) {
         const missedKeywords = new Map();
         const keywordToAgent = new Map();
-        for (const prompt of promptData) {
+        for (let i = 0; i < promptData.length; i++) {
+            const prompt = promptData[i];
+            const keywords = keywordsByPrompt[i];
+            if (!prompt || !keywords)
+                continue;
             if (!prompt.templatePrompt || prompt.templatePrompt.length === 0) {
-                const keywords = this.extractKeywords(prompt.userRequest || '');
                 for (const keyword of keywords) {
                     if (keyword.length > 3) {
                         missedKeywords.set(keyword, (missedKeywords.get(keyword) || 0) + 1);

package/dist/analytics/routing-performance-analyzer.d.ts

@@ -62,6 +62,8 @@ declare class RoutingPerformanceAnalyzer {
     private readonly lowConfidenceThreshold;
     private readonly mediumConfidenceThreshold;
     private readonly minSamplesForMetrics;
+    /** First row for each taskId, matching Array.find. */
+    private firstByTaskId;
     /**
      * Generate comprehensive routing performance report
      */

package/dist/analytics/routing-performance-analyzer.js

@@ -11,6 +11,15 @@ class RoutingPerformanceAnalyzer {
     lowConfidenceThreshold = 0.6;
     mediumConfidenceThreshold = 0.8;
     minSamplesForMetrics = 5;
+    /** First row for each taskId, matching Array.find. */
+    firstByTaskId(rows) {
+        const indexed = new Map();
+        for (const row of rows) {
+            if (!indexed.has(row.taskId))
+                indexed.set(row.taskId, row);
+        }
+        return indexed;
+    }
     /**
      * Generate comprehensive routing performance report
      */
@@ -25,7 +34,7 @@ class RoutingPerformanceAnalyzer {
         }
         const agentMetrics = this.calculateAgentMetrics(outcomes, promptData);
         const keywordEffectiveness = this.analyzeKeywordEffectiveness(decisions, outcomes);
-        const confidenceMetrics = this.analyzeConfidenceThresholds(outcomes);
+        const confidenceMetrics = this.analyzeConfidenceThresholds(outcomes, promptData);
         const timeRange = this.calculateTimeRange(outcomes);
         const overallStats = this.calculateOverallStats(outcomes);
         const recommendations = this.generateRecommendations(agentMetrics, keywordEffectiveness, confidenceMetrics);
@@ -45,9 +54,10 @@ class RoutingPerformanceAnalyzer {
      */
     calculateAgentMetrics(outcomes, promptData) {
         const agentMap = new Map();
+        const promptByTask = this.firstByTaskId(promptData);
         for (const outcome of outcomes) {
             const agent = outcome.routedAgent;
-            const prompt = promptData.find((p) => p.taskId === outcome.taskId);
+            const prompt = promptByTask.get(outcome.taskId);
             const confidence = prompt?.confidence ?? 0;
             const executionTime = prompt?.usageMetadata?.retryCount ?? 0;
             if (!agentMap.has(agent)) {
@@ -58,7 +68,7 @@ class RoutingPerformanceAnalyzer {
                     failures: 0,
                     escalated: 0,
                     confidenceSum: 0,
-                    executionTimes: [],
+                    executionSum: 0,
                     highConfidence: 0,
                     mediumConfidence: 0,
                     lowConfidence: 0,
@@ -91,15 +101,12 @@ class RoutingPerformanceAnalyzer {
             if (confidence < 0.75) {
                 metrics.escalated++;
             }
-            metrics.executionTimes.push(executionTime);
+            metrics.executionSum += executionTime;
         }
         return Array.from(agentMap.entries())
             .filter(([, metrics]) => metrics.total >= this.minSamplesForMetrics)
             .map(([agent, metrics]) => {
-            const avgExecutionTime = metrics.executionTimes.length > 0
-                ? metrics.executionTimes.reduce((sum, time) => sum + time, 0) /
-                    metrics.executionTimes.length
-                : 0;
+            const avgExecutionTime = metrics.total > 0 ? metrics.executionSum / metrics.total : 0;
             const timestamps = metrics.timestamps.sort((a, b) => a.getTime() - b.getTime());
             return {
                 agent,
@@ -129,11 +136,12 @@ class RoutingPerformanceAnalyzer {
      */
     analyzeKeywordEffectiveness(decisions, outcomes) {
         const keywordMap = new Map();
+        const outcomeByTask = this.firstByTaskId(outcomes);
         for (const decision of decisions) {
             const keyword = decision.keywordMatched;
             if (!keyword)
                 continue;
-            const outcome = outcomes.find((o) => o.taskId === decision.taskId);
+            const outcome = outcomeByTask.get(decision.taskId);
             if (!outcome)
                 continue;
             if (!keywordMap.has(keyword)) {
@@ -175,30 +183,43 @@ class RoutingPerformanceAnalyzer {
     /**
      * Analyze confidence threshold performance
      */
-    analyzeConfidenceThresholds(outcomes) {
-        const promptData = routingOutcomeTracker.getPromptData();
+    analyzeConfidenceThresholds(outcomes, promptData) {
         const thresholds = [0.5, 0.6, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95];
-        return thresholds.map((threshold) => {
-            const belowThresholdOutcomes = outcomes.filter((outcome) => {
-                const prompt = promptData.find((p) => p.taskId === outcome.taskId);
-                const confidence = prompt?.confidence ?? 1;
-                return confidence < threshold;
-            });
-            const totalRoutings = belowThresholdOutcomes.length;
-            const successfulRoutings = belowThresholdOutcomes.filter((o) => o.success === true).length;
-            const successRate = totalRoutings > 0 ? successfulRoutings / totalRoutings : 0;
-            const escalatedCount = belowThresholdOutcomes.length;
+        const promptByTask = this.firstByTaskId(promptData);
+        const totalRoutings = thresholds.map(() => 0);
+        const successfulRoutings = thresholds.map(() => 0);
+        for (const outcome of outcomes) {
+            const prompt = promptByTask.get(outcome.taskId);
+            const confidence = prompt?.confidence ?? 1;
+            for (let i = 0; i < thresholds.length; i++) {
+                const threshold = thresholds[i];
+                if (threshold === undefined || !(confidence < threshold))
+                    continue;
+                const total = totalRoutings[i];
+                const successful = successfulRoutings[i];
+                if (total === undefined || successful === undefined)
+                    continue;
+                totalRoutings[i] = total + 1;
+                if (outcome.success === true)
+                    successfulRoutings[i] = successful + 1;
+            }
+        }
+        return thresholds.map((threshold, i) => {
+            const total = totalRoutings[i] ?? 0;
+            const successful = successfulRoutings[i] ?? 0;
+            const successRate = total > 0 ? successful / total : 0;
+            const escalatedCount = total;
             let recommendation = "Threshold is optimal";
-            if (successRate < 0.6 && escalatedCount > totalRoutings * 0.5) {
+            if (successRate < 0.6 && escalatedCount > total * 0.5) {
                 recommendation = "Consider lowering threshold to reduce escalations";
             }
-            else if (successRate > 0.9 && escalatedCount < totalRoutings * 0.2) {
+            else if (successRate > 0.9 && escalatedCount < total * 0.2) {
                 recommendation = "Consider raising threshold to improve routing precision";
             }
             return {
                 threshold,
-                totalRoutings,
-                successfulRoutings,
+                totalRoutings: total,
+                successfulRoutings: successful,
                 successRate,
                 escalatedCount,
                 recommendation,
@@ -209,10 +230,14 @@ class RoutingPerformanceAnalyzer {
      * Calculate overall routing statistics
      */
     calculateOverallStats(outcomes) {
-        const successful = outcomes.filter((o) => o.success === true).length;
+        let successful = 0;
+        let totalConfidence = 0;
+        for (const outcome of outcomes) {
+            if (outcome.success === true)
+                successful++;
+            totalConfidence += outcome.confidence || 0;
+        }
         const successRate = outcomes.length > 0 ? successful / outcomes.length : 0;
-        // Confidence is in outcomes, not promptData
-        const totalConfidence = outcomes.reduce((sum, o) => sum + (o.confidence || 0), 0);
         const avgConfidence = outcomes.length > 0 ? totalConfidence / outcomes.length : 0;
         return { successRate, avgConfidence };
     }
@@ -228,16 +253,43 @@ class RoutingPerformanceAnalyzer {
             const d = ts instanceof Date ? ts : new Date(ts);
             return d.getTime();
         };
-        const sorted = [...outcomes].sort((a, b) => getTime(a.timestamp) - getTime(b.timestamp));
-        const now = new Date();
-        const firstOutcome = sorted[0];
-        const lastOutcome = sorted[sorted.length - 1];
-        const firstTs = firstOutcome?.timestamp;
-        const lastTs = lastOutcome?.timestamp;
-        return {
-            start: firstTs instanceof Date ? firstTs : (firstTs ? new Date(firstTs) : now),
-            end: lastTs instanceof Date ? lastTs : (lastTs ? new Date(lastTs) : now),
+        const asRange = (firstTs, lastTs) => {
+            const now = new Date();
+            return {
+                start: firstTs instanceof Date ? firstTs : (firstTs ? new Date(firstTs) : now),
+                end: lastTs instanceof Date ? lastTs : (lastTs ? new Date(lastTs) : now),
+            };
         };
+        const firstOutcome = outcomes[0];
+        if (firstOutcome) {
+            let startTs = firstOutcome.timestamp;
+            let endTs = startTs;
+            let startTime = getTime(startTs);
+            let endTime = startTime;
+            let finite = !Number.isNaN(startTime);
+            for (let i = 1; finite && i < outcomes.length; i++) {
+                const outcome = outcomes[i];
+                if (!outcome)
+                    continue;
+                const time = getTime(outcome.timestamp);
+                if (Number.isNaN(time)) {
+                    finite = false;
+                    break;
+                }
+                if (time < startTime) {
+                    startTime = time;
+                    startTs = outcome.timestamp;
+                }
+                if (time >= endTime) {
+                    endTime = time;
+                    endTs = outcome.timestamp;
+                }
+            }
+            if (finite)
+                return asRange(startTs, endTs);
+        }
+        const sorted = [...outcomes].sort((a, b) => getTime(a.timestamp) - getTime(b.timestamp));
+        return asRange(sorted[0]?.timestamp, sorted[sorted.length - 1]?.timestamp);
     }
     /**
      * Generate recommendations based on analysis

package/dist/analytics/simple-pattern-analyzer.d.ts

@@ -66,6 +66,10 @@ export declare class SimplePatternAnalyzer {
      * Calculate statistics from parsed entries
      */
     private calculateStats;
+    /**
+     * Earliest and latest timestamp. Matches a stable sort on finite times.
+     */
+    private entryDateRange;
     /**
      * Generate human-readable insights
      */