@azumag/opencode-rate-limit-fallback 1.49.0 → 1.57.0

package/dist/src/errors/PatternStorage.js

@@ -0,0 +1,234 @@
+/**
+ * Pattern Storage for Learned Error Patterns
+ */
+import { readFile, writeFile } from 'fs/promises';
+import { calculateJaccardSimilarity } from '../utils/similarity.js';
+/**
+ * PatternStorage - Manages persistence of learned patterns to config file
+ */
+export class PatternStorage {
+    configPath;
+    logger;
+    constructor(configPath, logger) {
+        this.configPath = configPath;
+        this.logger = logger;
+    }
+    /**
+     * Save a learned pattern to config file
+     */
+    async savePattern(pattern) {
+        try {
+            // Load existing config
+            const config = await this.loadConfig();
+            const errorPatterns = config.errorPatterns || {};
+            // Initialize learnedPatterns array if not exists
+            if (!errorPatterns.learnedPatterns) {
+                errorPatterns.learnedPatterns = [];
+            }
+            const learnedPatterns = errorPatterns.learnedPatterns;
+            // Check if pattern with same name already exists
+            const existingIndex = learnedPatterns.findIndex((p) => p.name === pattern.name);
+            if (existingIndex >= 0) {
+                // Update existing pattern
+                learnedPatterns[existingIndex] = pattern;
+                this.logger.debug(`[PatternStorage] Updated learned pattern: ${pattern.name}`);
+            }
+            else {
+                // Add new pattern
+                learnedPatterns.push(pattern);
+                this.logger.info(`[PatternStorage] Saved new learned pattern: ${pattern.name}`);
+            }
+            // Cleanup old patterns if exceeding limit
+            const maxPatterns = config.errorPatterns?.maxLearnedPatterns || 20;
+            if (learnedPatterns.length > maxPatterns) {
+                await this.cleanupOldPatterns(maxPatterns, learnedPatterns);
+            }
+            // Save config
+            await this.saveConfig(config);
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to save pattern', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Load all learned patterns from config file
+     */
+    async loadPatterns() {
+        try {
+            const config = await this.loadConfig();
+            const learnedPatterns = config.errorPatterns?.learnedPatterns || [];
+            // Validate patterns
+            const validPatterns = learnedPatterns.filter((p) => this.isValidPattern(p));
+            if (validPatterns.length !== learnedPatterns.length) {
+                this.logger.warn(`[PatternStorage] Filtered out ${learnedPatterns.length - validPatterns.length} invalid patterns`);
+            }
+            return validPatterns;
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to load patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Delete a pattern by name from config file
+     */
+    async deletePattern(name) {
+        try {
+            const config = await this.loadConfig();
+            const errorPatterns = config.errorPatterns || {};
+            const learnedPatterns = errorPatterns.learnedPatterns || [];
+            const index = learnedPatterns.findIndex((p) => p.name === name);
+            if (index >= 0) {
+                learnedPatterns.splice(index, 1);
+                errorPatterns.learnedPatterns = learnedPatterns;
+                config.errorPatterns = errorPatterns;
+                await this.saveConfig(config);
+                this.logger.info(`[PatternStorage] Deleted learned pattern: ${name}`);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to delete pattern', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Merge duplicate patterns with high similarity
+     */
+    async mergeDuplicatePatterns() {
+        try {
+            const config = await this.loadConfig();
+            const errorPatterns = config.errorPatterns || {};
+            let learnedPatterns = errorPatterns.learnedPatterns || [];
+            const mergeThreshold = 0.8;
+            let mergedCount = 0;
+            // Find and merge similar patterns
+            const patternsToMerge = [];
+            for (let i = 0; i < learnedPatterns.length; i++) {
+                if (patternsToMerge.includes(i))
+                    continue;
+                for (let j = i + 1; j < learnedPatterns.length; j++) {
+                    if (patternsToMerge.includes(j))
+                        continue;
+                    const pattern1 = learnedPatterns[i];
+                    const pattern2 = learnedPatterns[j];
+                    // Only merge patterns from same provider
+                    if (pattern1.provider !== pattern2.provider)
+                        continue;
+                    // Calculate similarity
+                    const similarity = this.calculatePatternSimilarity(pattern1, pattern2);
+                    if (similarity >= mergeThreshold) {
+                        // Merge pattern2 into pattern1
+                        pattern1.patterns = [...new Set([...pattern1.patterns, ...pattern2.patterns])];
+                        pattern1.sampleCount += pattern2.sampleCount;
+                        pattern1.confidence = Math.max(pattern1.confidence, pattern2.confidence);
+                        patternsToMerge.push(j);
+                        mergedCount++;
+                        this.logger.info(`[PatternStorage] Merged pattern ${pattern2.name} into ${pattern1.name}`);
+                    }
+                }
+            }
+            // Remove merged patterns (in reverse order to preserve indices)
+            patternsToMerge.sort((a, b) => b - a);
+            for (const index of patternsToMerge) {
+                learnedPatterns.splice(index, 1);
+            }
+            if (mergedCount > 0) {
+                errorPatterns.learnedPatterns = learnedPatterns;
+                config.errorPatterns = errorPatterns;
+                await this.saveConfig(config);
+            }
+            return mergedCount;
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to merge patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Cleanup old patterns, keeping only the most confident ones
+     */
+    async cleanupOldPatterns(maxCount, patterns) {
+        try {
+            const config = await this.loadConfig();
+            const errorPatterns = config.errorPatterns || {};
+            let learnedPatterns = patterns || errorPatterns.learnedPatterns || [];
+            if (learnedPatterns.length <= maxCount) {
+                return 0;
+            }
+            // Sort by confidence (descending), then by sample count (descending), then by learnedAt (descending)
+            learnedPatterns.sort((a, b) => {
+                if (b.confidence !== a.confidence) {
+                    return b.confidence - a.confidence;
+                }
+                if (b.sampleCount !== a.sampleCount) {
+                    return b.sampleCount - a.sampleCount;
+                }
+                return new Date(b.learnedAt).getTime() - new Date(a.learnedAt).getTime();
+            });
+            const removedCount = learnedPatterns.length - maxCount;
+            learnedPatterns = learnedPatterns.slice(0, maxCount);
+            errorPatterns.learnedPatterns = learnedPatterns;
+            config.errorPatterns = errorPatterns;
+            await this.saveConfig(config);
+            this.logger.info(`[PatternStorage] Cleaned up ${removedCount} old patterns`);
+            return removedCount;
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to cleanup patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Load config file
+     */
+    async loadConfig() {
+        try {
+            const content = await readFile(this.configPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            // If file doesn't exist or is invalid, return empty config
+            return {};
+        }
+    }
+    /**
+     * Save config file
+     */
+    async saveConfig(config) {
+        await writeFile(this.configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    /**
+     * Validate pattern structure
+     */
+    isValidPattern(pattern) {
+        return (pattern &&
+            typeof pattern === 'object' &&
+            typeof pattern.name === 'string' &&
+            Array.isArray(pattern.patterns) &&
+            typeof pattern.confidence === 'number' &&
+            typeof pattern.learnedAt === 'string' &&
+            typeof pattern.sampleCount === 'number' &&
+            typeof pattern.priority === 'number');
+    }
+    /**
+     * Calculate similarity between two patterns
+     */
+    calculatePatternSimilarity(pattern1, pattern2) {
+        const text1 = pattern1.patterns.join(' ').toLowerCase();
+        const text2 = pattern2.patterns.join(' ').toLowerCase();
+        return calculateJaccardSimilarity(text1, text2);
+    }
+}

package/dist/src/fallback/FallbackHandler.d.ts

@@ -25,6 +25,7 @@ export declare class FallbackHandler {
     private retryManager;
     private circuitBreaker?;
     private healthTracker?;
+    private dynamicPrioritizer?;
     constructor(config: PluginConfig, client: OpenCodeClient, logger: Logger, metricsManager: MetricsManager, subagentTracker: SubagentTracker, healthTracker?: HealthTracker);
     /**
      * Check and mark fallback in progress for deduplication
@@ -46,8 +47,8 @@ export declare class FallbackHandler {
      */
     private abortSession;
     /**
-     * Queue the prompt asynchronously (non-blocking), then abort the retry loop.
-     * promptAsync FIRST queues pending work so the server doesn't dispose on idle.
+     * Queue prompt asynchronously (non-blocking), then abort retry loop.
+     * promptAsync FIRST queues pending work so that server doesn't dispose on idle.
      * abort SECOND cancels the retry loop; the server sees the queued prompt and processes it.
      */
     retryWithModel(targetSessionID: string, model: FallbackModel, parts: MessagePart[], hierarchy: SessionHierarchy | null): Promise<void>;

package/dist/src/fallback/FallbackHandler.js

@@ -6,6 +6,8 @@ import { ModelSelector } from './ModelSelector.js';
 import { CircuitBreaker } from '../circuitbreaker/CircuitBreaker.js';
 import { extractMessageParts, convertPartsToSDKFormat, safeShowToast, getStateKey, getModelKey, DEDUP_WINDOW_MS, STATE_TIMEOUT_MS } from '../utils/helpers.js';
 import { RetryManager } from '../retry/RetryManager.js';
+import { DynamicPrioritizer } from '../dynamic/DynamicPrioritizer.js';
+import { DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG } from '../config/defaults.js';
 /**
  * Fallback Handler class for orchestrating the fallback retry flow
  */
@@ -30,6 +32,8 @@ export class FallbackHandler {
     circuitBreaker;
     // Health tracker reference
     healthTracker;
+    // Dynamic prioritizer reference
+    dynamicPrioritizer;
     constructor(config, client, logger, metricsManager, subagentTracker, healthTracker) {
         this.config = config;
         this.client = client;
@@ -41,7 +45,12 @@ export class FallbackHandler {
         if (config.circuitBreaker?.enabled) {
             this.circuitBreaker = new CircuitBreaker(config.circuitBreaker, logger, metricsManager, client);
         }
-        this.modelSelector = new ModelSelector(config, client, this.circuitBreaker, healthTracker);
+        // Initialize dynamic prioritizer if enabled and health tracker is available
+        if (healthTracker && config.dynamicPrioritization?.enabled) {
+            const dynamicConfig = { ...DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, ...config.dynamicPrioritization };
+            this.dynamicPrioritizer = new DynamicPrioritizer(dynamicConfig, healthTracker, logger, metricsManager);
+        }
+        this.modelSelector = new ModelSelector(config, client, this.circuitBreaker, healthTracker, this.dynamicPrioritizer);
         this.currentSessionModel = new Map();
         this.modelRequestStartTimes = new Map();
         this.retryState = new Map();
@@ -95,18 +104,22 @@ export class FallbackHandler {
         }
     }
     /**
-     * Queue the prompt asynchronously (non-blocking), then abort the retry loop.
-     * promptAsync FIRST queues pending work so the server doesn't dispose on idle.
+     * Queue prompt asynchronously (non-blocking), then abort retry loop.
+     * promptAsync FIRST queues pending work so that server doesn't dispose on idle.
      * abort SECOND cancels the retry loop; the server sees the queued prompt and processes it.
      */
     async retryWithModel(targetSessionID, model, parts, hierarchy) {
-        // Track the new model for this session
+        // Record model usage for dynamic prioritization
+        if (this.dynamicPrioritizer) {
+            this.dynamicPrioritizer.recordUsage(model.providerID, model.modelID);
+        }
+        // Track new model for this session
         this.currentSessionModel.set(targetSessionID, {
             providerID: model.providerID,
             modelID: model.modelID,
             lastUpdated: Date.now(),
         });
-        // If this is a root session with subagents, propagate the model to all subagents
+        // If this is a root session with subagents, propagate model to all subagents
         if (hierarchy) {
             if (hierarchy.rootSessionID === targetSessionID) {
                 hierarchy.sharedFallbackState = "completed";
@@ -464,6 +477,26 @@ export class FallbackHandler {
                 this.modelSelector.setCircuitBreaker(undefined);
             }
         }
+        // Handle dynamic prioritizer configuration changes
+        const oldDynamicPrioritizerEnabled = this.dynamicPrioritizer !== undefined;
+        if (newConfig.dynamicPrioritization?.enabled !== oldDynamicPrioritizerEnabled) {
+            if (newConfig.dynamicPrioritization?.enabled && this.healthTracker) {
+                // Create new dynamic prioritizer
+                const dynamicConfig = { ...DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, ...newConfig.dynamicPrioritization };
+                this.dynamicPrioritizer = new DynamicPrioritizer(dynamicConfig, this.healthTracker, this.logger, this.metricsManager);
+                this.modelSelector.setDynamicPrioritizer(this.dynamicPrioritizer);
+            }
+            else if (!newConfig.dynamicPrioritization?.enabled) {
+                // Disable dynamic prioritizer
+                this.dynamicPrioritizer = undefined;
+                this.modelSelector.setDynamicPrioritizer(undefined);
+            }
+        }
+        else if (this.dynamicPrioritizer && newConfig.dynamicPrioritization) {
+            // Update existing dynamic prioritizer config
+            const dynamicConfig = { ...DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, ...newConfig.dynamicPrioritization };
+            this.dynamicPrioritizer.updateConfig(dynamicConfig);
+        }
         this.logger.debug('FallbackHandler configuration updated');
     }
 }

package/dist/src/fallback/ModelSelector.d.ts

@@ -4,6 +4,7 @@
 import type { FallbackModel, PluginConfig, OpenCodeClient } from '../types/index.js';
 import type { CircuitBreaker } from '../circuitbreaker/index.js';
 import type { HealthTracker } from '../health/HealthTracker.js';
+import type { DynamicPrioritizer } from '../dynamic/DynamicPrioritizer.js';
 /**
  * Model Selector class for handling model selection strategies
  */
@@ -13,7 +14,8 @@ export declare class ModelSelector {
     private client;
     private circuitBreaker?;
     private healthTracker?;
-    constructor(config: PluginConfig, client: OpenCodeClient, circuitBreaker?: CircuitBreaker, healthTracker?: HealthTracker);
+    private dynamicPrioritizer?;
+    constructor(config: PluginConfig, client: OpenCodeClient, circuitBreaker?: CircuitBreaker, healthTracker?: HealthTracker, dynamicPrioritizer?: DynamicPrioritizer);
     /**
      * Check if a model is currently rate limited
      */
@@ -50,4 +52,8 @@ export declare class ModelSelector {
      * Set circuit breaker (for hot reload)
      */
     setCircuitBreaker(circuitBreaker: CircuitBreaker | undefined): void;
+    /**
+     * Set dynamic prioritizer (for hot reload)
+     */
+    setDynamicPrioritizer(dynamicPrioritizer: DynamicPrioritizer | undefined): void;
 }

package/dist/src/fallback/ModelSelector.js

@@ -12,11 +12,13 @@ export class ModelSelector {
     client;
     circuitBreaker;
     healthTracker;
-    constructor(config, client, circuitBreaker, healthTracker) {
+    dynamicPrioritizer;
+    constructor(config, client, circuitBreaker, healthTracker, dynamicPrioritizer) {
         this.config = config;
         this.client = client;
         this.circuitBreaker = circuitBreaker;
         this.healthTracker = healthTracker;
+        this.dynamicPrioritizer = dynamicPrioritizer;
         this.rateLimitedModels = new Map();
     }
     /**
@@ -57,6 +59,11 @@ export class ModelSelector {
                 candidates.push(model);
             }
         }
+        // Apply dynamic prioritization if enabled
+        if (this.dynamicPrioritizer && this.dynamicPrioritizer.isEnabled() && this.dynamicPrioritizer.shouldUseDynamicOrdering()) {
+            const prioritizedCandidates = this.dynamicPrioritizer.getPrioritizedModels(candidates);
+            return prioritizedCandidates[0] || null;
+        }
         // Sort by health score if health tracker is enabled
         if (this.healthTracker && this.config.enableHealthBasedSelection) {
             const healthiest = this.healthTracker.getHealthiestModels(candidates);
@@ -172,4 +179,10 @@ export class ModelSelector {
     setCircuitBreaker(circuitBreaker) {
         this.circuitBreaker = circuitBreaker;
     }
+    /**
+     * Set dynamic prioritizer (for hot reload)
+     */
+    setDynamicPrioritizer(dynamicPrioritizer) {
+        this.dynamicPrioritizer = dynamicPrioritizer;
+    }
 }

package/dist/src/main/ConfigReloader.d.ts

@@ -29,7 +29,10 @@ export declare class ConfigReloader {
     private worktree?;
     private notifyOnReload;
     private reloadMetrics;
-    constructor(config: PluginConfig, configPath: string | null, logger: Logger, validator: ConfigValidator, client: OpenCodeClient, components: ComponentRefs, directory: string, worktree?: string, notifyOnReload?: boolean);
+    private minReloadIntervalMs;
+    private recentReloadAttempts;
+    private maxReloadAttemptsPerMinute;
+    constructor(config: PluginConfig, configPath: string | null, logger: Logger, validator: ConfigValidator, client: OpenCodeClient, components: ComponentRefs, directory: string, worktree?: string, notifyOnReload?: boolean, minReloadIntervalMs?: number, maxReloadAttemptsPerMinute?: number);
     /**
      * Reload configuration from file
      */
@@ -50,6 +53,10 @@ export declare class ConfigReloader {
      * Get reload metrics
      */
     getReloadMetrics(): ReloadMetrics;
+    /**
+     * Check if reload is allowed based on rate limiting
+     */
+    private checkRateLimit;
     /**
      * Show success toast notification
      */

package/dist/src/main/ConfigReloader.js

@@ -17,7 +17,11 @@ export class ConfigReloader {
     worktree;
     notifyOnReload;
     reloadMetrics;
-    constructor(config, configPath, logger, validator, client, components, directory, worktree, notifyOnReload = true) {
+    // Rate limiting for reload operations
+    minReloadIntervalMs;
+    recentReloadAttempts;
+    maxReloadAttemptsPerMinute;
+    constructor(config, configPath, logger, validator, client, components, directory, worktree, notifyOnReload = true, minReloadIntervalMs = 1000, maxReloadAttemptsPerMinute = 10) {
         this.config = config;
         this.configPath = configPath;
         this.logger = logger;
@@ -32,6 +36,10 @@ export class ConfigReloader {
             successfulReloads: 0,
             failedReloads: 0,
         };
+        // Rate limiting settings
+        this.minReloadIntervalMs = minReloadIntervalMs;
+        this.maxReloadAttemptsPerMinute = maxReloadAttemptsPerMinute;
+        this.recentReloadAttempts = [];
     }
     /**
      * Reload configuration from file
@@ -41,9 +49,17 @@ export class ConfigReloader {
             success: false,
             timestamp: Date.now(),
         };
+        // Rate limiting check
+        const rateLimitCheck = this.checkRateLimit();
+        if (!rateLimitCheck.allowed) {
+            result.error = rateLimitCheck.reason || 'Rate limit exceeded';
+            this.logger.warn(`Config reload blocked: ${result.error}`);
+            return result;
+        }
         // Track reload metrics
         this.reloadMetrics.totalReloads++;
         this.reloadMetrics.lastReloadTime = result.timestamp;
+        this.recentReloadAttempts.push(result.timestamp);
         if (!this.configPath) {
             result.error = 'No config file path available';
             this.reloadMetrics.failedReloads++;
@@ -173,6 +189,34 @@ export class ConfigReloader {
     getReloadMetrics() {
         return { ...this.reloadMetrics };
     }
+    /**
+     * Check if reload is allowed based on rate limiting
+     */
+    checkRateLimit() {
+        const now = Date.now();
+        const oneMinuteAgo = now - 60000;
+        // Clean up old reload attempts
+        this.recentReloadAttempts = this.recentReloadAttempts.filter(timestamp => timestamp > oneMinuteAgo);
+        // Check minimum interval between reloads
+        if (this.reloadMetrics.lastReloadTime) {
+            const timeSinceLastReload = now - this.reloadMetrics.lastReloadTime;
+            if (timeSinceLastReload < this.minReloadIntervalMs) {
+                const waitTime = this.minReloadIntervalMs - timeSinceLastReload;
+                return {
+                    allowed: false,
+                    reason: `Too soon. Wait ${waitTime}ms before reloading`,
+                };
+            }
+        }
+        // Check maximum attempts per minute
+        if (this.recentReloadAttempts.length >= this.maxReloadAttemptsPerMinute) {
+            return {
+                allowed: false,
+                reason: `Rate limit exceeded. Maximum ${this.maxReloadAttemptsPerMinute} reloads per minute`,
+            };
+        }
+        return { allowed: true };
+    }
     /**
      * Show success toast notification
      */

package/dist/src/metrics/MetricsManager.d.ts

@@ -65,6 +65,14 @@ export declare class MetricsManager {
      * Record a circuit breaker state transition
      */
     recordCircuitBreakerStateTransition(modelKey: string, oldState: CircuitBreakerStateType, newState: CircuitBreakerStateType): void;
+    /**
+     * Update dynamic prioritization metrics
+     */
+    updateDynamicPrioritizationMetrics(enabled: boolean, reorders: number, modelsWithDynamicScores: number): void;
+    /**
+     * Record a model reorder event
+     */
+    recordDynamicPrioritizationReorder(): void;
     /**
      * Helper method to update circuit breaker state counts
      * @private

package/dist/src/metrics/MetricsManager.js

@@ -43,6 +43,11 @@ export class MetricsManager {
                 },
                 byModel: new Map(),
             },
+            dynamicPrioritization: {
+                enabled: false,
+                reorders: 0,
+                modelsWithDynamicScores: 0,
+            },
             startedAt: Date.now(),
             generatedAt: Date.now(),
         };
@@ -95,6 +100,11 @@ export class MetricsManager {
                 },
                 byModel: new Map(),
             },
+            dynamicPrioritization: {
+                enabled: false,
+                reorders: 0,
+                modelsWithDynamicScores: 0,
+            },
             startedAt: Date.now(),
             generatedAt: Date.now(),
         };
@@ -280,6 +290,24 @@ export class MetricsManager {
         this.updateCircuitBreakerStateCounts(modelMetrics, oldState, newState);
         this.metrics.circuitBreaker.byModel.set(modelKey, modelMetrics);
     }
+    /**
+     * Update dynamic prioritization metrics
+     */
+    updateDynamicPrioritizationMetrics(enabled, reorders, modelsWithDynamicScores) {
+        if (!this.config.enabled)
+            return;
+        this.metrics.dynamicPrioritization.enabled = enabled;
+        this.metrics.dynamicPrioritization.reorders = reorders;
+        this.metrics.dynamicPrioritization.modelsWithDynamicScores = modelsWithDynamicScores;
+    }
+    /**
+     * Record a model reorder event
+     */
+    recordDynamicPrioritizationReorder() {
+        if (!this.config.enabled)
+            return;
+        this.metrics.dynamicPrioritization.reorders++;
+    }
     /**
      * Helper method to update circuit breaker state counts
      * @private
@@ -350,6 +378,7 @@ export class MetricsManager {
                 ...metrics.circuitBreaker,
                 byModel: Object.fromEntries(Array.from(metrics.circuitBreaker.byModel.entries()).map(([k, v]) => [k, v])),
             },
+            dynamicPrioritization: metrics.dynamicPrioritization,
             startedAt: metrics.startedAt,
             generatedAt: metrics.generatedAt,
         };
@@ -472,6 +501,13 @@ export class MetricsManager {
                 }
             }
         }
+        lines.push("");
+        // Dynamic Prioritization
+        lines.push("Dynamic Prioritization:");
+        lines.push("-".repeat(40));
+        lines.push(`  Enabled: ${metrics.dynamicPrioritization.enabled ? 'Yes' : 'No'}`);
+        lines.push(`  Reorders: ${metrics.dynamicPrioritization.reorders}`);
+        lines.push(`  Models with dynamic scores: ${metrics.dynamicPrioritization.modelsWithDynamicScores}`);
         return lines.join("\n");
     }
     /**
@@ -579,6 +615,15 @@ export class MetricsManager {
                 successRate,
             ].join(","));
         }
+        lines.push("");
+        // Dynamic Prioritization CSV
+        lines.push("=== DYNAMIC_PRIORITIZATION ===");
+        lines.push("enabled,reorders,models_with_dynamic_scores");
+        lines.push([
+            metrics.dynamicPrioritization.enabled ? 'Yes' : 'No',
+            metrics.dynamicPrioritization.reorders,
+            metrics.dynamicPrioritization.modelsWithDynamicScores,
+        ].join(","));
         return lines.join("\n");
     }
     /**