whydid 1.0.0

package/dist/db/database.js

@@ -0,0 +1,631 @@
+import { createRequire } from "node:module";
+import { SCHEMA_SQL } from "./schema.js";
+const nodeRequire = createRequire(import.meta.url);
+const { DatabaseSync } = nodeRequire("node:sqlite");
+function rowToSocialPost(row) {
+    return {
+        id: row.id, projectId: row.project_id, sessionId: row.session_id, platform: row.platform,
+        content: row.content, source: row.source, pinned: row.pinned === 1, createdAt: row.created_at,
+        model: row.model ?? null, inputTokens: row.input_tokens ?? null, outputTokens: row.output_tokens ?? null,
+    };
+}
+function rowToChatConversation(row) {
+    return { id: row.id, projectId: row.project_id, title: row.title, createdAt: row.created_at, updatedAt: row.updated_at };
+}
+function rowToChatMessage(row) {
+    return {
+        id: row.id, conversationId: row.conversation_id, role: row.role, content: row.content,
+        citedStateIds: row.cited_state_ids_json ? JSON.parse(row.cited_state_ids_json) : [],
+        model: row.model ?? null, inputTokens: row.input_tokens ?? null, outputTokens: row.output_tokens ?? null, createdAt: row.created_at,
+    };
+}
+function buildStateFilter(projectId, opts) {
+    const clauses = ["s.project_id = ?"];
+    const params = [projectId];
+    if (opts.risk) {
+        clauses.push("COALESCE(a.risk_level, s.risk_level) = ?");
+        params.push(opts.risk);
+    }
+    if (opts.search && opts.search.trim() !== "") {
+        clauses.push("(LOWER(COALESCE(a.summary,'')) LIKE ? OR LOWER(COALESCE(a.reason,'')) LIKE ? OR LOWER(COALESCE(s.label,'')) LIKE ? OR LOWER(s.id) LIKE ?)");
+        const q = `%${opts.search.trim().toLowerCase()}%`;
+        params.push(q, q, q, q);
+    }
+    return { where: clauses.join(" AND "), params };
+}
+export class WhydidDatabase {
+    raw;
+    constructor(dbPath) {
+        this.raw = new DatabaseSync(dbPath);
+        this.raw.exec("PRAGMA journal_mode = WAL;");
+        this.raw.exec("PRAGMA foreign_keys = ON;");
+        this.raw.exec(SCHEMA_SQL);
+        this.runMigrations();
+    }
+    // CREATE TABLE IF NOT EXISTS is a no-op for a table that already exists,
+    // so a column added to schema.ts after someone's .whydid/db.sqlite was
+    // first created needs an explicit, idempotent migration — this project
+    // doesn't otherwise have a migration framework, so this stays a short
+    // list of "add this column if it isn't already there" steps.
+    runMigrations() {
+        this.addColumnIfMissing("annotations", "input_tokens", "INTEGER");
+        this.addColumnIfMissing("annotations", "output_tokens", "INTEGER");
+        this.addColumnIfMissing("social_posts", "model", "TEXT");
+        this.addColumnIfMissing("social_posts", "input_tokens", "INTEGER");
+        this.addColumnIfMissing("social_posts", "output_tokens", "INTEGER");
+        this.addColumnIfMissing("chat_messages", "model", "TEXT");
+        this.addColumnIfMissing("chat_messages", "input_tokens", "INTEGER");
+        this.addColumnIfMissing("chat_messages", "output_tokens", "INTEGER");
+        this.addColumnIfMissing("states", "milestone_label", "TEXT");
+        this.addColumnIfMissing("turns", "kind", "TEXT NOT NULL DEFAULT 'prompt'");
+    }
+    addColumnIfMissing(table, column, definition) {
+        const cols = this.raw.prepare(`PRAGMA table_info(${table})`).all();
+        if (!cols.some((c) => c.name === column)) {
+            this.raw.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+        }
+    }
+    close() {
+        this.raw.close();
+    }
+    // node:sqlite runs every statement in its own implicit transaction
+    // (autocommit) unless wrapped in an explicit BEGIN/COMMIT — meaning a
+    // bulk insert of one row per statement pays a full fsync per row. Wrapping
+    // the batch in one transaction turns N fsyncs into 1, with identical rows
+    // ending up in the table either way.
+    transaction(fn) {
+        this.raw.exec("BEGIN");
+        try {
+            const result = fn();
+            this.raw.exec("COMMIT");
+            return result;
+        }
+        catch (err) {
+            this.raw.exec("ROLLBACK");
+            throw err;
+        }
+    }
+    insertProject(p) {
+        const now = new Date().toISOString();
+        this.raw
+            .prepare(`INSERT INTO projects (id, name, root_path, git_root, head_state_id, created_at, updated_at)
+         VALUES (?, ?, ?, ?, NULL, ?, ?)`)
+            .run(p.id, p.name, p.rootPath, p.gitRoot, now, now);
+    }
+    getProject(id) {
+        const row = this.raw.prepare(`SELECT * FROM projects WHERE id = ?`).get(id);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id, name: row.name, rootPath: row.root_path, gitRoot: row.git_root,
+            headStateId: row.head_state_id, createdAt: row.created_at, updatedAt: row.updated_at,
+        };
+    }
+    insertState(s) {
+        this.raw
+            .prepare(`INSERT INTO states
+         (id, project_id, parent_state_id, session_id, turn_id, state_type, label, summary,
+          reason, decision_notes, risk_level, created_at, git_commit_sha, working_tree_hash)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(s.id, s.projectId, s.parentStateId, s.sessionId, s.turnId, s.stateType, s.label, s.summary, s.reason, s.decisionNotes, s.riskLevel, s.createdAt, s.gitCommitSha, s.workingTreeHash);
+    }
+    rowToState(row) {
+        return {
+            id: row.id, projectId: row.project_id, parentStateId: row.parent_state_id,
+            sessionId: row.session_id, turnId: row.turn_id, stateType: row.state_type,
+            label: row.label, summary: row.summary, reason: row.reason,
+            decisionNotes: row.decision_notes, riskLevel: row.risk_level, createdAt: row.created_at,
+            gitCommitSha: row.git_commit_sha, workingTreeHash: row.working_tree_hash,
+            milestoneLabel: row.milestone_label ?? null,
+        };
+    }
+    getState(id) {
+        const row = this.raw.prepare(`SELECT * FROM states WHERE id = ?`).get(id);
+        return row ? this.rowToState(row) : undefined;
+    }
+    /** Tags (or untags, with label = null) a state as a milestone — a founder-chosen marker like "v1 launch" or "before pricing change" so it stands out in the timeline later. */
+    setStateMilestone(id, label) {
+        this.raw.prepare(`UPDATE states SET milestone_label = ? WHERE id = ?`).run(label, id);
+    }
+    listMilestones(projectId) {
+        const rows = this.raw
+            .prepare(`SELECT * FROM states WHERE project_id = ? AND milestone_label IS NOT NULL ORDER BY created_at DESC`)
+            .all(projectId);
+        return rows.map((r) => this.rowToState(r));
+    }
+    getHeadState(projectId) {
+        const project = this.getProject(projectId);
+        if (!project?.headStateId)
+            return undefined;
+        return this.getState(project.headStateId);
+    }
+    setHeadState(projectId, stateId) {
+        this.raw
+            .prepare(`UPDATE projects SET head_state_id = ?, updated_at = ? WHERE id = ?`)
+            .run(stateId, new Date().toISOString(), projectId);
+    }
+    listStates(projectId, opts = {}) {
+        const { where, params } = buildStateFilter(projectId, opts);
+        let sql = `SELECT s.* FROM states s LEFT JOIN annotations a ON a.id = (
+      SELECT id FROM annotations WHERE state_id = s.id ORDER BY created_at DESC LIMIT 1
+    ) WHERE ${where} ORDER BY s.created_at DESC, s.id DESC`;
+        if (opts.limit != null) {
+            sql += ` LIMIT ? OFFSET ?`;
+            params.push(opts.limit, opts.offset ?? 0);
+        }
+        const rows = this.raw.prepare(sql).all(...params);
+        return rows.map((r) => this.rowToState(r));
+    }
+    countStates(projectId, opts = {}) {
+        const { where, params } = buildStateFilter(projectId, opts);
+        const sql = `SELECT COUNT(*) as n FROM states s LEFT JOIN annotations a ON a.id = (
+      SELECT id FROM annotations WHERE state_id = s.id ORDER BY created_at DESC LIMIT 1
+    ) WHERE ${where}`;
+        const row = this.raw.prepare(sql).get(...params);
+        return row.n;
+    }
+    /** Real checkpoints (excludes the initial state) per calendar day, oldest first, since sinceIso. Days with zero activity are simply absent. */
+    getDailyCheckpointCounts(projectId, sinceIso) {
+        const rows = this.raw
+            .prepare(`SELECT substr(created_at, 1, 10) as day, COUNT(*) as n
+         FROM states
+         WHERE project_id = ? AND state_type != 'initial' AND created_at >= ?
+         GROUP BY day ORDER BY day ASC`)
+            .all(projectId, sinceIso);
+        return rows.map((r) => ({ date: r.day, count: r.n }));
+    }
+    /** All-time totals for the "progress so far" showcase — not paginated/filtered. */
+    getProjectTotals(projectId) {
+        const checkpoints = this.raw
+            .prepare(`SELECT COUNT(*) as n FROM states WHERE project_id = ? AND state_type != 'initial'`)
+            .get(projectId);
+        const sessions = this.raw.prepare(`SELECT COUNT(*) as n FROM sessions WHERE project_id = ?`).get(projectId);
+        return { totalCheckpoints: checkpoints.n, totalSessions: sessions.n };
+    }
+    /**
+     * State ids with a *generated* annotation, newest first, capped at limit —
+     * scoped to a directory's immediate file children, or project-wide.
+     *   dir === null -> any file, anywhere in the project (for the project summary)
+     *   dir === ""   -> files directly at the project root (no "/" in their path)
+     *   dir === "src/auth" -> files whose immediate directory is exactly "src/auth"
+     *     (deeper-nested files like src/auth/handlers/x.ts belong to their own
+     *     "src/auth/handlers" bucket, not this one — matches how CONTEXT.md files
+     *     are generated, one per immediate directory)
+     */
+    findAnnotatedStateIdsForDirectory(projectId, dir, limit) {
+        let sql = `
+      SELECT DISTINCT s.id, s.created_at
+      FROM states s
+      JOIN annotations a ON a.id = (
+        SELECT id FROM annotations WHERE state_id = s.id ORDER BY created_at DESC LIMIT 1
+      )`;
+        const clauses = [`s.project_id = ?`, `a.status = 'generated'`];
+        const params = [projectId];
+        if (dir !== null) {
+            sql += ` JOIN file_changes fc ON fc.state_id = s.id`;
+            if (dir === "") {
+                clauses.push(`fc.file_path NOT LIKE '%/%'`);
+            }
+            else {
+                clauses.push(`fc.file_path LIKE ? AND fc.file_path NOT LIKE ?`);
+                params.push(`${dir}/%`, `${dir}/%/%`);
+            }
+        }
+        sql += ` WHERE ${clauses.join(" AND ")} ORDER BY s.created_at DESC LIMIT ?`;
+        params.push(limit);
+        const rows = this.raw.prepare(sql).all(...params);
+        return rows.map((r) => r.id);
+    }
+    upsertContextFile(entry) {
+        this.raw
+            .prepare(`INSERT INTO context_files (project_id, dir_path, file_path, checkpoint_count, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(project_id, file_path) DO UPDATE SET
+           dir_path = excluded.dir_path, checkpoint_count = excluded.checkpoint_count, updated_at = excluded.updated_at`)
+            .run(entry.projectId, entry.dirPath, entry.filePath, entry.checkpointCount, entry.updatedAt);
+    }
+    listContextFiles(projectId) {
+        const rows = this.raw
+            .prepare(`SELECT dir_path, file_path, checkpoint_count, updated_at FROM context_files WHERE project_id = ? ORDER BY updated_at DESC`)
+            .all(projectId);
+        return rows.map((r) => ({ dirPath: r.dir_path, filePath: r.file_path, checkpointCount: r.checkpoint_count, updatedAt: r.updated_at }));
+    }
+    insertSocialPost(p) {
+        this.raw
+            .prepare(`INSERT INTO social_posts (id, project_id, session_id, platform, content, source, pinned, created_at, model, input_tokens, output_tokens)
+         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?)`)
+            .run(p.id, p.projectId, p.sessionId, p.platform, p.content, p.source, new Date().toISOString(), p.model ?? null, p.inputTokens ?? null, p.outputTokens ?? null);
+    }
+    listSocialPosts(projectId) {
+        const rows = this.raw
+            .prepare(`SELECT * FROM social_posts WHERE project_id = ? ORDER BY created_at DESC`)
+            .all(projectId);
+        return rows.map(rowToSocialPost);
+    }
+    getSocialPost(id) {
+        const row = this.raw.prepare(`SELECT * FROM social_posts WHERE id = ?`).get(id);
+        return row ? rowToSocialPost(row) : undefined;
+    }
+    setSocialPostPinned(id, pinned) {
+        this.raw.prepare(`UPDATE social_posts SET pinned = ? WHERE id = ?`).run(pinned ? 1 : 0, id);
+    }
+    deleteSocialPost(id) {
+        this.raw.prepare(`DELETE FROM social_posts WHERE id = ?`).run(id);
+    }
+    /** Deletes unpinned drafts older than retentionDays. retentionDays <= 0 is a no-op (auto-delete disabled). Returns the number removed. */
+    pruneOldSocialPosts(projectId, retentionDays) {
+        if (retentionDays <= 0)
+            return 0;
+        const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
+        const result = this.raw
+            .prepare(`DELETE FROM social_posts WHERE project_id = ? AND pinned = 0 AND created_at < ?`)
+            .run(projectId, cutoff);
+        return Number(result.changes);
+    }
+    // ---- Project chat ----
+    insertChatConversation(c) {
+        const now = new Date().toISOString();
+        this.raw
+            .prepare(`INSERT INTO chat_conversations (id, project_id, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`)
+            .run(c.id, c.projectId, c.title, now, now);
+    }
+    listChatConversations(projectId) {
+        const rows = this.raw
+            .prepare(`SELECT * FROM chat_conversations WHERE project_id = ? ORDER BY updated_at DESC`)
+            .all(projectId);
+        return rows.map(rowToChatConversation);
+    }
+    getChatConversation(id) {
+        const row = this.raw.prepare(`SELECT * FROM chat_conversations WHERE id = ?`).get(id);
+        return row ? rowToChatConversation(row) : undefined;
+    }
+    touchChatConversation(id) {
+        this.raw.prepare(`UPDATE chat_conversations SET updated_at = ? WHERE id = ?`).run(new Date().toISOString(), id);
+    }
+    setChatConversationTitle(id, title) {
+        this.raw.prepare(`UPDATE chat_conversations SET title = ? WHERE id = ?`).run(title, id);
+    }
+    deleteChatConversation(id) {
+        this.transaction(() => {
+            this.raw.prepare(`DELETE FROM chat_messages WHERE conversation_id = ?`).run(id);
+            this.raw.prepare(`DELETE FROM chat_conversations WHERE id = ?`).run(id);
+        });
+    }
+    insertChatMessage(m) {
+        this.raw
+            .prepare(`INSERT INTO chat_messages (id, conversation_id, role, content, cited_state_ids_json, model, input_tokens, output_tokens, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(m.id, m.conversationId, m.role, m.content, m.citedStateIds ? JSON.stringify(m.citedStateIds) : null, m.model ?? null, m.inputTokens ?? null, m.outputTokens ?? null, new Date().toISOString());
+    }
+    listChatMessages(conversationId) {
+        const rows = this.raw
+            .prepare(`SELECT * FROM chat_messages WHERE conversation_id = ? ORDER BY created_at ASC`)
+            .all(conversationId);
+        return rows.map(rowToChatMessage);
+    }
+    /** Indexes (or re-indexes) one state's annotation content for chat retrieval. Call only for generated annotations — there's nothing useful to search otherwise. */
+    indexAnnotationForSearch(stateId, projectId, text) {
+        this.raw.prepare(`DELETE FROM annotation_search WHERE state_id = ?`).run(stateId);
+        this.raw.prepare(`INSERT INTO annotation_search (state_id, project_id, text) VALUES (?, ?, ?)`).run(stateId, projectId, text);
+    }
+    /**
+     * Keyword search over indexed annotations, safe against arbitrary user
+     * input: terms are extracted as plain words and each wrapped as an FTS5
+     * quoted phrase (escaping embedded quotes), joined with OR — so anything
+     * a free-text chat question contains (colons, parens, "-", etc., all
+     * meaningful in raw FTS5 query syntax) can never produce a malformed
+     * MATCH expression or an unintended AND/NOT.
+     */
+    searchAnnotations(projectId, query, limit) {
+        const terms = [...new Set(query.toLowerCase().match(/[a-z0-9]{3,}/g) ?? [])].slice(0, 12);
+        if (terms.length === 0)
+            return [];
+        const matchExpr = terms.map((t) => `"${t.replace(/"/g, '""')}"`).join(" OR ");
+        const rows = this.raw
+            .prepare(`SELECT state_id FROM annotation_search WHERE project_id = ? AND annotation_search MATCH ? ORDER BY rank LIMIT ?`)
+            .all(projectId, matchExpr, limit);
+        return rows.map((r) => r.state_id);
+    }
+    insertFileChanges(stateId, changes) {
+        const stmt = this.raw.prepare(`INSERT INTO file_changes (id, state_id, file_path, change_type, before_hash, after_hash, lines_added, lines_removed)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+        this.transaction(() => {
+            for (const c of changes) {
+                stmt.run(`${stateId}:${c.filePath}`, stateId, c.filePath, c.changeType, c.beforeHash, c.afterHash, c.linesAdded, c.linesRemoved);
+            }
+        });
+    }
+    getFileChanges(stateId) {
+        const rows = this.raw.prepare(`SELECT * FROM file_changes WHERE state_id = ?`).all(stateId);
+        return rows.map((r) => ({
+            id: r.id, stateId: r.state_id, filePath: r.file_path, changeType: r.change_type,
+            beforeHash: r.before_hash, afterHash: r.after_hash, linesAdded: r.lines_added,
+            linesRemoved: r.lines_removed,
+        }));
+    }
+    insertStateManifest(stateId, manifest) {
+        const stmt = this.raw.prepare(`INSERT INTO state_manifest (state_id, file_path, content_hash, size_bytes) VALUES (?, ?, ?, ?)`);
+        this.transaction(() => {
+            for (const entry of manifest) {
+                stmt.run(stateId, entry.filePath, entry.contentHash, entry.sizeBytes);
+            }
+        });
+    }
+    /** Whether a full manifest snapshot ("keyframe") is stored for this exact state — vs. a state whose manifest must be reconstructed from its ancestors' deltas. */
+    hasFullManifest(stateId) {
+        const row = this.raw.prepare(`SELECT 1 FROM state_manifest WHERE state_id = ? LIMIT 1`).get(stateId);
+        return row !== undefined;
+    }
+    readFullManifestRows(stateId) {
+        const rows = this.raw
+            .prepare(`SELECT file_path, content_hash, size_bytes FROM state_manifest WHERE state_id = ? ORDER BY file_path`)
+            .all(stateId);
+        return rows.map((r) => ({ filePath: r.file_path, contentHash: r.content_hash, sizeBytes: r.size_bytes }));
+    }
+    /**
+     * Returns the full file manifest for a state. Not every state has one
+     * stored directly — createCheckpoint only stores a full snapshot
+     * ("keyframe") periodically (see MANIFEST_KEYFRAME_INTERVAL in engine.ts)
+     * to avoid writing every tracked file's row on every single checkpoint,
+     * which at scale (tens of thousands of files, thousands of checkpoints
+     * over a project's life) made state_manifest the dominant driver of
+     * .whydid's on-disk size. For a state with no stored snapshot, this walks
+     * up the parent chain collecting file_changes (already stored for every
+     * state regardless) until it finds an ancestor that does have one, then
+     * replays those deltas oldest-first — the initial state always has a
+     * full manifest, so the walk is guaranteed to terminate.
+     *
+     * sizeBytes on a reconstructed (non-keyframe) entry is not accurate — it
+     * isn't consumed by anything correctness-critical (restore/fork apply by
+     * contentHash only; diffing and the state fingerprint are hash-based too)
+     * so recomputing it from the object store on every replay isn't worth the
+     * extra disk read.
+     */
+    getStateManifest(stateId) {
+        if (this.hasFullManifest(stateId))
+            return this.readFullManifestRows(stateId);
+        const deltaChain = []; // nearest-to-stateId first
+        let cur = stateId;
+        let keyframeRows = [];
+        while (cur) {
+            if (this.hasFullManifest(cur)) {
+                keyframeRows = this.readFullManifestRows(cur);
+                break;
+            }
+            deltaChain.push(cur);
+            const parent = this.raw.prepare(`SELECT parent_state_id FROM states WHERE id = ?`).get(cur);
+            cur = parent?.parent_state_id ?? undefined;
+        }
+        const manifestMap = new Map(keyframeRows.map((e) => [e.filePath, e]));
+        for (const sid of deltaChain.reverse()) {
+            const changes = this.raw.prepare(`SELECT file_path, change_type, after_hash FROM file_changes WHERE state_id = ?`).all(sid);
+            for (const c of changes) {
+                if (c.change_type === "deleted") {
+                    manifestMap.delete(c.file_path);
+                }
+                else {
+                    manifestMap.set(c.file_path, { filePath: c.file_path, contentHash: c.after_hash, sizeBytes: -1 });
+                }
+            }
+        }
+        return [...manifestMap.values()].sort((a, b) => a.filePath.localeCompare(b.filePath));
+    }
+    insertAnnotation(a) {
+        this.raw
+            .prepare(`INSERT INTO annotations (id, state_id, summary, reason, decisions_json, risk_level, generated_by, model, status, created_at, input_tokens, output_tokens)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(a.id, a.stateId, a.summary, a.reason, JSON.stringify(a.decisions), a.riskLevel, a.generatedBy, a.model, a.status, a.createdAt ?? new Date().toISOString(), a.inputTokens ?? null, a.outputTokens ?? null);
+    }
+    getAnnotation(stateId) {
+        const row = this.raw
+            .prepare(`SELECT * FROM annotations WHERE state_id = ? ORDER BY created_at DESC LIMIT 1`)
+            .get(stateId);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id, stateId: row.state_id, summary: row.summary, reason: row.reason,
+            decisions: JSON.parse(row.decisions_json ?? "[]"), riskLevel: row.risk_level,
+            generatedBy: row.generated_by, model: row.model, status: row.status, createdAt: row.created_at,
+            inputTokens: row.input_tokens ?? null, outputTokens: row.output_tokens ?? null,
+        };
+    }
+    /** Per-day input/output token totals across all generated annotations, oldest first — the data behind the AI-cost visualization. */
+    // Every LLM call whydid itself makes — checkpoint annotation, build-in-public
+    // drafting, and project chat — records real usage on its own table (they
+    // each already had a natural row to attach it to). This unions all three
+    // so the AI Usage page reflects total real spend, not just annotations.
+    static TOKEN_USAGE_SOURCES = `
+    SELECT a.created_at as created_at, a.model as model, a.input_tokens as input_tokens, a.output_tokens as output_tokens, s.project_id as project_id
+    FROM annotations a JOIN states s ON s.id = a.state_id WHERE a.input_tokens IS NOT NULL
+    UNION ALL
+    SELECT created_at, model, input_tokens, output_tokens, project_id FROM social_posts WHERE input_tokens IS NOT NULL
+    UNION ALL
+    SELECT m.created_at as created_at, m.model as model, m.input_tokens as input_tokens, m.output_tokens as output_tokens, c.project_id as project_id
+    FROM chat_messages m JOIN chat_conversations c ON c.id = m.conversation_id WHERE m.input_tokens IS NOT NULL
+  `;
+    getDailyTokenUsage(projectId, sinceIso) {
+        const rows = this.raw
+            .prepare(`SELECT substr(created_at, 1, 10) as day, SUM(COALESCE(input_tokens, 0)) as input_tokens, SUM(COALESCE(output_tokens, 0)) as output_tokens
+         FROM (${WhydidDatabase.TOKEN_USAGE_SOURCES}) usage
+         WHERE project_id = ? AND created_at >= ?
+         GROUP BY day ORDER BY day ASC`)
+            .all(projectId, sinceIso);
+        return rows.map((r) => ({ date: r.day, inputTokens: r.input_tokens, outputTokens: r.output_tokens }));
+    }
+    /** All-time token totals, broken down per model — pairs with a pricing table to estimate spend, since cost varies per model. */
+    getTokenUsageByModel(projectId) {
+        const rows = this.raw
+            .prepare(`SELECT COALESCE(model, 'unknown') as model, COUNT(*) as calls,
+                SUM(COALESCE(input_tokens, 0)) as input_tokens, SUM(COALESCE(output_tokens, 0)) as output_tokens
+         FROM (${WhydidDatabase.TOKEN_USAGE_SOURCES}) usage
+         WHERE project_id = ?
+         GROUP BY model ORDER BY input_tokens DESC`)
+            .all(projectId);
+        return rows.map((r) => ({ model: r.model, calls: r.calls, inputTokens: r.input_tokens, outputTokens: r.output_tokens }));
+    }
+    /** Same as getTokenUsageByModel but scoped to created_at >= sinceIso — used for month-to-date budget tracking, where "all-time" would never trip an alert. */
+    getTokenUsageByModelSince(projectId, sinceIso) {
+        const rows = this.raw
+            .prepare(`SELECT COALESCE(model, 'unknown') as model, COUNT(*) as calls,
+                SUM(COALESCE(input_tokens, 0)) as input_tokens, SUM(COALESCE(output_tokens, 0)) as output_tokens
+         FROM (${WhydidDatabase.TOKEN_USAGE_SOURCES}) usage
+         WHERE project_id = ? AND created_at >= ?
+         GROUP BY model ORDER BY input_tokens DESC`)
+            .all(projectId, sinceIso);
+        return rows.map((r) => ({ model: r.model, calls: r.calls, inputTokens: r.input_tokens, outputTokens: r.output_tokens }));
+    }
+    insertFork(f) {
+        this.raw
+            .prepare(`INSERT INTO forks (id, project_id, source_state_id, name, created_at) VALUES (?, ?, ?, ?, ?)`)
+            .run(f.id, f.projectId, f.sourceStateId, f.name, new Date().toISOString());
+    }
+    listForks(projectId) {
+        const rows = this.raw.prepare(`SELECT * FROM forks WHERE project_id = ?`).all(projectId);
+        return rows.map((r) => ({
+            id: r.id, projectId: r.project_id, sourceStateId: r.source_state_id, name: r.name, createdAt: r.created_at,
+        }));
+    }
+    /** Idempotent by id — safe to call again after a daemon restart re-scans a session file. */
+    insertSession(s) {
+        this.raw
+            .prepare(`INSERT OR IGNORE INTO sessions (id, project_id, agent, agent_session_id, started_at, ended_at, metadata_json)
+         VALUES (?, ?, ?, ?, ?, NULL, ?)`)
+            .run(s.id, s.projectId, s.agent, s.agentSessionId, s.startedAt, s.metadataJson ?? null);
+    }
+    getSessionByAgentSessionId(projectId, agent, agentSessionId) {
+        const row = this.raw
+            .prepare(`SELECT * FROM sessions WHERE project_id = ? AND agent = ? AND agent_session_id = ?`)
+            .get(projectId, agent, agentSessionId);
+        return row ? this.rowToSession(row) : undefined;
+    }
+    getSession(id) {
+        const row = this.raw.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
+        return row ? this.rowToSession(row) : undefined;
+    }
+    listSessions(projectId, opts = {}) {
+        let sql = `SELECT * FROM sessions WHERE project_id = ? ORDER BY started_at DESC, id DESC`;
+        const params = [projectId];
+        if (opts.limit != null) {
+            sql += ` LIMIT ? OFFSET ?`;
+            params.push(opts.limit, opts.offset ?? 0);
+        }
+        const rows = this.raw.prepare(sql).all(...params);
+        return rows.map((r) => this.rowToSession(r));
+    }
+    countSessions(projectId) {
+        const row = this.raw.prepare(`SELECT COUNT(*) as n FROM sessions WHERE project_id = ?`).get(projectId);
+        return row.n;
+    }
+    getMostRecentActiveTurn(projectId) {
+        const row = this.raw.prepare(`SELECT s.id AS session_id, s.agent, t.id AS turn_id, t.prompt
+       FROM turns t JOIN sessions s ON s.id = t.session_id
+       WHERE s.project_id = ? AND t.status = 'in_progress'
+       ORDER BY t.started_at DESC, t.id DESC LIMIT 1`).get(projectId);
+        return row ? { sessionId: row.session_id, turnId: row.turn_id, prompt: row.prompt, agent: row.agent } : undefined;
+    }
+    listActiveTurns(projectId) {
+        const rows = this.raw.prepare(`SELECT s.id AS session_id, t.id AS turn_id
+       FROM turns t JOIN sessions s ON s.id = t.session_id
+       WHERE s.project_id = ? AND t.status = 'in_progress'`).all(projectId);
+        return rows.map((row) => ({ sessionId: row.session_id, turnId: row.turn_id }));
+    }
+    updateSessionEndedAt(sessionId, endedAt = new Date().toISOString()) {
+        this.raw.prepare(`UPDATE sessions SET ended_at = ? WHERE id = ?`).run(endedAt, sessionId);
+    }
+    // Ordered by started_at, not sequence: a Claude Code session's sequence
+    // numbers come from an in-memory counter (ClaudeCodeTailer) that starts
+    // over at 0 every time the daemon restarts mid-session, so two turns
+    // discovered across a restart can end up with colliding or out-of-order
+    // sequence values even though their real timestamps are always correct.
+    // (Codex/Cursor turns, written through hook-events.ts off a fresh
+    // getLatestTurn() query every time, don't have this problem — but
+    // ordering everyone by the timestamp that's always reliable is simpler
+    // than trusting sequence only for the agents where it happens to hold.)
+    listTurns(sessionId) {
+        const rows = this.raw.prepare(`SELECT * FROM turns WHERE session_id = ? ORDER BY started_at ASC, sequence ASC`).all(sessionId);
+        return rows.map((r) => this.rowToTurn(r));
+    }
+    /** States attributed to a turn (its session/turn id columns), newest first. */
+    getStatesForTurn(turnId) {
+        const rows = this.raw.prepare(`SELECT * FROM states WHERE turn_id = ? ORDER BY created_at DESC`).all(turnId);
+        return rows.map((r) => this.rowToState(r));
+    }
+    rowToSession(row) {
+        return {
+            id: row.id, projectId: row.project_id, agent: row.agent, agentSessionId: row.agent_session_id,
+            startedAt: row.started_at, endedAt: row.ended_at, metadataJson: row.metadata_json,
+        };
+    }
+    /**
+     * Upsert by id (Claude Code's own message uuid) — safe to re-poll the same
+     * turn repeatedly as its title/status/touched-files metadata fills in over
+     * the course of the turn.
+     */
+    insertTurn(t) {
+        this.raw
+            .prepare(`INSERT INTO turns (id, session_id, sequence, prompt, started_at, ended_at, status, metadata_json, kind)
+         VALUES (?, ?, ?, ?, ?, NULL, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET prompt = excluded.prompt, status = excluded.status, metadata_json = excluded.metadata_json`)
+            .run(t.id, t.sessionId, t.sequence, t.prompt, t.startedAt, t.status, t.metadataJson ?? null, t.kind ?? "prompt");
+    }
+    updateTurnStatus(turnId, status, endedAt) {
+        this.raw.prepare(`UPDATE turns SET status = ?, ended_at = ? WHERE id = ?`).run(status, endedAt ?? new Date().toISOString(), turnId);
+    }
+    getTurn(id) {
+        const row = this.raw.prepare(`SELECT * FROM turns WHERE id = ?`).get(id);
+        return row ? this.rowToTurn(row) : undefined;
+    }
+    getLatestTurn(sessionId) {
+        const row = this.raw.prepare(`SELECT * FROM turns WHERE session_id = ? ORDER BY sequence DESC LIMIT 1`).get(sessionId);
+        return row ? this.rowToTurn(row) : undefined;
+    }
+    /** Every turn across the project's sessions where a coding agent's own context got auto-compacted and the session continued — newest first. */
+    listCompactResumeTurns(projectId) {
+        const rows = this.raw
+            .prepare(`SELECT t.* FROM turns t JOIN sessions s ON s.id = t.session_id
+         WHERE s.project_id = ? AND t.kind = 'compact_resume'
+         ORDER BY t.started_at DESC`)
+            .all(projectId);
+        return rows.map((r) => this.rowToTurn(r));
+    }
+    rowToTurn(row) {
+        return {
+            id: row.id, sessionId: row.session_id, sequence: row.sequence, prompt: row.prompt,
+            startedAt: row.started_at, endedAt: row.ended_at, status: row.status, metadataJson: row.metadata_json,
+            kind: row.kind ?? "prompt",
+        };
+    }
+    insertEvent(e) {
+        this.raw
+            .prepare(`INSERT INTO events (id, project_id, type, timestamp, payload_json) VALUES (?, ?, ?, ?, ?)`)
+            .run(e.id, e.projectId, e.type, new Date().toISOString(), e.payloadJson);
+    }
+    insertTestRun(t) {
+        this.raw
+            .prepare(`INSERT INTO test_runs (id, state_id, command, status, exit_code, duration_ms, output_path, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(t.id, t.stateId, t.command, t.status, t.exitCode, t.durationMs, t.outputPath, new Date().toISOString());
+    }
+    getTestRuns(stateId) {
+        const rows = this.raw.prepare(`SELECT * FROM test_runs WHERE state_id = ? ORDER BY created_at DESC`).all(stateId);
+        return rows.map((r) => ({
+            id: r.id, stateId: r.state_id, command: r.command, status: r.status,
+            exitCode: r.exit_code, durationMs: r.duration_ms, outputPath: r.output_path, createdAt: r.created_at,
+        }));
+    }
+    getLatestTestRunForProject(projectId) {
+        const row = this.raw
+            .prepare(`SELECT test_runs.* FROM test_runs
+         JOIN states ON states.id = test_runs.state_id
+         WHERE states.project_id = ?
+         ORDER BY test_runs.created_at DESC LIMIT 1`)
+            .get(projectId);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id, stateId: row.state_id, command: row.command, status: row.status,
+            exitCode: row.exit_code, durationMs: row.duration_ms, outputPath: row.output_path, createdAt: row.created_at,
+        };
+    }
+}
+//# sourceMappingURL=database.js.map