@detergent-software/conductor 0.0.0-stage → 1.0.0-dev.10

package/build/store.js

@@ -0,0 +1,724 @@
+import { EventEmitter } from 'node:events';
+import { DatabaseSync } from 'node:sqlite';
+import { z } from 'zod';
+import { ConductorError } from "./errors.js";
+import { issueLines } from "./jsonc.js";
+import { profileSchema } from "./profile.js";
+import { totalTokens } from "./spend.js";
+// Migrations by schema version (PRAGMA user_version). Append only: a shipped migration never
+// changes. Version 1 is the design note's section 15; the tables later build steps fill start empty.
+// Exported so tests can build a database at an older version.
+export const MIGRATIONS = [
+    `
+  CREATE TABLE projects (
+    name         TEXT PRIMARY KEY,
+    root         TEXT NOT NULL,
+    profile_path TEXT NOT NULL,
+    protocol     INTEGER NOT NULL,
+    profile      TEXT NOT NULL,
+    enabled      INTEGER NOT NULL DEFAULT 1,
+    added_at     TEXT NOT NULL,
+    updated_at   TEXT NOT NULL
+  ) STRICT;
+
+  CREATE TABLE items (
+    project     TEXT NOT NULL,
+    id          TEXT NOT NULL,
+    title       TEXT,
+    state       TEXT,
+    labels      TEXT NOT NULL DEFAULT '[]',
+    area        TEXT,
+    blocked_by  TEXT NOT NULL DEFAULT '[]',
+    priority    INTEGER,
+    latest_note TEXT,
+    updated_at  TEXT NOT NULL,
+    PRIMARY KEY (project, id)
+  ) STRICT;
+
+  CREATE TABLE workers (
+    id         INTEGER PRIMARY KEY,
+    project    TEXT NOT NULL,
+    item       TEXT NOT NULL,
+    session_id TEXT,
+    worktree   TEXT,
+    branch     TEXT,
+    pr         TEXT,
+    phase      TEXT,
+    status     TEXT NOT NULL CHECK (status IN ('running', 'parked', 'stopped-unexpectedly', 'exited')),
+    retries    INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  ) STRICT;
+
+  CREATE TABLE waits (
+    id          INTEGER PRIMARY KEY,
+    worker      INTEGER NOT NULL,
+    condition   TEXT NOT NULL,
+    created_at  TEXT NOT NULL,
+    resolved_at TEXT,
+    resolution  TEXT
+  ) STRICT;
+
+  CREATE TABLE inbox (
+    id          INTEGER PRIMARY KEY,
+    project     TEXT,
+    item        TEXT,
+    kind        TEXT NOT NULL,
+    text        TEXT NOT NULL,
+    commands    TEXT NOT NULL DEFAULT '[]',
+    links       TEXT NOT NULL DEFAULT '[]',
+    raised_at   TEXT NOT NULL,
+    resolved_at TEXT,
+    resolved_by TEXT
+  ) STRICT;
+
+  CREATE TABLE spend (
+    worker  INTEGER NOT NULL,
+    project TEXT NOT NULL,
+    item    TEXT NOT NULL,
+    day     TEXT NOT NULL,
+    tokens  INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (worker, day)
+  ) STRICT;
+
+  CREATE TABLE rules (
+    id        INTEGER PRIMARY KEY,
+    source    TEXT NOT NULL,
+    position  INTEGER NOT NULL,
+    rule      TEXT NOT NULL,
+    loaded_at TEXT NOT NULL
+  ) STRICT;
+
+  CREATE TABLE overrides (
+    id         INTEGER PRIMARY KEY,
+    project    TEXT,
+    kind       TEXT NOT NULL,
+    value      TEXT NOT NULL,
+    until      TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  ) STRICT;
+
+  CREATE TABLE todos (
+    id          INTEGER PRIMARY KEY,
+    project     TEXT,
+    item        TEXT,
+    action      TEXT NOT NULL,
+    after_ticks INTEGER,
+    after       TEXT,
+    created_at  TEXT NOT NULL,
+    done_at     TEXT
+  ) STRICT;
+
+  CREATE TABLE locks (
+    name   TEXT PRIMARY KEY,
+    holder TEXT NOT NULL,
+    since  TEXT NOT NULL
+  ) STRICT;
+
+  CREATE TABLE events (
+    id      INTEGER PRIMARY KEY AUTOINCREMENT,
+    at      TEXT NOT NULL,
+    project TEXT,
+    kind    TEXT NOT NULL,
+    subject TEXT,
+    data    TEXT NOT NULL,
+    rule    TEXT
+  ) STRICT;
+  CREATE INDEX events_by_project ON events (project, id);
+  CREATE TRIGGER events_no_update BEFORE UPDATE ON events BEGIN SELECT RAISE(ABORT, 'events is append-only'); END;
+  CREATE TRIGGER events_no_delete BEFORE DELETE ON events BEGIN SELECT RAISE(ABORT, 'events is append-only'); END;
+  `,
+    // 2: the session manager (ATK-309). A worker is `launching` while its worktree is made, and
+    // `failed` when that or the session start fails. `name` is its session's and worktree's name
+    // (probe-<item> for a probe); `handle` is the short id `claude stop`/`rm`/`attach` take. A
+    // resolved wait is delivered when a resume carries it. Spend keeps the four kinds of token, and
+    // `tokens` is their sum. `transcripts` holds where reading each transcript stopped.
+    `
+  CREATE TABLE workers_v2 (
+    id          INTEGER PRIMARY KEY,
+    project     TEXT NOT NULL,
+    item        TEXT NOT NULL,
+    name        TEXT NOT NULL,
+    probe       INTEGER NOT NULL DEFAULT 0,
+    session_id  TEXT,
+    handle      TEXT,
+    worktree    TEXT,
+    branch      TEXT,
+    pr          TEXT,
+    phase       TEXT,
+    status      TEXT NOT NULL CHECK (status IN ('launching', 'running', 'parked', 'stopped-unexpectedly', 'failed', 'exited')),
+    retries     INTEGER NOT NULL DEFAULT 0,
+    attached_at TEXT,
+    stopped_at  TEXT,
+    created_at  TEXT NOT NULL,
+    updated_at  TEXT NOT NULL
+  ) STRICT;
+  INSERT INTO workers_v2 (id, project, item, name, session_id, worktree, branch, pr, phase, status, retries, created_at, updated_at)
+    SELECT id, project, item, item, session_id, worktree, branch, pr, phase, status, retries, created_at, updated_at FROM workers;
+  DROP TABLE workers;
+  ALTER TABLE workers_v2 RENAME TO workers;
+  CREATE UNIQUE INDEX workers_in_flight ON workers (project, name) WHERE status NOT IN ('failed', 'exited');
+
+  ALTER TABLE waits ADD COLUMN delivered_at TEXT;
+  CREATE INDEX waits_by_worker ON waits (worker, id);
+
+  ALTER TABLE spend ADD COLUMN input INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE spend ADD COLUMN output INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE spend ADD COLUMN cache_read INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE spend ADD COLUMN cache_write INTEGER NOT NULL DEFAULT 0;
+
+  CREATE TABLE transcripts (
+    file       TEXT PRIMARY KEY,
+    worker     INTEGER NOT NULL,
+    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);
+  `,
+];
+export const SCHEMA_VERSION = MIGRATIONS.length;
+const eventRow = z.object({
+    at: z.string(),
+    data: z.string().transform((s) => z.record(z.string(), z.unknown()).parse(JSON.parse(s))),
+    id: z.number(),
+    kind: z.string(),
+    project: z.string().nullable(),
+    rule: z.string().nullable(),
+    subject: z.string().nullable(),
+});
+const projectRow = z.object({
+    added_at: z.string(),
+    enabled: z.number(),
+    name: z.string(),
+    profile: z.string(),
+    profile_path: z.string(),
+    protocol: z.number(),
+    root: z.string(),
+    updated_at: z.string(),
+});
+// A registered project as the API returns it. A stored profile that this build's schema no longer
+// accepts comes back as `profile: null` with the reason in `problem`, so one stale row doesn't break
+// every listing; `conduct project add` again refreshes it.
+export const projectSchema = z.object({
+    addedAt: z.string(),
+    enabled: z.boolean(),
+    name: z.string(),
+    problem: z.string().nullable(),
+    profile: profileSchema.nullable(),
+    profilePath: z.string(),
+    protocol: z.number(),
+    root: z.string(),
+    updatedAt: z.string(),
+});
+export const WORKER_STATUSES = ['launching', 'running', 'parked', 'stopped-unexpectedly', 'failed', 'exited'];
+// The statuses of a worker the daemon still looks after; `failed` and `exited` are history.
+export const ACTIVE_STATUSES = ['launching', 'running', 'parked', 'stopped-unexpectedly'];
+export const workerSchema = z.object({
+    attachedAt: z.string().nullable(),
+    branch: z.string().nullable(),
+    createdAt: z.string(),
+    handle: z.string().nullable(),
+    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(),
+    status: z.enum(WORKER_STATUSES),
+    stoppedAt: z.string().nullable(),
+    updatedAt: z.string(),
+    worktree: z.string().nullable(),
+});
+export const waitSchema = z.object({
+    condition: z.string(),
+    createdAt: z.string(),
+    deliveredAt: z.string().nullable(),
+    id: z.number(),
+    resolution: z.string().nullable(),
+    resolvedAt: z.string().nullable(),
+    worker: z.number(),
+});
+// What waits on Jason (design note, section 7). `ready-to-release`, `queue-drained` and
+// `prod-approval` belong to the scheduler (ATK-315) and `/release-atk`; nothing raises them yet.
+export const INBOX_KINDS = [
+    'plan',
+    'merge',
+    'npm-otp',
+    'prod-approval',
+    'permission',
+    'jason',
+    'human',
+    'scope',
+    'blocked',
+    'abandoned',
+    'failed',
+    'stall',
+    'runaway',
+    'ready-to-release',
+    'queue-drained',
+];
+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 workerRow = z.object({
+    attached_at: z.string().nullable(),
+    branch: z.string().nullable(),
+    created_at: z.string(),
+    handle: z.string().nullable(),
+    id: z.number(),
+    item: z.string(),
+    name: z.string(),
+    phase: z.string().nullable(),
+    probe: z.number(),
+    project: z.string(),
+    session_id: z.string().nullable(),
+    status: z.enum(WORKER_STATUSES),
+    stopped_at: z.string().nullable(),
+    updated_at: z.string(),
+    worktree: z.string().nullable(),
+});
+const waitRow = z.object({
+    condition: z.string(),
+    created_at: z.string(),
+    delivered_at: z.string().nullable(),
+    id: z.number(),
+    resolution: z.string().nullable(),
+    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(),
+    until: z.string(),
+    value: z.string(),
+});
+const PATCH_KEYS = [
+    'attachedAt',
+    'branch',
+    'handle',
+    'phase',
+    'sessionId',
+    'status',
+    'stoppedAt',
+    'worktree',
+];
+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);
+    try {
+        db.exec('PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;');
+        migrate(db, file);
+    }
+    catch (error) {
+        db.close();
+        throw error;
+    }
+    const emitter = new EventEmitter();
+    emitter.setMaxListeners(0);
+    const insertEvent = db.prepare('INSERT INTO events (at, project, kind, subject, data, rule) VALUES (?, ?, ?, ?, ?, ?) RETURNING *');
+    const selectAfter = db.prepare('SELECT * FROM events WHERE id > ? ORDER BY id LIMIT ?');
+    // The only writer to `events`. Everything the daemon observes or does goes through here.
+    const appendEvent = (event) => {
+        const row = eventRow.parse(insertEvent.get(now().toISOString(), event.project ?? null, event.kind, event.subject ?? null, JSON.stringify(event.data ?? {}), event.rule ?? null));
+        emitter.emit('event', row);
+        return row;
+    };
+    const toProject = (row) => {
+        const r = projectRow.parse(row);
+        const stored = parseStoredProfile(r.profile);
+        return {
+            addedAt: r.added_at,
+            enabled: r.enabled === 1,
+            name: r.name,
+            problem: stored.problem,
+            profile: stored.profile,
+            profilePath: r.profile_path,
+            protocol: r.protocol,
+            root: r.root,
+            updatedAt: r.updated_at,
+        };
+    };
+    const getWorker = (id) => {
+        const row = db.prepare('SELECT * FROM workers WHERE id = ?').get(id);
+        return row === undefined ? null : toWorker(row);
+    };
+    return {
+        addSpend: ({ day, item, project, usage, worker }) => {
+            db.prepare(`INSERT INTO spend (worker, project, item, day, tokens, input, output, cache_read, cache_write)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (worker, day) DO UPDATE SET
+           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);
+        },
+        addWait: (worker, condition) => toWait(db
+            .prepare('INSERT INTO waits (worker, condition, created_at) VALUES (?, ?, ?) RETURNING *')
+            .get(worker, condition, now().toISOString())),
+        appendEvent,
+        close: () => db.close(),
+        closeWaits: (worker, resolution) => {
+            const at = now().toISOString();
+            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);
+        },
+        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);
+        },
+        eventsAfter: (id, limit = 500) => selectAfter.all(id, limit).map((row) => eventRow.parse(row)),
+        getInbox: (id) => {
+            const row = db.prepare('SELECT * FROM inbox WHERE id = ?').get(id);
+            return row === undefined ? null : toInbox(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,
+        inboxOf: (worker) => db.prepare('SELECT * FROM inbox WHERE worker = ? ORDER BY id').all(worker).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 {
+                return toWorker(db
+                    .prepare(`INSERT INTO workers (project, item, name, probe, status, created_at, updated_at)
+               VALUES (?, ?, ?, ?, 'launching', ?, ?) RETURNING *`)
+                    .get(project, item, name, probe ? 1 : 0, at, at));
+            }
+            catch (error) {
+                if (error instanceof Error && /UNIQUE constraint failed/.test(error.message)) {
+                    throw new ConductorError(`${name} is already in flight in ${project}`);
+                }
+                throw error;
+            }
+        },
+        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);
+        },
+        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);
+        },
+        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);
+        },
+        onEvent: (listener) => {
+            emitter.on('event', listener);
+            return () => emitter.off('event', listener);
+        },
+        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),
+        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 *')
+                .get(now().toISOString(), resolution, id);
+            if (row === undefined)
+                throw new ConductorError(`wait ${id} is not open`);
+            return toWait(row);
+        },
+        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());
+        },
+        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);
+        },
+        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, until, value }) => toOverride(db
+            .prepare('INSERT INTO overrides (project, kind, value, until, created_at) VALUES (?, ?, ?, ?, ?) RETURNING *')
+            .get(project, kind, value, until, now().toISOString())),
+        spendByWorker: (day) => {
+            const rows = db
+                .prepare(`SELECT worker, sum(tokens) AS total, sum(CASE WHEN day = ? THEN tokens ELSE 0 END) AS today
+           FROM spend GROUP BY worker`)
+                .all(day);
+            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 }]));
+        },
+        tables: () => db
+            .prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
+            .all()
+            .map((row) => z.object({ name: z.string() }).parse(row).name),
+        transaction: (write) => {
+            db.exec('BEGIN IMMEDIATE');
+            try {
+                const result = write();
+                db.exec('COMMIT');
+                return result;
+            }
+            catch (error) {
+                db.exec('ROLLBACK');
+                throw error;
+            }
+        },
+        transcriptCursor: (file) => {
+            const row = db.prepare('SELECT bytes, recent_ids FROM transcripts WHERE file = ?').get(file);
+            if (row === undefined)
+                return null;
+            const r = z.object({ bytes: z.number(), recent_ids: z.string() }).parse(row);
+            return { bytes: r.bytes, recentIds: z.array(z.string()).parse(JSON.parse(r.recent_ids)) };
+        },
+        updateWorker: (id, patch) => {
+            const keys = PATCH_KEYS.filter((k) => patch[k] !== undefined);
+            const row = db
+                .prepare(`UPDATE workers SET ${[...keys.map((k) => `${WORKER_COLUMNS[k]} = ?`), 'updated_at = ?'].join(', ')}
+           WHERE id = ? RETURNING *`)
+                .get(...keys.map((k) => patch[k] ?? null), now().toISOString(), id);
+            if (row === undefined)
+                throw new ConductorError(`no worker ${id}`);
+            return toWorker(row);
+        },
+        // One row per project name. Adding a project again (or from another checkout path) updates it.
+        upsertProject: ({ profile, profilePath, root }) => {
+            const at = now().toISOString();
+            const existing = db.prepare('SELECT 1 FROM projects WHERE name = ?').get(profile.name) !== undefined;
+            const project = toProject(db
+                .prepare(`INSERT INTO projects (name, root, profile_path, protocol, profile, added_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)
+             ON CONFLICT (name) DO UPDATE SET
+               root = excluded.root, profile_path = excluded.profile_path, protocol = excluded.protocol,
+               profile = excluded.profile, updated_at = excluded.updated_at
+             RETURNING *`)
+                .get(profile.name, root, profilePath, profile.protocol, JSON.stringify(profile), at, at));
+            appendEvent({
+                data: { profilePath, root },
+                kind: existing ? 'project.updated' : 'project.added',
+                project: project.name,
+            });
+            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),
+        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)),
+        workerSpend: (worker) => z.object({ tokens: z.number() }).parse(db.prepare('SELECT coalesce(sum(input + output + cache_write), 0) AS tokens FROM spend WHERE worker = ?').get(worker))
+            .tokens,
+    };
+}
+// The daemon and a CLI running without it can open a new database at the same moment, so the
+// version is read again under the write lock before anything is created.
+function migrate(db, file) {
+    if (schemaVersion(db, file) === SCHEMA_VERSION)
+        return;
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        for (let next = schemaVersion(db, file); next < SCHEMA_VERSION; next++) {
+            db.exec(MIGRATIONS[next] ?? '');
+            db.exec(`PRAGMA user_version = ${next + 1}`);
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+function parseStoredProfile(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return { problem: 'the stored profile is not JSON', profile: null };
+    }
+    const result = profileSchema.safeParse(value);
+    return result.success
+        ? { problem: null, profile: result.data }
+        : { problem: `the stored profile no longer validates: ${issueLines(result.error).join('; ')}`, profile: null };
+}
+function schemaVersion(db, file) {
+    const { user_version: version } = z.object({ user_version: z.number() }).parse(db.prepare('PRAGMA user_version').get());
+    if (version > SCHEMA_VERSION) {
+        throw new ConductorError(`${file} has schema version ${version}; this conductor knows up to ${SCHEMA_VERSION}`, [
+            'upgrade the conductor (npm install --global @detergent-software/conductor@dev, or @latest; a linked checkout: pull and rebuild) before starting it',
+        ]);
+    }
+    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, until: r.until, value: r.value };
+}
+function toWait(row) {
+    const r = waitRow.parse(row);
+    return {
+        condition: r.condition,
+        createdAt: r.created_at,
+        deliveredAt: r.delivered_at,
+        id: r.id,
+        resolution: r.resolution,
+        resolvedAt: r.resolved_at,
+        worker: r.worker,
+    };
+}
+function toWorker(row) {
+    const r = workerRow.parse(row);
+    return {
+        attachedAt: r.attached_at,
+        branch: r.branch,
+        createdAt: r.created_at,
+        handle: r.handle,
+        id: r.id,
+        item: r.item,
+        name: r.name,
+        phase: r.phase,
+        probe: r.probe === 1,
+        project: r.project,
+        sessionId: r.session_id,
+        status: r.status,
+        stoppedAt: r.stopped_at,
+        updatedAt: r.updated_at,
+        worktree: r.worktree,
+    };
+}
+//# sourceMappingURL=store.js.map