@faithfulalabi/agent-lens 0.1.0

package/dist/src/corpus/watch.js

@@ -0,0 +1,189 @@
+import { createArchiveReader } from '../archive/read.js';
+import { resolveArchiveRoot, resolveTranscriptRoot } from '../archive/paths.js';
+import { createContentEnv, createContentResolver, createSpillLocator } from '../content/resolve.js';
+import { ensureProjected } from '../db/freshness.js';
+import { readChildSessionIds, readEventArchivePath, readMeta, readTreeRoots } from '../db/read.js';
+import { readSessionEnvelope } from '../db/sidecars.js';
+import { indexSpills } from '../db/spill-index.js';
+import { markRollupComplete, recomputeSubagentRollups, setParentSession, upsertSessionIndex, writeMeta, } from '../db/write.js';
+import { createProjectionEnv } from './env.js';
+import { decodeProjectDir, projectSlugOf, rowIdOf, workflowParentOf } from './paths.js';
+import { scanCorpus } from './scan.js';
+const INTERVAL_MS = 1000;
+const WAVE2_DEADLINE_MS = 250;
+export function emptyReport() {
+    return {
+        walked: 0,
+        indexed: 0,
+        indexed_ids: [],
+        deferred: 0,
+        deferred_wf_sidecars: 0,
+        unchanged: 0,
+        excluded: [],
+        ignored: 0,
+        unkeyable: [],
+        envelope_incomplete: [],
+        projection_failed: [],
+        spills_indexed: 0,
+        spills_removed: 0,
+        spills_skipped: [],
+    };
+}
+export function createSpillIndexEnv(db, reader, roots) {
+    const archivePathOf = (id) => readEventArchivePath(db, id)?.archive_path;
+    const env = createContentEnv(reader, roots);
+    return {
+        resolve: createContentResolver(archivePathOf, env),
+        locate: createSpillLocator(archivePathOf, env),
+    };
+}
+export function conservationOf(report) {
+    return {
+        walked: report.walked,
+        accounted: report.indexed +
+            report.deferred +
+            report.unchanged +
+            report.ignored +
+            report.excluded.length +
+            report.unkeyable.length +
+            report.envelope_incomplete.length,
+    };
+}
+export function startCorpusSweep(options) {
+    const sweep = createCorpusSweep(options);
+    sweep.tick();
+    return sweep.bind();
+}
+export function createCorpusSweep(options) {
+    const { db } = options;
+    const now = options.now ?? Date.now;
+    const intervalMs = options.intervalMs ?? INTERVAL_MS;
+    const deadlineMs = options.wave2DeadlineMs ?? WAVE2_DEADLINE_MS;
+    const archiveRoot = resolveArchiveRoot(options.dataDir);
+    const sourceRoot = resolveTranscriptRoot(options.transcriptRoot);
+    const reader = options.reader ?? createArchiveReader();
+    const env = createProjectionEnv(reader, { archiveRoot, transcriptRoot: sourceRoot });
+    const spillEnv = createSpillIndexEnv(db, reader, [archiveRoot, sourceRoot]);
+    let last = emptyReport();
+    const runWave1 = (report) => {
+        const scan = scanCorpus(db, archiveRoot, sourceRoot);
+        report.walked += scan.walked;
+        report.unchanged += scan.unchanged;
+        report.deferred += scan.deferred;
+        report.ignored += scan.ignored;
+        report.excluded.push(...scan.excluded);
+        report.unkeyable.push(...scan.unkeyable);
+        const queue = [...scan.changed].sort((a, b) => b.fold.mtime_ms - a.fold.mtime_ms);
+        for (const entry of queue) {
+            const seed = decodeProjectDir(projectSlugOf(entry.relPath));
+            const envelope = readSessionEnvelope(reader, entry.archivePath, seed);
+            if (envelope === undefined) {
+                report.envelope_incomplete.push(entry.relPath);
+                continue;
+            }
+            const id = rowIdOf(entry.relPath);
+            upsertSessionIndex(db, {
+                id,
+                source_path: entry.sourcePath,
+                archive_path: entry.archivePath,
+                file_mtime_ms: entry.fold.mtime_ms,
+                file_size: entry.fold.size,
+                project_path: envelope.project_path,
+                started_at: envelope.started_at,
+                last_activity_at: envelope.last_activity_at,
+            });
+            report.indexed += 1;
+            report.indexed_ids.push(id);
+            const parent = workflowParentOf(entry.relPath);
+            if (parent !== undefined) {
+                setParentSession(db, id, parent);
+                report.deferred_wf_sidecars += 1;
+            }
+        }
+        stampIndexMeta(db, sourceRoot, report, now);
+    };
+    const projectTree = (root, report) => {
+        const done = [];
+        const seen = new Set();
+        let frontier = [root];
+        while (frontier.length > 0) {
+            const next = [];
+            for (const id of frontier) {
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                done.push(id);
+                if (ensureProjected(db, id, env) === 'failed')
+                    report.projection_failed.push(id);
+                for (const child of readChildSessionIds(db, id)) {
+                    if (!seen.has(child))
+                        next.push(child);
+                }
+            }
+            frontier = next;
+        }
+        for (const id of done.reverse())
+            recomputeSubagentRollups(db, id);
+        markRollupComplete(db, root);
+    };
+    const runWave2 = (report, startedAt) => {
+        let processed = 0;
+        for (const root of readTreeRoots(db)) {
+            if (processed > 0 && now() - startedAt >= deadlineMs)
+                break;
+            projectTree(root, report);
+            processed += 1;
+        }
+        const spills = indexSpills(db, spillEnv, { now, startedAt, deadlineMs });
+        report.spills_indexed += spills.indexed;
+        report.spills_removed += spills.removed;
+        report.spills_skipped.push(...spills.skipped);
+    };
+    const tick = () => {
+        const startedAt = now();
+        const report = emptyReport();
+        runWave1(report);
+        runWave2(report, startedAt);
+        last = report;
+        return report;
+    };
+    const wave1 = () => {
+        const report = emptyReport();
+        runWave1(report);
+        last = report;
+        return report;
+    };
+    const wave2 = () => {
+        const report = emptyReport();
+        runWave2(report, now());
+        last = report;
+        return report;
+    };
+    let timer;
+    const handle = {
+        tick,
+        wave1,
+        wave2,
+        report: () => last,
+        close: () => {
+            if (timer !== undefined)
+                clearInterval(timer);
+            timer = undefined;
+        },
+        bind: () => {
+            timer = setInterval(tick, intervalMs);
+            timer.unref?.();
+            return handle;
+        },
+    };
+    return handle;
+}
+function stampIndexMeta(db, sourceRoot, report, now) {
+    if (readMeta(db, 'projects_root') !== sourceRoot)
+        writeMeta(db, 'projects_root', sourceRoot);
+    if (report.unkeyable.length > 0 || report.envelope_incomplete.length > 0)
+        return;
+    if (readMeta(db, 'index_built_at') !== undefined && report.indexed === 0)
+        return;
+    writeMeta(db, 'index_built_at', new Date(now()).toISOString());
+}

package/dist/src/db/freshness.js

@@ -0,0 +1,82 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { statSafe } from '../archive/paths.js';
+import { PROJECTOR_VERSION } from '../transcript/version.js';
+import { SCHEMA_VERSION } from './schema.js';
+import { projectSession, writeMeta } from './write.js';
+const TRANSCRIPT_EXT = '.jsonl';
+const SEALED_SUFFIX = '.zst';
+export function foldArchive(archivePath) {
+    const parent = statSafe(archivePath) ?? statSafe(`${archivePath}${SEALED_SUFFIX}`);
+    if (parent === undefined)
+        return undefined;
+    const fold = {
+        mtime_ms: Math.floor(parent.mtimeMs),
+        size: parent.size,
+        sidecar_count: 0,
+    };
+    if (archivePath.endsWith(TRANSCRIPT_EXT)) {
+        walk(archivePath.slice(0, -TRANSCRIPT_EXT.length), fold);
+    }
+    return fold;
+}
+function walk(dir, fold) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(path, fold);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const stat = statSafe(path);
+        if (stat === undefined)
+            continue;
+        fold.mtime_ms = Math.max(fold.mtime_ms, Math.floor(stat.mtimeMs));
+        fold.size += stat.size;
+        if (entry.name.endsWith(TRANSCRIPT_EXT))
+            fold.sidecar_count += 1;
+    }
+}
+export function fingerprint(fold) {
+    return `${fold.mtime_ms}:${fold.size}:${fold.sidecar_count}`;
+}
+export function seedMeta(db) {
+    writeMeta(db, 'schema_version', String(SCHEMA_VERSION));
+    writeMeta(db, 'projector_version', String(PROJECTOR_VERSION));
+}
+const GATE_SQL = `SELECT archive_path, projected_mtime_ms, projected_size, projector_version
+  FROM sessions WHERE id = ?`;
+export function ensureProjectedFold(db, id, env) {
+    const row = db.prepare(GATE_SQL).get(id);
+    if (row === undefined) {
+        seedMeta(db);
+        return { outcome: 'unindexed' };
+    }
+    const fold = foldArchive(row.archive_path);
+    if (fold === undefined)
+        return { outcome: 'failed' };
+    if (row.projected_mtime_ms === fold.mtime_ms &&
+        row.projected_size === fold.size &&
+        row.projector_version === PROJECTOR_VERSION) {
+        return { outcome: 'hit', fold };
+    }
+    seedMeta(db);
+    try {
+        projectSession(db, id, env, fold);
+    }
+    catch {
+        return { outcome: 'failed', fold };
+    }
+    return { outcome: 'projected', fold };
+}
+export function ensureProjected(db, id, env) {
+    return ensureProjectedFold(db, id, env).outcome;
+}

package/dist/src/db/open.js

@@ -0,0 +1,74 @@
+import { existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { acquireLock } from '../archive/lock.js';
+import { SCHEMA_DDL, SCHEMA_VERSION } from './schema.js';
+export const CACHE_DB_FILE = 'cache.db';
+export const CACHE_LOCK_FILE = 'cache.db.lock';
+export class DbLockedError extends Error {
+    holderPid;
+    constructor(message, holderPid) {
+        super(message);
+        this.name = 'DbLockedError';
+        this.holderPid = holderPid;
+    }
+}
+export function applyConnectionPragmas(db) {
+    db.exec('PRAGMA busy_timeout = 5000');
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA synchronous = NORMAL');
+}
+function journalModeOf(db) {
+    return String(db.prepare('PRAGMA journal_mode').get()?.journal_mode);
+}
+function userVersionOf(db) {
+    return Number(db.prepare('PRAGMA user_version').get()?.user_version);
+}
+function connect(path) {
+    const db = new DatabaseSync(path);
+    applyConnectionPragmas(db);
+    return db;
+}
+function shutdown(db, lock) {
+    if (db?.isOpen === true)
+        db.close();
+    lock.release();
+}
+export function openReadOnlyDb(dataDir) {
+    const path = join(dataDir, CACHE_DB_FILE);
+    if (!existsSync(path))
+        return undefined;
+    return new DatabaseSync(path, { readOnly: true });
+}
+export function openDb(options) {
+    const { dataDir, port, identity, readJournalMode = journalModeOf } = options;
+    const lockPath = join(dataDir, CACHE_LOCK_FILE);
+    const lock = acquireLock(dataDir, identity, lockPath);
+    if (lock.state.state === 'held') {
+        const holderPid = lock.state.holder_pid;
+        const who = `agent-lens is already running (pid ${holderPid ?? 'unknown'})`;
+        throw new DbLockedError(port === undefined ? `${who}; ${lockPath} is held` : `${who}; port ${port} was requested`, holderPid);
+    }
+    const path = join(dataDir, CACHE_DB_FILE);
+    let handle;
+    try {
+        handle = connect(path);
+        if (userVersionOf(handle) !== SCHEMA_VERSION) {
+            handle.close();
+            for (const suffix of ['', '-wal', '-shm'])
+                rmSync(path + suffix, { force: true });
+            handle = connect(path);
+            handle.exec(SCHEMA_DDL);
+        }
+        const mode = readJournalMode(handle);
+        if (mode !== 'wal') {
+            throw new Error(`refusing to use ${path}: journal_mode read back '${mode}', not 'wal'`);
+        }
+        const db = handle;
+        return { db, close: () => shutdown(db, lock) };
+    }
+    catch (error) {
+        shutdown(handle, lock);
+        throw error;
+    }
+}

package/dist/src/db/read.js

@@ -0,0 +1,266 @@
+import { PROJECTOR_VERSION } from '../transcript/version.js';
+const PAGE_TAIL = ' LIMIT ? OFFSET ?';
+function pushPageParams(params, page) {
+    params.push(page.limit + 1, page.offset);
+}
+function pageOf(db, query, map, { limit, offset }) {
+    const rows = db.prepare(query.sql).all(...query.params);
+    return {
+        items: rows.slice(0, limit).map(map),
+        limit,
+        offset,
+        has_more: rows.length > limit,
+    };
+}
+const SORT_EXPRESSIONS = {
+    recent: 'last_activity_at',
+    cost: 'est_cost',
+    tokens: '(tokens_in + tokens_out)',
+    errors: 'error_count',
+};
+const SESSION_LIST_COLUMNS = `id, title, preview, project_path, git_branch, model, harness_version,
+     started_at, last_activity_at, turn_count, tool_call_count, error_count,
+     tokens_in, tokens_out, tokens_cache_read, tokens_cache_write, est_cost,
+     agent_count, sub_tool_call_count, sub_error_count, sub_tokens_in, sub_tokens_out,
+     sub_tokens_cache_read, sub_tokens_cache_write, sub_est_cost, rollup_state, drift_json`;
+const TOP_LEVEL_ONLY = 'parent_session_id IS NULL';
+const NO_DRIFT = '{}';
+const Q_PREDICATE = "(COALESCE(title,'') || ' ' || COALESCE(preview,'') || ' ' || project_path) LIKE ? ESCAPE '\\'";
+function likeContains(q) {
+    return `%${q.replace(/[\\%_]/g, (ch) => `\\${ch}`)}%`;
+}
+function toSessionRow(row) {
+    const { drift_json, ...rest } = row;
+    return { ...rest, has_drift: drift_json !== NO_DRIFT };
+}
+export function buildSessionListSql(query) {
+    const where = [TOP_LEVEL_ONLY];
+    const params = [];
+    if (query.project !== undefined) {
+        where.push('project_path = ?');
+        params.push(query.project);
+    }
+    if (query.q !== undefined) {
+        where.push(Q_PREDICATE);
+        params.push(likeContains(query.q));
+    }
+    const sort = query.sort ?? 'recent';
+    const order = SORT_EXPRESSIONS[sort];
+    if (order === undefined)
+        throw new Error(`unknown sort: ${String(sort)}`);
+    const sql = `SELECT ${SESSION_LIST_COLUMNS} FROM sessions WHERE ${where.join(' AND ')}` +
+        ` ORDER BY ${order} DESC, id DESC${PAGE_TAIL}`;
+    pushPageParams(params, query);
+    return { sql, params };
+}
+export function readSessionList(db, query) {
+    return pageOf(db, buildSessionListSql(query), toSessionRow, query);
+}
+export function buildProjectsSql() {
+    return {
+        sql: `SELECT project_path AS path, count(*) AS session_count,` +
+            ` max(last_activity_at) AS last_activity_at FROM sessions WHERE ${TOP_LEVEL_ONLY}` +
+            ` GROUP BY project_path ORDER BY last_activity_at DESC, path ASC`,
+        params: [],
+    };
+}
+export function readProjects(db) {
+    const query = buildProjectsSql();
+    return { items: db.prepare(query.sql).all() };
+}
+const SESSION_HEADER_COLUMNS = `${SESSION_LIST_COLUMNS},
+     agent_type, agent_description, spawn_depth, parent_session_id,
+     projection_state, projection_error, projector_version, projected_at`;
+function parseDrift(text) {
+    const raw = JSON.parse(text);
+    return {
+        unknown_line_types: raw.unknown_line_types ?? {},
+        unknown_block_types: raw.unknown_block_types ?? {},
+        unjoined_tool_uses: raw.unjoined_tool_uses ?? 0,
+        unresolved_spills: raw.unresolved_spills ?? 0,
+    };
+}
+function toDetailHeader(row) {
+    const { agent_type, agent_description, spawn_depth, parent_session_id, projection_state, projection_error, projector_version, projected_at, ...listRow } = row;
+    const header = {
+        ...toSessionRow(listRow),
+        cwd: listRow.project_path,
+        projection: {
+            state: projection_state,
+            projector_version,
+            projected_at,
+            drift: parseDrift(listRow.drift_json),
+        },
+    };
+    if (projection_error !== null)
+        header.projection.error = projection_error;
+    if (agent_type !== null)
+        header.agent_type = agent_type;
+    if (agent_description !== null)
+        header.agent_description = agent_description;
+    if (spawn_depth !== null)
+        header.spawn_depth = spawn_depth;
+    if (parent_session_id !== null)
+        header.parent_session_id = parent_session_id;
+    return header;
+}
+export function readSessionHeader(db, id) {
+    const row = db
+        .prepare(`SELECT ${SESSION_HEADER_COLUMNS} FROM sessions WHERE id = ?`)
+        .get(id);
+    return row === undefined ? undefined : toDetailHeader(row);
+}
+const TURN_COLUMNS = `id, seq, kind, parent_event_id, title, started_at, ended_at, duration_ms, duration_source,
+     tokens_in, tokens_out, tokens_cache_read, tokens_cache_write, est_cost,
+     tool_call_count, error_count, first_seq, last_seq`;
+export function readTurns(db, session_id) {
+    return db
+        .prepare(`SELECT ${TURN_COLUMNS} FROM turns WHERE session_id = ? ORDER BY seq`)
+        .all(session_id);
+}
+const EVENT_COLUMNS = `id, turn_id, seq, kind, ts, request_id, block_index, name, status,
+     duration_ms, duration_source, input, input_bytes, input_storage,
+     text, text_bytes, output_storage, spill_path, spill_bytes,
+     model, tokens_in, tokens_out, tokens_cache_read, tokens_cache_write, est_cost,
+     child_session_id, agent_type, agent_status, raw_type, raw_subtype`;
+export function buildEventPageSql(session_id, query) {
+    return {
+        sql: `SELECT ${EVENT_COLUMNS} FROM events WHERE session_id = ? AND seq >= ?` +
+            ` ORDER BY seq LIMIT ?`,
+        params: [session_id, query.from_seq, query.limit + 1],
+    };
+}
+export function readEventPage(db, session_id, query) {
+    const built = buildEventPageSql(session_id, query);
+    const rows = db.prepare(built.sql).all(...built.params);
+    const items = rows.slice(0, query.limit);
+    const last = items[items.length - 1];
+    return {
+        items,
+        next_seq: last === undefined ? query.from_seq : last.seq + 1,
+        has_more: rows.length > query.limit,
+    };
+}
+export function readRunningEventIds(db, session_id) {
+    const rows = db
+        .prepare(`SELECT id FROM events WHERE session_id = ? AND status = 'running' ORDER BY seq`)
+        .all(session_id);
+    return rows.map((row) => row.id);
+}
+export function readEventsByIds(db, session_id, ids) {
+    if (ids.length === 0)
+        return [];
+    const holes = ids.map(() => '?').join(', ');
+    return db
+        .prepare(`SELECT ${EVENT_COLUMNS} FROM events WHERE session_id = ? AND id IN (${holes}) ORDER BY seq`)
+        .all(session_id, ...ids);
+}
+export const EVENT_CONTENT_COLUMNS = `id, session_id, block_index, input, input_bytes, input_storage,
+     text, text_bytes, output_storage, spill_path, spill_bytes,
+     src_offset, src_len, result_offset, result_len, result_block`;
+export function readEventContentRow(db, event_id) {
+    return db
+        .prepare(`SELECT ${EVENT_CONTENT_COLUMNS} FROM events WHERE id = ?`)
+        .get(event_id);
+}
+export function readEventArchivePath(db, session_id) {
+    return db
+        .prepare(`SELECT archive_path, parent_session_id FROM sessions WHERE id = ?`)
+        .get(session_id);
+}
+const SNIPPET = `snippet(events_fts, -1, '<mark>', '</mark>', '…', 12)`;
+const SPILL_SNIPPET = `snippet(spill_fts, 3, '<mark>', '</mark>', '…', 12)`;
+function ftsPhrase(q) {
+    return `"${q.replaceAll('"', '""')}"`;
+}
+function searchSql(scoped) {
+    const scope = scoped ? ' AND e.session_id = :session' : '';
+    const events = `SELECT e.session_id AS session_id, s.title AS session_title, s.project_path AS project_path,` +
+        ` e.turn_id AS turn_id, e.id AS event_id, e.seq AS seq, e.kind AS kind, e.name AS name,` +
+        ` e.ts AS ts, ${SNIPPET} AS snippet, rank AS score` +
+        ` FROM events_fts JOIN events e ON e.rowid = events_fts.rowid` +
+        ` JOIN sessions s ON s.id = e.session_id` +
+        ` WHERE events_fts MATCH :q${scope}`;
+    const spills = `SELECT e.session_id, s.title, s.project_path, e.turn_id, e.id, e.seq, e.kind, e.name,` +
+        ` e.ts, ${SPILL_SNIPPET}, rank` +
+        ` FROM spill_fts JOIN events e ON e.id = spill_fts.event_id` +
+        ` AND e.output_storage = 'spill' AND e.spill_path = spill_fts.spill_path` +
+        ` JOIN sessions s ON s.id = e.session_id` +
+        ` WHERE spill_fts MATCH :q${scope}`;
+    return (`SELECT session_id, session_title, project_path, turn_id, event_id, seq, kind, name, ts,` +
+        ` snippet FROM (${events} UNION ALL ${spills}) ORDER BY score LIMIT :limit`);
+}
+export function searchEvents(db, query) {
+    const scoped = query.session !== undefined;
+    const sql = searchSql(scoped);
+    const run = (q) => db.prepare(sql).all({
+        q,
+        limit: query.limit,
+        ...(scoped && { session: query.session }),
+    });
+    try {
+        return run(query.q);
+    }
+    catch {
+        return run(ftsPhrase(query.q));
+    }
+}
+export function countUnprojected(db) {
+    const row = db
+        .prepare(`SELECT count(*) AS n FROM sessions WHERE projection_state NOT IN ('ready', 'empty')`)
+        .get();
+    return row.n;
+}
+const WARMABLE_SQL = `SELECT id FROM sessions
+  WHERE projection_state NOT IN ('ready', 'empty')
+     OR projector_version IS NOT :version
+  ORDER BY last_activity_at DESC, id DESC`;
+export function readWarmableIds(db) {
+    const rows = db.prepare(WARMABLE_SQL).all({ version: PROJECTOR_VERSION });
+    return rows.map((row) => row.id);
+}
+export function readDriftRows(db) {
+    return db
+        .prepare(`SELECT id, title, harness_version, drift_json FROM sessions
+       WHERE projection_state = 'ready'`)
+        .all();
+}
+export function readHealthCounts(db) {
+    const sessions = db
+        .prepare(`SELECT count(*) AS sessions_indexed,
+       coalesce(sum(projection_state IN ('ready', 'empty')), 0) AS sessions_projected
+     FROM sessions`)
+        .get();
+    const pages = db.prepare('PRAGMA page_count').get();
+    const size = db.prepare('PRAGMA page_size').get();
+    return { ...sessions, db_bytes: pages.page_count * size.page_size };
+}
+export function readEventCount(db, session_id) {
+    const row = db
+        .prepare('SELECT count(*) AS n FROM events WHERE session_id = ?')
+        .get(session_id);
+    return row.n;
+}
+export function readIndexedFolds(db) {
+    const rows = db
+        .prepare('SELECT archive_path, file_mtime_ms, file_size FROM sessions')
+        .all();
+    return new Map(rows.map((row) => [row.archive_path, row]));
+}
+export function readMeta(db, key) {
+    const row = db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
+    return row?.value;
+}
+const TREE_ROOTS_SQL = `SELECT id FROM sessions
+  WHERE parent_session_id IS NULL AND rollup_state = 'own'
+  ORDER BY last_activity_at DESC, id DESC`;
+export function readTreeRoots(db) {
+    const rows = db.prepare(TREE_ROOTS_SQL).all();
+    return rows.map((row) => row.id);
+}
+export function readChildSessionIds(db, session_id) {
+    const rows = db
+        .prepare('SELECT id FROM sessions WHERE parent_session_id = ?')
+        .all(session_id);
+    return rows.map((row) => row.id);
+}