lastlight 0.1.8 → 0.2.0

package/dist/state/db.js

@@ -1,870 +1,147 @@
 import Database from "better-sqlite3";
 import { resolve } from "path";
+import { migrate } from "./migrate.js";
+import { ExecutionStore } from "./execution-store.js";
+import { ApprovalStore } from "./approval-store.js";
+import { WorkflowRunStore } from "./workflow-run-store.js";
+export { ExecutionStore } from "./execution-store.js";
+export { ApprovalStore } from "./approval-store.js";
+export { WorkflowRunStore } from "./workflow-run-store.js";
 const DEFAULT_DB_PATH = "lastlight.db";
 /**
  * Lightweight SQLite state for operational tracking.
  * NOT for conversation history — only execution logs and rate limits.
+ *
+ * Construction root for the three per-table stores (issue #97): it opens the
+ * single `Database` connection, runs {@link migrate}, and builds
+ * {@link ExecutionStore} / {@link ApprovalStore} / {@link WorkflowRunStore} on
+ * top of it (all sharing the one connection so better-sqlite3 transactions
+ * span every store). Callers reach the stores via `db.runs` / `db.approvals` /
+ * `db.executions`. StateDb itself retains only the cross-cutting cron-override
+ * and workflow kill-switch concerns.
  */
 export class StateDb {
     db;
+    /** Owns the `executions` ledger. */
+    executions;
+    /** Owns the `workflow_approvals` table. */
+    approvals;
+    /** Aggregate root for `workflow_runs` + the atomic lifecycle operations. */
+    runs;
     constructor(dbPath) {
-        this.db = new Database(resolve(dbPath || DEFAULT_DB_PATH));
+        // ":memory:" stays a real per-connection in-memory DB (used by tests for
+        // isolation) — only filesystem paths go through resolve(). Previously
+        // resolve(":memory:") produced a shared on-disk file named ":memory:",
+        // which let parallel test files contend on one DB and deadlock once the
+        // stores started holding write transactions.
+        const target = dbPath === ":memory:" ? ":memory:" : resolve(dbPath || DEFAULT_DB_PATH);
+        this.db = new Database(target);
         this.db.pragma("journal_mode = WAL");
-        this.migrate();
-    }
-    migrate() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS executions (
-        id TEXT PRIMARY KEY,
-        trigger_type TEXT NOT NULL,
-        trigger_id TEXT NOT NULL,
-        skill TEXT NOT NULL,
-        repo TEXT,
-        issue_number INTEGER,
-        started_at TEXT NOT NULL,
-        finished_at TEXT,
-        success INTEGER,
-        error TEXT,
-        turns INTEGER,
-        duration_ms INTEGER
-      );
-
-      CREATE TABLE IF NOT EXISTS rate_limits (
-        resource TEXT PRIMARY KEY,
-        remaining INTEGER,
-        reset_at TEXT,
-        updated_at TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS system_status (
-        component TEXT PRIMARY KEY,
-        state TEXT NOT NULL,
-        reason TEXT,
-        since TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_executions_trigger ON executions(trigger_type, trigger_id);
-      CREATE INDEX IF NOT EXISTS idx_executions_skill ON executions(skill, started_at);
-
-      CREATE TABLE IF NOT EXISTS workflow_runs (
-        id TEXT PRIMARY KEY,
-        workflow_name TEXT NOT NULL,
-        trigger_id TEXT NOT NULL,
-        repo TEXT,
-        issue_number INTEGER,
-        current_phase TEXT NOT NULL,
-        phase_history TEXT NOT NULL DEFAULT '[]',
-        status TEXT NOT NULL DEFAULT 'running',
-        context TEXT,
-        started_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL,
-        finished_at TEXT
-      );
-      CREATE INDEX IF NOT EXISTS idx_workflow_runs_trigger ON workflow_runs(trigger_id, status);
-      CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
-
-      CREATE TABLE IF NOT EXISTS workflow_approvals (
-        id TEXT PRIMARY KEY,
-        workflow_run_id TEXT NOT NULL,
-        gate TEXT NOT NULL,
-        summary TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'pending',
-        requested_by TEXT,
-        responded_by TEXT,
-        response TEXT,
-        responded_at TEXT,
-        created_at TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_approvals_workflow ON workflow_approvals(workflow_run_id);
-      CREATE INDEX IF NOT EXISTS idx_approvals_status ON workflow_approvals(status);
-    `);
-        // Add node_statuses column for DAG parallelism (safe for existing DBs)
-        try {
-            this.db.exec(`ALTER TABLE workflow_runs ADD COLUMN node_statuses TEXT`);
-        }
-        catch {
-            // Column already exists — ignore
-        }
-        // Mutable phase-to-phase state for features like the socratic explore
-        // loop that accumulate data across reply-gate pauses.
-        try {
-            this.db.exec(`ALTER TABLE workflow_runs ADD COLUMN scratch TEXT`);
-        }
-        catch {
-            // Column already exists — ignore
-        }
-        // Gate flavor: 'approve' (explicit approve/reject) vs 'reply' (resolves
-        // on any free-form reply in the same thread — used by the socratic
-        // explore loop).
-        try {
-            this.db.exec(`ALTER TABLE workflow_approvals ADD COLUMN kind TEXT NOT NULL DEFAULT 'approve'`);
-        }
-        catch {
-            // Column already exists — ignore
-        }
-        // Add session_id column to executions so the dashboard can resolve a
-        // phase click to its agent session log. Additive — safe on existing DBs.
-        try {
-            this.db.exec(`ALTER TABLE executions ADD COLUMN session_id TEXT`);
-        }
-        catch {
-            // Column already exists — ignore
-        }
-        // Per-execution Claude usage metrics, captured from the stream-json
-        // result message. Lets the dashboard show cost / tokens per phase and
-        // lets us aggregate spend later. All additive, safe on existing DBs.
-        for (const col of [
-            "cost_usd REAL",
-            "input_tokens INTEGER",
-            "cache_creation_input_tokens INTEGER",
-            "cache_read_input_tokens INTEGER",
-            "output_tokens INTEGER",
-            "api_duration_ms INTEGER",
-            "stop_reason TEXT",
-            // Links a phase execution to its owning workflow_run. Dedup and
-            // "already running / done" checks scope to this column so a fresh
-            // re-trigger of the same workflow on the same issue creates new
-            // executions instead of reusing the old run's rows.
-            "workflow_run_id TEXT",
-        ]) {
-            try {
-                this.db.exec(`ALTER TABLE executions ADD COLUMN ${col}`);
-            }
-            catch {
-                // Column already exists — ignore
-            }
-        }
-        try {
-            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_executions_workflow_run ON executions(workflow_run_id, skill)`);
-        }
-        catch {
-            // Index already exists — ignore
-        }
-    }
-    recordStart(record) {
-        this.db.prepare(`
-      INSERT INTO executions (id, trigger_type, trigger_id, skill, repo, issue_number, started_at, workflow_run_id)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(record.id, record.triggerType, record.triggerId, record.skill, record.repo, record.issueNumber, record.startedAt, record.workflowRunId ?? null);
-    }
-    /**
-     * Mid-run update: persist the agent session id as soon as the executor sees
-     * the stream-json `system/init` line. Lets the dashboard surface the live
-     * session log for an in-flight phase, not just for completed ones.
-     */
-    recordSessionId(id, sessionId) {
-        this.db.prepare(`UPDATE executions SET session_id = ? WHERE id = ?`).run(sessionId, id);
-    }
-    recordFinish(id, result) {
-        this.db.prepare(`
-      UPDATE executions
-      SET finished_at = ?,
-          success = ?,
-          error = ?,
-          turns = ?,
-          duration_ms = ?,
-          session_id = COALESCE(?, session_id),
-          cost_usd = COALESCE(?, cost_usd),
-          input_tokens = COALESCE(?, input_tokens),
-          cache_creation_input_tokens = COALESCE(?, cache_creation_input_tokens),
-          cache_read_input_tokens = COALESCE(?, cache_read_input_tokens),
-          output_tokens = COALESCE(?, output_tokens),
-          api_duration_ms = COALESCE(?, api_duration_ms),
-          stop_reason = COALESCE(?, stop_reason)
-      WHERE id = ?
-    `).run(new Date().toISOString(), result.success ? 1 : 0, result.error, result.turns, result.durationMs, result.sessionId ?? null, result.costUsd ?? null, result.inputTokens ?? null, result.cacheCreationInputTokens ?? null, result.cacheReadInputTokens ?? null, result.outputTokens ?? null, result.apiDurationMs ?? null, result.stopReason ?? null, id);
-    }
-    /**
-     * List chat threads aggregated from the executions table.
-     *
-     * Each row collapses every execution sharing a `trigger_id` (the messaging
-     * session id) into one summary so the dashboard's chat-sessions tab can
-     * show one card per Slack thread, not one per turn. Joined with
-     * `messaging_sessions` for the agent SDK session id (used to resolve to
-     * the on-disk jsonl when streaming messages) and with `messaging_messages`
-     * for the most recent assistant text (preview snippet).
-     */
-    listChatThreads(limit) {
-        const rows = this.db.prepare(`
-      SELECT
-        e.trigger_id              AS triggerId,
-        ms.agent_session_id       AS agentSessionId,
-        MIN(e.started_at)         AS firstStartedAt,
-        MAX(COALESCE(e.finished_at, e.started_at)) AS lastActivityAt,
-        COUNT(*)                  AS turnCount,
-        SUM(COALESCE(e.cost_usd, 0))           AS totalCost,
-        SUM(COALESCE(e.input_tokens, 0))       AS inputTokens,
-        SUM(COALESCE(e.output_tokens, 0))      AS outputTokens,
-        SUM(COALESCE(e.cache_read_input_tokens, 0)) AS cacheReadTokens,
-        (
-          SELECT mm.content
-          FROM messaging_messages mm
-          WHERE mm.session_id = e.trigger_id AND mm.role = 'assistant'
-          ORDER BY mm.timestamp DESC
-          LIMIT 1
-        ) AS lastAssistantContent
-      FROM executions e
-      LEFT JOIN messaging_sessions ms ON ms.id = e.trigger_id
-      WHERE e.skill = 'chat'
-      GROUP BY e.trigger_id
-      ORDER BY lastActivityAt DESC
-      LIMIT ?
-    `).all(limit);
-        return rows;
-    }
-    /** Look up a single chat thread by its messaging session id (= trigger_id). */
-    getChatThread(triggerId) {
-        const row = this.db.prepare(`
-      SELECT
-        e.trigger_id              AS triggerId,
-        ms.agent_session_id       AS agentSessionId,
-        MIN(e.started_at)         AS firstStartedAt,
-        MAX(COALESCE(e.finished_at, e.started_at)) AS lastActivityAt,
-        COUNT(*)                  AS turnCount,
-        SUM(COALESCE(e.cost_usd, 0))           AS totalCost,
-        SUM(COALESCE(e.input_tokens, 0))       AS inputTokens,
-        SUM(COALESCE(e.output_tokens, 0))      AS outputTokens,
-        SUM(COALESCE(e.cache_read_input_tokens, 0)) AS cacheReadTokens,
-        (
-          SELECT mm.content
-          FROM messaging_messages mm
-          WHERE mm.session_id = e.trigger_id AND mm.role = 'assistant'
-          ORDER BY mm.timestamp DESC
-          LIMIT 1
-        ) AS lastAssistantContent
-      FROM executions e
-      LEFT JOIN messaging_sessions ms ON ms.id = e.trigger_id
-      WHERE e.skill = 'chat' AND e.trigger_id = ?
-      GROUP BY e.trigger_id
-    `).get(triggerId);
-        return row ?? null;
-    }
-    /** Check if a skill is currently running for a given trigger */
-    isRunning(skill, triggerId) {
-        const row = this.db.prepare(`
-      SELECT 1 FROM executions
-      WHERE skill = ? AND trigger_id = ? AND finished_at IS NULL
-      LIMIT 1
-    `).get(skill, triggerId);
-        return !!row;
-    }
-    /** Check if a skill has already completed successfully for a given trigger */
-    isCompleted(skill, triggerId) {
-        const row = this.db.prepare(`
-      SELECT 1 FROM executions
-      WHERE skill = ? AND trigger_id = ? AND success = 1
-      LIMIT 1
-    `).get(skill, triggerId);
-        return !!row;
-    }
-    /**
-     * Check if a phase should run: not currently running AND not already
-     * succeeded. When `workflowRunId` is provided, scopes the check to that
-     * specific run — a fresh re-trigger (new workflow_run_id) will see no
-     * matching rows and correctly return "run" even if a prior completed run
-     * for the same trigger exists. Omit `workflowRunId` for legacy callers
-     * (e.g. chat/status-report dedup) that want the old trigger-wide scope.
-     */
-    shouldRunPhase(skill, triggerId, workflowRunId) {
-        const [scopeClause, scopeParam] = workflowRunId
-            ? ["workflow_run_id = ?", workflowRunId]
-            : ["trigger_id = ?", triggerId];
-        const running = this.db.prepare(`
-      SELECT 1 FROM executions
-      WHERE skill = ? AND ${scopeClause} AND finished_at IS NULL
-      LIMIT 1
-    `).get(skill, scopeParam);
-        if (running)
-            return "running";
-        const done = this.db.prepare(`
-      SELECT 1 FROM executions
-      WHERE skill = ? AND ${scopeClause} AND success = 1
-      LIMIT 1
-    `).get(skill, scopeParam);
-        if (done)
-            return "done";
-        return "run";
-    }
-    /** Mark all stale "running" executions for a skill/trigger as failed.
-     *  Called when we detect no matching Docker container is alive. */
-    markStaleAsFailed(skill, triggerId, workflowRunId) {
-        const [scopeClause, scopeParam] = workflowRunId
-            ? ["workflow_run_id = ?", workflowRunId]
-            : ["trigger_id = ?", triggerId];
-        const result = this.db.prepare(`
-      UPDATE executions
-      SET finished_at = ?, success = 0, error = 'stale: container no longer running'
-      WHERE skill = ? AND ${scopeClause} AND finished_at IS NULL
-    `).run(new Date().toISOString(), skill, scopeParam);
-        return result.changes;
-    }
-    /**
-     * Mark every unfinished execution row for a trigger as failed, regardless
-     * of skill. Used by the boot-time recovery sweep to clear out phases that
-     * were running when the harness crashed/restarted, so the runner's dedup
-     * logic doesn't think they're still in flight.
-     */
-    markAllStaleForTrigger(triggerId, reason) {
-        const result = this.db.prepare(`
-      UPDATE executions
-      SET finished_at = ?, success = 0, error = ?
-      WHERE trigger_id = ? AND finished_at IS NULL
-    `).run(new Date().toISOString(), reason, triggerId);
-        return result.changes;
-    }
-    /**
-     * Mark the most recent execution for a skill/trigger as failed.
-     * Used when the agent SDK reported success but the orchestrator decided
-     * the business outcome was a failure (e.g. guardrails BLOCKED, reviewer
-     * REQUEST_CHANGES). Without this, runPhase would skip the phase on the
-     * next run because the DB still says success=1.
-     */
-    markLatestAsFailed(skill, triggerId, reason, workflowRunId) {
-        const [scopeClause, scopeParam] = workflowRunId
-            ? ["workflow_run_id = ?", workflowRunId]
-            : ["trigger_id = ?", triggerId];
-        const result = this.db.prepare(`
-      UPDATE executions
-      SET success = 0, error = ?
-      WHERE id = (
-        SELECT id FROM executions
-        WHERE skill = ? AND ${scopeClause}
-        ORDER BY started_at DESC
-        LIMIT 1
-      )
-    `).run(reason, skill, scopeParam);
-        return result.changes;
-    }
-    /** Get recent executions for a skill */
-    recentExecutions(skill, limit = 10) {
-        return this.db.prepare(`
-      SELECT * FROM executions
-      WHERE skill = ?
-      ORDER BY started_at DESC
-      LIMIT ?
-    `).all(skill, limit);
+        migrate(this.db);
+        this.executions = new ExecutionStore(this.db);
+        this.approvals = new ApprovalStore(this.db);
+        this.runs = new WorkflowRunStore(this.db, { approvals: this.approvals });
+    }
+    // ── Cron overrides ─────────────────────────────────────────────
+    /** Get the override row for a single cron, or null if none. */
+    getCronOverride(name) {
+        const row = this.db
+            .prepare(`SELECT name, enabled, schedule, updated_at, updated_by FROM cron_overrides WHERE name = ?`)
+            .get(name);
+        return row ? this.deserializeCronOverride(row) : null;
     }
-    /** Count consecutive failures for a skill (for cron failure tracking) */
-    consecutiveFailures(skill) {
-        const rows = this.db.prepare(`
-      SELECT success FROM executions
-      WHERE skill = ? AND finished_at IS NOT NULL
-      ORDER BY started_at DESC
-      LIMIT 10
-    `).all(skill);
-        let count = 0;
+    /** All override rows keyed by cron name. */
+    getAllCronOverrides() {
+        const rows = this.db
+            .prepare(`SELECT name, enabled, schedule, updated_at, updated_by FROM cron_overrides`)
+            .all();
+        const map = new Map();
         for (const row of rows) {
-            if (row.success === 0)
-                count++;
-            else
-                break;
+            const o = this.deserializeCronOverride(row);
+            map.set(o.name, o);
         }
-        return count;
-    }
-    /** Update rate limit state */
-    updateRateLimit(resource, remaining, resetAt) {
-        this.db.prepare(`
-      INSERT INTO rate_limits (resource, remaining, reset_at, updated_at)
-      VALUES (?, ?, ?, ?)
-      ON CONFLICT(resource) DO UPDATE SET remaining = ?, reset_at = ?, updated_at = ?
-    `).run(resource, remaining, resetAt, new Date().toISOString(), remaining, resetAt, new Date().toISOString());
-    }
-    /** Get all rate limit records */
-    getRateLimits() {
-        return this.db.prepare(`
-      SELECT resource, remaining, reset_at, updated_at FROM rate_limits
-      ORDER BY resource
-    `).all();
-    }
-    // ── System status (component health tracking) ──
-    /**
-     * Get the current state of a system component.
-     * Returns null if the component has never reported.
-     */
-    getSystemStatus(component) {
-        const row = this.db.prepare(`
-      SELECT state, reason, since, updated_at FROM system_status WHERE component = ?
-    `).get(component);
-        return row || null;
+        return map;
     }
     /**
-     * Set the state of a system component. If the new state differs from the
-     * current state, updates `since` to now (transition timestamp). Returns
-     * true on transition (state changed), false on refresh (state unchanged).
+     * Upsert an override. Pass only the fields you want to change — undefined
+     * fields preserve the existing value (or default to enabled=1, schedule=null
+     * on insert).
      */
-    setSystemStatus(component, state, reason) {
-        const now = new Date().toISOString();
-        const existing = this.getSystemStatus(component);
-        const transitioned = !existing || existing.state !== state;
-        const since = transitioned ? now : existing.since;
-        this.db.prepare(`
-      INSERT INTO system_status (component, state, reason, since, updated_at)
-      VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(component) DO UPDATE SET
-        state = excluded.state,
-        reason = excluded.reason,
-        since = excluded.since,
-        updated_at = excluded.updated_at
-    `).run(component, state, reason || null, since, now);
-        return transitioned;
-    }
-    /** List all known component statuses. */
-    listSystemStatus() {
-        return this.db.prepare(`
-      SELECT component, state, reason, since, updated_at FROM system_status
-      ORDER BY component
-    `).all();
-    }
-    /** Get all executions with pagination */
-    allExecutions(limit = 100, offset = 0) {
-        return this.db.prepare(`
-      SELECT * FROM executions
-      ORDER BY started_at DESC
-      LIMIT ? OFFSET ?
-    `).all(limit, offset);
-    }
-    /**
-     * Get every execution recorded for a workflow run, with camelCase fields
-     * ready for the dashboard. Ordered by start time ascending so phases
-     * display in the order they ran. Scopes to a specific `workflow_run_id`
-     * when provided (preferred — isolates fresh re-triggers from prior runs);
-     * falls back to the legacy trigger-wide scope for rows written before the
-     * workflow_run_id column existed.
-     */
-    getExecutionsForWorkflowRun(workflowRunId, triggerId, workflowName) {
-        const skillPattern = workflowName ? `${workflowName}:%` : "%:%";
-        const rows = this.db.prepare(`
-      SELECT
-        id,
-        trigger_type    AS triggerType,
-        trigger_id      AS triggerId,
-        skill,
-        repo,
-        issue_number    AS issueNumber,
-        started_at      AS startedAt,
-        finished_at     AS finishedAt,
-        success,
-        error,
-        turns,
-        duration_ms     AS durationMs,
-        session_id      AS sessionId,
-        cost_usd        AS costUsd,
-        input_tokens    AS inputTokens,
-        cache_creation_input_tokens AS cacheCreationInputTokens,
-        cache_read_input_tokens     AS cacheReadInputTokens,
-        output_tokens   AS outputTokens,
-        api_duration_ms AS apiDurationMs,
-        stop_reason     AS stopReason,
-        workflow_run_id AS workflowRunId
-      FROM executions
-      WHERE (workflow_run_id = ? OR (workflow_run_id IS NULL AND trigger_id = ?))
-        AND skill LIKE ?
-      ORDER BY started_at ASC
-    `).all(workflowRunId, triggerId, skillPattern);
-        return rows.map((r) => ({
-            id: r.id,
-            triggerType: r.triggerType,
-            triggerId: r.triggerId,
-            skill: r.skill,
-            repo: r.repo ?? undefined,
-            issueNumber: r.issueNumber ?? undefined,
-            startedAt: r.startedAt,
-            finishedAt: r.finishedAt ?? undefined,
-            success: r.success === null || r.success === undefined ? undefined : Boolean(r.success),
-            error: r.error ?? undefined,
-            turns: r.turns ?? undefined,
-            durationMs: r.durationMs ?? undefined,
-            sessionId: r.sessionId ?? undefined,
-            costUsd: r.costUsd ?? undefined,
-            inputTokens: r.inputTokens ?? undefined,
-            cacheCreationInputTokens: r.cacheCreationInputTokens ?? undefined,
-            cacheReadInputTokens: r.cacheReadInputTokens ?? undefined,
-            outputTokens: r.outputTokens ?? undefined,
-            apiDurationMs: r.apiDurationMs ?? undefined,
-            stopReason: r.stopReason ?? undefined,
-            workflowRunId: r.workflowRunId ?? undefined,
-        }));
-    }
-    /** Get currently running executions (no finished_at) */
-    runningExecutions() {
-        return this.db.prepare(`
-      SELECT * FROM executions
-      WHERE finished_at IS NULL
-      ORDER BY started_at DESC
-    `).all();
-    }
-    /** Aggregate execution stats */
-    executionStats() {
-        const today = new Date();
-        today.setHours(0, 0, 0, 0);
-        const todayIso = today.toISOString();
-        const total = this.db.prepare(`SELECT COUNT(*) as c FROM executions`).get().c;
-        const todayCount = this.db.prepare(`SELECT COUNT(*) as c FROM executions WHERE started_at >= ?`).get(todayIso).c;
-        const running = this.db.prepare(`SELECT COUNT(*) as c FROM executions WHERE finished_at IS NULL`).get().c;
-        const skillRows = this.db.prepare(`
-      SELECT skill, COUNT(*) as count,
-        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success,
-        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as fail
-      FROM executions GROUP BY skill
-    `).all();
-        const by_skill = {};
-        for (const r of skillRows) {
-            by_skill[r.skill] = { count: r.count, success: r.success, fail: r.fail };
-        }
-        const triggerRows = this.db.prepare(`
-      SELECT trigger_type, COUNT(*) as count FROM executions GROUP BY trigger_type
-    `).all();
-        const by_trigger = {};
-        for (const r of triggerRows) {
-            by_trigger[r.trigger_type] = r.count;
-        }
-        return { total_executions: total, today_count: todayCount, by_skill, by_trigger, running };
-    }
-    /** Daily aggregated stats for the last N days */
-    dailyStats(days) {
-        // Build the inclusive UTC date window: [today - (days-1), today].
-        // SQLite's date(started_at) returns a UTC YYYY-MM-DD string, so we
-        // generate the same format here to align keys.
-        const today = new Date();
-        const startUtc = new Date(Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate() - (days - 1)));
-        const dateKeys = [];
-        for (let i = 0; i < days; i++) {
-            const d = new Date(startUtc);
-            d.setUTCDate(startUtc.getUTCDate() + i);
-            dateKeys.push(d.toISOString().slice(0, 10));
-        }
-        const rows = this.db.prepare(`
-      SELECT
-        date(started_at) AS date,
-        COUNT(*) AS executions,
-        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) AS successes,
-        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) AS failures,
-        COALESCE(SUM(input_tokens), 0) + COALESCE(SUM(output_tokens), 0) + COALESCE(SUM(cache_read_input_tokens), 0) AS totalTokens,
-        COALESCE(SUM(input_tokens), 0) AS inputTokens,
-        COALESCE(SUM(output_tokens), 0) AS outputTokens,
-        COALESCE(SUM(cache_read_input_tokens), 0) AS cacheReadTokens,
-        COALESCE(SUM(cost_usd), 0) AS costUsd
-      FROM executions
-      WHERE date(started_at) >= ?
-      GROUP BY date(started_at)
-    `).all(dateKeys[0]);
-        const byDate = new Map(rows.map((r) => [r.date, r]));
-        return dateKeys.map((date) => byDate.get(date) ?? {
-            date,
-            executions: 0,
-            successes: 0,
-            failures: 0,
-            totalTokens: 0,
-            inputTokens: 0,
-            outputTokens: 0,
-            cacheReadTokens: 0,
-            costUsd: 0,
-        });
-    }
-    /** Hourly aggregated stats for the last N hours (UTC). Bucket key is `YYYY-MM-DDTHH`. */
-    hourlyStats(hours) {
-        const now = new Date();
-        const startUtc = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), now.getUTCHours() - (hours - 1)));
-        const hourKeys = [];
-        for (let i = 0; i < hours; i++) {
-            const d = new Date(startUtc);
-            d.setUTCHours(startUtc.getUTCHours() + i);
-            // YYYY-MM-DDTHH (matches strftime('%Y-%m-%dT%H', …))
-            hourKeys.push(d.toISOString().slice(0, 13));
-        }
-        const rows = this.db.prepare(`
-      SELECT
-        strftime('%Y-%m-%dT%H', started_at) AS date,
-        COUNT(*) AS executions,
-        SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) AS successes,
-        SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) AS failures,
-        COALESCE(SUM(input_tokens), 0) + COALESCE(SUM(output_tokens), 0) + COALESCE(SUM(cache_read_input_tokens), 0) AS totalTokens,
-        COALESCE(SUM(input_tokens), 0) AS inputTokens,
-        COALESCE(SUM(output_tokens), 0) AS outputTokens,
-        COALESCE(SUM(cache_read_input_tokens), 0) AS cacheReadTokens,
-        COALESCE(SUM(cost_usd), 0) AS costUsd
-      FROM executions
-      WHERE strftime('%Y-%m-%dT%H', started_at) >= ?
-      GROUP BY strftime('%Y-%m-%dT%H', started_at)
-    `).all(hourKeys[0]);
-        const byHour = new Map(rows.map((r) => [r.date, r]));
-        return hourKeys.map((date) => byHour.get(date) ?? {
-            date,
-            executions: 0,
-            successes: 0,
-            failures: 0,
-            totalTokens: 0,
-            inputTokens: 0,
-            outputTokens: 0,
-            cacheReadTokens: 0,
-            costUsd: 0,
-        });
-    }
-    // ── Workflow Runs ──────────────────────────────────────────────
-    /** Create a new workflow run record */
-    createWorkflowRun(run) {
+    setCronOverride(name, patch) {
         const now = new Date().toISOString();
-        this.db.prepare(`
-      INSERT INTO workflow_runs (id, workflow_name, trigger_id, repo, issue_number, current_phase, phase_history, status, context, scratch, started_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, '[]', ?, ?, ?, ?, ?)
-    `).run(run.id, run.workflowName, run.triggerId, run.repo ?? null, run.issueNumber ?? null, run.currentPhase, run.status, run.context ? JSON.stringify(run.context) : null, run.scratch ? JSON.stringify(run.scratch) : null, run.startedAt, now);
+        const existing = this.getCronOverride(name);
+        const enabled = patch.enabled ?? existing?.enabled ?? true;
+        const schedule = patch.schedule === undefined ? existing?.schedule ?? null : patch.schedule;
+        this.db
+            .prepare(`INSERT INTO cron_overrides (name, enabled, schedule, updated_at, updated_by)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(name) DO UPDATE SET
+           enabled = excluded.enabled,
+           schedule = excluded.schedule,
+           updated_at = excluded.updated_at,
+           updated_by = excluded.updated_by`)
+            .run(name, enabled ? 1 : 0, schedule, now, patch.updatedBy ?? null);
+    }
+    /** Remove the override entirely (revert to YAML defaults). */
+    clearCronOverride(name) {
+        this.db.prepare(`DELETE FROM cron_overrides WHERE name = ?`).run(name);
+    }
+    deserializeCronOverride(row) {
+        return {
+            name: row.name,
+            enabled: row.enabled === 1,
+            schedule: row.schedule ?? null,
+            updatedAt: row.updated_at,
+            updatedBy: row.updated_by ?? null,
+        };
     }
+    // ── Workflow overrides (kill switch) ───────────────────────────
     /**
-     * Top-level merge of `patch` into the workflow run's scratch state.
-     * Loop iterations can append to `scratch.socratic.qa` without clobbering
-     * other keys.
+     * Cheap check used by every dispatch path. Returns true unless an explicit
+     * `workflow_overrides` row says otherwise.
      */
-    updateWorkflowRunScratch(id, patch) {
-        const now = new Date().toISOString();
+    isWorkflowEnabled(name) {
         const row = this.db
-            .prepare(`SELECT scratch FROM workflow_runs WHERE id = ?`)
-            .get(id);
+            .prepare(`SELECT enabled FROM workflow_overrides WHERE name = ?`)
+            .get(name);
         if (!row)
-            return;
-        const current = row.scratch ? JSON.parse(row.scratch) : {};
-        const merged = { ...current, ...patch };
-        this.db
-            .prepare(`UPDATE workflow_runs SET scratch = ?, updated_at = ? WHERE id = ?`)
-            .run(JSON.stringify(merged), now, id);
-    }
-    /** Update the current phase and append to phase history */
-    updateWorkflowPhase(id, phase, entry) {
-        const now = new Date().toISOString();
-        const row = this.db.prepare(`SELECT phase_history FROM workflow_runs WHERE id = ?`).get(id);
-        if (!row)
-            return;
-        const history = JSON.parse(row.phase_history);
-        history.push(entry);
-        this.db.prepare(`
-      UPDATE workflow_runs SET current_phase = ?, phase_history = ?, updated_at = ? WHERE id = ?
-    `).run(phase, JSON.stringify(history), now, id);
-    }
-    /** Mark a workflow run as finished */
-    finishWorkflowRun(id, status, error) {
-        const now = new Date().toISOString();
-        this.db.prepare(`
-      UPDATE workflow_runs SET status = ?, finished_at = ?, updated_at = ?, context = CASE
-        WHEN ? IS NOT NULL THEN json_patch(COALESCE(context, '{}'), json_object('error', ?))
-        ELSE context
-      END WHERE id = ?
-    `).run(status, now, now, error ?? null, error ?? null, id);
-    }
-    /** Get a single workflow run by ID */
-    getWorkflowRun(id) {
-        const row = this.db.prepare(`SELECT * FROM workflow_runs WHERE id = ?`).get(id);
-        return row ? this.deserializeWorkflowRun(row) : null;
+            return true;
+        return row.enabled === 1;
     }
-    /** Find the most recent active (running or paused) workflow run for a trigger */
-    getWorkflowRunByTrigger(triggerId) {
-        const row = this.db.prepare(`
-      SELECT * FROM workflow_runs
-      WHERE trigger_id = ? AND status IN ('running', 'paused')
-      ORDER BY started_at DESC
-      LIMIT 1
-    `).get(triggerId);
-        return row ? this.deserializeWorkflowRun(row) : null;
-    }
-    /** List all active (running or paused) workflow runs */
-    activeWorkflowRuns() {
-        const rows = this.db.prepare(`
-      SELECT * FROM workflow_runs WHERE status IN ('running', 'paused') ORDER BY started_at DESC
-    `).all();
-        return rows.map((r) => this.deserializeWorkflowRun(r));
-    }
-    /** List recent workflow runs, ordered by start time descending */
-    recentWorkflowRuns(limit = 20) {
-        const rows = this.db.prepare(`
-      SELECT * FROM workflow_runs ORDER BY started_at DESC LIMIT ?
-    `).all(limit);
-        return rows.map((r) => this.deserializeWorkflowRun(r));
-    }
-    /**
-     * List workflow runs with pagination + filters. Returns the page slice
-     * AND the post-filter total so the dashboard knows how many remain.
-     *
-     * - sinceIso filters `started_at >= sinceIso` (used for the header date range).
-     * - workflowName filters by exact `workflow_name`.
-     * - statuses filters to one of the workflow statuses (`running`, `paused`,
-     *   `succeeded`, `failed`, `cancelled`). Used for the dashboard's "live"
-     *   filter, which maps to ['running','paused'].
-     */
-    listWorkflowRuns(opts = {}) {
-        const limit = opts.limit ?? 20;
-        const offset = opts.offset ?? 0;
-        const where = [];
-        const params = [];
-        if (opts.sinceIso) {
-            where.push("started_at >= ?");
-            params.push(opts.sinceIso);
-        }
-        if (opts.workflowName) {
-            where.push("workflow_name = ?");
-            params.push(opts.workflowName);
-        }
-        if (opts.statuses && opts.statuses.length > 0) {
-            where.push(`status IN (${opts.statuses.map(() => "?").join(",")})`);
-            params.push(...opts.statuses);
-        }
-        const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
-        const total = this.db
-            .prepare(`SELECT COUNT(*) as c FROM workflow_runs ${whereClause}`)
-            .get(...params).c;
-        const rows = this.db
-            .prepare(`SELECT * FROM workflow_runs ${whereClause} ORDER BY started_at DESC LIMIT ? OFFSET ?`)
-            .all(...params, limit, offset);
-        return {
-            runs: rows.map((r) => this.deserializeWorkflowRun(r)),
-            total,
-        };
+    getWorkflowOverride(name) {
+        const row = this.db
+            .prepare(`SELECT name, enabled, updated_at, updated_by FROM workflow_overrides WHERE name = ?`)
+            .get(name);
+        return row ? this.deserializeWorkflowOverride(row) : null;
     }
-    /** Distinct workflow_name values, sorted alphabetically. */
-    distinctWorkflowNames() {
+    getAllWorkflowOverrides() {
         const rows = this.db
-            .prepare(`SELECT DISTINCT workflow_name FROM workflow_runs ORDER BY workflow_name ASC`)
+            .prepare(`SELECT name, enabled, updated_at, updated_by FROM workflow_overrides`)
             .all();
-        return rows.map((r) => r.workflow_name);
-    }
-    /** Cancel a workflow run */
-    cancelWorkflowRun(id) {
-        const now = new Date().toISOString();
-        this.db.prepare(`
-      UPDATE workflow_runs SET status = 'cancelled', updated_at = ?, finished_at = ? WHERE id = ?
-    `).run(now, now, id);
-    }
-    /** Pause a workflow run (waiting for approval) */
-    pauseWorkflowRun(id) {
-        const now = new Date().toISOString();
-        this.db.prepare(`
-      UPDATE workflow_runs SET status = 'paused', updated_at = ? WHERE id = ?
-    `).run(now, id);
-    }
-    /** Resume a paused workflow run (set back to running) */
-    resumeWorkflowRun(id) {
-        const now = new Date().toISOString();
-        this.db.prepare(`
-      UPDATE workflow_runs SET status = 'running', updated_at = ? WHERE id = ?
-    `).run(now, id);
-    }
-    // ── Workflow Approvals ─────────────────────────────────────────
-    /** Create a new pending approval request */
-    createApproval(approval) {
-        this.db
-            .prepare(`
-      INSERT INTO workflow_approvals (id, workflow_run_id, gate, summary, status, kind, requested_by, created_at)
-      VALUES (?, ?, ?, ?, 'pending', ?, ?, ?)
-    `)
-            .run(approval.id, approval.workflowRunId, approval.gate, approval.summary, approval.kind ?? "approve", approval.requestedBy ?? null, approval.createdAt);
+        const map = new Map();
+        for (const row of rows) {
+            const o = this.deserializeWorkflowOverride(row);
+            map.set(o.name, o);
+        }
+        return map;
     }
-    /**
-     * Resolve a reply gate: marks the approval row as approved (reply gates
-     * don't have approve/reject semantics — any reply is a "go") and stores
-     * the reply text as the `response`. Used by the socratic explore loop.
-     */
-    resolveReplyGate(id, replyText, responder) {
+    setWorkflowEnabled(name, enabled, updatedBy) {
         const now = new Date().toISOString();
         this.db
-            .prepare(`UPDATE workflow_approvals
-           SET status = 'approved',
-               responded_by = ?,
-               response = ?,
-               responded_at = ?
-         WHERE id = ? AND kind = 'reply'`)
-            .run(responder, replyText, now, id);
-    }
-    /**
-     * Find the most recent pending reply gate for a given trigger id. Used by
-     * the router to short-circuit free-form replies on a paused socratic
-     * explore loop without re-running classifier logic.
-     */
-    getPendingReplyGateByTrigger(triggerId) {
-        const row = this.db
-            .prepare(`SELECT wa.* FROM workflow_approvals wa
-         JOIN workflow_runs wr ON wa.workflow_run_id = wr.id
-         WHERE wr.trigger_id = ? AND wa.status = 'pending' AND wa.kind = 'reply'
-         ORDER BY wa.created_at DESC
-         LIMIT 1`)
-            .get(triggerId);
-        return row ? this.deserializeApproval(row) : null;
-    }
-    /** Get a single approval by ID */
-    getApproval(id) {
-        const row = this.db.prepare(`SELECT * FROM workflow_approvals WHERE id = ?`).get(id);
-        return row ? this.deserializeApproval(row) : null;
-    }
-    /** Find the pending approval for a workflow run */
-    getPendingApprovalForWorkflow(workflowRunId) {
-        const row = this.db.prepare(`
-      SELECT * FROM workflow_approvals WHERE workflow_run_id = ? AND status = 'pending' LIMIT 1
-    `).get(workflowRunId);
-        return row ? this.deserializeApproval(row) : null;
-    }
-    /** Find the pending approval by trigger ID (join with workflow_runs) */
-    getPendingApprovalByTrigger(triggerId) {
-        const row = this.db.prepare(`
-      SELECT wa.* FROM workflow_approvals wa
-      JOIN workflow_runs wr ON wa.workflow_run_id = wr.id
-      WHERE wr.trigger_id = ? AND wa.status = 'pending'
-      ORDER BY wa.created_at DESC
-      LIMIT 1
-    `).get(triggerId);
-        return row ? this.deserializeApproval(row) : null;
-    }
-    /** List all pending approvals */
-    listPendingApprovals() {
-        const rows = this.db.prepare(`
-      SELECT * FROM workflow_approvals WHERE status = 'pending' ORDER BY created_at DESC
-    `).all();
-        return rows.map((r) => this.deserializeApproval(r));
-    }
-    /** Record the response to an approval */
-    respondToApproval(id, status, respondedBy, response) {
-        const now = new Date().toISOString();
-        this.db.prepare(`
-      UPDATE workflow_approvals SET status = ?, responded_by = ?, response = ?, responded_at = ? WHERE id = ?
-    `).run(status, respondedBy, response ?? null, now, id);
-    }
-    /** Update a single node's status in the workflow run's nodeStatuses map. */
-    updateNodeStatus(workflowId, nodeName, status) {
-        const now = new Date().toISOString();
-        const row = this.db.prepare(`SELECT node_statuses FROM workflow_runs WHERE id = ?`).get(workflowId);
-        if (!row)
-            return;
-        const statuses = row.node_statuses ? JSON.parse(row.node_statuses) : {};
-        statuses[nodeName] = status;
-        this.db.prepare(`UPDATE workflow_runs SET node_statuses = ?, updated_at = ? WHERE id = ?`).run(JSON.stringify(statuses), now, workflowId);
-    }
-    deserializeApproval(row) {
-        return {
-            id: row.id,
-            workflowRunId: row.workflow_run_id,
-            gate: row.gate,
-            summary: row.summary,
-            status: row.status,
-            kind: (row.kind || "approve"),
-            requestedBy: row.requested_by || undefined,
-            respondedBy: row.responded_by || undefined,
-            response: row.response || undefined,
-            respondedAt: row.responded_at || undefined,
-            createdAt: row.created_at,
-        };
-    }
-    deserializeWorkflowRun(row) {
+            .prepare(`INSERT INTO workflow_overrides (name, enabled, updated_at, updated_by)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(name) DO UPDATE SET
+           enabled = excluded.enabled,
+           updated_at = excluded.updated_at,
+           updated_by = excluded.updated_by`)
+            .run(name, enabled ? 1 : 0, now, updatedBy ?? null);
+    }
+    deserializeWorkflowOverride(row) {
         return {
-            id: row.id,
-            workflowName: row.workflow_name,
-            triggerId: row.trigger_id,
-            repo: row.repo,
-            issueNumber: row.issue_number,
-            currentPhase: row.current_phase,
-            phaseHistory: JSON.parse(row.phase_history),
-            status: row.status,
-            context: row.context ? JSON.parse(row.context) : undefined,
-            scratch: row.scratch ? JSON.parse(row.scratch) : undefined,
-            nodeStatuses: row.node_statuses ? JSON.parse(row.node_statuses) : undefined,
-            startedAt: row.started_at,
+            name: row.name,
+            enabled: row.enabled === 1,
             updatedAt: row.updated_at,
-            finishedAt: row.finished_at,
+            updatedBy: row.updated_by ?? null,
         };
     }
     /** Expose the underlying Database instance (for SessionManager, etc.) */