@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-U45RTRGY.js

@@ -0,0 +1,818 @@
+import {
+  parseJsonWithContext
+} from "./chunk-QVZMFDYG.js";
+import {
+  resolvePoeticDirFromContext
+} from "./chunk-UI2F6DJ5.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/storage/ExecutionTracker.ts
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import Database from "better-sqlite3";
+
+// src/core/storage/schema-migrations.ts
+function tableExists(db, tableName) {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
+  return row !== void 0;
+}
+function hasCompositePromptVersionFk(db) {
+  const rows = db.prepare("PRAGMA foreign_key_list(prompt_executions)").all();
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows.filter((r) => r.table === "prompt_versions")) {
+    const group = groups.get(row.id) ?? [];
+    group.push(row);
+    groups.set(row.id, group);
+  }
+  return Array.from(groups.values()).some((group) => {
+    const mapping = new Map(group.map((row) => [row.from, row.to]));
+    return mapping.get("prompt_id") === "prompt_id" && mapping.get("version_id") === "id";
+  });
+}
+function supportsEphemeralExecutions(db) {
+  const rows = db.prepare("PRAGMA table_info(prompt_executions)").all();
+  const columns = new Map(rows.map((row) => [row.name, row]));
+  return columns.get("prompt_id")?.notnull === 0 && columns.get("version_id")?.notnull === 0 && columns.has("task_hash") && columns.has("input_provenance");
+}
+function columnNames(db, tableName) {
+  const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
+  return new Set(rows.map((row) => row.name));
+}
+function quoted(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function buildSelectList(sourceColumns, columns) {
+  return columns.map((column) => sourceColumns.has(column.name) ? quoted(column.name) : column.fallback).join(", ");
+}
+var EXECUTION_COLUMNS = [
+  { name: "id", fallback: "''" },
+  { name: "prompt_id", fallback: "''" },
+  { name: "version_id", fallback: "''" },
+  { name: "task_hash", fallback: "'legacy:' || id" },
+  { name: "input_provenance", fallback: "'legacy'" },
+  { name: "execution_mode", fallback: "'compete'" },
+  { name: "variant_count", fallback: "1" },
+  { name: "started_at", fallback: "CURRENT_TIMESTAMP" },
+  { name: "completed_at", fallback: "NULL" },
+  { name: "duration_seconds", fallback: "NULL" },
+  { name: "status", fallback: "'completed'" },
+  { name: "winning_variant_id", fallback: "NULL" },
+  { name: "success_rate", fallback: "NULL" },
+  { name: "avg_completeness", fallback: "NULL" },
+  { name: "avg_code_delivery_rate", fallback: "NULL" },
+  { name: "avg_duration", fallback: "NULL" },
+  { name: "total_cost_usd", fallback: "NULL" },
+  { name: "total_tokens", fallback: "NULL" },
+  { name: "task_description", fallback: "NULL" },
+  { name: "task_complexity", fallback: "NULL" },
+  { name: "project_context", fallback: "NULL" },
+  { name: "created_at", fallback: "CURRENT_TIMESTAMP" },
+  { name: "updated_at", fallback: "CURRENT_TIMESTAMP" }
+];
+var VARIANT_COLUMNS = [
+  { name: "id", fallback: "NULL" },
+  { name: "execution_id", fallback: "''" },
+  { name: "variant_name", fallback: "''" },
+  { name: "provider", fallback: "''" },
+  { name: "model", fallback: "NULL" },
+  { name: "success", fallback: "0" },
+  { name: "completeness", fallback: "NULL" },
+  { name: "code_delivered", fallback: "NULL" },
+  { name: "duration_seconds", fallback: "NULL" },
+  { name: "error_count", fallback: "0" },
+  { name: "warning_count", fallback: "0" },
+  { name: "test_results", fallback: "NULL" },
+  { name: "cost_usd", fallback: "NULL" },
+  { name: "tokens_used", fallback: "NULL" },
+  { name: "judge_score", fallback: "NULL" },
+  { name: "judge_feedback", fallback: "NULL" },
+  { name: "is_winner", fallback: "0" },
+  { name: "created_at", fallback: "CURRENT_TIMESTAMP" }
+];
+var PROMPT_EXECUTION_VIEWS_SQL = `
+  CREATE VIEW IF NOT EXISTS v_prompt_execution_metrics AS
+  SELECT
+    pe.prompt_id,
+    pe.version_id,
+    COUNT(*) as total_executions,
+    SUM(CASE WHEN pe.status = 'completed' THEN 1 ELSE 0 END) as completed_executions,
+    AVG(pe.success_rate) as avg_success_rate,
+    AVG(pe.avg_completeness) as avg_completeness,
+    AVG(pe.avg_duration) as avg_duration,
+    SUM(pe.total_cost_usd) as total_cost,
+    MIN(pe.started_at) as first_execution,
+    MAX(pe.started_at) as last_execution,
+    COUNT(DISTINCT pe.execution_mode) as execution_modes_used
+  FROM prompt_executions pe
+  WHERE pe.status = 'completed'
+  GROUP BY pe.prompt_id, pe.version_id;
+
+  CREATE VIEW IF NOT EXISTS v_prompts_ready_for_optimization AS
+  SELECT
+    p.id as prompt_id,
+    p.name,
+    p.active_version_id,
+    COUNT(DISTINCT pe.id) as execution_count,
+    AVG(pe.success_rate) as avg_success_rate,
+    AVG(pe.avg_completeness) as avg_completeness,
+    MAX(pe.started_at) as last_execution,
+    CASE
+      WHEN COUNT(DISTINCT pe.id) >= 10 AND AVG(pe.success_rate) < 0.9 THEN 1
+      ELSE 0
+    END as optimization_recommended,
+    JULIANDAY('now') - JULIANDAY(
+      COALESCE(
+        (SELECT MAX(started_at) FROM prompt_optimization_cycles WHERE prompt_id = p.id),
+        p.created_at
+      )
+    ) as days_since_optimization
+  FROM prompts p
+  LEFT JOIN prompt_executions pe
+    ON p.id = pe.prompt_id AND p.active_version_id = pe.version_id
+  GROUP BY p.id, p.name, p.active_version_id, p.created_at
+  HAVING execution_count > 0;
+`;
+function ensurePromptExecutionViews(db) {
+  if (!tableExists(db, "prompt_executions") || !tableExists(db, "prompts")) return;
+  db.exec(PROMPT_EXECUTION_VIEWS_SQL);
+}
+function ensurePromptExecutionsCompositeForeignKey(db) {
+  if (!tableExists(db, "prompt_executions") || hasCompositePromptVersionFk(db) && supportsEphemeralExecutions(db)) {
+    return;
+  }
+  const hasVariantTable = tableExists(db, "prompt_execution_variants");
+  const executionSelect = buildSelectList(columnNames(db, "prompt_executions"), EXECUTION_COLUMNS);
+  const variantSelect = hasVariantTable ? buildSelectList(columnNames(db, "prompt_execution_variants"), VARIANT_COLUMNS) : "";
+  const foreignKeysEnabled = Number(db.pragma("foreign_keys", { simple: true })) === 1;
+  db.exec("PRAGMA foreign_keys = OFF");
+  try {
+    const migrate = db.transaction(() => {
+      db.exec(`
+      DROP VIEW IF EXISTS v_prompt_execution_metrics;
+      DROP VIEW IF EXISTS v_prompts_ready_for_optimization;
+      DROP TABLE IF EXISTS prompt_execution_variants_migration_old;
+      DROP TABLE IF EXISTS prompt_executions_migration_old;
+      ${hasVariantTable ? "ALTER TABLE prompt_execution_variants RENAME TO prompt_execution_variants_migration_old;" : ""}
+      ALTER TABLE prompt_executions RENAME TO prompt_executions_migration_old;
+
+      CREATE TABLE prompt_executions (
+        id TEXT PRIMARY KEY,
+        prompt_id TEXT,
+        version_id TEXT,
+        task_hash TEXT NOT NULL,
+        input_provenance TEXT NOT NULL DEFAULT 'stored-prompt',
+        execution_mode TEXT NOT NULL,
+        variant_count INTEGER DEFAULT 1,
+        started_at TEXT NOT NULL,
+        completed_at TEXT,
+        duration_seconds REAL,
+        status TEXT NOT NULL,
+        winning_variant_id TEXT,
+        success_rate REAL,
+        avg_completeness REAL,
+        avg_code_delivery_rate REAL,
+        avg_duration REAL,
+        total_cost_usd REAL,
+        total_tokens INTEGER,
+        task_description TEXT,
+        task_complexity TEXT,
+        project_context TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        CHECK ((prompt_id IS NULL AND version_id IS NULL) OR
+               (prompt_id IS NOT NULL AND version_id IS NOT NULL)),
+        FOREIGN KEY (prompt_id) REFERENCES prompts(id) ON DELETE CASCADE,
+        FOREIGN KEY (prompt_id, version_id) REFERENCES prompt_versions(prompt_id, id) ON DELETE CASCADE
+      );
+
+      INSERT INTO prompt_executions (${EXECUTION_COLUMNS.map((c) => quoted(c.name)).join(", ")})
+      SELECT ${executionSelect} FROM prompt_executions_migration_old;
+
+      CREATE TABLE IF NOT EXISTS prompt_execution_variants (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        execution_id TEXT NOT NULL,
+        variant_name TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT,
+        success INTEGER NOT NULL,
+        completeness REAL,
+        code_delivered INTEGER,
+        duration_seconds REAL,
+        error_count INTEGER DEFAULT 0,
+        warning_count INTEGER DEFAULT 0,
+        test_results TEXT,
+        cost_usd REAL,
+        tokens_used INTEGER,
+        judge_score REAL,
+        judge_feedback TEXT,
+        is_winner INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (execution_id) REFERENCES prompt_executions(id) ON DELETE CASCADE
+      );
+
+      ${hasVariantTable ? `INSERT INTO prompt_execution_variants (${VARIANT_COLUMNS.map((c) => quoted(c.name)).join(", ")})
+             SELECT ${variantSelect} FROM prompt_execution_variants_migration_old;` : ""}
+
+      DROP TABLE prompt_executions_migration_old;
+      DROP TABLE IF EXISTS prompt_execution_variants_migration_old;
+      CREATE INDEX IF NOT EXISTS idx_executions_prompt ON prompt_executions(prompt_id);
+      CREATE INDEX IF NOT EXISTS idx_executions_version ON prompt_executions(prompt_id, version_id);
+      CREATE INDEX IF NOT EXISTS idx_executions_status ON prompt_executions(status);
+      CREATE INDEX IF NOT EXISTS idx_executions_started ON prompt_executions(started_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_executions_mode ON prompt_executions(execution_mode);
+      CREATE INDEX IF NOT EXISTS idx_variant_execution ON prompt_execution_variants(execution_id);
+      CREATE INDEX IF NOT EXISTS idx_variant_winner ON prompt_execution_variants(execution_id, is_winner);
+      CREATE INDEX IF NOT EXISTS idx_variant_provider ON prompt_execution_variants(provider, variant_name);
+      `);
+      ensurePromptExecutionViews(db);
+    });
+    migrate.immediate();
+  } finally {
+    db.exec(`PRAGMA foreign_keys = ${foreignKeysEnabled ? "ON" : "OFF"}`);
+  }
+}
+
+// src/core/storage/ExecutionTracker.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+function asNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : 0;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+var ExecutionTracker = class {
+  poeticDir;
+  dbPath;
+  db;
+  ownsDb;
+  constructor(options = {}) {
+    this.poeticDir = resolvePoeticDirFromContext(options.poeticDir);
+    const dbDir = path.join(this.poeticDir, "prompts", "db");
+    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;
+    }
+    if (options.autoApplySchema !== false) {
+      this.applySchema();
+    }
+  }
+  /**
+   * Apply schema extensions to database.
+   *
+   * Bootstraps the canonical prompts / prompt_versions schema so that
+   * schema-extensions.sql foreign keys can be applied even when this tracker
+   * is the first writer to a fresh DB. The shape mirrors the canonical
+   * writers (src/prompts/store.ts and src/core/storage/PromptStore.ts:
+   * hash-and-file, composite PK on (prompt_id, id)). Older inline-content
+   * databases continue to be read via the writers' PRAGMA-driven detection.
+   */
+  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 DEFAULT '',
+        active_version_id TEXT,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        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 DEFAULT '',
+        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 DEFAULT CURRENT_TIMESTAMP,
+        activated_at TEXT,
+        deactivated_at TEXT,
+        parent_version_id TEXT,
+        mutation_type 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 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 {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS prompt_executions (
+          id TEXT PRIMARY KEY,
+          prompt_id TEXT,
+          version_id TEXT,
+          task_hash TEXT NOT NULL,
+          input_provenance TEXT NOT NULL DEFAULT 'stored-prompt',
+          execution_mode TEXT NOT NULL,
+          variant_count INTEGER DEFAULT 1,
+          started_at TEXT NOT NULL,
+          completed_at TEXT,
+          duration_seconds REAL,
+          status TEXT NOT NULL,
+          winning_variant_id TEXT,
+          success_rate REAL,
+          avg_completeness REAL,
+          avg_code_delivery_rate REAL,
+          avg_duration REAL,
+          total_cost_usd REAL,
+          total_tokens INTEGER,
+          task_description TEXT,
+          task_complexity TEXT,
+          project_context TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          CHECK ((prompt_id IS NULL AND version_id IS NULL) OR
+                 (prompt_id IS NOT NULL AND version_id IS NOT NULL)),
+          FOREIGN KEY (prompt_id) REFERENCES prompts(id) ON DELETE CASCADE,
+          FOREIGN KEY (prompt_id, version_id) REFERENCES prompt_versions(prompt_id, id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_executions_prompt ON prompt_executions(prompt_id);
+        CREATE INDEX IF NOT EXISTS idx_executions_version ON prompt_executions(prompt_id, version_id);
+        CREATE INDEX IF NOT EXISTS idx_executions_status ON prompt_executions(status);
+
+        CREATE TABLE IF NOT EXISTS prompt_execution_variants (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          execution_id TEXT NOT NULL,
+          variant_name TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          model TEXT,
+          success INTEGER NOT NULL,
+          completeness REAL,
+          code_delivered INTEGER,
+          duration_seconds REAL,
+          error_count INTEGER DEFAULT 0,
+          warning_count INTEGER DEFAULT 0,
+          test_results TEXT,
+          cost_usd REAL,
+          tokens_used INTEGER,
+          judge_score REAL,
+          judge_feedback TEXT,
+          is_winner INTEGER DEFAULT 0,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+          FOREIGN KEY (execution_id) REFERENCES prompt_executions(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_variant_execution ON prompt_execution_variants(execution_id);
+      `);
+      ensurePromptExecutionsCompositeForeignKey(this.db);
+      ensurePromptExecutionViews(this.db);
+    }
+  }
+  /**
+   * Start tracking a new execution
+   */
+  async startExecution(input) {
+    if (input.promptId === void 0 !== (input.versionId === void 0)) {
+      throw new Error("promptId and versionId must either both be provided or both be omitted");
+    }
+    const id = input.id ?? this.generateExecutionId();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const taskHash = input.taskHash ?? crypto.createHash("sha256").update(input.taskDescription ?? `${input.promptId ?? ""}:${input.versionId ?? ""}:${id}`).digest("hex");
+    const inputProvenance = input.inputProvenance ?? (input.promptId ? "stored-prompt" : "inline");
+    const stmt = this.db.prepare(`
+      ${input.id ? "INSERT OR IGNORE" : "INSERT"} INTO prompt_executions (
+        id, prompt_id, version_id, task_hash, input_provenance, execution_mode, variant_count,
+        started_at, status, task_description, task_complexity, project_context,
+        created_at, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      id,
+      input.promptId ?? null,
+      input.versionId ?? null,
+      taskHash,
+      inputProvenance,
+      input.executionMode,
+      input.variantCount || 1,
+      now,
+      "running",
+      input.taskDescription || null,
+      input.taskComplexity || null,
+      input.projectContext ? JSON.stringify(input.projectContext) : null,
+      now,
+      now
+    );
+    const execution = this.getExecution(id);
+    if (!execution) {
+      throw new Error(`Failed to start execution ${id}`);
+    }
+    return execution;
+  }
+  /**
+   * Complete an execution with results
+   */
+  async completeExecution(executionId, result) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const execution = this.getExecution(executionId);
+    if (!execution) {
+      throw new Error(`Execution ${executionId} not found`);
+    }
+    const durationSeconds = execution.startedAt ? (new Date(now).getTime() - new Date(execution.startedAt).getTime()) / 1e3 : void 0;
+    const stmt = this.db.prepare(`
+      UPDATE prompt_executions
+      SET
+        completed_at = ?,
+        duration_seconds = ?,
+        status = ?,
+        winning_variant_id = ?,
+        success_rate = ?,
+        avg_completeness = ?,
+        avg_code_delivery_rate = ?,
+        avg_duration = ?,
+        total_cost_usd = ?,
+        total_tokens = ?,
+        updated_at = ?
+      WHERE id = ?
+    `);
+    stmt.run(
+      now,
+      durationSeconds ?? null,
+      result.status,
+      result.winningVariantId ?? null,
+      result.successRate ?? null,
+      result.avgCompleteness ?? null,
+      result.avgCodeDeliveryRate ?? null,
+      result.avgDuration ?? null,
+      result.totalCostUsd ?? null,
+      result.totalTokens ?? null,
+      now,
+      executionId
+    );
+  }
+  /**
+   * Record a variant result
+   */
+  async recordVariant(input) {
+    const stmt = this.db.prepare(`
+      INSERT INTO prompt_execution_variants (
+        execution_id, variant_name, provider, model, success, completeness,
+        code_delivered, duration_seconds, error_count, warning_count,
+        test_results, cost_usd, tokens_used, judge_score, judge_feedback,
+        is_winner
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(
+      input.executionId,
+      input.variantName,
+      input.provider,
+      input.model ?? null,
+      input.success ? 1 : 0,
+      input.completeness ?? null,
+      input.codeDelivered ? 1 : 0,
+      input.durationSeconds ?? null,
+      input.errorCount || 0,
+      input.warningCount || 0,
+      input.testResults ? JSON.stringify(input.testResults) : null,
+      input.costUsd ?? null,
+      input.tokensUsed ?? null,
+      input.judgeScore ?? null,
+      input.judgeFeedback ?? null,
+      input.isWinner ? 1 : 0
+    );
+    return this.getVariant(Number(result.lastInsertRowid));
+  }
+  /**
+   * Get execution by ID
+   */
+  getExecution(id) {
+    const stmt = this.db.prepare("SELECT * FROM prompt_executions WHERE id = ?");
+    const row = stmt.get(id);
+    if (!row) {
+      return null;
+    }
+    return this.rowToExecution(row);
+  }
+  /**
+   * Get all executions for a prompt with optional pagination
+   * @param promptId The prompt ID
+   * @param versionId Optional version ID filter
+   * @param limit Maximum number of results (default: 1000, max: 1000)
+   * @param offset Number of results to skip (default: 0)
+   */
+  getExecutions(promptId, versionId, limit, offset) {
+    let query = "SELECT * FROM prompt_executions WHERE prompt_id = ?";
+    const params = [promptId];
+    if (versionId) {
+      query += " AND version_id = ?";
+      params.push(versionId);
+    }
+    query += " ORDER BY started_at DESC";
+    const actualLimit = Math.min(limit ?? 1e3, 1e3);
+    const actualOffset = offset ?? 0;
+    query += " LIMIT ? OFFSET ?";
+    params.push(actualLimit, actualOffset);
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map((row) => this.rowToExecution(row));
+  }
+  /**
+   * Get variant results for an execution
+   */
+  getVariants(executionId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM prompt_execution_variants WHERE execution_id = ? ORDER BY judge_score DESC, completeness DESC"
+    );
+    const rows = stmt.all(executionId);
+    return rows.map((row) => this.rowToVariant(row));
+  }
+  /**
+   * Get variant by ID
+   */
+  getVariant(id) {
+    const stmt = this.db.prepare("SELECT * FROM prompt_execution_variants WHERE id = ?");
+    const row = stmt.get(id);
+    if (!row) {
+      return null;
+    }
+    return this.rowToVariant(row);
+  }
+  /**
+   * Get aggregated metrics for a prompt version
+   */
+  getMetrics(promptId, versionId) {
+    let query = `
+      SELECT
+        prompt_id,
+        version_id,
+        COUNT(*) as total_executions,
+        SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed_executions,
+        AVG(success_rate) as avg_success_rate,
+        AVG(avg_completeness) as avg_completeness,
+        AVG(avg_code_delivery_rate) as avg_code_delivery_rate,
+        AVG(avg_duration) as avg_duration,
+        -- Population variance via the identity E[x^2] - E[x]^2.
+        -- SQLite has no built-in STDDEV; we compute std-dev in JS
+        -- (sqrt(max(variance, 0))) to clamp tiny negative floating-point
+        -- artifacts that occur when all sampled values are identical.
+        AVG(avg_completeness * avg_completeness) as avg_completeness_sq,
+        MIN(avg_completeness) as min_completeness,
+        MAX(avg_completeness) as max_completeness,
+        -- SUM skips NULL, so a partial subtotal is not a full total. Count known-cost
+        -- rows and expose totalCost only when every included execution has known cost.
+        SUM(total_cost_usd) as total_cost,
+        SUM(CASE WHEN total_cost_usd IS NOT NULL THEN 1 ELSE 0 END) as known_cost_executions,
+        MIN(started_at) as first_execution,
+        MAX(started_at) as last_execution,
+        COUNT(DISTINCT execution_mode) as execution_modes_used
+      FROM prompt_executions
+      WHERE prompt_id = ?
+    `;
+    const params = [promptId];
+    if (versionId) {
+      query += " AND version_id = ?";
+      params.push(versionId);
+    } else {
+      query += " GROUP BY prompt_id, version_id";
+    }
+    const stmt = this.db.prepare(query);
+    const row = stmt.get(...params);
+    if (!row || typeof row !== "object") {
+      return null;
+    }
+    const r = row;
+    const totalExecutions = asNumber(r.total_executions);
+    if (totalExecutions === 0) {
+      return null;
+    }
+    const avgCompleteness = asNumber(r.avg_completeness);
+    const avgCompletenessSq = asNumber(r.avg_completeness_sq);
+    const variance = Math.max(0, avgCompletenessSq - avgCompleteness * avgCompleteness);
+    const stdDevCompleteness = Math.sqrt(variance);
+    const knownCostExecutions = asNumber(r.known_cost_executions);
+    const totalCostStatus = knownCostExecutions === totalExecutions ? "complete" : "incomplete";
+    const totalCost = totalCostStatus === "complete" ? asNumber(r.total_cost) : void 0;
+    return {
+      promptId: r.prompt_id,
+      versionId: r.version_id,
+      totalExecutions,
+      completedExecutions: asNumber(r.completed_executions),
+      avgSuccessRate: asNumber(r.avg_success_rate),
+      avgCompleteness,
+      avgCodeDeliveryRate: asNumber(r.avg_code_delivery_rate),
+      avgDuration: asNumber(r.avg_duration),
+      minCompleteness: asNumber(r.min_completeness),
+      maxCompleteness: asNumber(r.max_completeness),
+      stdDevCompleteness,
+      ...totalCost !== void 0 ? { totalCost } : {},
+      totalCostStatus,
+      firstExecution: r.first_execution,
+      lastExecution: r.last_execution,
+      executionModesUsed: asNumber(r.execution_modes_used)
+    };
+  }
+  /**
+   * Check if prompt is ready for optimization
+   */
+  isReadyForOptimization(promptId, versionId) {
+    const metrics = this.getMetrics(promptId, versionId);
+    if (!metrics) {
+      return {
+        ready: false,
+        reason: "No executions recorded",
+        executionCount: 0,
+        avgSuccessRate: 0,
+        avgCompleteness: 0
+      };
+    }
+    const MIN_EXECUTIONS = 10;
+    const MIN_SUCCESS_RATE = 0.9;
+    const MIN_COMPLETENESS = 85;
+    if (metrics.totalExecutions < MIN_EXECUTIONS) {
+      return {
+        ready: false,
+        reason: `Need ${MIN_EXECUTIONS - metrics.totalExecutions} more executions`,
+        executionCount: metrics.totalExecutions,
+        avgSuccessRate: metrics.avgSuccessRate,
+        avgCompleteness: metrics.avgCompleteness
+      };
+    }
+    if (metrics.avgSuccessRate < MIN_SUCCESS_RATE || metrics.avgCompleteness < MIN_COMPLETENESS) {
+      return {
+        ready: true,
+        reason: "Performance below target",
+        executionCount: metrics.totalExecutions,
+        avgSuccessRate: metrics.avgSuccessRate,
+        avgCompleteness: metrics.avgCompleteness
+      };
+    }
+    return {
+      ready: false,
+      reason: "Performance meets target",
+      executionCount: metrics.totalExecutions,
+      avgSuccessRate: metrics.avgSuccessRate,
+      avgCompleteness: metrics.avgCompleteness
+    };
+  }
+  /**
+   * Close database connection (only if owned)
+   */
+  close() {
+    if (this.ownsDb) {
+      this.db.close();
+    }
+  }
+  // Private helpers
+  generateExecutionId() {
+    return `exec_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
+  }
+  rowToExecution(row) {
+    const executionMode = row.execution_mode;
+    const status = row.status;
+    const taskComplexity = row.task_complexity;
+    let projectContext;
+    if (row.project_context) {
+      try {
+        const parsed = parseJsonWithContext(
+          row.project_context,
+          "ExecutionTracker.projectContext"
+        );
+        projectContext = parsed || {};
+      } catch (err) {
+        emitWarning(
+          "WS-003",
+          {
+            taskId: row.id,
+            subsystem: "storage",
+            executionPhase: "execution"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              error: err instanceof Error ? err.message : String(err),
+              operation: "parseProjectContext"
+            }
+          }
+        );
+      }
+    }
+    return {
+      id: row.id,
+      promptId: row.prompt_id ?? void 0,
+      versionId: row.version_id ?? void 0,
+      taskHash: row.task_hash,
+      inputProvenance: row.input_provenance,
+      executionMode,
+      variantCount: row.variant_count,
+      startedAt: row.started_at,
+      completedAt: row.completed_at ?? void 0,
+      durationSeconds: row.duration_seconds ?? void 0,
+      status,
+      winningVariantId: row.winning_variant_id ?? void 0,
+      successRate: row.success_rate ?? void 0,
+      avgCompleteness: row.avg_completeness ?? void 0,
+      avgCodeDeliveryRate: row.avg_code_delivery_rate ?? void 0,
+      avgDuration: row.avg_duration ?? void 0,
+      totalCostUsd: row.total_cost_usd ?? void 0,
+      totalTokens: row.total_tokens ?? void 0,
+      taskDescription: row.task_description ?? void 0,
+      taskComplexity: taskComplexity || void 0,
+      projectContext,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  rowToVariant(row) {
+    let testResults;
+    if (row.test_results) {
+      try {
+        const parsed = parseJsonWithContext(
+          row.test_results,
+          "ExecutionTracker.testResults"
+        );
+        testResults = parsed || {};
+      } catch (err) {
+        emitWarning(
+          "WS-003",
+          {
+            taskId: row.execution_id,
+            subsystem: "storage",
+            executionPhase: "execution"
+          },
+          {
+            severity: "WARN" /* WARN */,
+            metadata: {
+              variantId: row.id,
+              error: err instanceof Error ? err.message : String(err),
+              operation: "parseTestResults"
+            }
+          }
+        );
+      }
+    }
+    return {
+      id: row.id,
+      executionId: row.execution_id,
+      variantName: row.variant_name,
+      provider: row.provider,
+      model: row.model ?? void 0,
+      success: row.success === 1,
+      completeness: row.completeness ?? void 0,
+      codeDelivered: row.code_delivered === 1,
+      durationSeconds: row.duration_seconds ?? void 0,
+      errorCount: row.error_count ?? 0,
+      warningCount: row.warning_count ?? 0,
+      testResults,
+      costUsd: row.cost_usd ?? void 0,
+      tokensUsed: row.tokens_used ?? void 0,
+      judgeScore: row.judge_score ?? void 0,
+      judgeFeedback: row.judge_feedback ?? void 0,
+      isWinner: row.is_winner === 1,
+      createdAt: row.created_at
+    };
+  }
+};
+
+export {
+  ensurePromptExecutionViews,
+  ensurePromptExecutionsCompositeForeignKey,
+  ExecutionTracker
+};
+//# sourceMappingURL=chunk-U45RTRGY.js.map