@poetic-ai/poetic 1.42.0

package/dist/chunk-OQ6K46CK.js

@@ -0,0 +1,1734 @@
+import {
+  performActivation
+} from "./chunk-6BM72ZMG.js";
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  sqlite_wrapper_default
+} from "./chunk-45FPSA3B.js";
+import {
+  resolvePoeticDirFromContext
+} from "./chunk-UI2F6DJ5.js";
+
+// src/prompts/store.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+var PROMPT_ID_PATTERN = /^[a-z0-9-]+$/;
+var LEGACY_PROMPT_ID_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+var VERSION_ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/i;
+var LIKE_WILDCARD_CHARACTERS = /[%_]/g;
+function escapeLikePattern(value) {
+  return value.replace(LIKE_WILDCARD_CHARACTERS, "\\$&");
+}
+function atomicWriteTextSync(filePath, content) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tempPath = path.join(
+    dir,
+    `.tmp.${process.pid}.${Date.now()}.${crypto.randomBytes(8).toString("hex")}`
+  );
+  let fd;
+  try {
+    fd = fs.openSync(tempPath, "wx");
+    fs.writeFileSync(fd, content, "utf8");
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    fd = void 0;
+    fs.renameSync(tempPath, filePath);
+  } catch (error) {
+    if (fd !== void 0) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      fs.unlinkSync(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+var PromptStore = class {
+  poeticDir;
+  promptsDir;
+  dbDir;
+  activeDir;
+  archivedDir;
+  templatesDir;
+  db;
+  constructor(options = {}) {
+    this.poeticDir = resolvePoeticDirFromContext(options.poeticDir);
+    this.promptsDir = path.join(this.poeticDir, "prompts");
+    this.dbDir = path.join(this.promptsDir, "db");
+    this.activeDir = path.join(this.promptsDir, "active");
+    this.archivedDir = path.join(this.promptsDir, "archived");
+    this.templatesDir = path.join(this.promptsDir, "templates");
+    this.ensureDirectories();
+    if (!sqlite_wrapper_default) {
+      throw new Error("Database constructor not available");
+    }
+    const DatabaseConstructor = sqlite_wrapper_default;
+    this.db = new DatabaseConstructor(path.join(this.dbDir, "prompts.db"));
+    if (this.db.defaultSafeIntegers) {
+      this.db.defaultSafeIntegers(false);
+    }
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("journal_mode = WAL");
+    this.initSchema();
+  }
+  /**
+   * Ensure all required directories exist
+   */
+  ensureDirectories() {
+    [this.promptsDir, this.dbDir, this.activeDir, this.archivedDir, this.templatesDir].forEach(
+      (dir) => {
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+      }
+    );
+  }
+  /**
+   * Initialize database schema
+   */
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompts (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL,
+        category TEXT NOT NULL,
+        status TEXT NOT NULL,
+        variant TEXT,
+        tags TEXT NOT NULL,
+        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_category ON prompts(category);
+      CREATE INDEX IF NOT EXISTS idx_prompts_updated ON prompts(updated_at DESC);
+    `);
+    const promptColumns = this.db.prepare("PRAGMA table_info(prompts)").all();
+    const promptColumnNames = promptColumns.map((col) => col.name);
+    if (!promptColumnNames.includes("auto_opt_in")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN auto_opt_in INTEGER DEFAULT 0");
+    }
+    if (!promptColumnNames.includes("active_version_id")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN active_version_id TEXT");
+    }
+    if (!promptColumnNames.includes("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.includes("status")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN status TEXT NOT NULL DEFAULT 'active'");
+    }
+    if (!promptColumnNames.includes("variant")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN variant TEXT");
+    }
+    if (!promptColumnNames.includes("tags")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'");
+    }
+    if (!promptColumnNames.includes("archived_at")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN archived_at TEXT");
+    }
+    if (!promptColumnNames.includes("usage_count")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN usage_count INTEGER DEFAULT 0");
+    }
+    if (!promptColumnNames.includes("last_used_at")) {
+      this.db.exec("ALTER TABLE prompts ADD COLUMN last_used_at TEXT");
+    }
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_prompts_status ON prompts(status)");
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_prompts_variant ON prompts(variant)");
+    this.db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_prompts_active_version ON prompts(active_version_id)"
+    );
+    this.db.exec(`
+      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);
+    `);
+    const versionColumns = this.db.prepare("PRAGMA table_info(prompt_versions)").all();
+    const versionColumnNames = versionColumns.map((col) => col.name);
+    if (!versionColumnNames.includes("content_hash")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN content_hash TEXT NOT NULL DEFAULT ''");
+    }
+    if (versionColumnNames.includes("content")) {
+      const legacyRows = this.db.prepare("SELECT prompt_id, id, content, content_hash FROM prompt_versions").all();
+      const invalidHash = /^(?:sha256:)?[a-f0-9]{64}$/i;
+      const updateHash = this.db.prepare(
+        "UPDATE prompt_versions SET content_hash = ? WHERE prompt_id = ? AND id = ?"
+      );
+      const applyBackfill = () => {
+        for (const row of legacyRows) {
+          if (typeof row.content !== "string" || invalidHash.test(row.content_hash.trim()))
+            continue;
+          updateHash.run(this.hashContent(row.content), row.prompt_id, row.id);
+        }
+      };
+      if (this.db.transaction) {
+        this.db.transaction(applyBackfill)();
+      } else {
+        applyBackfill();
+      }
+    }
+    if (!versionColumnNames.includes("changelog")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN changelog TEXT");
+    }
+    if (!versionColumnNames.includes("author")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN author TEXT");
+    }
+    if (!versionColumnNames.includes("is_generated")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN is_generated INTEGER DEFAULT 0");
+    }
+    if (!versionColumnNames.includes("generation_model")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN generation_model TEXT");
+    }
+    if (!versionColumnNames.includes("generation_prompt")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN generation_prompt TEXT");
+    }
+    if (!versionColumnNames.includes("activated_at")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN activated_at TEXT");
+    }
+    if (!versionColumnNames.includes("deactivated_at")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN deactivated_at TEXT");
+    }
+    if (!versionColumnNames.includes("parent_version_id")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN parent_version_id TEXT");
+    }
+    if (!versionColumnNames.includes("mutation_type")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN mutation_type TEXT");
+    }
+    if (!versionColumnNames.includes("optimization_metadata")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN optimization_metadata TEXT");
+    }
+    if (!versionColumnNames.includes("generated_by")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN generated_by TEXT");
+    }
+    if (!versionColumnNames.includes("activated_by")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN activated_by TEXT");
+    }
+    if (!versionColumnNames.includes("performance_score")) {
+      this.db.exec("ALTER TABLE prompt_versions ADD COLUMN performance_score REAL");
+    }
+    this.db.exec("CREATE INDEX IF NOT EXISTS idx_versions_hash ON prompt_versions(content_hash)");
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_versions_parent ON prompt_versions(parent_version_id);
+      CREATE INDEX IF NOT EXISTS idx_versions_lineage ON prompt_versions(prompt_id, parent_version_id);
+      CREATE INDEX IF NOT EXISTS idx_versions_mutation_type ON prompt_versions(mutation_type);
+      CREATE INDEX IF NOT EXISTS idx_versions_performance ON prompt_versions(performance_score DESC);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_performance (
+        prompt_id TEXT NOT NULL,
+        version_id TEXT NOT NULL,
+        variant TEXT,
+        total_executions INTEGER DEFAULT 0,
+        successful_executions INTEGER DEFAULT 0,
+        failed_executions INTEGER DEFAULT 0,
+        success_rate REAL DEFAULT 0,
+        avg_completeness REAL DEFAULT 0,
+        avg_code_delivery_rate REAL DEFAULT 0,
+        avg_duration REAL DEFAULT 0,
+        min_completeness REAL DEFAULT 0,
+        max_completeness REAL DEFAULT 0,
+        std_dev_completeness REAL DEFAULT 0,
+        sample_size INTEGER DEFAULT 0,
+        first_execution_at TEXT,
+        last_execution_at TEXT,
+        calculated_at TEXT NOT NULL,
+        PRIMARY KEY (prompt_id, version_id, variant),
+        FOREIGN KEY (prompt_id, version_id) REFERENCES prompt_versions(prompt_id, id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_performance_version ON prompt_performance(version_id);
+      CREATE INDEX IF NOT EXISTS idx_performance_variant ON prompt_performance(variant);
+      CREATE INDEX IF NOT EXISTS idx_performance_success_rate ON prompt_performance(success_rate DESC);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS prompt_variants (
+        id TEXT PRIMARY KEY,
+        prompt_id TEXT NOT NULL,
+        base_version_id TEXT NOT NULL,
+        mutation_strategies TEXT NOT NULL,
+        success_rate REAL,
+        completeness REAL,
+        duration_ms INTEGER,
+        confidence REAL,
+        expected_improvement REAL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (prompt_id) REFERENCES prompts(id) ON DELETE CASCADE,
+        FOREIGN KEY (prompt_id, base_version_id) REFERENCES prompt_versions(prompt_id, id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_variants_prompt ON prompt_variants(prompt_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_variants_base_version ON prompt_variants(base_version_id);
+      CREATE INDEX IF NOT EXISTS idx_variants_performance ON prompt_variants(success_rate DESC, completeness DESC);
+      CREATE INDEX IF NOT EXISTS idx_variants_strategies ON prompt_variants(mutation_strategies);
+      CREATE INDEX IF NOT EXISTS idx_variants_confidence ON prompt_variants(confidence DESC);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS activation_history (
+        id TEXT PRIMARY KEY,
+        prompt_id TEXT NOT NULL,
+        version_id TEXT NOT NULL,
+        activated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        activated_by TEXT,
+        reason TEXT,
+        FOREIGN KEY (prompt_id) REFERENCES prompts(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_activation_prompt_timeline ON activation_history(prompt_id, activated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_activation_version ON activation_history(version_id, activated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_activation_by ON activation_history(activated_by, activated_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_activation_recent ON activation_history(activated_at DESC);
+    `);
+  }
+  promptVersionsHasColumn(columnName) {
+    const columns = this.db.prepare("PRAGMA table_info(prompt_versions)").all();
+    return columns.some((column) => column.name === columnName);
+  }
+  nextLegacyVersionNumber(promptId) {
+    const row = this.db.prepare("SELECT MAX(version_number) as maxVersion FROM prompt_versions WHERE prompt_id = ?").get(promptId);
+    return (row?.maxVersion ?? 0) + 1;
+  }
+  createPrompt(inputOrId, name, description, category, variant, tags = []) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const data = typeof inputOrId === "object" ? {
+      id: inputOrId.id,
+      name: inputOrId.name,
+      description: inputOrId.description,
+      category: inputOrId.category,
+      status: inputOrId.status ?? "active",
+      variant: inputOrId.variant,
+      tags: inputOrId.tags ?? [],
+      currentVersion: inputOrId.currentVersion ?? "",
+      autoOptimize: inputOrId.autoOptimize ?? false
+    } : {
+      id: inputOrId,
+      name: name ?? "",
+      description: description ?? "",
+      category,
+      status: "active",
+      variant,
+      tags,
+      currentVersion: "",
+      autoOptimize: false
+    };
+    if (!data.id || !data.name || !data.description || !data.category) {
+      throw new Error("createPrompt requires id, name, description, and category");
+    }
+    if (!PROMPT_ID_PATTERN.test(data.id)) {
+      throw new Error("Prompt ID must be a valid slug (lowercase, numbers, hyphens only)");
+    }
+    const existing = this.getPrompt(data.id);
+    if (existing) {
+      throw new Error(`Prompt with ID "${data.id}" already exists`);
+    }
+    const promptDirBase = data.status === "archived" ? this.archivedDir : this.activeDir;
+    const promptDir = path.join(promptDirBase, data.id);
+    if (!fs.existsSync(promptDir)) {
+      fs.mkdirSync(promptDir, { recursive: true });
+    }
+    const stmt = this.db.prepare(`
+      INSERT INTO prompts (
+        id, name, description, category, status, variant, tags,
+        auto_opt_in, current_version, created_at, updated_at, archived_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      data.id,
+      data.name,
+      data.description,
+      data.category,
+      data.status,
+      data.variant || null,
+      JSON.stringify(data.tags),
+      data.autoOptimize ? 1 : 0,
+      data.currentVersion,
+      now,
+      now,
+      data.status === "archived" ? now : null
+    );
+    return this.getPrompt(data.id);
+  }
+  /**
+   * Get a prompt by ID
+   */
+  getPrompt(id) {
+    const stmt = this.db.prepare("SELECT * FROM prompts WHERE id = ?");
+    const row = stmt.get(id);
+    if (!row) {
+      return null;
+    }
+    return this.rowToPrompt(row);
+  }
+  /**
+   * Update a prompt
+   */
+  updatePrompt(id, updates) {
+    const existing = this.getPrompt(id);
+    if (!existing) {
+      return null;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const setClauses = [];
+    const values = [];
+    if (updates.name !== void 0) {
+      setClauses.push("name = ?");
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+      if (updates.status !== void 0 && updates.status !== "archived" && updates.status !== "active") {
+      }
+      if (updates.status === "archived" && existing.status !== "archived") {
+        setClauses.push("archived_at = ?");
+        values.push(now);
+      } else if (updates.status !== "archived" && existing.status === "archived") {
+        setClauses.push("archived_at = ?");
+        values.push(null);
+      }
+    }
+    if (updates.variant !== void 0) {
+      setClauses.push("variant = ?");
+      values.push(updates.variant || null);
+    }
+    if (updates.category !== void 0) {
+      setClauses.push("category = ?");
+      values.push(updates.category);
+    }
+    if (updates.tags !== void 0) {
+      setClauses.push("tags = ?");
+      values.push(JSON.stringify(updates.tags));
+    }
+    if (updates.autoOptimize !== void 0) {
+      setClauses.push("auto_opt_in = ?");
+      values.push(updates.autoOptimize ? 1 : 0);
+    }
+    setClauses.push("updated_at = ?");
+    values.push(now);
+    values.push(id);
+    const stmt = this.db.prepare(`
+      UPDATE prompts
+      SET ${setClauses.join(", ")}
+      WHERE id = ?
+    `);
+    stmt.run(...values);
+    if (updates.status !== void 0) {
+      try {
+        if (updates.status === "archived" && existing.status !== "archived") {
+          this.movePromptFiles(id, "active", "archived");
+        } else if (updates.status !== "archived" && existing.status === "archived") {
+          this.movePromptFiles(id, "archived", "active");
+        }
+      } catch (moveErr) {
+        try {
+          const revertStmt = this.db.prepare(
+            "UPDATE prompts SET status = ?, archived_at = ?, updated_at = ? WHERE id = ?"
+          );
+          revertStmt.run(
+            existing.status,
+            existing.status === "archived" ? existing.archivedAt ?? now : null,
+            now,
+            id
+          );
+        } catch {
+        }
+        throw moveErr;
+      }
+    }
+    return this.getPrompt(id);
+  }
+  /**
+   * Delete a prompt and all its versions
+   */
+  deletePrompt(id) {
+    const prompt = this.getPrompt(id);
+    if (!prompt) {
+      return false;
+    }
+    try {
+      const versions = this.listVersions(id);
+      const stmt = this.db.prepare("DELETE FROM prompts WHERE id = ?");
+      const result = stmt.run(id);
+      for (const version of versions) {
+        const contentPath = this.getVersionContentPath(id, version.id, prompt.status);
+        if (fs.existsSync(contentPath)) {
+          fs.unlinkSync(contentPath);
+        }
+      }
+      return result.changes > 0;
+    } catch (error) {
+      console.error(`Error deleting prompt ${id}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Archive a prompt
+   */
+  archivePrompt(id) {
+    return this.updatePrompt(id, { status: "archived" });
+  }
+  /**
+   * Restore an archived prompt
+   */
+  restorePrompt(id) {
+    return this.updatePrompt(id, { status: "active" });
+  }
+  /**
+   * List prompts with optional filtering and pagination
+   */
+  listPrompts(criteria = {}) {
+    let query = "SELECT * FROM prompts WHERE 1=1";
+    const params = [];
+    if (criteria.category) {
+      query += " AND category = ?";
+      params.push(criteria.category);
+    }
+    if (criteria.status) {
+      query += " AND status = ?";
+      params.push(criteria.status);
+    }
+    if (criteria.variant) {
+      query += " AND variant = ?";
+      params.push(criteria.variant);
+    }
+    if (criteria.minUsageCount !== void 0) {
+      query += " AND usage_count >= ?";
+      params.push(criteria.minUsageCount);
+    }
+    if (criteria.tags && criteria.tags.length > 0) {
+      const normalizedTags = criteria.tags.map((tag) => typeof tag === "string" ? tag.trim() : "").filter((tag) => tag.length > 0);
+      normalizedTags.forEach((tag) => {
+        query += " AND tags LIKE ? ESCAPE '\\'";
+        params.push(`%"${escapeLikePattern(tag)}"%`);
+      });
+    }
+    if (criteria.autoOptimize !== void 0) {
+      query += " AND auto_opt_in = ?";
+      params.push(criteria.autoOptimize ? 1 : 0);
+    }
+    if (criteria.query) {
+      query += " AND (name LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\')";
+      const searchPattern = `%${escapeLikePattern(criteria.query)}%`;
+      params.push(searchPattern, searchPattern);
+    }
+    const sortBy = criteria.sortBy || "updatedAt";
+    const sortOrder = (criteria.sortOrder || "desc").toLowerCase();
+    const sortColumn = {
+      name: "name",
+      createdAt: "created_at",
+      updatedAt: "updated_at",
+      usageCount: "usage_count",
+      successRate: "usage_count",
+      avgCompleteness: "usage_count"
+    }[sortBy] || "updated_at";
+    const sortDirection = sortOrder === "asc" ? "ASC" : "DESC";
+    query += ` ORDER BY ${sortColumn} ${sortDirection}`;
+    if (sortColumn !== "updated_at") {
+      query += ", updated_at DESC";
+    }
+    query += `, id ${sortDirection}`;
+    const hasLimit = typeof criteria.limit === "number";
+    const hasOffset = typeof criteria.offset === "number";
+    if (hasLimit) {
+      query += " LIMIT ?";
+      params.push(criteria.limit);
+    }
+    if (!hasLimit && hasOffset) {
+      query += " LIMIT -1";
+    }
+    if (hasOffset) {
+      query += " OFFSET ?";
+      params.push(criteria.offset);
+    }
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => this.rowToPrompt(row));
+  }
+  createVersion(inputOrPromptId, versionId, content, options = {}) {
+    const data = typeof inputOrPromptId === "object" ? {
+      promptId: inputOrPromptId.promptId,
+      versionId: inputOrPromptId.id,
+      content: inputOrPromptId.content,
+      changelog: inputOrPromptId.changelog,
+      author: inputOrPromptId.author,
+      isGenerated: inputOrPromptId.isGenerated,
+      generationModel: inputOrPromptId.generationModel,
+      generationPrompt: inputOrPromptId.generationPrompt,
+      activate: inputOrPromptId.activate ?? inputOrPromptId.isActive ?? false
+    } : {
+      promptId: inputOrPromptId,
+      versionId: versionId ?? "",
+      content: content ?? "",
+      changelog: options.changelog,
+      author: options.author,
+      isGenerated: options.isGenerated,
+      generationModel: options.generationModel,
+      generationPrompt: options.generationPrompt,
+      activate: options.activate ?? false
+    };
+    if (!data.promptId || !data.versionId || data.content === void 0) {
+      throw new Error("createVersion requires promptId, versionId, and content");
+    }
+    const prompt = this.getPrompt(data.promptId);
+    if (!prompt) {
+      throw new Error(`Prompt with ID "${data.promptId}" not found`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const contentHash = this.hashContent(data.content);
+    const duplicateStmt = this.db.prepare(
+      "SELECT id FROM prompt_versions WHERE prompt_id = ? AND content_hash = ?"
+    );
+    const duplicate = duplicateStmt.get(data.promptId, contentHash);
+    if (duplicate) {
+      throw new Error("A version with identical content already exists");
+    }
+    this.saveVersionContent(data.promptId, data.versionId, data.content, prompt.status);
+    if (!this.db.transaction) {
+      try {
+        this.deleteVersionContent(data.promptId, data.versionId, prompt.status);
+      } catch {
+      }
+      throw new Error("Database transaction not available");
+    }
+    const transaction = this.db.transaction(() => {
+      const versionColumns = [
+        "id",
+        "prompt_id",
+        "content_hash",
+        "changelog",
+        "author",
+        "is_active",
+        "is_generated",
+        "generation_model",
+        "generation_prompt",
+        "created_at",
+        "activated_at"
+      ];
+      const versionValues = [
+        data.versionId,
+        data.promptId,
+        contentHash,
+        data.changelog || null,
+        data.author || null,
+        0,
+        data.isGenerated ? 1 : 0,
+        data.generationModel || null,
+        data.generationPrompt || null,
+        now,
+        null
+      ];
+      if (this.promptVersionsHasColumn("version_number")) {
+        versionColumns.splice(2, 0, "version_number");
+        versionValues.splice(2, 0, this.nextLegacyVersionNumber(data.promptId));
+      }
+      if (this.promptVersionsHasColumn("content")) {
+        versionColumns.push("content");
+        versionValues.push(data.content);
+      }
+      if (this.promptVersionsHasColumn("created_by")) {
+        versionColumns.push("created_by");
+        versionValues.push(data.author || "unknown");
+      }
+      const placeholders = versionColumns.map(() => "?").join(", ");
+      const stmt = this.db.prepare(`
+        INSERT INTO prompt_versions (${versionColumns.join(", ")})
+        VALUES (${placeholders})
+      `);
+      stmt.run(...versionValues);
+      if (data.activate) {
+        performActivation(this.db, {
+          promptId: data.promptId,
+          versionId: data.versionId,
+          now
+        });
+      }
+    });
+    try {
+      transaction();
+    } catch (txErr) {
+      try {
+        this.deleteVersionContent(data.promptId, data.versionId, prompt.status);
+      } catch {
+      }
+      throw txErr;
+    }
+    return this.getVersion(data.promptId, data.versionId);
+  }
+  getVersion(idOrPromptId, versionId) {
+    if (typeof versionId === "string") {
+      const stmt2 = this.db.prepare("SELECT * FROM prompt_versions WHERE prompt_id = ? AND id = ?");
+      const row = stmt2.get(idOrPromptId, versionId);
+      if (!row) return null;
+      return this.rowToVersion(row);
+    }
+    const stmt = this.db.prepare("SELECT * FROM prompt_versions WHERE id = ?");
+    const rows = stmt.all(idOrPromptId);
+    if (rows.length === 0) return null;
+    if (rows.length > 1) {
+      throw new Error(
+        `Version ID "${idOrPromptId}" is ambiguous (matches ${rows.length} prompts); pass promptId explicitly`
+      );
+    }
+    return this.rowToVersion(rows[0]);
+  }
+  /**
+   * Get active version for a prompt
+   */
+  getActiveVersion(promptId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM prompt_versions WHERE prompt_id = ? AND is_active = 1"
+    );
+    const row = stmt.get(promptId);
+    if (!row) {
+      return null;
+    }
+    return this.rowToVersion(row);
+  }
+  /**
+   * List all versions for a prompt
+   */
+  listVersions(promptId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM prompt_versions WHERE prompt_id = ? ORDER BY created_at DESC"
+    );
+    const rows = stmt.all(promptId);
+    return rows.map((row) => this.rowToVersion(row));
+  }
+  /** List version metadata without hydrating prompt content side-files. */
+  listVersionMetadata(promptId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM prompt_versions WHERE prompt_id = ? ORDER BY created_at DESC"
+    );
+    const rows = stmt.all(promptId);
+    return rows.map((row) => ({
+      id: row.id,
+      promptId: row.prompt_id,
+      contentHash: row.content_hash,
+      isActive: row.is_active === 1,
+      isGenerated: row.is_generated === 1,
+      createdAt: row.created_at
+    }));
+  }
+  /**
+   * Alias for listVersions to maintain backward compatibility
+   */
+  getVersions(promptId) {
+    return this.listVersions(promptId);
+  }
+  /**
+   * Activate a version
+   */
+  activateVersion(promptId, versionId, reason) {
+    const version = this.getVersion(promptId, versionId);
+    if (!version) {
+      throw new Error(`Version "${versionId}" not found for prompt "${promptId}"`);
+    }
+    if (!this.db.transaction) {
+      throw new Error("Database transaction not available");
+    }
+    performActivation(this.db, { promptId, versionId });
+    this.recordActivationHistory(promptId, versionId, reason || "manual:activate");
+  }
+  /**
+   * Sync helper that writes one row into activation_history. Best-effort:
+   * the primary activation has already been performed by the caller, so a
+   * history-write failure must not abort it. Failures are surfaced via a
+   * console warning so test runs and ops surfaces still see them.
+   */
+  recordActivationHistory(promptId, versionId, reason) {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const recordId = `activation-${promptId}-${versionId}-${Date.now()}`;
+      const stmt = this.db.prepare(`
+        INSERT INTO activation_history (
+          id, prompt_id, version_id, activated_at, activated_by, reason
+        )
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(recordId, promptId, versionId, now, "system:version-activation", reason);
+    } catch (error) {
+      console.warn(
+        `[prompts] activation_history insert failed for ${promptId}/${versionId}: ${error.message}`
+      );
+    }
+  }
+  deactivateVersion(idOrPromptId, versionId) {
+    let resolvedPromptId;
+    let resolvedVersionId;
+    if (typeof versionId === "string") {
+      resolvedPromptId = idOrPromptId;
+      resolvedVersionId = versionId;
+      const version = this.getVersion(resolvedPromptId, resolvedVersionId);
+      if (!version) {
+        throw new Error(
+          `Version "${resolvedVersionId}" not found for prompt "${resolvedPromptId}"`
+        );
+      }
+    } else {
+      resolvedVersionId = idOrPromptId;
+      const lookupStmt = this.db.prepare("SELECT prompt_id FROM prompt_versions WHERE id = ?");
+      const rows = lookupStmt.all(resolvedVersionId);
+      if (rows.length === 0) {
+        throw new Error(`Version with ID "${resolvedVersionId}" not found`);
+      }
+      if (rows.length > 1) {
+        throw new Error(
+          `Version ID "${resolvedVersionId}" is ambiguous (matches ${rows.length} prompts); pass promptId explicitly`
+        );
+      }
+      resolvedPromptId = rows[0].prompt_id;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const stmt = this.db.prepare(`
+      UPDATE prompt_versions
+      SET is_active = 0, deactivated_at = ?
+      WHERE prompt_id = ? AND id = ?
+    `);
+    stmt.run(now, resolvedPromptId, resolvedVersionId);
+  }
+  /**
+   * Increment usage count for a prompt
+   * Uses transaction and lock to prevent race conditions
+   */
+  incrementUsage(promptId) {
+    if (!this.db.transaction) {
+      throw new Error("Database transaction not available");
+    }
+    const transaction = this.db.transaction(() => {
+      const checkStmt = this.db.prepare("SELECT last_used_at FROM prompts WHERE id = ?");
+      const row = checkStmt.get(promptId);
+      if (!row) {
+        return;
+      }
+      let nowDate = /* @__PURE__ */ new Date();
+      if (row.last_used_at) {
+        const previous = new Date(row.last_used_at);
+        if (!Number.isNaN(previous.getTime()) && nowDate <= previous) {
+          nowDate = new Date(previous.getTime() + 1);
+        }
+      }
+      const now = nowDate.toISOString();
+      const updateStmt = this.db.prepare(`
+        UPDATE prompts
+        SET usage_count = usage_count + 1, last_used_at = ?, updated_at = ?
+        WHERE id = ?
+      `);
+      updateStmt.run(now, now, promptId);
+    });
+    transaction();
+  }
+  /**
+   * Batch increment usage counts for multiple prompts
+   * More efficient than calling incrementUsage multiple times (prevents N+1 queries)
+   */
+  incrementUsageBatch(promptIds) {
+    if (promptIds.length === 0) {
+      return;
+    }
+    if (!this.db.transaction) {
+      throw new Error("Database transaction not available");
+    }
+    const transaction = this.db.transaction(() => {
+      const placeholders = promptIds.map(() => "?").join(",");
+      const batchLoadStmt = this.db.prepare(`
+        SELECT id, last_used_at FROM prompts WHERE id IN (${placeholders})
+      `);
+      const rows = batchLoadStmt.all(...promptIds);
+      const promptMap = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        promptMap.set(row.id, row.last_used_at);
+      }
+      const updateStmt = this.db.prepare(`
+        UPDATE prompts
+        SET usage_count = usage_count + 1, last_used_at = ?, updated_at = ?
+        WHERE id = ?
+      `);
+      const now = Date.now();
+      for (const promptId of promptIds) {
+        const lastUsedAt = promptMap.get(promptId);
+        if (lastUsedAt === void 0) {
+          continue;
+        }
+        let nowDate = new Date(now);
+        if (lastUsedAt !== null) {
+          const previous = new Date(lastUsedAt);
+          if (!Number.isNaN(previous.getTime()) && nowDate <= previous) {
+            nowDate = new Date(previous.getTime() + 1);
+          }
+        }
+        const nowIso = nowDate.toISOString();
+        updateStmt.run(nowIso, nowIso, promptId);
+      }
+    });
+    transaction();
+  }
+  /**
+   * Get performance metrics for a version
+   */
+  getPerformanceMetrics(versionId, variant) {
+    let query = "SELECT * FROM prompt_performance WHERE version_id = ?";
+    const params = [versionId];
+    if (variant) {
+      query += " AND variant = ?";
+      params.push(variant);
+    }
+    const stmt = this.db.prepare(query);
+    const row = stmt.get(...params);
+    if (!row) {
+      return null;
+    }
+    return this.rowToPerformance(row);
+  }
+  /**
+   * Update performance metrics for a version
+   */
+  updatePerformanceMetrics(metrics) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO prompt_performance (
+        prompt_id, version_id, variant,
+        total_executions, successful_executions, failed_executions,
+        success_rate, avg_completeness, avg_code_delivery_rate, avg_duration,
+        min_completeness, max_completeness, std_dev_completeness,
+        sample_size, first_execution_at, last_execution_at, calculated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      metrics.promptId,
+      metrics.versionId,
+      metrics.variant || null,
+      metrics.totalExecutions,
+      metrics.successfulExecutions,
+      metrics.failedExecutions,
+      metrics.successRate,
+      metrics.avgCompleteness,
+      metrics.avgCodeDeliveryRate,
+      metrics.avgDuration,
+      metrics.minCompleteness,
+      metrics.maxCompleteness,
+      metrics.stdDevCompleteness,
+      metrics.sampleSize,
+      metrics.firstExecutionAt,
+      metrics.lastExecutionAt,
+      metrics.calculatedAt
+    );
+  }
+  /**
+   * Store performance metrics for a version (alias for updatePerformanceMetrics)
+   */
+  storeMetrics(metrics) {
+    this.updatePerformanceMetrics(metrics);
+  }
+  /**
+   * Get metrics for a prompt and version (alias for getPerformanceMetrics)
+   */
+  getMetrics(promptId, versionId, variant) {
+    let query = "SELECT * FROM prompt_performance WHERE prompt_id = ? AND version_id = ?";
+    const params = [promptId, versionId];
+    if (variant) {
+      query += " AND variant = ?";
+      params.push(variant);
+    }
+    const stmt = this.db.prepare(query);
+    const row = stmt.get(...params);
+    if (!row) {
+      return null;
+    }
+    return this.rowToPerformance(row);
+  }
+  /**
+   * Get version content from file
+   */
+  getVersionContent(promptId, versionId, status = "active") {
+    const contentPath = this.getVersionContentPath(promptId, versionId, status);
+    if (!fs.existsSync(contentPath)) {
+      throw new Error(`Content file not found for version ${versionId}`);
+    }
+    return fs.readFileSync(contentPath, "utf8");
+  }
+  /**
+   * Creates a new version of an existing prompt with content
+   *
+   * Tracks parent version for lineage and validates prompt exists.
+   *
+   * @param promptId - ID of the prompt to version
+   * @param content - New version content
+   * @param options - Optional metadata (changelog, author, activation reason)
+   * @returns New version ID
+   * @throws Error if prompt not found
+   *
+   * @example
+   * const versionId = await store.createVersionAsync('user-auth', 'New prompt text', {
+   *   changelog: 'Improved clarity',
+   *   author: 'user:alice',
+   *   reason: 'Manual refinement'
+   * });
+   */
+  createVersionAsync(promptId, content, options) {
+    return new Promise((resolve, reject) => {
+      try {
+        const prompt = this.getPrompt(promptId);
+        if (!prompt) {
+          reject(new Error(`Prompt with ID "${promptId}" not found`));
+          return;
+        }
+        const versionId = crypto.randomBytes(8).toString("hex");
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const contentHash = this.hashContent(content);
+        const duplicateStmt = this.db.prepare(
+          "SELECT id FROM prompt_versions WHERE prompt_id = ? AND content_hash = ?"
+        );
+        const duplicate = duplicateStmt.get(promptId, contentHash);
+        if (duplicate) {
+          reject(new Error("A version with identical content already exists"));
+          return;
+        }
+        const currentActiveStmt = this.db.prepare(
+          "SELECT id FROM prompt_versions WHERE prompt_id = ? AND is_active = 1"
+        );
+        const currentActive = currentActiveStmt.get(promptId);
+        const parentVersionId = currentActive?.id || null;
+        this.saveVersionContent(promptId, versionId, content, prompt.status);
+        const versionColumns = [
+          "id",
+          "prompt_id",
+          "content_hash",
+          "changelog",
+          "author",
+          "is_active",
+          "is_generated",
+          "generation_model",
+          "generation_prompt",
+          "created_at",
+          "parent_version_id"
+        ];
+        const versionValues = [
+          versionId,
+          promptId,
+          contentHash,
+          options?.changelog || null,
+          options?.author || null,
+          0,
+          // not active by default
+          options?.isGenerated ? 1 : 0,
+          options?.generationModel || null,
+          options?.generationPrompt || null,
+          now,
+          parentVersionId
+        ];
+        if (this.promptVersionsHasColumn("version_number")) {
+          versionColumns.splice(2, 0, "version_number");
+          versionValues.splice(2, 0, this.nextLegacyVersionNumber(promptId));
+        }
+        if (this.promptVersionsHasColumn("content")) {
+          versionColumns.push("content");
+          versionValues.push(content);
+        }
+        if (this.promptVersionsHasColumn("created_by")) {
+          versionColumns.push("created_by");
+          versionValues.push(options?.author || "unknown");
+        }
+        const placeholders = versionColumns.map(() => "?").join(", ");
+        const stmt = this.db.prepare(`
+          INSERT INTO prompt_versions (${versionColumns.join(", ")})
+          VALUES (${placeholders})
+        `);
+        stmt.run(...versionValues);
+        resolve(versionId);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Returns all versions of a prompt in chronological order with lineage
+   *
+   * Includes parent-child relationships for lineage visualization.
+   *
+   * @param promptId - ID of the prompt
+   * @returns Array of versions sorted by creation date (oldest first)
+   * @throws Error if prompt not found
+   *
+   * @example
+   * const history = await store.getVersionHistory('user-auth');
+   * history.forEach(v => console.log(`${v.id}: ${v.changelog}`));
+   */
+  getVersionHistory(promptId) {
+    return new Promise((resolve, reject) => {
+      try {
+        const prompt = this.getPrompt(promptId);
+        if (!prompt) {
+          reject(new Error(`Prompt with ID "${promptId}" not found`));
+          return;
+        }
+        const stmt = this.db.prepare(`
+          SELECT * FROM prompt_versions
+          WHERE prompt_id = ?
+          ORDER BY created_at ASC
+        `);
+        const rows = stmt.all(promptId);
+        const versions = rows.map((row) => this.rowToVersion(row));
+        resolve(versions);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Activates a specific version of a prompt
+   *
+   * Updates the active version and records activation history. Validates
+   * version exists for the prompt before activation.
+   *
+   * @param promptId - ID of the prompt
+   * @param versionId - ID of the version to activate
+   * @param reason - Optional activation reason (logged to history)
+   * @throws Error if version not found for prompt
+   *
+   * @example
+   * await store.setActiveVersion('user-auth', 'v3',
+   *   'AutoTuner: +12% success rate');
+   */
+  setActiveVersion(promptId, versionId, reason) {
+    return new Promise((resolve, reject) => {
+      try {
+        const version = this.getVersion(promptId, versionId);
+        if (!version) {
+          reject(new Error(`Version "${versionId}" not found for prompt "${promptId}"`));
+          return;
+        }
+        performActivation(this.db, { promptId, versionId });
+        this.recordActivationHistory(promptId, versionId, reason || "system:set-active");
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Records version activation in the audit trail
+   *
+   * Creates an immutable record of who activated what version and why.
+   * Uses activation_history table for audit compliance.
+   *
+   * @param promptId - ID of the prompt
+   * @param versionId - ID of the activated version
+   * @param reason - Activation reason (required for audit trail)
+   * @throws Error if version not found or database error
+   *
+   * @example
+   * await store.trackActivation('user-auth', 'v3',
+   *   'system:auto-tuner - Improved success rate by 8%');
+   */
+  /**
+   * List activation history rows for a prompt (newest first).
+   */
+  listActivationHistory(promptId) {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT id, prompt_id, version_id, activated_at, activated_by, reason
+        FROM activation_history
+        WHERE prompt_id = ?
+        ORDER BY activated_at DESC, id DESC
+      `);
+      const rows = stmt.all(promptId);
+      return rows.map((row) => ({
+        id: row.id,
+        promptId: row.prompt_id,
+        versionId: row.version_id,
+        activatedAt: row.activated_at,
+        activatedBy: row.activated_by,
+        reason: row.reason
+      }));
+    } catch {
+      return [];
+    }
+  }
+  trackActivation(promptId, versionId, reason) {
+    return new Promise((resolve, reject) => {
+      try {
+        const version = this.getVersion(promptId, versionId);
+        if (!version) {
+          reject(new Error(`Version "${versionId}" not found for prompt "${promptId}"`));
+          return;
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const recordId = `activation-${promptId}-${versionId}-${Date.now()}`;
+        const stmt = this.db.prepare(`
+          INSERT INTO activation_history (
+            id, prompt_id, version_id, activated_at, activated_by, reason
+          )
+          VALUES (?, ?, ?, ?, ?, ?)
+        `);
+        stmt.run(
+          recordId,
+          promptId,
+          versionId,
+          now,
+          "system:version-activation",
+          // Mark as system-initiated
+          reason
+        );
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Returns all variants generated from a version
+   *
+   * Includes mutation strategies applied and measured performance data.
+   * Sorted by performance score descending.
+   *
+   * @param versionId - ID of the base version
+   * @returns Array of variants sorted by performance (best first)
+   *
+   * @example
+   * const variants = await store.getVariants('v1.0');
+   * variants.forEach(v => {
+   *   console.log(`${v.id}: strategies=${v.mutationStrategies}, score=${v.successRate}`);
+   * });
+   */
+  getVariants(versionId) {
+    return new Promise((resolve, reject) => {
+      try {
+        const stmt = this.db.prepare(`
+          SELECT * FROM prompt_variants
+          WHERE base_version_id = ?
+          ORDER BY success_rate DESC, confidence DESC
+        `);
+        const rows = stmt.all(versionId);
+        const variants = rows.map((row) => ({
+          id: row.id,
+          promptId: row.prompt_id,
+          baseVersionId: row.base_version_id,
+          mutationStrategies: parseJsonWithContext(
+            row.mutation_strategies,
+            "PromptStore.mutationStrategies"
+          ) ?? [],
+          successRate: row.success_rate ?? void 0,
+          completeness: row.completeness ?? void 0,
+          durationMs: row.duration_ms ?? void 0,
+          confidence: row.confidence ?? void 0,
+          expectedImprovement: row.expected_improvement ?? void 0,
+          createdAt: row.created_at
+        }));
+        resolve(variants);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Returns version tree showing parent-child relationships
+   *
+   * Builds hierarchical tree structure showing how versions evolved.
+   * Includes lineage information, performance scores, and mutation types.
+   * Useful for visualization and understanding version evolution.
+   *
+   * @param promptId - ID of the prompt
+   * @returns Version tree with root at the original version
+   * @throws Error if prompt not found
+   *
+   * @example
+   * const tree = await store.getVersionLineage('user-auth');
+   * console.log(`Root: ${tree.rootVersion.id}`);
+   * console.log(`Total versions: ${tree.totalVersions}`);
+   * console.log(`Max depth: ${tree.depth}`);
+   */
+  getVersionLineage(promptId) {
+    return new Promise((resolve, reject) => {
+      try {
+        const prompt = this.getPrompt(promptId);
+        if (!prompt) {
+          reject(new Error(`Prompt with ID "${promptId}" not found`));
+          return;
+        }
+        const versionStmt = this.db.prepare(`
+          SELECT * FROM prompt_versions
+          WHERE prompt_id = ?
+          ORDER BY created_at ASC
+        `);
+        const versionRows = versionStmt.all(promptId);
+        if (versionRows.length === 0) {
+          resolve({
+            promptId,
+            rootVersion: {
+              id: "root",
+              contentHash: "",
+              isActive: false,
+              isGenerated: false,
+              children: [],
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            totalVersions: 0,
+            activeVersionId: prompt.currentVersion,
+            depth: 0
+          });
+          return;
+        }
+        const versionMap = /* @__PURE__ */ new Map();
+        for (const row of versionRows) {
+          versionMap.set(row.id, {
+            id: row.id,
+            contentHash: row.content_hash,
+            changelog: row.changelog || void 0,
+            author: row.author || void 0,
+            isActive: row.is_active === 1,
+            isGenerated: row.is_generated === 1,
+            generationModel: row.generation_model || void 0,
+            parentVersionId: row.parent_version_id || void 0,
+            children: [],
+            createdAt: row.created_at,
+            activatedAt: row.activated_at || void 0,
+            performanceScore: void 0
+            // Populated from performance table elsewhere
+          });
+        }
+        const rootNodes = [];
+        for (const row of versionRows) {
+          const node = versionMap.get(row.id);
+          const parentId = row.parent_version_id;
+          const parent = parentId ? versionMap.get(parentId) : void 0;
+          if (parent) {
+            parent.children.push(node);
+          } else {
+            rootNodes.push(node);
+          }
+        }
+        const calculateDepth = (node) => {
+          if (node.children.length === 0) {
+            return 1;
+          }
+          return 1 + Math.max(...node.children.map(calculateDepth));
+        };
+        const primaryRoot = rootNodes[0];
+        if (!primaryRoot) {
+          reject(new Error("Unable to determine root version"));
+          return;
+        }
+        for (let i = 1; i < rootNodes.length; i++) {
+          primaryRoot.children.push(rootNodes[i]);
+        }
+        const depth = calculateDepth(primaryRoot);
+        const tree = {
+          promptId,
+          rootVersion: primaryRoot,
+          totalVersions: versionRows.length,
+          activeVersionId: prompt.currentVersion,
+          depth
+        };
+        resolve(tree);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Returns aggregated performance statistics across all versions
+   *
+   * Compares versions, identifies best/worst performers, analyzes trends,
+   * and provides recommendations for optimization or rollback.
+   *
+   * @param promptId - ID of the prompt
+   * @returns Performance statistics with recommendations
+   * @throws Error if prompt not found
+   *
+   * @example
+   * const stats = await store.getPerformanceStats('user-auth');
+   * console.log(`Best version: ${stats.bestPerformingVersionId}`);
+   * console.log(`Trend: ${stats.performanceTrend}`);
+   * stats.recommendations.forEach(r => console.log(`${r.type}: ${r.reason}`));
+   */
+  getPerformanceStats(promptId) {
+    return new Promise((resolve, reject) => {
+      try {
+        const prompt = this.getPrompt(promptId);
+        if (!prompt) {
+          reject(new Error(`Prompt with ID "${promptId}" not found`));
+          return;
+        }
+        const metricsStmt = this.db.prepare(`
+          SELECT * FROM prompt_performance
+          WHERE prompt_id = ?
+          ORDER BY calculated_at DESC
+        `);
+        const metricsRows = metricsStmt.all(promptId);
+        if (metricsRows.length === 0) {
+          const emptyStats = {
+            promptId,
+            totalVersions: 0,
+            activeVersionId: prompt.currentVersion,
+            overallSuccessRate: 0,
+            overallAvgCompleteness: 0,
+            overallAvgDuration: 0,
+            bestPerformingVersionId: "",
+            bestSuccessRate: 0,
+            lowestPerformingVersionId: "",
+            lowestSuccessRate: 0,
+            performanceTrend: "stable",
+            trendDetails: [],
+            recommendations: [],
+            calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          resolve(emptyStats);
+          return;
+        }
+        const successRates = metricsRows.map((r) => r.success_rate);
+        const completeness = metricsRows.map((r) => r.avg_completeness);
+        const durations = metricsRows.map((r) => r.avg_duration);
+        const overallSuccessRate = successRates.length > 0 ? successRates.reduce((a, b) => a + b, 0) / successRates.length : 0;
+        const overallAvgCompleteness = completeness.length > 0 ? completeness.reduce((a, b) => a + b, 0) / completeness.length : 0;
+        const overallAvgDuration = durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0;
+        const sortedBySuccess = [...metricsRows].sort((a, b) => b.success_rate - a.success_rate);
+        const bestPerforming = sortedBySuccess[0];
+        const lowestPerforming = sortedBySuccess[sortedBySuccess.length - 1];
+        if (!bestPerforming || !lowestPerforming) {
+          reject(new Error("Unable to determine best/lowest performing versions"));
+          return;
+        }
+        const trendDetails = metricsRows.slice(0, 5).reverse().map((row) => ({
+          versionId: row.version_id,
+          successRate: row.success_rate,
+          timestamp: row.calculated_at
+        }));
+        let performanceTrend = "stable";
+        if (trendDetails.length >= 2) {
+          const oldTrend = trendDetails[0];
+          const newTrend = trendDetails[trendDetails.length - 1];
+          if (oldTrend && newTrend) {
+            const oldSuccess = oldTrend.successRate;
+            const newSuccess = newTrend.successRate;
+            const delta = newSuccess - oldSuccess;
+            const threshold = 0.05;
+            if (delta > threshold) {
+              performanceTrend = "improving";
+            } else if (delta < -threshold) {
+              performanceTrend = "declining";
+            }
+          }
+        }
+        const recommendations = [];
+        if (bestPerforming.version_id !== prompt.currentVersion) {
+          recommendations.push({
+            type: "promote",
+            targetVersionId: bestPerforming.version_id,
+            reason: `Version ${bestPerforming.version_id} has highest success rate (${(bestPerforming.success_rate * 100).toFixed(1)}%)`,
+            expectedImprovement: bestPerforming.success_rate - overallSuccessRate
+          });
+        }
+        if (performanceTrend === "declining") {
+          recommendations.push({
+            type: "rollback",
+            targetVersionId: bestPerforming.version_id,
+            reason: "Performance is declining over recent versions",
+            expectedImprovement: bestPerforming.success_rate - overallSuccessRate
+          });
+        }
+        const stats = {
+          promptId,
+          totalVersions: metricsRows.length,
+          activeVersionId: prompt.currentVersion,
+          overallSuccessRate,
+          overallAvgCompleteness,
+          overallAvgDuration,
+          bestPerformingVersionId: bestPerforming.version_id,
+          bestSuccessRate: bestPerforming.success_rate,
+          lowestPerformingVersionId: lowestPerforming.version_id,
+          lowestSuccessRate: lowestPerforming.success_rate,
+          performanceTrend,
+          trendDetails,
+          recommendations,
+          calculatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        resolve(stats);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    this.db.close();
+  }
+  // Private helper methods
+  rowToPrompt(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      category: row.category,
+      status: row.status,
+      variant: row.variant ? row.variant : void 0,
+      tags: parseJsonWithContext(row.tags, "PromptStore.tags") ?? [],
+      autoOptimize: row.auto_opt_in === 1,
+      currentVersion: row.current_version,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      archivedAt: row.archived_at || void 0,
+      usageCount: row.usage_count,
+      lastUsedAt: row.last_used_at || void 0
+    };
+  }
+  rowToVersion(row) {
+    const prompt = this.getPrompt(row.prompt_id);
+    if (!prompt) {
+      throw new Error(`Prompt "${row.prompt_id}" not found while resolving version "${row.id}"`);
+    }
+    const content = this.getVersionContent(row.prompt_id, row.id, prompt.status);
+    return {
+      id: row.id,
+      promptId: row.prompt_id,
+      content,
+      contentHash: row.content_hash,
+      changelog: row.changelog || void 0,
+      author: row.author || void 0,
+      isActive: row.is_active === 1,
+      isGenerated: row.is_generated === 1,
+      generationModel: row.generation_model || void 0,
+      generationPrompt: row.generation_prompt || void 0,
+      createdAt: row.created_at,
+      activatedAt: row.activated_at || void 0,
+      deactivatedAt: row.deactivated_at || void 0
+    };
+  }
+  rowToPerformance(row) {
+    return {
+      promptId: row.prompt_id,
+      versionId: row.version_id,
+      variant: row.variant ? row.variant : null,
+      totalExecutions: row.total_executions,
+      successfulExecutions: row.successful_executions,
+      failedExecutions: row.failed_executions,
+      successRate: row.success_rate,
+      avgCompleteness: row.avg_completeness,
+      avgCodeDeliveryRate: row.avg_code_delivery_rate,
+      avgDuration: row.avg_duration,
+      minCompleteness: row.min_completeness,
+      maxCompleteness: row.max_completeness,
+      stdDevCompleteness: row.std_dev_completeness,
+      sampleSize: row.sample_size,
+      firstExecutionAt: row.first_execution_at,
+      lastExecutionAt: row.last_execution_at,
+      calculatedAt: row.calculated_at
+    };
+  }
+  hashContent(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+  saveVersionContent(promptId, versionId, content, status) {
+    const contentPath = this.getVersionContentPath(promptId, versionId, status);
+    atomicWriteTextSync(contentPath, content);
+  }
+  deleteVersionContent(promptId, versionId, status) {
+    const contentPath = this.getVersionContentPath(promptId, versionId, status);
+    try {
+      fs.unlinkSync(contentPath);
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+  movePromptFiles(id, from, to) {
+    const fromDir = from === "archived" ? this.archivedDir : this.activeDir;
+    const toDir = to === "archived" ? this.archivedDir : this.activeDir;
+    this.ensureSafePromptId(id);
+    const versionRows = this.db.prepare("SELECT id FROM prompt_versions WHERE prompt_id = ?").all(id);
+    for (const row of versionRows) {
+      this.ensureSafeVersionId(row.id);
+      const srcPath = path.join(fromDir, `${id}-${row.id}.txt`);
+      const destPath = path.join(toDir, `${id}-${row.id}.txt`);
+      if (fs.existsSync(srcPath)) {
+        fs.renameSync(srcPath, destPath);
+      }
+    }
+  }
+  /**
+   * Search prompts based on criteria
+   */
+  searchPrompts(queryOrCriteria, filterCriteria) {
+    try {
+      const criteria = typeof queryOrCriteria === "string" ? { query: queryOrCriteria, ...filterCriteria } : queryOrCriteria;
+      let query = "SELECT * FROM prompts WHERE 1=1";
+      const params = [];
+      if (criteria.query) {
+        query += " AND (name LIKE ? OR description LIKE ? OR tags LIKE ?)";
+        const searchTerm = `%${criteria.query}%`;
+        params.push(searchTerm, searchTerm, searchTerm);
+      }
+      if (criteria.category) {
+        query += " AND category = ?";
+        params.push(criteria.category);
+      }
+      if (criteria.status) {
+        query += " AND status = ?";
+        params.push(criteria.status);
+      }
+      if (criteria.tags && criteria.tags.length > 0) {
+        const normalizedTags = criteria.tags.map((tag) => typeof tag === "string" ? tag.trim() : "").filter((tag) => tag.length > 0);
+        if (normalizedTags.length > 0) {
+          query += " AND (";
+          for (const tag of normalizedTags) {
+            query += "tags LIKE ? ESCAPE '\\' OR ";
+            params.push(`%${escapeLikePattern(tag)}%`);
+          }
+          query = `${query.slice(0, -4)})`;
+        }
+      }
+      query += " ORDER BY usage_count DESC, updated_at DESC";
+      const stmt = this.db.prepare(query);
+      const rows = stmt.all(...params);
+      return rows.map((row) => this.rowToPrompt(row));
+    } catch (error) {
+      throw new Error(
+        `searchPrompts failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get all metrics for a prompt
+   */
+  getAllMetrics(promptId) {
+    try {
+      const stmt = this.db.prepare(`
+        SELECT * FROM prompt_performance
+        WHERE prompt_id = ?
+        ORDER BY calculated_at DESC
+      `);
+      const rows = stmt.all(promptId);
+      return rows.map((row) => this.rowToPerformance(row));
+    } catch (_error) {
+      return [];
+    }
+  }
+  /**
+   * Get the poetic directory path
+   */
+  getPoticDir() {
+    return this.poeticDir;
+  }
+  /**
+   * Save a prompt variant to database
+   */
+  saveVariant(variant) {
+    try {
+      const versionStmt = this.db.prepare(
+        "SELECT id FROM prompt_versions WHERE prompt_id = ? AND id = ?"
+      );
+      const versionExists = versionStmt.get(variant.promptId, variant.baseVersionId);
+      if (!versionExists) {
+        throw new Error(
+          `Base version "${variant.baseVersionId}" not found for prompt "${variant.promptId}"`
+        );
+      }
+      const stmt = this.db.prepare(`
+        INSERT OR REPLACE INTO prompt_variants (
+          id,
+          prompt_id,
+          base_version_id,
+          mutation_strategies,
+          success_rate,
+          completeness,
+          duration_ms,
+          confidence,
+          expected_improvement,
+          created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(
+        variant.id,
+        variant.promptId,
+        variant.baseVersionId,
+        JSON.stringify(variant.mutationStrategies),
+        variant.successRate || null,
+        variant.completeness || null,
+        variant.durationMs || null,
+        variant.confidence || null,
+        variant.expectedImprovement || null,
+        variant.createdAt
+      );
+    } catch (error) {
+      throw new Error(`Failed to save variant: ${error.message}`);
+    }
+  }
+  ensureSafePromptId(promptId) {
+    if (!PROMPT_ID_PATTERN.test(promptId) && !LEGACY_PROMPT_ID_PATTERN.test(promptId)) {
+      throw new Error(
+        "Prompt ID must be a safe identifier (lowercase letters, numbers, hyphens; legacy underscores are readable)"
+      );
+    }
+    if (promptId.includes("/") || promptId.includes("\\")) {
+      throw new Error("Prompt ID cannot contain path separators");
+    }
+  }
+  ensureSafeVersionId(versionId) {
+    if (!VERSION_ID_PATTERN.test(versionId)) {
+      throw new Error(
+        "Version ID must start with an alphanumeric character and may only include dots, underscores, or hyphens"
+      );
+    }
+    if (versionId.includes("/") || versionId.includes("\\")) {
+      throw new Error("Version ID cannot contain path separators");
+    }
+  }
+  getVersionContentPath(promptId, versionId, status = "active") {
+    this.ensureSafePromptId(promptId);
+    this.ensureSafeVersionId(versionId);
+    const baseDir = status === "archived" ? this.archivedDir : this.activeDir;
+    return path.join(baseDir, `${promptId}-${versionId}.txt`);
+  }
+};
+
+export {
+  PromptStore
+};
+//# sourceMappingURL=chunk-OQ6K46CK.js.map