agentic-qe 3.7.19 → 3.7.21

package/dist/routing/index.d.ts

@@ -11,6 +11,10 @@ export type { QEAgentProfile, QETask, QERoutingDecision, AgentScore, RoutingWeig
 export { DEFAULT_ROUTER_CONFIG } from './types.js';
 export { QE_AGENT_REGISTRY, getAgentsByDomain, getAgentsByCapability, getAgentsByLanguage, getAgentsByFramework, getAgentsByComplexity, getAgentById, getAgentCounts, } from './qe-agent-registry.js';
 export { QETaskRouter, createQETaskRouter, } from './qe-task-router.js';
+export { CoExecutionRepository, getCoExecutionRepository, } from './co-execution-repository.js';
+export type { CoExecutionRecord, CoExecutionStats, } from './co-execution-repository.js';
+export { SignalMerger, createSignalMerger, DEFAULT_SIGNAL_MERGER_CONFIG, } from './signal-merger.js';
+export type { SignalSource, RoutingSignal, MergedAgentScore, SignalMergerConfig, } from './signal-merger.js';
 export { RoutingFeedbackCollector, createRoutingFeedbackCollector, } from './routing-feedback.js';
 export { classifyTask, isSimpleTask, requiresOpus, getRecommendedModel, getComplexityScore, COMPLEX_DOMAINS, MODERATE_DOMAINS, COMPLEX_CAPABILITIES, COMPLEXITY_THRESHOLDS, COMPLEXITY_TO_MODEL, } from './task-classifier.js';
 export type { TaskComplexity, ClaudeModel, ComplexityFactor, ClassificationResult, ClassifiableTask, } from './task-classifier.js';
@@ -18,6 +22,8 @@ export { TinyDancerRouter, createTinyDancerRouter, } from './tiny-dancer-router.
 export type { RouteResult, TinyDancerConfig, RoutingOutcome as TinyDancerRoutingOutcome, RouterStats, } from './tiny-dancer-router.js';
 export { DEFAULT_ROUTING_CONFIG, DEFAULT_CONFIDENCE_THRESHOLDS, DEFAULT_TIER_MAPPING, DEFAULT_COST_OPTIMIZATION, DEFAULT_FALLBACK_CONFIG, loadRoutingConfigFromEnv, mapComplexityToTier, getNextFallbackTier, tierToModel, estimateTaskCost, validateRoutingConfig, } from './routing-config.js';
 export type { AgentTier, ConfidenceThresholds, ComplexityTierMapping, CostOptimizationConfig, FallbackConfig, RoutingConfig, } from './routing-config.js';
+export { parseDependenciesFromFrontmatter, buildDependencyGraph, createSpawnPlan, getAgentDependencies, } from './agent-dependency-graph.js';
+export type { DependencyType, AgentDependency, McpServerDependency, ModelRequirement, AgentDependencies, DependencyNode, DependencyGraphResult, SpawnPlan, } from './agent-dependency-graph.js';
 export { EMACalibrator, DEFAULT_EMA_CONFIG, } from './calibration/index.js';
 export type { CalibrationRecord, EMAConfig, } from './calibration/index.js';
 export { AutoEscalationTracker, DEFAULT_ESCALATION_CONFIG, } from './escalation/index.js';

package/dist/routing/index.js

@@ -12,6 +12,10 @@ export { DEFAULT_ROUTER_CONFIG } from './types.js';
 export { QE_AGENT_REGISTRY, getAgentsByDomain, getAgentsByCapability, getAgentsByLanguage, getAgentsByFramework, getAgentsByComplexity, getAgentById, getAgentCounts, } from './qe-agent-registry.js';
 // Router
 export { QETaskRouter, createQETaskRouter, } from './qe-task-router.js';
+// Co-Execution Repository (Issue #342 Item 3)
+export { CoExecutionRepository, getCoExecutionRepository, } from './co-execution-repository.js';
+// Signal Merger (Issue #342 Item 3)
+export { SignalMerger, createSignalMerger, DEFAULT_SIGNAL_MERGER_CONFIG, } from './signal-merger.js';
 // Feedback
 export { RoutingFeedbackCollector, createRoutingFeedbackCollector, } from './routing-feedback.js';
 // Task Classifier (TD-002)
@@ -20,6 +24,8 @@ export { classifyTask, isSimpleTask, requiresOpus, getRecommendedModel, getCompl
 export { TinyDancerRouter, createTinyDancerRouter, } from './tiny-dancer-router.js';
 // Routing Configuration (TD-004)
 export { DEFAULT_ROUTING_CONFIG, DEFAULT_CONFIDENCE_THRESHOLDS, DEFAULT_TIER_MAPPING, DEFAULT_COST_OPTIMIZATION, DEFAULT_FALLBACK_CONFIG, loadRoutingConfigFromEnv, mapComplexityToTier, getNextFallbackTier, tierToModel, estimateTaskCost, validateRoutingConfig, } from './routing-config.js';
+// Agent Dependency Graph (Issue #342 Item 2)
+export { parseDependenciesFromFrontmatter, buildDependencyGraph, createSpawnPlan, getAgentDependencies, } from './agent-dependency-graph.js';
 // EMA Calibration (loki-mode inspired)
 export { EMACalibrator, DEFAULT_EMA_CONFIG, } from './calibration/index.js';
 // Auto-Escalation Tracker (loki-mode inspired)

package/dist/routing/qe-task-router.d.ts

@@ -18,6 +18,8 @@ export declare class QETaskRouter {
     private initialized;
     private embeddingCache;
     private contextCompiler;
+    private coExecutionRepo;
+    private signalMerger;
     /** Optional witness chain for audit trail of routing decisions (ADR-070) */
     private _witnessChain;
     set witnessChain(wc: WitnessChain | null);
@@ -66,6 +68,11 @@ export declare class QETaskRouter {
      * Update agent performance based on feedback
      */
     updateAgentPerformance(agentId: string, success: boolean, qualityScore: number, durationMs: number): void;
+    /**
+     * Record a co-execution outcome for behavioral learning (Issue #342 Item 3).
+     * Call this after a swarm task completes to track which agent combinations work well together.
+     */
+    recordCoExecution(agentIds: string[], domain: string, success: boolean, taskDescription?: string): void;
     /**
      * Get router statistics
      */

package/dist/routing/qe-task-router.js

@@ -12,6 +12,8 @@ import { DEFAULT_ROUTER_CONFIG } from './types.js';
 import { QE_AGENT_REGISTRY, getAgentById, getAgentOverlayConfig, initializeOverlays } from './qe-agent-registry.js';
 import { computeRealEmbedding, cosineSimilarity, } from '../learning/real-embeddings.js';
 import { ContextCompiler, formatContextForPrompt } from '../context/compiler.js';
+import { getCoExecutionRepository } from './co-execution-repository.js';
+import { createSignalMerger } from './signal-merger.js';
 // ============================================================================
 // Task Keyword Detection
 // ============================================================================
@@ -132,11 +134,14 @@ export class QETaskRouter {
     initialized = false;
     embeddingCache = new Map();
     contextCompiler = null;
+    coExecutionRepo = null;
+    signalMerger;
     /** Optional witness chain for audit trail of routing decisions (ADR-070) */
     _witnessChain = null;
     set witnessChain(wc) { this._witnessChain = wc; }
     constructor(config = {}) {
         this.config = { ...DEFAULT_ROUTER_CONFIG, ...config };
+        this.signalMerger = createSignalMerger();
     }
     /**
      * Initialize router by computing agent embeddings
@@ -153,6 +158,18 @@ export class QETaskRouter {
             this.agentEmbeddings.set(agent.id, embedding);
         }
         this.contextCompiler = new ContextCompiler();
+        // Initialize co-execution repository for behavioral signals (Issue #342 Item 3)
+        try {
+            const { getUnifiedMemory } = await import('../kernel/unified-memory.js');
+            const unifiedMemory = getUnifiedMemory();
+            await unifiedMemory.initialize();
+            this.coExecutionRepo = getCoExecutionRepository();
+            this.coExecutionRepo.initialize(unifiedMemory.getDatabase());
+        }
+        catch {
+            // Non-blocking: behavioral signals unavailable if DB init fails
+            console.debug('[QETaskRouter] Co-execution repository unavailable (behavioral signals disabled)');
+        }
         this.initialized = true;
     }
     /**
@@ -195,7 +212,45 @@ export class QETaskRouter {
             const score = await this.scoreAgent(agent, task, taskEmbedding, detectedCapabilities);
             scores.push(score);
         }
-        // 4. Sort by combined score
+        // 4. Multi-signal merge (Issue #342 Item 3)
+        // Build static analysis signal map from base scores
+        const staticAnalysisMap = new Map();
+        for (const score of scores) {
+            staticAnalysisMap.set(score.agent, {
+                confidence: score.combinedScore,
+                reason: score.reason,
+            });
+        }
+        // Build behavioral signal map from co-execution data
+        const behavioralMap = new Map();
+        if (this.coExecutionRepo && task.context?.previousAgent) {
+            for (const score of scores) {
+                const stats = this.coExecutionRepo.getCoExecutionStats(task.context.previousAgent, score.agent);
+                if (stats) {
+                    behavioralMap.set(score.agent, stats);
+                }
+            }
+        }
+        // Merge signals with precedence: user > static > behavioral
+        const mergedResults = this.signalMerger.merge(scores.map(s => s.agent), {
+            userDeclaration: task.context?.preferredAgent,
+            staticAnalysis: staticAnalysisMap,
+            behavioral: behavioralMap,
+        });
+        // Apply merged scores back
+        for (const merged of mergedResults) {
+            const score = scores.find(s => s.agent === merged.agentId);
+            if (score) {
+                score.combinedScore = merged.mergedConfidence;
+                if (merged.determinedBy === 'user-declaration') {
+                    score.reason = 'user-declared agent (confidence: 1.0)';
+                }
+                else if (merged.signals.length > 1) {
+                    score.reason += `, ${merged.determinedBy} signal dominant`;
+                }
+            }
+        }
+        // 4.5. Sort by combined score
         scores.sort((a, b) => b.combinedScore - a.combinedScore);
         // 5. Build routing decision
         const topScore = scores[0];
@@ -470,6 +525,13 @@ export class QETaskRouter {
         agent.avgDurationMs =
             (agent.avgDurationMs * prevTotal + durationMs) / agent.tasksCompleted;
     }
+    /**
+     * Record a co-execution outcome for behavioral learning (Issue #342 Item 3).
+     * Call this after a swarm task completes to track which agent combinations work well together.
+     */
+    recordCoExecution(agentIds, domain, success, taskDescription) {
+        this.coExecutionRepo?.recordSwarmCoExecution(agentIds, domain, success, taskDescription);
+    }
     /**
      * Get router statistics
      */

package/dist/routing/signal-merger.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Multi-Signal Confidence Merger (Issue #342, Item 3)
+ *
+ * Combines three independent routing signals with clear precedence:
+ *
+ * | Signal | AQE Equivalent | Confidence | Precedence |
+ * |--------|---------------|------------|------------|
+ * | User declaration | preferredAgent in task context or CLAUDE.md | 1.0 | Overrides all |
+ * | Static analysis | Code pattern scanning (domain + capability match) | 0.5-0.9 | Overrides behavioral |
+ * | Behavioral co-usage | Learning DB: which agents succeed together | 0.0-1.0 (linear ramp) | Lowest |
+ *
+ * Key rules from Skillsmith:
+ * - When declaration and inference agree, keep declaration, drop inferred (dedup)
+ * - Behavioral confidence ramps linearly: min(1.0, success_count / 20)
+ */
+import type { CoExecutionStats } from './co-execution-repository.js';
+/** Signal source type */
+export type SignalSource = 'user-declaration' | 'static-analysis' | 'behavioral';
+/** A single routing signal */
+export interface RoutingSignal {
+    /** Signal source */
+    readonly source: SignalSource;
+    /** Recommended agent ID */
+    readonly agentId: string;
+    /** Confidence score (0-1) */
+    readonly confidence: number;
+    /** Human-readable reason */
+    readonly reason: string;
+}
+/** Merged signal result for one agent */
+export interface MergedAgentScore {
+    /** Agent ID */
+    readonly agentId: string;
+    /** Final merged confidence */
+    readonly mergedConfidence: number;
+    /** Individual signal contributions */
+    readonly signals: RoutingSignal[];
+    /** Which signal determined the final score */
+    readonly determinedBy: SignalSource;
+    /** Whether signals agreed */
+    readonly signalsAgreed: boolean;
+}
+/** Configuration for the signal merger */
+export interface SignalMergerConfig {
+    /** Weight for static analysis signal when no declaration present */
+    readonly staticAnalysisWeight: number;
+    /** Weight for behavioral signal when no declaration present */
+    readonly behavioralWeight: number;
+    /** Minimum behavioral confidence to contribute to scoring */
+    readonly minBehavioralConfidence: number;
+}
+export declare const DEFAULT_SIGNAL_MERGER_CONFIG: SignalMergerConfig;
+export declare class SignalMerger {
+    private readonly config;
+    constructor(config?: Partial<SignalMergerConfig>);
+    /**
+     * Merge multiple routing signals for a set of candidate agents.
+     *
+     * Precedence rules:
+     * 1. User declaration (confidence 1.0) overrides everything
+     * 2. Static analysis (0.5-0.9) overrides behavioral
+     * 3. Behavioral co-usage (0.0-1.0 linear ramp) is lowest priority
+     *
+     * Deduplication: when declaration and analysis agree on the same agent,
+     * keep declaration, drop analysis (Skillsmith rule).
+     */
+    merge(candidateAgentIds: string[], signals: {
+        /** User-declared preferred agent (confidence 1.0) */
+        userDeclaration?: string;
+        /** Static analysis scores per agent */
+        staticAnalysis: Map<string, {
+            confidence: number;
+            reason: string;
+        }>;
+        /** Behavioral co-execution data per agent */
+        behavioral: Map<string, CoExecutionStats>;
+    }): MergedAgentScore[];
+}
+/** Create a signal merger instance */
+export declare function createSignalMerger(config?: Partial<SignalMergerConfig>): SignalMerger;
+//# sourceMappingURL=signal-merger.d.ts.map

package/dist/routing/signal-merger.js

@@ -0,0 +1,136 @@
+/**
+ * Multi-Signal Confidence Merger (Issue #342, Item 3)
+ *
+ * Combines three independent routing signals with clear precedence:
+ *
+ * | Signal | AQE Equivalent | Confidence | Precedence |
+ * |--------|---------------|------------|------------|
+ * | User declaration | preferredAgent in task context or CLAUDE.md | 1.0 | Overrides all |
+ * | Static analysis | Code pattern scanning (domain + capability match) | 0.5-0.9 | Overrides behavioral |
+ * | Behavioral co-usage | Learning DB: which agents succeed together | 0.0-1.0 (linear ramp) | Lowest |
+ *
+ * Key rules from Skillsmith:
+ * - When declaration and inference agree, keep declaration, drop inferred (dedup)
+ * - Behavioral confidence ramps linearly: min(1.0, success_count / 20)
+ */
+// ============================================================================
+// Default Configuration
+// ============================================================================
+export const DEFAULT_SIGNAL_MERGER_CONFIG = {
+    staticAnalysisWeight: 0.7,
+    behavioralWeight: 0.3,
+    minBehavioralConfidence: 0.05, // At least 1 successful co-execution
+};
+// ============================================================================
+// Signal Merger
+// ============================================================================
+export class SignalMerger {
+    config;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_SIGNAL_MERGER_CONFIG, ...config };
+    }
+    /**
+     * Merge multiple routing signals for a set of candidate agents.
+     *
+     * Precedence rules:
+     * 1. User declaration (confidence 1.0) overrides everything
+     * 2. Static analysis (0.5-0.9) overrides behavioral
+     * 3. Behavioral co-usage (0.0-1.0 linear ramp) is lowest priority
+     *
+     * Deduplication: when declaration and analysis agree on the same agent,
+     * keep declaration, drop analysis (Skillsmith rule).
+     */
+    merge(candidateAgentIds, signals) {
+        const results = [];
+        for (const agentId of candidateAgentIds) {
+            const agentSignals = [];
+            let determinedBy = 'static-analysis';
+            let mergedConfidence;
+            // Signal 1: User declaration (highest precedence)
+            const isUserDeclared = signals.userDeclaration === agentId;
+            if (isUserDeclared) {
+                agentSignals.push({
+                    source: 'user-declaration',
+                    agentId,
+                    confidence: 1.0,
+                    reason: 'User explicitly selected this agent',
+                });
+            }
+            // Signal 2: Static analysis
+            const staticScore = signals.staticAnalysis.get(agentId);
+            if (staticScore) {
+                // Dedup: if user declared the same agent, don't add static signal
+                if (!isUserDeclared) {
+                    agentSignals.push({
+                        source: 'static-analysis',
+                        agentId,
+                        confidence: staticScore.confidence,
+                        reason: staticScore.reason,
+                    });
+                }
+            }
+            // Signal 3: Behavioral co-execution
+            const behavioralStats = signals.behavioral.get(agentId);
+            if (behavioralStats && behavioralStats.behavioralConfidence >= this.config.minBehavioralConfidence) {
+                agentSignals.push({
+                    source: 'behavioral',
+                    agentId,
+                    confidence: behavioralStats.behavioralConfidence,
+                    reason: `${behavioralStats.successCount} successful co-executions (${(behavioralStats.successRate * 100).toFixed(0)}% success rate)`,
+                });
+            }
+            // Merge using precedence rules
+            if (isUserDeclared) {
+                // User declaration overrides everything
+                mergedConfidence = 1.0;
+                determinedBy = 'user-declaration';
+            }
+            else if (staticScore && behavioralStats) {
+                // Both static and behavioral available -- weighted merge
+                const behavioralConf = behavioralStats.behavioralConfidence >= this.config.minBehavioralConfidence
+                    ? behavioralStats.behavioralConfidence * behavioralStats.successRate
+                    : 0;
+                mergedConfidence =
+                    this.config.staticAnalysisWeight * staticScore.confidence +
+                        this.config.behavioralWeight * behavioralConf;
+                // Clamp to [0, 1]
+                mergedConfidence = Math.min(1.0, Math.max(0, mergedConfidence));
+                determinedBy = staticScore.confidence >= behavioralConf
+                    ? 'static-analysis'
+                    : 'behavioral';
+            }
+            else if (staticScore) {
+                // Only static analysis
+                mergedConfidence = staticScore.confidence;
+                determinedBy = 'static-analysis';
+            }
+            else if (behavioralStats && behavioralStats.behavioralConfidence >= this.config.minBehavioralConfidence) {
+                // Only behavioral
+                mergedConfidence = behavioralStats.behavioralConfidence * behavioralStats.successRate;
+                determinedBy = 'behavioral';
+            }
+            else {
+                // No signals -- baseline
+                mergedConfidence = 0;
+                determinedBy = 'static-analysis';
+            }
+            const signalsAgreed = agentSignals.length > 1 &&
+                agentSignals.every(s => s.agentId === agentSignals[0].agentId);
+            results.push({
+                agentId,
+                mergedConfidence,
+                signals: agentSignals,
+                determinedBy,
+                signalsAgreed,
+            });
+        }
+        // Sort by merged confidence descending
+        results.sort((a, b) => b.mergedConfidence - a.mergedConfidence);
+        return results;
+    }
+}
+/** Create a signal merger instance */
+export function createSignalMerger(config) {
+    return new SignalMerger(config);
+}
+//# sourceMappingURL=signal-merger.js.map

package/dist/routing/types.d.ts

@@ -198,6 +198,7 @@ export interface AgentPerformanceMetrics {
     /** Last updated */
     readonly updatedAt: Date;
 }
+export type { DependencyType, AgentDependency, McpServerDependency, ModelRequirement, AgentDependencies } from './agent-dependency-graph.js';
 /**
  * Task router configuration
  */

package/dist/shared/llm/providers/azure-openai.js

@@ -31,6 +31,7 @@ import { createLLMError, } from '../interfaces';
 import { CostTracker } from '../cost-tracker';
 import { TokenMetricsCollector } from '../../../learning/token-tracker.js';
 import { toError } from '../../error-utils.js';
+import { backoffDelay } from '../retry.js';
 /**
  * Default Azure OpenAI configuration
  */
@@ -517,7 +518,7 @@ export class AzureOpenAIProvider {
                 // Retry on server errors and rate limiting
                 if (response.status >= 500 || response.status === 429) {
                     if (attempt < maxRetries - 1) {
-                        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                        const delay = backoffDelay(attempt);
                         await this.sleep(delay);
                         continue;
                     }
@@ -528,7 +529,7 @@ export class AzureOpenAIProvider {
                 lastError = toError(error);
                 // Only retry on network/timeout errors
                 if (attempt < maxRetries - 1) {
-                    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                    const delay = backoffDelay(attempt);
                     await this.sleep(delay);
                 }
             }

package/dist/shared/llm/providers/bedrock.js

@@ -15,6 +15,7 @@ import { createLLMError, } from '../interfaces';
 import { CostTracker } from '../cost-tracker';
 import { TokenMetricsCollector } from '../../../learning/token-tracker.js';
 import { toError } from '../../error-utils.js';
+import { backoffDelay } from '../retry.js';
 /**
  * Default Bedrock configuration
  */
@@ -353,7 +354,7 @@ export class BedrockProvider {
                 // Retry on server errors and throttling
                 if (response.status >= 500 || response.status === 429) {
                     if (attempt < maxRetries - 1) {
-                        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                        const delay = backoffDelay(attempt);
                         await this.sleep(delay);
                         continue;
                     }
@@ -363,7 +364,7 @@ export class BedrockProvider {
             catch (error) {
                 lastError = toError(error);
                 if (attempt < maxRetries - 1) {
-                    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                    const delay = backoffDelay(attempt);
                     await this.sleep(delay);
                 }
             }

package/dist/shared/llm/providers/claude.js

@@ -9,6 +9,7 @@ import { createLLMError, } from '../interfaces';
 import { CostTracker } from '../cost-tracker';
 import { TokenMetricsCollector } from '../../../learning/token-tracker.js';
 import { toError } from '../../error-utils.js';
+import { backoffDelay } from '../retry.js';
 /**
  * Default Claude configuration
  */
@@ -375,7 +376,7 @@ export class ClaudeProvider {
                 // Retry on server errors and rate limiting
                 if (response.status >= 500 || response.status === 429) {
                     if (attempt < maxRetries - 1) {
-                        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                        const delay = backoffDelay(attempt);
                         await this.sleep(delay);
                         continue;
                     }
@@ -386,7 +387,7 @@ export class ClaudeProvider {
                 lastError = toError(error);
                 // Only retry on network/timeout errors
                 if (attempt < maxRetries - 1) {
-                    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                    const delay = backoffDelay(attempt);
                     await this.sleep(delay);
                 }
             }

package/dist/shared/llm/providers/gemini.js

@@ -11,6 +11,7 @@
 import { createLLMError, } from '../interfaces';
 import { TokenMetricsCollector } from '../../../learning/token-tracker.js';
 import { toError } from '../../error-utils.js';
+import { backoffDelay } from '../retry.js';
 import { safeJsonParse } from '../../safe-json.js';
 /**
  * Default Gemini configuration
@@ -582,7 +583,7 @@ export class GeminiProvider {
                 }
                 if (response.status >= 500 || response.status === 429) {
                     if (attempt < maxRetries - 1) {
-                        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                        const delay = backoffDelay(attempt);
                         await this.sleep(delay);
                         continue;
                     }
@@ -592,7 +593,7 @@ export class GeminiProvider {
             catch (error) {
                 lastError = toError(error);
                 if (attempt < maxRetries - 1) {
-                    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                    const delay = backoffDelay(attempt);
                     await this.sleep(delay);
                 }
             }

package/dist/shared/llm/providers/openai.js

@@ -9,6 +9,7 @@ import { createLLMError, } from '../interfaces';
 import { CostTracker } from '../cost-tracker';
 import { TokenMetricsCollector } from '../../../learning/token-tracker.js';
 import { toError } from '../../error-utils.js';
+import { backoffDelay } from '../retry.js';
 /**
  * Default OpenAI configuration
  */
@@ -421,7 +422,7 @@ export class OpenAIProvider {
                 // Retry on server errors and rate limiting
                 if (response.status >= 500 || response.status === 429) {
                     if (attempt < maxRetries - 1) {
-                        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                        const delay = backoffDelay(attempt);
                         await this.sleep(delay);
                         continue;
                     }
@@ -432,7 +433,7 @@ export class OpenAIProvider {
                 lastError = toError(error);
                 // Only retry on network/timeout errors
                 if (attempt < maxRetries - 1) {
-                    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                    const delay = backoffDelay(attempt);
                     await this.sleep(delay);
                 }
             }

package/dist/shared/llm/providers/openrouter.js

@@ -12,6 +12,7 @@
 import { createLLMError, } from '../interfaces';
 import { TokenMetricsCollector } from '../../../learning/token-tracker.js';
 import { toError } from '../../error-utils.js';
+import { backoffDelay } from '../retry.js';
 import { safeJsonParse } from '../../safe-json.js';
 /**
  * Default OpenRouter configuration
@@ -618,7 +619,7 @@ export class OpenRouterProvider {
                 // Retry on server errors and rate limiting
                 if (response.status >= 500 || response.status === 429) {
                     if (attempt < maxRetries - 1) {
-                        const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                        const delay = backoffDelay(attempt);
                         await this.sleep(delay);
                         continue;
                     }
@@ -629,7 +630,7 @@ export class OpenRouterProvider {
                 lastError = toError(error);
                 // Only retry on network/timeout errors
                 if (attempt < maxRetries - 1) {
-                    const delay = Math.min(1000 * Math.pow(2, attempt), 30000);
+                    const delay = backoffDelay(attempt);
                     await this.sleep(delay);
                 }
             }

package/dist/shared/llm/retry.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared retry utilities for LLM providers.
+ * Extracts the common exponential backoff pattern used across all providers.
+ */
+/**
+ * Compute exponential backoff delay: min(base * 2^attempt, max).
+ * Used by all LLM provider retry loops.
+ */
+export declare function backoffDelay(attempt: number, baseMs?: number, maxMs?: number): number;
+//# sourceMappingURL=retry.d.ts.map

package/dist/shared/llm/retry.js

@@ -0,0 +1,16 @@
+/**
+ * Shared retry utilities for LLM providers.
+ * Extracts the common exponential backoff pattern used across all providers.
+ */
+/** Default base delay (1 second) */
+const DEFAULT_BASE_MS = 1000;
+/** Default maximum delay cap (30 seconds) */
+const DEFAULT_MAX_MS = 30000;
+/**
+ * Compute exponential backoff delay: min(base * 2^attempt, max).
+ * Used by all LLM provider retry loops.
+ */
+export function backoffDelay(attempt, baseMs = DEFAULT_BASE_MS, maxMs = DEFAULT_MAX_MS) {
+    return Math.min(baseMs * Math.pow(2, attempt), maxMs);
+}
+//# sourceMappingURL=retry.js.map

package/dist/shared/llm/router/agent-router-config.d.ts

@@ -109,7 +109,8 @@ export declare const DEFAULT_CATEGORY_MODELS: Record<AgentCategory, ModelPrefere
  */
 export declare const AGENT_CATEGORY_MAP: Record<string, AgentCategory>;
 /**
- * Default capability requirements for each agent category
+ * Default capability requirements for each agent category.
+ * Categories map to one of 4 presets, with per-category overrides where needed.
  */
 export declare const DEFAULT_CATEGORY_CAPABILITIES: Record<AgentCategory, AgentCapabilityRequirements>;
 /**