@poetic-ai/poetic 1.42.0

package/dist/chunk-7MMLMXO6.js

@@ -0,0 +1,3679 @@
+import {
+  PromptManager,
+  VariantGenerator
+} from "./chunk-Q3WIC6GQ.js";
+import {
+  PromptStore
+} from "./chunk-OQ6K46CK.js";
+import {
+  BUILT_IN_VARIANT_STRATEGIES
+} from "./chunk-VXF4Q3FW.js";
+import {
+  DEFAULT_EVALUATION_CRITERIA,
+  getActiveCriteria
+} from "./chunk-6Y5TWI7H.js";
+import {
+  TelemetryLogger
+} from "./chunk-CKNX3TTP.js";
+import {
+  JUDGE_DEFAULTS
+} from "./chunk-ETYDXCK7.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  resolvePoeticDirFromContext
+} from "./chunk-UI2F6DJ5.js";
+import {
+  emitWarning,
+  isTelemetryDebug
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/optimization/ActivationAuthority.ts
+var TunerActivationAuthority = class {
+  constructor(tuner, telemetry) {
+    this.tuner = tuner;
+    this.telemetry = telemetry;
+  }
+  tuner;
+  telemetry;
+  async activate(request) {
+    const decision = {
+      shouldActivate: true,
+      candidateVersionId: request.candidateVersionId,
+      currentVersionId: request.sourceVersionId,
+      improvementPercentage: request.improvementPercentage,
+      statisticalSignificance: 1,
+      confidence: request.confidence,
+      safetyChecks: [],
+      recommendation: "activate",
+      rationale: request.reason,
+      decidedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const record = await this.tuner.executeActivation(request.promptId, decision, {
+      skipSafetyChecks: request.skipSafetyChecks
+    });
+    const activated = record !== null;
+    if (activated && this.telemetry) {
+      this.telemetry.logCostEvent("prompt:activate:auto", {
+        promptId: request.promptId,
+        versionId: request.candidateVersionId,
+        improvementPercentage: request.improvementPercentage,
+        safetyChecksPassed: request.safetyChecksPassed ?? null
+      });
+    }
+    return {
+      activated,
+      record,
+      reason: request.reason
+    };
+  }
+  scheduleMonitoring(activationId) {
+    void this.tuner.monitorActivation(activationId).catch(() => {
+    });
+  }
+};
+
+// src/prompts/auto-tuner.ts
+import { randomBytes } from "crypto";
+
+// src/prompts/evaluator.ts
+var PromptEvaluator = class {
+  store;
+  telemetry;
+  constructor(options = {}) {
+    this.store = new PromptStore(options);
+    this.telemetry = options.telemetryLogger || TelemetryLogger.getInstance(options);
+  }
+  /**
+   * Evaluate a prompt version against criteria
+   */
+  async evaluate(versionId, criteria = {}, variant) {
+    try {
+      const version = this.store.getVersion(versionId);
+      if (!version) {
+        throw new Error(`Version ${versionId} not found`);
+      }
+      const performance = await this.calculatePerformanceMetrics(version, variant);
+      const defaultCriteria = {
+        minSuccessRate: criteria.minSuccessRate ?? 0.7,
+        // 70%
+        minCompleteness: criteria.minCompleteness ?? 70,
+        maxAvgDuration: criteria.maxAvgDuration ?? 300,
+        // 5 minutes
+        minCodeDeliveryRate: criteria.minCodeDeliveryRate ?? 0.8,
+        // 80%
+        minSampleSize: criteria.minSampleSize ?? 5
+      };
+      const hasEnoughData = performance.sampleSize >= defaultCriteria.minSampleSize;
+      if (!hasEnoughData) {
+        return {
+          versionId,
+          promptId: version.promptId,
+          variant,
+          meetsStandards: false,
+          performance,
+          criteriaResults: [],
+          recommendation: "needs_data",
+          rationale: `Insufficient data for evaluation (${performance.sampleSize}/${defaultCriteria.minSampleSize} executions)`,
+          evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const criteriaResults = [
+        {
+          criterion: "Success Rate",
+          required: defaultCriteria.minSuccessRate,
+          actual: performance.successRate,
+          passed: performance.successRate >= defaultCriteria.minSuccessRate
+        },
+        {
+          criterion: "Completeness",
+          required: defaultCriteria.minCompleteness,
+          actual: performance.avgCompleteness,
+          passed: performance.avgCompleteness >= defaultCriteria.minCompleteness
+        },
+        {
+          criterion: "Duration",
+          required: defaultCriteria.maxAvgDuration,
+          actual: performance.avgDuration,
+          passed: performance.avgDuration <= defaultCriteria.maxAvgDuration
+        },
+        {
+          criterion: "Code Delivery Rate",
+          required: defaultCriteria.minCodeDeliveryRate,
+          actual: performance.avgCodeDeliveryRate,
+          passed: performance.avgCodeDeliveryRate >= defaultCriteria.minCodeDeliveryRate
+        }
+      ];
+      const meetsStandards = criteriaResults.every((c) => c.passed);
+      const failedCriteria = criteriaResults.filter((c) => !c.passed);
+      let recommendation;
+      let rationale;
+      if (meetsStandards) {
+        recommendation = "keep";
+        rationale = "Prompt meets all quality standards and performs well";
+      } else if (failedCriteria.length === 1) {
+        recommendation = "improve";
+        const failed = failedCriteria[0];
+        if (!failed) {
+          rationale = "Prompt needs improvement";
+        } else {
+          rationale = `Prompt needs improvement in ${failed.criterion.toLowerCase()} (${failed.actual.toFixed(2)} vs ${failed.required.toFixed(2)} required)`;
+        }
+      } else if (performance.successRate < 0.5) {
+        recommendation = "replace";
+        rationale = `Prompt has low success rate (${(performance.successRate * 100).toFixed(1)}%) - consider replacing`;
+      } else {
+        recommendation = "improve";
+        rationale = `Prompt fails ${failedCriteria.length} criteria: ${failedCriteria.map((c) => c.criterion).join(", ")}`;
+      }
+      return {
+        versionId,
+        promptId: version.promptId,
+        variant,
+        meetsStandards,
+        performance,
+        criteriaResults,
+        recommendation,
+        rationale,
+        evaluatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to evaluate version ${versionId}: ${error.message}`);
+    }
+  }
+  /**
+   * Analyze trends for a prompt version over time
+   */
+  async analyzeTrends(versionId, variant, minDataPoints = 10) {
+    try {
+      const version = this.store.getVersion(versionId);
+      if (!version) {
+        throw new Error(`Version ${versionId} not found`);
+      }
+      const variantStr = variant || "conservative";
+      const executions = this.telemetry.getVariantPerformance(variantStr, {
+        limit: 100,
+        promptVersion: versionId
+      });
+      if (executions.length < minDataPoints) {
+        return {
+          versionId,
+          promptId: version.promptId,
+          variant,
+          dataPoints: executions.length,
+          trends: {
+            successRate: "insufficient_data",
+            completeness: "insufficient_data",
+            duration: "insufficient_data"
+          },
+          insights: [
+            `Insufficient data for trend analysis (${executions.length}/${minDataPoints} data points)`
+          ],
+          analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const recentWindow = Math.floor(executions.length / 3);
+      const olderData = executions.slice(0, recentWindow);
+      const recentData = executions.slice(-recentWindow);
+      const recentSuccessRate = recentData.filter((e) => e.verdict === "success").length / recentData.length;
+      const olderSuccessRate = olderData.filter((e) => e.verdict === "success").length / olderData.length;
+      const successRateTrend = this.determineTrend(recentSuccessRate, olderSuccessRate);
+      const recentCompleteness = recentData.reduce((sum, e) => sum + (e.completeness || 0), 0) / recentData.length;
+      const olderCompleteness = olderData.reduce((sum, e) => sum + (e.completeness || 0), 0) / olderData.length;
+      const completenessTrend = this.determineTrend(recentCompleteness, olderCompleteness);
+      const recentDuration = recentData.reduce((sum, e) => sum + (e.total_duration_sec || 0), 0) / recentData.length;
+      const olderDuration = olderData.reduce((sum, e) => sum + (e.total_duration_sec || 0), 0) / olderData.length;
+      const durationTrend = this.determineTrend(olderDuration, recentDuration);
+      const insights = [];
+      if (successRateTrend === "improving") {
+        insights.push(
+          `Success rate is improving (${(olderSuccessRate * 100).toFixed(1)}% \u2192 ${(recentSuccessRate * 100).toFixed(1)}%)`
+        );
+      } else if (successRateTrend === "declining") {
+        insights.push(
+          `Success rate is declining (${(olderSuccessRate * 100).toFixed(1)}% \u2192 ${(recentSuccessRate * 100).toFixed(1)}%)`
+        );
+      }
+      if (completenessTrend === "improving") {
+        insights.push(
+          `Completeness is improving (${olderCompleteness.toFixed(1)} \u2192 ${recentCompleteness.toFixed(1)})`
+        );
+      } else if (completenessTrend === "declining") {
+        insights.push(
+          `Completeness is declining (${olderCompleteness.toFixed(1)} \u2192 ${recentCompleteness.toFixed(1)})`
+        );
+      }
+      if (durationTrend === "improving") {
+        insights.push(
+          `Execution time is improving (${olderDuration.toFixed(0)}s \u2192 ${recentDuration.toFixed(0)}s)`
+        );
+      } else if (durationTrend === "declining") {
+        insights.push(
+          `Execution time is declining (${olderDuration.toFixed(0)}s \u2192 ${recentDuration.toFixed(0)}s)`
+        );
+      }
+      if (insights.length === 0) {
+        insights.push("Performance is stable across all metrics");
+      }
+      return {
+        versionId,
+        promptId: version.promptId,
+        variant,
+        dataPoints: executions.length,
+        trends: {
+          successRate: successRateTrend,
+          completeness: completenessTrend,
+          duration: durationTrend
+        },
+        insights,
+        analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to analyze trends for version ${versionId}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Calculate performance metrics from telemetry data
+   */
+  async calculatePerformanceMetrics(version, variant) {
+    try {
+      const cachedMetrics = this.store.getPerformanceMetrics(version.id, variant);
+      const variantStr = variant || "conservative";
+      const executions = this.telemetry.getVariantPerformance(variantStr, {
+        limit: 1e3,
+        promptVersion: version.id
+      });
+      if (executions.length === 0) {
+        if (cachedMetrics) {
+          return {
+            ...cachedMetrics,
+            calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        return {
+          promptId: version.promptId,
+          versionId: version.id,
+          variant,
+          totalExecutions: 0,
+          successfulExecutions: 0,
+          failedExecutions: 0,
+          successRate: 0,
+          avgCompleteness: 0,
+          avgCodeDeliveryRate: 0,
+          avgDuration: 0,
+          minCompleteness: 0,
+          maxCompleteness: 0,
+          stdDevCompleteness: 0,
+          sampleSize: 0,
+          firstExecutionAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastExecutionAt: (/* @__PURE__ */ new Date()).toISOString(),
+          calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const successfulExecutions = executions.filter((e) => e.verdict === "success").length;
+      const failedExecutions = executions.length - successfulExecutions;
+      const successRate = successfulExecutions / executions.length;
+      const completenessValues = executions.map((e) => e.completeness || 0).filter((v) => v > 0);
+      const avgCompleteness = completenessValues.reduce((sum, v) => sum + v, 0) / completenessValues.length || 0;
+      const minCompleteness = completenessValues.length > 0 ? Math.min(...completenessValues) : 0;
+      const maxCompleteness = completenessValues.length > 0 ? Math.max(...completenessValues) : 0;
+      const variance = completenessValues.reduce((sum, v) => sum + (v - avgCompleteness) ** 2, 0) / completenessValues.length || 0;
+      const stdDevCompleteness = Math.sqrt(variance);
+      const codeDeliveredCount = executions.filter((e) => e.code_delivered).length;
+      const avgCodeDeliveryRate = codeDeliveredCount / executions.length;
+      const durationValues = executions.map((e) => e.total_duration_sec || 0).filter((v) => v > 0);
+      const avgDuration = durationValues.reduce((sum, v) => sum + v, 0) / durationValues.length || 0;
+      const timestamps = executions.map((e) => e.started_at).filter(Boolean).sort();
+      const firstExecutionAt = timestamps[0] || (/* @__PURE__ */ new Date()).toISOString();
+      const lastExecutionAt = timestamps[timestamps.length - 1] || (/* @__PURE__ */ new Date()).toISOString();
+      const metrics = {
+        promptId: version.promptId,
+        versionId: version.id,
+        variant,
+        totalExecutions: executions.length,
+        successfulExecutions,
+        failedExecutions,
+        successRate,
+        avgCompleteness,
+        avgCodeDeliveryRate,
+        avgDuration,
+        minCompleteness,
+        maxCompleteness,
+        stdDevCompleteness,
+        sampleSize: executions.length,
+        firstExecutionAt,
+        lastExecutionAt,
+        calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.store.updatePerformanceMetrics(metrics);
+      return metrics;
+    } catch (error) {
+      throw new Error(`Failed to calculate performance metrics: ${error.message}`);
+    }
+  }
+  /**
+   * Batch evaluate all versions of a prompt
+   */
+  async evaluateAllVersions(promptId, criteria) {
+    try {
+      const versions = this.store.listVersions(promptId);
+      const results = [];
+      for (const version of versions) {
+        try {
+          const result = await this.evaluate(version.id, criteria);
+          results.push(result);
+        } catch (error) {
+          emitWarning(
+            "VAL-001",
+            {
+              taskId: "prompt-evaluator",
+              subsystem: "prompts",
+              executionPhase: "validation"
+            },
+            {
+              severity: "ERROR" /* ERROR */,
+              metadata: {
+                error: error.message,
+                operation: "evaluateVersion",
+                versionId: version.id,
+                promptId
+              }
+            }
+          );
+        }
+      }
+      return results;
+    } catch (error) {
+      throw new Error(
+        `Failed to evaluate versions for prompt ${promptId}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Compare performance across variants for a single prompt version
+   */
+  async compareVariantPerformance(versionId) {
+    try {
+      const version = this.store.getVersion(versionId);
+      if (!version) {
+        throw new Error(`Version ${versionId} not found`);
+      }
+      const variants = [...BUILT_IN_VARIANT_STRATEGIES];
+      const variantMetrics = [];
+      for (const variant of variants) {
+        try {
+          const metrics = await this.calculatePerformanceMetrics(version, variant);
+          if (metrics.sampleSize > 0) {
+            const evaluation = await this.evaluate(versionId, {}, variant);
+            variantMetrics.push({ variant, metrics, evaluation });
+          }
+        } catch (error) {
+          emitWarning(
+            "VAL-001",
+            {
+              taskId: "prompt-evaluator",
+              subsystem: "prompts",
+              executionPhase: "validation"
+            },
+            {
+              severity: "ERROR" /* ERROR */,
+              metadata: {
+                error: error.message,
+                operation: "evaluateVariant",
+                variant,
+                versionId
+              }
+            }
+          );
+        }
+      }
+      if (variantMetrics.length === 0) {
+        return {
+          versionId,
+          variantMetrics: [],
+          bestVariant: null,
+          insights: ["No variant performance data available"]
+        };
+      }
+      const scored = variantMetrics.map((vm) => ({
+        variant: vm.variant,
+        score: vm.metrics.successRate * 0.4 + vm.metrics.avgCompleteness / 100 * 0.4 + Math.max(0, 1 - (vm.metrics.avgDuration ?? 0) / 300) * 0.2
+      }));
+      scored.sort((a, b) => b.score - a.score);
+      const bestVariant = scored[0]?.variant ?? null;
+      const insights = [];
+      const best = bestVariant ? variantMetrics.find((vm) => vm.variant === bestVariant) : void 0;
+      if (best) {
+        insights.push(
+          `${bestVariant} variant performs best (${(best.metrics.successRate * 100).toFixed(1)}% success, ${best.metrics.avgCompleteness.toFixed(1)} avg completeness)`
+        );
+      }
+      for (const vm of variantMetrics) {
+        if (vm.variant !== bestVariant && best) {
+          const deltaSuccess = (vm.metrics.successRate - best.metrics.successRate) * 100;
+          const deltaCompleteness = vm.metrics.avgCompleteness - best.metrics.avgCompleteness;
+          if (Math.abs(deltaSuccess) > 10 || Math.abs(deltaCompleteness) > 10) {
+            insights.push(
+              `${vm.variant} shows ${deltaSuccess > 0 ? "+" : ""}${deltaSuccess.toFixed(1)}% success rate, ${deltaCompleteness > 0 ? "+" : ""}${deltaCompleteness.toFixed(1)} completeness vs ${bestVariant}`
+            );
+          }
+        }
+      }
+      return {
+        versionId,
+        variantMetrics,
+        bestVariant,
+        insights
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to compare variant performance for version ${versionId}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Close connections
+   */
+  close() {
+    this.store.close();
+    this.telemetry.close();
+  }
+  // Private helper methods
+  /**
+   * Determine trend direction based on comparison
+   */
+  determineTrend(recent, older, threshold = 0.05) {
+    const change = recent - older;
+    const percentChange = Math.abs(change) / older;
+    if (percentChange < threshold) {
+      return "stable";
+    } else if (change > 0) {
+      return "improving";
+    } else {
+      return "declining";
+    }
+  }
+};
+
+// src/prompts/optimizer.ts
+var PromptOptimizer = class {
+  store;
+  evaluator;
+  constructor(options = {}) {
+    this.store = new PromptStore(options);
+    this.evaluator = new PromptEvaluator({
+      poeticDir: options.poeticDir,
+      telemetryLogger: options.telemetryLogger
+    });
+  }
+  /**
+   * Analyze a prompt version and generate optimization suggestions
+   */
+  async analyze(versionId, variant) {
+    try {
+      const version = this.store.getVersion(versionId);
+      if (!version) {
+        throw new Error(`Version ${versionId} not found`);
+      }
+      const performance = await this.evaluator.calculatePerformanceMetrics(version, variant);
+      const suggestions = this.generateSuggestions(version, performance);
+      const strengths = this.identifyStrengths(performance);
+      const weaknesses = this.identifyWeaknesses(performance);
+      const overallScore = this.calculateOverallScore(performance);
+      return {
+        versionId,
+        promptId: version.promptId,
+        version: version.id,
+        performance,
+        suggestions,
+        strengths,
+        weaknesses,
+        overallScore,
+        analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to analyze version ${versionId}: ${error.message}`);
+    }
+  }
+  /**
+   * Compare current version with a baseline version
+   */
+  async compareWithBaseline(currentVersionId, baselineVersionId, variant) {
+    try {
+      const currentVersion = this.store.getVersion(currentVersionId);
+      const baselineVersion = this.store.getVersion(baselineVersionId);
+      if (!currentVersion || !baselineVersion) {
+        throw new Error("One or both versions not found");
+      }
+      const currentPerf = await this.evaluator.calculatePerformanceMetrics(currentVersion, variant);
+      const baselinePerf = await this.evaluator.calculatePerformanceMetrics(
+        baselineVersion,
+        variant
+      );
+      const currentScore = this.calculateOverallScore(currentPerf);
+      const baselineScore = this.calculateOverallScore(baselinePerf);
+      const performanceChange = (currentScore - baselineScore) / baselineScore * 100;
+      const improvements = [];
+      const regressions = [];
+      const successRateChange = (currentPerf.successRate - baselinePerf.successRate) * 100;
+      if (successRateChange > 5) {
+        improvements.push(`Success rate improved by ${successRateChange.toFixed(1)}%`);
+      } else if (successRateChange < -5) {
+        regressions.push(`Success rate decreased by ${Math.abs(successRateChange).toFixed(1)}%`);
+      }
+      const completenessChange = currentPerf.avgCompleteness - baselinePerf.avgCompleteness;
+      if (completenessChange > 5) {
+        improvements.push(`Completeness improved by ${completenessChange.toFixed(1)} points`);
+      } else if (completenessChange < -5) {
+        regressions.push(
+          `Completeness decreased by ${Math.abs(completenessChange).toFixed(1)} points`
+        );
+      }
+      const durationChange = currentPerf.avgDuration - baselinePerf.avgDuration;
+      if (durationChange < -10) {
+        improvements.push(`Execution time improved by ${Math.abs(durationChange).toFixed(0)}s`);
+      } else if (durationChange > 10) {
+        regressions.push(`Execution time increased by ${durationChange.toFixed(0)}s`);
+      }
+      const deliveryChange = (currentPerf.avgCodeDeliveryRate - baselinePerf.avgCodeDeliveryRate) * 100;
+      if (deliveryChange > 5) {
+        improvements.push(`Code delivery rate improved by ${deliveryChange.toFixed(1)}%`);
+      } else if (deliveryChange < -5) {
+        regressions.push(`Code delivery rate decreased by ${Math.abs(deliveryChange).toFixed(1)}%`);
+      }
+      let recommendation;
+      if (performanceChange > 10 && regressions.length === 0) {
+        recommendation = "Significant improvement - recommend activating this version";
+      } else if (performanceChange > 5) {
+        recommendation = "Moderate improvement - consider activating after review";
+      } else if (performanceChange < -10) {
+        recommendation = "Performance regression - do not activate, investigate issues";
+      } else if (performanceChange < -5) {
+        recommendation = "Minor regression - investigate before activating";
+      } else {
+        recommendation = "Performance is similar - review improvements and regressions before deciding";
+      }
+      return {
+        currentVersion: currentVersionId,
+        baselineVersion: baselineVersionId,
+        performanceChange,
+        improvements,
+        regressions,
+        recommendation
+      };
+    } catch (error) {
+      throw new Error(`Failed to compare versions: ${error.message}`);
+    }
+  }
+  /**
+   * Generate optimization suggestions for all versions of a prompt
+   */
+  async analyzeAllVersions(promptId, variant) {
+    try {
+      const versions = this.store.listVersions(promptId);
+      const analyses = [];
+      for (const version of versions) {
+        try {
+          const analysis = await this.analyze(version.id, variant);
+          analyses.push(analysis);
+        } catch (error) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: "prompt-optimizer",
+              subsystem: "prompts",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                error: error.message,
+                operation: "analyzeVersion",
+                versionId: version.id,
+                promptId
+              }
+            }
+          );
+        }
+      }
+      return analyses;
+    } catch (error) {
+      throw new Error(
+        `Failed to analyze versions for prompt ${promptId}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Recommend the best version based on performance
+   */
+  async recommendBestVersion(promptId, variant) {
+    try {
+      const analyses = await this.analyzeAllVersions(promptId, variant);
+      if (analyses.length === 0) {
+        throw new Error("No versions found for prompt");
+      }
+      const validAnalyses = analyses.filter((a) => a.performance.sampleSize >= 5);
+      if (validAnalyses.length === 0) {
+        throw new Error("No versions have sufficient performance data");
+      }
+      validAnalyses.sort((a, b) => b.overallScore - a.overallScore);
+      const best = validAnalyses[0];
+      if (!best) {
+        throw new Error("No best version found");
+      }
+      const rationale = this.generateRecommendationRationale(best);
+      const alternatives = validAnalyses.slice(1, 4).map((analysis) => ({
+        version: analysis.versionId,
+        reason: this.generateAlternativeReason(analysis, best)
+      }));
+      return {
+        recommendedVersion: best.versionId,
+        rationale,
+        alternatives
+      };
+    } catch (error) {
+      throw new Error(`Failed to recommend best version: ${error.message}`);
+    }
+  }
+  /**
+   * Close connections
+   */
+  close() {
+    this.store.close();
+    this.evaluator.close();
+  }
+  // Private helper methods
+  /**
+   * Generate optimization suggestions based on performance
+   */
+  generateSuggestions(version, performance) {
+    const suggestions = [];
+    if (performance.successRate < 0.7) {
+      suggestions.push({
+        promptId: version.promptId,
+        versionId: version.id,
+        type: "improve_clarity",
+        priority: "high",
+        description: "Low success rate indicates unclear or ambiguous instructions",
+        rationale: `Current success rate is ${(performance.successRate * 100).toFixed(1)}% (target: 70%+)`,
+        affectedMetrics: ["successRate"],
+        expectedImprovement: "Clearer instructions should increase success rate by 15-20%",
+        suggestedChanges: "Add explicit step-by-step instructions, clarify expected outcomes, provide examples",
+        estimatedEffort: "medium",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        generatedBy: "analyzer"
+      });
+    }
+    if (performance.avgCompleteness < 70) {
+      suggestions.push({
+        promptId: version.promptId,
+        versionId: version.id,
+        type: "add_context",
+        priority: "high",
+        description: "Low completeness suggests insufficient context or guidance",
+        rationale: `Average completeness is ${performance.avgCompleteness.toFixed(1)} (target: 70+)`,
+        affectedMetrics: ["avgCompleteness"],
+        expectedImprovement: "Better context should increase completeness by 10-15 points",
+        suggestedChanges: "Add more context about requirements, provide acceptance criteria, include edge cases",
+        estimatedEffort: "medium",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        generatedBy: "analyzer"
+      });
+    }
+    if (performance.stdDevCompleteness > 20) {
+      suggestions.push({
+        promptId: version.promptId,
+        versionId: version.id,
+        type: "improve_clarity",
+        priority: "medium",
+        description: "High variability in completeness indicates inconsistent interpretation",
+        rationale: `Standard deviation of ${performance.stdDevCompleteness.toFixed(1)} suggests prompt ambiguity`,
+        affectedMetrics: ["stdDevCompleteness"],
+        expectedImprovement: "More specific instructions should reduce variability by 30-40%",
+        suggestedChanges: "Make instructions more specific, reduce ambiguous terms, add constraints",
+        estimatedEffort: "low",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        generatedBy: "analyzer"
+      });
+    }
+    if (performance.avgDuration > 180) {
+      suggestions.push({
+        promptId: version.promptId,
+        versionId: version.id,
+        type: "split_prompt",
+        priority: "medium",
+        description: "Long execution time suggests prompt may be too complex",
+        rationale: `Average duration of ${performance.avgDuration.toFixed(0)}s exceeds 3 minutes`,
+        affectedMetrics: ["avgDuration"],
+        expectedImprovement: "Breaking into smaller tasks should reduce duration by 40-50%",
+        suggestedChanges: "Split into multiple focused prompts, reduce scope, prioritize critical features",
+        estimatedEffort: "high",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        generatedBy: "analyzer"
+      });
+    }
+    if (performance.avgCodeDeliveryRate < 0.8) {
+      suggestions.push({
+        promptId: version.promptId,
+        versionId: version.id,
+        type: "update_strategy",
+        priority: "medium",
+        description: "Low code delivery rate suggests implementation difficulties",
+        rationale: `Code delivery rate of ${(performance.avgCodeDeliveryRate * 100).toFixed(1)}% is below 80%`,
+        affectedMetrics: ["avgCodeDeliveryRate"],
+        expectedImprovement: "Better guidance should increase delivery rate by 10-15%",
+        suggestedChanges: "Add implementation hints, provide code patterns, clarify technical requirements",
+        estimatedEffort: "medium",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        generatedBy: "analyzer"
+      });
+    }
+    const wordCount = version.content.split(/\s+/).length;
+    if (wordCount < 50 && performance.avgCompleteness < 85) {
+      suggestions.push({
+        promptId: version.promptId,
+        versionId: version.id,
+        type: "add_context",
+        priority: "low",
+        description: "Short prompt may lack sufficient detail",
+        rationale: `Prompt has only ${wordCount} words - may need more context`,
+        affectedMetrics: ["avgCompleteness"],
+        expectedImprovement: "More detailed prompts typically improve completeness by 10-20%",
+        suggestedChanges: "Add background information, specify requirements, provide examples",
+        estimatedEffort: "low",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        generatedBy: "analyzer"
+      });
+    } else if (wordCount > 500) {
+      suggestions.push({
+        promptId: version.promptId,
+        versionId: version.id,
+        type: "remove_redundancy",
+        priority: "low",
+        description: "Long prompt may contain redundancy or unnecessary detail",
+        rationale: `Prompt has ${wordCount} words - may overwhelm or confuse`,
+        affectedMetrics: ["avgDuration", "successRate"],
+        expectedImprovement: "Concise prompts can improve clarity and reduce execution time",
+        suggestedChanges: "Remove redundant information, consolidate instructions, focus on essentials",
+        estimatedEffort: "medium",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        generatedBy: "analyzer"
+      });
+    }
+    return suggestions;
+  }
+  /**
+   * Identify strengths of a prompt based on performance
+   */
+  identifyStrengths(performance) {
+    const strengths = [];
+    if (performance.successRate >= 0.85) {
+      strengths.push(`Excellent success rate (${(performance.successRate * 100).toFixed(1)}%)`);
+    } else if (performance.successRate >= 0.7) {
+      strengths.push(`Good success rate (${(performance.successRate * 100).toFixed(1)}%)`);
+    }
+    if (performance.avgCompleteness >= 85) {
+      strengths.push(`High completeness (${performance.avgCompleteness.toFixed(1)})`);
+    } else if (performance.avgCompleteness >= 70) {
+      strengths.push(`Good completeness (${performance.avgCompleteness.toFixed(1)})`);
+    }
+    if (performance.avgCodeDeliveryRate >= 0.9) {
+      strengths.push(
+        `Excellent code delivery rate (${(performance.avgCodeDeliveryRate * 100).toFixed(1)}%)`
+      );
+    }
+    if (performance.avgDuration <= 60) {
+      strengths.push(`Fast execution (${performance.avgDuration.toFixed(0)}s avg)`);
+    } else if (performance.avgDuration <= 120) {
+      strengths.push(`Good execution time (${performance.avgDuration.toFixed(0)}s avg)`);
+    }
+    if (performance.stdDevCompleteness < 10) {
+      strengths.push("Consistent performance across executions");
+    }
+    if (strengths.length === 0) {
+      strengths.push("Meets basic quality standards");
+    }
+    return strengths;
+  }
+  /**
+   * Identify weaknesses of a prompt based on performance
+   */
+  identifyWeaknesses(performance) {
+    const weaknesses = [];
+    if (performance.successRate < 0.5) {
+      weaknesses.push(`Poor success rate (${(performance.successRate * 100).toFixed(1)}%)`);
+    } else if (performance.successRate < 0.7) {
+      weaknesses.push(`Below-target success rate (${(performance.successRate * 100).toFixed(1)}%)`);
+    }
+    if (performance.avgCompleteness < 60) {
+      weaknesses.push(`Low completeness (${performance.avgCompleteness.toFixed(1)})`);
+    } else if (performance.avgCompleteness < 70) {
+      weaknesses.push(`Below-target completeness (${performance.avgCompleteness.toFixed(1)})`);
+    }
+    if (performance.avgCodeDeliveryRate < 0.7) {
+      weaknesses.push(
+        `Low code delivery rate (${(performance.avgCodeDeliveryRate * 100).toFixed(1)}%)`
+      );
+    }
+    if (performance.avgDuration > 300) {
+      weaknesses.push(`Slow execution (${performance.avgDuration.toFixed(0)}s avg)`);
+    } else if (performance.avgDuration > 180) {
+      weaknesses.push(`Long execution time (${performance.avgDuration.toFixed(0)}s avg)`);
+    }
+    if (performance.stdDevCompleteness > 25) {
+      weaknesses.push("Inconsistent performance across executions");
+    }
+    if (weaknesses.length === 0) {
+      weaknesses.push("No significant weaknesses identified");
+    }
+    return weaknesses;
+  }
+  /**
+   * Calculate overall performance score (0-100)
+   */
+  calculateOverallScore(performance) {
+    const successScore = performance.successRate * 100 * 0.35;
+    const completenessScore = performance.avgCompleteness * 0.35;
+    const durationScore = Math.max(0, 1 - performance.avgDuration / 300) * 100 * 0.15;
+    const deliveryScore = performance.avgCodeDeliveryRate * 100 * 0.15;
+    return successScore + completenessScore + durationScore + deliveryScore;
+  }
+  /**
+   * Generate rationale for recommendation
+   */
+  generateRecommendationRationale(analysis) {
+    const parts = [];
+    parts.push(`Overall performance score: ${analysis.overallScore.toFixed(1)}/100`);
+    parts.push(`Success rate: ${(analysis.performance.successRate * 100).toFixed(1)}%`);
+    parts.push(`Average completeness: ${analysis.performance.avgCompleteness.toFixed(1)}`);
+    parts.push(`Sample size: ${analysis.performance.sampleSize} executions`);
+    if (analysis.strengths.length > 0) {
+      parts.push(`Key strengths: ${analysis.strengths.slice(0, 2).join(", ")}`);
+    }
+    return parts.join(". ");
+  }
+  /**
+   * Generate reason why version is an alternative
+   */
+  generateAlternativeReason(analysis, best) {
+    const scoreDiff = best.overallScore - analysis.overallScore;
+    if (scoreDiff < 5) {
+      return `Similar performance (score: ${analysis.overallScore.toFixed(1)}, only ${scoreDiff.toFixed(1)} points lower)`;
+    } else if (analysis.performance.avgDuration < best.performance.avgDuration) {
+      return `Faster execution (${analysis.performance.avgDuration.toFixed(0)}s vs ${best.performance.avgDuration.toFixed(0)}s)`;
+    } else if (analysis.performance.stdDevCompleteness < best.performance.stdDevCompleteness) {
+      return "More consistent results";
+    } else {
+      return `Lower score (${analysis.overallScore.toFixed(1)}) but may suit different use cases`;
+    }
+  }
+};
+
+// src/prompts/auto-tuner.ts
+var AutoTuningEngine = class {
+  manager;
+  evaluator;
+  optimizer;
+  options;
+  // Track activations and rollbacks
+  activationHistory = /* @__PURE__ */ new Map();
+  rollbackCounts = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.manager = new PromptManager(options);
+    this.evaluator = new PromptEvaluator(options);
+    this.optimizer = new PromptOptimizer(options);
+    this.options = {
+      poeticDir: resolvePoeticDirFromContext(options.poeticDir),
+      minSampleSize: options.minSampleSize ?? 10,
+      significanceThreshold: options.significanceThreshold ?? 10,
+      confidenceLevel: options.confidenceLevel ?? 0.8,
+      enableAutoActivation: options.enableAutoActivation ?? false,
+      maxRollbacks: options.maxRollbacks ?? 3
+    };
+  }
+  /**
+   * Analyze whether a prompt should be auto-tuned
+   */
+  async analyzeForActivation(promptId) {
+    try {
+      this.manager.getOrThrow(promptId);
+      const currentVersion = this.manager.getActiveVersionOrThrow(promptId);
+      const rollbackCount = this.rollbackCounts.get(promptId) || 0;
+      if (rollbackCount >= this.options.maxRollbacks) {
+        return {
+          shouldActivate: false,
+          candidateVersionId: null,
+          currentVersionId: currentVersion.id,
+          improvementPercentage: 0,
+          statisticalSignificance: 0,
+          confidence: 0,
+          safetyChecks: [
+            {
+              check: "rollback_limit",
+              passed: false,
+              message: `Maximum rollbacks (${this.options.maxRollbacks}) reached for this prompt`
+            }
+          ],
+          recommendation: "reject",
+          rationale: "Auto-tuning disabled due to excessive rollbacks",
+          decidedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const currentPerf = await this.evaluator.calculatePerformanceMetrics(currentVersion);
+      let bestVersionResult;
+      let candidateVersionId;
+      try {
+        bestVersionResult = await this.optimizer.recommendBestVersion(promptId);
+        candidateVersionId = bestVersionResult.recommendedVersion;
+      } catch (optimizerError) {
+        if (optimizerError.message.includes("No versions have sufficient performance data")) {
+          return {
+            shouldActivate: false,
+            candidateVersionId: null,
+            currentVersionId: currentVersion.id,
+            improvementPercentage: 0,
+            statisticalSignificance: 0,
+            confidence: 0,
+            safetyChecks: [
+              {
+                check: "sample_size",
+                passed: false,
+                message: "No versions have sufficient performance data (need at least 5 samples)"
+              }
+            ],
+            recommendation: "wait_for_data",
+            rationale: "Need more execution data before any version comparison",
+            decidedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        throw optimizerError;
+      }
+      if (currentPerf.sampleSize < this.options.minSampleSize) {
+        return {
+          shouldActivate: false,
+          candidateVersionId: null,
+          currentVersionId: currentVersion.id,
+          improvementPercentage: 0,
+          statisticalSignificance: 0,
+          confidence: 0,
+          safetyChecks: [
+            {
+              check: "sample_size",
+              passed: false,
+              message: `Insufficient data (${currentPerf.sampleSize}/${this.options.minSampleSize} samples)`
+            }
+          ],
+          recommendation: "wait_for_data",
+          rationale: "Need more execution data before considering activation",
+          decidedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      if (candidateVersionId === currentVersion.id) {
+        return {
+          shouldActivate: false,
+          candidateVersionId: null,
+          currentVersionId: currentVersion.id,
+          improvementPercentage: 0,
+          statisticalSignificance: 1,
+          confidence: 1,
+          safetyChecks: [
+            {
+              check: "current_is_best",
+              passed: true,
+              message: "Current version is already the best performer"
+            }
+          ],
+          recommendation: "monitor",
+          rationale: "Current version performs optimally",
+          decidedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const candidateVersion = this.manager.getVersion(promptId, candidateVersionId);
+      if (!candidateVersion) {
+        throw new Error(`Candidate version ${candidateVersionId} not found`);
+      }
+      const candidatePerf = await this.evaluator.calculatePerformanceMetrics(candidateVersion);
+      const currentScore = this.calculateScore(currentPerf);
+      const candidateScore = this.calculateScore(candidatePerf);
+      const improvementPercentage = (candidateScore - currentScore) / currentScore * 100;
+      const safetyChecks = await this.runSafetyChecks(
+        currentPerf,
+        candidatePerf,
+        improvementPercentage
+      );
+      const allChecksPassed = safetyChecks.every((c) => c.passed);
+      const statisticalSignificance = this.calculateStatisticalSignificance(
+        currentPerf,
+        candidatePerf
+      );
+      const confidence = this.calculateConfidence(
+        candidatePerf.sampleSize,
+        statisticalSignificance,
+        improvementPercentage
+      );
+      let shouldActivate = false;
+      let recommendation;
+      let rationale;
+      if (!allChecksPassed) {
+        recommendation = "reject";
+        rationale = `Safety checks failed: ${safetyChecks.filter((c) => !c.passed).map((c) => c.check).join(", ")}`;
+      } else if (candidatePerf.sampleSize < this.options.minSampleSize) {
+        recommendation = "wait_for_data";
+        rationale = "Candidate needs more testing before activation";
+      } else if (improvementPercentage < this.options.significanceThreshold) {
+        recommendation = "monitor";
+        rationale = `Improvement (${improvementPercentage.toFixed(1)}%) below threshold (${this.options.significanceThreshold}%)`;
+      } else if (confidence < this.options.confidenceLevel) {
+        recommendation = "monitor";
+        rationale = `Confidence (${confidence.toFixed(2)}) below threshold (${this.options.confidenceLevel})`;
+      } else if (this.options.enableAutoActivation) {
+        shouldActivate = true;
+        recommendation = "activate";
+        rationale = `Significant improvement (${improvementPercentage.toFixed(1)}%) with high confidence (${confidence.toFixed(2)})`;
+      } else {
+        recommendation = "monitor";
+        rationale = "Auto-activation disabled - manual review required";
+      }
+      return {
+        shouldActivate,
+        candidateVersionId,
+        currentVersionId: currentVersion.id,
+        improvementPercentage,
+        statisticalSignificance,
+        confidence,
+        safetyChecks,
+        recommendation,
+        rationale,
+        decidedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to analyze prompt for activation: ${error.message}`);
+    }
+  }
+  /**
+   * Execute activation if decision recommends it
+   */
+  async executeActivation(promptId, decision, options = {}) {
+    try {
+      if (!decision.shouldActivate || !decision.candidateVersionId) {
+        return null;
+      }
+      const currentVersion = this.manager.getVersion(promptId, decision.currentVersionId);
+      const candidateVersion = this.manager.getVersion(promptId, decision.candidateVersionId);
+      if (!currentVersion || !candidateVersion) {
+        throw new Error("Version not found");
+      }
+      const previousPerf = await this.evaluator.calculatePerformanceMetrics(currentVersion);
+      const expectedPerf = await this.evaluator.calculatePerformanceMetrics(candidateVersion);
+      await this.manager.activateVersion(decision.candidateVersionId, {
+        reason: decision.rationale,
+        skipSafetyChecks: options.skipSafetyChecks
+      });
+      const record = {
+        id: this.generateActivationId(),
+        promptId,
+        previousVersionId: decision.currentVersionId,
+        newVersionId: decision.candidateVersionId,
+        previousPerformance: previousPerf,
+        expectedPerformance: expectedPerf,
+        activatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: decision.rationale,
+        confidence: decision.confidence,
+        monitoringStatus: "active"
+      };
+      this.activationHistory.set(record.id, record);
+      return record;
+    } catch (error) {
+      throw new Error(`Failed to execute activation: ${error.message}`);
+    }
+  }
+  /**
+   * Monitor activated prompts for regressions
+   */
+  async monitorActivation(activationId, minSamplesSinceActivation = 5) {
+    try {
+      const record = this.activationHistory.get(activationId);
+      if (!record) {
+        throw new Error(`Activation record ${activationId} not found`);
+      }
+      if (record.monitoringStatus !== "active") {
+        return {
+          status: record.monitoringStatus === "validated" ? "validated" : "needs_rollback",
+          reason: `Already ${record.monitoringStatus}`,
+          shouldRollback: false
+        };
+      }
+      const currentVersion = this.manager.getVersion(record.promptId, record.newVersionId);
+      if (!currentVersion) {
+        throw new Error(`Version ${record.newVersionId} not found`);
+      }
+      const currentPerf = await this.evaluator.calculatePerformanceMetrics(currentVersion);
+      const samplesSinceActivation = currentPerf.sampleSize - record.expectedPerformance.sampleSize;
+      if (samplesSinceActivation < minSamplesSinceActivation) {
+        return {
+          status: "validating",
+          reason: `Still collecting data (${samplesSinceActivation}/${minSamplesSinceActivation} samples)`,
+          shouldRollback: false
+        };
+      }
+      const expectedScore = this.calculateScore(record.expectedPerformance);
+      const actualScore = this.calculateScore(currentPerf);
+      const performanceChange = (actualScore - expectedScore) / expectedScore * 100;
+      if (performanceChange < -15) {
+        return {
+          status: "needs_rollback",
+          reason: `Significant regression detected (${performanceChange.toFixed(1)}% worse than expected)`,
+          shouldRollback: true
+        };
+      } else if (performanceChange >= -5) {
+        record.monitoringStatus = "validated";
+        record.validatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.activationHistory.set(activationId, record);
+        return {
+          status: "validated",
+          reason: `Performance validated (${performanceChange >= 0 ? "+" : ""}${performanceChange.toFixed(1)}%)`,
+          shouldRollback: false
+        };
+      } else {
+        return {
+          status: "validating",
+          reason: `Minor deviation (${performanceChange.toFixed(1)}%), continuing to monitor`,
+          shouldRollback: false
+        };
+      }
+    } catch (error) {
+      throw new Error(`Failed to monitor activation: ${error.message}`);
+    }
+  }
+  /**
+   * Rollback an activation if it performed poorly
+   */
+  async rollbackActivation(activationId, reason) {
+    try {
+      const record = this.activationHistory.get(activationId);
+      if (!record) {
+        throw new Error(`Activation record ${activationId} not found`);
+      }
+      if (record.monitoringStatus === "rolled_back") {
+        throw new Error("Activation already rolled back");
+      }
+      await this.manager.activateVersion(record.previousVersionId);
+      record.monitoringStatus = "rolled_back";
+      record.rolledBackAt = (/* @__PURE__ */ new Date()).toISOString();
+      record.rollbackReason = reason;
+      this.activationHistory.set(activationId, record);
+      const currentCount = this.rollbackCounts.get(record.promptId) || 0;
+      this.rollbackCounts.set(record.promptId, currentCount + 1);
+    } catch (error) {
+      throw new Error(`Failed to rollback activation: ${error.message}`);
+    }
+  }
+  /**
+   * Get activation history for a prompt.
+   *
+   * Returns the in-memory ActivationRecord set (richer: includes previous
+   * performance, monitoring status). Falls back to the persisted
+   * activation_history table for activations that happened in earlier
+   * processes, surfacing them as minimal records.
+   */
+  getActivationHistory(promptId) {
+    const inMemory = Array.from(this.activationHistory.values()).filter(
+      (record) => record.promptId === promptId
+    );
+    const seen = new Set(inMemory.map((r) => r.id));
+    let persisted = [];
+    try {
+      const store = this.manager.getStore();
+      if (store && typeof store.listActivationHistory === "function") {
+        const rows = store.listActivationHistory(promptId);
+        const emptyMetrics = (versionId) => ({
+          promptId,
+          versionId,
+          totalExecutions: 0,
+          successfulExecutions: 0,
+          failedExecutions: 0,
+          successRate: 0,
+          avgCompleteness: 0,
+          avgCodeDeliveryRate: 0,
+          avgDuration: 0,
+          minCompleteness: 0,
+          maxCompleteness: 0,
+          stdDevCompleteness: 0,
+          sampleSize: 0,
+          firstExecutionAt: "",
+          lastExecutionAt: "",
+          calculatedAt: ""
+        });
+        persisted = rows.filter((row) => !seen.has(row.id)).map((row) => ({
+          id: row.id,
+          promptId: row.promptId,
+          previousVersionId: "",
+          newVersionId: row.versionId,
+          previousPerformance: emptyMetrics(row.versionId),
+          expectedPerformance: emptyMetrics(row.versionId),
+          activatedAt: row.activatedAt,
+          reason: row.reason ?? "",
+          confidence: 0,
+          monitoringStatus: "unknown"
+        }));
+      }
+    } catch {
+    }
+    return [...inMemory, ...persisted].sort((a, b) => b.activatedAt.localeCompare(a.activatedAt));
+  }
+  /**
+   * Close resources
+   */
+  close() {
+    this.manager.close();
+    this.evaluator.close();
+    this.optimizer.close();
+  }
+  // Private helper methods
+  calculateScore(metrics) {
+    const successScore = metrics.successRate * 100 * 0.35;
+    const completenessScore = metrics.avgCompleteness * 0.35;
+    const durationScore = Math.max(0, 1 - metrics.avgDuration / 300) * 100 * 0.15;
+    const deliveryScore = metrics.avgCodeDeliveryRate * 100 * 0.15;
+    return successScore + completenessScore + durationScore + deliveryScore;
+  }
+  async runSafetyChecks(currentPerf, candidatePerf, improvementPercentage) {
+    const checks = [];
+    checks.push({
+      check: "sample_size",
+      passed: candidatePerf.sampleSize >= this.options.minSampleSize,
+      message: `Candidate has ${candidatePerf.sampleSize} samples (min: ${this.options.minSampleSize})`
+    });
+    const successRateChange = (candidatePerf.successRate - currentPerf.successRate) * 100;
+    checks.push({
+      check: "success_rate",
+      passed: successRateChange >= -5,
+      // Allow up to 5% decrease
+      message: `Success rate change: ${successRateChange.toFixed(1)}%`
+    });
+    const completenessChange = candidatePerf.avgCompleteness - currentPerf.avgCompleteness;
+    checks.push({
+      check: "completeness",
+      passed: completenessChange >= -10,
+      // Allow up to 10 point decrease
+      message: `Completeness change: ${completenessChange.toFixed(1)} points`
+    });
+    checks.push({
+      check: "improvement_threshold",
+      passed: improvementPercentage >= this.options.significanceThreshold,
+      message: `Improvement: ${improvementPercentage.toFixed(1)}% (threshold: ${this.options.significanceThreshold}%)`
+    });
+    return checks;
+  }
+  calculateStatisticalSignificance(currentPerf, candidatePerf) {
+    const n1 = currentPerf.sampleSize;
+    const n2 = candidatePerf.sampleSize;
+    const sampleFactor = Math.min((n1 + n2) / 40, 1);
+    const avgStdDev = (currentPerf.stdDevCompleteness + candidatePerf.stdDevCompleteness) / 2;
+    const variabilityFactor = Math.max(0, 1 - avgStdDev / 50);
+    return (sampleFactor + variabilityFactor) / 2;
+  }
+  calculateConfidence(sampleSize, statisticalSignificance, improvementPercentage) {
+    const sampleFactor = Math.min(sampleSize / 25, 1) * 0.4;
+    const significanceFactor = statisticalSignificance * 0.3;
+    const improvementFactor = Math.min(improvementPercentage / 30, 1) * 0.3;
+    return sampleFactor + significanceFactor + improvementFactor;
+  }
+  generateActivationId() {
+    return `act-${Date.now()}-${randomBytes(8).toString("hex")}`;
+  }
+};
+
+// src/prompts/lineage-tracker.ts
+import fs from "fs";
+import path from "path";
+import Database from "better-sqlite3";
+var LineageTracker = class {
+  poeticDir;
+  promptsDir;
+  dbDir;
+  db;
+  debug;
+  constructor(options = {}) {
+    this.poeticDir = resolvePoeticDirFromContext(options.poeticDir);
+    this.promptsDir = path.join(this.poeticDir, "prompts");
+    this.dbDir = path.join(this.promptsDir, "db");
+    this.debug = options.debug || false;
+    this.ensureDirectories();
+    const dbPath = path.join(this.dbDir, "prompts.db");
+    this.db = new Database(dbPath);
+    this.db.defaultSafeIntegers(false);
+    this.initSchema();
+    if (this.debug) {
+      console.log("[LineageTracker] Initialized with database at:", dbPath);
+    }
+  }
+  /**
+   * Ensure all required directories exist
+   */
+  ensureDirectories() {
+    [this.promptsDir, this.dbDir].forEach((dir) => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    });
+  }
+  /**
+   * Initialize database schema for lineage tracking
+   */
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_lineage (
+        child_id TEXT PRIMARY KEY,
+        parent_id TEXT,
+        prompt_id TEXT NOT NULL,
+        cycle_id TEXT,
+        mutations TEXT NOT NULL,
+        depth INTEGER DEFAULT 0,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (child_id) REFERENCES prompt_versions(id) ON DELETE CASCADE,
+        FOREIGN KEY (parent_id) REFERENCES prompt_versions(id) ON DELETE SET NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_lineage_prompt ON prompt_lineage(prompt_id);
+      CREATE INDEX IF NOT EXISTS idx_lineage_parent ON prompt_lineage(parent_id);
+      CREATE INDEX IF NOT EXISTS idx_lineage_cycle ON prompt_lineage(cycle_id);
+      CREATE INDEX IF NOT EXISTS idx_lineage_depth ON prompt_lineage(depth);
+    `);
+  }
+  /**
+   * Track a mutation from parent to child version
+   *
+   * Creates a lineage entry recording the parent-child relationship,
+   * mutations applied, and optimization cycle.
+   *
+   * @param parentId - Parent version ID (null for root versions)
+   * @param childId - Child version ID
+   * @param mutations - Array of mutations applied
+   * @param cycleId - Optimization cycle identifier (optional)
+   * @throws Error if child already has lineage recorded
+   *
+   * @example
+   * ```typescript
+   * await tracker.trackMutation('v1.0.0', 'v1.1.0', [
+   *   {
+   *     type: 'add_context',
+   *     description: 'Added TypeScript specific examples',
+   *     impact: 0.7
+   *   }
+   * ], 'optimization-cycle-1');
+   * ```
+   */
+  async trackMutation(parentId, childId, mutations, cycleId) {
+    const existingStmt = this.db.prepare("SELECT child_id FROM prompt_lineage WHERE child_id = ?");
+    const existing = existingStmt.get(childId);
+    if (existing) {
+      throw new Error(`Lineage already exists for version "${childId}"`);
+    }
+    let depth = 0;
+    let promptId;
+    if (parentId) {
+      const parentLineage = this.getLineageEntry(parentId);
+      if (parentLineage) {
+        depth = parentLineage.depth + 1;
+        promptId = parentLineage.promptId;
+      } else {
+        const versionStmt = this.db.prepare("SELECT prompt_id FROM prompt_versions WHERE id = ?");
+        const parentVersion = versionStmt.get(parentId);
+        if (!parentVersion) {
+          throw new Error(`Parent version "${parentId}" not found`);
+        }
+        promptId = parentVersion.prompt_id;
+        depth = 1;
+      }
+    } else {
+      const versionStmt = this.db.prepare("SELECT prompt_id FROM prompt_versions WHERE id = ?");
+      const childVersion = versionStmt.get(childId);
+      if (!childVersion) {
+        throw new Error(`Child version "${childId}" not found`);
+      }
+      promptId = childVersion.prompt_id;
+      depth = 0;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const mutationsJson = JSON.stringify(mutations);
+    const stmt = this.db.prepare(`
+      INSERT INTO prompt_lineage (
+        child_id, parent_id, prompt_id, cycle_id, mutations, depth, created_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(childId, parentId, promptId, cycleId || null, mutationsJson, depth, now);
+    if (this.debug) {
+      console.log("[LineageTracker] Tracked mutation:", {
+        parentId,
+        childId,
+        promptId,
+        depth,
+        mutations: mutations.length
+      });
+    }
+    return {
+      childId,
+      parentId,
+      promptId,
+      cycleId: cycleId || null,
+      mutations,
+      depth,
+      createdAt: now
+    };
+  }
+  /**
+   * Get lineage for a prompt, ordered from newest to oldest
+   *
+   * Returns the full version history in chronological order (newest first),
+   * with each version's metadata from the prompt_versions table.
+   *
+   * @param promptId - Prompt ID to get lineage for
+   * @returns Array of versions ordered newest to oldest
+   *
+   * @example
+   * ```typescript
+   * const lineage = await tracker.getLineage('my-prompt');
+   * console.log('Latest version:', lineage[0]);
+   * console.log('Original version:', lineage[lineage.length - 1]);
+   * ```
+   */
+  async getLineage(promptId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM prompt_versions
+      WHERE prompt_id = ?
+      ORDER BY created_at DESC
+    `);
+    const rows = stmt.all(promptId);
+    return rows.map((row) => this.rowToVersion(row, promptId));
+  }
+  /**
+   * Get evolution tree for a prompt
+   *
+   * Builds a complete tree structure showing all versions and their
+   * parent-child relationships, with mutation information.
+   *
+   * @param promptId - Prompt ID to build tree for
+   * @returns Evolution tree structure
+   * @throws Error if no versions exist for the prompt
+   *
+   * @example
+   * ```typescript
+   * const tree = await tracker.getEvolutionTree('my-prompt');
+   * console.log('Root version:', tree.rootId);
+   * console.log('Total versions:', tree.totalVersions);
+   * console.log('Max depth:', tree.maxDepth);
+   *
+   * // Walk the tree
+   * const root = tree.nodes.get(tree.rootId);
+   * root?.children.forEach(childId => {
+   *   const child = tree.nodes.get(childId);
+   *   console.log('Child mutations:', child?.mutations);
+   * });
+   * ```
+   */
+  async getEvolutionTree(promptId) {
+    const lineageStmt = this.db.prepare(`
+      SELECT * FROM prompt_lineage
+      WHERE prompt_id = ?
+      ORDER BY depth ASC, created_at ASC
+    `);
+    const lineageRows = lineageStmt.all(promptId);
+    if (lineageRows.length === 0) {
+      throw new Error(`No lineage found for prompt "${promptId}"`);
+    }
+    const versionsStmt = this.db.prepare(`
+      SELECT * FROM prompt_versions
+      WHERE prompt_id = ?
+    `);
+    const versionRows = versionsStmt.all(promptId);
+    const versionMap = /* @__PURE__ */ new Map();
+    let activeVersionId = null;
+    versionRows.forEach((row) => {
+      const version = this.rowToVersion(row, promptId);
+      versionMap.set(row.id, version);
+      if (row.is_active === 1) {
+        activeVersionId = row.id;
+      }
+    });
+    const nodes = /* @__PURE__ */ new Map();
+    let rootId = null;
+    let maxDepth = 0;
+    lineageRows.forEach((row) => {
+      const mutations = parseJsonWithContext(
+        row.mutations,
+        "prompt mutations for evolution tree"
+      );
+      const version = versionMap.get(row.child_id) || null;
+      const isActive = row.child_id === activeVersionId;
+      const node = {
+        versionId: row.child_id,
+        version,
+        parentId: row.parent_id,
+        children: [],
+        mutations,
+        cycleId: row.cycle_id,
+        depth: row.depth,
+        isActive,
+        createdAt: row.created_at
+      };
+      nodes.set(row.child_id, node);
+      if (row.depth === 0 && !row.parent_id) {
+        rootId = row.child_id;
+      }
+      maxDepth = Math.max(maxDepth, row.depth);
+    });
+    nodes.forEach((node) => {
+      if (node.parentId) {
+        const parent = nodes.get(node.parentId);
+        if (parent) {
+          parent.children.push(node.versionId);
+        }
+      }
+    });
+    if (!rootId) {
+      throw new Error(`No root version found for prompt "${promptId}"`);
+    }
+    return {
+      rootId,
+      nodes,
+      maxDepth,
+      totalVersions: nodes.size,
+      activeVersionId
+    };
+  }
+  /**
+   * Rollback prompt to a previous version
+   *
+   * Activates the target version, deactivating the current active version.
+   * Does not delete any versions - all history is preserved.
+   *
+   * @param promptId - Prompt ID to rollback
+   * @param targetVersionId - Version ID to activate
+   * @throws Error if version doesn't exist or doesn't belong to prompt
+   *
+   * @example
+   * ```typescript
+   * // Rollback to previous version
+   * await tracker.rollback('my-prompt', 'v1.0.0');
+   * ```
+   */
+  async rollback(promptId, targetVersionId) {
+    const versionStmt = this.db.prepare(
+      "SELECT prompt_id, is_active FROM prompt_versions WHERE id = ?"
+    );
+    const version = versionStmt.get(targetVersionId);
+    if (!version) {
+      throw new Error(`Version "${targetVersionId}" not found`);
+    }
+    if (version.prompt_id !== promptId) {
+      throw new Error(`Version "${targetVersionId}" does not belong to prompt "${promptId}"`);
+    }
+    if (version.is_active === 1) {
+      if (this.debug) {
+        console.log("[LineageTracker] Version already active, no rollback needed");
+      }
+      return;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const deactivateStmt = this.db.prepare(`
+      UPDATE prompt_versions
+      SET is_active = 0, deactivated_at = ?
+      WHERE prompt_id = ? AND is_active = 1
+    `);
+    const activateStmt = this.db.prepare(`
+      UPDATE prompt_versions
+      SET is_active = 1, activated_at = ?
+      WHERE id = ?
+    `);
+    const updatePromptStmt = this.db.prepare(`
+      UPDATE prompts
+      SET current_version = ?, updated_at = ?
+      WHERE id = ?
+    `);
+    const transaction = this.db.transaction(() => {
+      deactivateStmt.run(now, promptId);
+      activateStmt.run(now, targetVersionId);
+      updatePromptStmt.run(targetVersionId, now, promptId);
+    });
+    transaction();
+    if (this.debug) {
+      console.log("[LineageTracker] Rolled back prompt to version:", targetVersionId);
+    }
+  }
+  /**
+   * Get lineage entry for a specific version
+   *
+   * @param versionId - Version ID to get lineage for
+   * @returns Lineage entry or null if not found
+   */
+  getLineageEntry(versionId) {
+    const stmt = this.db.prepare("SELECT * FROM prompt_lineage WHERE child_id = ?");
+    const row = stmt.get(versionId);
+    if (!row) {
+      return null;
+    }
+    return this.rowToLineageEntry(row);
+  }
+  /**
+   * Get all children of a version
+   *
+   * @param parentId - Parent version ID
+   * @returns Array of child lineage entries
+   */
+  getChildren(parentId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM prompt_lineage
+      WHERE parent_id = ?
+      ORDER BY created_at ASC
+    `);
+    const rows = stmt.all(parentId);
+    return rows.map((row) => this.rowToLineageEntry(row));
+  }
+  /**
+   * Get all versions in an optimization cycle
+   *
+   * @param cycleId - Optimization cycle ID
+   * @returns Array of lineage entries in the cycle
+   */
+  getCycleVersions(cycleId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM prompt_lineage
+      WHERE cycle_id = ?
+      ORDER BY depth ASC, created_at ASC
+    `);
+    const rows = stmt.all(cycleId);
+    return rows.map((row) => this.rowToLineageEntry(row));
+  }
+  /**
+   * Get mutation statistics for a prompt
+   *
+   * Analyzes all mutations across the lineage to provide insights
+   * into evolution patterns.
+   *
+   * @param promptId - Prompt ID to analyze
+   * @returns Mutation statistics
+   */
+  getMutationStats(promptId) {
+    const stmt = this.db.prepare("SELECT mutations FROM prompt_lineage WHERE prompt_id = ?");
+    const rows = stmt.all(promptId);
+    let totalMutations = 0;
+    const mutationsByType = {};
+    let totalImpact = 0;
+    let impactCount = 0;
+    rows.forEach((row) => {
+      const mutations = parseJsonWithContext(
+        row.mutations,
+        "prompt mutations for stats"
+      );
+      totalMutations += mutations.length;
+      mutations.forEach((mutation) => {
+        mutationsByType[mutation.type] = (mutationsByType[mutation.type] || 0) + 1;
+        if (mutation.impact !== void 0) {
+          totalImpact += mutation.impact;
+          impactCount++;
+        }
+      });
+    });
+    return {
+      totalMutations,
+      mutationsByType,
+      avgMutationsPerVersion: rows.length > 0 ? totalMutations / rows.length : 0,
+      avgImpact: impactCount > 0 ? totalImpact / impactCount : 0
+    };
+  }
+  /**
+   * Close database connection
+   *
+   * Should be called when done using the tracker to release resources.
+   *
+   * @example
+   * ```typescript
+   * const tracker = new LineageTracker();
+   * // ... use tracker ...
+   * tracker.close();
+   * ```
+   */
+  close() {
+    this.db.close();
+    if (this.debug) {
+      console.log("[LineageTracker] Closed database connection");
+    }
+  }
+  // Private helper methods
+  /**
+   * Convert database row to PromptVersion
+   */
+  rowToVersion(row, promptId) {
+    return {
+      id: row.id,
+      promptId,
+      content: "",
+      // Empty - fetch from PromptStore if needed
+      contentHash: row.content_hash,
+      changelog: row.changelog || void 0,
+      author: row.author || void 0,
+      isActive: row.is_active === 1,
+      isGenerated: row.is_generated === 1,
+      generationModel: row.generation_model || void 0,
+      generationPrompt: row.generation_prompt || void 0,
+      createdAt: row.created_at,
+      activatedAt: row.activated_at || void 0,
+      deactivatedAt: row.deactivated_at || void 0
+    };
+  }
+  /**
+   * Convert database row to LineageEntry
+   */
+  rowToLineageEntry(row) {
+    const mutations = parseJsonWithContext(
+      row.mutations,
+      "prompt mutations for lineage entry"
+    );
+    return {
+      childId: row.child_id,
+      parentId: row.parent_id,
+      promptId: row.prompt_id,
+      cycleId: row.cycle_id,
+      mutations,
+      depth: row.depth,
+      createdAt: row.created_at
+    };
+  }
+};
+
+// src/prompts/provider-tracker.ts
+import fs2 from "fs";
+import path2 from "path";
+import Database2 from "better-sqlite3";
+
+// src/core/evaluation/scoring-telemetry-event.ts
+function createTelemetryEvent(eventType, data, metadata) {
+  return {
+    eventType,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data,
+    metadata
+  };
+}
+
+// src/core/evaluation/unified-scoring.ts
+function clamp01(x) {
+  if (!Number.isFinite(x)) return 0;
+  return Math.max(0, Math.min(1, x));
+}
+function clamp100(x) {
+  if (!Number.isFinite(x)) return 0;
+  return Math.max(0, Math.min(100, x));
+}
+function aggregateScores(scores, options = {}) {
+  const cfg = options.criteriaConfig ?? DEFAULT_EVALUATION_CRITERIA;
+  const active = getActiveCriteria(cfg);
+  const reasons = [];
+  let disqualified = false;
+  for (const [key, criterion] of Object.entries(active)) {
+    const s = clamp100(scores[key] ?? 0);
+    if (s < criterion.minThreshold) {
+      reasons.push(`${key} below threshold: ${s.toFixed(1)} < ${criterion.minThreshold}`);
+      if (options.requireAllThresholds ?? cfg.defaultStrategy.requireAllThresholds) {
+        disqualified = true;
+      }
+    }
+  }
+  const algo = options.baseAlgorithm ?? "harmonic-mean";
+  const entries = Object.entries(active).map(([key, c]) => ({
+    key,
+    weight: clamp01(c.weight),
+    value: clamp01((scores[key] ?? 0) / 100)
+  }));
+  if (isTelemetryDebug()) {
+    try {
+      const event = createTelemetryEvent("scoring.aggregate_entries", {
+        entries: entries.map((e) => ({ key: e.key, weight: e.weight, value: e.value * 100 })),
+        algorithm: algo
+      });
+      if (typeof process !== "undefined" && process.stderr) {
+        process.stderr.write(`${JSON.stringify(event)}
+`);
+      }
+    } catch {
+    }
+  }
+  const weightSum = entries.reduce((s, e) => s + e.weight, 0) || 1;
+  const normalizedEntries = entries.map((entry) => ({
+    ...entry,
+    weight: entry.weight / weightSum
+  }));
+  let value01 = 0;
+  if (algo === "weighted-sum") {
+    value01 = normalizedEntries.reduce((s, e) => s + e.value * e.weight, 0);
+  } else {
+    const eps = 1e-6;
+    const numerator = normalizedEntries.reduce((s, e) => s + e.weight, 0);
+    const denominator = normalizedEntries.reduce(
+      (s, e) => s + e.weight / Math.max(e.value, eps),
+      0
+    );
+    value01 = numerator / Math.max(denominator, eps);
+  }
+  const score = clamp100(value01 * 100);
+  const minOverall = options.minOverallScore ?? cfg.defaultStrategy.minOverallScore;
+  if (score < minOverall) {
+    reasons.push(`overall score below minimum: ${score.toFixed(1)} < ${minOverall}`);
+    disqualified = true;
+  }
+  return { score, disqualified, reasons };
+}
+function buildCriterionScores(partial, criteriaConfig = DEFAULT_EVALUATION_CRITERIA, fallbackValue = JUDGE_DEFAULTS.CRITERION_FALLBACK) {
+  const active = getActiveCriteria(criteriaConfig);
+  const out = {};
+  const defaulted = [];
+  for (const key of Object.keys(active)) {
+    const v = partial[key];
+    if (typeof v === "number" && Number.isFinite(v)) {
+      out[key] = clamp100(v);
+    } else {
+      out[key] = clamp100(fallbackValue);
+      defaulted.push(key);
+    }
+  }
+  if (defaulted.length > 0 && isTelemetryDebug()) {
+    try {
+      const event = createTelemetryEvent("scoring.build_defaults", {
+        fallbackValue,
+        defaulted
+      });
+      if (typeof process !== "undefined" && process.stderr) {
+        process.stderr.write(`${JSON.stringify(event)}
+`);
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/prompts/provider-tracker.ts
+var ProviderTracker = class {
+  poeticDir;
+  dbPath;
+  db;
+  options;
+  // Valid providers, derived from the registry so newly registered or
+  // user-defined providers are tracked rather than silently rejected [B7].
+  // Resolved once in the constructor from ProviderRegistry.getAllProviderIds().
+  validProviders;
+  validProviderSet;
+  constructor(options = {}) {
+    this.poeticDir = resolvePoeticDirFromContext(options.poeticDir);
+    const dbDir = path2.join(this.poeticDir, "prompts", "db");
+    if (!fs2.existsSync(dbDir)) {
+      fs2.mkdirSync(dbDir, { recursive: true });
+    }
+    this.dbPath = path2.join(dbDir, "provider-performance.db");
+    this.db = new Database2(this.dbPath);
+    let registeredProviders = [];
+    try {
+      registeredProviders = ProviderRegistry.getAllProviderIds();
+    } catch {
+      registeredProviders = [];
+    }
+    this.validProviders = registeredProviders;
+    this.validProviderSet = new Set(registeredProviders);
+    this.options = {
+      poeticDir: this.poeticDir,
+      minSampleSize: options.minSampleSize ?? 5,
+      confidenceLevel: options.confidenceLevel ?? 0.95,
+      explorationRate: options.explorationRate ?? 0.1,
+      enablePrediction: options.enablePrediction ?? true
+    };
+    this.initSchema();
+  }
+  /**
+   * Initialize database schema
+   */
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS provider_executions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        provider TEXT NOT NULL,
+        prompt_id TEXT NOT NULL,
+        version_id TEXT NOT NULL,
+        variant TEXT,
+
+        -- Performance metrics
+        success INTEGER NOT NULL,
+        completeness REAL NOT NULL,
+        duration REAL NOT NULL,
+        tokens_used INTEGER,
+        code_delivered INTEGER NOT NULL,
+
+        -- Quality metrics
+        error_count INTEGER DEFAULT 0,
+        warning_count INTEGER DEFAULT 0,
+        tests_passed INTEGER,
+        tests_failed INTEGER,
+
+        -- Context
+        task_complexity TEXT,
+        codebase_size TEXT,
+        timestamp TEXT NOT NULL,
+
+        -- Metadata
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_provider_prompt
+        ON provider_executions(provider, prompt_id, version_id);
+      CREATE INDEX IF NOT EXISTS idx_provider_timestamp
+        ON provider_executions(provider, timestamp DESC);
+      CREATE INDEX IF NOT EXISTS idx_prompt_provider
+        ON provider_executions(prompt_id, provider);
+
+      -- Aggregated statistics cache for performance
+      CREATE TABLE IF NOT EXISTS provider_stats_cache (
+        provider TEXT NOT NULL,
+        prompt_id TEXT NOT NULL,
+        version_id TEXT NOT NULL,
+        variant TEXT NOT NULL DEFAULT '',
+
+        -- Cached metrics
+        total_executions INTEGER NOT NULL,
+        success_rate REAL NOT NULL,
+        avg_completeness REAL NOT NULL,
+        avg_duration REAL NOT NULL,
+        std_dev_completeness REAL NOT NULL,
+        median_completeness REAL NOT NULL,
+
+        -- Trend analysis
+        performance_trend TEXT NOT NULL,
+        trend_strength REAL NOT NULL,
+
+        -- Metadata
+        calculated_at TEXT NOT NULL,
+        sample_size INTEGER NOT NULL,
+
+        PRIMARY KEY (provider, prompt_id, version_id, variant)
+      );
+
+      -- Provider affinity scores for contextual recommendations
+      CREATE TABLE IF NOT EXISTS provider_affinity (
+        provider TEXT NOT NULL,
+        prompt_id TEXT NOT NULL,
+        context_hash TEXT NOT NULL,
+        affinity_score REAL NOT NULL,
+        context_factors TEXT NOT NULL,
+        calculated_at TEXT NOT NULL,
+
+        PRIMARY KEY (provider, prompt_id, context_hash)
+      );
+    `);
+  }
+  /**
+   * Track a provider execution
+   *
+   * Records performance metrics for a specific provider execution. This is the
+   * primary method for feeding data into the analytics system.
+   *
+   * @param metrics Execution metrics to track
+   * @throws Error if provider is invalid or metrics are incomplete
+   *
+   * @example
+   * ```typescript
+   * await tracker.trackProviderExecution({
+   *   provider: 'claude',
+   *   promptId: 'typescript-expert',
+   *   versionId: 'v1.2.0',
+   *   variant: 'conservative',
+   *   success: true,
+   *   completeness: 95,
+   *   duration: 45.2,
+   *   codeDelivered: true,
+   *   errorCount: 0,
+   *   timestamp: new Date().toISOString()
+   * });
+   * ```
+   */
+  async trackProviderExecution(metrics) {
+    try {
+      if (!this.isValidProvider(metrics.provider)) {
+        throw new Error(
+          `Invalid provider: ${metrics.provider}. Must be one of: ${this.validProviders.join(", ")}`
+        );
+      }
+      if (!metrics.promptId || !metrics.versionId) {
+        throw new Error("promptId and versionId are required");
+      }
+      if (metrics.completeness < 0 || metrics.completeness > 100) {
+        throw new Error("completeness must be between 0 and 100");
+      }
+      if (metrics.duration < 0) {
+        throw new Error("duration must be non-negative");
+      }
+      const stmt = this.db.prepare(`
+        INSERT INTO provider_executions (
+          provider, prompt_id, version_id, variant,
+          success, completeness, duration, tokens_used, code_delivered,
+          error_count, warning_count, tests_passed, tests_failed,
+          task_complexity, codebase_size, timestamp
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(
+        metrics.provider,
+        metrics.promptId,
+        metrics.versionId,
+        metrics.variant || null,
+        metrics.success ? 1 : 0,
+        metrics.completeness,
+        metrics.duration,
+        metrics.tokensUsed || null,
+        metrics.codeDelivered ? 1 : 0,
+        metrics.errorCount || 0,
+        metrics.warningCount || 0,
+        metrics.testsPassed || null,
+        metrics.testsFailed || null,
+        metrics.taskComplexity || null,
+        metrics.codebaseSize || null,
+        metrics.timestamp
+      );
+      await this.invalidateCache(
+        metrics.provider,
+        metrics.promptId,
+        metrics.versionId,
+        metrics.variant
+      );
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to track provider execution: ${error}`);
+    }
+  }
+  /**
+   * Get provider performance metrics for a specific prompt
+   *
+   * Retrieves comprehensive performance statistics with Bayesian confidence intervals,
+   * trend analysis, and statistical measures.
+   *
+   * @param provider AI provider to analyze
+   * @param promptId Prompt identifier
+   * @param versionId Optional version filter
+   * @param variant Optional variant filter
+   * @returns Performance metrics or null if insufficient data
+   *
+   * @example
+   * ```typescript
+   * const performance = await tracker.getProviderPerformance(
+   *   'claude',
+   *   'typescript-expert',
+   *   'v1.2.0'
+   * );
+   * console.log(`Success rate: ${performance.successRate * 100}%`);
+   * console.log(`95% CI: [${performance.successRateCI[0]}, ${performance.successRateCI[1]}]`);
+   * ```
+   */
+  async getProviderPerformance(provider, promptId, versionId, variant) {
+    try {
+      if (!this.isValidProvider(provider)) {
+        throw new Error(`Invalid provider: ${provider}`);
+      }
+      const cached = this.getCachedPerformance(provider, promptId, versionId, variant);
+      if (cached && this.isCacheFresh(cached.calculatedAt)) {
+        return cached;
+      }
+      let query = `
+        SELECT * FROM provider_executions
+        WHERE provider = ? AND prompt_id = ?
+      `;
+      const params = [provider, promptId];
+      if (versionId) {
+        query += " AND version_id = ?";
+        params.push(versionId);
+      }
+      if (variant) {
+        query += " AND variant = ?";
+        params.push(variant);
+      }
+      query += " ORDER BY timestamp DESC";
+      const stmt = this.db.prepare(query);
+      const executions = stmt.all(...params);
+      if (executions.length < this.options.minSampleSize) {
+        return null;
+      }
+      const performance = this.calculatePerformanceMetrics(
+        executions,
+        provider,
+        promptId,
+        versionId,
+        variant
+      );
+      this.cachePerformance(performance);
+      return performance;
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to get provider performance: ${error}`);
+    }
+  }
+  /**
+   * Get comprehensive statistics for a provider
+   *
+   * Aggregates performance across all prompts to provide overall provider characteristics.
+   *
+   * @param provider AI provider to analyze
+   * @returns Provider statistics
+   *
+   * @example
+   * ```typescript
+   * const stats = await tracker.getProviderStats('claude');
+   * console.log(`Reliability: ${stats.reliability * 100}%`);
+   * console.log(`Specializations: ${stats.specialization.join(', ')}`);
+   * ```
+   */
+  async getProviderStats(provider) {
+    try {
+      if (!this.isValidProvider(provider)) {
+        throw new Error(`Invalid provider: ${provider}`);
+      }
+      const stmt = this.db.prepare(`
+        SELECT
+          COUNT(DISTINCT prompt_id) as total_prompts,
+          COUNT(*) as total_executions,
+          AVG(success) as avg_success_rate,
+          AVG(completeness) as avg_completeness,
+          AVG(duration) as avg_duration,
+          AVG(tokens_used) as avg_tokens
+        FROM provider_executions
+        WHERE provider = ?
+      `);
+      const aggregates = stmt.get(provider);
+      if (aggregates.total_executions === 0) {
+        return this.emptyProviderStats(provider);
+      }
+      const reliability = this.calculateReliabilityScore(provider);
+      const speed = this.calculateSpeedScore(provider);
+      const quality = this.calculateQualityScore(provider);
+      const { bestPromptId, worstPromptId } = this.findBestWorstPrompts(provider);
+      const specialization = this.identifySpecializations(provider);
+      return {
+        provider,
+        totalPrompts: aggregates.total_prompts,
+        totalExecutions: aggregates.total_executions,
+        avgSuccessRate: aggregates.avg_success_rate,
+        avgCompleteness: aggregates.avg_completeness,
+        avgDuration: aggregates.avg_duration,
+        avgTokenEfficiency: aggregates.avg_tokens ? 1 / aggregates.avg_tokens : void 0,
+        reliability,
+        speed,
+        quality,
+        bestPromptId,
+        worstPromptId,
+        specialization,
+        calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to get provider stats: ${error}`);
+    }
+  }
+  /**
+   * Get best prompts for a provider
+   *
+   * Uses multi-armed bandit algorithm (Upper Confidence Bound) to balance
+   * exploration vs exploitation when recommending prompts.
+   *
+   * @param provider AI provider
+   * @param limit Maximum number of prompts to return
+   * @returns Array of prompt IDs ranked by UCB score
+   *
+   * @example
+   * ```typescript
+   * const bestPrompts = await tracker.getBestPromptsForProvider('claude', 5);
+   * console.log('Top 5 prompts:', bestPrompts);
+   * ```
+   */
+  async getBestPromptsForProvider(provider, limit = 10) {
+    try {
+      if (!this.isValidProvider(provider)) {
+        throw new Error(`Invalid provider: ${provider}`);
+      }
+      const stmt = this.db.prepare(`
+        SELECT
+          prompt_id,
+          COUNT(*) as executions,
+          AVG(success) as success_rate,
+          AVG(completeness) as avg_completeness
+        FROM provider_executions
+        WHERE provider = ?
+        GROUP BY prompt_id
+        HAVING executions >= ?
+      `);
+      const prompts = stmt.all(provider, this.options.minSampleSize);
+      if (prompts.length === 0) {
+        return [];
+      }
+      const totalExecutions = prompts.reduce((sum, p) => sum + p.executions, 0);
+      const scored = prompts.map((p) => {
+        const exploitationScore = p.success_rate * 0.5 + p.avg_completeness / 100 * 0.5;
+        const explorationBonus = Math.sqrt(2 * Math.log(totalExecutions) / p.executions) * this.options.explorationRate;
+        const ucbScore = exploitationScore + explorationBonus;
+        return {
+          promptId: p.prompt_id,
+          ucbScore,
+          executions: p.executions
+        };
+      });
+      scored.sort((a, b) => b.ucbScore - a.ucbScore);
+      return scored.slice(0, limit).map((s) => s.promptId);
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to get best prompts: ${error}`);
+    }
+  }
+  /**
+   * Get provider recommendations for a prompt
+   *
+   * Uses Bayesian inference to recommend the best provider(s) with confidence scores.
+   * Considers success rate, completeness, and duration with uncertainty quantification.
+   *
+   * @param promptId Prompt identifier
+   * @param versionId Optional version filter
+   * @returns Ranked provider recommendations
+   *
+   * @example
+   * ```typescript
+   * const recommendations = await tracker.getProviderRecommendations('typescript-expert');
+   * const best = recommendations[0];
+   * console.log(`Recommend ${best.provider} with ${best.confidence * 100}% confidence`);
+   * ```
+   */
+  async getProviderRecommendations(promptId, versionId) {
+    try {
+      const recommendations = [];
+      for (const provider of this.validProviders) {
+        const performance = await this.getProviderPerformance(provider, promptId, versionId);
+        if (!performance || performance.sampleSize < this.options.minSampleSize) {
+          continue;
+        }
+        const confidence = this.calculateBayesianConfidence(
+          performance.successfulExecutions,
+          performance.totalExecutions
+        );
+        const reasoning = this.generateRecommendationReasoning(performance);
+        recommendations.push({
+          provider,
+          confidence,
+          expectedSuccess: performance.successRate,
+          expectedCompleteness: performance.avgCompleteness,
+          expectedDuration: performance.avgDuration,
+          reasoning,
+          rank: 0
+          // Will be set after sorting
+        });
+      }
+      recommendations.sort((a, b) => {
+        const scoreA = a.expectedSuccess * (a.expectedCompleteness / 100) * a.confidence;
+        const scoreB = b.expectedSuccess * (b.expectedCompleteness / 100) * b.confidence;
+        return scoreB - scoreA;
+      });
+      recommendations.forEach((rec, index) => {
+        rec.rank = index + 1;
+      });
+      return recommendations;
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to get provider recommendations: ${error}`);
+    }
+  }
+  /**
+   * Get optimization insights for a provider
+   *
+   * Analyzes performance patterns to identify strengths, weaknesses, opportunities,
+   * and threats (SWOT analysis) for a specific provider and prompt combination.
+   *
+   * @param provider AI provider
+   * @param promptId Prompt identifier
+   * @returns Array of actionable insights
+   *
+   * @example
+   * ```typescript
+   * const insights = await tracker.getProviderOptimizationInsights('claude', 'typescript-expert');
+   * insights.forEach(insight => {
+   *   console.log(`[${insight.priority}] ${insight.type}: ${insight.description}`);
+   * });
+   * ```
+   */
+  async getProviderOptimizationInsights(provider, promptId) {
+    try {
+      const insights = [];
+      const performance = await this.getProviderPerformance(provider, promptId);
+      if (!performance) {
+        return insights;
+      }
+      if (performance.successRate >= 0.9) {
+        insights.push({
+          provider,
+          promptId,
+          type: "strength",
+          priority: "low",
+          description: "Excellent success rate",
+          impact: `${(performance.successRate * 100).toFixed(1)}% success rate indicates high reliability`,
+          recommendation: "Consider using this provider as primary for this prompt",
+          confidence: 0.9
+        });
+      } else if (performance.successRate < 0.7) {
+        insights.push({
+          provider,
+          promptId,
+          type: "weakness",
+          priority: "high",
+          description: "Low success rate",
+          impact: `${(performance.successRate * 100).toFixed(1)}% success rate indicates reliability issues`,
+          recommendation: "Review prompt structure, consider alternative provider, or add error handling",
+          confidence: 0.85
+        });
+      }
+      if (performance.stdDevCompleteness > 20) {
+        insights.push({
+          provider,
+          promptId,
+          type: "weakness",
+          priority: "medium",
+          description: "Inconsistent output quality",
+          impact: `High variance (\u03C3=${performance.stdDevCompleteness.toFixed(1)}) in completeness scores`,
+          recommendation: "Add more specific instructions or examples to improve consistency",
+          confidence: 0.75
+        });
+      } else if (performance.stdDevCompleteness < 10) {
+        insights.push({
+          provider,
+          promptId,
+          type: "strength",
+          priority: "low",
+          description: "Highly consistent performance",
+          impact: `Low variance (\u03C3=${performance.stdDevCompleteness.toFixed(1)}) indicates predictable outputs`,
+          recommendation: "This provider-prompt combination is production-ready",
+          confidence: 0.85
+        });
+      }
+      if (performance.performanceTrend === "declining") {
+        insights.push({
+          provider,
+          promptId,
+          type: "threat",
+          priority: performance.trendStrength > 0.7 ? "critical" : "medium",
+          description: "Performance degradation detected",
+          impact: "Quality or reliability is declining over time",
+          recommendation: "Investigate recent changes, consider prompt refresh or provider update",
+          confidence: performance.trendStrength
+        });
+      } else if (performance.performanceTrend === "improving") {
+        insights.push({
+          provider,
+          promptId,
+          type: "opportunity",
+          priority: "low",
+          description: "Performance improving over time",
+          impact: "Quality or reliability is increasing",
+          recommendation: "Continue current approach, consider expanding usage",
+          confidence: performance.trendStrength
+        });
+      }
+      if (performance.avgDuration > 180) {
+        insights.push({
+          provider,
+          promptId,
+          type: "weakness",
+          priority: "medium",
+          description: "Slow execution time",
+          impact: `Average duration of ${performance.avgDuration.toFixed(0)}s may impact user experience`,
+          recommendation: "Consider optimizing prompt length, task scope, or using faster provider",
+          confidence: 0.8
+        });
+      } else if (performance.avgDuration < 60) {
+        insights.push({
+          provider,
+          promptId,
+          type: "strength",
+          priority: "low",
+          description: "Fast execution time",
+          impact: `Average duration of ${performance.avgDuration.toFixed(0)}s enables quick iterations`,
+          recommendation: "Consider this provider for time-sensitive tasks",
+          confidence: 0.85
+        });
+      }
+      const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      insights.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+      return insights;
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to get optimization insights: ${error}`);
+    }
+  }
+  /**
+   * Get provider-specific insights for a prompt
+   *
+   * Returns insights about which providers and strategies work best for this prompt.
+   * This method is used by the auto-optimizer to make informed decisions.
+   *
+   * @param promptId Prompt identifier
+   * @returns Array of provider insights with performance data
+   */
+  async getProviderInsights(promptId) {
+    try {
+      const insights = [];
+      for (const provider of this.validProviders) {
+        const performance = await this.getProviderPerformance(provider, promptId);
+        if (!performance || performance.sampleSize < this.options.minSampleSize) {
+          continue;
+        }
+        const performanceScore = performance.successRate * 50 + // 50% weight for success rate
+        performance.avgCompleteness / 100 * 30 + // 30% weight for completeness
+        Math.max(0, 100 - performance.avgDuration / 3) * 20;
+        let bestStrategy = "conservative";
+        if (performance.successRate > 0.9 && performance.avgCompleteness > 90) {
+          bestStrategy = "innovative";
+        } else if (performance.successRate > 0.8 && performance.stdDevCompleteness < 15) {
+          bestStrategy = "balanced";
+        }
+        insights.push({
+          provider,
+          bestStrategy,
+          performanceScore: Math.round(performanceScore * 100) / 100,
+          sampleSize: performance.sampleSize
+        });
+      }
+      insights.sort((a, b) => b.performanceScore - a.performanceScore);
+      return insights;
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to get provider insights: ${error}`);
+    }
+  }
+  /**
+   * Compare providers for a specific prompt
+   *
+   * Performs comprehensive comparison across all providers with statistical rigor.
+   *
+   * @param promptId Prompt identifier
+   * @param versionId Optional version filter
+   * @returns Comparison result with recommendations
+   */
+  async compareProviders(promptId, versionId) {
+    try {
+      const recommendations = await this.getProviderRecommendations(promptId, versionId);
+      if (recommendations.length === 0) {
+        throw new Error("Insufficient data for provider comparison");
+      }
+      const best = recommendations[0];
+      if (!best) {
+        throw new Error("No best provider found in recommendations");
+      }
+      const recommendationText = this.generateComparisonRecommendation(recommendations);
+      const confidence = recommendations.reduce((sum, rec) => sum + rec.confidence, 0) / recommendations.length;
+      return {
+        promptId,
+        versionId: versionId || "all",
+        providers: recommendations,
+        bestProvider: best.provider,
+        recommendation: recommendationText,
+        confidence
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to compare providers: ${error}`);
+    }
+  }
+  /**
+   * Close database connection
+   *
+   * Should be called when done with the tracker to properly release resources.
+   */
+  close() {
+    this.db.close();
+  }
+  // ============================================================================
+  // PRIVATE HELPER METHODS
+  // ============================================================================
+  /**
+   * Whether a provider id should be accepted for tracking. Registry-known and
+   * user-defined providers are valid [B7]. If the registry could not be loaded
+   * (empty set), any non-empty id is accepted so tracking degrades open rather
+   * than rejecting every provider.
+   */
+  isValidProvider(provider) {
+    if (this.validProviderSet.size === 0) {
+      return typeof provider === "string" && provider.length > 0;
+    }
+    return this.validProviderSet.has(provider);
+  }
+  /**
+   * Calculate comprehensive performance metrics from raw executions
+   */
+  calculatePerformanceMetrics(executions, provider, promptId, versionId, variant) {
+    const totalExecutions = executions.length;
+    const successfulExecutions = executions.filter((e) => e.success === 1).length;
+    const successRate = successfulExecutions / totalExecutions;
+    const completenessValues = executions.map((e) => e.completeness).sort((a, b) => a - b);
+    const avgCompleteness = completenessValues.reduce((sum, v) => sum + v, 0) / completenessValues.length;
+    const minCompleteness = completenessValues[0] ?? 0;
+    const maxCompleteness = completenessValues[completenessValues.length - 1] ?? 0;
+    const medianCompleteness = this.calculateMedian(completenessValues);
+    const p95Completeness = this.calculatePercentile(completenessValues, 0.95);
+    const stdDevCompleteness = this.calculateStdDev(completenessValues, avgCompleteness);
+    const durationValues = executions.map((e) => e.duration);
+    const avgDuration = durationValues.reduce((sum, v) => sum + v, 0) / durationValues.length;
+    const codeDeliveredCount = executions.filter((e) => e.code_delivered === 1).length;
+    const avgCodeDeliveryRate = codeDeliveredCount / totalExecutions;
+    const successRateCI = this.calculateBayesianCI(successfulExecutions, totalExecutions);
+    const completenessCI = this.calculateNormalCI(
+      avgCompleteness,
+      stdDevCompleteness,
+      totalExecutions
+    );
+    const { trend, strength } = this.analyzeTrend(executions);
+    const timestamps = executions.map((e) => e.timestamp).sort();
+    const firstSeenAt = timestamps[0] ?? (/* @__PURE__ */ new Date()).toISOString();
+    const lastSeenAt = timestamps[timestamps.length - 1] ?? (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      provider,
+      promptId,
+      versionId: versionId || "all",
+      variant,
+      totalExecutions,
+      successfulExecutions,
+      successRate,
+      avgCompleteness,
+      avgDuration,
+      avgCodeDeliveryRate,
+      stdDevCompleteness,
+      medianCompleteness,
+      p95Completeness,
+      minCompleteness,
+      maxCompleteness,
+      successRateCI,
+      completenessCI,
+      performanceTrend: trend,
+      trendStrength: strength,
+      sampleSize: totalExecutions,
+      firstSeenAt,
+      lastSeenAt,
+      calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Calculate Bayesian confidence interval for success rate
+   * Uses Beta distribution (conjugate prior for Binomial)
+   */
+  calculateBayesianCI(successes, total) {
+    const alpha = successes + 0.5;
+    const beta = total - successes + 0.5;
+    const mean = alpha / (alpha + beta);
+    const variance = alpha * beta / ((alpha + beta) ** 2 * (alpha + beta + 1));
+    const stdDev = Math.sqrt(variance);
+    const z = 1.96;
+    const lower = Math.max(0, mean - z * stdDev);
+    const upper = Math.min(1, mean + z * stdDev);
+    return [lower, upper];
+  }
+  /**
+   * Calculate normal confidence interval for continuous metrics
+   */
+  calculateNormalCI(mean, stdDev, n) {
+    const z = 1.96;
+    const margin = z * (stdDev / Math.sqrt(n));
+    return [Math.max(0, mean - margin), Math.min(100, mean + margin)];
+  }
+  /**
+   * Calculate Bayesian confidence score
+   */
+  calculateBayesianConfidence(successes, total) {
+    const alpha = successes + 0.5;
+    const beta = total - successes + 0.5;
+    const mean = alpha / (alpha + beta);
+    const sampleConfidence = Math.min(1, total / 20);
+    return mean * sampleConfidence;
+  }
+  /**
+   * Analyze performance trend using linear regression
+   */
+  analyzeTrend(executions) {
+    if (executions.length < 5) {
+      return { trend: "insufficient_data", strength: 0 };
+    }
+    const sorted = [...executions].sort(
+      (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+    );
+    const x = sorted.map((_, i) => i);
+    const y = sorted.map((e) => e.completeness);
+    const { slope, rSquared } = this.linearRegression(x, y);
+    let trend;
+    if (Math.abs(slope) < 1) {
+      trend = "stable";
+    } else if (slope > 0) {
+      trend = "improving";
+    } else {
+      trend = "declining";
+    }
+    return { trend, strength: rSquared };
+  }
+  /**
+   * Perform linear regression
+   */
+  linearRegression(x, y) {
+    const n = x.length;
+    const sumX = x.reduce((sum, v) => sum + v, 0);
+    const sumY = y.reduce((sum, v) => sum + v, 0);
+    const sumXY = x.reduce((sum, v, i) => sum + v * (y[i] ?? 0), 0);
+    const sumXX = x.reduce((sum, v) => sum + v * v, 0);
+    const sumYY = y.reduce((sum, v) => sum + v * v, 0);
+    const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+    const intercept = (sumY - slope * sumX) / n;
+    const meanY = sumY / n;
+    const ssTotal = sumYY - n * meanY * meanY;
+    const ssResidual = y.reduce((sum, yi, i) => {
+      const predicted = intercept + slope * (x[i] ?? 0);
+      return sum + (yi - predicted) ** 2;
+    }, 0);
+    const rSquared = 1 - ssResidual / ssTotal;
+    return { slope, intercept, rSquared };
+  }
+  /**
+   * Calculate median
+   */
+  calculateMedian(sorted) {
+    const mid = Math.floor(sorted.length / 2);
+    const lower = sorted[mid - 1] ?? 0;
+    const upper = sorted[mid] ?? 0;
+    const single = sorted[mid] ?? 0;
+    return sorted.length % 2 === 0 ? (lower + upper) / 2 : single;
+  }
+  /**
+   * Calculate percentile
+   */
+  calculatePercentile(sorted, p) {
+    const index = Math.ceil(sorted.length * p) - 1;
+    return sorted[Math.max(0, Math.min(index, sorted.length - 1))] ?? 0;
+  }
+  /**
+   * Calculate standard deviation
+   */
+  calculateStdDev(values, mean) {
+    const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+    return Math.sqrt(variance);
+  }
+  /**
+   * Calculate reliability score (consistency)
+   */
+  calculateReliabilityScore(provider) {
+    const stmt = this.db.prepare(`
+      SELECT AVG(completeness) as mean,
+             (AVG(completeness * completeness) - AVG(completeness) * AVG(completeness)) as variance
+      FROM provider_executions
+      WHERE provider = ?
+    `);
+    const result = stmt.get(provider);
+    if (!result || result.mean === null || result.variance === null) return 0;
+    const stdDev = Math.sqrt(result.variance);
+    const coefficientOfVariation = stdDev / result.mean;
+    return Math.max(0, 1 - coefficientOfVariation);
+  }
+  /**
+   * Calculate speed score (normalized)
+   */
+  calculateSpeedScore(provider) {
+    const stmt = this.db.prepare(`
+      SELECT AVG(duration) as avg_duration
+      FROM provider_executions
+      WHERE provider = ?
+    `);
+    const result = stmt.get(provider);
+    if (!result || result.avg_duration === null) return 0;
+    const normalized = 1 - Math.min(1, (result.avg_duration - 60) / 240);
+    return Math.max(0, normalized);
+  }
+  /**
+   * Calculate quality score
+   */
+  calculateQualityScore(provider) {
+    const stmt = this.db.prepare(`
+      SELECT AVG(success) as success_rate,
+             AVG(completeness) as avg_completeness
+      FROM provider_executions
+      WHERE provider = ?
+    `);
+    const result = stmt.get(provider);
+    if (!result) return 0;
+    const functionality = (typeof result.avg_completeness === "number" ? result.avg_completeness : 0) * 0.5 + (typeof result.success_rate === "number" ? result.success_rate * 100 : 0) * 0.5;
+    const base = {
+      functionality_correctness: functionality,
+      scalability_adaptability: result.avg_completeness,
+      code_quality_maintainability: result.avg_completeness,
+      security_robustness: Math.min(85, result.avg_completeness)
+    };
+    const scores = buildCriterionScores(base);
+    const agg = aggregateScores(scores);
+    return agg.score / 100;
+  }
+  /**
+   * Find best and worst prompts for a provider
+   */
+  findBestWorstPrompts(provider) {
+    const stmt = this.db.prepare(`
+      SELECT prompt_id,
+             AVG(success) as success_rate,
+             AVG(completeness) as avg_completeness
+      FROM provider_executions
+      WHERE provider = ?
+      GROUP BY prompt_id
+      HAVING COUNT(*) >= ?
+    `);
+    const prompts = stmt.all(provider, this.options.minSampleSize);
+    if (prompts.length === 0) {
+      return { bestPromptId: null, worstPromptId: null };
+    }
+    const scored = prompts.map((p) => ({
+      promptId: p.prompt_id,
+      score: (p.success_rate ?? 0) * 0.5 + (p.avg_completeness ?? 0) / 100 * 0.5
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    return {
+      bestPromptId: scored[0]?.promptId ?? null,
+      worstPromptId: scored[scored.length - 1]?.promptId ?? null
+    };
+  }
+  /**
+   * Identify provider specializations
+   */
+  identifySpecializations(provider) {
+    const specializations = [];
+    const complexStmt = this.db.prepare(`
+      SELECT task_complexity, AVG(success) as success_rate
+      FROM provider_executions
+      WHERE provider = ? AND task_complexity IS NOT NULL
+      GROUP BY task_complexity
+    `);
+    const complexResults = complexStmt.all(provider);
+    for (const result of complexResults) {
+      if (result.success_rate > 0.85) {
+        specializations.push(`${result.task_complexity} tasks`);
+      }
+    }
+    if (specializations.length === 0) {
+      specializations.push("general purpose");
+    }
+    return specializations;
+  }
+  /**
+   * Generate recommendation reasoning
+   */
+  generateRecommendationReasoning(performance) {
+    const reasoning = [];
+    if (performance.successRate >= 0.9) {
+      reasoning.push(`High success rate (${(performance.successRate * 100).toFixed(1)}%)`);
+    }
+    if (performance.avgCompleteness >= 85) {
+      reasoning.push(`Excellent completeness (${performance.avgCompleteness.toFixed(1)}/100)`);
+    }
+    if (performance.stdDevCompleteness < 10) {
+      reasoning.push("Highly consistent performance");
+    }
+    if (performance.avgDuration < 60) {
+      reasoning.push(`Fast execution (${performance.avgDuration.toFixed(0)}s)`);
+    }
+    if (performance.performanceTrend === "improving") {
+      reasoning.push("Performance improving over time");
+    } else if (performance.performanceTrend === "declining") {
+      reasoning.push(" Performance declining - needs attention");
+    }
+    if (reasoning.length === 0) {
+      reasoning.push("Adequate performance");
+    }
+    return reasoning;
+  }
+  /**
+   * Generate comparison recommendation text
+   */
+  generateComparisonRecommendation(recommendations) {
+    if (recommendations.length === 0) {
+      return "No data available for comparison";
+    }
+    const best = recommendations[0];
+    if (!best) {
+      return "No best provider available";
+    }
+    const parts = [];
+    parts.push(`Recommend ${best.provider} as primary provider`);
+    parts.push(`Expected success: ${(best.expectedSuccess * 100).toFixed(1)}%`);
+    parts.push(`Expected completeness: ${best.expectedCompleteness.toFixed(1)}/100`);
+    parts.push(`Confidence: ${(best.confidence * 100).toFixed(1)}%`);
+    if (recommendations.length > 1) {
+      const second = recommendations[1];
+      if (second) {
+        const gap = (best.expectedSuccess - second.expectedSuccess) * 100;
+        if (gap < 5) {
+          parts.push(
+            `Note: ${second.provider} is a close alternative (${gap.toFixed(1)}% difference)`
+          );
+        }
+      }
+    }
+    return parts.join(". ");
+  }
+  /**
+   * Empty provider stats for when no data exists
+   */
+  emptyProviderStats(provider) {
+    return {
+      provider,
+      totalPrompts: 0,
+      totalExecutions: 0,
+      avgSuccessRate: 0,
+      avgCompleteness: 0,
+      avgDuration: 0,
+      reliability: 0,
+      speed: 0,
+      quality: 0,
+      bestPromptId: null,
+      worstPromptId: null,
+      specialization: [],
+      calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Cache performance results
+   */
+  cachePerformance(performance) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO provider_stats_cache
+      (provider, prompt_id, version_id, variant, total_executions, success_rate,
+       avg_completeness, avg_duration, std_dev_completeness, median_completeness,
+       performance_trend, trend_strength, calculated_at, sample_size)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      performance.provider,
+      performance.promptId,
+      performance.versionId || "",
+      performance.variant || "",
+      performance.totalExecutions,
+      performance.successRate,
+      performance.avgCompleteness,
+      performance.avgDuration,
+      performance.stdDevCompleteness,
+      performance.medianCompleteness,
+      performance.performanceTrend,
+      performance.trendStrength,
+      performance.calculatedAt,
+      performance.sampleSize
+    );
+  }
+  /**
+   * Get cached performance if available and fresh
+   */
+  getCachedPerformance(provider, promptId, versionId, variant) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM provider_stats_cache
+      WHERE provider = ? AND prompt_id = ? AND version_id = ? AND variant = ?
+    `);
+    const row = stmt.get(provider, promptId, versionId || "", variant || "");
+    if (!row) return null;
+    return {
+      provider: row.provider,
+      promptId: row.prompt_id,
+      versionId: row.version_id || "",
+      variant: row.variant || void 0,
+      totalExecutions: row.total_executions,
+      successfulExecutions: Math.round(row.success_rate * row.total_executions),
+      successRate: row.success_rate,
+      avgCompleteness: row.avg_completeness,
+      avgDuration: row.avg_duration,
+      avgCodeDeliveryRate: 0,
+      // Not cached
+      stdDevCompleteness: row.std_dev_completeness,
+      medianCompleteness: row.median_completeness,
+      p95Completeness: 0,
+      // Not cached
+      minCompleteness: 0,
+      // Not cached
+      maxCompleteness: 100,
+      // Not cached
+      successRateCI: [0, 1],
+      // Not cached
+      completenessCI: [0, 100],
+      // Not cached
+      performanceTrend: row.performance_trend,
+      trendStrength: row.trend_strength,
+      sampleSize: row.sample_size,
+      firstSeenAt: "",
+      // Not cached
+      lastSeenAt: "",
+      // Not cached
+      calculatedAt: row.calculated_at
+    };
+  }
+  /**
+   * Check if cached result is fresh (within 1 hour)
+   */
+  isCacheFresh(calculatedAt) {
+    const cached = new Date(calculatedAt).getTime();
+    const now = Date.now();
+    const ageMs = now - cached;
+    const maxAgeMs = 60 * 60 * 1e3;
+    return ageMs < maxAgeMs;
+  }
+  /**
+   * Invalidate cache for a specific combination
+   */
+  async invalidateCache(provider, promptId, versionId, variant) {
+    const stmt = this.db.prepare(`
+      DELETE FROM provider_stats_cache
+      WHERE provider = ? AND prompt_id = ? AND version_id = ? AND variant = ?
+    `);
+    stmt.run(provider, promptId, versionId || "", variant || "");
+  }
+};
+
+// src/prompts/auto-optimizer.ts
+var AutomaticPromptOptimizer = class {
+  store;
+  manager;
+  evaluator;
+  optimizer;
+  variantGenerator;
+  providerTracker;
+  autoTuner;
+  activationAuthority;
+  telemetry;
+  lineage;
+  options;
+  constructor(options = {}) {
+    this.telemetry = options.telemetryLogger || TelemetryLogger.getInstance(options);
+    this.store = options.promptStore || new PromptStore(options);
+    this.manager = options.promptManager || new PromptManager(options);
+    this.evaluator = new PromptEvaluator({
+      poeticDir: options.poeticDir,
+      telemetryLogger: this.telemetry
+    });
+    this.optimizer = new PromptOptimizer({
+      poeticDir: options.poeticDir,
+      telemetryLogger: this.telemetry
+    });
+    this.variantGenerator = new VariantGenerator();
+    this.providerTracker = new ProviderTracker(options);
+    this.autoTuner = new AutoTuningEngine(options);
+    this.activationAuthority = options.activationAuthority ?? new TunerActivationAuthority(this.autoTuner, this.telemetry);
+    this.lineage = options.lineageTracker || new LineageTracker(options);
+    this.options = {
+      poeticDir: resolvePoeticDirFromContext(options.poeticDir),
+      telemetryLogger: this.telemetry,
+      minSampleSize: options.minSampleSize ?? 10,
+      improvementThreshold: options.improvementThreshold ?? 5,
+      maxVariantsPerOptimization: options.maxVariantsPerOptimization ?? 3,
+      autoActivateBestVariant: options.autoActivateBestVariant ?? false,
+      enableAutoTuning: options.enableAutoTuning ?? false,
+      requireManualReview: options.requireManualReview ?? true,
+      rollbackOnRegression: options.rollbackOnRegression ?? true
+    };
+  }
+  /**
+   * Analyze a prompt and generate optimization recommendations
+   */
+  async analyzePrompt(promptId) {
+    try {
+      this.manager.getOrThrow(promptId);
+      const activeVersion = this.manager.getActiveVersionOrThrow(promptId);
+      const currentPerformance = await this.evaluator.calculatePerformanceMetrics(activeVersion);
+      if (currentPerformance.sampleSize < this.options.minSampleSize) {
+        return {
+          promptId,
+          currentVersionId: activeVersion.id,
+          currentPerformance,
+          suggestions: [],
+          proposedVariants: [],
+          providerInsights: [],
+          action: "needs_more_data",
+          rationale: `Insufficient data (${currentPerformance.sampleSize}/${this.options.minSampleSize} samples). Continue running tasks to gather more performance data.`,
+          estimatedImpact: {
+            successRateImprovement: 0,
+            completenessImprovement: 0,
+            durationImprovement: 0
+          },
+          confidence: 0,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const analysis = await this.optimizer.analyze(activeVersion.id);
+      if (analysis.overallScore >= 85 && analysis.suggestions.length === 0) {
+        return {
+          promptId,
+          currentVersionId: activeVersion.id,
+          currentPerformance,
+          suggestions: [],
+          proposedVariants: [],
+          providerInsights: await this.getProviderInsights(promptId),
+          action: "no_action",
+          rationale: "Prompt is performing well. No optimization needed at this time.",
+          estimatedImpact: {
+            successRateImprovement: 0,
+            completenessImprovement: 0,
+            durationImprovement: 0
+          },
+          confidence: 0.9,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const bestVersion = await this.optimizer.recommendBestVersion(promptId);
+      if (bestVersion.recommendedVersion !== activeVersion.id) {
+        const recommendedMetrics = await this.evaluator.calculatePerformanceMetrics(
+          this.store.getVersion(promptId, bestVersion.recommendedVersion)
+        );
+        const improvement = (recommendedMetrics.successRate - currentPerformance.successRate) * 100;
+        if (improvement >= this.options.improvementThreshold) {
+          return {
+            promptId,
+            currentVersionId: activeVersion.id,
+            currentPerformance,
+            suggestions: analysis.suggestions,
+            proposedVariants: [],
+            providerInsights: await this.getProviderInsights(promptId),
+            action: "activate_existing",
+            rationale: `Existing version ${bestVersion.recommendedVersion} performs ${improvement.toFixed(1)}% better. Recommend activating it.`,
+            estimatedImpact: {
+              successRateImprovement: improvement,
+              completenessImprovement: recommendedMetrics.avgCompleteness - currentPerformance.avgCompleteness,
+              durationImprovement: currentPerformance.avgDuration - recommendedMetrics.avgDuration
+            },
+            confidence: 0.8,
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+      }
+      const generatedVariants = await this.variantGenerator.generateVariants(
+        activeVersion,
+        this.options.maxVariantsPerOptimization,
+        {
+          strategies: this.selectStrategiesForSuggestions(analysis.suggestions),
+          targetMetric: this.determineTargetMetric(analysis.suggestions)
+        }
+      );
+      const proposedVariants = generatedVariants.map(
+        (variant, index) => this.toProposedVariant(activeVersion.id, index, variant)
+      );
+      const estimatedImpact = this.estimateImpact(analysis.suggestions);
+      const confidence = this.calculateConfidence(
+        currentPerformance.sampleSize,
+        analysis.suggestions
+      );
+      return {
+        promptId,
+        currentVersionId: activeVersion.id,
+        currentPerformance,
+        suggestions: analysis.suggestions,
+        proposedVariants,
+        providerInsights: await this.getProviderInsights(promptId),
+        action: "generate_variants",
+        rationale: `Generated ${proposedVariants.length} suggested prompt revision proposals based on performance analysis. Estimated ${estimatedImpact.successRateImprovement.toFixed(1)}% improvement.`,
+        estimatedImpact,
+        confidence,
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to analyze prompt ${promptId}: ${error.message}`);
+    }
+  }
+  /**
+   * Execute automatic optimization for a prompt
+   */
+  async optimizePrompt(promptId, recommendation) {
+    try {
+      if (!recommendation) {
+        recommendation = await this.analyzePrompt(promptId);
+      }
+      const result = {
+        promptId,
+        success: false,
+        variantsGenerated: 0,
+        variantsActivated: 0,
+        improvements: [],
+        warnings: [],
+        errors: [],
+        suggestedPromptRevisions: [],
+        beforeMetrics: recommendation.currentPerformance,
+        executedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      switch (recommendation.action) {
+        case "needs_more_data":
+          result.warnings.push(recommendation.rationale);
+          result.success = true;
+          break;
+        case "no_action":
+          result.improvements.push(recommendation.rationale);
+          result.success = true;
+          break;
+        case "activate_existing":
+          await this.activateExistingVariant(promptId, recommendation, result);
+          break;
+        case "generate_variants":
+          await this.generateAndTestVariants(promptId, recommendation, result);
+          break;
+      }
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to optimize prompt ${promptId}: ${error.message}`);
+    }
+  }
+  /**
+   * Batch optimize all prompts that need optimization
+   */
+  async optimizeAllPrompts() {
+    try {
+      const prompts = this.manager.list({ status: "active" });
+      const results = [];
+      const errors = [];
+      let optimized = 0;
+      for (const prompt of prompts) {
+        try {
+          const recommendation = await this.analyzePrompt(prompt.id);
+          if (recommendation.action === "generate_variants" || recommendation.action === "activate_existing") {
+            const result = await this.optimizePrompt(prompt.id, recommendation);
+            results.push(result);
+            if (result.success) {
+              optimized++;
+            }
+          }
+        } catch (error) {
+          errors.push({
+            promptId: prompt.id,
+            _error: error.message
+          });
+        }
+      }
+      return {
+        analyzed: prompts.length,
+        optimized,
+        results,
+        errors
+      };
+    } catch (error) {
+      throw new Error(`Failed to optimize all prompts: ${error.message}`);
+    }
+  }
+  /**
+   * Monitor prompt performance and trigger optimization when needed
+   */
+  async monitorAndOptimize(promptId) {
+    try {
+      this.manager.getOrThrow(promptId);
+      const activeVersion = this.manager.getActiveVersionOrThrow(promptId);
+      const performance = await this.evaluator.calculatePerformanceMetrics(activeVersion);
+      const shouldOptimize = await this.shouldTriggerOptimization(promptId, performance);
+      if (!shouldOptimize.trigger) {
+        return {
+          optimizationTriggered: false,
+          reason: shouldOptimize.reason
+        };
+      }
+      const result = await this.optimizePrompt(promptId);
+      return {
+        optimizationTriggered: true,
+        reason: shouldOptimize.reason,
+        result
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to monitor and optimize prompt ${promptId}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Rollback to previous version if regression detected
+   */
+  async rollbackIfRegression(promptId) {
+    try {
+      if (!this.options.rollbackOnRegression) {
+        return { rollbackPerformed: false };
+      }
+      this.manager.getOrThrow(promptId);
+      const versions = this.manager.listVersions(promptId);
+      if (versions.length < 2) {
+        return { rollbackPerformed: false };
+      }
+      const current = versions.find((v) => v.isActive);
+      const previous = versions.filter((v) => !v.isActive)[0];
+      if (!current || !previous) {
+        return { rollbackPerformed: false };
+      }
+      const currentPerf = await this.evaluator.calculatePerformanceMetrics(current);
+      const previousPerf = await this.evaluator.calculatePerformanceMetrics(previous);
+      const successRateDelta = (currentPerf.successRate - previousPerf.successRate) * 100;
+      const completenessDelta = currentPerf.avgCompleteness - previousPerf.avgCompleteness;
+      const hasRegression = successRateDelta < -10 || completenessDelta < -15;
+      if (hasRegression && currentPerf.sampleSize >= 5) {
+        const reason = `Detected regression: success rate ${successRateDelta.toFixed(1)}%, completeness ${completenessDelta.toFixed(1)}`;
+        await this.activateThroughAuthority({
+          promptId,
+          sourceVersionId: current.id,
+          candidateVersionId: previous.id,
+          improvementPercentage: 0,
+          confidence: 0.9,
+          reason,
+          skipSafetyChecks: true
+        });
+        return {
+          rollbackPerformed: true,
+          previousVersionId: previous.id,
+          reason
+        };
+      }
+      return { rollbackPerformed: false };
+    } catch (error) {
+      throw new Error(
+        `Failed to check for regression on prompt ${promptId}: ${error.message}`
+      );
+    }
+  }
+  /**
+   * Close all connections
+   */
+  close() {
+    this.store.close();
+    this.manager.close();
+    this.evaluator.close();
+    this.optimizer.close();
+    this.variantGenerator.close();
+    this.providerTracker.close();
+    this.autoTuner.close();
+    this.telemetry.close();
+  }
+  // Private helper methods
+  /**
+   * Activate an existing better-performing variant
+   */
+  async activateExistingVariant(promptId, _recommendation, result) {
+    try {
+      const bestVersion = await this.optimizer.recommendBestVersion(promptId);
+      if (this.options.requireManualReview && !this.options.enableAutoTuning) {
+        result.warnings.push(
+          `Manual review required before activating version ${bestVersion.recommendedVersion}`
+        );
+        result.success = true;
+        return;
+      }
+      const activeVersion = this.manager.getActiveVersionOrThrow(promptId);
+      await this.activateThroughAuthority({
+        promptId,
+        sourceVersionId: activeVersion.id,
+        candidateVersionId: bestVersion.recommendedVersion,
+        improvementPercentage: _recommendation.estimatedImpact.successRateImprovement,
+        confidence: _recommendation.confidence,
+        reason: bestVersion.rationale
+      });
+      result.variantsActivated = 1;
+      result.improvements.push(
+        `Activated version ${bestVersion.recommendedVersion}: ${bestVersion.rationale}`
+      );
+      const newVersion = this.manager.getVersion(promptId, bestVersion.recommendedVersion);
+      if (newVersion) {
+        result.afterMetrics = await this.evaluator.calculatePerformanceMetrics(newVersion);
+        result.performanceChange = (result.afterMetrics.successRate - result.beforeMetrics.successRate) * 100;
+      }
+      result.success = true;
+    } catch (error) {
+      result.errors.push(error.message);
+      result.success = false;
+    }
+  }
+  /**
+   * Generate and test new variants
+   */
+  async generateAndTestVariants(promptId, recommendation, result) {
+    try {
+      const activeVersion = this.manager.getActiveVersionOrThrow(promptId);
+      const cycleId = this.createOptimizationCycleId(promptId);
+      const generatedVersions = [];
+      for (const proposed of recommendation.proposedVariants) {
+        try {
+          const generationPrompt = this.buildGenerationPrompt(proposed);
+          const newVersion = await this.manager.createVersion({
+            promptId,
+            content: proposed.content,
+            changelog: `Suggested prompt revision (${proposed.variantId}): ${proposed.description}`,
+            author: "auto-optimizer",
+            activate: false,
+            // Don't activate yet (unless auto-tuning is enabled)
+            isGenerated: true,
+            generationModel: "poetic-auto-optimizer",
+            generationPrompt
+          });
+          generatedVersions.push(newVersion.id);
+          try {
+            await this.lineage.trackMutation(
+              activeVersion.id,
+              newVersion.id,
+              this.mapMutations(proposed.mutations, proposed.confidence),
+              cycleId
+            );
+          } catch (lineageError) {
+            emitWarning(
+              "WS-003",
+              {
+                taskId: "auto-optimizer",
+                subsystem: "prompts",
+                executionPhase: "execution"
+              },
+              {
+                severity: "WARN" /* WARN */,
+                metadata: {
+                  error: lineageError.message,
+                  operation: "trackMutation",
+                  versionId: newVersion.id,
+                  promptId
+                }
+              }
+            );
+            result.warnings.push(
+              `Lineage tracking failed for ${newVersion.id}: ${lineageError.message}`
+            );
+          }
+          result.variantsGenerated++;
+          const revisionSummary = `Suggested prompt revision ${newVersion.id}: ${proposed.description} (expected ${proposed.expectedImprovement})`;
+          result.suggestedPromptRevisions.push(revisionSummary);
+          result.improvements.push(revisionSummary);
+        } catch (error) {
+          result.errors.push(
+            `Failed to generate suggested prompt revision: ${error.message}`
+          );
+        }
+      }
+      if (this.options.enableAutoTuning && this.options.autoActivateBestVariant && recommendation.confidence >= 0.8 && result.variantsGenerated > 0 && generatedVersions.length > 0) {
+        const variantToActivate = generatedVersions[0];
+        if (!variantToActivate) {
+          result.errors.push("No variant generated for activation");
+        } else {
+          try {
+            await this.activateThroughAuthority({
+              promptId,
+              sourceVersionId: activeVersion.id,
+              candidateVersionId: variantToActivate,
+              improvementPercentage: recommendation.estimatedImpact.successRateImprovement,
+              confidence: recommendation.confidence,
+              reason: recommendation.rationale
+            });
+            result.variantsActivated++;
+            result.improvements.push(
+              `Activated suggested prompt revision ${variantToActivate} (${recommendation.rationale})`
+            );
+          } catch (activationError) {
+            result.warnings.push(
+              `Failed to auto-activate variant ${variantToActivate}: ${activationError.message}`
+            );
+          }
+        }
+      } else if ((this.options.enableAutoTuning || this.options.autoActivateBestVariant) && recommendation.confidence < 0.8) {
+        result.warnings.push(
+          `Confidence too low (${(recommendation.confidence * 100).toFixed(0)}%) for auto-activation. Suggested prompt revisions generated but require manual review.`
+        );
+      } else if (result.variantsGenerated > 0) {
+        result.warnings.push(
+          "Auto-activation disabled - suggested prompt revisions generated but need testing before activation"
+        );
+      }
+      result.success = result.variantsGenerated > 0;
+    } catch (error) {
+      result.errors.push(error.message);
+      result.success = false;
+    }
+  }
+  async activateThroughAuthority(request) {
+    const result = await this.activationAuthority.activate({
+      ...request,
+      safetyChecksPassed: null
+    });
+    if (!result.activated) {
+      throw new Error(result.reason || "Activation authority declined activation");
+    }
+    const recordId = result.record?.id;
+    if (recordId && this.activationAuthority.scheduleMonitoring) {
+      this.activationAuthority.scheduleMonitoring(recordId);
+    }
+  }
+  toProposedVariant(baseVersionId, index, variant) {
+    const variantId = `${baseVersionId}-opt-${index + 1}`;
+    const changes = variant.mutations.length ? variant.mutations.map((mutation) => `- [${mutation.strategy}] ${mutation.description}`).join("\n") : "- No structural mutations recorded";
+    return {
+      variantId,
+      description: variant.testHypothesis,
+      changes,
+      expectedImprovement: variant.expectedImprovement,
+      content: variant.content,
+      mutations: variant.mutations,
+      hypothesis: variant.testHypothesis,
+      confidence: variant.confidence
+    };
+  }
+  selectStrategiesForSuggestions(suggestions) {
+    const mapping = {
+      improve_clarity: ["clarity", "structure"],
+      add_context: ["context", "examples"],
+      remove_redundancy: ["conciseness", "structure"],
+      update_strategy: ["hybrid", "clarity"],
+      split_prompt: ["structure", "constraints"],
+      merge_prompts: ["structure", "clarity"]
+    };
+    const selected = /* @__PURE__ */ new Set();
+    for (const suggestion of suggestions) {
+      const strategies = mapping[suggestion.type] || ["hybrid"];
+      strategies.forEach((strategy) => {
+        selected.add(strategy);
+      });
+    }
+    if (selected.size === 0) {
+      ["clarity", "context", "structure"].forEach((strategy) => {
+        selected.add(strategy);
+      });
+    }
+    return Array.from(selected).slice(0, this.options.maxVariantsPerOptimization);
+  }
+  determineTargetMetric(suggestions) {
+    if (suggestions.some(
+      (s) => s.affectedMetrics.some((metric) => metric.toLowerCase().includes("success"))
+    )) {
+      return "success_rate";
+    }
+    if (suggestions.some(
+      (s) => s.affectedMetrics.some((metric) => metric.toLowerCase().includes("completeness"))
+    )) {
+      return "completeness";
+    }
+    if (suggestions.some(
+      (s) => s.affectedMetrics.some((metric) => metric.toLowerCase().includes("duration"))
+    )) {
+      return "duration";
+    }
+    return "balanced";
+  }
+  buildGenerationPrompt(proposed) {
+    const header = `Hypothesis: ${proposed.hypothesis}`;
+    const improvement = `Expected impact: ${proposed.expectedImprovement}`;
+    const mutations = proposed.mutations.length ? proposed.mutations.map(
+      (mutation) => `? ${mutation.strategy.toUpperCase()}: ${mutation.description} (${mutation.rationale})`
+    ).join("\n") : "? No explicit mutations captured";
+    return `${header}
+${improvement}
+Mutations:
+${mutations}`;
+  }
+  mapMutations(mutations, confidence) {
+    if (mutations.length === 0) {
+      return [
+        {
+          type: "other",
+          description: "No explicit mutation recorded",
+          details: "Auto-optimizer generated a holistic revision without discrete mutations",
+          impact: Math.max(0.2, Math.min(1, confidence))
+        }
+      ];
+    }
+    return mutations.map((mutation) => ({
+      type: this.mapMutationType(mutation.strategy),
+      description: mutation.description,
+      details: mutation.rationale || `${mutation.before} ? ${mutation.after}`,
+      impact: Math.max(0.2, Math.min(1, confidence))
+    }));
+  }
+  mapMutationType(strategy) {
+    switch (strategy) {
+      case "clarity":
+        return "clarify_instructions";
+      case "context":
+      case "examples":
+        return "add_context";
+      case "conciseness":
+        return "remove_redundancy";
+      case "structure":
+      case "constraints":
+        return "optimize_structure";
+      case "tone":
+        return "adjust_tone";
+      default:
+        return "other";
+    }
+  }
+  createOptimizationCycleId(promptId) {
+    return `auto-opt-${promptId}-${Date.now()}`;
+  }
+  /**
+   * Get provider-specific insights
+   */
+  async getProviderInsights(promptId) {
+    try {
+      const insights = await this.providerTracker.getProviderInsights(promptId);
+      return insights.map((i) => ({
+        provider: i.provider,
+        bestStrategy: i.bestStrategy,
+        performanceScore: i.performanceScore,
+        sampleSize: i.sampleSize
+      }));
+    } catch (error) {
+      emitWarning(
+        "WS-003",
+        {
+          taskId: "auto-optimizer",
+          subsystem: "prompts",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: error.message,
+            operation: "getProviderInsights",
+            promptId
+          }
+        }
+      );
+      return [];
+    }
+  }
+  /**
+   * Estimate impact of suggested improvements
+   */
+  estimateImpact(suggestions) {
+    let successRateImprovement = 0;
+    let completenessImprovement = 0;
+    let durationImprovement = 0;
+    for (const suggestion of suggestions) {
+      switch (suggestion.type) {
+        case "improve_clarity":
+          successRateImprovement += 10;
+          completenessImprovement += 8;
+          break;
+        case "add_context":
+          completenessImprovement += 12;
+          successRateImprovement += 5;
+          break;
+        case "remove_redundancy":
+          durationImprovement += 15;
+          break;
+        case "update_strategy":
+          successRateImprovement += 8;
+          completenessImprovement += 5;
+          break;
+        case "split_prompt":
+          durationImprovement += 30;
+          break;
+      }
+    }
+    return {
+      successRateImprovement: Math.min(successRateImprovement, 25),
+      // Cap at 25%
+      completenessImprovement: Math.min(completenessImprovement, 20),
+      // Cap at 20 points
+      durationImprovement: Math.min(durationImprovement, 40)
+      // Cap at 40%
+    };
+  }
+  /**
+   * Calculate confidence in recommendations
+   */
+  calculateConfidence(sampleSize, suggestions) {
+    let confidence = Math.min(sampleSize / 50, 1);
+    const highPriority = suggestions.filter((s) => s.priority === "high").length;
+    const criticalPriority = suggestions.filter((s) => s.priority === "critical").length;
+    if (criticalPriority > 0) {
+      confidence *= 0.9;
+    } else if (highPriority > 2) {
+      confidence *= 0.85;
+    }
+    return Math.max(0.3, Math.min(1, confidence));
+  }
+  /**
+   * Determine if optimization should be triggered
+   */
+  async shouldTriggerOptimization(_promptId, performance) {
+    if (performance.sampleSize < this.options.minSampleSize) {
+      return {
+        trigger: false,
+        reason: `Insufficient data (${performance.sampleSize}/${this.options.minSampleSize})`
+      };
+    }
+    if (performance.successRate < 0.7) {
+      return {
+        trigger: true,
+        reason: `Low success rate (${(performance.successRate * 100).toFixed(1)}%)`
+      };
+    }
+    if (performance.avgCompleteness < 70) {
+      return {
+        trigger: true,
+        reason: `Low completeness (${performance.avgCompleteness.toFixed(1)})`
+      };
+    }
+    if (performance.stdDevCompleteness > 25) {
+      return {
+        trigger: true,
+        reason: "High performance variability detected"
+      };
+    }
+    return {
+      trigger: false,
+      reason: "Performance meets standards"
+    };
+  }
+};
+
+export {
+  aggregateScores,
+  buildCriterionScores,
+  ProviderTracker,
+  TunerActivationAuthority,
+  PromptEvaluator,
+  PromptOptimizer,
+  AutoTuningEngine,
+  AutomaticPromptOptimizer
+};
+//# sourceMappingURL=chunk-7MMLMXO6.js.map