labgate 0.5.31 → 0.5.33

package/dist/lib/explorer-store.js

@@ -0,0 +1,950 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplorerStore = void 0;
+exports.makeExplorerExperimentId = makeExplorerExperimentId;
+exports.makeExplorerRunId = makeExplorerRunId;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_js_1 = require("./config.js");
+const explorer_retention_js_1 = require("./explorer-retention.js");
+let Database;
+try {
+    Database = require('better-sqlite3');
+}
+catch {
+    Database = null;
+}
+const ACTIVE_RUN_STATES = new Set(['queued', 'running', 'commit_ok']);
+const RUN_STATUS_VALUES = [
+    'queued',
+    'running',
+    'commit_ok',
+    'eval_ok',
+    'failed_build',
+    'failed_eval',
+    'timeout',
+    'invalid_output',
+];
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS experiments (
+  id               TEXT PRIMARY KEY,
+  name             TEXT NOT NULL,
+  created_at       TEXT NOT NULL,
+  status           TEXT NOT NULL,
+  repo_path        TEXT NOT NULL,
+  base_ref         TEXT NOT NULL,
+  eval_command     TEXT NOT NULL,
+  eval_timeout_sec INTEGER NOT NULL,
+  policy_json      TEXT NOT NULL,
+  constraints_json TEXT NOT NULL,
+  prompt_preamble  TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS runs (
+  id                TEXT PRIMARY KEY,
+  experiment_id     TEXT NOT NULL,
+  parent_run_id     TEXT,
+  parent_commit_sha TEXT NOT NULL,
+  branch_name       TEXT NOT NULL,
+  worktree_path     TEXT NOT NULL,
+  commit_sha        TEXT,
+  status            TEXT NOT NULL,
+  score             REAL,
+  metrics_json      TEXT,
+  model             TEXT NOT NULL,
+  summary_md        TEXT NOT NULL,
+  created_at        TEXT NOT NULL,
+  started_at        TEXT,
+  finished_at       TEXT,
+  artifact_dir      TEXT NOT NULL,
+  worktree_pruned_at TEXT,
+  artifacts_pruned_at TEXT,
+  artifacts_mode_kept TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_runs_experiment_created ON runs(experiment_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_runs_experiment_score ON runs(experiment_id, score DESC);
+CREATE INDEX IF NOT EXISTS idx_runs_experiment_status ON runs(experiment_id, status);
+
+CREATE TABLE IF NOT EXISTS events (
+  id           TEXT PRIMARY KEY,
+  experiment_id TEXT NOT NULL,
+  run_id       TEXT,
+  type         TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  created_at   TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_experiment_created ON events(experiment_id, created_at DESC);
+`;
+function nowIso() {
+    return new Date().toISOString();
+}
+function sanitizeString(value, maxLen) {
+    if (typeof value !== 'string')
+        return '';
+    const trimmed = value.trim();
+    if (!trimmed)
+        return '';
+    return trimmed.length > maxLen ? trimmed.slice(0, maxLen) : trimmed;
+}
+function sanitizeJsonString(value, fallback = '{}') {
+    if (typeof value !== 'string' || !value.trim())
+        return fallback;
+    try {
+        const parsed = JSON.parse(value);
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return fallback;
+    }
+}
+function clampInt(value, fallback, min, max) {
+    if (!Number.isFinite(value))
+        return fallback;
+    return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function initStatusCounts() {
+    return {
+        queued: 0,
+        running: 0,
+        commit_ok: 0,
+        eval_ok: 0,
+        failed_build: 0,
+        failed_eval: 0,
+        timeout: 0,
+        invalid_output: 0,
+    };
+}
+function makeExplorerExperimentId() {
+    const stamp = new Date().toISOString().replace(/[-:.TZ]/g, '').slice(0, 14);
+    return `exp_${stamp}_${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+}
+function makeExplorerRunId() {
+    return `run_${Date.now()}_${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+}
+function makeEventId() {
+    return `evt_${Date.now()}_${(0, crypto_1.randomUUID)().slice(0, 8)}`;
+}
+function mapRunRow(row) {
+    return {
+        id: String(row.id),
+        experiment_id: String(row.experiment_id),
+        parent_run_id: row.parent_run_id ? String(row.parent_run_id) : null,
+        parent_commit_sha: String(row.parent_commit_sha),
+        branch_name: String(row.branch_name),
+        worktree_path: String(row.worktree_path),
+        commit_sha: row.commit_sha ? String(row.commit_sha) : null,
+        status: row.status,
+        score: row.score == null ? null : Number(row.score),
+        metrics_json: row.metrics_json == null ? null : String(row.metrics_json),
+        model: String(row.model),
+        summary_md: String(row.summary_md),
+        created_at: String(row.created_at),
+        started_at: row.started_at ? String(row.started_at) : null,
+        finished_at: row.finished_at ? String(row.finished_at) : null,
+        artifact_dir: String(row.artifact_dir),
+        worktree_pruned_at: row.worktree_pruned_at ? String(row.worktree_pruned_at) : null,
+        artifacts_pruned_at: row.artifacts_pruned_at ? String(row.artifacts_pruned_at) : null,
+        artifacts_mode_kept: row.artifacts_mode_kept
+            ? String(row.artifacts_mode_kept)
+            : null,
+    };
+}
+function normalizeRunObject(row) {
+    return {
+        id: String(row.id || ''),
+        experiment_id: String(row.experiment_id || ''),
+        parent_run_id: row.parent_run_id ? String(row.parent_run_id) : null,
+        parent_commit_sha: String(row.parent_commit_sha || ''),
+        branch_name: String(row.branch_name || ''),
+        worktree_path: String(row.worktree_path || ''),
+        commit_sha: row.commit_sha ? String(row.commit_sha) : null,
+        status: String(row.status || 'queued'),
+        score: row.score == null ? null : Number(row.score),
+        metrics_json: row.metrics_json == null ? null : String(row.metrics_json),
+        model: String(row.model || 'stub'),
+        summary_md: String(row.summary_md || ''),
+        created_at: String(row.created_at || nowIso()),
+        started_at: row.started_at ? String(row.started_at) : null,
+        finished_at: row.finished_at ? String(row.finished_at) : null,
+        artifact_dir: String(row.artifact_dir || ''),
+        worktree_pruned_at: row.worktree_pruned_at ? String(row.worktree_pruned_at) : null,
+        artifacts_pruned_at: row.artifacts_pruned_at ? String(row.artifacts_pruned_at) : null,
+        artifacts_mode_kept: row.artifacts_mode_kept
+            ? String(row.artifacts_mode_kept)
+            : null,
+    };
+}
+function mapExperimentRow(row) {
+    return {
+        id: String(row.id),
+        name: String(row.name),
+        created_at: String(row.created_at),
+        status: row.status,
+        repo_path: String(row.repo_path),
+        base_ref: String(row.base_ref),
+        eval_command: String(row.eval_command),
+        eval_timeout_sec: Number(row.eval_timeout_sec),
+        policy_json: String(row.policy_json),
+        constraints_json: String(row.constraints_json),
+        prompt_preamble: String(row.prompt_preamble),
+    };
+}
+function mapEventRow(row) {
+    return {
+        id: String(row.id),
+        experiment_id: String(row.experiment_id),
+        run_id: row.run_id ? String(row.run_id) : null,
+        type: row.type,
+        payload_json: String(row.payload_json),
+        created_at: String(row.created_at),
+    };
+}
+class ExplorerStore {
+    dbPath;
+    db;
+    useJsonFallback = false;
+    jsonPath = null;
+    jsonStore = {
+        version: 1,
+        experiments: [],
+        runs: [],
+        events: [],
+    };
+    constructor(dbPath = (0, config_js_1.getExplorerDbPath)()) {
+        this.dbPath = dbPath;
+        const dir = (0, path_1.dirname)(dbPath);
+        if (!(0, fs_1.existsSync)(dir)) {
+            (0, fs_1.mkdirSync)(dir, { recursive: true, mode: 0o700 });
+        }
+        const forceJson = process.env.LABGATE_EXPLORER_DB_FORCE_JSON === '1';
+        if (Database && !forceJson) {
+            try {
+                this.db = new Database(dbPath);
+                this.db.pragma('journal_mode = WAL');
+                this.db.pragma('busy_timeout = 5000');
+                this.db.exec(SCHEMA);
+                try {
+                    this.db.exec('ALTER TABLE runs ADD COLUMN worktree_pruned_at TEXT');
+                }
+                catch { /* already exists */ }
+                try {
+                    this.db.exec('ALTER TABLE runs ADD COLUMN artifacts_pruned_at TEXT');
+                }
+                catch { /* already exists */ }
+                try {
+                    this.db.exec('ALTER TABLE runs ADD COLUMN artifacts_mode_kept TEXT');
+                }
+                catch { /* already exists */ }
+                try {
+                    (0, fs_1.chmodSync)(dbPath, 0o600);
+                }
+                catch {
+                    // Best effort on FSs with limited chmod support.
+                }
+                return;
+            }
+            catch {
+                // Fallback below.
+            }
+        }
+        this.useJsonFallback = true;
+        this.jsonPath = `${dbPath}.json`;
+        this.loadJson();
+        this.flushJson();
+    }
+    getPath() {
+        return this.dbPath;
+    }
+    createExperiment(input) {
+        const id = sanitizeString(input.id, 128) || makeExplorerExperimentId();
+        const name = sanitizeString(input.name, 240);
+        if (!name)
+            throw new Error('name is required');
+        const repoPath = sanitizeString(input.repo_path, 4096);
+        const baseRef = sanitizeString(input.base_ref, 256) || 'HEAD';
+        const evalCommand = sanitizeString(input.eval_command, 4000);
+        const evalTimeout = clampInt(input.eval_timeout_sec, 120, 5, 86_400);
+        if (!repoPath)
+            throw new Error('repo_path is required');
+        if (!evalCommand)
+            throw new Error('eval_command is required');
+        const created = {
+            id,
+            name,
+            created_at: nowIso(),
+            status: 'active',
+            repo_path: repoPath,
+            base_ref: baseRef,
+            eval_command: evalCommand,
+            eval_timeout_sec: evalTimeout,
+            policy_json: sanitizeJsonString(input.policy_json, '{}'),
+            constraints_json: sanitizeJsonString(input.constraints_json, '{}'),
+            prompt_preamble: sanitizeString(input.prompt_preamble, 20_000),
+        };
+        if (this.useJsonFallback) {
+            if (this.jsonStore.experiments.some((row) => row.id === id)) {
+                throw new Error(`Experiment id already exists: ${id}`);
+            }
+            this.jsonStore.experiments.push(created);
+            this.flushJson();
+            return created;
+        }
+        this.db.prepare(`INSERT INTO experiments (
+        id, name, created_at, status, repo_path, base_ref, eval_command,
+        eval_timeout_sec, policy_json, constraints_json, prompt_preamble
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(created.id, created.name, created.created_at, created.status, created.repo_path, created.base_ref, created.eval_command, created.eval_timeout_sec, created.policy_json, created.constraints_json, created.prompt_preamble);
+        return created;
+    }
+    listExperiments(limit = 100, offset = 0) {
+        const safeLimit = clampInt(limit, 100, 1, 1000);
+        const safeOffset = clampInt(offset, 0, 0, 100_000);
+        if (this.useJsonFallback) {
+            return [...this.jsonStore.experiments]
+                .sort((a, b) => b.created_at.localeCompare(a.created_at))
+                .slice(safeOffset, safeOffset + safeLimit)
+                .map((row) => ({ ...row }));
+        }
+        const rows = this.db
+            .prepare('SELECT * FROM experiments ORDER BY created_at DESC LIMIT ? OFFSET ?')
+            .all(safeLimit, safeOffset);
+        return rows.map(mapExperimentRow);
+    }
+    getExperiment(experimentId) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return null;
+        if (this.useJsonFallback) {
+            const row = this.jsonStore.experiments.find((x) => x.id === id);
+            return row ? { ...row } : null;
+        }
+        const row = this.db.prepare('SELECT * FROM experiments WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return mapExperimentRow(row);
+    }
+    setExperimentStatus(experimentId, status) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return false;
+        if (this.useJsonFallback) {
+            const idx = this.jsonStore.experiments.findIndex((row) => row.id === id);
+            if (idx < 0)
+                return false;
+            this.jsonStore.experiments[idx] = {
+                ...this.jsonStore.experiments[idx],
+                status,
+            };
+            this.flushJson();
+            return true;
+        }
+        const result = this.db.prepare('UPDATE experiments SET status = ? WHERE id = ?').run(status, id);
+        return result.changes > 0;
+    }
+    createRun(input) {
+        const id = sanitizeString(input.id, 128) || makeExplorerRunId();
+        const experimentId = sanitizeString(input.experiment_id, 128);
+        const parentCommitSha = sanitizeString(input.parent_commit_sha, 256);
+        const branchName = sanitizeString(input.branch_name, 256);
+        const worktreePath = sanitizeString(input.worktree_path, 4096);
+        const artifactDir = sanitizeString(input.artifact_dir, 4096);
+        if (!experimentId)
+            throw new Error('experiment_id is required');
+        if (!parentCommitSha)
+            throw new Error('parent_commit_sha is required');
+        if (!branchName)
+            throw new Error('branch_name is required');
+        if (!worktreePath)
+            throw new Error('worktree_path is required');
+        if (!artifactDir)
+            throw new Error('artifact_dir is required');
+        const created = {
+            id,
+            experiment_id: experimentId,
+            parent_run_id: input.parent_run_id ? sanitizeString(input.parent_run_id, 128) : null,
+            parent_commit_sha: parentCommitSha,
+            branch_name: branchName,
+            worktree_path: worktreePath,
+            commit_sha: null,
+            status: 'queued',
+            score: null,
+            metrics_json: null,
+            model: sanitizeString(input.model, 64) || 'stub',
+            summary_md: '',
+            created_at: nowIso(),
+            started_at: null,
+            finished_at: null,
+            artifact_dir: artifactDir,
+            worktree_pruned_at: null,
+            artifacts_pruned_at: null,
+            artifacts_mode_kept: null,
+        };
+        if (this.useJsonFallback) {
+            if (this.jsonStore.runs.some((row) => row.id === id)) {
+                throw new Error(`Run id already exists: ${id}`);
+            }
+            this.jsonStore.runs.push(created);
+            this.flushJson();
+            return created;
+        }
+        this.db.prepare(`INSERT INTO runs (
+        id, experiment_id, parent_run_id, parent_commit_sha, branch_name, worktree_path,
+        commit_sha, status, score, metrics_json, model, summary_md,
+        created_at, started_at, finished_at, artifact_dir,
+        worktree_pruned_at, artifacts_pruned_at, artifacts_mode_kept
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(created.id, created.experiment_id, created.parent_run_id, created.parent_commit_sha, created.branch_name, created.worktree_path, created.commit_sha, created.status, created.score, created.metrics_json, created.model, created.summary_md, created.created_at, created.started_at, created.finished_at, created.artifact_dir, created.worktree_pruned_at, created.artifacts_pruned_at, created.artifacts_mode_kept);
+        return created;
+    }
+    markRunStarted(runId) {
+        const id = sanitizeString(runId, 128);
+        if (!id)
+            return false;
+        const startedAt = nowIso();
+        if (this.useJsonFallback) {
+            const idx = this.jsonStore.runs.findIndex((row) => row.id === id);
+            if (idx < 0)
+                return false;
+            this.jsonStore.runs[idx] = {
+                ...this.jsonStore.runs[idx],
+                status: 'running',
+                started_at: startedAt,
+            };
+            this.flushJson();
+            return true;
+        }
+        const result = this.db
+            .prepare('UPDATE runs SET status = ?, started_at = ? WHERE id = ?')
+            .run('running', startedAt, id);
+        return result.changes > 0;
+    }
+    recordRunCommit(runId, commitSha) {
+        const id = sanitizeString(runId, 128);
+        const commit = sanitizeString(commitSha, 256);
+        if (!id || !commit)
+            return false;
+        if (this.useJsonFallback) {
+            const idx = this.jsonStore.runs.findIndex((row) => row.id === id);
+            if (idx < 0)
+                return false;
+            this.jsonStore.runs[idx] = {
+                ...this.jsonStore.runs[idx],
+                commit_sha: commit,
+                status: 'commit_ok',
+            };
+            this.flushJson();
+            return true;
+        }
+        const result = this.db
+            .prepare('UPDATE runs SET commit_sha = ?, status = ? WHERE id = ?')
+            .run(commit, 'commit_ok', id);
+        return result.changes > 0;
+    }
+    recordRunResult(runId, result) {
+        const id = sanitizeString(runId, 128);
+        if (!id)
+            return false;
+        const finishedAt = nowIso();
+        const summary = sanitizeString(result.summary_md, 20_000);
+        let metricsJson = null;
+        if (typeof result.metrics_json === 'string' && result.metrics_json.trim()) {
+            try {
+                metricsJson = JSON.stringify(JSON.parse(result.metrics_json));
+            }
+            catch {
+                metricsJson = null;
+            }
+        }
+        const normalizedScore = Number.isFinite(result.score)
+            ? Number(result.score)
+            : null;
+        if (this.useJsonFallback) {
+            const idx = this.jsonStore.runs.findIndex((row) => row.id === id);
+            if (idx < 0)
+                return false;
+            this.jsonStore.runs[idx] = {
+                ...this.jsonStore.runs[idx],
+                status: result.status,
+                score: normalizedScore,
+                metrics_json: metricsJson,
+                summary_md: summary,
+                finished_at: finishedAt,
+            };
+            this.flushJson();
+            return true;
+        }
+        const runResult = this.db
+            .prepare('UPDATE runs SET status = ?, score = ?, metrics_json = ?, summary_md = ?, finished_at = ? WHERE id = ?')
+            .run(result.status, normalizedScore, metricsJson, summary, finishedAt, id);
+        return runResult.changes > 0;
+    }
+    getRun(runId) {
+        const id = sanitizeString(runId, 128);
+        if (!id)
+            return null;
+        if (this.useJsonFallback) {
+            const row = this.jsonStore.runs.find((x) => x.id === id);
+            return row ? normalizeRunObject(row) : null;
+        }
+        const row = this.db.prepare('SELECT * FROM runs WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return mapRunRow(row);
+    }
+    listRuns(experimentId, opts) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return [];
+        const safeLimit = clampInt(opts?.limit, 50, 1, 1000);
+        const safeOffset = clampInt(opts?.offset, 0, 0, 100_000);
+        if (this.useJsonFallback) {
+            return this.jsonStore.runs
+                .filter((row) => row.experiment_id === id)
+                .sort((a, b) => b.created_at.localeCompare(a.created_at))
+                .slice(safeOffset, safeOffset + safeLimit)
+                .map((row) => normalizeRunObject(row));
+        }
+        const rows = this.db
+            .prepare('SELECT * FROM runs WHERE experiment_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?')
+            .all(id, safeLimit, safeOffset);
+        return rows.map(mapRunRow);
+    }
+    getBestRun(experimentId) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return null;
+        if (this.useJsonFallback) {
+            const rows = this.jsonStore.runs
+                .filter((row) => row.experiment_id === id && row.status === 'eval_ok' && row.score !== null)
+                .sort((a, b) => {
+                const scoreDelta = b.score - a.score;
+                if (scoreDelta !== 0)
+                    return scoreDelta;
+                return b.created_at.localeCompare(a.created_at);
+            });
+            return rows[0] ? normalizeRunObject(rows[0]) : null;
+        }
+        const row = this.db
+            .prepare(`SELECT * FROM runs
+         WHERE experiment_id = ? AND status = 'eval_ok' AND score IS NOT NULL
+         ORDER BY score DESC, created_at DESC
+         LIMIT 1`)
+            .get(id);
+        if (!row)
+            return null;
+        return mapRunRow(row);
+    }
+    hasActiveRun(experimentId) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return false;
+        if (this.useJsonFallback) {
+            return this.jsonStore.runs.some((row) => row.experiment_id === id && ACTIVE_RUN_STATES.has(row.status));
+        }
+        const row = this.db
+            .prepare(`SELECT COUNT(*) as count FROM runs
+         WHERE experiment_id = ? AND status IN ('queued', 'running', 'commit_ok')`)
+            .get(id);
+        return Number(row?.count || 0) > 0;
+    }
+    listActiveRuns(experimentId) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return [];
+        if (this.useJsonFallback) {
+            return this.jsonStore.runs
+                .filter((row) => row.experiment_id === id && ACTIVE_RUN_STATES.has(row.status))
+                .sort((a, b) => a.created_at.localeCompare(b.created_at))
+                .map((row) => normalizeRunObject(row));
+        }
+        const rows = this.db
+            .prepare(`SELECT * FROM runs
+         WHERE experiment_id = ? AND status IN ('queued', 'running', 'commit_ok')
+         ORDER BY created_at ASC`)
+            .all(id);
+        return rows.map(mapRunRow);
+    }
+    getRunCount(experimentId) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return 0;
+        if (this.useJsonFallback) {
+            let count = 0;
+            for (const run of this.jsonStore.runs) {
+                if (run.experiment_id === id)
+                    count++;
+            }
+            return count;
+        }
+        const row = this.db.prepare('SELECT COUNT(*) as count FROM runs WHERE experiment_id = ?').get(id);
+        return Number(row?.count || 0);
+    }
+    getRunStatusCounts(experimentId) {
+        const id = sanitizeString(experimentId, 128);
+        const counts = initStatusCounts();
+        if (!id)
+            return counts;
+        if (this.useJsonFallback) {
+            for (const run of this.jsonStore.runs) {
+                if (run.experiment_id !== id)
+                    continue;
+                counts[run.status] = (counts[run.status] || 0) + 1;
+            }
+            return counts;
+        }
+        const rows = this.db
+            .prepare('SELECT status, COUNT(*) as count FROM runs WHERE experiment_id = ? GROUP BY status')
+            .all(id);
+        for (const row of rows) {
+            const status = String(row.status);
+            if (!RUN_STATUS_VALUES.includes(status))
+                continue;
+            counts[status] = Number(row.count || 0);
+        }
+        return counts;
+    }
+    getLatestRun(experimentId) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return null;
+        if (this.useJsonFallback) {
+            const row = this.jsonStore.runs
+                .filter((run) => run.experiment_id === id)
+                .sort((a, b) => b.created_at.localeCompare(a.created_at) || b.id.localeCompare(a.id))[0];
+            return row ? normalizeRunObject(row) : null;
+        }
+        const row = this.db
+            .prepare('SELECT * FROM runs WHERE experiment_id = ? ORDER BY created_at DESC, id DESC LIMIT 1')
+            .get(id);
+        if (!row)
+            return null;
+        return mapRunRow(row);
+    }
+    getExperimentOverview(experimentId) {
+        const experiment = this.getExperiment(experimentId);
+        if (!experiment)
+            return null;
+        const retentionPolicy = this.getRetentionPolicy(experimentId);
+        const runCount = this.getRunCount(experimentId);
+        const activeRuns = this.listActiveRuns(experimentId);
+        const statusCounts = this.getRunStatusCounts(experimentId);
+        const bestRun = this.getBestRun(experimentId);
+        const latestRun = this.getLatestRun(experimentId);
+        return {
+            experiment,
+            retention_policy: retentionPolicy,
+            run_count: runCount,
+            active_run_count: activeRuns.length,
+            status_counts: statusCounts,
+            best_run: bestRun,
+            latest_run: latestRun,
+        };
+    }
+    getRetentionPolicy(experimentId) {
+        const experiment = this.getExperiment(experimentId);
+        if (!experiment)
+            return (0, explorer_retention_js_1.defaultRetentionPolicy)();
+        let constraints = {};
+        try {
+            const parsed = JSON.parse(experiment.constraints_json || '{}');
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                constraints = parsed;
+            }
+        }
+        catch {
+            constraints = {};
+        }
+        return (0, explorer_retention_js_1.normalizeRetentionPolicy)(constraints.retention);
+    }
+    setRetentionPolicy(experimentId, retention) {
+        const experiment = this.getExperiment(experimentId);
+        if (!experiment)
+            return false;
+        let constraints = {};
+        try {
+            const parsed = JSON.parse(experiment.constraints_json || '{}');
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                constraints = parsed;
+            }
+        }
+        catch {
+            constraints = {};
+        }
+        constraints.retention = (0, explorer_retention_js_1.normalizeRetentionPolicy)(retention);
+        const nextJson = JSON.stringify(constraints);
+        if (this.useJsonFallback) {
+            const idx = this.jsonStore.experiments.findIndex((row) => row.id === experiment.id);
+            if (idx < 0)
+                return false;
+            this.jsonStore.experiments[idx] = {
+                ...this.jsonStore.experiments[idx],
+                constraints_json: nextJson,
+            };
+            this.flushJson();
+            return true;
+        }
+        const result = this.db
+            .prepare('UPDATE experiments SET constraints_json = ? WHERE id = ?')
+            .run(nextJson, experiment.id);
+        return result.changes > 0;
+    }
+    setRunWorktreePruned(runId, prunedAt = nowIso()) {
+        const id = sanitizeString(runId, 128);
+        if (!id)
+            return false;
+        if (this.useJsonFallback) {
+            const idx = this.jsonStore.runs.findIndex((row) => row.id === id);
+            if (idx < 0)
+                return false;
+            this.jsonStore.runs[idx] = {
+                ...this.jsonStore.runs[idx],
+                worktree_pruned_at: prunedAt,
+            };
+            this.flushJson();
+            return true;
+        }
+        const result = this.db
+            .prepare('UPDATE runs SET worktree_pruned_at = ? WHERE id = ?')
+            .run(prunedAt, id);
+        return result.changes > 0;
+    }
+    setRunArtifactsPruned(runId, modeKept, prunedAt = nowIso()) {
+        const id = sanitizeString(runId, 128);
+        if (!id)
+            return false;
+        if (this.useJsonFallback) {
+            const idx = this.jsonStore.runs.findIndex((row) => row.id === id);
+            if (idx < 0)
+                return false;
+            this.jsonStore.runs[idx] = {
+                ...this.jsonStore.runs[idx],
+                artifacts_pruned_at: prunedAt,
+                artifacts_mode_kept: modeKept,
+            };
+            this.flushJson();
+            return true;
+        }
+        const result = this.db
+            .prepare('UPDATE runs SET artifacts_pruned_at = ?, artifacts_mode_kept = ? WHERE id = ?')
+            .run(prunedAt, modeKept, id);
+        return result.changes > 0;
+    }
+    listFinishedRuns(experimentId) {
+        const id = sanitizeString(experimentId, 128);
+        if (!id)
+            return [];
+        const finishedStates = new Set([
+            'eval_ok',
+            'failed_build',
+            'failed_eval',
+            'timeout',
+            'invalid_output',
+        ]);
+        if (this.useJsonFallback) {
+            return this.jsonStore.runs
+                .filter((run) => run.experiment_id === id && finishedStates.has(run.status))
+                .map((run) => normalizeRunObject(run))
+                .sort((a, b) => (b.finished_at || '').localeCompare(a.finished_at || '') || b.created_at.localeCompare(a.created_at));
+        }
+        const rows = this.db
+            .prepare(`SELECT * FROM runs
+         WHERE experiment_id = ? AND status IN ('eval_ok', 'failed_build', 'failed_eval', 'timeout', 'invalid_output')
+         ORDER BY finished_at DESC, created_at DESC`)
+            .all(id);
+        return rows.map(mapRunRow);
+    }
+    createEvent(experimentId, type, payload, runId) {
+        const expId = sanitizeString(experimentId, 128);
+        if (!expId)
+            throw new Error('experiment_id is required');
+        const event = {
+            id: makeEventId(),
+            experiment_id: expId,
+            run_id: runId ? sanitizeString(runId, 128) : null,
+            type,
+            payload_json: JSON.stringify(payload || {}),
+            created_at: nowIso(),
+        };
+        if (this.useJsonFallback) {
+            this.jsonStore.events.push(event);
+            this.flushJson();
+            return event;
+        }
+        this.db.prepare('INSERT INTO events (id, experiment_id, run_id, type, payload_json, created_at) VALUES (?, ?, ?, ?, ?, ?)').run(event.id, event.experiment_id, event.run_id, event.type, event.payload_json, event.created_at);
+        return event;
+    }
+    listEvents(experimentId, opts) {
+        const expId = sanitizeString(experimentId, 128);
+        if (!expId)
+            return [];
+        const safeLimit = clampInt(opts?.limit, 100, 1, 1000);
+        const safeOffset = clampInt(opts?.offset, 0, 0, 100_000);
+        if (this.useJsonFallback) {
+            return this.jsonStore.events
+                .filter((row) => row.experiment_id === expId)
+                .sort((a, b) => b.created_at.localeCompare(a.created_at))
+                .slice(safeOffset, safeOffset + safeLimit)
+                .map((row) => ({ ...row }));
+        }
+        const rows = this.db
+            .prepare('SELECT * FROM events WHERE experiment_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?')
+            .all(expId, safeLimit, safeOffset);
+        return rows.map(mapEventRow);
+    }
+    getLeaderboard(experimentId, topK = 10) {
+        const expId = sanitizeString(experimentId, 128);
+        if (!expId)
+            return [];
+        const safeTopK = clampInt(topK, 10, 1, 500);
+        if (this.useJsonFallback) {
+            return this.jsonStore.runs
+                .filter((row) => row.experiment_id === expId && row.status === 'eval_ok' && row.score !== null)
+                .sort((a, b) => {
+                const scoreDelta = b.score - a.score;
+                if (scoreDelta !== 0)
+                    return scoreDelta;
+                return b.created_at.localeCompare(a.created_at);
+            })
+                .slice(0, safeTopK)
+                .map((row) => ({
+                run_id: row.id,
+                score: row.score,
+                status: row.status,
+                commit_sha: row.commit_sha,
+                created_at: row.created_at,
+            }));
+        }
+        const rows = this.db
+            .prepare(`SELECT id as run_id, score, status, commit_sha, created_at
+         FROM runs
+         WHERE experiment_id = ? AND status = 'eval_ok' AND score IS NOT NULL
+         ORDER BY score DESC, created_at DESC
+         LIMIT ?`)
+            .all(expId, safeTopK);
+        return rows.map((row) => ({
+            run_id: String(row.run_id),
+            score: Number(row.score),
+            status: row.status,
+            commit_sha: row.commit_sha ? String(row.commit_sha) : null,
+            created_at: String(row.created_at),
+        }));
+    }
+    getTree(experimentId, mode = 'best_path') {
+        const expId = sanitizeString(experimentId, 128);
+        if (!expId) {
+            return { mode, nodes: [], edges: [] };
+        }
+        const allRuns = this.getAllRunsForTree(expId);
+        if (allRuns.length === 0) {
+            return { mode, nodes: [], edges: [] };
+        }
+        if (mode === 'full') {
+            const nodes = allRuns.map((run) => ({
+                run_id: run.id,
+                parent_run_id: run.parent_run_id,
+                score: run.score,
+                status: run.status,
+                commit_sha: run.commit_sha,
+                created_at: run.created_at,
+            }));
+            const edges = allRuns
+                .filter((run) => !!run.parent_run_id)
+                .map((run) => ({ from: run.parent_run_id, to: run.id }));
+            return { mode, nodes, edges };
+        }
+        const best = this.getBestRun(expId);
+        if (!best) {
+            return { mode, nodes: [], edges: [] };
+        }
+        const byId = new Map(allRuns.map((run) => [run.id, run]));
+        const path = [];
+        const visited = new Set();
+        let cursor = best;
+        while (cursor && !visited.has(cursor.id)) {
+            visited.add(cursor.id);
+            path.push(cursor);
+            if (!cursor.parent_run_id)
+                break;
+            cursor = byId.get(cursor.parent_run_id);
+        }
+        path.reverse();
+        const nodes = path.map((run) => ({
+            run_id: run.id,
+            parent_run_id: run.parent_run_id,
+            score: run.score,
+            status: run.status,
+            commit_sha: run.commit_sha,
+            created_at: run.created_at,
+        }));
+        const edges = [];
+        for (let i = 1; i < path.length; i++) {
+            edges.push({ from: path[i - 1].id, to: path[i].id });
+        }
+        return { mode, nodes, edges };
+    }
+    close() {
+        if (this.useJsonFallback) {
+            this.flushJson();
+            return;
+        }
+        this.db.close();
+    }
+    getAllRunsForTree(experimentId) {
+        if (this.useJsonFallback) {
+            return this.jsonStore.runs
+                .filter((row) => row.experiment_id === experimentId)
+                .sort((a, b) => a.created_at.localeCompare(b.created_at))
+                .map((row) => normalizeRunObject(row));
+        }
+        const rows = this.db
+            .prepare('SELECT * FROM runs WHERE experiment_id = ? ORDER BY created_at ASC')
+            .all(experimentId);
+        return rows.map(mapRunRow);
+    }
+    loadJson() {
+        if (!this.jsonPath || !(0, fs_1.existsSync)(this.jsonPath))
+            return;
+        try {
+            const parsed = JSON.parse((0, fs_1.readFileSync)(this.jsonPath, 'utf-8'));
+            const experiments = Array.isArray(parsed?.experiments) ? parsed.experiments : [];
+            const runs = Array.isArray(parsed?.runs) ? parsed.runs : [];
+            const events = Array.isArray(parsed?.events) ? parsed.events : [];
+            this.jsonStore = {
+                version: 1,
+                experiments,
+                runs,
+                events,
+            };
+        }
+        catch {
+            this.jsonStore = {
+                version: 1,
+                experiments: [],
+                runs: [],
+                events: [],
+            };
+        }
+    }
+    flushJson() {
+        if (!this.jsonPath)
+            return;
+        try {
+            (0, fs_1.writeFileSync)(this.jsonPath, JSON.stringify(this.jsonStore, null, 2) + '\n', {
+                encoding: 'utf-8',
+                mode: 0o600,
+            });
+            try {
+                (0, fs_1.chmodSync)(this.jsonPath, 0o600);
+            }
+            catch {
+                // Best effort only.
+            }
+        }
+        catch {
+            // Best effort; continue in-memory.
+        }
+    }
+}
+exports.ExplorerStore = ExplorerStore;
+//# sourceMappingURL=explorer-store.js.map