@agentdeck/bridge 0.1.0 → 0.2.1

package/dist/apme/store.js

@@ -0,0 +1,911 @@
+/**
+ * APME SQLite store — wraps better-sqlite3 with a tiny DAO.
+ *
+ * better-sqlite3 is an optional native dep; if it fails to load (e.g. CI without
+ * build tooling), we fall back to a no-op store so the bridge still boots.
+ * Callers should check `store.enabled` before assuming persistence.
+ */
+import { existsSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+import { createRequire } from 'module';
+import { debug } from '../logger.js';
+// better-sqlite3 is an optional native dep. Resolving via createRequire from
+// this file's URL lets Node walk `bridge/node_modules/*` via the pnpm
+// workspace symlinks, regardless of the process CWD (vitest runs from the
+// repo root, where the symlink doesn't exist).
+const require = createRequire(import.meta.url);
+// ─── Schema ────────────────────────────────────────────────────────────────────
+const DDL = `
+CREATE TABLE IF NOT EXISTS runs (
+  id            TEXT PRIMARY KEY,
+  session_id    TEXT NOT NULL,
+  agent_type    TEXT NOT NULL,
+  model_id      TEXT,
+  project_name  TEXT,
+  project_path  TEXT,
+  task_prompt   TEXT,
+  started_at    INTEGER NOT NULL,
+  ended_at      INTEGER,
+  input_tokens  INTEGER,
+  output_tokens INTEGER,
+  cost_usd      REAL,
+  exit_code     INTEGER,
+  git_before    TEXT,
+  git_after     TEXT,
+  hw_profile    TEXT,
+  task_signals  TEXT,
+  task_category TEXT,
+  task_category_source TEXT DEFAULT 'auto',
+  outcome       TEXT,
+  outcome_confidence TEXT,
+  efficiency_json TEXT,
+  composite_score REAL
+);
+
+CREATE TABLE IF NOT EXISTS steps (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id     TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  ts         INTEGER NOT NULL,
+  kind       TEXT NOT NULL,
+  tool_name  TEXT,
+  payload    TEXT
+);
+
+CREATE TABLE IF NOT EXISTS turns (
+  id          TEXT PRIMARY KEY,
+  run_id      TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  task_id     TEXT,
+  turn_index  INTEGER NOT NULL,
+  prompt      TEXT,
+  response    TEXT,
+  started_at  INTEGER NOT NULL,
+  ended_at    INTEGER,
+  tool_calls  INTEGER DEFAULT 0,
+  files_modified INTEGER DEFAULT 0,
+  files_created INTEGER DEFAULT 0,
+  git_before  TEXT,
+  git_after   TEXT,
+  task_category TEXT,
+  outcome     TEXT,
+  composite_score REAL,
+  efficiency_json TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_turns_run ON turns(run_id);
+CREATE INDEX IF NOT EXISTS idx_turns_task ON turns(task_id);
+
+CREATE TABLE IF NOT EXISTS tasks (
+  id               TEXT PRIMARY KEY,
+  run_id           TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  task_index       INTEGER NOT NULL,
+  boundary_signal  TEXT NOT NULL,
+  started_at       INTEGER NOT NULL,
+  ended_at         INTEGER,
+  first_turn_index INTEGER,
+  last_turn_index  INTEGER,
+  summary          TEXT,
+  outcome          TEXT,
+  composite_score  REAL,
+  task_category    TEXT,
+  notes_json       TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_run ON tasks(run_id);
+
+CREATE TABLE IF NOT EXISTS artifacts (
+  id        INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id    TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  kind      TEXT NOT NULL,
+  path      TEXT NOT NULL,
+  sha256    TEXT,
+  bytes     INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS evals (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id      TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  turn_id     TEXT REFERENCES turns(id) ON DELETE CASCADE,
+  task_id     TEXT REFERENCES tasks(id) ON DELETE CASCADE,
+  layer       TEXT NOT NULL,
+  metric      TEXT NOT NULL,
+  score       REAL,
+  raw         TEXT,
+  rubric_ver  INTEGER,
+  judge_model TEXT,
+  created_at  INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS rubrics (
+  version     INTEGER PRIMARY KEY,
+  purpose     TEXT NOT NULL,
+  prompt      TEXT NOT NULL,
+  weights     TEXT NOT NULL,
+  created_at  INTEGER NOT NULL,
+  parent_ver  INTEGER,
+  notes       TEXT
+);
+
+CREATE TABLE IF NOT EXISTS vibe_feedback (
+  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+  run_id     TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  verdict    TEXT NOT NULL,
+  note       TEXT,
+  ts         INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_runs_model ON runs(model_id);
+CREATE INDEX IF NOT EXISTS idx_runs_agent ON runs(agent_type);
+CREATE INDEX IF NOT EXISTS idx_runs_started ON runs(started_at);
+CREATE INDEX IF NOT EXISTS idx_evals_run ON evals(run_id);
+CREATE INDEX IF NOT EXISTS idx_steps_run ON steps(run_id);
+
+-- Pre-aggregate per-run eval metrics to avoid inflating cost_usd when
+-- multiple eval rows exist per run (e.g. 3 deterministic + 5 judge axes).
+CREATE VIEW IF NOT EXISTS v_run_metrics AS
+SELECT
+  run_id,
+  MAX(CASE WHEN metric='overall' AND layer='llm_judge' THEN score END) AS overall,
+  MAX(CASE WHEN metric='tests_pass' AND layer='deterministic' THEN score END) AS tests_pass
+FROM evals
+GROUP BY run_id;
+
+CREATE VIEW IF NOT EXISTS v_model_scorecard AS
+SELECT
+  r.agent_type AS agent_type,
+  COALESCE(r.model_id, 'unknown') AS model_id,
+  COUNT(*) AS runs,
+  AVG(m.overall) AS avg_overall,
+  AVG(m.tests_pass) AS avg_tests_pass,
+  SUM(r.cost_usd) AS total_cost,
+  CASE
+    WHEN AVG(m.overall) > 0
+    THEN SUM(r.cost_usd) / AVG(m.overall)
+    ELSE NULL
+  END AS cost_per_quality
+FROM runs r
+LEFT JOIN v_run_metrics m ON m.run_id = r.id
+GROUP BY r.agent_type, r.model_id;
+
+CREATE VIEW IF NOT EXISTS v_category_scorecard AS
+SELECT
+  r.task_category AS task_category,
+  COALESCE(r.model_id, 'unknown') AS model_id,
+  COUNT(*) AS runs,
+  AVG(m.overall) AS avg_overall,
+  AVG(m.tests_pass) AS avg_tests_pass,
+  SUM(r.cost_usd) AS total_cost
+FROM runs r
+LEFT JOIN v_run_metrics m ON m.run_id = r.id
+WHERE r.task_category IS NOT NULL AND r.task_category != 'unknown'
+GROUP BY r.task_category, r.model_id;
+`;
+// ─── Default rubric v1 (seeded on first boot) ──────────────────────────────────
+const DEFAULT_RUBRIC_V1 = {
+    version: 1,
+    purpose: 'general',
+    prompt: `You are a senior engineer evaluating whether an AI coding agent completed the user's task.
+
+Given the task prompt and the git diff produced, evaluate the agent's contribution.
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- task_completion: Did the agent actually do what the user asked? A perfect score means the task prompt's request was fully addressed in the diff. A zero means nothing relevant was done.
+- code_quality: Is the code correct, safe, and maintainable? Check for bugs, missing error handling, security issues, and dead code.
+- efficiency: Did the agent make minimal, focused changes? Penalize unrelated modifications, unnecessary refactoring, or verbose solutions to simple problems.
+- overall: Your holistic judgment. Weight task_completion most heavily — a session that completes the task with decent quality is better than a perfect-style session that misses the point.
+
+Important: Explain your reasoning with specific references to what was done and what was missed. List concrete items with checkmarks (done) and crosses (missed). This reasoning will be shown to the user for verification.
+
+Return strict JSON: {"task_completion":N,"code_quality":N,"efficiency":N,"overall":N,"reasoning":"...", "done":["item1","item2"], "missed":["item1"]}.`,
+    weights: JSON.stringify({ task_completion: 0.5, code_quality: 0.3, efficiency: 0.2 }),
+    notes: 'seeded default',
+};
+// ─── Category-specific rubrics ──────────────────────────────────────────────
+// Each category has evaluation axes suited to its domain.
+// The judge selects the rubric matching the run's taskCategory.
+// Falls back to 'general' if no category-specific rubric exists.
+const CATEGORY_RUBRICS = {
+    conversation: {
+        purpose: 'conversation',
+        prompt: `You are evaluating an AI assistant's response to a conversational query or question.
+The user asked a question and the agent responded. Evaluate the quality of the response.
+
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- accuracy: Is the answer factually correct? For math/logic questions, is the result right?
+- helpfulness: Does the response address what the user actually wanted? Is it complete?
+- conciseness: Is the response appropriately sized? Not too verbose, not too terse.
+- overall: Holistic judgment. An accurate, helpful response scores high even if brief.
+
+Return strict JSON: {"accuracy":N,"helpfulness":N,"conciseness":N,"overall":N,"reasoning":"...", "done":["item1"], "missed":["item1"]}.`,
+        weights: JSON.stringify({ accuracy: 0.5, helpfulness: 0.3, conciseness: 0.2 }),
+        notes: 'conversation/Q&A evaluation',
+    },
+    planning: {
+        purpose: 'planning',
+        prompt: `You are evaluating an AI agent's planning session. The user asked the agent to plan an approach for a task.
+
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- completeness: Does the plan cover all aspects of the request? Are edge cases considered?
+- feasibility: Is the plan technically sound and implementable? Are the proposed steps realistic?
+- clarity: Is the plan well-structured, easy to follow, with clear priorities?
+- overall: Holistic judgment. A thorough, actionable plan scores high.
+
+Return strict JSON: {"completeness":N,"feasibility":N,"clarity":N,"overall":N,"reasoning":"...", "done":["item1"], "missed":["item1"]}.`,
+        weights: JSON.stringify({ completeness: 0.4, feasibility: 0.35, clarity: 0.25 }),
+        notes: 'planning/architecture evaluation',
+    },
+    research: {
+        purpose: 'research',
+        prompt: `You are evaluating an AI agent's research session. The user asked the agent to investigate, search, or gather information.
+
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- thoroughness: Did the agent search broadly enough? Were relevant files, docs, or sources explored?
+- relevance: Is the information found actually relevant to the user's question?
+- synthesis: Did the agent synthesize findings into a clear answer or summary?
+- overall: Holistic judgment. Research that finds the right answer efficiently scores high.
+
+Return strict JSON: {"thoroughness":N,"relevance":N,"synthesis":N,"overall":N,"reasoning":"...", "done":["item1"], "missed":["item1"]}.`,
+        weights: JSON.stringify({ thoroughness: 0.3, relevance: 0.4, synthesis: 0.3 }),
+        notes: 'research/investigation evaluation',
+    },
+    debugging: {
+        purpose: 'debugging',
+        prompt: `You are evaluating an AI agent's debugging session. The user reported a bug and the agent investigated and attempted to fix it.
+
+Given the task prompt and the git diff produced, evaluate the debugging effort.
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- diagnosis: Did the agent correctly identify the root cause? Not just symptoms but the actual bug?
+- fix_quality: Is the fix correct, minimal, and safe? Does it avoid introducing new bugs?
+- verification: Did the agent verify the fix (run tests, check edge cases)?
+- overall: Holistic judgment. A correct diagnosis + clean fix scores high.
+
+Return strict JSON: {"diagnosis":N,"fix_quality":N,"verification":N,"overall":N,"reasoning":"...", "done":["item1"], "missed":["item1"]}.`,
+        weights: JSON.stringify({ diagnosis: 0.35, fix_quality: 0.4, verification: 0.25 }),
+        notes: 'debugging evaluation',
+    },
+    refactoring: {
+        purpose: 'refactoring',
+        prompt: `You are evaluating an AI agent's refactoring session. The user asked the agent to restructure or improve existing code.
+
+Given the task prompt and the git diff produced, evaluate the refactoring.
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- safety: Does the refactoring preserve existing behavior? No regressions introduced?
+- improvement: Is the resulting code genuinely better? Cleaner, more maintainable, less duplication?
+- scope: Was the refactoring appropriately scoped? Not too aggressive, not too timid?
+- overall: Holistic judgment. Safe refactoring that clearly improves the code scores high.
+
+Return strict JSON: {"safety":N,"improvement":N,"scope":N,"overall":N,"reasoning":"...", "done":["item1"], "missed":["item1"]}.`,
+        weights: JSON.stringify({ safety: 0.4, improvement: 0.35, scope: 0.25 }),
+        notes: 'refactoring evaluation',
+    },
+    review: {
+        purpose: 'review',
+        prompt: `You are evaluating an AI agent's code review session. The user asked the agent to review code for issues.
+
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- coverage: Did the review examine all relevant areas? Were critical paths checked?
+- insight: Did the review catch real issues (not just style nits)? Were suggestions actionable?
+- accuracy: Are the identified issues real problems? Low false positive rate?
+- overall: Holistic judgment. A review that catches important bugs/issues scores high.
+
+Return strict JSON: {"coverage":N,"insight":N,"accuracy":N,"overall":N,"reasoning":"...", "done":["item1"], "missed":["item1"]}.`,
+        weights: JSON.stringify({ coverage: 0.3, insight: 0.4, accuracy: 0.3 }),
+        notes: 'code review evaluation',
+    },
+    ops: {
+        purpose: 'ops',
+        prompt: `You are evaluating an AI agent's ops/DevOps session. The user asked the agent to perform operational tasks (git, CI/CD, deployment, configuration).
+
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- correctness: Did the operations complete successfully? Were commands appropriate?
+- safety: Were destructive operations handled carefully? Were backups/confirmations used?
+- completeness: Were all requested steps performed? Nothing left half-done?
+- overall: Holistic judgment. Correct, safe ops that complete the task score high.
+
+Return strict JSON: {"correctness":N,"safety":N,"completeness":N,"overall":N,"reasoning":"...", "done":["item1"], "missed":["item1"]}.`,
+        weights: JSON.stringify({ correctness: 0.4, safety: 0.35, completeness: 0.25 }),
+        notes: 'ops/DevOps evaluation',
+    },
+    task_rollup: {
+        purpose: 'task_rollup',
+        prompt: `You are evaluating a multi-turn AI agent task that the agent itself has just signaled as complete
+(for example: every TodoWrite item was marked \`completed\`, or the user issued \`/clear\` to reset context).
+
+You will be given the full sequence of turns (user prompt → agent response) that make up this task.
+Produce a concise rollup: a single-sentence summary plus axis scores.
+
+Score each axis as a float in [0,1] where 0=failed and 1=excellent.
+
+Axes:
+- completion: Did the agent actually finish what the task was about? A high score means the task was
+  delivered end-to-end; low if large pieces were skipped or declared done without evidence.
+- coherence: Did the turns build on each other toward a single goal? Penalize incoherent jumps,
+  redundant re-planning, or lost context between turns.
+- efficiency: Were the turns appropriately scoped? Penalize unnecessary back-and-forth, repeated
+  tool calls with the same inputs, or churn. Reward focused, decisive progress.
+- overall: Holistic judgment. Weight completion most heavily — an efficient, coherent task that
+  never actually finishes is worse than a slightly messier task that delivered.
+
+Summary guidance: one sentence, ≤ 140 characters, past tense, describing what the task accomplished.
+Start with a verb (e.g. "Added", "Fixed", "Investigated", "Refactored"). No hedging.
+
+Return strict JSON exactly:
+{"summary":"<one sentence>","completion":N,"coherence":N,"efficiency":N,"overall":N,"reasoning":"...","done":["item1"],"missed":["item1"]}.`,
+        weights: JSON.stringify({ completion: 0.5, coherence: 0.25, efficiency: 0.25 }),
+        notes: 'task-unit rollup (TodoWrite all-completed / /clear / session_end)',
+    },
+};
+export class ApmeStore {
+    db = null;
+    enabled = false;
+    dbPath;
+    constructor(dbPath) {
+        const dataDir = process.env.AGENTDECK_DATA_DIR || join(homedir(), '.agentdeck');
+        this.dbPath = dbPath ?? join(dataDir, 'apme.sqlite');
+    }
+    /** Attempt to open the DB. Returns false if better-sqlite3 is unavailable. */
+    async init() {
+        try {
+            let Ctor = null;
+            try {
+                Ctor = require('better-sqlite3');
+            }
+            catch {
+                debug('APME', 'better-sqlite3 not installed — APME store disabled');
+                return false;
+            }
+            const dir = dirname(this.dbPath);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            this.db = new Ctor(this.dbPath);
+            this.db.pragma('journal_mode = WAL');
+            this.db.pragma('foreign_keys = ON');
+            this.db.exec(DDL);
+            this.migrateSchema();
+            this.seedDefaultRubric();
+            this.enabled = true;
+            debug('APME', `store ready at ${this.dbPath}`);
+            return true;
+        }
+        catch (err) {
+            debug('APME', `store init failed: ${String(err)}`);
+            return false;
+        }
+    }
+    close() {
+        try {
+            this.db?.close();
+        }
+        catch { /* ignore */ }
+        this.db = null;
+        this.enabled = false;
+    }
+    /** Add columns that may be missing from databases created before this version. */
+    migrateSchema() {
+        if (!this.db)
+            return;
+        const cols = this.db.prepare("PRAGMA table_info(runs)").all().map(c => c.name);
+        const migrations = [
+            ['task_signals', 'ALTER TABLE runs ADD COLUMN task_signals TEXT'],
+            ['task_category', 'ALTER TABLE runs ADD COLUMN task_category TEXT'],
+            ['task_category_source', "ALTER TABLE runs ADD COLUMN task_category_source TEXT DEFAULT 'auto'"],
+            ['turn_id', 'ALTER TABLE evals ADD COLUMN turn_id TEXT REFERENCES turns(id) ON DELETE CASCADE'],
+            ['turn_response', 'ALTER TABLE turns ADD COLUMN response TEXT'],
+            ['outcome', 'ALTER TABLE runs ADD COLUMN outcome TEXT'],
+            ['outcome_confidence', 'ALTER TABLE runs ADD COLUMN outcome_confidence TEXT'],
+            ['efficiency_json', 'ALTER TABLE runs ADD COLUMN efficiency_json TEXT'],
+            ['composite_score', 'ALTER TABLE runs ADD COLUMN composite_score REAL'],
+        ];
+        for (const [col, sql] of migrations) {
+            if (!cols.includes(col)) {
+                try {
+                    this.db.exec(sql);
+                }
+                catch { /* column may already exist from partial migration */ }
+            }
+        }
+        // Tasks table — created via CREATE TABLE IF NOT EXISTS above, but older
+        // DBs need ALTER for turns.task_id and evals.task_id.
+        const turnCols = this.db.prepare("PRAGMA table_info(turns)").all().map(c => c.name);
+        if (!turnCols.includes('task_id')) {
+            try {
+                this.db.exec('ALTER TABLE turns ADD COLUMN task_id TEXT');
+            }
+            catch { /* ignore */ }
+            try {
+                this.db.exec('CREATE INDEX IF NOT EXISTS idx_turns_task ON turns(task_id)');
+            }
+            catch { /* ignore */ }
+        }
+        const evalCols = this.db.prepare("PRAGMA table_info(evals)").all().map(c => c.name);
+        if (!evalCols.includes('task_id')) {
+            try {
+                this.db.exec('ALTER TABLE evals ADD COLUMN task_id TEXT REFERENCES tasks(id) ON DELETE CASCADE');
+            }
+            catch { /* ignore */ }
+        }
+    }
+    seedDefaultRubric() {
+        if (!this.db)
+            return;
+        // Seed general rubric if none exists
+        const row = this.db.prepare('SELECT COUNT(*) AS n FROM rubrics WHERE purpose = ?').get('general');
+        if (row.n > 0) {
+            // Seed category rubrics that don't exist yet (idempotent)
+            for (const [, rubric] of Object.entries(CATEGORY_RUBRICS)) {
+                const exists = this.db.prepare('SELECT COUNT(*) AS n FROM rubrics WHERE purpose = ?').get(rubric.purpose);
+                if (exists.n === 0) {
+                    this.db.prepare(`INSERT INTO rubrics (purpose, prompt, weights, created_at, parent_ver, notes) VALUES (?, ?, ?, ?, NULL, ?)`).run(rubric.purpose, rubric.prompt, rubric.weights, Date.now(), rubric.notes);
+                }
+            }
+            return;
+        }
+        this.db.prepare(`INSERT INTO rubrics (version, purpose, prompt, weights, created_at, parent_ver, notes)
+       VALUES (?, ?, ?, ?, ?, NULL, ?)`).run(DEFAULT_RUBRIC_V1.version, DEFAULT_RUBRIC_V1.purpose, DEFAULT_RUBRIC_V1.prompt, DEFAULT_RUBRIC_V1.weights, Date.now(), DEFAULT_RUBRIC_V1.notes);
+        // Seed category-specific rubrics (version auto-assigned by SQLite rowid)
+        for (const [, rubric] of Object.entries(CATEGORY_RUBRICS)) {
+            this.db.prepare(`INSERT INTO rubrics (purpose, prompt, weights, created_at, parent_ver, notes) VALUES (?, ?, ?, ?, NULL, ?)`).run(rubric.purpose, rubric.prompt, rubric.weights, Date.now(), rubric.notes);
+        }
+    }
+    // ─── Runs ────────────────────────────────────────────────────────────────────
+    insertRun(row) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO runs
+        (id, session_id, agent_type, model_id, project_name, project_path, task_prompt,
+         started_at, ended_at, input_tokens, output_tokens, cost_usd, exit_code,
+         git_before, git_after, hw_profile)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.sessionId, row.agentType, row.modelId ?? null, row.projectName ?? null, row.projectPath ?? null, row.taskPrompt ?? null, row.startedAt, row.endedAt ?? null, row.inputTokens ?? null, row.outputTokens ?? null, row.costUsd ?? null, row.exitCode ?? null, row.gitBefore ?? null, row.gitAfter ?? null, row.hwProfile ?? null);
+    }
+    updateRun(id, patch) {
+        if (!this.db)
+            return;
+        const fields = [];
+        const values = [];
+        const map = {
+            modelId: 'model_id',
+            projectName: 'project_name',
+            projectPath: 'project_path',
+            taskPrompt: 'task_prompt',
+            endedAt: 'ended_at',
+            inputTokens: 'input_tokens',
+            outputTokens: 'output_tokens',
+            costUsd: 'cost_usd',
+            exitCode: 'exit_code',
+            gitBefore: 'git_before',
+            gitAfter: 'git_after',
+            hwProfile: 'hw_profile',
+            taskSignals: 'task_signals',
+            taskCategory: 'task_category',
+            taskCategorySource: 'task_category_source',
+            outcome: 'outcome',
+            outcomeConfidence: 'outcome_confidence',
+            efficiencyJson: 'efficiency_json',
+            compositeScore: 'composite_score',
+        };
+        for (const [k, v] of Object.entries(patch)) {
+            const col = map[k];
+            if (!col || v === undefined)
+                continue;
+            fields.push(`${col} = ?`);
+            values.push(v);
+        }
+        if (fields.length === 0)
+            return;
+        values.push(id);
+        this.db.prepare(`UPDATE runs SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+    }
+    /** Delete a run and all its related data (steps, turns, evals, artifacts, vibe). */
+    deleteRun(id) {
+        if (!this.db)
+            return;
+        // CASCADE should handle children, but be explicit for safety.
+        this.db.prepare('DELETE FROM steps WHERE run_id = ?').run(id);
+        this.db.prepare('DELETE FROM turns WHERE run_id = ?').run(id);
+        this.db.prepare('DELETE FROM evals WHERE run_id = ?').run(id);
+        this.db.prepare('DELETE FROM artifacts WHERE run_id = ?').run(id);
+        this.db.prepare('DELETE FROM vibe_feedback WHERE run_id = ?').run(id);
+        this.db.prepare('DELETE FROM runs WHERE id = ?').run(id);
+    }
+    getRun(id) {
+        if (!this.db)
+            return null;
+        const row = this.db.prepare('SELECT * FROM runs WHERE id = ?').get(id);
+        return row ? rowToRun(row) : null;
+    }
+    listRuns(opts = {}) {
+        if (!this.db)
+            return [];
+        const wh = [];
+        const args = [];
+        if (opts.agentType) {
+            wh.push('agent_type = ?');
+            args.push(opts.agentType);
+        }
+        if (opts.modelId) {
+            wh.push('model_id = ?');
+            args.push(opts.modelId);
+        }
+        const where = wh.length ? `WHERE ${wh.join(' AND ')}` : '';
+        const limit = Math.min(Math.max(opts.limit ?? 50, 1), 500);
+        const rows = this.db.prepare(`SELECT * FROM runs ${where} ORDER BY started_at DESC LIMIT ${limit}`).all(...args);
+        return rows.map(rowToRun);
+    }
+    // ─── Turns ──────────────────────────────────────────────────────────────────
+    insertTurn(turn) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO turns (id, run_id, task_id, turn_index, prompt, started_at, git_before) VALUES (?,?,?,?,?,?,?)`).run(turn.id, turn.runId, turn.taskId ?? null, turn.turnIndex, turn.prompt ?? null, turn.startedAt, turn.gitBefore ?? null);
+    }
+    updateTurn(id, fields) {
+        if (!this.db)
+            return;
+        const map = {
+            endedAt: 'ended_at', toolCalls: 'tool_calls', filesModified: 'files_modified',
+            filesCreated: 'files_created', gitAfter: 'git_after', taskCategory: 'task_category',
+            outcome: 'outcome', compositeScore: 'composite_score', efficiencyJson: 'efficiency_json',
+            prompt: 'prompt', response: 'response', taskId: 'task_id',
+        };
+        const sets = [];
+        const vals = [];
+        for (const [k, v] of Object.entries(fields)) {
+            const col = map[k];
+            if (!col || v === undefined)
+                continue;
+            sets.push(`${col} = ?`);
+            vals.push(v);
+        }
+        if (sets.length === 0)
+            return;
+        vals.push(id);
+        this.db.prepare(`UPDATE turns SET ${sets.join(', ')} WHERE id = ?`).run(...vals);
+    }
+    getTurn(id) {
+        if (!this.db)
+            return null;
+        return this.db.prepare('SELECT * FROM turns WHERE id = ?').get(id) ?? null;
+    }
+    listTurns(runId) {
+        if (!this.db)
+            return [];
+        return this.db.prepare('SELECT * FROM turns WHERE run_id = ? ORDER BY turn_index ASC').all(runId);
+    }
+    // ─── Tasks ──────────────────────────────────────────────────────────────────
+    insertTask(row) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO tasks (id, run_id, task_index, boundary_signal, started_at, first_turn_index)
+       VALUES (?,?,?,?,?,?)`).run(row.id, row.runId, row.taskIndex, row.boundarySignal, row.startedAt, row.firstTurnIndex ?? null);
+    }
+    updateTask(id, patch) {
+        if (!this.db)
+            return;
+        const map = {
+            endedAt: 'ended_at',
+            firstTurnIndex: 'first_turn_index',
+            lastTurnIndex: 'last_turn_index',
+            summary: 'summary',
+            outcome: 'outcome',
+            compositeScore: 'composite_score',
+            taskCategory: 'task_category',
+            notesJson: 'notes_json',
+            boundarySignal: 'boundary_signal',
+        };
+        const sets = [];
+        const vals = [];
+        for (const [k, v] of Object.entries(patch)) {
+            const col = map[k];
+            if (!col || v === undefined)
+                continue;
+            sets.push(`${col} = ?`);
+            vals.push(v);
+        }
+        if (sets.length === 0)
+            return;
+        vals.push(id);
+        this.db.prepare(`UPDATE tasks SET ${sets.join(', ')} WHERE id = ?`).run(...vals);
+    }
+    getTask(id) {
+        if (!this.db)
+            return null;
+        const row = this.db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
+        return row ? rowToTask(row) : null;
+    }
+    listTasksForRun(runId) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare('SELECT * FROM tasks WHERE run_id = ? ORDER BY task_index ASC').all(runId);
+        return rows.map(rowToTask);
+    }
+    listTurnsForTask(taskId) {
+        if (!this.db)
+            return [];
+        return this.db.prepare('SELECT * FROM turns WHERE task_id = ? ORDER BY turn_index ASC').all(taskId);
+    }
+    /** Ended tasks (boundary hit) that haven't been judged yet — backfill candidates. */
+    listTasksNeedingSummary(limit = 20) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare(`SELECT t.id, t.run_id, t.task_category FROM tasks t
+       WHERE t.ended_at IS NOT NULL
+         AND t.summary IS NULL
+       ORDER BY t.ended_at DESC
+       LIMIT ?`).all(limit);
+        return rows.map((r) => ({ id: r.id, runId: r.run_id, taskCategory: r.task_category }));
+    }
+    insertEvalForTask(row) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO evals (run_id, task_id, layer, metric, score, raw, rubric_ver, judge_model, created_at)
+       VALUES (?,?,?,?,?,?,?,?,?)`).run(row.runId, row.taskId, row.layer, row.metric, row.score, row.raw ?? null, row.rubricVer ?? null, row.judgeModel ?? null, row.createdAt);
+    }
+    listEvalsForTask(taskId) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare('SELECT * FROM evals WHERE task_id = ? ORDER BY created_at ASC').all(taskId);
+        return rows.map((r) => ({
+            id: r.id,
+            runId: r.run_id,
+            layer: r.layer,
+            metric: r.metric,
+            score: r.score,
+            raw: r.raw ?? null,
+            rubricVer: r.rubric_ver ?? null,
+            judgeModel: r.judge_model ?? null,
+            createdAt: r.created_at,
+        }));
+    }
+    listEvalsForTurn(turnId) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare('SELECT * FROM evals WHERE turn_id = ? ORDER BY created_at ASC').all(turnId);
+        return rows.map((r) => ({
+            id: r.id,
+            runId: r.run_id,
+            layer: r.layer,
+            metric: r.metric,
+            score: r.score,
+            raw: r.raw ?? null,
+            rubricVer: r.rubric_ver ?? null,
+            judgeModel: r.judge_model ?? null,
+            createdAt: r.created_at,
+        }));
+    }
+    insertEvalForTurn(row) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO evals (run_id, turn_id, layer, metric, score, raw, rubric_ver, judge_model, created_at)
+       VALUES (?,?,?,?,?,?,?,?,?)`).run(row.runId, row.turnId, row.layer, row.metric, row.score, row.raw ?? null, row.rubricVer ?? null, row.judgeModel ?? null, row.createdAt);
+    }
+    // ─── Steps / Artifacts ───────────────────────────────────────────────────────
+    insertStep(row) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO steps (run_id, ts, kind, tool_name, payload) VALUES (?, ?, ?, ?, ?)`).run(row.runId, row.ts, row.kind, row.toolName ?? null, row.payload);
+    }
+    listSteps(runId) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare('SELECT * FROM steps WHERE run_id = ? ORDER BY ts ASC').all(runId);
+        return rows.map((r) => ({
+            id: r.id,
+            runId: r.run_id,
+            ts: r.ts,
+            kind: r.kind,
+            toolName: r.tool_name ?? null,
+            payload: r.payload ?? '{}',
+        }));
+    }
+    insertArtifact(row) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO artifacts (run_id, kind, path, sha256, bytes) VALUES (?, ?, ?, ?, ?)`).run(row.runId, row.kind, row.path, row.sha256 ?? null, row.bytes ?? null);
+    }
+    // ─── Evals ───────────────────────────────────────────────────────────────────
+    insertEval(row) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO evals
+        (run_id, layer, metric, score, raw, rubric_ver, judge_model, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(row.runId, row.layer, row.metric, row.score, row.raw ?? null, row.rubricVer ?? null, row.judgeModel ?? null, row.createdAt);
+    }
+    listEvalsForRun(runId) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare('SELECT * FROM evals WHERE run_id = ? ORDER BY created_at ASC').all(runId);
+        return rows.map((r) => ({
+            id: r.id,
+            runId: r.run_id,
+            layer: r.layer,
+            metric: r.metric,
+            score: r.score,
+            raw: r.raw ?? null,
+            rubricVer: r.rubric_ver ?? null,
+            judgeModel: r.judge_model ?? null,
+            createdAt: r.created_at,
+        }));
+    }
+    // ─── Rubrics ─────────────────────────────────────────────────────────────────
+    getCurrentRubric(purpose = 'general') {
+        if (!this.db)
+            return null;
+        const row = this.db.prepare(`SELECT * FROM rubrics WHERE purpose = ? ORDER BY version DESC LIMIT 1`).get(purpose);
+        return row ? rowToRubric(row) : null;
+    }
+    appendRubric(row) {
+        if (!this.db)
+            return 0;
+        const next = this.db.prepare('SELECT COALESCE(MAX(version),0)+1 AS v FROM rubrics').get().v;
+        this.db.prepare(`INSERT INTO rubrics (version, purpose, prompt, weights, created_at, parent_ver, notes)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(next, row.purpose, row.prompt, row.weights, row.createdAt, row.parentVer ?? null, row.notes ?? null);
+        return next;
+    }
+    // ─── Vibe ────────────────────────────────────────────────────────────────────
+    insertVibe(row) {
+        if (!this.db)
+            return;
+        this.db.prepare(`INSERT INTO vibe_feedback (run_id, verdict, note, ts) VALUES (?, ?, ?, ?)`).run(row.runId, row.verdict, row.note ?? null, row.ts);
+    }
+    /** Return the most recent vibe verdict for a run, or null if none. */
+    latestVibeForRun(runId) {
+        if (!this.db)
+            return null;
+        const row = this.db.prepare(`SELECT * FROM vibe_feedback WHERE run_id = ? ORDER BY ts DESC LIMIT 1`).get(runId);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            runId: row.run_id,
+            verdict: row.verdict,
+            note: row.note ?? null,
+            ts: row.ts,
+        };
+    }
+    /** Runs that have ended but have zero eval rows — candidates for the daemon eval queue. */
+    listUnevaluatedRuns(limit = 20) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare(`SELECT r.id, r.project_path FROM runs r
+       WHERE r.ended_at IS NOT NULL
+         AND NOT EXISTS (SELECT 1 FROM evals e WHERE e.run_id = r.id)
+       ORDER BY r.ended_at DESC
+       LIMIT ?`).all(limit);
+        return rows.map((r) => ({ id: r.id, projectPath: r.project_path }));
+    }
+    /** Runs that have ended but have no category — candidates for daemon re-classification. */
+    listUnclassifiedRuns(limit = 5) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare(`SELECT r.id, r.project_path FROM runs r
+       WHERE r.ended_at IS NOT NULL
+         AND r.task_category IS NULL
+       ORDER BY r.ended_at DESC
+       LIMIT ?`).all(limit);
+        return rows.map((r) => ({ id: r.id, projectPath: r.project_path }));
+    }
+    /** Turns with response captured but no outcome yet — backfill candidates. */
+    listTurnsNeedingOutcome(limit = 20) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare(`SELECT id, run_id FROM turns
+       WHERE response IS NOT NULL AND response != ''
+         AND outcome IS NULL
+       ORDER BY started_at DESC
+       LIMIT ?`).all(limit);
+        return rows.map((r) => ({ id: r.id, runId: r.run_id }));
+    }
+    /** Orphaned runs: started long ago, never closed, no turns.
+     *  Typically from session bridges that crashed without cleanup. */
+    listOrphanedRuns(staleSec = 1800) {
+        if (!this.db)
+            return [];
+        const cutoff = Date.now() - staleSec * 1000;
+        const rows = this.db.prepare(`SELECT r.id FROM runs r
+       WHERE r.ended_at IS NULL
+         AND r.started_at < ?
+         AND r.task_prompt IS NULL
+         AND NOT EXISTS (SELECT 1 FROM turns t WHERE t.run_id = r.id)
+       LIMIT 20`).all(cutoff);
+        return rows.map((r) => r.id);
+    }
+    // ─── Scorecard ───────────────────────────────────────────────────────────────
+    scorecard() {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare('SELECT * FROM v_model_scorecard').all();
+        return rows.map((r) => ({
+            agentType: r.agent_type,
+            modelId: r.model_id,
+            runs: r.runs,
+            avgOverall: r.avg_overall ?? null,
+            avgTestsPass: r.avg_tests_pass ?? null,
+            totalCost: r.total_cost ?? null,
+            costPerQuality: r.cost_per_quality ?? null,
+        }));
+    }
+    categoryScorecard() {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare('SELECT * FROM v_category_scorecard').all();
+        return rows.map((r) => ({
+            taskCategory: r.task_category,
+            modelId: r.model_id,
+            runs: r.runs,
+            avgOverall: r.avg_overall ?? null,
+            avgTestsPass: r.avg_tests_pass ?? null,
+            totalCost: r.total_cost ?? null,
+        }));
+    }
+}
+// ─── Row mappers ───────────────────────────────────────────────────────────────
+function rowToRun(r) {
+    return {
+        id: r.id,
+        sessionId: r.session_id,
+        agentType: r.agent_type,
+        modelId: r.model_id ?? null,
+        projectName: r.project_name ?? null,
+        projectPath: r.project_path ?? null,
+        taskPrompt: r.task_prompt ?? null,
+        startedAt: r.started_at,
+        endedAt: r.ended_at ?? null,
+        inputTokens: r.input_tokens ?? null,
+        outputTokens: r.output_tokens ?? null,
+        costUsd: r.cost_usd ?? null,
+        exitCode: r.exit_code ?? null,
+        gitBefore: r.git_before ?? null,
+        gitAfter: r.git_after ?? null,
+        hwProfile: r.hw_profile ?? null,
+        taskSignals: r.task_signals ?? null,
+        taskCategory: r.task_category ?? null,
+        taskCategorySource: r.task_category_source ?? null,
+        outcome: r.outcome ?? null,
+        outcomeConfidence: r.outcome_confidence ?? null,
+        efficiencyJson: r.efficiency_json ?? null,
+        compositeScore: r.composite_score ?? null,
+    };
+}
+function rowToTask(r) {
+    return {
+        id: r.id,
+        runId: r.run_id,
+        taskIndex: r.task_index,
+        boundarySignal: r.boundary_signal,
+        startedAt: r.started_at,
+        endedAt: r.ended_at ?? null,
+        firstTurnIndex: r.first_turn_index ?? null,
+        lastTurnIndex: r.last_turn_index ?? null,
+        summary: r.summary ?? null,
+        outcome: r.outcome ?? null,
+        compositeScore: r.composite_score ?? null,
+        taskCategory: r.task_category ?? null,
+        notesJson: r.notes_json ?? null,
+    };
+}
+function rowToRubric(r) {
+    return {
+        version: r.version,
+        purpose: r.purpose,
+        prompt: r.prompt,
+        weights: r.weights,
+        createdAt: r.created_at,
+        parentVer: r.parent_ver ?? null,
+        notes: r.notes ?? null,
+    };
+}
+//# sourceMappingURL=store.js.map