rvlib-shipkit 2.2.0 → 2.4.0

package/src/agent-time/signals.ts

@@ -0,0 +1,84 @@
+// What his typed prompts say about the work, by rule, no model: a status ping
+// (he is waiting and asks where things stand), a slowness complaint, a
+// correction. The rules are this visible table, so every count is explainable
+// by the row that matched.
+//
+// The constraint a reader breaks first: his prompts are also SPECS, and a spec
+// says "slow" about the game ("the camera pans too slow"). A slowness rule
+// names the agent's world (tests, the gate, a tool, "takes forever"), never
+// the bare word.
+
+export type Signal = 'status' | 'slow' | 'correction'
+
+export type Rule = { signal: Signal; id: string; re: RegExp }
+
+const AGENT_WORLD = String.raw`(?:tests?|ci|gate|tools?|builds?|agents?|commands?|machine|cpu|checks?|deploys?|hub|servers?|sessions?|lanes?|you|sk|shipkit|typecheck|tsc|lint|everything|things|projects?|progress|it all|shots?|renders?|indexing)`
+
+export const RULES: Rule[] = [
+    { signal: 'status', id: 'where-stand', re: /\bwhere (?:do|are) we (?:stand|at)\b/i },
+    { signal: 'status', id: 'progress', re: /\b(?:good progress|any progress|how(?:'s| is) it going|any news|status update|still (?:running|working|on it)|are you (?:done|finished|still))\b/i },
+    { signal: 'status', id: 'done-q', re: /^\s*(?:done|finished|status|progress|eta|so)\s*\?+\s*$/i },
+    { signal: 'status', id: 'fr-avance', re: /\b(?:ça avance|ca avance|où en (?:est|sommes)|ou en est)\b/i },
+
+    { signal: 'slow', id: 'too-slow', re: new RegExp(String.raw`\b${AGENT_WORLD}\b[^.?!\n]{0,40}\b(?:too|so|very|really|super|crazy|insanely|extremely|painfully)\s+slow|\b(?:too|so|very|really|super|crazy|insanely|extremely|painfully)\s+slow\b[^.?!\n]{0,30}\b${AGENT_WORLD}\b`, 'i') },
+    { signal: 'slow', id: 'takes-long', re: /\b(?:takes?|taking|took)\s+(?:so\s+|too\s+|way\s+too\s+|really\s+)?(?:long|forever|ages|minutes)\b/i },
+    { signal: 'slow', id: 'world-slow', re: new RegExp(String.raw`\b${AGENT_WORLD}\b[^.?!\n]{0,40}\b(?:slow|sluggish|hangs?|stuck)\b`, 'i') },
+    { signal: 'slow', id: 'slow-world', re: new RegExp(String.raw`\b(?:slow|sluggish)\b[^.?!\n]{0,20}\b${AGENT_WORLD}\b`, 'i') },
+    { signal: 'slow', id: 'make-faster', re: new RegExp(String.raw`\b(?:make|making|get)\s+${AGENT_WORLD}\s+(?:\w+\s+)?faster\b`, 'i') },
+    { signal: 'slow', id: 'still-waiting', re: /\b(?:(?:i'?m|i am|we'?re|we are) still waiting|waiting for ages|been waiting|wait(?:ing)? forever|my cpu|save my machine)\b/i },
+    { signal: 'slow', id: 'slow-equals', re: /\bslow\s*=\s*wrong\b/i },
+
+    { signal: 'correction', id: 'double-bang', re: /!!/ },
+    { signal: 'correction', id: 'already-said', re: /\b(?:i (?:already|just) (?:said|told|asked)|how many times|as i said|i said (?:it|that) before|again\s*\?!|stop doing)\b/i },
+    { signal: 'correction', id: 'swear', re: /\b(?:wtf|fuck\w*|ffs|ridiculous|seriously\s*\?|are you kidding)\b/i },
+    { signal: 'correction', id: 'not-what', re: /\b(?:that'?s not what i (?:asked|said|meant)|you (?:didn'?t|did not) (?:read|listen)|you misread|wrong again)\b/i },
+]
+
+/** short words in capitals that are names, never shouting */
+const CAPS_OK = new Set([
+    'API', 'URL', 'URLS', 'JSON', 'HTML', 'CSS', 'PR', 'OK', 'TODO', 'README', 'CLI', 'TUI', 'DSL', 'TLDR', 'ASAP', 'GPU', 'CPU', 'IDS',
+    'FAIL', 'WARN', 'GO', 'UI', 'UX', 'SVG', 'PNG', 'MP4', 'SQL', 'HTTP', 'HTTPS', 'SSH', 'NPM', 'TS', 'JS', 'MD', 'IMO', 'FYI', 'LLM',
+    'AGENTS', 'CLAUDE', 'STE', 'VAT', 'TVA', 'OVH', 'DNS', 'CDN', 'OG', 'RGB', 'FPS', 'HMR', 'MCP', 'SDK', 'AI', 'GIF', 'PDF', 'EN', 'FR',
+    'WIP', 'MVP', 'VS', 'ID', 'NPC', 'NPCS', 'HUD', 'HP', 'XP', 'UTC', 'CET', 'ENV', 'EOF', 'RAM', 'SSD', 'USB', 'AND', 'OR', 'NOT',
+])
+
+/** code and pastes say nothing about his mood: fenced blocks, inline code and
+ *  quoted pastes are dropped before any rule runs */
+export function prose(text: string): string {
+    return text
+        .replace(/<pasted_content\b[\s\S]*?(?:<\/pasted_content>|$)/g, ' ')
+        .replace(/```[\s\S]*?(?:```|$)/g, ' ')
+        .replace(/`[^`\n]*`/g, ' ')
+        .split('\n')
+        // quoted lines, tables, stack frames, shell lines, and an agent's report
+        // pasted back (its lines open on a skim marker)
+        .filter((l) => !/^\s*(?:>|\||\d+\s*[|:]|at |\$ |[✅💬🔴🔶🧹💡❓🤝🚧🔼🚀🔒💥💸])/u.test(l))
+        .join('\n')
+}
+
+/** two or more shouted words (three letters or more, not a known name) */
+export function shouts(text: string): number {
+    const words = text.match(/\b[A-Z][A-Z']{2,}\b/g) ?? []
+    return words.filter((w) => !CAPS_OK.has(w.replace(/'.*$/, '')) && !/^[A-Z]{2,}\d/.test(w)).length
+}
+
+export type SignalHit = { signal: Signal; rule: string }
+
+/** every signal one prompt carries, with the rule that matched each */
+/** joy shouts too: `!!` and capitals next to these words are delight, not a correction */
+const JOY = /\b(?:love|amazing|great|awesome|perfect|fantastic|wonderful|beautiful|wow|nice|yes|excellent|brilliant|bravo|incredible|gorgeous)\b/i
+
+export function signalsOf(text: string): SignalHit[] {
+    const body = prose(text).slice(0, 2000)
+    const hits: SignalHit[] = []
+    const seen = new Set<Signal>()
+    const joy = JOY.test(body)
+    for (const r of RULES) {
+        if (joy && r.id === 'double-bang') continue
+        if (seen.has(r.signal) || !r.re.test(body)) continue
+        seen.add(r.signal)
+        hits.push({ signal: r.signal, rule: r.id })
+    }
+    if (!seen.has('correction') && !joy && shouts(body) >= 2) hits.push({ signal: 'correction', rule: 'caps' })
+    return hits
+}

package/src/agent-time/store.ts

@@ -0,0 +1,379 @@
+// THE AGENT TIME INDEX: every Claude Code transcript on this machine, every
+// config root, read once into one sqlite file, `~/.shipkit/agent-time.sqlite`.
+// A file is read again only when it changed, and a live session only from
+// where the last read stopped, so a warm query reads a few new lines.
+//
+// The index KEEPS what Claude Code prunes: a transcript deleted by retention
+// stays here, so the history grows past the harness's window.
+//
+// The constraint a reader breaks first: the rows hold his commands and prompts.
+// The file is machine local, under $HOME, never in a repo, and every line
+// printed from it goes through mask.ts.
+//
+// Several agents query at once: each file is indexed inside one immediate
+// transaction that reads its row again first, so two indexers never both
+// append the same lines, and a killed build resumes at the next file.
+import { Database } from 'bun:sqlite'
+import { closeSync, existsSync, mkdirSync, openSync, readSync, readdirSync, statSync } from 'fs'
+import { homedir } from 'os'
+import { basename, dirname, join } from 'path'
+import { ensureWal } from '../ledger/db.ts'
+import { type ConfigRoot, discoverConfigRoots } from '../reflect/prompt-corpus.ts'
+import { type TranscriptEvent, readTranscriptLine } from '../reflect/transcript.ts'
+import { SHAPE_VERSION, toolShape } from './shape.ts'
+import { READ_VERSION, isReadOnly } from './turns.ts'
+import type { Call, Mark } from './timeline.ts'
+
+export const AGENT_TIME_DB_ENV = 'SHIPKIT_AGENT_TIME_DB'
+
+/** bumped when what a row holds changes: every file is read again */
+export const INDEX_VERSION = 6
+
+export function agentTimeDbPath(): string {
+    const env = process.env[AGENT_TIME_DB_ENV]
+    if (env != null && env !== '') return env
+    return join(homedir(), '.shipkit', 'agent-time.sqlite')
+}
+
+const SCHEMA = `
+create table if not exists files (
+    id integer primary key,
+    path text not null unique,
+    account text not null,
+    project text not null,
+    session text not null,
+    agent text not null,
+    size integer not null,
+    mtime integer not null,
+    offset integer not null,
+    version integer not null,
+    first_at integer,
+    last_at integer,
+    gone integer not null default 0
+);
+create index if not exists files_project on files (project);
+create table if not exists calls (
+    file_id integer not null,
+    id text not null,
+    start integer not null,
+    end integer,
+    tool text not null,
+    shape text not null,
+    cmd text not null,
+    outcome text,
+    code integer,
+    approval integer not null default 0,
+    perm text not null default '',
+    read integer not null default 0
+);
+create index if not exists calls_file on calls (file_id, start);
+create table if not exists marks (
+    file_id integer not null,
+    at integer not null,
+    kind text not null
+);
+create index if not exists marks_file on marks (file_id, at);
+create table if not exists prompts (
+    file_id integer not null,
+    at integer not null,
+    uuid text,
+    origin text not null,
+    text text not null
+);
+create index if not exists prompts_file on prompts (file_id, at);
+create table if not exists meta (key text primary key, value text not null);
+`
+
+export function openIndex(path = agentTimeDbPath()): Database {
+    mkdirSync(dirname(path), { recursive: true })
+    const db = new Database(path, { create: true, readwrite: true })
+    db.exec('pragma busy_timeout = 30000')
+    ensureWal(db, 5_000)
+    db.exec('pragma synchronous = normal')
+    db.exec(SCHEMA)
+    migrate(db)
+    return db
+}
+
+/** columns added after the first build, added in place: the rows of pruned
+ *  transcripts cannot be read again, so a migration never drops a table */
+function migrate(db: Database): void {
+    const cols = (db.query('pragma table_info(calls)').all() as { name: string }[]).map((c) => c.name)
+    if (!cols.includes('approval')) db.exec('alter table calls add column approval integer not null default 0')
+    if (!cols.includes('perm')) db.exec("alter table calls add column perm text not null default ''")
+    if (!cols.includes('read')) db.exec('alter table calls add column read integer not null default 0')
+    // a tool use id is unique on the machine: a session copied into a second
+    // account (to resume it there) holds the same calls, written once
+    const unique = db.query("select 1 from sqlite_master where type = 'index' and name = 'calls_id'").get()
+    if (unique == null) {
+        db.exec('drop index if exists calls_open')
+        db.exec('delete from calls where rowid not in (select min(rowid) from calls group by id)')
+        db.exec('create unique index calls_id on calls (id)')
+    }
+    const row = db.query("select value from meta where key = 'shape'").get() as { value: string } | null
+    if (row?.value === RULES_VERSION) return
+    reshape(db)
+}
+
+/** the shape rules and the read rules, one stamp: either changing reshapes */
+const RULES_VERSION = `${SHAPE_VERSION}.${READ_VERSION}`
+
+/** a shape or read rule changed: every call is shaped and judged again from
+ *  its stored command, pruned transcripts included, no file read */
+function reshape(db: Database): void {
+    const rows = db.query('select rowid, tool, cmd, shape, read from calls').all() as { rowid: number; tool: string; cmd: string; shape: string; read: number }[]
+    const set = db.query('update calls set shape = ?, read = ? where rowid = ?')
+    db.transaction(() => {
+        for (const r of rows) {
+            const shape = toolShape(r.tool, r.cmd)
+            const read = isReadOnly({ tool: r.tool, shape, cmd: r.cmd }) ? 1 : 0
+            if (shape !== r.shape || read !== r.read) set.run(shape, read, r.rowid)
+        }
+        db.query("insert or replace into meta (key, value) values ('shape', ?)").run(RULES_VERSION)
+    })()
+}
+
+/** one transcript file on disk */
+export type TranscriptFile = { path: string; account: string; project: string; session: string; agent: string; size: number; mtime: number }
+
+/** what the index remembers of a file */
+export type IndexedFile = { size: number; mtime: number; offset: number; version: number }
+
+export type Freshness = 'skip' | 'append' | 'rebuild'
+
+/** what a file needs: nothing, its new tail, or a full read. A transcript only
+ *  grows, so a larger file with the same start is read from where the last
+ *  read stopped; anything else is read again from the top */
+export function freshness(prev: IndexedFile | null, now: { size: number; mtime: number }, version = INDEX_VERSION): Freshness {
+    if (prev == null || prev.version !== version) return 'rebuild'
+    if (now.size === prev.size && now.mtime === prev.mtime) return 'skip'
+    if (now.size > prev.size && prev.offset <= now.size) return 'append'
+    return 'rebuild'
+}
+
+/** the projects of the repos asked for: the repo's slug and its worktrees */
+export type ProjectFilter = (project: string) => boolean
+
+/** every transcript file under every config root: sessions, and the sub-agent
+ *  runs under `<session>/subagents/` */
+export function listTranscripts(roots: ConfigRoot[] = discoverConfigRoots(), keep: ProjectFilter = () => true): TranscriptFile[] {
+    const out: TranscriptFile[] = []
+    const add = (path: string, account: string, project: string, session: string, agent: string): void => {
+        try {
+            const st = statSync(path)
+            out.push({ path, account, project, session, agent, size: st.size, mtime: Math.floor(st.mtimeMs) })
+        } catch { /* deleted between the listing and the stat */ }
+    }
+    for (const root of roots) {
+        let projects: string[]
+        try { projects = readdirSync(root.projects) } catch { continue }
+        for (const project of projects) {
+            if (!keep(project)) continue
+            const dir = join(root.projects, project)
+            let entries: string[]
+            try { entries = readdirSync(dir) } catch { continue }
+            const sessions = new Set(entries.filter((e) => e.endsWith('.jsonl')).map((e) => e.slice(0, -6)))
+            for (const s of sessions) add(join(dir, `${s}.jsonl`), root.account, project, s, '')
+            for (const e of entries) {
+                if (e.endsWith('.jsonl') || e.includes('.')) continue
+                const sub = join(dir, e, 'subagents')
+                let agents: string[]
+                try { agents = readdirSync(sub) } catch { continue }
+                for (const a of agents) if (a.endsWith('.jsonl')) add(join(sub, a), root.account, project, e, a.slice(0, -6))
+            }
+        }
+    }
+    return out
+}
+
+const CHUNK_BYTES = 32 * 1024 * 1024
+
+/** every complete line of a file from `offset`, read in chunks so a session
+ *  of half a gigabyte never becomes one string. Returns the offset after the
+ *  last newline, so a half written tail line is read next time */
+function eachLine(path: string, offset: number, size: number, onLine: (line: string) => void): number {
+    const fd = openSync(path, 'r')
+    let pos = offset
+    let carry: Buffer | null = null
+    try {
+        while (pos < size) {
+            const want = Math.min(CHUNK_BYTES, size - pos)
+            const fresh = Buffer.allocUnsafe(want)
+            const n = readSync(fd, fresh, 0, want, pos)
+            if (n <= 0) break
+            pos += n
+            const buf: Buffer = carry == null ? fresh.subarray(0, n) : Buffer.concat([carry, fresh.subarray(0, n)])
+            let start = 0
+            for (;;) {
+                const end = buf.indexOf(10, start)
+                if (end === -1) break
+                if (end > start) onLine(buf.toString('utf8', start, end))
+                start = end + 1
+            }
+            carry = start < buf.length ? Buffer.from(buf.subarray(start)) : null
+        }
+    } finally {
+        closeSync(fd)
+    }
+    return pos - (carry?.length ?? 0)
+}
+
+type Stmts = ReturnType<typeof statements>
+const statements = (db: Database) => ({
+    get: db.query('select id, size, mtime, offset, version from files where path = ?'),
+    insFile: db.query('insert into files (path, account, project, session, agent, size, mtime, offset, version, first_at, last_at) values (?, ?, ?, ?, ?, 0, 0, 0, 0, null, null) returning id'),
+    setFile: db.query('update files set size = ?, mtime = ?, offset = ?, version = ?, first_at = coalesce(first_at, ?), last_at = coalesce(?, last_at), gone = 0 where id = ?'),
+    clear: [db.query('delete from calls where file_id = ?'), db.query('delete from marks where file_id = ?'), db.query('delete from prompts where file_id = ?')],
+    resetFile: db.query('update files set offset = 0, first_at = null, last_at = null where id = ?'),
+    insCall: db.query('insert or ignore into calls (file_id, id, start, end, tool, shape, cmd, outcome, code, approval, perm, read) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'),
+    endCall: db.query('update calls set end = ?, outcome = ?, code = ?, approval = ?, perm = ? where id = ? and end is null'),
+    insMark: db.query('insert into marks (file_id, at, kind) values (?, ?, ?)'),
+    insPrompt: db.query('insert into prompts (file_id, at, uuid, origin, text) values (?, ?, ?, ?, ?)'),
+})
+
+/** write the events of a chunk of lines: a call is written once its result
+ *  is in this chunk or the chunk ends, and only once on the machine (a copy of
+ *  the session in another account is ignored); a result for a call written by
+ *  an earlier read, or by the copy, closes that row */
+function writeEvents(st: Stmts, fileId: number, events: TranscriptEvent[]): { first: number | null; last: number | null } {
+    const pending = new Map<string, { id: string; start: number; end: number | null; tool: string; detail: string; outcome: string | null; code: number | null; perm: string }>()
+    let first: number | null = null
+    let last: number | null = null
+    const seen = (at: number): void => {
+        if (Number.isNaN(at)) return
+        if (first == null || at < first) first = at
+        if (last == null || at > last) last = at
+    }
+    for (const e of events) {
+        seen(e.at)
+        if (e.kind === 'use') pending.set(e.id, { id: e.id, start: e.at, end: null, tool: e.name, detail: e.detail, outcome: null, code: null, perm: '' })
+        else if (e.kind === 'result') {
+            const p = pending.get(e.id)
+            if (p != null) Object.assign(p, { end: e.at, outcome: e.outcome, code: e.code, perm: e.perm })
+            else st.endCall.run(e.at, e.outcome, e.code, e.perm === 'user' ? 1 : 0, e.perm, e.id)
+        } else if (e.kind === 'prompt') {
+            if (!Number.isNaN(e.at)) st.insPrompt.run(fileId, e.at, e.uuid, e.origin, e.text)
+            if (e.origin === 'typed' && !Number.isNaN(e.at)) st.insMark.run(fileId, e.at, 'prompt')
+        } else st.insMark.run(fileId, e.at, e.kind)
+    }
+    for (const p of pending.values()) {
+        const shape = toolShape(p.tool, p.detail)
+        st.insCall.run(fileId, p.id, p.start, p.end, p.tool, shape, p.detail, p.outcome, p.code, p.perm === 'user' ? 1 : 0, p.perm, isReadOnly({ tool: p.tool, shape, cmd: p.detail }) ? 1 : 0)
+    }
+    return { first, last }
+}
+
+export type IndexProgress = { files: number; done: number; bytes: number; doneBytes: number }
+
+export type IndexResult = { scanned: number; read: number; bytes: number; ms: number; gone: number }
+
+/** bring the index up to date for the files listed: unchanged files cost a
+ *  stat, a grown one its new lines. `onProgress` fires after each file read */
+export function indexTranscripts(db: Database, files: TranscriptFile[], onProgress?: (p: IndexProgress) => void): IndexResult {
+    const t0 = performance.now()
+    const st = statements(db)
+    const prevOf = (path: string) => st.get.get(path) as ({ id: number } & IndexedFile) | null
+    const toRead = new Map<string, number>()
+    for (const f of files) {
+        const prev = prevOf(f.path)
+        const how = freshness(prev, f)
+        if (how !== 'skip') toRead.set(f.path, how === 'append' && prev != null ? f.size - prev.offset : f.size)
+    }
+    const todo = files.filter((f) => toRead.has(f.path))
+    const total = todo.reduce((a, f) => a + (toRead.get(f.path) ?? 0), 0)
+    let doneBytes = 0
+    let readBytes = 0
+    todo.forEach((f, i) => {
+        db.exec('begin immediate')
+        try {
+            let row = prevOf(f.path)
+            const how = freshness(row, f)
+            if (how !== 'skip') {
+                if (row == null) {
+                    const ins = st.insFile.get(f.path, f.account, f.project, f.session, f.agent) as { id: number }
+                    row = { id: ins.id, size: 0, mtime: 0, offset: 0, version: 0 }
+                }
+                let from = row.offset
+                if (how === 'rebuild') {
+                    for (const q of st.clear) q.run(row.id)
+                    st.resetFile.run(row.id)
+                    from = 0
+                }
+                const events: TranscriptEvent[] = []
+                const next = eachLine(f.path, from, f.size, (line) => {
+                    for (const e of readTranscriptLine(line)) events.push(e)
+                })
+                readBytes += next - from
+                const span = writeEvents(st, row.id, events)
+                st.setFile.run(f.size, f.mtime, next, INDEX_VERSION, span.first, span.last, row.id)
+            }
+            db.exec('commit')
+        } catch (e) {
+            db.exec('rollback')
+            throw e
+        }
+        doneBytes += toRead.get(f.path) ?? 0
+        onProgress?.({ files: todo.length, done: i + 1, bytes: total, doneBytes })
+    })
+    return { scanned: files.length, read: todo.length, bytes: readBytes, ms: Math.round(performance.now() - t0), gone: 0 }
+}
+
+/** the files the index holds that are no longer on disk, marked so the
+ *  report can say how much history outlived the harness */
+export function markGone(db: Database, onDisk: TranscriptFile[], keep: ProjectFilter): number {
+    const present = new Set(onDisk.map((f) => f.path))
+    const rows = db.query('select id, path, project, gone from files').all() as { id: number; path: string; project: string; gone: number }[]
+    let gone = 0
+    const set = db.query('update files set gone = ? where id = ?')
+    db.transaction(() => {
+        for (const r of rows) {
+            if (!keep(r.project)) continue
+            const isGone = present.has(r.path) ? 0 : 1
+            if (isGone !== r.gone) set.run(isGone, r.id)
+            gone += isGone
+        }
+    })()
+    return gone
+}
+
+export type FileRow = { id: number; path: string; account: string; project: string; session: string; agent: string; first_at: number | null; last_at: number | null; gone: number }
+
+export type Loaded = { files: FileRow[]; calls: Map<number, Call[]>; marks: Map<number, Mark[]>; prompts: { file_id: number; at: number; origin: 'typed' | 'queued'; text: string }[] }
+
+/** every row of the matching projects with activity in [from, to] */
+export function loadWindow(db: Database, keep: ProjectFilter, from: number, to: number): Loaded {
+    const all = db.query('select id, path, account, project, session, agent, first_at, last_at, gone from files').all() as FileRow[]
+    const files = all.filter((f) => keep(f.project) && f.last_at != null && f.last_at >= from && (f.first_at ?? 0) <= to)
+    const ids = files.map((f) => f.id)
+    const calls = new Map<number, Call[]>()
+    const marks = new Map<number, Mark[]>()
+    const prompts: Loaded['prompts'] = []
+    const CHUNK = 500
+    for (let i = 0; i < ids.length; i += CHUNK) {
+        const part = ids.slice(i, i + CHUNK)
+        const inList = part.map(() => '?').join(',')
+        for (const c of db.query(`select file_id, id, start, end, tool, shape, cmd, outcome, code, approval = 1 as approval, perm, read = 1 as read from calls where file_id in (${inList}) and start between ? and ?`).all(...part, from, to) as (Call & { file_id: number })[]) {
+            const list = calls.get(c.file_id) ?? []
+            list.push(c)
+            calls.set(c.file_id, list)
+        }
+        for (const m of db.query(`select file_id, at, kind from marks where file_id in (${inList}) and at between ? and ?`).all(...part, from, to) as (Mark & { file_id: number })[]) {
+            const list = marks.get(m.file_id) ?? []
+            list.push(m)
+            marks.set(m.file_id, list)
+        }
+        prompts.push(...(db.query(`select file_id, at, origin, text from prompts where file_id in (${inList}) and at between ? and ?`).all(...part, from, to) as Loaded['prompts']))
+    }
+    return { files, calls, marks, prompts }
+}
+
+/** the repo a project dir belongs to: its slug without the worktree suffix,
+ *  named by what follows the home dev folder when it sits there */
+export function repoOfProject(project: string, home = homedir()): string {
+    const bare = project.replace(/--claude-worktrees-.*$/, '')
+    const devSlug = join(home, 'dev').replace(/[^a-zA-Z0-9]/g, '-')
+    return bare.startsWith(`${devSlug}-`) ? bare.slice(devSlug.length + 1) : bare
+}
+
+export const fileLabel = (path: string): string => basename(path).replace(/\.jsonl$/, '')
+