@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-Q3WIC6GQ.js

@@ -0,0 +1,2670 @@
+import {
+  PromptStore
+} from "./chunk-OQ6K46CK.js";
+import {
+  SEVEN_DAYS_MS
+} from "./chunk-3AOKYKA7.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/prompts/analytics.ts
+var AnalyticsEngine = class {
+  TREND_WINDOW = 10;
+  // Number of recent values to analyze
+  MIN_SAMPLES_FOR_TREND = 4;
+  REGRESSION_THRESHOLD = 2;
+  // Standard deviations from mean
+  /**
+   * Detect trend in metric values
+   *
+   * @param metrics Array of metric values
+   * @param metric Type of metric being analyzed
+   * @returns Trend analysis with type and strength
+   *
+   * @example
+   * ```typescript
+   * const successRates = [0.70, 0.72, 0.75, 0.78, 0.80, 0.82, 0.83];
+   * const trend = analytics.detectTrend(successRates, 'success_rate');
+   * console.log(`Trend: ${trend.type}, Strength: ${trend.strength}`);
+   * ```
+   */
+  detectTrend(metrics, _metric) {
+    if (metrics.length < this.MIN_SAMPLES_FOR_TREND) {
+      return {
+        type: "insufficient_data",
+        strength: 0,
+        slope: 0,
+        direction: "flat",
+        lastNValues: metrics
+      };
+    }
+    const window = metrics.slice(-this.TREND_WINDOW);
+    const { slope, rSquared } = this.linearRegression(
+      Array.from({ length: window.length }, (_, i) => i),
+      window
+    );
+    const absSlope = Math.abs(slope);
+    let type = "stable";
+    let strength = rSquared;
+    const firstValue = window[0] ?? 0;
+    const lastValue = window[window.length - 1] ?? 0;
+    const totalChange = Math.abs(lastValue - firstValue);
+    const relativeChange = totalChange / Math.max(Math.abs(firstValue), 0.01);
+    if (absSlope < 5e-3 || relativeChange < 0.02 && absSlope < 0.3) {
+      type = "stable";
+      strength = 1 - Math.min(1, absSlope);
+    } else if (slope > 0) {
+      type = "improving";
+      strength = Math.min(1, rSquared * (1 + absSlope / 10));
+    } else {
+      type = "declining";
+      strength = Math.min(1, rSquared * (1 + absSlope / 10));
+    }
+    const direction = slope > 0.05 ? "up" : slope < -0.05 ? "down" : "flat";
+    return {
+      type,
+      strength: Math.max(0, Math.min(1, strength)),
+      slope,
+      direction,
+      lastNValues: window
+    };
+  }
+  /**
+   * Forecast future performance
+   *
+   * @param metrics Historical metric values
+   * @param daysAhead Days to forecast ahead (default 7)
+   * @param versionId Version being analyzed
+   * @param metricType Type of metric
+   * @returns Forecast with confidence
+   *
+   * @example
+   * ```typescript
+   * const historicalCompleteness = [75, 76, 77, 78, 79, 80];
+   * const forecast = analytics.forecastPerformance(
+   *   historicalCompleteness,
+   *   7,
+   *   'v2.0.0',
+   *   'completeness'
+   * );
+   * console.log(`Forecasted: ${forecast.forecastedValue}/100`);
+   * ```
+   */
+  forecastPerformance(metrics, daysAhead, versionId, metricType) {
+    if (metrics.length < this.MIN_SAMPLES_FOR_TREND) {
+      return {
+        versionId,
+        metric: metricType,
+        currentValue: metrics[metrics.length - 1] ?? 0,
+        forecastedValue: metrics[metrics.length - 1] ?? 0,
+        daysAhead,
+        confidence: 0,
+        trendType: "insufficient_data",
+        reasoning: "Insufficient data for forecasting (need at least 5 samples)"
+      };
+    }
+    const trend = this.detectTrend(metrics);
+    const x = Array.from({ length: metrics.length }, (_, i) => i);
+    const { slope, intercept } = this.linearRegression(x, metrics);
+    const forecastedValue = intercept + slope * (metrics.length + daysAhead);
+    const currentValue = metrics[metrics.length - 1] ?? 0;
+    let adjustedForecasted = forecastedValue;
+    if (metricType === "success_rate") {
+      const maxValue = Math.max(...metrics);
+      if (maxValue > 1) {
+        adjustedForecasted = Math.max(0, Math.min(100, forecastedValue));
+      } else {
+        adjustedForecasted = Math.max(0, Math.min(1, forecastedValue));
+      }
+    } else if (metricType === "completeness") {
+      adjustedForecasted = Math.max(0, Math.min(100, forecastedValue));
+    } else if (metricType === "duration") {
+      adjustedForecasted = Math.max(0, forecastedValue);
+    }
+    const distanceConfidence = Math.max(0.2, 1 - daysAhead / 30);
+    const trendConfidence = trend.strength;
+    const confidence = (distanceConfidence + trendConfidence) / 2;
+    let reasoning = `Based on ${metrics.length} historical samples. `;
+    if (trend.type === "improving") {
+      reasoning += `Trending upward (slope: ${slope.toFixed(3)}). `;
+    } else if (trend.type === "declining") {
+      reasoning += `Trending downward (slope: ${slope.toFixed(3)}). `;
+    } else {
+      reasoning += "Performance is stable. ";
+    }
+    reasoning += `Confidence: ${(confidence * 100).toFixed(0)}%`;
+    return {
+      versionId,
+      metric: metricType,
+      currentValue,
+      forecastedValue: adjustedForecasted,
+      daysAhead,
+      confidence,
+      trendType: trend.type,
+      reasoning
+    };
+  }
+  /**
+   * Detect regressions in prompt performance
+   *
+   * @param metrics Array of performance metrics
+   * @param versionId Version being analyzed
+   * @returns Array of detected regressions
+   *
+   * @example
+   * ```typescript
+   * const regressions = analytics.detectRegressions(
+   *   metricsHistory,
+   *   'v1.5.0'
+   * );
+   * regressions.forEach(r => {
+   *   console.log(`[${r.severity}] ${r.metric}: ${r.actualValue} vs ${r.expectedValue}`);
+   * });
+   * ```
+   */
+  detectRegressions(metrics, versionId) {
+    const regressions = [];
+    if (metrics.length < 5) {
+      return regressions;
+    }
+    const successRates = metrics.map((m) => m.successRate);
+    const successRegression = this.detectMetricRegression(successRates, "success_rate");
+    if (successRegression) {
+      regressions.push({
+        versionId,
+        metric: "success_rate",
+        expectedValue: successRegression.expected,
+        actualValue: successRegression.actual,
+        deviation: successRegression.deviation,
+        severity: this.calculateSeverity(successRegression.deviation, "success_rate"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: `Success rate dropped from ${(successRegression.expected * 100).toFixed(1)}% to ${(successRegression.actual * 100).toFixed(1)}%`
+      });
+    }
+    const completeness = metrics.map((m) => m.avgCompleteness);
+    const completenessRegression = this.detectMetricRegression(completeness, "completeness");
+    if (completenessRegression) {
+      regressions.push({
+        versionId,
+        metric: "completeness",
+        expectedValue: completenessRegression.expected,
+        actualValue: completenessRegression.actual,
+        deviation: completenessRegression.deviation,
+        severity: this.calculateSeverity(completenessRegression.deviation, "completeness"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: `Completeness dropped from ${completenessRegression.expected.toFixed(1)} to ${completenessRegression.actual.toFixed(1)}`
+      });
+    }
+    const durations = metrics.map((m) => m.avgDuration);
+    const durationRegression = this.detectMetricRegression(durations, "duration");
+    if (durationRegression && durationRegression.deviation > 0) {
+      regressions.push({
+        versionId,
+        metric: "duration",
+        expectedValue: durationRegression.expected,
+        actualValue: durationRegression.actual,
+        deviation: durationRegression.deviation,
+        severity: this.calculateSeverity(durationRegression.deviation, "duration"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: `Execution time increased from ${durationRegression.expected.toFixed(1)}s to ${durationRegression.actual.toFixed(1)}s`
+      });
+    }
+    return regressions;
+  }
+  /**
+   * Suggest optimizations based on performance analysis
+   *
+   * @param metrics Current performance metrics
+   * @param versionId Version being analyzed
+   * @param historicalMetrics Historical metrics for comparison
+   * @returns Array of actionable suggestions
+   *
+   * @example
+   * ```typescript
+   * const suggestions = analytics.suggestOptimizations(
+   *   currentMetrics,
+   *   'v2.0.0',
+   *   historicalMetrics
+   * );
+   * suggestions.filter(s => s.priority === 'high').forEach(s => {
+   *   console.log(`${s.description}`);
+   *   s.actionItems.forEach(a => console.log(`  - ${a}`));
+   * });
+   * ```
+   */
+  suggestOptimizations(metrics, _versionId, historicalMetrics) {
+    const suggestions = [];
+    if (metrics.successRate < 0.7) {
+      suggestions.push({
+        type: "success_improvement",
+        priority: metrics.successRate <= 0.5 ? "critical" : "high",
+        metric: "success_rate",
+        currentValue: metrics.successRate,
+        targetValue: 0.85,
+        description: `Success rate is low at ${(metrics.successRate * 100).toFixed(1)}%. Target 85%+ for production readiness.`,
+        actionItems: [
+          "Review prompt clarity and specificity",
+          "Add more context or examples",
+          "Check for ambiguous instructions",
+          "Consider testing with different prompt variants"
+        ],
+        estimatedImpact: (0.85 - metrics.successRate) * 100,
+        confidence: 0.75
+      });
+    }
+    if (metrics.stdDevCompleteness && metrics.stdDevCompleteness > 20) {
+      suggestions.push({
+        type: "consistency_improvement",
+        priority: metrics.stdDevCompleteness > 30 ? "high" : "medium",
+        metric: "completeness_variance",
+        currentValue: metrics.stdDevCompleteness,
+        targetValue: 10,
+        description: `Output quality is inconsistent (\u03C3=${metrics.stdDevCompleteness.toFixed(1)}). Improve consistency for reliable deployments.`,
+        actionItems: [
+          "Add structure requirements to prompt",
+          "Provide more specific examples",
+          "Define expected output format clearly",
+          "Test with variance-reducing prompt strategies"
+        ],
+        estimatedImpact: Math.min(15, metrics.stdDevCompleteness - 10),
+        confidence: 0.8
+      });
+    }
+    if (metrics.avgCompleteness < 70) {
+      suggestions.push({
+        type: "completeness_boost",
+        priority: metrics.avgCompleteness < 50 ? "critical" : "high",
+        metric: "avgCompleteness",
+        currentValue: metrics.avgCompleteness,
+        targetValue: 85,
+        description: `Output completeness is low at ${metrics.avgCompleteness.toFixed(1)}/100. Enhance prompt to get more thorough responses.`,
+        actionItems: [
+          "Ask for more detailed explanations",
+          "Request specific sections or components",
+          "Add quality criteria to the prompt",
+          "Include examples of desired output level"
+        ],
+        estimatedImpact: (85 - metrics.avgCompleteness) * 0.5,
+        confidence: 0.7
+      });
+    }
+    if (metrics.avgDuration > 120) {
+      suggestions.push({
+        type: "duration_optimization",
+        priority: metrics.avgDuration > 300 ? "high" : "medium",
+        metric: "avgDuration",
+        currentValue: metrics.avgDuration,
+        targetValue: 60,
+        description: `Execution takes ${metrics.avgDuration.toFixed(0)}s on average. Optimize for faster iterations.`,
+        actionItems: [
+          "Simplify prompt scope",
+          "Remove unnecessary examples",
+          "Use faster provider (check provider analytics)",
+          "Consider breaking into smaller prompts"
+        ],
+        estimatedImpact: (metrics.avgDuration - 60) / metrics.avgDuration * 50,
+        confidence: 0.65
+      });
+    }
+    if (historicalMetrics && historicalMetrics.length >= 3) {
+      const successTrend = this.detectTrend(historicalMetrics.map((m) => m.successRate));
+      const firstMetric = historicalMetrics[0];
+      if (successTrend.type === "improving" && successTrend.strength > 0.3 && firstMetric) {
+        const improvement = (metrics.successRate - firstMetric.successRate) * 100;
+        if (improvement > 3) {
+          suggestions.push({
+            type: "variant_activation",
+            priority: "medium",
+            metric: "trend",
+            currentValue: improvement,
+            targetValue: improvement * 1.5,
+            description: `This version shows consistent improvement (${improvement.toFixed(1)}% gain in success rate). Consider activating.`,
+            actionItems: [
+              "Review recent changes",
+              "Validate with additional test runs",
+              "Activate if confidence threshold met",
+              "Monitor post-activation for regressions"
+            ],
+            estimatedImpact: improvement,
+            confidence: successTrend.strength
+          });
+        }
+      }
+    }
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    suggestions.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    return suggestions;
+  }
+  /**
+   * Calculate trend using linear regression
+   *
+   * @param x X values (time indices)
+   * @param y Y values (metrics)
+   * @returns Slope, intercept, and R-squared
+   */
+  linearRegression(x, y) {
+    const n = x.length;
+    const sumX = x.reduce((a, b) => a + b, 0);
+    const sumY = y.reduce((a, b) => a + b, 0);
+    const sumXY = x.reduce((sum, xi, i) => sum + xi * (y[i] ?? 0), 0);
+    const sumXX = x.reduce((sum, xi) => sum + xi * xi, 0);
+    const sumYY = y.reduce((sum, yi) => sum + yi * yi, 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 = ssTotal === 0 ? 0 : 1 - ssResidual / ssTotal;
+    return { slope, intercept, rSquared };
+  }
+  /**
+   * Detect regression in a metric
+   */
+  detectMetricRegression(metrics, metricType) {
+    if (metrics.length < 5) {
+      return null;
+    }
+    const cutoff = Math.floor(metrics.length * 0.8);
+    const baseline = metrics.slice(0, cutoff);
+    const recent = metrics.slice(cutoff);
+    const mean = baseline.reduce((a, b) => a + b, 0) / baseline.length;
+    const variance = baseline.reduce((sum, v) => sum + (v - mean) ** 2, 0) / baseline.length;
+    const stdDev = Math.sqrt(variance);
+    const recentMean = recent.reduce((a, b) => a + b, 0) / recent.length;
+    const zScore = Math.abs((recentMean - mean) / (stdDev || 1));
+    if (zScore >= this.REGRESSION_THRESHOLD) {
+      const deviation = metricType === "duration" ? (recentMean - mean) / mean * 100 : (mean - recentMean) / mean * 100;
+      return {
+        expected: mean,
+        actual: recentMean,
+        deviation
+      };
+    }
+    return null;
+  }
+  /**
+   * Calculate severity of regression
+   */
+  calculateSeverity(deviation, metricType) {
+    const absDeviation = Math.abs(deviation);
+    if (metricType === "duration") {
+      if (absDeviation > 50) return "critical";
+      if (absDeviation > 30) return "high";
+      if (absDeviation > 15) return "medium";
+      return "low";
+    } else {
+      if (absDeviation > 30) return "critical";
+      if (absDeviation > 20) return "high";
+      if (absDeviation > 10) return "medium";
+      return "low";
+    }
+  }
+  /**
+   * Aggregate metrics from multiple samples
+   *
+   * @param metrics Array of performance metrics
+   * @returns Aggregated metrics with statistics
+   */
+  aggregateMetrics(metrics) {
+    if (metrics.length === 0) {
+      return {
+        successRate: 0,
+        avgCompleteness: 0,
+        avgDuration: 0,
+        variance: 0,
+        consistency: 0,
+        sampleSize: 0,
+        compositeScore: 0,
+        trend: {
+          type: "insufficient_data",
+          strength: 0,
+          slope: 0,
+          direction: "flat",
+          lastNValues: []
+        }
+      };
+    }
+    const successRates = metrics.map((m) => m.successRate);
+    const completeness = metrics.map((m) => m.avgCompleteness);
+    const durations = metrics.map((m) => m.avgDuration);
+    const avgSuccessRate = successRates.reduce((a, b) => a + b, 0) / metrics.length;
+    const avgCompleteness = completeness.reduce((a, b) => a + b, 0) / metrics.length;
+    const avgDuration = durations.reduce((a, b) => a + b, 0) / metrics.length;
+    const variance = completeness.reduce((sum, v) => sum + (v - avgCompleteness) ** 2, 0) / metrics.length;
+    const stdDev = Math.sqrt(variance);
+    const coefficientOfVariation = stdDev / (avgCompleteness || 1);
+    const consistency = Math.max(0, 1 - coefficientOfVariation / 2);
+    const trend = this.detectTrend(completeness);
+    const compositeScore = avgSuccessRate * 40 + avgCompleteness / 100 * 40 + Math.max(0, 1 - avgDuration / 300) * 20;
+    return {
+      successRate: avgSuccessRate,
+      avgCompleteness,
+      avgDuration,
+      variance,
+      consistency: Math.max(0, Math.min(1, consistency)),
+      sampleSize: metrics.length,
+      compositeScore: Math.max(0, Math.min(100, compositeScore)),
+      trend
+    };
+  }
+  /**
+   * Score a version based on metrics
+   *
+   * @param metrics Performance metrics
+   * @returns Score from 0-100
+   *
+   * @example
+   * ```typescript
+   * const score = analytics.scoreVersion(metrics);
+   * console.log(`Version score: ${score.toFixed(1)}/100`);
+   * ```
+   */
+  scoreVersion(metrics) {
+    const successScore = metrics.successRate * 100 * 0.6;
+    const completenessScore = metrics.avgCompleteness * 0.25;
+    const durationScore = Math.max(0, 1 - metrics.avgDuration / 300) * 100 * 0.15;
+    const score = successScore + completenessScore + durationScore;
+    return Math.max(0, Math.min(100, score));
+  }
+  /**
+   * Identify outliers in metrics
+   *
+   * @param metrics Array of values
+   * @param threshold Z-score threshold (default 2.0)
+   * @returns Array of detected outliers
+   *
+   * @example
+   * ```typescript
+   * const values = [0.75, 0.76, 0.77, 0.2, 0.78]; // 0.2 is outlier
+   * const outliers = analytics.identifyOutliers(values);
+   * outliers.forEach(o => {
+   *   console.log(`Value ${o.value} at index ${o.index} is an outlier`);
+   * });
+   * ```
+   */
+  identifyOutliers(metrics, threshold = 2) {
+    if (metrics.length < 3) {
+      return [];
+    }
+    const mean = metrics.reduce((a, b) => a + b, 0) / metrics.length;
+    const variance = metrics.reduce((sum, v) => sum + (v - mean) ** 2, 0) / metrics.length;
+    const stdDev = Math.sqrt(variance);
+    const outliers = [];
+    for (let i = 0; i < metrics.length; i++) {
+      const value = metrics[i];
+      if (value === void 0) continue;
+      const zscore = Math.abs((value - mean) / (stdDev || 1));
+      const isOutlier = zscore > threshold;
+      if (isOutlier) {
+        outliers.push({
+          index: i,
+          value,
+          expectedRange: [mean - 2 * stdDev, mean + 2 * stdDev],
+          zscore,
+          isOutlier: true
+        });
+      }
+    }
+    return outliers;
+  }
+  /**
+   * Calculate trend line for visualization
+   *
+   * @param metrics Array of metric values
+   * @returns Array of predicted values matching input length
+   */
+  calculateTrendLine(metrics) {
+    if (metrics.length < 2) {
+      return metrics;
+    }
+    const x = Array.from({ length: metrics.length }, (_, i) => i);
+    const { slope, intercept } = this.linearRegression(x, metrics);
+    return x.map((xi) => intercept + slope * xi);
+  }
+};
+
+// src/prompts/prompt-analytics.ts
+var PromptAnalytics = class {
+  operations;
+  analyticsEngine;
+  constructor(operations) {
+    this.operations = operations;
+    this.analyticsEngine = new AnalyticsEngine();
+  }
+  /**
+   * Auto-tune a prompt by evaluating variants and activating if criteria met
+   *
+   * Evaluates variant candidates against current version and automatically
+   * activates the best performer if improvement meets configured threshold.
+   * Includes comprehensive safety checks to prevent bad activations.
+   *
+   * @param promptId ID of the prompt to auto-tune
+   * @param options Auto-tuning configuration
+   * @returns Auto-tuning result with decision and rationale
+   * @throws Error if prompt not found or auto-tuning fails
+   *
+   * @example
+   * ```ts
+   * const result = await analytics.autoTunePrompt('user-auth', {
+   *   minSampleSize: 10,
+   *   significanceThreshold: 10,
+   *   enableAutoActivation: true,
+   * });
+   * console.log(`Auto-tuning: ${result.shouldAutoTune ? 'activated' : 'skipped'}`);
+   * if (result.selectedCandidate) {
+   *   console.log(`Activated version: ${result.selectedCandidate}`);
+   * }
+   * ```
+   */
+  async autoTunePrompt(promptId, options) {
+    try {
+      this.operations.getOrThrow(promptId);
+      const currentVersion = this.operations.getActiveVersionOrThrow(promptId);
+      const versions = this.operations.listVersions(promptId);
+      const candidates = [];
+      for (const version of versions) {
+        const metrics = this.operations.getPerformance(version.id);
+        const score = metrics ? this.analyticsEngine.scoreVersion(metrics) : 0;
+        candidates.push({
+          versionId: version.id,
+          metrics,
+          score
+        });
+      }
+      const minSampleSize = options?.minSampleSize ?? 10;
+      const validCandidates = candidates.filter(
+        (c) => c.metrics && c.metrics.sampleSize >= minSampleSize
+      );
+      if (validCandidates.length === 0) {
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          shouldAutoTune: false,
+          candidates: [],
+          reason: `No versions have sufficient sample size (need ${minSampleSize}+ samples)`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const currentScore = candidates.find((c) => c.versionId === currentVersion.id)?.score ?? 0;
+      const bestCandidate = validCandidates.reduce(
+        (best, current) => current.score > best.score ? current : best
+      );
+      if (bestCandidate.versionId === currentVersion.id) {
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          shouldAutoTune: false,
+          candidates: validCandidates.map((c) => ({
+            versionId: c.versionId,
+            improvementPercentage: 0,
+            confidence: 1
+          })),
+          reason: "Current version is already the best performer",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const improvementPercentage = currentScore > 0 ? (bestCandidate.score - currentScore) / currentScore * 100 : bestCandidate.score > 0 ? 100 : 0;
+      const significanceThreshold = options?.significanceThreshold ?? 10;
+      if (improvementPercentage < significanceThreshold) {
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          shouldAutoTune: false,
+          candidates: validCandidates.map((c) => ({
+            versionId: c.versionId,
+            improvementPercentage: (c.score - currentScore) / currentScore * 100,
+            confidence: (c.metrics?.sampleSize ?? 0) / 100
+          })),
+          reason: `Improvement (${improvementPercentage.toFixed(1)}%) below threshold (${significanceThreshold}%)`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const safetyChecks = [];
+      const currentMetrics = candidates.find((c) => c.versionId === currentVersion.id)?.metrics;
+      if (currentMetrics && bestCandidate.metrics) {
+        const successRateChange = (bestCandidate.metrics.successRate - currentMetrics.successRate) * 100;
+        safetyChecks.push({
+          check: "success_rate",
+          passed: successRateChange >= -5,
+          message: `Success rate change: ${successRateChange.toFixed(1)}%`
+        });
+      }
+      if (currentMetrics && bestCandidate.metrics) {
+        const completenessChange = bestCandidate.metrics.avgCompleteness - currentMetrics.avgCompleteness;
+        safetyChecks.push({
+          check: "completeness",
+          passed: completenessChange >= -10,
+          message: `Completeness change: ${completenessChange.toFixed(1)} points`
+        });
+      }
+      const allChecksPassed = safetyChecks.every((c) => c.passed);
+      if (!allChecksPassed) {
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          shouldAutoTune: false,
+          candidates: validCandidates.map((c) => ({
+            versionId: c.versionId,
+            improvementPercentage: (c.score - currentScore) / currentScore * 100,
+            confidence: (c.metrics?.sampleSize ?? 0) / 100
+          })),
+          reason: `Safety checks failed: ${safetyChecks.filter((c) => !c.passed).map((c) => c.check).join(", ")}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const enableAutoActivation = options?.enableAutoActivation ?? false;
+      let shouldAutoTune = false;
+      let selectedCandidate;
+      if (enableAutoActivation) {
+        shouldAutoTune = true;
+        selectedCandidate = bestCandidate.versionId;
+        try {
+          await this.operations.activateVersion(bestCandidate.versionId, {
+            reason: `Auto-tuned: ${improvementPercentage.toFixed(1)}% improvement in composite score`
+          });
+        } catch (activateError) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: "prompt-analytics",
+              subsystem: "prompts",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                error: activateError.message,
+                operation: "autoActivateVersion",
+                versionId: bestCandidate.versionId,
+                promptId
+              }
+            }
+          );
+          shouldAutoTune = false;
+          selectedCandidate = void 0;
+        }
+      }
+      return {
+        promptId,
+        versionId: currentVersion.id,
+        shouldAutoTune,
+        candidates: validCandidates.map((c) => ({
+          versionId: c.versionId,
+          improvementPercentage: (c.score - currentScore) / currentScore * 100,
+          confidence: (c.metrics?.sampleSize ?? 0) / 100
+        })),
+        selectedCandidate,
+        reason: `Significant improvement (${improvementPercentage.toFixed(1)}%) meets activation criteria`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Failed to auto-tune prompt "${promptId}": ${error.message}`);
+    }
+  }
+  /**
+   * Monitor an auto-activated version for regressions
+   *
+   * Monitors recently activated versions for performance regressions and
+   * triggers rollback if necessary. Uses post-activation data to validate
+   * that the activation was beneficial.
+   *
+   * @param promptId ID of the prompt to monitor
+   * @param options Monitoring configuration
+   * @returns Monitoring result with status and details
+   * @throws Error if monitoring fails
+   *
+   * @example
+   * ```ts
+   * const result = await analytics.monitorAutoTuning('user-auth');
+   * if (result.regressionDetected) {
+   *   console.log(`[REGRESSION] ${result.details}`);
+   *   // Automatic rollback handled if needed
+   * } else {
+   *   console.log(`[OK] Performance validated: ${result.details}`);
+   * }
+   * ```
+   */
+  async monitorAutoTuning(promptId, options) {
+    try {
+      this.operations.getOrThrow(promptId);
+      const currentVersion = this.operations.getActiveVersionOrThrow(promptId);
+      const allVersions = this.operations.listVersions(promptId);
+      const currentMetrics = this.operations.getPerformance(currentVersion.id);
+      if (!currentMetrics) {
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          monitoringStatus: "validating",
+          samplesSinceActivation: 0,
+          performanceChange: 0,
+          regressionDetected: false,
+          details: "No performance data available yet",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const previousVersions = allVersions.filter((v) => v.id !== currentVersion.id).sort(
+        (a, b) => new Date(b.deactivatedAt || "").getTime() - new Date(a.deactivatedAt || "").getTime()
+      );
+      if (previousVersions.length === 0) {
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          monitoringStatus: "validating",
+          samplesSinceActivation: currentMetrics.sampleSize,
+          performanceChange: 0,
+          regressionDetected: false,
+          details: "No previous version for comparison",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const previousMetrics = previousVersions[0] ? this.operations.getPerformance(previousVersions[0].id) : null;
+      if (!previousMetrics) {
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          monitoringStatus: "validating",
+          samplesSinceActivation: currentMetrics.sampleSize,
+          performanceChange: 0,
+          regressionDetected: false,
+          details: "No performance data for previous version",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const minSamplesSinceActivation = options?.minSamplesSinceActivation ?? 5;
+      const samplesSinceActivation = currentMetrics.sampleSize - previousMetrics.sampleSize;
+      if (samplesSinceActivation < minSamplesSinceActivation) {
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          monitoringStatus: "validating",
+          samplesSinceActivation,
+          performanceChange: 0,
+          regressionDetected: false,
+          details: `Still collecting data (${samplesSinceActivation}/${minSamplesSinceActivation} samples)`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const currentScore = this.analyticsEngine.scoreVersion(currentMetrics);
+      const previousScore = this.analyticsEngine.scoreVersion(previousMetrics);
+      const performanceChange = (currentScore - previousScore) / previousScore * 100;
+      let regressionDetected = false;
+      let details = "";
+      if (performanceChange < -15) {
+        regressionDetected = true;
+        details = `Significant regression detected (${performanceChange.toFixed(1)}% worse than previous version). Consider rollback.`;
+        try {
+          await this.operations.rollbackVersion(promptId);
+          details += " Automatic rollback performed.";
+        } catch (rollbackError) {
+          details += ` Rollback failed: ${rollbackError.message}`;
+        }
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          monitoringStatus: "needs_rollback",
+          samplesSinceActivation,
+          performanceChange,
+          regressionDetected,
+          details,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      } else if (performanceChange >= -5) {
+        details = `Performance validated (${performanceChange >= 0 ? "+" : ""}${performanceChange.toFixed(1)}%). Version performing as expected.`;
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          monitoringStatus: "validated",
+          samplesSinceActivation,
+          performanceChange,
+          regressionDetected: false,
+          details,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      } else {
+        details = `Minor deviation (${performanceChange.toFixed(1)}%). Continuing to monitor.`;
+        return {
+          promptId,
+          versionId: currentVersion.id,
+          monitoringStatus: "validating",
+          samplesSinceActivation,
+          performanceChange,
+          regressionDetected: false,
+          details,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to monitor auto-tuning for "${promptId}": ${error.message}`
+      );
+    }
+  }
+  /**
+   * Get performance analysis for a prompt
+   *
+   * Analyzes performance metrics and detects trends, regressions, and
+   * optimization opportunities. Returns comprehensive analytics including
+   * trend detection, forecasting, and suggestions.
+   *
+   * @param promptId ID of the prompt to analyze
+   * @param versionId Optional specific version to analyze
+   * @returns Analysis including trends, regressions, and suggestions
+   * @throws Error if analysis fails
+   *
+   * @example
+   * ```ts
+   * const analysis = await analytics.analyzePerformance('user-auth');
+   * console.log(`Trend: ${analysis.trend.type}`);
+   * analysis.suggestions.forEach(s => {
+   *   console.log(`[${s.priority}] ${s.description}`);
+   * });
+   * ```
+   */
+  async analyzePerformance(promptId, versionId) {
+    try {
+      const prompt = this.operations.getOrThrow(promptId);
+      let metrics;
+      if (versionId) {
+        metrics = this.operations.getPerformance(versionId);
+      } else {
+        const activeVersion = this.operations.getActiveVersion(promptId);
+        metrics = activeVersion ? this.operations.getPerformance(activeVersion.id) : null;
+      }
+      if (!metrics) {
+        throw new Error("No performance data available for analysis");
+      }
+      const allVersions = this.operations.listVersions(promptId);
+      const allMetrics = [];
+      for (const version of allVersions) {
+        const m = this.operations.getPerformance(version.id);
+        if (m) {
+          allMetrics.push(m);
+        }
+      }
+      const completenessValues = allMetrics.map((m) => m.avgCompleteness);
+      const trend = this.analyticsEngine.detectTrend(completenessValues);
+      const detectedRegressions = this.analyticsEngine.detectRegressions(
+        allMetrics,
+        versionId || metrics.versionId
+      );
+      const suggestions = this.analyticsEngine.suggestOptimizations(
+        metrics,
+        versionId || metrics.versionId,
+        allMetrics.length > 1 ? allMetrics : void 0
+      );
+      return {
+        prompt,
+        trend,
+        regressions: detectedRegressions.map((r) => ({
+          metric: r.metric,
+          severity: r.severity,
+          details: r.reason
+        })),
+        suggestions,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to analyze performance for "${promptId}": ${error.message}`
+      );
+    }
+  }
+  /**
+   * Get performance trend for a prompt
+   *
+   * @param promptId ID of the prompt
+   * @param versionId Optional specific version
+   * @returns Trend analysis
+   *
+   * @example
+   * ```ts
+   * const trend = await analytics.getPerformanceTrend('user-auth');
+   * console.log(`Status: ${trend.type} (strength: ${trend.strength})`);
+   * ```
+   */
+  async getPerformanceTrend(promptId, _versionId) {
+    try {
+      const allVersions = this.operations.listVersions(promptId);
+      const metrics = [];
+      for (const version of allVersions) {
+        const m = this.operations.getPerformance(version.id);
+        if (m) {
+          metrics.push(m);
+        }
+      }
+      if (metrics.length === 0) {
+        return {
+          type: "insufficient_data",
+          strength: 0,
+          slope: 0,
+          direction: "flat",
+          lastNValues: []
+        };
+      }
+      const completenessValues = metrics.map((m) => m.avgCompleteness);
+      return this.analyticsEngine.detectTrend(completenessValues);
+    } catch (error) {
+      throw new Error(`Failed to get trend for "${promptId}": ${error.message}`);
+    }
+  }
+  /**
+   * Get optimization suggestions for a prompt
+   *
+   * @param promptId ID of the prompt
+   * @returns Array of actionable suggestions
+   *
+   * @example
+   * ```ts
+   * const suggestions = await analytics.getSuggestions('user-auth');
+   * suggestions.filter(s => s.priority === 'critical').forEach(s => {
+   *   console.log(`ACTION: ${s.description}`);
+   * });
+   * ```
+   */
+  async getSuggestions(promptId) {
+    try {
+      const activeVersion = this.operations.getActiveVersionOrThrow(promptId);
+      const metrics = this.operations.getPerformance(activeVersion.id);
+      if (!metrics) {
+        return [];
+      }
+      const allVersions = this.operations.listVersions(promptId);
+      const allMetrics = [];
+      for (const version of allVersions) {
+        const m = this.operations.getPerformance(version.id);
+        if (m) {
+          allMetrics.push(m);
+        }
+      }
+      return this.analyticsEngine.suggestOptimizations(
+        metrics,
+        activeVersion.id,
+        allMetrics.length > 1 ? allMetrics : void 0
+      );
+    } catch (error) {
+      throw new Error(`Failed to get suggestions for "${promptId}": ${error.message}`);
+    }
+  }
+};
+
+// src/prompts/variant-generator.ts
+var VariantGenerator = class {
+  /**
+   * Generate variants for A/B testing
+   */
+  async generateVariants(basePrompt, count = 3, _options) {
+    const { strategies, targetMetric = "balanced" } = _options || {};
+    const selectedStrategies = strategies || this.selectOptimalStrategies(targetMetric, count);
+    const variants = [];
+    for (const strategy of selectedStrategies) {
+      const variant = await this.generateVariant(basePrompt, strategy);
+      variants.push(variant);
+    }
+    return variants;
+  }
+  /**
+   * Generate single variant using mutation strategy
+   */
+  async generateVariant(basePrompt, strategy) {
+    const content = basePrompt.content;
+    const mutations = [];
+    let mutatedContent = content;
+    switch (strategy) {
+      case "clarity":
+        mutatedContent = this.improveClarity(content, mutations);
+        break;
+      case "conciseness":
+        mutatedContent = this.improveConciseness(content, mutations);
+        break;
+      case "context":
+        mutatedContent = this.addContext(content, mutations);
+        break;
+      case "examples":
+        mutatedContent = this.addExamples(content, mutations);
+        break;
+      case "structure":
+        mutatedContent = this.improveStructure(content, mutations);
+        break;
+      case "constraints":
+        mutatedContent = this.addConstraints(content, mutations);
+        break;
+      case "tone":
+        mutatedContent = this.adjustTone(content, mutations);
+        break;
+      case "hybrid":
+        mutatedContent = this.hybridMutation(content, mutations);
+        break;
+    }
+    return {
+      content: mutatedContent,
+      mutations,
+      expectedImprovement: this.predictImprovement(strategy),
+      testHypothesis: this.generateHypothesis(strategy),
+      confidence: this.estimateConfidence(strategy, mutations.length)
+    };
+  }
+  /**
+   * Close resources
+   */
+  close() {
+  }
+  // Private methods
+  selectOptimalStrategies(targetMetric, count) {
+    const strategyMap = {
+      success_rate: ["clarity", "examples", "structure"],
+      completeness: ["context", "constraints", "examples"],
+      duration: ["conciseness", "clarity", "structure"],
+      balanced: ["clarity", "context", "structure", "examples", "hybrid"]
+    };
+    const strategies = strategyMap[targetMetric] || strategyMap.balanced;
+    const finalStrategies = strategies || ["clarity", "context", "structure", "examples", "hybrid"];
+    return finalStrategies.slice(0, count);
+  }
+  improveClarity(content, mutations) {
+    let result = content;
+    if (!result.includes("specific")) {
+      const insertion = "\n\nBe specific and explicit in your implementation.";
+      result = result + insertion;
+      mutations.push({
+        strategy: "clarity",
+        description: "Add specificity instruction",
+        before: content,
+        after: insertion,
+        rationale: "Explicit instructions reduce ambiguity"
+      });
+    }
+    if (!result.match(/step|1\.|first/i)) {
+      const insertion = "\n\nSteps:\n1. Analyze requirements\n2. Plan implementation\n3. Write code\n4. Test solution";
+      result = result + insertion;
+      mutations.push({
+        strategy: "clarity",
+        description: "Add step-by-step breakdown",
+        before: content,
+        after: insertion,
+        rationale: "Step-by-step improves success rate"
+      });
+    }
+    return result;
+  }
+  improveConciseness(content, mutations) {
+    let result = content;
+    const redundantPhrases = [
+      /please note that /gi,
+      /it is important to /gi,
+      /you should make sure to /gi
+    ];
+    for (const pattern of redundantPhrases) {
+      if (pattern.test(result)) {
+        const before = result;
+        result = result.replace(pattern, "");
+        mutations.push({
+          strategy: "conciseness",
+          description: "Remove redundant phrase",
+          before,
+          after: result,
+          rationale: "Concise prompts reduce cognitive load"
+        });
+      }
+    }
+    return result;
+  }
+  addContext(content, mutations) {
+    let result = content;
+    if (!result.match(/context|background/i)) {
+      const insertion = "\n\nContext: Consider existing codebase patterns and maintain consistency.";
+      result = result + insertion;
+      mutations.push({
+        strategy: "context",
+        description: "Add background context",
+        before: content,
+        after: insertion,
+        rationale: "Context helps AI make better decisions"
+      });
+    }
+    if (!result.match(/success|criteria/i)) {
+      const insertion = "\n\nSuccess criteria:\n- All tests pass\n- Code follows conventions\n- Complete implementation";
+      result = result + insertion;
+      mutations.push({
+        strategy: "context",
+        description: "Add success criteria",
+        before: content,
+        after: insertion,
+        rationale: "Clear criteria improve completeness"
+      });
+    }
+    return result;
+  }
+  addExamples(content, mutations) {
+    let result = content;
+    if (!result.match(/example|for instance/i)) {
+      const insertion = "\n\nExample:\n```text\n1. Validate inputs at the boundary\n2. Apply the core change following existing patterns\n3. Return or report the result explicitly\n```";
+      result = result + insertion;
+      mutations.push({
+        strategy: "examples",
+        description: "Add illustrative example outline",
+        before: content,
+        after: insertion,
+        rationale: "Examples clarify expected output"
+      });
+    }
+    return result;
+  }
+  improveStructure(content, mutations) {
+    let result = content;
+    if (!result.match(/^#{1,3} /m)) {
+      const lines = result.split("\n");
+      const sections = [
+        "## Objective",
+        lines[0],
+        "\n## Requirements",
+        ...lines.slice(1, 3),
+        "\n## Implementation",
+        ...lines.slice(3)
+      ].join("\n");
+      mutations.push({
+        strategy: "structure",
+        description: "Add section headers",
+        before: content,
+        after: sections,
+        rationale: "Structure improves comprehension"
+      });
+      result = sections;
+    }
+    return result;
+  }
+  addConstraints(content, mutations) {
+    let result = content;
+    if (!result.match(/constraint|must/i)) {
+      const insertion = "\n\nConstraints:\n- Respect the project's type system and compiler/linter settings\n- Follow existing patterns\n- Include error handling";
+      result = result + insertion;
+      mutations.push({
+        strategy: "constraints",
+        description: "Add technical constraints",
+        before: content,
+        after: insertion,
+        rationale: "Constraints guide implementation quality"
+      });
+    }
+    return result;
+  }
+  adjustTone(content, mutations) {
+    let result = content;
+    const passivePatterns = [
+      { pattern: /you could /gi, replacement: "You must " },
+      { pattern: /might want to /gi, replacement: "Should " }
+    ];
+    for (const { pattern, replacement } of passivePatterns) {
+      if (pattern.test(result)) {
+        const before = result;
+        result = result.replace(pattern, replacement);
+        mutations.push({
+          strategy: "tone",
+          description: "Make more directive",
+          before,
+          after: result,
+          rationale: "Directive tone improves completion"
+        });
+      }
+    }
+    return result;
+  }
+  hybridMutation(content, mutations) {
+    let result = content;
+    result = this.improveClarity(result, mutations);
+    result = this.addContext(result, mutations);
+    result = this.improveStructure(result, mutations);
+    return result;
+  }
+  predictImprovement(strategy) {
+    const predictions = {
+      clarity: "10-15% improvement in success rate",
+      conciseness: "5-10% faster execution",
+      context: "15-20% better completeness",
+      examples: "20-25% higher success rate",
+      structure: "10-15% better comprehension",
+      constraints: "15-20% higher code quality",
+      tone: "5-10% better task completion",
+      hybrid: "15-25% overall improvement"
+    };
+    return predictions[strategy];
+  }
+  generateHypothesis(strategy) {
+    const hypotheses = {
+      clarity: "Clearer instructions reduce ambiguity",
+      conciseness: "Concise prompts reduce execution time",
+      context: "Additional context improves quality",
+      examples: "Examples clarify expectations",
+      structure: "Better structure improves comprehension",
+      constraints: "Constraints guide implementation",
+      tone: "Directive tone improves completion",
+      hybrid: "Combined improvements optimize multiple metrics"
+    };
+    return hypotheses[strategy];
+  }
+  estimateConfidence(strategy, mutationCount) {
+    const strategyConfidence = {
+      clarity: 0.85,
+      conciseness: 0.7,
+      context: 0.8,
+      examples: 0.9,
+      structure: 0.75,
+      constraints: 0.8,
+      tone: 0.65,
+      hybrid: 0.75
+    };
+    const base = strategyConfidence[strategy];
+    const mutationBonus = Math.min(mutationCount * 0.05, 0.15);
+    return Math.min(base + mutationBonus, 0.95);
+  }
+};
+
+// src/prompts/prompt-operations.ts
+var PromptOperations = class {
+  store;
+  constructor(options = {}) {
+    this.store = new PromptStore(options);
+  }
+  /**
+   * Get the underlying store instance
+   */
+  getStore() {
+    return this.store;
+  }
+  /**
+   * Create a new prompt with optional initial version
+   */
+  async create(options) {
+    try {
+      const prompt = await this.store.createPrompt({
+        id: options.id,
+        name: options.name,
+        description: options.description,
+        category: options.category,
+        variant: options.variant,
+        tags: options.tags || [],
+        autoOptimize: options.autoOptimize ?? false
+      });
+      let version;
+      if (options.initialContent !== void 0 && options.initialContent !== null) {
+        const versionId = options.initialVersion || "v1.0.0";
+        version = await this.store.createVersion(options.id, versionId, options.initialContent, {
+          changelog: "Initial version",
+          author: options.author,
+          activate: true
+        });
+      }
+      return { prompt, version };
+    } catch (error) {
+      throw new Error(`Failed to create prompt "${options.id}": ${error.message}`);
+    }
+  }
+  /**
+   * Get a prompt by ID
+   */
+  get(id) {
+    try {
+      return this.store.getPrompt(id);
+    } catch (error) {
+      throw new Error(`Failed to get prompt "${id}": ${error.message}`);
+    }
+  }
+  /**
+   * Get a prompt by ID, throwing if not found
+   */
+  getOrThrow(id) {
+    const prompt = this.get(id);
+    if (!prompt) {
+      throw new Error(`Prompt with ID "${id}" not found`);
+    }
+    return prompt;
+  }
+  /**
+   * Update a prompt
+   */
+  async update(id, options) {
+    const result = await this.store.updatePrompt(id, options);
+    if (!result) {
+      throw new Error("Failed to update prompt");
+    }
+    return result;
+  }
+  /**
+   * Delete a prompt and all its versions
+   */
+  async delete(id) {
+    const result = this.store.deletePrompt(id);
+    if (!result) {
+      throw new Error("Failed to delete prompt");
+    }
+  }
+  /**
+   * Archive a prompt
+   */
+  async archive(id) {
+    return this.update(id, { status: "archived" });
+  }
+  /**
+   * Restore an archived prompt
+   */
+  async restore(id) {
+    return this.update(id, { status: "active" });
+  }
+  /**
+   * List prompts with optional filtering
+   */
+  list(criteria) {
+    try {
+      return this.store.listPrompts(criteria);
+    } catch (error) {
+      throw new Error(`Failed to list prompts: ${error.message}`);
+    }
+  }
+  /**
+   * Search prompts by query string
+   */
+  search(query, options) {
+    return this.list({ ...options, query });
+  }
+  /**
+   * Create a new version for a prompt
+   */
+  async createVersion(options) {
+    try {
+      let versionId = options.version;
+      if (!versionId) {
+        versionId = await this.getNextVersion(options.promptId);
+      }
+      return await this.store.createVersion(options.promptId, versionId, options.content, {
+        changelog: options.changelog,
+        author: options.author,
+        activate: options.activate !== false,
+        // Default to true
+        isGenerated: options.isGenerated,
+        generationModel: options.generationModel,
+        generationPrompt: options.generationPrompt
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to create version for prompt "${options.promptId}": ${error.message}`
+      );
+    }
+  }
+  getVersion(idOrPromptId, versionId) {
+    try {
+      if (versionId === void 0) {
+        return this.store.getVersion(idOrPromptId);
+      }
+      return this.store.getVersion(idOrPromptId, versionId);
+    } catch (error) {
+      const errorMsg = versionId ? `Failed to get version "${versionId}" for prompt "${idOrPromptId}"` : `Failed to get version "${idOrPromptId}"`;
+      throw new Error(`${errorMsg}: ${error.message}`);
+    }
+  }
+  /**
+   * Get active version for a prompt
+   */
+  getActiveVersion(promptId) {
+    try {
+      return this.store.getActiveVersion(promptId);
+    } catch (error) {
+      throw new Error(
+        `Failed to get active version for prompt "${promptId}": ${error.message}`
+      );
+    }
+  }
+  /**
+   * Get active version, throwing if not found
+   */
+  getActiveVersionOrThrow(promptId) {
+    const version = this.getActiveVersion(promptId);
+    if (!version) {
+      throw new Error(`No active version found for prompt "${promptId}"`);
+    }
+    return version;
+  }
+  /**
+   * List all versions for a prompt
+   */
+  listVersions(promptId) {
+    try {
+      return this.store.listVersions(promptId);
+    } catch (error) {
+      throw new Error(
+        `Failed to list versions for prompt "${promptId}": ${error.message}`
+      );
+    }
+  }
+  /**
+   * Deactivate a version
+   */
+  async deactivateVersion(versionId) {
+    try {
+      await this.store.deactivateVersion(versionId);
+    } catch (error) {
+      throw new Error(`Failed to deactivate version "${versionId}": ${error.message}`);
+    }
+  }
+  /**
+   * Get performance metrics for a version
+   */
+  getPerformance(versionId, variant) {
+    try {
+      return this.store.getPerformanceMetrics(versionId, variant);
+    } catch (error) {
+      throw new Error(
+        `Failed to get performance metrics for version "${versionId}": ${error.message}`
+      );
+    }
+  }
+  /**
+   * Increment usage count when a prompt is used
+   */
+  recordUsage(promptId) {
+    try {
+      this.store.incrementUsage(promptId);
+    } catch (error) {
+      emitWarning(
+        "CFG-002",
+        {
+          taskId: "prompt-operations",
+          subsystem: "prompts",
+          executionPhase: "execution"
+        },
+        {
+          severity: "INFO" /* INFO */,
+          metadata: {
+            error: error.message,
+            operation: "recordUsage",
+            promptId
+          }
+        }
+      );
+    }
+  }
+  /**
+   * Batch increment usage counts for multiple prompts
+   * More efficient than calling recordUsage multiple times (prevents N+1 queries)
+   */
+  recordUsageBatch(promptIds) {
+    if (promptIds.length === 0) {
+      return;
+    }
+    try {
+      this.store.incrementUsageBatch(promptIds);
+    } catch (error) {
+      emitWarning(
+        "CFG-002",
+        {
+          taskId: "prompt-operations",
+          subsystem: "prompts",
+          executionPhase: "execution"
+        },
+        {
+          severity: "INFO" /* INFO */,
+          metadata: {
+            error: error.message,
+            operation: "recordUsageBatch",
+            promptCount: promptIds.length
+          }
+        }
+      );
+    }
+  }
+  /**
+   * Compare two prompts or versions
+   */
+  async compare(promptIdA, promptIdB, versionIdA, versionIdB) {
+    try {
+      const promptA = this.getOrThrow(promptIdA);
+      const promptB = this.getOrThrow(promptIdB);
+      const versionA = versionIdA ? this.store.getVersion(promptIdA, versionIdA) : this.getActiveVersion(promptIdA);
+      const versionB = versionIdB ? this.store.getVersion(promptIdB, versionIdB) : this.getActiveVersion(promptIdB);
+      if (!versionA || !versionB) {
+        throw new Error("One or both versions not found");
+      }
+      const metricsA = this.store.getPerformanceMetrics(versionA.id);
+      const metricsB = this.store.getPerformanceMetrics(versionB.id);
+      const lengthDelta = versionB.content.length - versionA.content.length;
+      const wordCountA = versionA.content.split(/\s+/).length;
+      const wordCountB = versionB.content.split(/\s+/).length;
+      const wordCountDelta = wordCountB - wordCountA;
+      const contentDiff = this.generateDiff(versionA.content, versionB.content);
+      let performanceComparison;
+      if (metricsA && metricsB) {
+        const successRateDelta = metricsB.successRate - metricsA.successRate;
+        const completenessDelta = metricsB.avgCompleteness - metricsA.avgCompleteness;
+        const durationDelta = metricsB.avgDuration - metricsA.avgDuration;
+        let recommendation;
+        let rationale;
+        if (metricsA.sampleSize < 10 || metricsB.sampleSize < 10) {
+          recommendation = "test_more";
+          rationale = "Insufficient data for confident recommendation (need 10+ samples)";
+        } else if (successRateDelta > 0.1 && completenessDelta > 5) {
+          recommendation = "use_b";
+          rationale = `Version B shows significantly better performance (+${(successRateDelta * 100).toFixed(1)}% success rate, +${completenessDelta.toFixed(1)} completeness)`;
+        } else if (successRateDelta < -0.1 && completenessDelta < -5) {
+          recommendation = "use_a";
+          rationale = `Version A shows significantly better performance (+${Math.abs(successRateDelta * 100).toFixed(1)}% success rate, +${Math.abs(completenessDelta).toFixed(1)} completeness)`;
+        } else if (Math.abs(successRateDelta) < 0.05 && Math.abs(completenessDelta) < 3) {
+          recommendation = "combine";
+          rationale = "Performance is similar - consider combining best aspects of both";
+        } else {
+          recommendation = "test_more";
+          rationale = "Results are mixed - need more data for clear recommendation";
+        }
+        performanceComparison = {
+          successRateDelta,
+          completenessDelta,
+          durationDelta,
+          recommendation,
+          rationale
+        };
+      }
+      return {
+        promptA,
+        promptB,
+        versionA,
+        versionB,
+        metricsA: metricsA || void 0,
+        metricsB: metricsB || void 0,
+        differences: {
+          contentDiff,
+          lengthDelta,
+          wordCountDelta
+        },
+        performanceComparison
+      };
+    } catch (error) {
+      throw new Error(`Failed to compare prompts: ${error.message}`);
+    }
+  }
+  /**
+   * Clone a prompt with a new ID
+   */
+  async clone(sourceId, newId, newName, options) {
+    try {
+      const source = this.getOrThrow(sourceId);
+      const activeVersion = this.getActiveVersion(sourceId);
+      if (!activeVersion) {
+        throw new Error("Source prompt has no active version");
+      }
+      const result = await this.create({
+        id: newId,
+        name: newName,
+        description: `${source.description} (cloned from ${sourceId})`,
+        category: source.category,
+        variant: source.variant,
+        tags: [...source.tags, "cloned"],
+        initialContent: activeVersion.content,
+        initialVersion: activeVersion.id,
+        author: options?.author
+      });
+      if (options?.cloneVersions) {
+        const versions = this.listVersions(sourceId);
+        const existingVersionIds = /* @__PURE__ */ new Set([result.version?.id || activeVersion.id]);
+        for (const version of versions) {
+          if (version.id !== activeVersion.id && !existingVersionIds.has(version.id)) {
+            await this.store.createVersion(newId, version.id, version.content, {
+              changelog: version.changelog,
+              author: options?.author,
+              activate: false
+            });
+            existingVersionIds.add(version.id);
+          }
+        }
+      }
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to clone prompt "${sourceId}": ${error.message}`);
+    }
+  }
+  /**
+   * Batch archive multiple prompts
+   */
+  async archiveBatch(ids) {
+    const result = {
+      total: ids.length,
+      successful: 0,
+      failed: 0,
+      errors: []
+    };
+    for (const id of ids) {
+      try {
+        await this.archive(id);
+        result.successful++;
+      } catch (error) {
+        result.failed++;
+        result.errors.push({
+          promptId: id,
+          _error: error.message
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * Batch delete multiple prompts
+   */
+  async deleteBatch(ids) {
+    const result = {
+      total: ids.length,
+      successful: 0,
+      failed: 0,
+      errors: []
+    };
+    for (const id of ids) {
+      try {
+        await this.delete(id);
+        result.successful++;
+      } catch (error) {
+        result.failed++;
+        result.errors.push({
+          promptId: id,
+          _error: error.message
+        });
+      }
+    }
+    return result;
+  }
+  /**
+   * Get statistics for all prompts
+   */
+  getStatistics() {
+    try {
+      const prompts = this.list();
+      const byStatus = {};
+      const byCategory = {};
+      let totalVersions = 0;
+      let totalUsage = 0;
+      for (const prompt of prompts) {
+        byStatus[prompt.status] = (byStatus[prompt.status] || 0) + 1;
+        byCategory[prompt.category] = (byCategory[prompt.category] || 0) + 1;
+        totalVersions += this.listVersions(prompt.id).length;
+        totalUsage += prompt.usageCount;
+      }
+      return {
+        total: prompts.length,
+        byStatus,
+        byCategory,
+        totalVersions,
+        totalUsage
+      };
+    } catch (error) {
+      throw new Error(`Failed to get statistics: ${error.message}`);
+    }
+  }
+  /**
+   * Save a new prompt with initial content
+   *
+   * Creates a new prompt with the given name and content, automatically
+   * setting the initial version to v1. Returns the created prompt ID.
+   *
+   * @param name - Human-readable prompt name (must be unique within category)
+   * @param content - Initial prompt content
+   * @param options - Optional configuration (category, tags, author, autoOptimize)
+   * @returns Promise resolving to the new prompt ID
+   * @throws Error if prompt name already exists or validation fails
+   *
+   * @example
+   * ```ts
+   * const promptId = await operations.savePrompt('auth-system', 'You are an auth specialist...', {
+   *   category: 'domain',
+   *   tags: ['authentication', 'security'],
+   *   author: 'dev-team',
+   *   autoOptimize: true,
+   * });
+   * ```
+   */
+  async savePrompt(name, content, options) {
+    try {
+      const id = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+      if (!id) {
+        throw new Error("Prompt name must contain at least one alphanumeric character");
+      }
+      const existingByName = this.list().find((p) => p.name === name);
+      if (existingByName) {
+        throw new Error(`Prompt with name "${name}" already exists (ID: ${existingByName.id})`);
+      }
+      const result = await this.create({
+        id,
+        name,
+        description: options?.description || name,
+        category: options?.category || "custom",
+        tags: options?.tags,
+        initialContent: content,
+        author: options?.author,
+        autoOptimize: options?.autoOptimize
+      });
+      return result.prompt.id;
+    } catch (error) {
+      throw new Error(`Failed to save prompt "${name}": ${error.message}`);
+    }
+  }
+  /**
+   * Activate a specific version of a prompt with safety checks
+   *
+   * Activates a previously created version after performing safety checks.
+   * Can optionally require user confirmation before activation. Logs the
+   * activation with reason for audit trail.
+   *
+   * Safety checks:
+   * - Version must exist
+   * - Version must have minimum completeness score (if metrics available)
+   * - Version must not have success rate below critical threshold
+   *
+   * @param promptId - ID of the prompt to update or versionId if first param is versionId string
+   * @param versionId - ID of the version to activate, or undefined if using overload
+   * @param options - Activation options (confirmation requirement, reason)
+   * @returns Promise that resolves when activation is complete
+   * @throws Error if safety checks fail or version not found
+   *
+   * @example
+   * ```ts
+   * // With prompt ID and version ID
+   * await operations.activateVersion('user-auth', 'v2.1.0', {
+   *   confirm: true,
+   *   reason: 'Manual: 15% improvement in success rate',
+   * });
+   *
+   * // With just version ID
+   * await operations.activateVersion('v2.1.0');
+   * ```
+   */
+  async activateVersion(promptIdOrVersionId, versionIdOrOptions, optionsArg) {
+    let promptId = "";
+    let versionId = "";
+    let options;
+    try {
+      if (typeof versionIdOrOptions === "string") {
+        promptId = promptIdOrVersionId;
+        versionId = versionIdOrOptions;
+        options = optionsArg;
+      } else {
+        const version2 = this.store.getVersion(promptIdOrVersionId);
+        if (!version2) {
+          throw new Error(`Version "${promptIdOrVersionId}" not found`);
+        }
+        promptId = version2.promptId;
+        versionId = promptIdOrVersionId;
+        options = versionIdOrOptions;
+      }
+      const prompt = this.getOrThrow(promptId);
+      const version = this.store.getVersion(promptId, versionId);
+      if (!version) {
+        throw new Error(`Version "${versionId}" not found for prompt "${promptId}"`);
+      }
+      const metrics = this.getPerformance(versionId);
+      if (metrics && !options?.skipSafetyChecks) {
+        if (metrics.successRate < 0.5) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: "prompt-operations",
+              subsystem: "prompts",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                versionId,
+                successRate: metrics.successRate,
+                threshold: 0.5,
+                operation: "activateVersion"
+              }
+            }
+          );
+        }
+        if (metrics.avgCompleteness < 60) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: "prompt-operations",
+              subsystem: "prompts",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                versionId,
+                avgCompleteness: metrics.avgCompleteness,
+                threshold: 60,
+                operation: "activateVersion"
+              }
+            }
+          );
+        }
+        if (metrics.successRate < 0.2 && metrics.sampleSize >= 10) {
+          throw new Error(
+            `Cannot activate version with critically low success rate: ${(metrics.successRate * 100).toFixed(1)}%`
+          );
+        }
+      }
+      if (options?.confirm) {
+        console.log(`[CONFIRM] Activate version ${versionId} of "${prompt.name}"?`);
+      }
+      const reason = options?.reason || "Manual activation via manager";
+      await this.store.setActiveVersion(promptId, versionId, reason);
+      console.log(`[INFO] Activated version ${versionId} for prompt "${prompt.name}": ${reason}`);
+    } catch (error) {
+      throw new Error(`Failed to activate version "${versionId}": ${error.message}`);
+    }
+  }
+  /**
+   * Rollback to the previous version of a prompt
+   *
+   * Safely reverts a prompt to its previous version. Includes safety checks
+   * to ensure rollback is valid (has previous version, hasn't been rolled back
+   * too many times). Returns the ID of the rolled-back version.
+   *
+   * @param promptId - ID of the prompt to rollback
+   * @returns Promise resolving to the ID of the now-active version
+   * @throws Error if rollback is not possible or safety checks fail
+   *
+   * @example
+   * ```ts
+   * const previousVersionId = await operations.rollbackVersion('user-auth');
+   * console.log(`Rolled back to ${previousVersionId}`);
+   * ```
+   */
+  async rollbackVersion(promptId) {
+    try {
+      const prompt = this.getOrThrow(promptId);
+      const versions = this.listVersions(promptId).sort(
+        (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+      );
+      if (versions.length < 2) {
+        throw new Error(
+          `Cannot rollback: prompt "${promptId}" has only ${versions.length} version(s)`
+        );
+      }
+      const currentActive = versions.find((v) => v.isActive);
+      if (!currentActive) {
+        throw new Error(`No active version found for prompt "${promptId}"`);
+      }
+      const previousVersion = versions[1];
+      if (!previousVersion) {
+        throw new Error("No previous version available for rollback");
+      }
+      const sevenDaysAgo = new Date(Date.now() - SEVEN_DAYS_MS).toISOString();
+      const recentRollbacks = versions.filter(
+        (v) => v.deactivatedAt && v.deactivatedAt > sevenDaysAgo && !v.isActive
+      ).length;
+      if (recentRollbacks >= 3) {
+        throw new Error(
+          `Too many rollbacks (${recentRollbacks}) in the last 7 days. Consider reviewing prompt strategy.`
+        );
+      }
+      await this.store.activateVersion(promptId, previousVersion.id);
+      console.log(
+        `[INFO] Rolled back "${prompt.name}" from ${currentActive.id} to ${previousVersion.id}`
+      );
+      return previousVersion.id;
+    } catch (error) {
+      throw new Error(`Failed to rollback version: ${error.message}`);
+    }
+  }
+  /**
+   * Create variants of a prompt using specified mutation strategies
+   *
+   * Generates new prompt variants using the VariantGenerator with configured
+   * mutation strategies (clarity, conciseness, context, etc.). The created
+   * variants are saved to the store for A/B testing.
+   *
+   * @param promptId - ID of the prompt to create variants for
+   * @param strategies - Mutation strategies to apply (clarity, conciseness, context, examples, structure, constraints, tone, hybrid)
+   * @param options - Optional configuration (targetMetric for optimization)
+   * @returns Promise resolving to array of created variants
+   * @throws Error if prompt not found or variant generation fails
+   *
+   * @example
+   * ```ts
+   * const variants = await operations.createVariant('user-auth', ['clarity', 'examples'], {
+   *   targetMetric: 'success_rate',
+   * });
+   * console.log(`Created ${variants.length} variants for A/B testing`);
+   * ```
+   */
+  async createVariant(promptId, strategies, options) {
+    try {
+      this.getOrThrow(promptId);
+      const baseVersion = this.getActiveVersionOrThrow(promptId);
+      const generator = new VariantGenerator();
+      const generatedVariants = await generator.generateVariants(baseVersion, strategies.length, {
+        strategies,
+        targetMetric: options?.targetMetric || "balanced"
+      });
+      const savedVariants = [];
+      for (let i = 0; i < generatedVariants.length; i++) {
+        const generated = generatedVariants[i];
+        if (!generated) continue;
+        const strategy = strategies[i] || "hybrid";
+        const variantVersionId = await this.getNextVersion(promptId);
+        await this.createVersion({
+          promptId,
+          content: generated.content,
+          version: variantVersionId,
+          changelog: `Variant using ${strategy} strategy: ${generated.expectedImprovement}`,
+          author: "variant-generator",
+          activate: false,
+          isGenerated: true,
+          generationModel: "variant-generator",
+          generationPrompt: `Apply ${strategy} mutation strategy`
+        });
+        const variantId = `${baseVersion.id}-${strategy}-${variantVersionId}`;
+        const variant = {
+          id: variantId,
+          promptId,
+          baseVersionId: baseVersion.id,
+          mutationStrategies: [strategy],
+          confidence: generated.confidence,
+          expectedImprovement: parseFloat(
+            generated.expectedImprovement.match(/[\d.]+/)?.[0] || "0"
+          ),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        try {
+          await this.store.saveVariant(variant);
+        } catch (variantError) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: "prompt-operations",
+              subsystem: "prompts",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                error: variantError.message,
+                operation: "saveVariant",
+                variantId: variant.id,
+                promptId
+              }
+            }
+          );
+        }
+        savedVariants.push(variant);
+      }
+      console.log(
+        `[INFO] Created ${savedVariants.length} variants for prompt "${promptId}" using strategies: ${strategies.join(", ")}`
+      );
+      return savedVariants;
+    } catch (error) {
+      throw new Error(
+        `Failed to create variants for prompt "${promptId}": ${error.message}`
+      );
+    }
+  }
+  /**
+   * Get human-readable version history for a prompt
+   *
+   * Compiles a complete history of all versions for a prompt including
+   * performance metrics and activation timeline. Returns formatted data
+   * suitable for CLI display or JSON export.
+   *
+   * @param promptId - ID of the prompt to get history for
+   * @returns Promise resolving to formatted version history
+   * @throws Error if prompt not found
+   *
+   * @example
+   * ```ts
+   * const history = await operations.getPromptHistory('user-auth');
+   * console.log(`${history.totalVersions} versions of "${history.promptName}"`);
+   * history.entries.forEach((entry) => {
+   *   console.log(`  ${entry.versionId}: ${entry.wordCount} words, active=${entry.isActive}`);
+   * });
+   * ```
+   */
+  async getPromptHistory(promptId) {
+    try {
+      const prompt = this.getOrThrow(promptId);
+      const versions = this.listVersions(promptId);
+      const activeVersion = this.getActiveVersion(promptId);
+      const activeVersionId = activeVersion?.id || "";
+      const entries = versions.map((version) => {
+        const metrics = this.getPerformance(version.id);
+        const wordCount = version.content.split(/\s+/).length;
+        const activationReason = activeVersionId === version.id ? "Currently active" : void 0;
+        return {
+          versionId: version.id,
+          content: version.content,
+          contentLength: version.content.length,
+          wordCount,
+          isActive: version.isActive,
+          isGenerated: version.isGenerated,
+          generationModel: version.generationModel,
+          changelog: version.changelog,
+          author: version.author,
+          createdAt: version.createdAt,
+          activatedAt: version.activatedAt,
+          deactivatedAt: version.deactivatedAt,
+          performance: metrics ? {
+            successRate: metrics.successRate,
+            avgCompleteness: metrics.avgCompleteness,
+            avgDuration: metrics.avgDuration,
+            sampleSize: metrics.sampleSize
+          } : void 0,
+          activationReason
+        };
+      });
+      entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+      return {
+        promptId,
+        promptName: prompt.name,
+        totalVersions: versions.length,
+        activeVersionId,
+        entries
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get history for prompt "${promptId}": ${error.message}`
+      );
+    }
+  }
+  /**
+   * Export all prompts with versions and metrics
+   *
+   * Exports complete prompt database including all versions and performance
+   * metrics in specified format (JSON or CSV). Useful for backup, migration,
+   * or analysis.
+   *
+   * @param options - Export format and options
+   * @returns Promise resolving to serialized export data
+   * @throws Error if export fails
+   *
+   * @example
+   * ```ts
+   * const json = await operations.exportPrompts({ format: 'json' });
+   * fs.writeFileSync('prompts-backup.json', json);
+   *
+   * const csv = await operations.exportPrompts({ format: 'csv' });
+   * fs.writeFileSync('prompts-export.csv', csv);
+   * ```
+   */
+  async exportPrompts(options) {
+    try {
+      const format = options?.format || "json";
+      const includeMetrics = options?.includeMetrics !== false;
+      const prompts = this.list();
+      if (format === "json") {
+        const exportData = {
+          version: "1.0.0",
+          exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          prompts: prompts.map((prompt) => {
+            const versions = this.listVersions(prompt.id);
+            const metrics = includeMetrics ? versions.map((v) => this.getPerformance(v.id)).filter(Boolean) : void 0;
+            return {
+              prompt,
+              versions,
+              metrics
+            };
+          })
+        };
+        return JSON.stringify(exportData, null, 2);
+      } else if (format === "csv") {
+        const lines = [];
+        lines.push(
+          "promptId,promptName,versionId,category,status,author,createdAt,isActive,successRate,avgCompleteness"
+        );
+        for (const prompt of prompts) {
+          const versions = this.listVersions(prompt.id);
+          for (const version of versions) {
+            const metrics = includeMetrics ? this.getPerformance(version.id) : null;
+            const row = [
+              prompt.id,
+              `"${prompt.name.replace(/"/g, '""')}"`,
+              version.id,
+              prompt.category,
+              prompt.status,
+              version.author || "",
+              version.createdAt,
+              version.isActive ? "true" : "false",
+              metrics?.successRate?.toFixed(3) || "",
+              metrics?.avgCompleteness?.toFixed(1) || ""
+            ].join(",");
+            lines.push(row);
+          }
+        }
+        return lines.join("\n");
+      } else {
+        throw new Error(`Unsupported export format: ${format}`);
+      }
+    } catch (error) {
+      throw new Error(`Failed to export prompts: ${error.message}`);
+    }
+  }
+  /**
+   * Import prompts from exported data
+   *
+   * Imports prompts from JSON or CSV export format. Handles conflict resolution
+   * (skip duplicates or update existing) and validates data integrity.
+   *
+   * @param data - Serialized export data (JSON or CSV)
+   * @param options - Import options (format, conflictResolution)
+   * @returns Promise that resolves when import is complete
+   * @throws Error if data format is invalid or import fails
+   *
+   * @example
+   * ```ts
+   * const data = fs.readFileSync('prompts-backup.json', 'utf-8');
+   * await operations.importPrompts(data, {
+   *   format: 'json',
+   *   conflictResolution: 'skip',
+   * });
+   * ```
+   */
+  async importPrompts(data, options) {
+    try {
+      const format = options?.format || "json";
+      const conflictResolution = options?.conflictResolution || "skip";
+      if (format === "json") {
+        const exportData = parseJsonWithContext(data, "Prompt export data");
+        if (!exportData.version || !Array.isArray(exportData.prompts)) {
+          throw new Error("Invalid export format: missing version or prompts array");
+        }
+        let imported = 0;
+        let skipped = 0;
+        for (const item of exportData.prompts) {
+          const { prompt, versions } = item;
+          const existing = this.get(prompt.id);
+          if (existing && conflictResolution === "skip") {
+            console.log(`[SKIP] Prompt "${prompt.id}" already exists`);
+            skipped++;
+            continue;
+          }
+          try {
+            if (!existing) {
+              if (versions.length === 0) {
+                console.warn(`[WARN] Prompt "${prompt.id}" has no versions, skipping`);
+                skipped++;
+                continue;
+              }
+              const firstVersion = versions[0];
+              if (!firstVersion) {
+                emitWarning(
+                  "PR-001",
+                  {
+                    taskId: "prompt-operations",
+                    subsystem: "prompts",
+                    executionPhase: "execution"
+                  },
+                  {
+                    severity: "WARN" /* WARN */,
+                    metadata: {
+                      operation: "importPrompts",
+                      promptId: prompt.id,
+                      reason: "No first version found"
+                    }
+                  }
+                );
+                skipped++;
+                continue;
+              }
+              await this.create({
+                id: prompt.id,
+                name: prompt.name,
+                description: prompt.description,
+                category: prompt.category,
+                variant: prompt.variant,
+                tags: prompt.tags,
+                initialContent: firstVersion.content,
+                initialVersion: firstVersion.id,
+                author: firstVersion.author,
+                autoOptimize: prompt.autoOptimize
+              });
+              for (let i = 1; i < versions.length; i++) {
+                const version = versions[i];
+                if (!version) continue;
+                await this.createVersion({
+                  promptId: prompt.id,
+                  content: version.content,
+                  version: version.id,
+                  changelog: version.changelog,
+                  author: version.author,
+                  activate: version.isActive,
+                  isGenerated: version.isGenerated,
+                  generationModel: version.generationModel
+                });
+              }
+              imported++;
+              console.log(`[OK] Imported prompt "${prompt.id}" with ${versions.length} versions`);
+            } else if (conflictResolution === "overwrite") {
+              await this.update(prompt.id, {
+                name: prompt.name,
+                description: prompt.description,
+                category: prompt.category,
+                tags: prompt.tags,
+                autoOptimize: prompt.autoOptimize
+              });
+              let newVersions = 0;
+              for (const version of versions) {
+                const existing2 = this.getVersion(version.id);
+                if (!existing2) {
+                  await this.createVersion({
+                    promptId: prompt.id,
+                    content: version.content,
+                    version: version.id,
+                    changelog: version.changelog,
+                    author: version.author,
+                    activate: version.isActive,
+                    isGenerated: version.isGenerated,
+                    generationModel: version.generationModel
+                  });
+                  newVersions++;
+                }
+              }
+              imported++;
+              console.log(`[OK] Updated prompt "${prompt.id}" with ${newVersions} new versions`);
+            }
+          } catch (error) {
+            console.error(
+              `[ERROR] Failed to import prompt "${prompt.id}": ${error.message}`
+            );
+            skipped++;
+          }
+        }
+        console.log(`[INFO] Import complete: ${imported} imported, ${skipped} skipped`);
+      } else if (format === "csv") {
+        const lines = data.split("\n").filter((line) => line.trim());
+        if (lines.length < 2) {
+          throw new Error("CSV import requires at least header + 1 data row");
+        }
+        const dataLines = lines.slice(1);
+        let imported = 0;
+        let skipped = 0;
+        for (const line of dataLines) {
+          try {
+            const parts = line.split(",");
+            if (parts.length < 5) {
+              skipped++;
+              continue;
+            }
+            const promptId = parts[0]?.trim();
+            const promptName = parts[1]?.replace(/^"|"$/g, "").replace('""', '"');
+            if (!promptId || !promptName) {
+              skipped++;
+              continue;
+            }
+            const existing = this.get(promptId);
+            if (existing && conflictResolution === "skip") {
+              skipped++;
+              continue;
+            }
+            if (!existing) {
+              await this.create({
+                id: promptId,
+                name: promptName,
+                description: promptName,
+                category: "custom",
+                initialContent: `Imported from CSV: ${promptName}`
+              });
+              imported++;
+            }
+          } catch (_error) {
+            skipped++;
+          }
+        }
+        console.log(`[INFO] CSV import complete: ${imported} imported, ${skipped} skipped`);
+      } else {
+        throw new Error(`Unsupported import format: ${format}`);
+      }
+    } catch (error) {
+      throw new Error(`Failed to import prompts: ${error.message}`);
+    }
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.store.close();
+  }
+  // Private helper methods
+  /**
+   * Get next semantic version for a prompt
+   */
+  async getNextVersion(promptId) {
+    const versions = this.listVersions(promptId);
+    if (versions.length === 0) {
+      return "v1.0.0";
+    }
+    const versionNumbers = versions.map((v) => v.id).filter((id) => /^v\d+\.\d+\.\d+$/.test(id)).map((id) => {
+      const parts = id.slice(1).split(".").map(Number);
+      return { major: parts[0], minor: parts[1], patch: parts[2] };
+    });
+    if (versionNumbers.length === 0) {
+      return "v1.0.0";
+    }
+    versionNumbers.sort((a, b) => {
+      const aMajor = a.major ?? 0;
+      const bMajor = b.major ?? 0;
+      if (aMajor !== bMajor) return bMajor - aMajor;
+      const aMinor = a.minor ?? 0;
+      const bMinor = b.minor ?? 0;
+      if (aMinor !== bMinor) return bMinor - aMinor;
+      const aPatch = a.patch ?? 0;
+      const bPatch = b.patch ?? 0;
+      return bPatch - aPatch;
+    });
+    const highest = versionNumbers[0];
+    if (!highest) {
+      return "v1.0.0";
+    }
+    return `v${highest.major ?? 1}.${highest.minor ?? 0}.${(highest.patch ?? 0) + 1}`;
+  }
+  /**
+   * Generate simple line-by-line diff
+   */
+  generateDiff(contentA, contentB) {
+    const linesA = contentA.split("\n");
+    const linesB = contentB.split("\n");
+    const diff = [];
+    const maxLines = Math.max(linesA.length, linesB.length);
+    for (let i = 0; i < maxLines; i++) {
+      const lineA = linesA[i];
+      const lineB = linesB[i];
+      if (lineA === lineB) {
+        diff.push(`  ${lineA || ""}`);
+      } else {
+        if (lineA !== void 0) {
+          diff.push(`- ${lineA}`);
+        }
+        if (lineB !== void 0) {
+          diff.push(`+ ${lineB}`);
+        }
+      }
+    }
+    return diff.join("\n");
+  }
+};
+
+// src/prompts/manager.ts
+var PromptManager = class {
+  operations;
+  analytics;
+  /**
+   * Create a new PromptManager instance.
+   *
+   * @param options - Configuration options
+   */
+  constructor(options = {}) {
+    this.operations = new PromptOperations(options);
+    this.analytics = new PromptAnalytics(this.operations);
+  }
+  /**
+   * Access the underlying PromptStore (for activation history and other
+   * read-paths that need direct DB access). Mutations should go through
+   * the manager's higher-level methods.
+   */
+  getStore() {
+    return this.operations.getStore();
+  }
+  // ============================================================================
+  // CRUD OPERATIONS (delegate to PromptOperations)
+  // ============================================================================
+  /**
+   * Create a new prompt with optional initial version
+   */
+  async create(options) {
+    return this.operations.create(options);
+  }
+  /**
+   * Get a prompt by ID
+   */
+  get(id) {
+    return this.operations.get(id);
+  }
+  /**
+   * Get a prompt by ID, throwing if not found
+   */
+  getOrThrow(id) {
+    return this.operations.getOrThrow(id);
+  }
+  /**
+   * Update a prompt
+   */
+  async update(id, options) {
+    return this.operations.update(id, options);
+  }
+  /**
+   * Delete a prompt and all its versions
+   */
+  async delete(id) {
+    return this.operations.delete(id);
+  }
+  /**
+   * Archive a prompt
+   */
+  async archive(id) {
+    return this.operations.archive(id);
+  }
+  /**
+   * Restore an archived prompt
+   */
+  async restore(id) {
+    return this.operations.restore(id);
+  }
+  /**
+   * List prompts with optional filtering
+   */
+  list(criteria) {
+    return this.operations.list(criteria);
+  }
+  /**
+   * Search prompts by query string
+   */
+  search(query, options) {
+    return this.operations.search(query, options);
+  }
+  // ============================================================================
+  // VERSION MANAGEMENT (delegate to PromptOperations)
+  // ============================================================================
+  /**
+   * Create a new version for a prompt
+   */
+  async createVersion(options) {
+    return this.operations.createVersion(options);
+  }
+  getVersion(idOrPromptId, versionId) {
+    return this.operations.getVersion(idOrPromptId, versionId);
+  }
+  /**
+   * Get active version for a prompt
+   */
+  getActiveVersion(promptId) {
+    return this.operations.getActiveVersion(promptId);
+  }
+  /**
+   * Get active version, throwing if not found
+   */
+  getActiveVersionOrThrow(promptId) {
+    return this.operations.getActiveVersionOrThrow(promptId);
+  }
+  /**
+   * List all versions for a prompt
+   */
+  listVersions(promptId) {
+    return this.operations.listVersions(promptId);
+  }
+  /**
+   * Deactivate a version
+   */
+  async deactivateVersion(versionId) {
+    return this.operations.deactivateVersion(versionId);
+  }
+  /**
+   * Activate a specific version of a prompt with safety checks
+   */
+  async activateVersion(promptIdOrVersionId, versionIdOrOptions, optionsArg) {
+    return this.operations.activateVersion(promptIdOrVersionId, versionIdOrOptions, optionsArg);
+  }
+  /**
+   * Rollback to the previous version of a prompt
+   */
+  async rollbackVersion(promptId) {
+    return this.operations.rollbackVersion(promptId);
+  }
+  // ============================================================================
+  // PERFORMANCE & METRICS (delegate to PromptOperations)
+  // ============================================================================
+  /**
+   * Get performance metrics for a version
+   */
+  getPerformance(versionId, variant) {
+    return this.operations.getPerformance(versionId, variant);
+  }
+  /**
+   * Increment usage count when a prompt is used
+   */
+  recordUsage(promptId) {
+    this.operations.recordUsage(promptId);
+  }
+  // ============================================================================
+  // COMPARISON & ANALYSIS (delegate to PromptOperations & PromptAnalytics)
+  // ============================================================================
+  /**
+   * Compare two prompts or versions
+   */
+  async compare(promptIdA, promptIdB, versionIdA, versionIdB) {
+    return this.operations.compare(promptIdA, promptIdB, versionIdA, versionIdB);
+  }
+  /**
+   * Get performance analysis for a prompt
+   */
+  async analyzePerformance(promptId, versionId) {
+    return this.analytics.analyzePerformance(promptId, versionId);
+  }
+  /**
+   * Get performance trend for a prompt
+   */
+  async getPerformanceTrend(promptId, versionId) {
+    return this.analytics.getPerformanceTrend(promptId, versionId);
+  }
+  /**
+   * Get optimization suggestions for a prompt
+   */
+  async getSuggestions(promptId) {
+    return this.analytics.getSuggestions(promptId);
+  }
+  // ============================================================================
+  // BATCH OPERATIONS (delegate to PromptOperations)
+  // ============================================================================
+  /**
+   * Clone a prompt with a new ID
+   */
+  async clone(sourceId, newId, newName, options) {
+    return this.operations.clone(sourceId, newId, newName, options);
+  }
+  /**
+   * Batch archive multiple prompts
+   */
+  async archiveBatch(ids) {
+    return this.operations.archiveBatch(ids);
+  }
+  /**
+   * Batch delete multiple prompts
+   */
+  async deleteBatch(ids) {
+    return this.operations.deleteBatch(ids);
+  }
+  // ============================================================================
+  // STATISTICS (delegate to PromptOperations)
+  // ============================================================================
+  /**
+   * Get statistics for all prompts
+   */
+  getStatistics() {
+    return this.operations.getStatistics();
+  }
+  // ============================================================================
+  // HIGH-LEVEL OPERATIONS (delegate to PromptOperations)
+  // ============================================================================
+  /**
+   * Save a new prompt with initial content
+   */
+  async savePrompt(name, content, options) {
+    return this.operations.savePrompt(name, content, options);
+  }
+  /**
+   * Create variants of a prompt using specified mutation strategies
+   */
+  async createVariant(promptId, strategies, options) {
+    return this.operations.createVariant(promptId, strategies, options);
+  }
+  /**
+   * Get human-readable version history for a prompt
+   */
+  async getPromptHistory(promptId) {
+    return this.operations.getPromptHistory(promptId);
+  }
+  // ============================================================================
+  // IMPORT/EXPORT (delegate to PromptOperations)
+  // ============================================================================
+  /**
+   * Export all prompts with versions and metrics
+   */
+  async exportPrompts(options) {
+    return this.operations.exportPrompts(options);
+  }
+  /**
+   * Import prompts from exported data
+   */
+  async importPrompts(data, options) {
+    return this.operations.importPrompts(data, options);
+  }
+  // ============================================================================
+  // AUTO-TUNING & MONITORING (delegate to PromptAnalytics)
+  // ============================================================================
+  /**
+   * Auto-tune a prompt by evaluating variants and activating if criteria met
+   */
+  async autoTunePrompt(promptId, options) {
+    return this.analytics.autoTunePrompt(promptId, options);
+  }
+  /**
+   * Monitor an auto-activated version for regressions
+   */
+  async monitorAutoTuning(promptId, options) {
+    return this.analytics.monitorAutoTuning(promptId, options);
+  }
+  // ============================================================================
+  // LIFECYCLE METHODS
+  // ============================================================================
+  /**
+   * Close all resources and clean up.
+   */
+  close() {
+    this.operations.close();
+  }
+  // ============================================================================
+  // ADVANCED ACCESS (for direct module access if needed)
+  // ============================================================================
+  /**
+   * Get the operations module for advanced usage.
+   *
+   * @returns PromptOperations instance
+   */
+  get operationsModule() {
+    return this.operations;
+  }
+  /**
+   * Get the analytics module for advanced usage.
+   *
+   * @returns PromptAnalytics instance
+   */
+  get analyticsModule() {
+    return this.analytics;
+  }
+};
+
+export {
+  VariantGenerator,
+  PromptManager
+};
+//# sourceMappingURL=chunk-Q3WIC6GQ.js.map