specrails-desktop 2.0.0

package/server/dist/db.js

@@ -0,0 +1,1034 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ULTRACODE_PRE_PROMPT = void 0;
+exports.initDb = initDb;
+exports.createJob = createJob;
+exports.finishJob = finishJob;
+exports.appendEvent = appendEvent;
+exports.upsertPhase = upsertPhase;
+exports.listJobs = listJobs;
+exports.getJob = getJob;
+exports.getJobEvents = getJobEvents;
+exports.deleteJob = deleteJob;
+exports.purgeJobs = purgeJobs;
+exports.getProjectActivity = getProjectActivity;
+exports.createConversation = createConversation;
+exports.listConversations = listConversations;
+exports.getConversation = getConversation;
+exports.deleteConversation = deleteConversation;
+exports.updateConversation = updateConversation;
+exports.addMessage = addMessage;
+exports.getMessages = getMessages;
+exports.createProposal = createProposal;
+exports.getProposal = getProposal;
+exports.listProposals = listProposals;
+exports.updateProposal = updateProposal;
+exports.deleteProposal = deleteProposal;
+exports.createTemplate = createTemplate;
+exports.listTemplates = listTemplates;
+exports.getTemplate = getTemplate;
+exports.updateTemplate = updateTemplate;
+exports.deleteTemplate = deleteTemplate;
+exports.skipJob = skipJob;
+exports.getPipelineJobs = getPipelineJobs;
+exports.getStats = getStats;
+exports.getProjectSettings = getProjectSettings;
+exports.getUltracodePrePrompt = getUltracodePrePrompt;
+exports.updateProjectSettings = updateProjectSettings;
+exports.getQuickContractRefineLast = getQuickContractRefineLast;
+exports.hasQuickContractRefineLast = hasQuickContractRefineLast;
+exports.setQuickContractRefineLast = setQuickContractRefineLast;
+exports.getTelemetryBlob = getTelemetryBlob;
+exports.upsertTelemetryBlob = upsertTelemetryBlob;
+exports.listActiveTelemetryBlobs = listActiveTelemetryBlobs;
+exports.setTelemetryBlobCompacted = setTelemetryBlobCompacted;
+exports.insertTelemetrySummary = insertTelemetrySummary;
+exports.getTelemetrySummaries = getTelemetrySummaries;
+exports.deleteTelemetryForJob = deleteTelemetryForJob;
+exports.getJobsWithTelemetry = getJobsWithTelemetry;
+exports.hasJobTelemetry = hasJobTelemetry;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const secure_fs_1 = require("./util/secure-fs");
+const MIGRATIONS = [
+    // Migration 1: initial schema
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_migrations (
+        version     INTEGER PRIMARY KEY,
+        applied_at  TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS jobs (
+        id                   TEXT    PRIMARY KEY,
+        command              TEXT    NOT NULL,
+        started_at           TEXT    NOT NULL,
+        finished_at          TEXT,
+        status               TEXT    NOT NULL DEFAULT 'running',
+        exit_code            INTEGER,
+        tokens_in            INTEGER,
+        tokens_out           INTEGER,
+        tokens_cache_read    INTEGER,
+        tokens_cache_create  INTEGER,
+        total_cost_usd       REAL,
+        num_turns            INTEGER,
+        model                TEXT,
+        duration_ms          INTEGER,
+        duration_api_ms      INTEGER,
+        session_id           TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_jobs_started_at ON jobs(started_at);
+      CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+
+      CREATE TABLE IF NOT EXISTS events (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        job_id      TEXT    NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+        seq         INTEGER NOT NULL,
+        event_type  TEXT    NOT NULL,
+        source      TEXT,
+        payload     TEXT    NOT NULL,
+        timestamp   TEXT    NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_events_job_id ON events(job_id);
+
+      CREATE TABLE IF NOT EXISTS job_phases (
+        job_id      TEXT    NOT NULL REFERENCES jobs(id) ON DELETE CASCADE,
+        phase       TEXT    NOT NULL,
+        state       TEXT    NOT NULL,
+        updated_at  TEXT    NOT NULL,
+        PRIMARY KEY (job_id, phase)
+      );
+    `);
+    },
+    // Migration 2: add queue_position column to jobs
+    (db) => {
+        db.exec(`
+      ALTER TABLE jobs ADD COLUMN queue_position INTEGER;
+    `);
+    },
+    // Migration 3: add queue_state table for persisting queue config (e.g., paused)
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS queue_state (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      INSERT OR IGNORE INTO queue_state (key, value) VALUES ('paused', 'false');
+    `);
+    },
+    // Migration 4: chat conversations and messages
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS chat_conversations (
+        id           TEXT PRIMARY KEY,
+        title        TEXT,
+        model        TEXT NOT NULL DEFAULT 'sonnet',
+        session_id   TEXT,
+        created_at   TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at   TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS chat_messages (
+        id              INTEGER PRIMARY KEY AUTOINCREMENT,
+        conversation_id TEXT NOT NULL REFERENCES chat_conversations(id) ON DELETE CASCADE,
+        role            TEXT NOT NULL CHECK(role IN ('user', 'assistant')),
+        content         TEXT NOT NULL,
+        created_at      TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chat_messages_conv ON chat_messages(conversation_id);
+    `);
+    },
+    // Migration 5: proposals table
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS proposals (
+        id              TEXT    PRIMARY KEY,
+        idea            TEXT    NOT NULL,
+        session_id      TEXT,
+        status          TEXT    NOT NULL DEFAULT 'input',
+        result_markdown TEXT,
+        issue_url       TEXT,
+        created_at      TEXT    NOT NULL DEFAULT (datetime('now')),
+        updated_at      TEXT    NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_proposals_status ON proposals(status);
+      CREATE INDEX IF NOT EXISTS idx_proposals_created_at ON proposals(created_at);
+    `);
+    },
+    // Migration 6: job templates
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS job_templates (
+        id          TEXT NOT NULL PRIMARY KEY,
+        name        TEXT NOT NULL UNIQUE,
+        description TEXT,
+        commands    TEXT NOT NULL,
+        created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_job_templates_created_at ON job_templates(created_at);
+    `);
+    },
+    // Migration 7: add priority column to jobs
+    (db) => {
+        db.exec(`
+      ALTER TABLE jobs ADD COLUMN priority TEXT NOT NULL DEFAULT 'normal';
+    `);
+    },
+    // Migration 8: job dependencies and pipelines
+    (db) => {
+        db.exec(`
+      ALTER TABLE jobs ADD COLUMN depends_on_job_id TEXT REFERENCES jobs(id);
+      ALTER TABLE jobs ADD COLUMN pipeline_id TEXT;
+      ALTER TABLE jobs ADD COLUMN skip_reason TEXT;
+      CREATE INDEX IF NOT EXISTS idx_jobs_depends_on ON jobs(depends_on_job_id);
+      CREATE INDEX IF NOT EXISTS idx_jobs_pipeline_id ON jobs(pipeline_id);
+    `);
+    },
+    // Migration 9: rails table for Rails board job integration
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS rails (
+        rail_index  INTEGER NOT NULL,
+        ticket_id   INTEGER NOT NULL,
+        position    INTEGER NOT NULL,
+        mode        TEXT    NOT NULL DEFAULT 'implement',
+        PRIMARY KEY (rail_index, ticket_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_rails_rail_index ON rails(rail_index);
+    `);
+    },
+    // Migration 10: pipeline telemetry blob and summary tables.
+    // The pipelineTelemetryEnabled flag reuses the existing queue_state key-value
+    // store (key = 'config.pipeline_telemetry_enabled') so no schema change needed
+    // for settings; only the raw-data tables are new.
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS telemetry_blobs (
+        jobId      TEXT    PRIMARY KEY,
+        path       TEXT,
+        byteSize   INTEGER NOT NULL DEFAULT 0,
+        startedAt  INTEGER,
+        endedAt    INTEGER,
+        state      TEXT    NOT NULL DEFAULT 'active'
+                           CHECK(state IN ('active','compacted','expired'))
+      );
+
+      CREATE TABLE IF NOT EXISTS telemetry_summaries (
+        jobId        TEXT    NOT NULL,
+        phase        TEXT    NOT NULL,
+        durationMs   INTEGER,
+        tokensInput  INTEGER,
+        tokensOutput INTEGER,
+        tokensCache  INTEGER,
+        toolCalls    TEXT,
+        apiErrors    INTEGER,
+        costUsd      REAL,
+        PRIMARY KEY (jobId, phase)
+      );
+    `);
+    },
+    // Migration 11: agent profiles — per-rail profile snapshots, custom agent
+    // version history, and sandboxed "test agent" run records. These back the
+    // Agents section (profiles + studio) added by add-agents-profiles.
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS job_profiles (
+        job_id        TEXT    PRIMARY KEY,
+        profile_name  TEXT    NOT NULL,
+        profile_json  TEXT    NOT NULL,
+        created_at    INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_job_profiles_name ON job_profiles(profile_name);
+
+      CREATE TABLE IF NOT EXISTS agent_versions (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_name   TEXT    NOT NULL,
+        version      INTEGER NOT NULL,
+        body         TEXT    NOT NULL,
+        created_at   INTEGER NOT NULL,
+        UNIQUE (agent_name, version)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_agent_versions_name ON agent_versions(agent_name);
+
+      CREATE TABLE IF NOT EXISTS agent_tests (
+        id             INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_name     TEXT    NOT NULL,
+        draft_hash     TEXT    NOT NULL,
+        sample_task_id TEXT,
+        tokens         INTEGER,
+        duration_ms    INTEGER,
+        output         TEXT,
+        created_at     INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_agent_tests_name ON agent_tests(agent_name);
+    `);
+    },
+    // Migration 12: remember per-rail agent profile selection across launches.
+    (db) => {
+        try {
+            db.exec(`ALTER TABLE rails ADD COLUMN profile_name TEXT`);
+        }
+        catch {
+            // Column may already exist (partially-migrated DB); no-op.
+        }
+    },
+    // Migration 13: agent_refine_sessions — in-flight AI Edit sessions for
+    // custom agents. Distinct from agent_versions (which is committed history);
+    // rows here are drafts in progress that may or may not be applied.
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_refine_sessions (
+        id              TEXT    PRIMARY KEY,
+        agent_id        TEXT    NOT NULL,
+        session_id      TEXT,
+        base_version    INTEGER NOT NULL,
+        base_body_hash  TEXT    NOT NULL,
+        draft_body      TEXT,
+        history_json    TEXT    NOT NULL DEFAULT '[]',
+        phase           TEXT    NOT NULL DEFAULT 'idle',
+        status          TEXT    NOT NULL DEFAULT 'idle',
+        auto_test       INTEGER NOT NULL DEFAULT 1,
+        last_test_at    INTEGER,
+        last_test_hash  TEXT,
+        created_at      INTEGER NOT NULL,
+        updated_at      INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_agent_refine_sessions_agent
+        ON agent_refine_sessions(agent_id, status);
+      CREATE INDEX IF NOT EXISTS idx_agent_refine_sessions_updated
+        ON agent_refine_sessions(updated_at);
+    `);
+    },
+    // Migration 14: terminal_settings_override — per-project key/value override
+    // for app-wide terminal settings. Absence of a row means "inherit app default".
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS terminal_settings_override (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+    },
+    // Migration 15: terminal_command_marks — per-session record of completed
+    // commands derived from OSC 133 prompt marks. FIFO-capped at 1000 rows per
+    // session by the marks store.
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS terminal_command_marks (
+        id           INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id   TEXT    NOT NULL,
+        started_at   INTEGER NOT NULL,
+        finished_at  INTEGER,
+        exit_code    INTEGER,
+        command      TEXT,
+        cwd          TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_terminal_marks_session_started
+        ON terminal_command_marks(session_id, started_at);
+    `);
+    },
+    // Migration 16: ai_invocations — unified per-project AI CLI invocation
+    // tracking across surfaces (job, quick-spec, explore-spec, ai-edit).
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS ai_invocations (
+        id                   TEXT    PRIMARY KEY,
+        project_id           TEXT    NOT NULL,
+        surface              TEXT    NOT NULL,
+        surface_ref_id       TEXT,
+        ticket_id            INTEGER,
+        conversation_id      TEXT,
+        model                TEXT,
+        status               TEXT    NOT NULL,
+        started_at           TEXT    NOT NULL,
+        finished_at          TEXT,
+        duration_ms          INTEGER,
+        duration_api_ms      INTEGER,
+        tokens_in            INTEGER,
+        tokens_out           INTEGER,
+        tokens_cache_read    INTEGER,
+        tokens_cache_create  INTEGER,
+        total_cost_usd       REAL,
+        num_turns            INTEGER,
+        session_id           TEXT,
+        created_at           TEXT    NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_ai_inv_project_started
+        ON ai_invocations(project_id, started_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_ai_inv_project_surface
+        ON ai_invocations(project_id, surface);
+      CREATE INDEX IF NOT EXISTS idx_ai_inv_project_ticket
+        ON ai_invocations(project_id, ticket_id) WHERE ticket_id IS NOT NULL;
+    `);
+    },
+    // Migration 17: chat_conversations.kind — distinguishes Explore conversations
+    // (kind='explore') from sidebar chat (kind='sidebar'). Capture for ai_invocations
+    // is gated on kind='explore'.
+    (db) => {
+        db.exec(`
+      ALTER TABLE chat_conversations ADD COLUMN kind TEXT NOT NULL DEFAULT 'sidebar';
+    `);
+    },
+    // Migration 18: chat_conversations.context_scope — per-conversation JSON
+    // freezing the Add Spec context scope at creation time. NULL means "legacy
+    // behavior" so existing rows behave unchanged.
+    //
+    // Idempotent: a parallel WIP branch shipped this column under migration #20,
+    // so on machines where it already exists we swallow the duplicate-column
+    // error rather than crash on a re-run.
+    (db) => {
+        try {
+            db.exec(`ALTER TABLE chat_conversations ADD COLUMN context_scope TEXT;`);
+        }
+        catch (err) {
+            const msg = err.message ?? '';
+            if (!/duplicate column name/i.test(msg))
+                throw err;
+        }
+    },
+    // Migration 19: ai_invocations.provider — provider id stamped at insert.
+    // Existing rows backfill to 'claude' since pre-migration that was the only
+    // path. New rows MUST be populated from the resolved adapter's id (see
+    // openspec/changes/add-multi-provider-support/specs/project-spending/spec.md).
+    //
+    // Idempotent: same dual-WIP concern — multi-provider branch originally
+    // numbered this #18, so on machines that ran the pre-merge multi-provider
+    // build the column already exists.
+    (db) => {
+        try {
+            db.exec(`ALTER TABLE ai_invocations ADD COLUMN provider TEXT;`);
+        }
+        catch (err) {
+            const msg = err.message ?? '';
+            if (!/duplicate column name/i.test(msg))
+                throw err;
+        }
+        db.exec(`UPDATE ai_invocations SET provider = 'claude' WHERE provider IS NULL;`);
+        db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_ai_inv_project_provider
+        ON ai_invocations(project_id, provider);
+    `);
+    },
+    // Migration 20: ai_invocations.total_cost_usd_estimated — 1 when the cost
+    // came from server/pricing.ts (estimated fallback for non-native-cost
+    // providers); 0 when authoritative from the provider's terminal event.
+    //
+    // Idempotent for the same reason as #18/#19.
+    (db) => {
+        try {
+            db.exec(`
+        ALTER TABLE ai_invocations
+          ADD COLUMN total_cost_usd_estimated INTEGER NOT NULL DEFAULT 0;
+      `);
+        }
+        catch (err) {
+            const msg = err.message ?? '';
+            if (!/duplicate column name/i.test(msg))
+                throw err;
+        }
+    },
+    // Migration 21: self-heal `ai_invocations.provider` and
+    // `ai_invocations.total_cost_usd_estimated` for projects whose
+    // `schema_migrations` table marked versions 19 / 20 as applied without the
+    // corresponding ALTER actually running (parallel WIP branches reshuffled
+    // migration indices during development, leaving some on-disk DBs with the
+    // applied row but no column). Uses `PRAGMA table_info` so we only ALTER
+    // when the column is genuinely missing — safe to re-run.
+    (db) => {
+        const cols = new Set(db.prepare(`PRAGMA table_info(ai_invocations)`).all()
+            .map((r) => r.name));
+        if (!cols.has('provider')) {
+            db.exec(`ALTER TABLE ai_invocations ADD COLUMN provider TEXT;`);
+            db.exec(`UPDATE ai_invocations SET provider = 'claude' WHERE provider IS NULL;`);
+            db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_ai_inv_project_provider
+          ON ai_invocations(project_id, provider);
+      `);
+        }
+        if (!cols.has('total_cost_usd_estimated')) {
+            db.exec(`
+        ALTER TABLE ai_invocations
+          ADD COLUMN total_cost_usd_estimated INTEGER NOT NULL DEFAULT 0;
+      `);
+        }
+    },
+    // Migration 22: file_provenance — per-project file ⇄ ticket tracking,
+    // populated by the QueueManager post-job hook and consumed by the Code
+    // Explorer router + TicketDetailModal.
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS file_provenance (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        file_path   TEXT    NOT NULL,
+        ticket_id   INTEGER,
+        job_id      TEXT,
+        kind        TEXT    NOT NULL CHECK(kind IN ('created','modified','deleted')),
+        at          INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_fp_path   ON file_provenance(file_path);
+      CREATE INDEX IF NOT EXISTS idx_fp_ticket ON file_provenance(ticket_id);
+      CREATE INDEX IF NOT EXISTS idx_fp_at     ON file_provenance(at DESC);
+    `);
+    },
+    // Migration 23: optional per-job file patch storage for Code Explorer
+    // provenance. Older provenance rows remain valid without a patch.
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS file_provenance_diffs (
+        provenance_id INTEGER PRIMARY KEY REFERENCES file_provenance(id) ON DELETE CASCADE,
+        patch         TEXT NOT NULL,
+        truncated     INTEGER NOT NULL DEFAULT 0
+      );
+    `);
+    },
+    // Migration 24: chat_conversations.provider — per-conversation AI engine for
+    // multi-provider projects. NULL means "fall back to the project's primary
+    // provider" (single-provider projects never set it, so behaviour is
+    // unchanged). Set at conversation creation from the Add Spec AI Engine
+    // selector; resume turns reuse it so the right CLI binary is spawned.
+    (db) => {
+        db.exec(`ALTER TABLE chat_conversations ADD COLUMN provider TEXT;`);
+    },
+    // Migration 25: rails.ai_engine — per-rail AI engine override for
+    // multi-provider projects. NULL means "use the project's primary provider".
+    // Stored on every rail row alongside profile_name; getRail reads the first
+    // row's value.
+    (db) => {
+        db.exec(`ALTER TABLE rails ADD COLUMN ai_engine TEXT;`);
+    },
+    // Migration 26: self-heal the multi-provider columns. An earlier WIP of the
+    // multi-provider feature consumed migration versions 24 and 25 on some
+    // databases with DIFFERENT meaning — those DBs already record v24/v25 so
+    // Migrations 24/25 above are skipped, leaving `rails.ai_engine` (and possibly
+    // `chat_conversations.provider`) missing. This higher-numbered migration is
+    // guarded by column checks: a no-op on DBs where the columns already exist,
+    // and an additive repair everywhere else. (Mirrors the #18/#19 self-heal
+    // precedent in this file.)
+    (db) => {
+        const convCols = db.prepare("PRAGMA table_info(chat_conversations)").all().map((c) => c.name);
+        if (!convCols.includes('provider')) {
+            db.exec(`ALTER TABLE chat_conversations ADD COLUMN provider TEXT;`);
+        }
+        const railCols = db.prepare("PRAGMA table_info(rails)").all().map((c) => c.name);
+        if (!railCols.includes('ai_engine')) {
+            db.exec(`ALTER TABLE rails ADD COLUMN ai_engine TEXT;`);
+        }
+    },
+    // Migration 27: jobs.total_cost_usd_estimated — 1 when jobs.total_cost_usd
+    // came from server/pricing.ts (estimated fallback for non-native-cost
+    // providers like codex); 0 when authoritative from the provider's terminal
+    // event. Mirrors the ai_invocations column (migration 20) so the app
+    // dashboard, budget enforcement, and webhook can distinguish a rate-card
+    // estimate from a provider-billed figure. Additive + idempotent.
+    (db) => {
+        const cols = db.prepare(`PRAGMA table_info(jobs)`).all().map((r) => r.name);
+        if (!cols.includes('total_cost_usd_estimated')) {
+            db.exec(`
+        ALTER TABLE jobs
+          ADD COLUMN total_cost_usd_estimated INTEGER NOT NULL DEFAULT 0;
+      `);
+        }
+    },
+    // Migration 28: rail_meta — per-rail display name, keyed by rail_index.
+    // The `rails` table stores name-less ticket rows (and has NO rows for an
+    // empty rail), so a rail's user-given name can't live there — a renamed but
+    // empty rail would lose its name. rail_meta is a separate, ticket-independent
+    // store so every rail (0/1/2) keeps its name regardless of assignments.
+    // NULL name = client falls back to the default "Rail N" label. This backs the
+    // desktop ⇄ mobile rail-name sync (broadcast via rail.updated).
+    (db) => {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS rail_meta (
+        rail_index  INTEGER PRIMARY KEY,
+        name        TEXT
+      );
+    `);
+    },
+];
+function applyMigrations(db) {
+    // Ensure the migrations table exists (migration 1 creates it, but we need
+    // it before we can read from it)
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version     INTEGER PRIMARY KEY,
+      applied_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+    const appliedVersions = new Set(db.prepare('SELECT version FROM schema_migrations').all()
+        .map((r) => r.version));
+    for (let i = 0; i < MIGRATIONS.length; i++) {
+        const version = i + 1;
+        if (!appliedVersions.has(version)) {
+            // M8: run each migration body and its version INSERT atomically. SQLite DDL
+            // is transactional, so a crash/failure mid-migration now rolls back the
+            // whole body instead of leaving a half-applied schema with the version
+            // unrecorded — which under the old code re-ran a bare `ALTER TABLE ADD
+            // COLUMN` on next startup and bricked it forever with 'duplicate column
+            // name'. With this, a failed migration leaves nothing applied and re-runs
+            // cleanly. (Pre-existing half-applied DBs are contained by the per-project
+            // load isolation in project-registry.ts — one bad DB no longer kills the app.)
+            const tx = db.transaction(() => {
+                MIGRATIONS[i](db);
+                db.prepare('INSERT OR IGNORE INTO schema_migrations (version) VALUES (?)').run(version);
+            });
+            tx();
+        }
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+function initDb(dbPath) {
+    if (dbPath !== ':memory:') {
+        const dir = path_1.default.dirname(dbPath);
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        (0, secure_fs_1.secureDir)(dir); // H-13: owner-only data dir
+    }
+    const db = new better_sqlite3_1.default(dbPath);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    applyMigrations(db);
+    // H-13: restrict the db + its WAL sidecars to 0600 (jobs.sqlite holds chat
+    // transcripts and verbatim terminal command history). After migrations the
+    // WAL/SHM files exist, so this covers them too.
+    (0, secure_fs_1.secureDbFile)(dbPath);
+    // Orphan sweep: mark any running jobs as failed on startup
+    db.prepare("UPDATE jobs SET status = 'failed', finished_at = ? WHERE status = 'running'").run(new Date().toISOString());
+    // Orphan sweep: cancel any in-flight proposals from a previous server session
+    db.prepare("UPDATE proposals SET status = 'cancelled', updated_at = ? WHERE status IN ('exploring', 'refining')").run(new Date().toISOString());
+    return db;
+}
+function createJob(db, job) {
+    // INSERT OR IGNORE handles the case where the job row already exists (restored from DB
+    // after server restart). The UPDATE that follows always sets status and started_at.
+    db.prepare('INSERT OR IGNORE INTO jobs (id, command, started_at, status, priority, depends_on_job_id, pipeline_id) VALUES (?, ?, ?, ?, ?, ?, ?)').run(job.id, job.command, job.started_at, 'running', job.priority ?? 'normal', job.depends_on_job_id ?? null, job.pipeline_id ?? null);
+    db.prepare('UPDATE jobs SET status = ?, started_at = ? WHERE id = ?').run('running', job.started_at, job.id);
+}
+function finishJob(db, jobId, result) {
+    db.prepare(`
+    UPDATE jobs SET
+      status              = ?,
+      exit_code           = ?,
+      finished_at         = ?,
+      tokens_in           = ?,
+      tokens_out          = ?,
+      tokens_cache_read   = ?,
+      tokens_cache_create = ?,
+      total_cost_usd      = ?,
+      total_cost_usd_estimated = ?,
+      num_turns           = ?,
+      model               = ?,
+      duration_ms         = ?,
+      duration_api_ms     = ?,
+      session_id          = ?
+    WHERE id = ?
+  `).run(result.status, result.exit_code, new Date().toISOString(), result.tokens_in ?? null, result.tokens_out ?? null, result.tokens_cache_read ?? null, result.tokens_cache_create ?? null, result.total_cost_usd ?? null, result.total_cost_usd_estimated ? 1 : 0, result.num_turns ?? null, result.model ?? null, result.duration_ms ?? null, result.duration_api_ms ?? null, result.session_id ?? null, jobId);
+}
+function appendEvent(db, jobId, seq, event) {
+    db.prepare('INSERT INTO events (job_id, seq, event_type, source, payload) VALUES (?, ?, ?, ?, ?)').run(jobId, seq, event.event_type, event.source ?? null, event.payload);
+}
+function upsertPhase(db, jobId, phase, state) {
+    db.prepare('INSERT OR REPLACE INTO job_phases (job_id, phase, state, updated_at) VALUES (?, ?, ?, ?)').run(jobId, phase, state, new Date().toISOString());
+}
+function listJobs(db, opts) {
+    const limit = Math.min(opts.limit ?? 50, 200);
+    const offset = opts.offset ?? 0;
+    const conditions = [];
+    const params = [];
+    if (opts.status) {
+        conditions.push('status = ?');
+        params.push(opts.status);
+    }
+    if (opts.from) {
+        conditions.push('started_at >= ?');
+        params.push(opts.from);
+    }
+    if (opts.to) {
+        conditions.push('started_at <= ?');
+        params.push(opts.to);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const countRow = db
+        .prepare(`SELECT COUNT(*) as count FROM jobs ${where}`)
+        .get(...params);
+    const jobs = db
+        .prepare(`SELECT jobs.*, jp.profile_name AS profile_name
+       FROM jobs LEFT JOIN job_profiles jp ON jp.job_id = jobs.id
+       ${where}
+       ORDER BY started_at DESC LIMIT ? OFFSET ?`)
+        .all(...params, limit, offset);
+    return { jobs, total: countRow.count };
+}
+function getJob(db, jobId) {
+    return db
+        .prepare('SELECT * FROM jobs WHERE id = ?')
+        .get(jobId);
+}
+function getJobEvents(db, jobId) {
+    return db
+        .prepare('SELECT * FROM events WHERE job_id = ? ORDER BY seq ASC')
+        .all(jobId);
+}
+function deleteJob(db, jobId) {
+    // M7: jobs.depends_on_job_id REFERENCES jobs(id) with no ON DELETE action and
+    // foreign_keys=ON, so deleting a pipeline parent throws 'FOREIGN KEY
+    // constraint failed' and the job becomes undeletable from the UI. Clear inbound
+    // references first, in the same transaction as the delete, so it always
+    // succeeds (children keep running; they just lose the now-irrelevant pointer).
+    const tx = db.transaction((id) => {
+        db.prepare('UPDATE jobs SET depends_on_job_id = NULL WHERE depends_on_job_id = ?').run(id);
+        // B41: events/job_phases cascade on the jobs FK, but telemetry_blobs/
+        // telemetry_summaries (keyed `jobId`), job_profiles and file_provenance
+        // (keyed `job_id`) have no FK — without these they accumulate forever. (The
+        // on-disk .ndjson.gz blob is reclaimed by the 7-day startup compactor.)
+        db.prepare('DELETE FROM telemetry_blobs WHERE jobId = ?').run(id);
+        db.prepare('DELETE FROM telemetry_summaries WHERE jobId = ?').run(id);
+        db.prepare('DELETE FROM job_profiles WHERE job_id = ?').run(id);
+        db.prepare('DELETE FROM file_provenance WHERE job_id = ?').run(id);
+        db.prepare('DELETE FROM jobs WHERE id = ?').run(id);
+    });
+    tx(jobId);
+}
+function purgeJobs(db, opts) {
+    const conditions = ["status IN ('completed', 'failed', 'canceled', 'zombie_terminated', 'skipped')"];
+    const params = [];
+    if (opts?.from) {
+        conditions.push('started_at >= ?');
+        params.push(opts.from);
+    }
+    if (opts?.to) {
+        conditions.push('started_at <= ?');
+        params.push(opts.to);
+    }
+    const where = conditions.join(' AND ');
+    // M6: run the whole purge atomically. Previously these statements ran without a
+    // transaction, so when the final `DELETE FROM jobs` aborted on the
+    // depends_on_job_id FK (a purged job still referenced by a non-purged one), the
+    // events/phases deletes had already committed — destroying log history while
+    // deleting zero job rows, and a misleading 500. The transaction rolls back on
+    // any failure, and NULL-ing inbound references first makes the delete succeed.
+    const tx = db.transaction(() => {
+        const sel = `SELECT id FROM jobs WHERE ${where}`;
+        db.prepare(`DELETE FROM events WHERE job_id IN (${sel})`).run(...params);
+        db.prepare(`DELETE FROM job_phases WHERE job_id IN (${sel})`).run(...params);
+        // B41: also purge the no-FK orphan tables for the same jobs.
+        db.prepare(`DELETE FROM telemetry_blobs WHERE jobId IN (${sel})`).run(...params);
+        db.prepare(`DELETE FROM telemetry_summaries WHERE jobId IN (${sel})`).run(...params);
+        db.prepare(`DELETE FROM job_profiles WHERE job_id IN (${sel})`).run(...params);
+        db.prepare(`DELETE FROM file_provenance WHERE job_id IN (${sel})`).run(...params);
+        // Clear inbound FK references from NON-purged jobs to purged jobs.
+        db.prepare(`UPDATE jobs SET depends_on_job_id = NULL WHERE depends_on_job_id IN (${sel})`).run(...params);
+        return db.prepare(`DELETE FROM jobs WHERE ${where}`).run(...params).changes;
+    });
+    return tx();
+}
+function getProjectActivity(db, opts) {
+    const limit = Math.min(opts.limit, 100);
+    const conditions = [];
+    const params = [];
+    if (opts.before) {
+        conditions.push('started_at < ?');
+        params.push(opts.before);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const jobs = db
+        .prepare(`SELECT * FROM jobs ${where} ORDER BY started_at DESC LIMIT ?`)
+        .all(...params, limit);
+    return jobs.map((j) => {
+        const isTerminal = j.status === 'completed' || j.status === 'failed' || j.status === 'canceled' || j.status === 'zombie_terminated';
+        const type = j.status === 'completed' ? 'job_completed'
+            : j.status === 'failed' ? 'job_failed'
+                : (j.status === 'canceled' || j.status === 'zombie_terminated') ? 'job_canceled'
+                    : 'job_started';
+        const timestamp = isTerminal && j.finished_at ? j.finished_at : j.started_at;
+        const shortCmd = j.command.length > 60 ? j.command.slice(0, 57) + '...' : j.command;
+        const summary = type === 'job_started' ? `Job started: ${shortCmd}`
+            : type === 'job_completed' ? `Job completed: ${shortCmd}`
+                : type === 'job_failed' ? `Job failed: ${shortCmd}`
+                    : j.status === 'zombie_terminated' ? `Job auto-terminated (zombie): ${shortCmd}`
+                        : `Job canceled: ${shortCmd}`;
+        return {
+            id: j.id,
+            type,
+            jobId: j.id,
+            jobCommand: j.command,
+            timestamp,
+            summary,
+            costUsd: isTerminal ? (j.total_cost_usd ?? null) : null,
+        };
+    });
+}
+// ─── Chat DB functions ────────────────────────────────────────────────────────
+function createConversation(db, opts) {
+    const scopeJson = opts.contextScope != null ? JSON.stringify(opts.contextScope) : null;
+    db.prepare('INSERT INTO chat_conversations (id, model, kind, context_scope, provider) VALUES (?, ?, ?, ?, ?)').run(opts.id, opts.model, opts.kind ?? 'sidebar', scopeJson, opts.provider ?? null);
+}
+function listConversations(db) {
+    return db.prepare('SELECT * FROM chat_conversations ORDER BY updated_at DESC').all();
+}
+function getConversation(db, id) {
+    return db.prepare('SELECT * FROM chat_conversations WHERE id = ?').get(id);
+}
+function deleteConversation(db, id) {
+    db.prepare('DELETE FROM chat_conversations WHERE id = ?').run(id);
+}
+function updateConversation(db, id, patch) {
+    const sets = ['updated_at = ?'];
+    const params = [new Date().toISOString()];
+    if (patch.title !== undefined) {
+        sets.push('title = ?');
+        params.push(patch.title);
+    }
+    if (patch.session_id !== undefined) {
+        sets.push('session_id = ?');
+        params.push(patch.session_id);
+    }
+    if (patch.model !== undefined) {
+        sets.push('model = ?');
+        params.push(patch.model);
+    }
+    params.push(id);
+    db.prepare(`UPDATE chat_conversations SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+}
+function addMessage(db, msg) {
+    const result = db.prepare('INSERT INTO chat_messages (conversation_id, role, content) VALUES (?, ?, ?)').run(msg.conversation_id, msg.role, msg.content);
+    return db.prepare('SELECT * FROM chat_messages WHERE id = ?').get(Number(result.lastInsertRowid));
+}
+function getMessages(db, conversationId) {
+    return db.prepare('SELECT * FROM chat_messages WHERE conversation_id = ? ORDER BY id ASC').all(conversationId);
+}
+// ─── Proposal DB functions ────────────────────────────────────────────────────
+function createProposal(db, opts) {
+    db.prepare('INSERT INTO proposals (id, idea, status) VALUES (?, ?, ?)').run(opts.id, opts.idea, 'input');
+}
+function getProposal(db, id) {
+    return db.prepare('SELECT * FROM proposals WHERE id = ?').get(id);
+}
+function listProposals(db, opts) {
+    const limit = Math.min(opts?.limit ?? 20, 100);
+    const offset = opts?.offset ?? 0;
+    const countRow = db
+        .prepare('SELECT COUNT(*) as count FROM proposals')
+        .get();
+    const proposals = db
+        .prepare('SELECT * FROM proposals ORDER BY created_at DESC LIMIT ? OFFSET ?')
+        .all(limit, offset);
+    return { proposals, total: countRow.count };
+}
+function updateProposal(db, id, patch) {
+    const sets = ['updated_at = ?'];
+    const params = [new Date().toISOString()];
+    if (patch.status !== undefined) {
+        sets.push('status = ?');
+        params.push(patch.status);
+    }
+    if (patch.session_id !== undefined) {
+        sets.push('session_id = ?');
+        params.push(patch.session_id);
+    }
+    if (patch.result_markdown !== undefined) {
+        sets.push('result_markdown = ?');
+        params.push(patch.result_markdown);
+    }
+    if (patch.issue_url !== undefined) {
+        sets.push('issue_url = ?');
+        params.push(patch.issue_url);
+    }
+    params.push(id);
+    db.prepare(`UPDATE proposals SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+}
+function deleteProposal(db, id) {
+    db.prepare('DELETE FROM proposals WHERE id = ?').run(id);
+}
+function createTemplate(db, t) {
+    db.prepare('INSERT INTO job_templates (id, name, description, commands) VALUES (?, ?, ?, ?)').run(t.id, t.name, t.description ?? null, JSON.stringify(t.commands));
+}
+function listTemplates(db) {
+    return db.prepare('SELECT * FROM job_templates ORDER BY created_at DESC').all();
+}
+function getTemplate(db, id) {
+    return db.prepare('SELECT * FROM job_templates WHERE id = ?').get(id);
+}
+function updateTemplate(db, id, patch) {
+    const sets = ['updated_at = ?'];
+    const params = [new Date().toISOString()];
+    if (patch.name !== undefined) {
+        sets.push('name = ?');
+        params.push(patch.name);
+    }
+    if (patch.description !== undefined) {
+        sets.push('description = ?');
+        params.push(patch.description);
+    }
+    if (patch.commands !== undefined) {
+        sets.push('commands = ?');
+        params.push(JSON.stringify(patch.commands));
+    }
+    params.push(id);
+    db.prepare(`UPDATE job_templates SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+}
+function deleteTemplate(db, id) {
+    db.prepare('DELETE FROM job_templates WHERE id = ?').run(id);
+}
+function skipJob(db, jobId, reason) {
+    db.prepare(`UPDATE jobs SET status = 'skipped', skip_reason = ?, finished_at = ? WHERE id = ?`).run(reason, new Date().toISOString(), jobId);
+}
+function getPipelineJobs(db, pipelineId) {
+    return db.prepare('SELECT * FROM jobs WHERE pipeline_id = ? ORDER BY queue_position ASC, started_at ASC').all(pipelineId);
+}
+function getStats(db) {
+    const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+    const totalRow = db.prepare(`
+    SELECT
+      COUNT(*) as totalJobs,
+      SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failedJobs,
+      SUM(total_cost_usd) as totalCostUsd,
+      AVG(duration_ms) as avgDurationMs
+    FROM jobs
+  `).get();
+    const todayRow = db.prepare(`
+    SELECT
+      COUNT(*) as jobsToday,
+      SUM(total_cost_usd) as costToday
+    FROM jobs
+    WHERE strftime('%Y-%m-%d', started_at) = ?
+  `).get(today);
+    return {
+        totalJobs: totalRow.totalJobs,
+        failedJobs: totalRow.failedJobs ?? 0,
+        jobsToday: todayRow.jobsToday,
+        totalCostUsd: totalRow.totalCostUsd ?? 0,
+        costToday: todayRow.costToday ?? 0,
+        avgDurationMs: totalRow.avgDurationMs,
+    };
+}
+// ─── Project settings ─────────────────────────────────────────────────────────
+/**
+ * Default pre-prompt used by Ultracode (Claude-only rails) when the project
+ * has no per-project override. Ultracode skips the OpenSpec pipeline entirely:
+ * it hands Claude the spec text plus this instruction and lets it work
+ * autonomously end-to-end.
+ */
+exports.DEFAULT_ULTRACODE_PRE_PROMPT = [
+    'You are operating in ULTRACODE: fully autonomous, end-to-end implementation.',
+    'Implement the following spec COMPLETELY in this repository. You have full access to the codebase and tools.',
+    'Work independently until the feature is done: write the code, the tests, update docs as needed, and make sure everything builds and the test suite passes.',
+    'Do NOT follow any structured architect/developer/reviewer pipeline — use your own judgement and the repo conventions.',
+    'Never ask for confirmation; there is no human to answer. Choose the recommended option and proceed.',
+].join('\n');
+function getProjectSettings(db) {
+    const telemetryRow = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.pipeline_telemetry_enabled'`).get();
+    const modelRow = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.orchestrator_model'`).get();
+    const prePromptRow = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.pre_prompt'`).get();
+    const ultraPrePromptRow = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.ultracode_pre_prompt'`).get();
+    return {
+        pipelineTelemetryEnabled: telemetryRow?.value === 'true',
+        orchestratorModel: modelRow?.value ?? 'sonnet',
+        prePrompt: prePromptRow?.value ?? '',
+        ultraPrePrompt: ultraPrePromptRow?.value ?? '',
+    };
+}
+/** Resolve the effective Ultracode pre-prompt: the per-project override when
+ *  set, otherwise the built-in default. */
+function getUltracodePrePrompt(db) {
+    const override = getProjectSettings(db).ultraPrePrompt.trim();
+    return override || exports.DEFAULT_ULTRACODE_PRE_PROMPT;
+}
+function updateProjectSettings(db, patch) {
+    if (patch.pipelineTelemetryEnabled !== undefined) {
+        db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.pipeline_telemetry_enabled', ?)`).run(patch.pipelineTelemetryEnabled ? 'true' : 'false');
+    }
+    if (patch.orchestratorModel !== undefined) {
+        db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.orchestrator_model', ?)`).run(patch.orchestratorModel);
+    }
+    if (patch.prePrompt !== undefined) {
+        if (patch.prePrompt.trim() === '') {
+            db.prepare(`DELETE FROM queue_state WHERE key = 'config.pre_prompt'`).run();
+        }
+        else {
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.pre_prompt', ?)`).run(patch.prePrompt);
+        }
+    }
+    if (patch.ultraPrePrompt !== undefined) {
+        if (patch.ultraPrePrompt.trim() === '') {
+            db.prepare(`DELETE FROM queue_state WHERE key = 'config.ultracode_pre_prompt'`).run();
+        }
+        else {
+            db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.ultracode_pre_prompt', ?)`).run(patch.ultraPrePrompt);
+        }
+    }
+}
+// ─── Explore Spec acceleration ────────────────────────────────────────────────
+/**
+ * Per-project last-used value for the Quick mode Contract Refine toggle in
+ * the Add Spec modal. Default `false` when never set.
+ */
+function getQuickContractRefineLast(db) {
+    const row = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.add_spec_quick_contract_refine_last'`).get();
+    return row?.value === 'true';
+}
+function hasQuickContractRefineLast(db) {
+    const row = db.prepare(`SELECT 1 FROM queue_state WHERE key = 'config.add_spec_quick_contract_refine_last'`).get();
+    return !!row;
+}
+function setQuickContractRefineLast(db, enabled) {
+    db.prepare(`INSERT OR REPLACE INTO queue_state (key, value) VALUES ('config.add_spec_quick_contract_refine_last', ?)`).run(enabled ? 'true' : 'false');
+}
+function getTelemetryBlob(db, jobId) {
+    return db.prepare('SELECT * FROM telemetry_blobs WHERE jobId = ?').get(jobId);
+}
+function upsertTelemetryBlob(db, row) {
+    db.prepare(`
+    INSERT INTO telemetry_blobs (jobId, path, byteSize, startedAt, endedAt, state)
+    VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT(jobId) DO UPDATE SET
+      path = excluded.path,
+      byteSize = excluded.byteSize,
+      startedAt = COALESCE(telemetry_blobs.startedAt, excluded.startedAt),
+      endedAt = excluded.endedAt,
+      state = excluded.state
+  `).run(row.jobId, row.path ?? null, row.byteSize, row.startedAt ?? null, row.endedAt ?? null, row.state);
+}
+function listActiveTelemetryBlobs(db) {
+    return db.prepare(`SELECT * FROM telemetry_blobs WHERE state = 'active'`).all();
+}
+function setTelemetryBlobCompacted(db, jobId) {
+    db.prepare(`UPDATE telemetry_blobs SET state = 'compacted', path = NULL WHERE jobId = ?`).run(jobId);
+}
+function insertTelemetrySummary(db, row) {
+    db.prepare(`
+    INSERT OR REPLACE INTO telemetry_summaries
+      (jobId, phase, durationMs, tokensInput, tokensOutput, tokensCache, toolCalls, apiErrors, costUsd)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(row.jobId, row.phase, row.durationMs ?? null, row.tokensInput ?? null, row.tokensOutput ?? null, row.tokensCache ?? null, row.toolCalls ?? null, row.apiErrors ?? null, row.costUsd ?? null);
+}
+function getTelemetrySummaries(db, jobId) {
+    return db.prepare('SELECT * FROM telemetry_summaries WHERE jobId = ?').all(jobId);
+}
+function deleteTelemetryForJob(db, jobId) {
+    db.prepare('DELETE FROM telemetry_blobs WHERE jobId = ?').run(jobId);
+    db.prepare('DELETE FROM telemetry_summaries WHERE jobId = ?').run(jobId);
+}
+/** Returns a Set of jobIds that have active or compacted telemetry blobs. */
+function getJobsWithTelemetry(db) {
+    const rows = db.prepare(`SELECT jobId FROM telemetry_blobs WHERE state IN ('active','compacted')`).all();
+    return new Set(rows.map((r) => r.jobId));
+}
+/** True iff the job has an active or compacted telemetry blob row. */
+function hasJobTelemetry(db, jobId) {
+    const row = db.prepare(`SELECT 1 FROM telemetry_blobs WHERE jobId = ? AND state IN ('active','compacted') LIMIT 1`).get(jobId);
+    return row !== undefined;
+}