@detergent-software/conductor 1.0.0-dev.2 → 1.0.0-dev.21

package/build/store.js

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'node:events';
+import { existsSync } from 'node:fs';
 import { DatabaseSync } from 'node:sqlite';
 import { z } from 'zod';
 import { ConductorError } from "./errors.js";
@@ -173,6 +174,61 @@ export const MIGRATIONS = [
     bytes      INTEGER NOT NULL DEFAULT 0,
     recent_ids TEXT NOT NULL DEFAULT '[]'
   ) STRICT;
+  `,
+    // 3: the inbox (ATK-312). An item may belong to a worker (a stall, a failed session) and may
+    // carry the condition whose wait resolves it (an approval, a PR, an npm version).
+    `
+  ALTER TABLE inbox ADD COLUMN worker INTEGER;
+  ALTER TABLE inbox ADD COLUMN condition TEXT;
+  CREATE INDEX inbox_open ON inbox (resolved_at, id);
+  `,
+    // 4: the notifier (ATK-313). One row per inbox item it routed: the channels, the reminders its
+    // rule gave it, how many pushes went out and when the last did, and whether quiet hours hold it.
+    // `dedupe_key` finds an earlier push of the same item, kind and text.
+    `
+  CREATE TABLE notify_state (
+    inbox        INTEGER PRIMARY KEY,
+    dedupe_key   TEXT NOT NULL,
+    channels     TEXT NOT NULL DEFAULT '[]',
+    remind_after REAL NOT NULL,
+    remind_times INTEGER NOT NULL,
+    sends        INTEGER NOT NULL DEFAULT 0,
+    last_sent_at TEXT,
+    held_at      TEXT
+  ) STRICT;
+  CREATE INDEX notify_state_dedupe ON notify_state (dedupe_key, last_sent_at);
+  CREATE INDEX overrides_by_kind ON overrides (kind, id);
+  `,
+    // 5: the scheduler (ATK-315). `items` holds each project's last queue read: the state's type
+    // (backlog, started, completed …), the tracker project it is in, when it was created, and
+    // `blocked_by` as the blockers still open, so a read that finds none left says it unblocked.
+    `
+  ALTER TABLE items ADD COLUMN state_type TEXT;
+  ALTER TABLE items ADD COLUMN tracker_project TEXT;
+  ALTER TABLE items ADD COLUMN created_at TEXT;
+  `,
+    // 6: rule actions (ATK-315). A state rule fires once per subject while it holds: `rule_state`
+    // keeps the ones that hold now, so a restart doesn't fire them again. An override says who set
+    // it (a command, or a rule's ref), so a rule ends only the pause it set.
+    `
+  CREATE TABLE rule_state (
+    rule     TEXT NOT NULL,
+    subject  TEXT NOT NULL,
+    fired_at TEXT NOT NULL,
+    PRIMARY KEY (rule, subject)
+  ) STRICT;
+  ALTER TABLE overrides ADD COLUMN set_by TEXT;
+  `,
+    // 7: the port broker (ATK-318). Each worktree's slot and the ports it gives (base + slot), so
+    // worktrees of every project get ports no other one has. Its locks (chrome) go in `locks`.
+    `
+  CREATE TABLE ports (
+    worktree    TEXT PRIMARY KEY,
+    project     TEXT NOT NULL,
+    slot        INTEGER NOT NULL,
+    ports       TEXT NOT NULL,
+    assigned_at TEXT NOT NULL
+  ) STRICT;
   `,
 ];
 export const SCHEMA_VERSION = MIGRATIONS.length;
@@ -220,6 +276,8 @@ export const workerSchema = z.object({
     id: z.number(),
     item: z.string(),
     name: z.string(),
+    // The newest phase note it wrote through `conduct note` (Started, Plan, PR opened, …).
+    phase: z.string().nullable(),
     probe: z.boolean(),
     project: z.string(),
     sessionId: z.string().nullable(),
@@ -237,6 +295,68 @@ export const waitSchema = z.object({
     resolvedAt: z.string().nullable(),
     worker: z.number(),
 });
+// What waits on Jason (design note, section 7). The scheduler raises `ready-to-release` and
+// `queue-drained`; `prod-approval` belongs to `/release-atk`, which raises none yet. `console` is the
+// console's finding on an escalation that needs Jason (`conduct escalations done --ask`).
+export const INBOX_KINDS = [
+    'plan',
+    'merge',
+    'npm-otp',
+    'prod-approval',
+    'permission',
+    'jason',
+    'human',
+    'scope',
+    'blocked',
+    'abandoned',
+    'failed',
+    'stall',
+    'runaway',
+    'ready-to-release',
+    'queue-drained',
+    'console',
+];
+export const inboxItemSchema = z.object({
+    commands: z.array(z.string()),
+    // The full-form condition whose wait resolves it, when one is known.
+    condition: z.string().nullable(),
+    id: z.number(),
+    // The tracker item it is about, such as ATK-312.
+    item: z.string().nullable(),
+    kind: z.enum(INBOX_KINDS),
+    links: z.array(z.string()),
+    project: z.string().nullable(),
+    raisedAt: z.string(),
+    resolvedAt: z.string().nullable(),
+    // What resolved it: the condition seen, a later note, or Jason's answer.
+    resolvedBy: z.string().nullable(),
+    text: z.string(),
+    worker: z.number().nullable(),
+});
+export const NO_EXPIRY = '9999-12-31T23:59:59.999Z';
+const queueItemRow = z.object({
+    area: z.string().nullable(),
+    blocked_by: z.string(),
+    created_at: z.string().nullable(),
+    id: z.string(),
+    labels: z.string(),
+    priority: z.number().nullable(),
+    state_type: z.string().nullable(),
+    title: z.string().nullable(),
+    tracker_project: z.string().nullable(),
+});
+// A checkout's dev ports from the broker. A main checkout has slot 0 and isn't stored, so its
+// `assignedAt` is null.
+export const portAssignmentSchema = z.object({
+    assignedAt: z.string().nullable(),
+    ports: z.record(z.string(), z.number()),
+    project: z.string(),
+    slot: z.number(),
+    worktree: z.string(),
+});
+// A broker lock: who holds it, and when they last acquired it.
+export const lockSchema = z.object({ holder: z.string(), name: z.string(), since: z.string() });
+const portsRow = z.object({ assigned_at: z.string(), ports: z.string(), project: z.string(), slot: z.number(), worktree: z.string() });
 const workerRow = z.object({
     attached_at: z.string().nullable(),
     branch: z.string().nullable(),
@@ -245,6 +365,7 @@ const workerRow = z.object({
     id: z.number(),
     item: z.string(),
     name: z.string(),
+    phase: z.string().nullable(),
     probe: z.number(),
     project: z.string(),
     session_id: z.string().nullable(),
@@ -262,10 +383,44 @@ const waitRow = z.object({
     resolved_at: z.string().nullable(),
     worker: z.number(),
 });
+const inboxRow = z.object({
+    commands: z.string(),
+    condition: z.string().nullable(),
+    id: z.number(),
+    item: z.string().nullable(),
+    kind: z.enum(INBOX_KINDS),
+    links: z.string(),
+    project: z.string().nullable(),
+    raised_at: z.string(),
+    resolved_at: z.string().nullable(),
+    resolved_by: z.string().nullable(),
+    text: z.string(),
+    worker: z.number().nullable(),
+});
+const notifyRow = z.object({
+    channels: z.string(),
+    dedupe_key: z.string(),
+    held_at: z.string().nullable(),
+    inbox: z.number(),
+    last_sent_at: z.string().nullable(),
+    remind_after: z.number(),
+    remind_times: z.number(),
+    sends: z.number(),
+});
+const overrideRow = z.object({
+    created_at: z.string(),
+    id: z.number(),
+    kind: z.string(),
+    project: z.string().nullable(),
+    set_by: z.string().nullable(),
+    until: z.string(),
+    value: z.string(),
+});
 const PATCH_KEYS = [
     'attachedAt',
     'branch',
     'handle',
+    'phase',
     'sessionId',
     'status',
     'stoppedAt',
@@ -275,16 +430,27 @@ const WORKER_COLUMNS = {
     attachedAt: 'attached_at',
     branch: 'branch',
     handle: 'handle',
+    phase: 'phase',
     sessionId: 'session_id',
     status: 'status',
     stoppedAt: 'stopped_at',
     worktree: 'worktree',
 };
-export function openStore(file, now = () => new Date()) {
-    const db = new DatabaseSync(file);
+// `readOnly` opens the database as it is, for a reader beside a daemon that may be older (conduct
+// history): it never migrates, so it can't move the schema out from under a running daemon.
+export function openStore(file, now = () => new Date(), { readOnly = false } = {}) {
+    if (readOnly && !existsSync(file))
+        throw new ConductorError(`${file} doesn't exist: the conductor hasn't recorded anything yet`);
+    const db = new DatabaseSync(file, { readOnly });
     try {
-        db.exec('PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;');
-        migrate(db, file);
+        if (readOnly) {
+            db.exec('PRAGMA busy_timeout = 5000;');
+            schemaVersion(db, file);
+        }
+        else {
+            db.exec('PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;');
+            migrate(db, file);
+        }
     }
     catch (error) {
         db.close();
@@ -327,6 +493,9 @@ export function openStore(file, now = () => new Date()) {
            tokens = tokens + excluded.tokens, input = input + excluded.input, output = output + excluded.output,
            cache_read = cache_read + excluded.cache_read, cache_write = cache_write + excluded.cache_write`).run(worker, project, item, day, totalTokens(usage), usage.input, usage.output, usage.cacheRead, usage.cacheWrite);
         },
+        addTodo: ({ action, after, item, project }) => z
+            .object({ id: z.number() })
+            .parse(db.prepare('INSERT INTO todos (project, item, action, after, created_at) VALUES (?, ?, ?, ?, ?) RETURNING id').get(project, item, action, after, now().toISOString())).id,
         addWait: (worker, condition) => toWait(db
             .prepare('INSERT INTO waits (worker, condition, created_at) VALUES (?, ?, ?) RETURNING *')
             .get(worker, condition, now().toISOString())),
@@ -337,18 +506,76 @@ export function openStore(file, now = () => new Date()) {
             db.prepare(`UPDATE waits SET resolved_at = coalesce(resolved_at, ?), resolution = coalesce(resolution, ?), delivered_at = ?
          WHERE worker = ? AND delivered_at IS NULL`).run(at, resolution, at, worker);
         },
+        deleteLock: (name) => {
+            db.prepare('DELETE FROM locks WHERE name = ?').run(name);
+        },
+        deletePorts: (worktree) => {
+            const row = db.prepare('DELETE FROM ports WHERE worktree = ? RETURNING *').get(worktree);
+            return row === undefined ? null : toPorts(row);
+        },
         deliverWaits: (ids) => {
             const deliver = db.prepare('UPDATE waits SET delivered_at = ? WHERE id = ? AND resolved_at IS NOT NULL');
             const at = now().toISOString();
             for (const id of ids)
                 deliver.run(at, id);
         },
+        dueTodos: (at) => z
+            .array(z.object({ action: z.string(), after: z.string(), created_at: z.string(), id: z.number(), item: z.string().nullable(), project: z.string().nullable() }))
+            .parse(db.prepare('SELECT id, project, item, action, after, created_at FROM todos WHERE done_at IS NULL AND after <= ? ORDER BY id').all(at))
+            .map(({ created_at: createdAt, ...t }) => ({ ...t, createdAt })),
+        escalationHandled: (id) => db.prepare("SELECT 1 FROM events WHERE kind = 'console.handled' AND json_extract(data, '$.cause') = ? LIMIT 1").get(id) !== undefined,
         eventsAfter: (id, limit = 500) => selectAfter.all(id, limit).map((row) => eventRow.parse(row)),
+        eventsBetween: ({ since, until }, { kinds, project, subjects, workers } = {}) => {
+            const where = [];
+            const args = [];
+            const add = (clause, arg) => {
+                where.push(clause);
+                args.push(arg);
+            };
+            add('at < ?', until);
+            if (since !== null)
+                add('at >= ?', since);
+            if (kinds)
+                add('kind IN (SELECT value FROM json_each(?))', JSON.stringify(kinds));
+            if (project !== undefined)
+                add('project IS ?', project);
+            if (subjects)
+                add('upper(subject) IN (SELECT upper(value) FROM json_each(?))', JSON.stringify(subjects));
+            if (workers)
+                add("json_extract(data, '$.worker') IN (SELECT value FROM json_each(?))", JSON.stringify(workers));
+            return db.prepare(`SELECT * FROM events WHERE ${where.join(' AND ')} ORDER BY id`).all(...args).map((row) => eventRow.parse(row));
+        },
+        finishTodo: (id) => {
+            db.prepare('UPDATE todos SET done_at = ? WHERE id = ?').run(now().toISOString(), id);
+        },
+        getEvent: (id) => {
+            const row = db.prepare('SELECT * FROM events WHERE id = ?').get(id);
+            return row === undefined ? null : eventRow.parse(row);
+        },
+        getInbox: (id) => {
+            const row = db.prepare('SELECT * FROM inbox WHERE id = ?').get(id);
+            return row === undefined ? null : toInbox(row);
+        },
+        getLock: (name) => {
+            const row = db.prepare('SELECT * FROM locks WHERE name = ?').get(name);
+            return row === undefined ? null : lockSchema.parse(row);
+        },
+        getNotifyState: (inbox) => {
+            const row = db.prepare('SELECT * FROM notify_state WHERE inbox = ?').get(inbox);
+            return row === undefined ? null : toNotifyState(row);
+        },
         getWait: (id) => {
             const row = db.prepare('SELECT * FROM waits WHERE id = ?').get(id);
             return row === undefined ? null : toWait(row);
         },
         getWorker,
+        holdRule: (rule, subject) => db.prepare('INSERT INTO rule_state (rule, subject, fired_at) VALUES (?, ?, ?) ON CONFLICT DO NOTHING').run(rule, subject, now().toISOString()).changes > 0,
+        inboxOf: (worker) => db.prepare('SELECT * FROM inbox WHERE worker = ? ORDER BY id').all(worker).map(toInbox),
+        inboxRaisedBetween: (since, until) => db.prepare('SELECT * FROM inbox WHERE raised_at >= ? AND raised_at < ? ORDER BY id').all(since, until).map(toInbox),
+        insertInbox: ({ commands, condition, item, kind, links, project, text, worker }) => toInbox(db
+            .prepare(`INSERT INTO inbox (project, item, worker, kind, text, commands, links, condition, raised_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`)
+            .get(project, item, worker, kind, text, JSON.stringify(commands), JSON.stringify(links), condition, now().toISOString())),
         insertWorker: ({ item, name, probe, project }) => {
             const at = now().toISOString();
             try {
@@ -364,17 +591,107 @@ export function openStore(file, now = () => new Date()) {
                 throw error;
             }
         },
+        itemTitles: () => new Map(z
+            .array(z.object({ id: z.string(), project: z.string(), title: z.string() }))
+            .parse(db.prepare('SELECT project, id, title FROM items WHERE title IS NOT NULL').all())
+            .map((r) => [`${r.project}|${r.id.toUpperCase()}`, r.title])),
+        lastNotified: (dedupeKey, since) => {
+            const row = db
+                .prepare('SELECT * FROM notify_state WHERE dedupe_key = ? AND sends > 0 AND last_sent_at >= ? ORDER BY last_sent_at DESC, inbox DESC LIMIT 1')
+                .get(dedupeKey, since);
+            return row === undefined ? null : toNotifyState(row);
+        },
+        latestEvent: (kinds) => {
+            const row = kinds === undefined
+                ? db.prepare('SELECT * FROM events ORDER BY id DESC LIMIT 1').get()
+                : db.prepare('SELECT * FROM events WHERE kind IN (SELECT value FROM json_each(?)) ORDER BY id DESC LIMIT 1').get(JSON.stringify(kinds));
+            return row === undefined ? null : eventRow.parse(row);
+        },
         latestEventId: () => z.object({ id: z.number() }).parse(db.prepare('SELECT coalesce(max(id), 0) AS id FROM events').get()).id,
+        latestInbox: (project, item, kind) => {
+            const row = db
+                .prepare('SELECT * FROM inbox WHERE project IS ? AND upper(item) = upper(?) AND kind = ? ORDER BY id DESC LIMIT 1')
+                .get(project, item, kind);
+            return row === undefined ? null : toInbox(row);
+        },
+        latestTier: (project, item) => {
+            const row = db
+                .prepare(`SELECT json_extract(data, '$.tier') AS tier FROM events
+           WHERE kind = 'note.posted' AND project = ? AND upper(subject) = upper(?) AND json_extract(data, '$.tier') IS NOT NULL
+           ORDER BY id DESC LIMIT 1`)
+                .get(project, item);
+            return row === undefined ? null : z.object({ tier: z.string() }).parse(row).tier;
+        },
+        listLocks: () => z.array(lockSchema).parse(db.prepare('SELECT * FROM locks ORDER BY name').all()),
         listProjects: () => db.prepare('SELECT * FROM projects ORDER BY name').all().map(toProject),
         listWorkers: (statuses = WORKER_STATUSES) => db
             .prepare(`SELECT * FROM workers WHERE status IN (${statuses.map(() => '?').join(', ')}) ORDER BY id`)
             .all(...statuses)
             .map(toWorker),
+        liveNotifyStates: () => db
+            .prepare(`SELECT n.* FROM notify_state n JOIN inbox i ON i.id = n.inbox
+           WHERE i.resolved_at IS NULL OR n.held_at IS NOT NULL ORDER BY n.inbox`)
+            .all()
+            .map(toNotifyState),
+        liveOverride: (kind, project = null) => {
+            const row = db
+                .prepare('SELECT * FROM overrides WHERE kind = ? AND project IS ? AND until > ? ORDER BY id DESC LIMIT 1')
+                .get(kind, project, now().toISOString());
+            return row === undefined ? null : toOverride(row);
+        },
+        liveOverrides: () => db
+            .prepare(`SELECT * FROM overrides o WHERE until > ? AND id = (
+             SELECT max(id) FROM overrides n WHERE n.kind = o.kind AND n.project IS o.project AND n.until > ?)
+           ORDER BY id`)
+            .all(now().toISOString(), now().toISOString())
+            .map(toOverride),
         onEvent: (listener) => {
             emitter.on('event', listener);
             return () => emitter.off('event', listener);
         },
+        openEscalations: (since) => {
+            // Two scans, not a correlated subquery: `events` has no index on kind, and adding one would be
+            // a migration an older daemon refuses to open (a downgrade).
+            const handled = new Set(z
+                .array(z.object({ cause: z.number().nullable() }))
+                .parse(db.prepare("SELECT json_extract(data, '$.cause') AS cause FROM events WHERE kind = 'console.handled'").all())
+                .map((r) => r.cause));
+            return db
+                .prepare("SELECT * FROM events WHERE kind = 'console.escalated' AND at >= ? ORDER BY id")
+                .all(since)
+                .map((row) => eventRow.parse(row))
+                .filter((e) => !handled.has(e.id));
+        },
+        openInbox: () => db.prepare('SELECT * FROM inbox WHERE resolved_at IS NULL ORDER BY id').all().map(toInbox),
         openWaits: () => db.prepare('SELECT * FROM waits WHERE resolved_at IS NULL ORDER BY id').all().map(toWait),
+        portAssignments: () => db.prepare('SELECT * FROM ports ORDER BY slot, worktree').all().map(toPorts),
+        queueItems: (project) => db
+            .prepare('SELECT * FROM items WHERE project = ? AND state_type IS NOT NULL ORDER BY id')
+            .all(project)
+            .map((row) => {
+            const r = queueItemRow.parse(row);
+            const strings = z.array(z.string());
+            return {
+                area: r.area,
+                blockedBy: strings.parse(JSON.parse(r.blocked_by)),
+                createdAt: r.created_at,
+                id: r.id,
+                labels: strings.parse(JSON.parse(r.labels)),
+                priority: r.priority,
+                stateType: r.state_type,
+                title: r.title,
+                trackerProject: r.tracker_project,
+            };
+        }),
+        releaseRule: (rule, subject) => {
+            db.prepare('DELETE FROM rule_state WHERE rule = ? AND subject = ?').run(rule, subject);
+        },
+        resolveInbox: (id, by) => {
+            const row = db
+                .prepare('UPDATE inbox SET resolved_at = ?, resolved_by = ? WHERE id = ? AND resolved_at IS NULL RETURNING *')
+                .get(now().toISOString(), by, id);
+            return row === undefined ? null : toInbox(row);
+        },
         resolveWait: (id, resolution) => {
             const row = db
                 .prepare('UPDATE waits SET resolved_at = ?, resolution = ? WHERE id = ? AND resolved_at IS NULL RETURNING *')
@@ -383,10 +700,75 @@ export function openStore(file, now = () => new Date()) {
                 throw new ConductorError(`wait ${id} is not open`);
             return toWait(row);
         },
+        ruleEvents: (item, limit = 10) => db
+            .prepare('SELECT * FROM events WHERE upper(subject) = upper(?) AND rule IS NOT NULL ORDER BY id DESC LIMIT ?')
+            .all(item, limit)
+            .map((row) => eventRow.parse(row)),
+        ruleStates: () => z.array(z.object({ rule: z.string(), subject: z.string() })).parse(db.prepare('SELECT rule, subject FROM rule_state ORDER BY rule, subject').all()),
+        saveItemNote: ({ item, phase, project }) => {
+            db.prepare(`INSERT INTO items (project, id, latest_note, updated_at) VALUES (?, ?, ?, ?)
+         ON CONFLICT (project, id) DO UPDATE SET latest_note = excluded.latest_note, updated_at = excluded.updated_at`).run(project, item, phase, now().toISOString());
+        },
+        saveLock: (name, holder) => lockSchema.parse(db
+            .prepare('INSERT INTO locks (name, holder, since) VALUES (?, ?, ?) ON CONFLICT (name) DO UPDATE SET holder = excluded.holder, since = excluded.since RETURNING *')
+            .get(name, holder, now().toISOString())),
+        saveNotifyState: (s) => {
+            db.prepare(`INSERT INTO notify_state (inbox, dedupe_key, channels, remind_after, remind_times, sends, last_sent_at, held_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (inbox) DO UPDATE SET dedupe_key = excluded.dedupe_key, channels = excluded.channels,
+           remind_after = excluded.remind_after, remind_times = excluded.remind_times, sends = excluded.sends,
+           last_sent_at = excluded.last_sent_at, held_at = excluded.held_at`).run(s.inbox, s.dedupeKey, JSON.stringify(s.channels), s.remindAfterMinutes, s.remindTimes, s.sends, s.lastSentAt, s.heldAt);
+        },
+        savePorts: ({ ports, project, slot, worktree }) => toPorts(db
+            .prepare('INSERT INTO ports (worktree, project, slot, ports, assigned_at) VALUES (?, ?, ?, ?, ?) RETURNING *')
+            .get(worktree, project, slot, JSON.stringify(ports), now().toISOString())),
+        saveQueueItems: (project, items) => {
+            const save = db.prepare(`INSERT INTO items (project, id, title, state_type, labels, area, blocked_by, priority, tracker_project, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (project, id) DO UPDATE SET title = excluded.title, state_type = excluded.state_type,
+           labels = excluded.labels, area = excluded.area, blocked_by = excluded.blocked_by, priority = excluded.priority,
+           tracker_project = excluded.tracker_project, created_at = excluded.created_at, updated_at = excluded.updated_at`);
+            const at = now().toISOString();
+            // An item the read no longer lists isn't open: it keeps its note, not its blockers, so a
+            // reopened item doesn't read as unblocked against blockers from weeks ago.
+            const gone = db.prepare(`UPDATE items SET state_type = NULL, blocked_by = '[]', updated_at = ?
+         WHERE project = ? AND state_type IS NOT NULL AND id NOT IN (SELECT value FROM json_each(?))`);
+            db.exec('BEGIN IMMEDIATE');
+            try {
+                for (const i of items) {
+                    save.run(project, i.id, i.title, i.stateType, JSON.stringify(i.labels), i.area, JSON.stringify(i.blockedBy), i.priority, i.trackerProject, i.createdAt, at);
+                }
+                gone.run(at, project, JSON.stringify(items.map((i) => i.id)));
+                db.exec('COMMIT');
+            }
+            catch (error) {
+                db.exec('ROLLBACK');
+                throw error;
+            }
+        },
         saveTranscript: (file, worker, cursor) => {
             db.prepare(`INSERT INTO transcripts (file, worker, bytes, recent_ids) VALUES (?, ?, ?, ?)
          ON CONFLICT (file) DO UPDATE SET worker = excluded.worker, bytes = excluded.bytes, recent_ids = excluded.recent_ids`).run(file, worker, cursor.bytes, JSON.stringify(cursor.recentIds));
         },
+        setInboxCondition: (id, condition) => {
+            db.prepare('UPDATE inbox SET condition = ? WHERE id = ?').run(condition, id);
+        },
+        setOverride: ({ kind, project, setBy, until, value }) => toOverride(db
+            .prepare('INSERT INTO overrides (project, kind, value, until, created_at, set_by) VALUES (?, ?, ?, ?, ?, ?) RETURNING *')
+            .get(project, kind, value, until, now().toISOString(), setBy)),
+        spendBetween: (fromDay, toDay) => z
+            .array(z.object({
+            cache_read: z.number(),
+            cache_write: z.number(),
+            day: z.string(),
+            input: z.number(),
+            item: z.string(),
+            output: z.number(),
+            project: z.string(),
+            worker: z.number(),
+        }))
+            .parse(db.prepare('SELECT * FROM spend WHERE day >= ? AND day <= ? ORDER BY day, worker').all(fromDay, toDay))
+            .map(({ cache_read: cacheRead, cache_write: cacheWrite, ...r }) => ({ ...r, cacheRead, cacheWrite })),
         spendByWorker: (day) => {
             const rows = db
                 .prepare(`SELECT worker, sum(tokens) AS total, sum(CASE WHEN day = ? THEN tokens ELSE 0 END) AS today
@@ -395,6 +777,19 @@ export function openStore(file, now = () => new Date()) {
             const totals = z.array(z.object({ today: z.number(), total: z.number(), worker: z.number() })).parse(rows);
             return new Map(totals.map((t) => [t.worker, { today: t.today, total: t.total }]));
         },
+        spendSummary: (day) => {
+            const sum = 'sum(input + output + cache_write)';
+            const rows = (sql, ...args) => z.array(z.object({ key: z.union([z.string(), z.number()]).transform(String), tokens: z.number() })).parse(db.prepare(sql).all(...args));
+            const byWorker = rows(`SELECT worker AS key, ${sum} AS tokens FROM spend GROUP BY worker`);
+            const byItem = rows(`SELECT project || '|' || upper(item) AS key, ${sum} AS tokens FROM spend GROUP BY project, upper(item)`);
+            const byProject = rows(`SELECT project AS key, ${sum} AS tokens FROM spend WHERE day = ? GROUP BY project`, day);
+            return {
+                byItem: new Map(byItem.map((r) => [r.key, r.tokens])),
+                byProjectToday: new Map(byProject.map((r) => [r.key, r.tokens])),
+                byWorker: new Map(byWorker.map((r) => [Number(r.key), r.tokens])),
+                today: byProject.reduce((n, r) => n + r.tokens, 0),
+            };
+        },
         tables: () => db
             .prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
             .all()
@@ -448,10 +843,23 @@ export function openStore(file, now = () => new Date()) {
             return { created: !existing, project };
         },
         waitsOf: (worker) => db.prepare('SELECT * FROM waits WHERE worker = ? AND delivered_at IS NULL ORDER BY id').all(worker).map(toWait),
+        waitsRegisteredBetween: (since, until) => db
+            .prepare(`SELECT w.*, k.item, k.probe, k.project FROM waits w JOIN workers k ON k.id = w.worker
+           WHERE w.created_at >= ? AND w.created_at < ? ORDER BY w.id`)
+            .all(since, until)
+            .map((row) => {
+            const r = z.looseObject({ item: z.string(), probe: z.number(), project: z.string() }).parse(row);
+            return { ...toWait(row), item: r.item, probe: r.probe === 1, project: r.project };
+        }),
         workerEvents: (worker, limit = 20) => db
             .prepare("SELECT * FROM events WHERE json_extract(data, '$.worker') = ? ORDER BY id DESC LIMIT ?")
             .all(worker, limit)
             .map((row) => eventRow.parse(row)),
+        // A worker gone before `since` was last updated then (failing or exiting is its last change).
+        workersBetween: (since, until) => db
+            .prepare(`SELECT * FROM workers WHERE created_at < ? AND (status IN (SELECT value FROM json_each(?)) OR updated_at >= ?) ORDER BY id`)
+            .all(until, JSON.stringify(ACTIVE_STATUSES), since)
+            .map(toWorker),
     };
 }
 // The daemon and a CLI running without it can open a new database at the same moment, so the
@@ -494,6 +902,45 @@ function schemaVersion(db, file) {
     }
     return version;
 }
+function toInbox(row) {
+    const r = inboxRow.parse(row);
+    const strings = z.array(z.string());
+    return {
+        commands: strings.parse(JSON.parse(r.commands)),
+        condition: r.condition,
+        id: r.id,
+        item: r.item,
+        kind: r.kind,
+        links: strings.parse(JSON.parse(r.links)),
+        project: r.project,
+        raisedAt: r.raised_at,
+        resolvedAt: r.resolved_at,
+        resolvedBy: r.resolved_by,
+        text: r.text,
+        worker: r.worker,
+    };
+}
+function toNotifyState(row) {
+    const r = notifyRow.parse(row);
+    return {
+        channels: z.array(z.string()).parse(JSON.parse(r.channels)),
+        dedupeKey: r.dedupe_key,
+        heldAt: r.held_at,
+        inbox: r.inbox,
+        lastSentAt: r.last_sent_at,
+        remindAfterMinutes: r.remind_after,
+        remindTimes: r.remind_times,
+        sends: r.sends,
+    };
+}
+function toOverride(row) {
+    const r = overrideRow.parse(row);
+    return { createdAt: r.created_at, id: r.id, kind: r.kind, project: r.project, setBy: r.set_by, until: r.until, value: r.value };
+}
+function toPorts(row) {
+    const r = portsRow.parse(row);
+    return { assignedAt: r.assigned_at, ports: z.record(z.string(), z.number()).parse(JSON.parse(r.ports)), project: r.project, slot: r.slot, worktree: r.worktree };
+}
 function toWait(row) {
     const r = waitRow.parse(row);
     return {
@@ -516,6 +963,7 @@ function toWorker(row) {
         id: r.id,
         item: r.item,
         name: r.name,
+        phase: r.phase,
         probe: r.probe === 1,
         project: r.project,
         sessionId: r.session_id,