@poetic-ai/poetic 1.42.0

package/dist/chunk-LR5IJIGV.js

@@ -0,0 +1,810 @@
+import {
+  ExecutionTracker,
+  ensurePromptExecutionViews,
+  ensurePromptExecutionsCompositeForeignKey
+} from "./chunk-U45RTRGY.js";
+import {
+  performActivation
+} from "./chunk-6BM72ZMG.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  resolvePoeticDirFromContext
+} from "./chunk-UI2F6DJ5.js";
+
+// src/core/storage/PromptStore.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import Database from "better-sqlite3";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var PromptVersionStore = class {
+  poeticDir;
+  dbPath;
+  db;
+  executionTracker;
+  ownsDb;
+  // Live schema flags. The canonical writer (src/prompts/store.ts) uses a
+  // hash-and-file schema with no inline content / version_number columns.
+  // Older databases created by this class used inline-content columns.
+  // We detect which shape the DB is in and adapt reads/writes accordingly.
+  hasInlineContent = false;
+  hasVersionNumberColumn = false;
+  hasOptimizationMetadataColumn = false;
+  activeContentDir;
+  archivedContentDir;
+  // Safety thresholds
+  MIN_EXECUTIONS = 3;
+  MIN_SUCCESS_RATE = 0.5;
+  MAX_QUALITY_REGRESSION = 10;
+  // percent
+  MAX_COST_MULTIPLIER = 2;
+  constructor(options = {}) {
+    this.poeticDir = resolvePoeticDirFromContext(options.poeticDir);
+    const dbDir = path.join(this.poeticDir, "prompts", "db");
+    this.activeContentDir = path.join(this.poeticDir, "prompts", "active");
+    this.archivedContentDir = path.join(this.poeticDir, "prompts", "archived");
+    if (options.db) {
+      this.db = options.db;
+      this.dbPath = this.db.name;
+      this.ownsDb = false;
+    } else {
+      if (!fs.existsSync(dbDir)) {
+        fs.mkdirSync(dbDir, { recursive: true });
+      }
+      this.dbPath = path.join(dbDir, "prompts.db");
+      this.db = new Database(this.dbPath);
+      this.ownsDb = true;
+    }
+    this.executionTracker = new ExecutionTracker({
+      poeticDir: this.poeticDir,
+      autoApplySchema: false,
+      // We'll apply schema ourselves
+      db: this.db
+      // Share the database connection
+    });
+    if (options.autoApplySchema !== false) {
+      this.applySchema();
+    }
+    this.detectSchemaShape();
+  }
+  /**
+   * Detect whether the prompt_versions table has inline content or hash-and-file shape.
+   * The canonical writer is src/prompts/store.ts (hash-and-file). This class historically
+   * created the inline-content shape; new installs must read whatever's actually on disk.
+   */
+  detectSchemaShape() {
+    try {
+      const cols = this.db.prepare("PRAGMA table_info(prompt_versions)").all();
+      const names = new Set(cols.map((c) => c.name));
+      this.hasInlineContent = names.has("content");
+      this.hasVersionNumberColumn = names.has("version_number");
+      this.hasOptimizationMetadataColumn = names.has("optimization_metadata");
+    } catch {
+      this.hasInlineContent = false;
+      this.hasVersionNumberColumn = false;
+      this.hasOptimizationMetadataColumn = false;
+    }
+  }
+  /**
+   * Hydrate version content from disk when the DB schema doesn't carry it inline.
+   * Mirrors src/prompts/store.ts:getVersionContentPath naming: <promptId>-<versionId>.txt.
+   * Returns empty string if the side file is missing - callers must validate.
+   */
+  hydrateContentFromFile(promptId, versionId) {
+    const candidates = [
+      path.join(this.activeContentDir, `${promptId}-${versionId}.txt`),
+      path.join(this.archivedContentDir, `${promptId}-${versionId}.txt`)
+    ];
+    for (const p of candidates) {
+      if (fs.existsSync(p)) {
+        try {
+          return fs.readFileSync(p, "utf8");
+        } catch {
+          return "";
+        }
+      }
+    }
+    return "";
+  }
+  /**
+   * Apply schema.
+   *
+   * This class previously created divergent prompts/prompt_versions tables (inline content,
+   * `version_number INTEGER NOT NULL`) that did not match the canonical writer
+   * src/prompts/store.ts (hash-and-file). On databases the canonical writer touched first,
+   * the IF NOT EXISTS made the divergent CREATE a silent no-op and `rowToVersion` then read
+   * a column that wasn't there.
+   *
+   * Now we declare the canonical hash-and-file shape so fresh databases match the canonical
+   * writer's expectations, and the legacy inline-content shape is read transparently when
+   * detected via PRAGMA in detectSchemaShape.
+   *
+   * The execution-tracking tables are owned exclusively here via schema-extensions.sql.
+   */
+  applySchema() {
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompts (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        category TEXT NOT NULL DEFAULT 'adhoc',
+        status TEXT NOT NULL DEFAULT 'active',
+        variant TEXT,
+        tags TEXT NOT NULL DEFAULT '[]',
+        auto_opt_in INTEGER DEFAULT 0,
+        current_version TEXT NOT NULL,
+        active_version_id TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        archived_at TEXT,
+        usage_count INTEGER DEFAULT 0,
+        last_used_at TEXT,
+        UNIQUE(name, category)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_prompts_name ON prompts(name);
+      CREATE INDEX IF NOT EXISTS idx_prompts_category ON prompts(category);
+      CREATE INDEX IF NOT EXISTS idx_prompts_active_version ON prompts(active_version_id);
+
+      CREATE TABLE IF NOT EXISTS prompt_versions (
+        id TEXT NOT NULL,
+        prompt_id TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        changelog TEXT,
+        author TEXT,
+        is_active INTEGER DEFAULT 0,
+        is_generated INTEGER DEFAULT 0,
+        generation_model TEXT,
+        generation_prompt TEXT,
+        created_at TEXT NOT NULL,
+        activated_at TEXT,
+        deactivated_at TEXT,
+        parent_version_id TEXT,
+        mutation_type TEXT,
+        optimization_metadata TEXT,
+        generated_by TEXT,
+        activated_by TEXT,
+        performance_score REAL,
+        PRIMARY KEY (prompt_id, id),
+        FOREIGN KEY (prompt_id) REFERENCES prompts(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_versions_prompt ON prompt_versions(prompt_id);
+      CREATE INDEX IF NOT EXISTS idx_versions_active ON prompt_versions(prompt_id, is_active);
+    `);
+    this.ensureActivationColumns();
+    const schemaPath = path.join(__dirname, "schema-extensions.sql");
+    if (fs.existsSync(schemaPath)) {
+      const schema = fs.readFileSync(schemaPath, "utf8");
+      this.db.exec(schema);
+      ensurePromptExecutionsCompositeForeignKey(this.db);
+      ensurePromptExecutionViews(this.db);
+    } else {
+      ensurePromptExecutionsCompositeForeignKey(this.db);
+      ensurePromptExecutionViews(this.db);
+    }
+  }
+  ensureActivationColumns() {
+    const promptColumns = this.db.prepare("PRAGMA table_info(prompts)").all();
+    const promptColumnNames = new Set(promptColumns.map((col) => col.name));
+    if (!promptColumnNames.has("active_version_id")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN active_version_id TEXT");
+    }
+    if (!promptColumnNames.has("current_version")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN current_version TEXT");
+      this.db.exec(
+        "UPDATE prompts SET current_version = active_version_id WHERE current_version IS NULL"
+      );
+    }
+    if (!promptColumnNames.has("tags")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'");
+    }
+    if (!promptColumnNames.has("archived_at")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN archived_at TEXT");
+    }
+    if (!promptColumnNames.has("usage_count")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN usage_count INTEGER DEFAULT 0");
+    }
+    if (!promptColumnNames.has("last_used_at")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN last_used_at TEXT");
+    }
+    const versionColumns = this.db.prepare("PRAGMA table_info(prompt_versions)").all();
+    const versionColumnNames = new Set(versionColumns.map((col) => col.name));
+    if (!versionColumnNames.has("activated_at")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN activated_at TEXT");
+    }
+    if (!versionColumnNames.has("deactivated_at")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN deactivated_at TEXT");
+    }
+    if (!versionColumnNames.has("optimization_metadata")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN optimization_metadata TEXT");
+    }
+    if (versionColumnNames.has("content_hash")) {
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_versions_hash ON prompt_versions(content_hash)");
+    }
+  }
+  // ============================================================================
+  // CRUD Operations
+  // ============================================================================
+  /**
+   * Create a new prompt with initial version
+   */
+  async createPrompt(input) {
+    const MAX_NAME_LENGTH = 255;
+    const MAX_DESCRIPTION_LENGTH = 1e3;
+    const MAX_CONTENT_SIZE = 10 * 1024 * 1024;
+    if (!input.name || input.name.trim().length === 0) {
+      throw new Error("Prompt name cannot be empty");
+    }
+    if (input.name.length > MAX_NAME_LENGTH) {
+      throw new Error(`Prompt name too long (max ${MAX_NAME_LENGTH} characters)`);
+    }
+    if (input.description && input.description.length > MAX_DESCRIPTION_LENGTH) {
+      throw new Error(`Description too long (max ${MAX_DESCRIPTION_LENGTH} characters)`);
+    }
+    if (input.initialContent.length > MAX_CONTENT_SIZE) {
+      throw new Error(
+        `Content too large (max ${MAX_CONTENT_SIZE / 1024 / 1024}MB, got ${(input.initialContent.length / 1024 / 1024).toFixed(2)}MB)`
+      );
+    }
+    const promptId = this.generateId("prompt");
+    const versionId = this.generateId("version");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const contentHash = crypto.createHash("sha256").update(input.initialContent).digest("hex");
+    if (!this.hasInlineContent) {
+      this.writeSideFile(promptId, versionId, input.initialContent);
+    }
+    try {
+      this.db.transaction(() => {
+        if (this.hasInlineContent) {
+          this.db.prepare(
+            `INSERT INTO prompts (id, name, description, category, active_version_id, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?)`
+          ).run(
+            promptId,
+            input.name,
+            input.description || null,
+            input.category || null,
+            versionId,
+            now,
+            now
+          );
+          this.db.prepare(
+            `INSERT INTO prompt_versions (id, prompt_id, version_number, content, created_by, is_active, created_at)
+               VALUES (?, ?, 1, ?, ?, 1, ?)`
+          ).run(versionId, promptId, input.initialContent, input.createdBy || "user", now);
+        } else {
+          this.db.prepare(
+            `INSERT INTO prompts
+                 (id, name, description, category, status, tags, current_version, active_version_id,
+                  created_at, updated_at)
+               VALUES (?, ?, ?, ?, 'active', '[]', ?, ?, ?, ?)`
+          ).run(
+            promptId,
+            input.name,
+            input.description || "",
+            input.category || "adhoc",
+            versionId,
+            versionId,
+            now,
+            now
+          );
+          this.db.prepare(
+            `INSERT INTO prompt_versions
+                 (id, prompt_id, content_hash, author, generated_by, is_active, created_at, activated_at)
+               VALUES (?, ?, ?, ?, ?, 1, ?, ?)`
+          ).run(
+            versionId,
+            promptId,
+            contentHash,
+            input.createdBy || "user",
+            input.createdBy || "user",
+            now,
+            now
+          );
+        }
+      })();
+    } catch (err) {
+      if (!this.hasInlineContent) {
+        this.removeSideFile(promptId, versionId);
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("UNIQUE constraint failed: prompts.name") || message.includes("UNIQUE constraint failed: prompts.name, prompts.category")) {
+        throw new Error(`Prompt "${input.name}" already exists`);
+      }
+      throw err;
+    }
+    const prompt = await this.getPromptById(promptId);
+    const version = await this.getVersion(versionId);
+    return { prompt, version };
+  }
+  writeSideFile(promptId, versionId, content) {
+    if (!fs.existsSync(this.activeContentDir)) {
+      fs.mkdirSync(this.activeContentDir, { recursive: true });
+    }
+    const target = path.join(this.activeContentDir, `${promptId}-${versionId}.txt`);
+    fs.writeFileSync(target, content, "utf8");
+  }
+  removeSideFile(promptId, versionId) {
+    for (const directory of [this.activeContentDir, this.archivedContentDir]) {
+      try {
+        const target = path.join(directory, `${promptId}-${versionId}.txt`);
+        if (fs.existsSync(target)) fs.unlinkSync(target);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Get prompt by name
+   */
+  async getPrompt(name) {
+    const stmt = this.db.prepare("SELECT * FROM prompts WHERE name = ?");
+    const row = stmt.get(name);
+    if (!row) {
+      return null;
+    }
+    return this.rowToPrompt(row);
+  }
+  /**
+   * Get or create an adhoc prompt (e.g. `adhoc-<hash>`) with a real prompt + active version row.
+   *
+   * This is used to ensure ExecutionTracker can record prompt executions without FK violations
+   * when `poetic compete` is run without `--prompt`/`--save-as`.
+   */
+  async getOrCreateAdhoc(adhocId, opts) {
+    const existing = await this.getPrompt(adhocId);
+    if (existing) {
+      const active = await this.getActiveVersion(existing.id);
+      if (active) {
+        return { promptId: existing.id, versionId: active.id };
+      }
+      const newVersion = await this.createVersion({
+        promptId: existing.id,
+        content: opts.content,
+        createdBy: "user"
+      });
+      await this.activateVersion(existing.id, newVersion.id, { skipSafetyChecks: true });
+      return { promptId: existing.id, versionId: newVersion.id };
+    }
+    try {
+      const { prompt, version } = await this.createPrompt({
+        name: adhocId,
+        initialContent: opts.content,
+        category: opts.category || "adhoc",
+        description: "Adhoc prompt from compete execution",
+        createdBy: "user"
+      });
+      return { promptId: prompt.id, versionId: version.id };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!message.includes("already exists")) {
+        throw err;
+      }
+      const winner = await this.getPrompt(adhocId);
+      if (!winner) {
+        throw err;
+      }
+      const active = await this.getActiveVersion(winner.id);
+      if (!active) {
+        throw new Error(`Adhoc prompt ${adhocId} exists but has no active version`);
+      }
+      return { promptId: winner.id, versionId: active.id };
+    }
+  }
+  /**
+   * Get prompt by ID
+   */
+  async getPromptById(id) {
+    const stmt = this.db.prepare("SELECT * FROM prompts WHERE id = ?");
+    const row = stmt.get(id);
+    if (!row) {
+      return null;
+    }
+    return this.rowToPrompt(row);
+  }
+  /**
+   * List all prompts with optional filters
+   */
+  async listPrompts(filters) {
+    let query = "SELECT * FROM prompts";
+    const params = [];
+    if (filters?.category) {
+      query += " WHERE category = ?";
+      params.push(filters.category);
+    }
+    query += " ORDER BY updated_at DESC";
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => this.rowToPrompt(row));
+  }
+  /**
+   * Delete prompt and all versions
+   */
+  async deletePrompt(id) {
+    const versions = this.hasInlineContent ? [] : this.db.prepare("SELECT id FROM prompt_versions WHERE prompt_id = ?").all(id);
+    const stmt = this.db.prepare("DELETE FROM prompts WHERE id = ?");
+    const result = stmt.run(id);
+    if (result.changes === 0) {
+      throw new Error(`Prompt ${id} not found`);
+    }
+    for (const version of versions) {
+      this.removeSideFile(id, version.id);
+    }
+  }
+  // ============================================================================
+  // Version Management
+  // ============================================================================
+  /**
+   * Create a new version of a prompt
+   */
+  async createVersion(input) {
+    const MAX_CONTENT_SIZE = 10 * 1024 * 1024;
+    if (input.content.length > MAX_CONTENT_SIZE) {
+      throw new Error(
+        `Content too large (max ${MAX_CONTENT_SIZE / 1024 / 1024}MB, got ${(input.content.length / 1024 / 1024).toFixed(2)}MB)`
+      );
+    }
+    const versionId = this.generateId("version");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const contentHash = crypto.createHash("sha256").update(input.content).digest("hex");
+    if (input.parentVersionId) {
+      const parentRow = this.db.prepare("SELECT prompt_id FROM prompt_versions WHERE id = ?").get(input.parentVersionId);
+      if (parentRow && parentRow.prompt_id !== input.promptId) {
+        throw new Error(`parentVersionId "${input.parentVersionId}" belongs to a different prompt`);
+      }
+    }
+    if (!this.hasInlineContent) {
+      this.writeSideFile(input.promptId, versionId, input.content);
+    }
+    try {
+      if (this.hasInlineContent) {
+        const maxRow = this.db.prepare(
+          "SELECT MAX(version_number) as max_version FROM prompt_versions WHERE prompt_id = ?"
+        ).get(input.promptId);
+        const versionNumber = (maxRow?.max_version ?? 0) + 1;
+        this.db.prepare(
+          `INSERT INTO prompt_versions (
+              id, prompt_id, version_number, content, created_by, parent_version_id,
+              optimization_metadata, is_active, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`
+        ).run(
+          versionId,
+          input.promptId,
+          versionNumber,
+          input.content,
+          input.createdBy,
+          input.parentVersionId || null,
+          input.optimizationMetadata ? JSON.stringify(input.optimizationMetadata) : null,
+          now
+        );
+      } else {
+        if (this.hasOptimizationMetadataColumn) {
+          this.db.prepare(
+            `INSERT INTO prompt_versions (
+                id, prompt_id, content_hash, author, generated_by, parent_version_id,
+                optimization_metadata, is_active, created_at
+              ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`
+          ).run(
+            versionId,
+            input.promptId,
+            contentHash,
+            input.createdBy,
+            input.createdBy,
+            input.parentVersionId || null,
+            input.optimizationMetadata ? JSON.stringify(input.optimizationMetadata) : null,
+            now
+          );
+        } else {
+          this.db.prepare(
+            `INSERT INTO prompt_versions (
+                id, prompt_id, content_hash, author, generated_by, parent_version_id,
+                is_active, created_at
+              ) VALUES (?, ?, ?, ?, ?, ?, 0, ?)`
+          ).run(
+            versionId,
+            input.promptId,
+            contentHash,
+            input.createdBy,
+            input.createdBy,
+            input.parentVersionId || null,
+            now
+          );
+        }
+      }
+    } catch (err) {
+      if (!this.hasInlineContent) this.removeSideFile(input.promptId, versionId);
+      throw err;
+    }
+    return await this.getVersion(versionId);
+  }
+  /**
+   * Get version by ID
+   */
+  async getVersion(versionId) {
+    const stmt = this.db.prepare("SELECT rowid AS rowid, * FROM prompt_versions WHERE id = ?");
+    const row = stmt.get(versionId);
+    if (!row) {
+      return null;
+    }
+    return this.rowToVersion(row);
+  }
+  /**
+   * Get all versions for a prompt, ordered newest-first.
+   *
+   * Uses version_number when available (legacy inline schema), otherwise falls back to SQLite
+   * insertion order, which matches the order rowToVersion uses to synthesize numbers.
+   */
+  async getVersionHistory(promptId) {
+    const orderClause = this.hasVersionNumberColumn ? "ORDER BY version_number DESC" : "ORDER BY rowid DESC";
+    const stmt = this.db.prepare(
+      `SELECT rowid AS rowid, * FROM prompt_versions WHERE prompt_id = ? ${orderClause}`
+    );
+    const rows = stmt.all(promptId);
+    if (this.hasVersionNumberColumn) {
+      return rows.map((row) => this.rowToVersion(row));
+    }
+    const versionNumbers = new Map(
+      [...rows].sort((left, right) => {
+        const leftRowId = left.rowid ?? 0;
+        const rightRowId = right.rowid ?? 0;
+        return leftRowId - rightRowId;
+      }).map((row, index) => [row.id, index + 1])
+    );
+    return [...rows].map((row) => this.rowToVersion(row, versionNumbers.get(row.id))).sort((left, right) => right.versionNumber - left.versionNumber);
+  }
+  /**
+   * Resolve a durable version ID or a legacy numeric display selector.
+   *
+   * String IDs are the stable public identity. Numeric selectors (`2`/`v2`) remain a
+   * compatibility convenience and are deliberately resolved only within the prompt.
+   */
+  async resolveVersionSelector(promptId, selector) {
+    const normalized = String(selector).trim();
+    if (!normalized) return null;
+    const scopedRow = this.db.prepare("SELECT rowid AS rowid, * FROM prompt_versions WHERE prompt_id = ? AND id = ?").get(promptId, normalized);
+    if (scopedRow) {
+      return this.rowToVersion(scopedRow);
+    }
+    const numericMatch = /^v?([1-9]\d*)$/.exec(normalized);
+    if (!numericMatch) return null;
+    const versionNumber = Number.parseInt(numericMatch[1], 10);
+    const versions = await this.getVersionHistory(promptId);
+    return versions.find((version) => version.versionNumber === versionNumber) ?? null;
+  }
+  /**
+   * Get version lineage (parent chain)
+   */
+  async getVersionLineage(versionId) {
+    const lineage = [];
+    let currentId = versionId;
+    while (currentId) {
+      const version = await this.getVersion(currentId);
+      if (!version) break;
+      lineage.push(version);
+      currentId = version.parentVersionId;
+    }
+    return lineage;
+  }
+  /**
+   * Get active version for a prompt
+   */
+  async getActiveVersion(promptId) {
+    const stmt = this.db.prepare(
+      "SELECT rowid AS rowid, * FROM prompt_versions WHERE prompt_id = ? AND is_active = 1"
+    );
+    const row = stmt.get(promptId);
+    if (!row) {
+      return null;
+    }
+    return this.rowToVersion(row);
+  }
+  /**
+   * Get the version that immediately precedes the active one in creation order.
+   *
+   * Walks getVersionHistory (newest-first) instead of looking up a specific version_number,
+   * which the canonical hash-and-file schema does not store.
+   */
+  async getPreviousVersion(promptId) {
+    const active = await this.getActiveVersion(promptId);
+    if (!active) {
+      return null;
+    }
+    if (active.parentVersionId) {
+      const parent = await this.getVersion(active.parentVersionId);
+      if (parent) {
+        return parent;
+      }
+    }
+    const history = await this.getVersionHistory(promptId);
+    const activeIndex = history.findIndex((v) => v.isActive);
+    if (activeIndex < 0 || activeIndex >= history.length - 1) {
+      return null;
+    }
+    return history[activeIndex + 1] ?? null;
+  }
+  // ============================================================================
+  // Activation & Safety
+  // ============================================================================
+  /**
+   * Activate a version with safety checks
+   */
+  async activateVersion(promptId, versionId, options) {
+    this.db.transaction(() => {
+      const versionStmt = this.db.prepare("SELECT * FROM prompt_versions WHERE id = ?");
+      const versionRow = versionStmt.get(versionId);
+      if (!versionRow) {
+        throw new Error(`Version ${versionId} not found`);
+      }
+      if (versionRow.prompt_id !== promptId) {
+        throw new Error(`Version ${versionId} does not belong to prompt ${promptId}`);
+      }
+      if (!options?.skipSafetyChecks) {
+        const candidateMetrics = this.executionTracker.getMetrics(promptId, versionId);
+        if (!candidateMetrics || candidateMetrics.completedExecutions < this.MIN_EXECUTIONS) {
+          const execCount = candidateMetrics?.completedExecutions || 0;
+          throw new Error(
+            `Activation blocked: Need at least ${this.MIN_EXECUTIONS} executions (have ${execCount})`
+          );
+        }
+        if (candidateMetrics.avgSuccessRate < this.MIN_SUCCESS_RATE) {
+          throw new Error(
+            `Activation blocked: Success rate ${(candidateMetrics.avgSuccessRate * 100).toFixed(1)}% below threshold ${(this.MIN_SUCCESS_RATE * 100).toFixed(0)}%`
+          );
+        }
+        const promptStmt = this.db.prepare("SELECT active_version_id FROM prompts WHERE id = ?");
+        const promptRow = promptStmt.get(promptId);
+        if (promptRow?.active_version_id) {
+          const currentMetrics = this.executionTracker.getMetrics(
+            promptId,
+            promptRow.active_version_id
+          );
+          if (currentMetrics) {
+            const qualityDelta = candidateMetrics.avgCompleteness - currentMetrics.avgCompleteness;
+            if (qualityDelta < -this.MAX_QUALITY_REGRESSION) {
+              throw new Error(
+                `Activation blocked: Quality regression ${qualityDelta.toFixed(1)}% drop in completeness`
+              );
+            }
+            if (currentMetrics.totalCostStatus === "complete" && candidateMetrics.totalCostStatus === "complete" && currentMetrics.totalCost !== void 0 && candidateMetrics.totalCost !== void 0) {
+              const currentAvgCost = currentMetrics.totalCost / Math.max(1, currentMetrics.completedExecutions);
+              const candidateAvgCost = candidateMetrics.totalCost / Math.max(1, candidateMetrics.completedExecutions);
+              if (currentAvgCost > 0) {
+                const costMultiplier = candidateAvgCost / currentAvgCost;
+                if (costMultiplier > this.MAX_COST_MULTIPLIER) {
+                  throw new Error(
+                    `Activation blocked: Cost increase ${costMultiplier.toFixed(1)}x exceeds ${this.MAX_COST_MULTIPLIER}x threshold`
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+      performActivation(this.db, { promptId, versionId });
+    })();
+  }
+  /**
+   * Rollback to a specific version
+   */
+  async rollbackToVersion(promptId, targetVersionId) {
+    await this.activateVersion(promptId, targetVersionId, { skipSafetyChecks: true });
+  }
+  // ============================================================================
+  // Metrics Integration
+  // ============================================================================
+  /**
+   * Record execution for a prompt version
+   * (Delegates to ExecutionTracker)
+   */
+  async recordExecution(input) {
+    return this.executionTracker.startExecution(input);
+  }
+  /**
+   * Get execution metrics for a prompt version
+   * (Delegates to ExecutionTracker)
+   */
+  getExecutionMetrics(promptId, versionId) {
+    return this.executionTracker.getMetrics(promptId, versionId);
+  }
+  /**
+   * Get all executions for a prompt version
+   */
+  getExecutions(promptId, versionId) {
+    return this.executionTracker.getExecutions(promptId, versionId);
+  }
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  /**
+   * Close database connection (only if owned)
+   */
+  close() {
+    this.executionTracker.close();
+    if (this.ownsDb) {
+      this.db.close();
+    }
+  }
+  /**
+   * Get database path (for testing)
+   */
+  getDatabasePath() {
+    return this.dbPath;
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  generateId(prefix) {
+    return `${prefix}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
+  }
+  rowToPrompt(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description || void 0,
+      category: row.category || void 0,
+      activeVersionId: row.active_version_id || void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  rowToVersion(row, versionNumberOverride) {
+    const createdByRaw = row.created_by ?? row.generated_by ?? row.author ?? "user";
+    const createdBy = createdByRaw === "auto-optimizer" || createdByRaw === "variant-generator" ? createdByRaw : "user";
+    let content = row.content;
+    if (content === void 0 || content === null) {
+      content = this.hydrateContentFromFile(row.prompt_id, row.id);
+    }
+    let versionNumber = versionNumberOverride ?? row.version_number;
+    if (typeof versionNumber !== "number") {
+      versionNumber = this.computeVersionNumber(row.prompt_id, row.id);
+    }
+    return {
+      id: row.id,
+      promptId: row.prompt_id,
+      versionNumber,
+      content,
+      createdBy,
+      parentVersionId: row.parent_version_id || void 0,
+      optimizationMetadata: row.optimization_metadata ? parseJsonWithContext(
+        row.optimization_metadata,
+        "PromptVersionStore.optimizationMetadata"
+      ) : void 0,
+      isActive: row.is_active === 1,
+      createdAt: row.created_at
+    };
+  }
+  /**
+   * Compute a 1-based version number by ordering all versions of a prompt by insertion order.
+   * Used as a fallback when the live schema has no version_number column.
+   */
+  computeVersionNumber(promptId, versionId) {
+    try {
+      const rows = this.db.prepare("SELECT id FROM prompt_versions WHERE prompt_id = ? ORDER BY rowid ASC").all(promptId);
+      const idx = rows.findIndex((r) => r.id === versionId);
+      return idx >= 0 ? idx + 1 : 1;
+    } catch {
+      return 1;
+    }
+  }
+  /**
+   * Resolve a prompt by either its id or its name. Prefers id (exact PK match), falls back to name.
+   *
+   * The CLI's prompt list output exposes `id`, but compete --prompt previously only resolved by
+   * name. This unifies both paths so users can pass either identifier.
+   */
+  async getPromptByIdOrName(idOrName) {
+    const byId = await this.getPromptById(idOrName);
+    if (byId) return byId;
+    return this.getPrompt(idOrName);
+  }
+};
+
+export {
+  PromptVersionStore
+};
+//# sourceMappingURL=chunk-LR5IJIGV.js.map