@poetic-ai/poetic 1.42.0

package/dist/OptimizationEngine-JIMGP3LY.js

@@ -0,0 +1,1597 @@
+import {
+  OptimizationConfigManager
+} from "./chunk-7FMJVYBS.js";
+import {
+  PromptVersionStore
+} from "./chunk-LR5IJIGV.js";
+import {
+  ExecutionTracker
+} from "./chunk-U45RTRGY.js";
+import {
+  AutoTuningEngine,
+  AutomaticPromptOptimizer,
+  ProviderTracker,
+  TunerActivationAuthority
+} from "./chunk-7MMLMXO6.js";
+import {
+  VariantGenerator
+} from "./chunk-Q3WIC6GQ.js";
+import "./chunk-OQ6K46CK.js";
+import "./chunk-6BM72ZMG.js";
+import "./chunk-3AOKYKA7.js";
+import "./chunk-7QCZSLBH.js";
+import "./chunk-VXF4Q3FW.js";
+import "./chunk-6Y5TWI7H.js";
+import {
+  resolveDefaultProvider
+} from "./chunk-XPU2XADL.js";
+import "./chunk-AURFMVCD.js";
+import "./chunk-VBNCKCCI.js";
+import "./chunk-SZ7DL357.js";
+import "./chunk-4VJITV4P.js";
+import "./chunk-SURZ2WFE.js";
+import "./chunk-SP3LFU6B.js";
+import "./chunk-R4UWBC35.js";
+import {
+  TelemetryLogger
+} from "./chunk-CKNX3TTP.js";
+import "./chunk-FYOILAN5.js";
+import "./chunk-J62KPGII.js";
+import "./chunk-XAONGNST.js";
+import "./chunk-GAFJEYLK.js";
+import "./chunk-H6G7QRMQ.js";
+import "./chunk-J6P3FWWW.js";
+import "./chunk-CP7H3HSP.js";
+import "./chunk-ETYDXCK7.js";
+import "./chunk-BSE4R6XD.js";
+import "./chunk-UR2IBGIM.js";
+import "./chunk-JSWMRQYG.js";
+import "./chunk-XGYF2QMZ.js";
+import "./chunk-72YTZMAM.js";
+import "./chunk-S2VQCZO4.js";
+import "./chunk-WMPU2UOV.js";
+import "./chunk-VX3UMWB7.js";
+import "./chunk-XT2ZQVTC.js";
+import "./chunk-YGXKOBQQ.js";
+import "./chunk-V72RMBM4.js";
+import "./chunk-ZDTGECTN.js";
+import "./chunk-G36W2T2S.js";
+import "./chunk-GKN3HMN4.js";
+import "./chunk-QVZMFDYG.js";
+import "./chunk-S54MKU6V.js";
+import "./chunk-3S62LLWJ.js";
+import "./chunk-45FPSA3B.js";
+import "./chunk-YMX76IOS.js";
+import "./chunk-6Y5U7UFY.js";
+import "./chunk-XV7NZL4B.js";
+import "./chunk-CD7ISXA4.js";
+import "./chunk-QGJDMEOV.js";
+import "./chunk-5WCQRDRB.js";
+import "./chunk-C57KJOUQ.js";
+import "./chunk-DF5SLDE4.js";
+import "./chunk-TGON4N4O.js";
+import "./chunk-I5WRT7ZR.js";
+import "./chunk-A3YGID55.js";
+import "./chunk-5EERLVZB.js";
+import "./chunk-XQD2B6BB.js";
+import "./chunk-34CNP2HB.js";
+import "./chunk-KNDYMVWN.js";
+import "./chunk-RWREC3KJ.js";
+import "./chunk-LAMKBTXX.js";
+import "./chunk-FD4ERYEG.js";
+import "./chunk-KTMW65UX.js";
+import "./chunk-FHOWVDF5.js";
+import "./chunk-UDMS5AD3.js";
+import "./chunk-MWHLBPNU.js";
+import "./chunk-JLS65NUQ.js";
+import "./chunk-TRSVUPCX.js";
+import "./chunk-FKAUPHMR.js";
+import "./chunk-TSXGRLPR.js";
+import "./chunk-LUVKFFWR.js";
+import "./chunk-ENRGKNR5.js";
+import "./chunk-XB5YLCLB.js";
+import "./chunk-QOCOVLUH.js";
+import "./chunk-2VSQMRCB.js";
+import "./chunk-ON3G73BU.js";
+import "./chunk-3G6FZCRF.js";
+import "./chunk-N5DX4JAK.js";
+import "./chunk-2QLYTVYX.js";
+import "./chunk-7GDRQBQC.js";
+import "./chunk-PGSPX4SU.js";
+import "./chunk-AT4TNPWW.js";
+import "./chunk-GSGD5E4C.js";
+import {
+  resolvePoeticDirFromContext
+} from "./chunk-UI2F6DJ5.js";
+import "./chunk-4BTDUT2S.js";
+import "./chunk-L6OM4A22.js";
+import "./chunk-G4THLFV3.js";
+import "./chunk-RGWHUI5E.js";
+import "./chunk-UUH2RVKS.js";
+import "./chunk-LEIIWPWQ.js";
+import "./chunk-L7JZLXQL.js";
+import "./chunk-IZYIQQ7X.js";
+import "./chunk-JPKSXKNB.js";
+import "./chunk-TAJPCXSB.js";
+import "./chunk-XZE4XARH.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+import "./chunk-LPITVM7M.js";
+import "./chunk-5DLKYTQX.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/core/optimization/OptimizationEngine.ts
+import crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+
+// src/core/optimization/CompetitionRunner.ts
+var NoopCompetitionRunner = class {
+  async run(context) {
+    return {
+      status: "deferred",
+      candidatesAttempted: context.candidates.length,
+      candidatesCompleted: 0,
+      errors: [],
+      warnings: []
+    };
+  }
+};
+
+// src/core/optimization/OptimizationRecommendationAdapter.ts
+var OptimizationRecommendationAdapter = class {
+  constructor(promptStore, executionTracker, autoOptimizer) {
+    this.promptStore = promptStore;
+    this.executionTracker = executionTracker;
+    this.autoOptimizer = autoOptimizer;
+  }
+  promptStore;
+  executionTracker;
+  autoOptimizer;
+  /**
+   * Check if prompt is ready for optimization
+   *
+   * @param promptId - Prompt to check
+   * @param versionId - Version to check
+   * @returns Readiness status with recommendation
+   */
+  async isReadyForOptimization(promptId, versionId) {
+    const metrics = this.executionTracker.getMetrics(promptId, versionId);
+    const MIN_EXECUTIONS = 10;
+    if (!metrics || metrics.totalExecutions < MIN_EXECUTIONS) {
+      return {
+        ready: false,
+        reason: `Need ${MIN_EXECUTIONS - (metrics?.totalExecutions || 0)} more executions`,
+        recommendation: "wait_for_data",
+        executionCount: metrics?.totalExecutions || 0,
+        avgQuality: metrics?.avgCompleteness || 0,
+        confidence: 0
+      };
+    }
+    try {
+      const recommendation = await this.autoOptimizer.analyzePrompt(promptId);
+      return {
+        ready: recommendation.action === "generate_variants" || recommendation.action === "activate_existing",
+        reason: recommendation.rationale,
+        recommendation: this.mapAction(recommendation.action),
+        executionCount: metrics.totalExecutions,
+        avgQuality: recommendation.currentPerformance.avgCompleteness,
+        confidence: recommendation.confidence
+      };
+    } catch (error) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: promptId,
+          subsystem: "optimization",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            error: error.message,
+            versionId,
+            operation: "autoOptimizerAnalysis"
+          }
+        }
+      );
+      return {
+        ready: false,
+        reason: `Analysis failed: ${error.message}`,
+        recommendation: "no_action",
+        executionCount: metrics.totalExecutions,
+        avgQuality: metrics.avgCompleteness,
+        confidence: 0
+      };
+    }
+  }
+  /**
+   * Analyze prompt and get optimization recommendations
+   *
+   * @param promptId - Prompt to analyze
+   * @returns Full optimization recommendation
+   * @throws Error if prompt not found
+   * @throws Error if insufficient data
+   */
+  async analyze(promptId) {
+    const prompt = await this.promptStore.getPrompt(promptId);
+    if (!prompt) {
+      throw new Error(`Prompt ${promptId} not found`);
+    }
+    try {
+      return await this.autoOptimizer.analyzePrompt(promptId);
+    } catch (error) {
+      throw new Error(`Failed to analyze prompt: ${error.message}`);
+    }
+  }
+  /**
+   * Get the best performing version for a prompt
+   *
+   * @param promptId - Prompt to analyze
+   * @returns Best version ID with rationale
+   * @throws Error if no versions with sufficient data
+   */
+  async recommendBestVersion(promptId) {
+    try {
+      const recommendation = await this.analyze(promptId);
+      if (recommendation.action === "activate_existing") {
+        const bestVariant = recommendation.proposedVariants[0];
+        if (bestVariant) {
+          return {
+            recommendedVersion: bestVariant.variantId,
+            rationale: `Better performing version found: ${bestVariant.description}`,
+            confidence: recommendation.confidence,
+            improvementPercentage: recommendation.estimatedImpact.completenessImprovement
+          };
+        }
+      }
+      return {
+        recommendedVersion: recommendation.currentVersionId,
+        rationale: "Current version performs optimally",
+        confidence: recommendation.confidence
+      };
+    } catch (error) {
+      throw new Error(`Failed to recommend best version: ${error.message}`);
+    }
+  }
+  /**
+   * Get optimization recommendation for a prompt
+   *
+   * Returns null if prompt has insufficient data. Throws on unexpected errors.
+   * Used by OptimizationEngine.analyze() for read-only analysis.
+   *
+   * @param promptId - Prompt to get recommendation for
+   * @returns Optimization recommendation or null if insufficient data
+   * @throws Error on unexpected failures (not data insufficiency)
+   */
+  async getRecommendation(promptId) {
+    try {
+      return await this.analyze(promptId);
+    } catch (error) {
+      const message = error.message || "";
+      const normalized = message.toLowerCase();
+      const isExpectedError = normalized.includes("insufficient") || normalized.includes("no execution metrics") || normalized.includes("more executions") || normalized.includes("no performance data") || normalized.includes("prompt") && normalized.includes("not found");
+      if (isExpectedError) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get optimization suggestions without full analysis
+   *
+   * Lighter-weight than full analyze()
+   */
+  async getSuggestions(promptId) {
+    try {
+      const recommendation = await this.analyze(promptId);
+      return recommendation.suggestions.map((s) => s.description);
+    } catch (error) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: promptId,
+          subsystem: "optimization",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            error: error.message,
+            operation: "getSuggestions"
+          }
+        }
+      );
+      return [];
+    }
+  }
+  /**
+   * Map AutoOptimizer action to our recommendation type
+   */
+  mapAction(action) {
+    switch (action) {
+      case "generate_variants":
+      case "activate_existing":
+        return "optimize_now";
+      case "needs_more_data":
+        return "wait_for_data";
+      case "no_action":
+        return "no_action";
+    }
+  }
+  /**
+   * Close resources
+   */
+  close() {
+    this.autoOptimizer.close();
+  }
+};
+
+// src/core/optimization/PromptVariantGenerator.ts
+var PromptVariantGenerator = class {
+  constructor(promptStore, variantGenerator) {
+    this.promptStore = promptStore;
+    this.variantGenerator = variantGenerator;
+  }
+  promptStore;
+  variantGenerator;
+  /**
+   * Generate candidate variants for optimization
+   *
+   * Creates new PromptVersion records for each variant with lineage tracking.
+   *
+   * @param promptId - Prompt to optimize
+   * @param versionId - Source version to mutate
+   * @param options - Generation options
+   * @returns Array of new PromptVersion objects saved to database
+   * @throws Error if source version not found
+   * @throws Error if all variant creations fail
+   */
+  async generateCandidates(promptId, versionId, options = {}) {
+    const sourceVersion = await this.promptStore.getVersion(versionId);
+    if (!sourceVersion) {
+      throw new Error(`Source version ${versionId} not found`);
+    }
+    if (sourceVersion.promptId !== promptId) {
+      throw new Error(`Version ${versionId} does not belong to prompt ${promptId}`);
+    }
+    if (options.count !== void 0 && options.count <= 0) {
+      throw new Error("Variant count must be at least 1");
+    }
+    const count = options.count || 3;
+    const adaptedVersion = {
+      id: sourceVersion.id,
+      promptId: sourceVersion.promptId,
+      content: sourceVersion.content,
+      contentHash: "",
+      // Not used by variant generator
+      changelog: "",
+      // Not used
+      author: sourceVersion.createdBy,
+      isActive: sourceVersion.isActive,
+      isGenerated: false,
+      createdAt: sourceVersion.createdAt
+    };
+    const generatedVariants = await this.variantGenerator.generateVariants(adaptedVersion, count, {
+      strategies: options.strategies,
+      targetMetric: options.targetMetric || "balanced"
+    });
+    if (generatedVariants.length === 0) {
+      throw new Error("VariantGenerator produced no variants");
+    }
+    const candidates = [];
+    const errors = [];
+    for (let i = 0; i < generatedVariants.length; i++) {
+      const variant = generatedVariants[i];
+      if (!variant) continue;
+      try {
+        const goalMap = {
+          success_rate: "quality",
+          completeness: "quality",
+          duration: "speed",
+          balanced: "balanced"
+        };
+        const goal = goalMap[options.targetMetric || "balanced"] || "balanced";
+        const version = await this.promptStore.createVersion({
+          promptId,
+          content: variant.content,
+          createdBy: "variant-generator",
+          parentVersionId: versionId,
+          optimizationMetadata: {
+            strategy: variant.mutations[0]?.strategy || "hybrid",
+            goal,
+            mutations: variant.mutations.map((m) => m.description),
+            expectedImprovements: {
+              confidence: Number(variant.confidence) || 0
+            }
+          }
+        });
+        candidates.push(version);
+      } catch (error) {
+        const errorMsg = `Failed to create variant ${i + 1}: ${error.message}`;
+        errors.push(errorMsg);
+        emitWarning(
+          "PR-001",
+          {
+            taskId: promptId,
+            subsystem: "optimization",
+            executionPhase: "execution"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              variantIndex: i + 1,
+              error: error.message,
+              operation: "createVariant"
+            }
+          }
+        );
+      }
+    }
+    if (candidates.length === 0) {
+      const errorSummary = errors.join("; ");
+      throw new Error(`Failed to create any candidate versions: ${errorSummary}`);
+    }
+    if (errors.length > 0) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: promptId,
+          subsystem: "optimization",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            successCount: candidates.length,
+            totalCount: generatedVariants.length,
+            failures: errors.join("; "),
+            operation: "generateCandidates"
+          }
+        }
+      );
+    }
+    return {
+      candidates,
+      generatedVariants
+    };
+  }
+  /**
+   * Get mutation details for a version
+   *
+   * Retrieves the mutations that created this version from optimizationMetadata.
+   */
+  getMutations(version) {
+    if (!version.optimizationMetadata?.mutations) {
+      return [];
+    }
+    const mutations = version.optimizationMetadata.mutations;
+    return Array.isArray(mutations) ? mutations : [];
+  }
+  /**
+   * Get generation strategy for a version
+   */
+  getStrategy(version) {
+    return version.optimizationMetadata?.strategy;
+  }
+  /**
+   * Get generation hypothesis for a version
+   */
+  getHypothesis(version) {
+    const metadata = version.optimizationMetadata?.expectedImprovements;
+    if (typeof metadata === "object" && metadata !== null) {
+      return metadata.hypothesis;
+    }
+    return void 0;
+  }
+  /**
+   * Get expected improvement for a version
+   */
+  getExpectedImprovement(version) {
+    const metadata = version.optimizationMetadata?.expectedImprovements;
+    if (typeof metadata === "object" && metadata !== null) {
+      return metadata.expectedImprovement;
+    }
+    return void 0;
+  }
+  /**
+   * Get confidence score for a version
+   */
+  getConfidence(version) {
+    const metadata = version.optimizationMetadata?.expectedImprovements;
+    if (typeof metadata === "object" && metadata !== null) {
+      const confidence = metadata.confidence;
+      return typeof confidence === "number" ? confidence : 0;
+    }
+    return 0;
+  }
+  /**
+   * Close resources
+   */
+  close() {
+    this.variantGenerator.close();
+  }
+};
+
+// src/core/optimization/ProviderInsights.ts
+var ProviderInsights = class {
+  constructor(providerTracker, executionTracker) {
+    this.providerTracker = providerTracker;
+    this.executionTracker = executionTracker;
+  }
+  providerTracker;
+  executionTracker;
+  /**
+   * Track all variants from optimization cycle
+   *
+   * Feeds execution data into ProviderTracker for analytics.
+   *
+   * @param promptId - Prompt being optimized
+   * @param candidateVersionIds - Versions tested in cycle
+   */
+  async trackOptimizationCycle(promptId, candidateVersionIds) {
+    for (const versionId of candidateVersionIds) {
+      try {
+        const executions = this.executionTracker.getExecutions(promptId, versionId);
+        for (const execution of executions) {
+          const variants = this.executionTracker.getVariants(execution.id);
+          for (const variant of variants) {
+            try {
+              await this.trackVariant(promptId, versionId, variant, execution.taskComplexity);
+            } catch (error) {
+              emitWarning(
+                "PR-001",
+                {
+                  taskId: promptId,
+                  subsystem: "optimization",
+                  provider: variant.provider,
+                  executionPhase: "execution"
+                },
+                {
+                  severity: "WARN" /* WARN */,
+                  metadata: {
+                    operation: "trackVariant",
+                    versionId,
+                    provider: variant.provider,
+                    error: error.message,
+                    reason: "Failed to track provider variant"
+                  }
+                }
+              );
+            }
+          }
+        }
+      } catch (error) {
+        emitWarning(
+          "PR-001",
+          {
+            taskId: promptId,
+            subsystem: "optimization",
+            executionPhase: "execution"
+          },
+          {
+            severity: "ERROR" /* ERROR */,
+            metadata: {
+              operation: "trackOptimizationCycle",
+              versionId,
+              error: error.message,
+              reason: "Failed to track version"
+            }
+          }
+        );
+      }
+    }
+  }
+  /**
+   * Analyze results and recommend best provider
+   *
+   * @param promptId - Prompt to analyze
+   * @returns Provider recommendations ranked by performance
+   */
+  async analyzeResults(promptId) {
+    try {
+      const recommendations = await this.providerTracker.getProviderRecommendations(promptId);
+      const insights = [];
+      for (const rec of recommendations.slice(0, 3)) {
+        try {
+          const providerInsights = await this.providerTracker.getProviderOptimizationInsights(
+            rec.provider,
+            promptId
+          );
+          insights.push(...providerInsights);
+        } catch (error) {
+          emitWarning(
+            "PR-001",
+            {
+              taskId: promptId,
+              subsystem: "optimization",
+              provider: rec.provider,
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                operation: "getProviderOptimizationInsights",
+                provider: rec.provider,
+                error: error.message,
+                reason: "Failed to get provider insights"
+              }
+            }
+          );
+        }
+      }
+      return {
+        bestProvider: recommendations[0]?.provider ?? resolveDefaultProvider().value,
+        providerRecommendations: recommendations,
+        insights
+      };
+    } catch (error) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: promptId,
+          subsystem: "optimization",
+          executionPhase: "execution"
+        },
+        {
+          severity: "ERROR" /* ERROR */,
+          metadata: {
+            operation: "analyzeResults",
+            error: error.message,
+            reason: "Failed to analyze provider results"
+          }
+        }
+      );
+      return {
+        bestProvider: resolveDefaultProvider().value,
+        providerRecommendations: [],
+        insights: []
+      };
+    }
+  }
+  /**
+   * Get optimization insights for specific provider
+   *
+   * SWOT analysis (Strengths, Weaknesses, Opportunities, Threats)
+   */
+  async getProviderOptimizationInsights(provider, promptId) {
+    try {
+      return await this.providerTracker.getProviderOptimizationInsights(
+        provider,
+        promptId
+      );
+    } catch (error) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: promptId,
+          subsystem: "optimization",
+          provider,
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "getProviderOptimizationInsights",
+            provider,
+            error: error.message,
+            reason: "Failed to get optimization insights for provider"
+          }
+        }
+      );
+      return [];
+    }
+  }
+  /**
+   * Get provider recommendations for a prompt
+   */
+  async getProviderRecommendations(promptId) {
+    try {
+      return await this.providerTracker.getProviderRecommendations(promptId);
+    } catch (error) {
+      emitWarning(
+        "PR-001",
+        {
+          taskId: promptId,
+          subsystem: "optimization",
+          executionPhase: "execution"
+        },
+        {
+          severity: "WARN" /* WARN */,
+          metadata: {
+            operation: "getProviderRecommendations",
+            error: error.message,
+            reason: "Failed to get provider recommendations"
+          }
+        }
+      );
+      return [];
+    }
+  }
+  // Private helpers
+  /**
+   * Track a single variant execution
+   */
+  async trackVariant(promptId, versionId, variant, taskComplexity) {
+    await this.providerTracker.trackProviderExecution({
+      provider: variant.provider,
+      promptId,
+      versionId,
+      variant: variant.variantName || void 0,
+      success: variant.success,
+      completeness: variant.completeness || 0,
+      duration: variant.durationSeconds || 0,
+      tokensUsed: variant.tokensUsed,
+      codeDelivered: variant.codeDelivered || false,
+      errorCount: variant.errorCount || 0,
+      warningCount: variant.warningCount || 0,
+      testsPassed: variant.testResults ? variant.testResults.passed : void 0,
+      testsFailed: variant.testResults ? variant.testResults.failed : void 0,
+      taskComplexity: taskComplexity || "medium",
+      timestamp: variant.createdAt
+    });
+  }
+  /**
+   * Close resources
+   */
+  close() {
+    this.providerTracker.close();
+  }
+};
+
+// src/core/optimization/OptimizationEngine.ts
+var OptimizationEngine = class {
+  poeticDir;
+  promptStore;
+  executionTracker;
+  configManager;
+  telemetry;
+  // Wrappers
+  variantGenerator;
+  optimizer;
+  providerInsights;
+  competitionRunner;
+  activationAuthority;
+  // Locks
+  activeLocks = /* @__PURE__ */ new Map();
+  lockDirs = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const poeticDir = resolvePoeticDirFromContext(options.poeticDir);
+    this.poeticDir = poeticDir;
+    this.promptStore = options.promptStore || new PromptVersionStore({ poeticDir });
+    this.executionTracker = options.executionTracker || new ExecutionTracker({ poeticDir });
+    this.configManager = new OptimizationConfigManager(poeticDir);
+    this.telemetry = options.telemetryLogger || TelemetryLogger.getInstance({ poeticDir });
+    const variantGen = new VariantGenerator();
+    const autoOptimizer = new AutomaticPromptOptimizer({ poeticDir });
+    const providerTracker = new ProviderTracker({ poeticDir });
+    this.variantGenerator = new PromptVariantGenerator(this.promptStore, variantGen);
+    this.optimizer = new OptimizationRecommendationAdapter(
+      this.promptStore,
+      this.executionTracker,
+      autoOptimizer
+    );
+    this.providerInsights = new ProviderInsights(providerTracker, this.executionTracker);
+    this.competitionRunner = options.competitionRunner ?? new NoopCompetitionRunner();
+    this.activationAuthority = options.activationAuthority ?? new TunerActivationAuthority(
+      new AutoTuningEngine({ poeticDir, enableAutoActivation: true }),
+      this.telemetry
+    );
+  }
+  /**
+   * Run complete optimization cycle
+   *
+   * Executes all 6 steps of the optimization loop.
+   *
+   * @param promptId - Prompt to optimize (name or ID)
+   * @param options - Optimization options
+   * @returns Optimization result
+   * @throws Error if lock acquisition fails
+   * @throws Error if prompt not found
+   * @throws Error if insufficient execution data
+   */
+  async optimize(promptId, options = {}) {
+    const startTime = Date.now();
+    const cycleId = options.cycleId || this.generateCycleId();
+    let lockKey = null;
+    try {
+      this.telemetry.logCostEvent("prompt:optimize:started", {
+        promptId,
+        cycleId,
+        variantCount: options.variantCount ?? null,
+        improvementThreshold: options.improvementThreshold ?? null,
+        costBudget: options.costBudget ?? null,
+        providerStrategy: options.providerStrategy ?? null,
+        mutationStrategies: options.mutationStrategies ?? null,
+        providers: options.providers ?? null,
+        autoActivate: options.autoActivate ?? null
+      });
+      const resolvedPrompt = await this.resolvePrompt(promptId);
+      if (!resolvedPrompt) {
+        throw new Error(`Prompt ${promptId} not found`);
+      }
+      lockKey = resolvedPrompt.id;
+      await this.acquireLock(lockKey, cycleId);
+      const { prompt, activeVersion, metrics } = await this.loadActiveVersion(resolvedPrompt.id);
+      const config = this.configManager.getConfig(prompt.name, {
+        variantCount: options.variantCount,
+        improvementThreshold: options.improvementThreshold,
+        maxCostIncrease: options.costBudget,
+        providerStrategy: options.providerStrategy,
+        providersToTest: options.providers,
+        autoActivate: options.autoActivate,
+        mutationStrategies: options.mutationStrategies
+      });
+      const cycle = await this.createCycle(
+        prompt.id,
+        activeVersion.id,
+        cycleId,
+        config,
+        options.triggerReason
+      );
+      try {
+        const { candidates } = await this.variantGenerator.generateCandidates(
+          prompt.id,
+          activeVersion.id,
+          {
+            count: config.variantCount,
+            strategies: config.mutationStrategies,
+            targetMetric: config.targetMetric,
+            cycleId
+          }
+        );
+        cycle.candidateVersionIds = candidates.map((c) => c.id);
+        const competitionResult = await this.runCompetition(
+          prompt.id,
+          activeVersion,
+          candidates,
+          config,
+          cycleId
+        );
+        if (competitionResult.status === "failed") {
+          throw new Error(
+            `Competition runner failed: ${competitionResult.errors[0] || "unknown runner error"}`
+          );
+        }
+        await this.providerInsights.trackOptimizationCycle(prompt.id, cycle.candidateVersionIds);
+        const analysis = await this.analyzeCandidates(
+          prompt.id,
+          activeVersion.id,
+          candidates,
+          config
+        );
+        const bestCandidate = analysis[0];
+        if (!bestCandidate) {
+          return {
+            cycleId,
+            promptId: prompt.id,
+            success: true,
+            candidatesGenerated: candidates.length,
+            candidatesTested: 0,
+            decision: "deferred",
+            improvementFound: false,
+            safetyChecksPassed: false,
+            messages: ["No execution metrics available for candidate evaluation"],
+            warnings: [],
+            errors: [],
+            durationSeconds: (Date.now() - startTime) / 1e3,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        const safetyChecks = this.runSafetyChecks(bestCandidate, metrics, config);
+        const decision = await this.makeActivationDecision(
+          prompt.id,
+          activeVersion.id,
+          bestCandidate,
+          safetyChecks,
+          config,
+          options
+        );
+        const result = await this.completeCycle(
+          cycle,
+          candidates,
+          analysis,
+          bestCandidate,
+          safetyChecks,
+          decision,
+          startTime
+        );
+        this.telemetry.logCostEvent("prompt:optimize:completed", {
+          promptId,
+          cycleId,
+          success: true,
+          improvementPercentage: result.improvementPercentage ?? null,
+          activated: result.decision === "activated"
+        });
+        return result;
+      } catch (error) {
+        this.telemetry.logCostEvent("prompt:optimize:failed", {
+          promptId,
+          cycleId,
+          error: error.message
+        });
+        cycle.status = "failed";
+        cycle.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        throw error;
+      } finally {
+        if (lockKey) {
+          this.releaseLock(lockKey);
+        }
+      }
+    } catch (error) {
+      const durationSeconds = (Date.now() - startTime) / 1e3;
+      return {
+        cycleId,
+        promptId,
+        success: false,
+        candidatesGenerated: 0,
+        candidatesTested: 0,
+        decision: "failed",
+        improvementFound: false,
+        safetyChecksPassed: false,
+        messages: [],
+        warnings: [],
+        errors: [error.message],
+        durationSeconds,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  // Private methods
+  /**
+   * Resolve prompt by ID or name
+   *
+   * Supports both CLI usage (passes name) and scheduled optimization (passes ID).
+   * Tries name lookup first, then falls back to ID lookup.
+   */
+  async resolvePrompt(promptIdOrName) {
+    let prompt = await this.promptStore.getPrompt(promptIdOrName);
+    if (!prompt) {
+      prompt = await this.promptStore.getPromptById(promptIdOrName);
+    }
+    return prompt;
+  }
+  /**
+   * Step 1: Load active version with validation
+   */
+  async loadActiveVersion(promptIdOrName) {
+    const prompt = await this.resolvePrompt(promptIdOrName);
+    if (!prompt) {
+      throw new Error(`Prompt ${promptIdOrName} not found`);
+    }
+    if (!prompt.activeVersionId) {
+      throw new Error(`Prompt ${promptIdOrName} has no active version`);
+    }
+    const activeVersion = await this.promptStore.getVersion(prompt.activeVersionId);
+    if (!activeVersion) {
+      throw new Error(`Active version ${prompt.activeVersionId} not found`);
+    }
+    const metrics = this.executionTracker.getMetrics(prompt.id, activeVersion.id);
+    if (!metrics) {
+      throw new Error(`No execution metrics found for ${promptIdOrName}`);
+    }
+    const config = this.configManager.getConfig(prompt.name);
+    if (metrics.totalExecutions < config.minSampleSize) {
+      throw new Error(
+        `Insufficient execution data: ${metrics.totalExecutions}/${config.minSampleSize} executions`
+      );
+    }
+    return { prompt, activeVersion, metrics };
+  }
+  /**
+   * Step 2: Acquire optimization lock
+   */
+  async acquireLock(promptId, cycleId) {
+    const SIX_HOURS = 6 * 60 * 60 * 1e3;
+    const owner = {
+      promptId,
+      cycleId,
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.activeLocks.has(promptId)) {
+      const existingLock = this.activeLocks.get(promptId);
+      const lockAge = Date.now() - new Date(existingLock.startedAt).getTime();
+      if (lockAge < SIX_HOURS) {
+        throw new Error(
+          `Optimization already running for ${promptId} (started ${(lockAge / 1e3 / 60).toFixed(0)} minutes ago)`
+        );
+      }
+      this.activeLocks.delete(promptId);
+    }
+    const lockDir = this.getLockDir(promptId);
+    try {
+      fs.mkdirSync(path.dirname(lockDir), { recursive: true });
+      fs.mkdirSync(lockDir);
+      fs.writeFileSync(path.join(lockDir, "owner.json"), JSON.stringify(owner, null, 2));
+      this.lockDirs.set(promptId, lockDir);
+    } catch (error) {
+      const nodeError = error;
+      if (nodeError.code !== "EEXIST") {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+        throw error;
+      }
+      const metadata = this.readLockMetadata(lockDir);
+      const startedAt = metadata?.startedAt ? Date.parse(metadata.startedAt) : NaN;
+      const lockAge = Number.isFinite(startedAt) ? Date.now() - startedAt : 0;
+      if (lockAge < SIX_HOURS) {
+        throw new Error(
+          `Optimization already running for ${promptId} (started ${(lockAge / 1e3 / 60).toFixed(0)} minutes ago)`
+        );
+      }
+      const staleLockDir = `${lockDir}.stale-${process.pid}-${Date.now()}-${crypto.randomBytes(3).toString("hex")}`;
+      try {
+        fs.renameSync(lockDir, staleLockDir);
+      } catch {
+        throw new Error(
+          `Optimization already running for ${promptId}; stale lock was recovered by another process`
+        );
+      }
+      try {
+        fs.rmSync(staleLockDir, { recursive: true, force: true });
+        fs.mkdirSync(lockDir);
+        fs.writeFileSync(
+          path.join(lockDir, "owner.json"),
+          JSON.stringify(
+            {
+              ...owner,
+              recoveredExpiredLock: true
+            },
+            null,
+            2
+          )
+        );
+        this.lockDirs.set(promptId, lockDir);
+      } catch (recoveryError) {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+        throw recoveryError;
+      }
+    }
+    const lock = {
+      id: cycleId,
+      promptId,
+      sourceVersionId: "",
+      candidateVersionIds: [],
+      cycleType: "manual",
+      config: this.configManager.getDefaults(),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "running",
+      activated: false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.activeLocks.set(promptId, lock);
+  }
+  /**
+   * Step 3: Release optimization lock
+   */
+  releaseLock(promptId) {
+    const activeLock = this.activeLocks.get(promptId);
+    const lockDir = this.lockDirs.get(promptId);
+    if (lockDir) {
+      const metadata = this.readLockMetadata(lockDir);
+      if (metadata?.cycleId === activeLock?.id && metadata?.pid === process.pid) {
+        fs.rmSync(lockDir, { recursive: true, force: true });
+      }
+      this.lockDirs.delete(promptId);
+    }
+    this.activeLocks.delete(promptId);
+  }
+  /**
+   * Step 4: Create cycle record
+   */
+  async createCycle(promptId, sourceVersionId, cycleId, config, triggerReason) {
+    const cycle = {
+      id: cycleId,
+      promptId,
+      sourceVersionId,
+      candidateVersionIds: [],
+      cycleType: "manual",
+      triggerReason,
+      config,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "running",
+      activated: false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.activeLocks.set(promptId, cycle);
+    return cycle;
+  }
+  /**
+   * Step 5: Run competition for candidates.
+   *
+   * Delegates to the injected `OptimizationCompetitionRunner`. The default
+   * runner (`NoopCompetitionRunner`) is intentionally a no-op so that
+   * freshly-generated candidates carry no `ExecutionTracker` metrics; the
+   * downstream `analyzeCandidates()` step then returns an empty array and
+   * `optimize()` resolves to a `deferred` no-change result with the message
+   * "No execution metrics available for candidate evaluation".
+   *
+   * To enable real competition, pass a non-default `competitionRunner` via
+   * the engine constructor. The runner records per-candidate executions
+   * through `ExecutionTracker`; analysis reads them back via
+   * `getMetrics(promptId, candidate.versionId)`.
+   *
+   * Pinned by `competition-stub.test.ts` (default behavior) and
+   * `competition-runner.test.ts` (injection seam).
+   */
+  async runCompetition(promptId, sourceVersion, candidates, config, cycleId) {
+    return this.competitionRunner.run({
+      promptId,
+      sourceVersion,
+      candidates,
+      config,
+      cycleId,
+      executionTracker: this.executionTracker,
+      promptStore: this.promptStore
+    });
+  }
+  /**
+   * Step 6: Analyze candidates
+   */
+  async analyzeCandidates(promptId, sourceVersionId, candidates, config) {
+    const sourceMetrics = this.executionTracker.getMetrics(promptId, sourceVersionId);
+    const analyses = [];
+    for (const candidate of candidates) {
+      const metrics = this.executionTracker.getMetrics(promptId, candidate.id);
+      if (!metrics) continue;
+      const score = metrics.avgSuccessRate * 0.35 + metrics.avgCompleteness / 100 * 0.35 + (1 - Math.min(metrics.avgDuration, 300) / 300) * 0.15 + 0.15;
+      const baseScore = sourceMetrics.avgSuccessRate * 0.35 + sourceMetrics.avgCompleteness / 100 * 0.35 + (1 - Math.min(sourceMetrics.avgDuration, 300) / 300) * 0.15 + 0.15;
+      const improvement = (score - baseScore) / baseScore * 100;
+      const confidenceInterval = this.calculateBayesianCI(
+        metrics.avgSuccessRate,
+        metrics.totalExecutions,
+        config.confidenceLevel
+      );
+      const analysis = {
+        versionId: candidate.id,
+        version: candidate,
+        totalExecutions: metrics.totalExecutions,
+        avgSuccessRate: metrics.avgSuccessRate,
+        avgCompleteness: metrics.avgCompleteness,
+        avgDuration: metrics.avgDuration,
+        compositeScore: score,
+        improvementPercentage: improvement,
+        confidenceInterval,
+        confidence: config.confidenceLevel,
+        safetyChecks: [],
+        safetyScore: 0,
+        riskScore: 0
+      };
+      if (metrics.totalCostStatus === "complete" && metrics.totalCost !== void 0) {
+        analysis.totalCost = metrics.totalCost;
+      }
+      analyses.push(analysis);
+    }
+    analyses.sort((a, b) => b.improvementPercentage - a.improvementPercentage);
+    return analyses;
+  }
+  /**
+   * Step 7: Run safety checks
+   */
+  runSafetyChecks(candidate, currentMetrics, config) {
+    const checks = [];
+    checks.push({
+      check: "sample_size",
+      passed: candidate.totalExecutions >= config.minSampleSize,
+      severity: "critical",
+      message: `${candidate.totalExecutions}/${config.minSampleSize} executions`,
+      value: candidate.totalExecutions,
+      threshold: config.minSampleSize
+    });
+    checks.push({
+      check: "improvement_threshold",
+      passed: candidate.improvementPercentage >= config.improvementThreshold,
+      severity: "high",
+      message: `${candidate.improvementPercentage.toFixed(1)}% improvement`,
+      value: candidate.improvementPercentage,
+      threshold: config.improvementThreshold
+    });
+    const successDelta = (candidate.avgSuccessRate - currentMetrics.avgSuccessRate) * 100;
+    checks.push({
+      check: "success_rate_regression",
+      passed: successDelta >= config.allowSuccessRateDrop,
+      severity: "high",
+      message: `${successDelta > 0 ? "+" : ""}${successDelta.toFixed(1)}% change`,
+      value: successDelta,
+      threshold: config.allowSuccessRateDrop
+    });
+    const currentCost = currentMetrics.totalCost;
+    const candidateCost = candidate.totalCost;
+    if (currentCost === void 0 || candidateCost === void 0 || !Number.isFinite(currentCost) || !Number.isFinite(candidateCost)) {
+      checks.push({
+        check: "cost_spike",
+        passed: false,
+        severity: "medium",
+        message: "cost unavailable"
+      });
+    } else if (currentCost === 0 && candidateCost === 0) {
+      checks.push({
+        check: "cost_spike",
+        passed: true,
+        severity: "medium",
+        message: "0% of current cost",
+        value: 0,
+        threshold: config.maxCostIncrease
+      });
+    } else if (currentCost === 0 && candidateCost > 0) {
+      checks.push({
+        check: "cost_spike",
+        passed: false,
+        severity: "medium",
+        message: "positive cost from zero baseline exceeds max cost increase",
+        threshold: config.maxCostIncrease
+      });
+    } else {
+      const costRatio = candidateCost / currentCost;
+      checks.push({
+        check: "cost_spike",
+        passed: costRatio <= config.maxCostIncrease,
+        severity: "medium",
+        message: `${(costRatio * 100).toFixed(0)}% of current cost`,
+        value: costRatio,
+        threshold: config.maxCostIncrease
+      });
+    }
+    return checks;
+  }
+  /**
+   * Step 8: Make activation decision
+   */
+  async makeActivationDecision(promptId, sourceVersionId, bestCandidate, safetyChecks, config, options) {
+    const shouldAutoActivate = options.autoActivate !== void 0 ? options.autoActivate : config.activationMode === "auto" || config.autoActivate;
+    if (!shouldAutoActivate) {
+      return {
+        activated: false,
+        kind: "disabled",
+        reason: "Auto-activation disabled - manual review required"
+      };
+    }
+    const allPassed = safetyChecks.every((c) => c.passed);
+    if (!allPassed && !options.skipSafetyChecks) {
+      const failed = safetyChecks.filter((c) => !c.passed).map((c) => c.check);
+      return {
+        activated: false,
+        kind: "safety_failed",
+        reason: `Safety checks failed: ${failed.join(", ")}`
+      };
+    }
+    const reason = `Activated v${bestCandidate.version.versionNumber} (+${bestCandidate.improvementPercentage.toFixed(1)}%)`;
+    try {
+      const result = await this.activationAuthority.activate({
+        promptId,
+        candidateVersionId: bestCandidate.versionId,
+        sourceVersionId,
+        improvementPercentage: bestCandidate.improvementPercentage,
+        confidence: bestCandidate.confidence,
+        skipSafetyChecks: options.skipSafetyChecks,
+        reason,
+        // Tranche B: forward engine-side safety result so the authority
+        // emits `prompt:activate:auto` with the same payload the engine
+        // used to emit. The engine no longer emits this event directly.
+        safetyChecksPassed: allPassed
+      });
+      if (!result.activated) {
+        return {
+          activated: false,
+          kind: "declined",
+          reason: result.reason || "Activation authority declined activation"
+        };
+      }
+      const recordId = result.record?.id;
+      if (recordId && this.activationAuthority.scheduleMonitoring) {
+        this.activationAuthority.scheduleMonitoring(recordId);
+      }
+      return {
+        activated: true,
+        kind: "activated",
+        record: result.record ?? void 0,
+        reason
+      };
+    } catch (error) {
+      return {
+        activated: false,
+        kind: "failed",
+        reason: `Activation failed: ${error.message}`
+      };
+    }
+  }
+  /**
+   * Step 9: Complete cycle and return result
+   */
+  async completeCycle(cycle, candidates, analysis, bestCandidate, safetyChecks, decision, startTime) {
+    const durationSeconds = (Date.now() - startTime) / 1e3;
+    const providerAnalysis = await this.providerInsights.analyzeResults(cycle.promptId);
+    const activationFailure = decision.kind === "failed";
+    const result = {
+      cycleId: cycle.id,
+      promptId: cycle.promptId,
+      success: !activationFailure,
+      candidatesGenerated: candidates.length,
+      candidatesTested: analysis.length,
+      bestCandidate,
+      decision: decision.activated ? "activated" : activationFailure ? "failed" : "deferred",
+      activatedVersionId: decision.activated ? bestCandidate.versionId : void 0,
+      activationRecord: decision.activated ? decision.record : void 0,
+      providerInsights: {
+        bestProvider: providerAnalysis.bestProvider,
+        recommendations: providerAnalysis.providerRecommendations,
+        insights: providerAnalysis.insights
+      },
+      improvementFound: bestCandidate.improvementPercentage > 0,
+      improvementPercentage: bestCandidate.improvementPercentage,
+      safetyChecksPassed: safetyChecks.every((c) => c.passed),
+      messages: [decision.reason],
+      warnings: [],
+      errors: activationFailure ? [decision.reason] : [],
+      durationSeconds,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (bestCandidate.totalCost !== void 0 && Number.isFinite(bestCandidate.totalCost)) {
+      result.costUsd = bestCandidate.totalCost;
+    }
+    cycle.status = activationFailure ? "failed" : "completed";
+    cycle.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    cycle.durationSeconds = durationSeconds;
+    cycle.bestCandidateId = bestCandidate.versionId;
+    cycle.improvementScore = bestCandidate.improvementPercentage;
+    cycle.activated = decision.activated;
+    cycle.safetyCheckResults = safetyChecks;
+    if (bestCandidate.totalCost !== void 0 && Number.isFinite(bestCandidate.totalCost)) {
+      cycle.totalCostUsd = bestCandidate.totalCost;
+    }
+    return result;
+  }
+  // Utility methods
+  generateCycleId() {
+    return `cycle_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+  }
+  getLockDir(promptId) {
+    const digest = crypto.createHash("sha256").update(promptId).digest("hex").slice(0, 24);
+    return path.join(this.poeticDir, "tmp", "optimization-locks", digest);
+  }
+  readLockMetadata(lockDir) {
+    try {
+      const raw = fs.readFileSync(path.join(lockDir, "owner.json"), "utf8");
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === "object" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  calculateBayesianCI(successRate, sampleSize, confidenceLevel) {
+    const z = confidenceLevel === 0.95 ? 1.96 : 1.645;
+    const phat = successRate;
+    const n = sampleSize;
+    const denominator = 1 + z * z / n;
+    const center = (phat + z * z / (2 * n)) / denominator;
+    const margin = z * Math.sqrt(phat * (1 - phat) / n + z * z / (4 * n * n)) / denominator;
+    return [Math.max(0, center - margin), Math.min(1, center + margin)];
+  }
+  // ============================================================================
+  // SCHEDULED OPTIMIZATION API
+  // ============================================================================
+  /**
+   * Run scheduled optimization for opted-in prompts
+   *
+   * This method is called by the scheduler (thin timing wrapper) to:
+   * 1. Select all prompts opted into auto-optimization
+   * 2. Apply unified policy from config
+   * 3. Run optimization for eligible prompts
+   * 4. Handle telemetry and logging
+   *
+   * @returns Summary of scheduled optimization run
+   */
+  async runScheduledOptimization() {
+    const startTime = Date.now();
+    const results = [];
+    const skipped = [];
+    const errors = [];
+    try {
+      const optedInPrompts = await this.getOptedInPrompts();
+      if (optedInPrompts.length === 0) {
+        this.telemetry.logCostEvent("optimization:scheduled:empty", {
+          message: "No prompts opted into auto-optimization"
+        });
+        return {
+          success: true,
+          totalPrompts: 0,
+          optimized: 0,
+          skipped: 0,
+          failed: 0,
+          results: [],
+          skippedPrompts: [],
+          errors: [],
+          durationSeconds: (Date.now() - startTime) / 1e3,
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      this.telemetry.logCostEvent("optimization:scheduled:started", {
+        promptCount: optedInPrompts.length,
+        promptIds: optedInPrompts.map((p) => p.id)
+      });
+      for (const prompt of optedInPrompts) {
+        try {
+          const eligibility = await this.checkOptimizationEligibility(prompt.id);
+          if (!eligibility.eligible) {
+            skipped.push({
+              promptId: prompt.id,
+              reason: eligibility.reason
+            });
+            continue;
+          }
+          const config = this.configManager.getConfig(prompt.name);
+          const shouldAutoActivate = config.activationMode === "auto" || config.autoActivate;
+          const result = await this.optimize(prompt.id, {
+            triggerReason: "scheduled",
+            autoActivate: shouldAutoActivate
+          });
+          results.push(result);
+        } catch (error) {
+          errors.push({
+            promptId: prompt.id,
+            error: error.message
+          });
+          this.telemetry.logCostEvent("optimization:scheduled:prompt-error", {
+            promptId: prompt.id,
+            error: error.message
+          });
+        }
+      }
+      const durationSeconds = (Date.now() - startTime) / 1e3;
+      this.telemetry.logCostEvent("optimization:scheduled:completed", {
+        totalPrompts: optedInPrompts.length,
+        optimized: results.filter((r) => r.success).length,
+        skipped: skipped.length,
+        failed: errors.length,
+        durationSeconds
+      });
+      return {
+        success: true,
+        totalPrompts: optedInPrompts.length,
+        optimized: results.filter((r) => r.success).length,
+        skipped: skipped.length,
+        failed: errors.length,
+        results,
+        skippedPrompts: skipped,
+        errors,
+        durationSeconds,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      const durationSeconds = (Date.now() - startTime) / 1e3;
+      this.telemetry.logCostEvent("optimization:scheduled:failed", {
+        error: error.message
+      });
+      return {
+        success: false,
+        totalPrompts: 0,
+        optimized: 0,
+        skipped: 0,
+        failed: 1,
+        results: [],
+        skippedPrompts: [],
+        errors: [{ promptId: "unknown", error: error.message }],
+        durationSeconds,
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  /**
+   * Get prompts opted into auto-optimization
+   *
+   * Checks multiple sources for opt-in (in priority order):
+   * 1. Prompt-specific config: activationMode: 'auto'
+   * 2. Prompt entity flag: prompt.autoOptimize (legacy)
+   * 3. Global config: activationMode: 'auto' (applies to all prompts)
+   * 4. Legacy flags: autoActivate: true && requireManualReview: false
+   */
+  async getOptedInPrompts() {
+    const allPrompts = await this.promptStore.listPrompts();
+    const globalConfig = this.configManager.getConfig(void 0);
+    const globalOptIn = globalConfig.activationMode === "auto";
+    const optedIn = [];
+    for (const prompt of allPrompts) {
+      const promptConfig = this.configManager.getPromptConfig(prompt.name);
+      const hasPromptAutoMode = promptConfig?.activationMode === "auto";
+      const hasPromptAutoOptimize = prompt.autoOptimize === true;
+      const hasGlobalAutoMode = globalOptIn && promptConfig?.activationMode !== "manual";
+      const fullConfig = this.configManager.getConfig(prompt.name);
+      const hasLegacyAutoActivate = fullConfig.autoActivate === true && fullConfig.requireManualReview === false;
+      const isOptedIn = hasPromptAutoMode || hasPromptAutoOptimize || hasGlobalAutoMode || hasLegacyAutoActivate;
+      if (isOptedIn) {
+        optedIn.push({ id: prompt.id, name: prompt.name });
+      }
+    }
+    return optedIn;
+  }
+  /**
+   * Check if a prompt is eligible for optimization
+   *
+   * @param promptIdOrName - Prompt ID or name (supports both for CLI and scheduled use)
+   */
+  async checkOptimizationEligibility(promptIdOrName) {
+    const prompt = await this.resolvePrompt(promptIdOrName);
+    if (!prompt) {
+      return { eligible: false, reason: "Prompt not found" };
+    }
+    if (!prompt.activeVersionId) {
+      return { eligible: false, reason: "No active version" };
+    }
+    const metrics = this.executionTracker.getMetrics(prompt.id, prompt.activeVersionId);
+    if (!metrics) {
+      return { eligible: false, reason: "No execution metrics available" };
+    }
+    const config = this.configManager.getConfig(prompt.name);
+    if (metrics.totalExecutions < config.minSampleSize) {
+      return {
+        eligible: false,
+        reason: `Insufficient data: ${metrics.totalExecutions}/${config.minSampleSize} executions`
+      };
+    }
+    if (this.activeLocks.has(prompt.id)) {
+      return { eligible: false, reason: "Optimization already in progress" };
+    }
+    return { eligible: true, reason: "Eligible for optimization" };
+  }
+  /**
+   * Analyze a prompt for potential optimization (dry-run)
+   *
+   * Returns analysis without generating variants or activating.
+   * Does NOT hard-fail on missing metrics - returns eligible: false instead.
+   * Useful for CLI `poetic prompt analyze` command.
+   *
+   * @param promptIdOrName - Prompt ID or name (supports both for CLI and scheduled use)
+   */
+  async analyze(promptIdOrName) {
+    const prompt = await this.resolvePrompt(promptIdOrName);
+    if (!prompt) {
+      throw new Error(`Prompt ${promptIdOrName} not found`);
+    }
+    if (!prompt.activeVersionId) {
+      throw new Error(`Prompt ${promptIdOrName} has no active version`);
+    }
+    const activeVersion = await this.promptStore.getVersion(prompt.activeVersionId);
+    if (!activeVersion) {
+      throw new Error(`Active version ${prompt.activeVersionId} not found`);
+    }
+    const config = this.configManager.getConfig(prompt.name);
+    const metrics = this.executionTracker.getMetrics(prompt.id, activeVersion.id);
+    const recommendation = await this.optimizer.getRecommendation(prompt.name);
+    const eligibility = await this.checkOptimizationEligibility(prompt.id);
+    const costComplete = metrics?.totalCostStatus === "complete" && metrics.totalCost !== void 0;
+    return {
+      promptId: prompt.id,
+      promptName: prompt.name,
+      activeVersionId: activeVersion.id,
+      currentPerformance: {
+        totalExecutions: metrics?.totalExecutions ?? 0,
+        avgSuccessRate: metrics?.avgSuccessRate ?? 0,
+        avgCompleteness: metrics?.avgCompleteness ?? 0,
+        avgDuration: metrics?.avgDuration ?? 0,
+        // Do not recreate zero from missing/incomplete cost.
+        ...costComplete ? { totalCost: metrics.totalCost } : {},
+        totalCostStatus: metrics?.totalCostStatus
+      },
+      eligibility,
+      recommendation,
+      config,
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Close resources
+   */
+  close() {
+    this.variantGenerator.close();
+    this.optimizer.close();
+    this.providerInsights.close();
+    this.promptStore.close();
+  }
+};
+export {
+  OptimizationEngine
+};
+//# sourceMappingURL=OptimizationEngine-JIMGP3LY.js.map