rvlib-shipkit 1.1.1 → 1.3.0

package/src/ledger/gate-checks.ts

@@ -19,9 +19,9 @@ import { discoverLegacyChecks } from '../core/discover-legacy-checks.ts'
 import { checkFileRunBy } from '../core/legacy-shapes.ts'
 import { ruleCacheExtra } from '../rules/rule.ts'
 import { discoverChecks } from '../core/discover-checks.ts'
-import { checkCacheExtra, describeFirst, type TaskDef, type CheckFrom } from '../check.ts'
+import { checkCacheExtra, describeFirst, type TaskDef, type CheckFrom, type CheckEnv } from '../check.ts'
 import { CHECK_TIMEOUT_MS, type RunnableCheck, type CheckBody } from '../core/check-runner.ts'
-import { parseDuration } from '../core/wire.ts'
+import { ttlMsOf } from '../core/wire.ts'
 import { budgetOf } from '../core/budget.ts'
 import { whenOfLegacyCheck, whenOfDisabledSlot, whenOfRule, whenOfTask, whenOfCheck, type WhenDecl } from '../core/when.ts'
 import type { CheckDecl } from './git-key.ts'
@@ -31,6 +31,7 @@ import type { RvtConfig } from '../ts/config.ts'
 import { LIB_ROOT } from '../core/lib-root.ts'
 import type { DiscoveredCheck } from '../core/discover-checks.ts'
 import { declaredTestUnits, inputsOutsideUnits, isTestFile } from '../suite/test-units.ts'
+import type { PlanDecl } from '../plan/cadence.ts'
 
 /** why an undeclared `run` check cannot be keyed on its reads, or null when it
  *  can. A built-in is walked inside the toolkit, a repo check inside the repo
@@ -73,6 +74,18 @@ export async function allTasks(c: RepoConfig, root: string): Promise<FloorResolu
 /** one gate check with everything a reader asks about it, not only what the
  *  key layer asks. The cache half stays in `decl` so `CheckDecl` never grows
  *  fields the key layer must then decide to ignore. */
+/** a check's `planOff`, read now; one that throws stays planned, and says so */
+function planOffOf(id: string, fn: ((env: CheckEnv) => string | null) | undefined, env: CheckEnv): { planOff?: string } {
+    if (fn == null) return {}
+    try {
+        const why = fn(env)
+        return why == null ? {} : { planOff: why }
+    } catch (e) {
+        console.error(`WARN ${id} planOff threw, so it stays planned: ${(e as Error).message}`)
+        return {}
+    }
+}
+
 export type CheckRow = {
     decl: CheckDecl
     /** the display name an operator reads (its title, else the id) */
@@ -118,6 +131,11 @@ export type CheckRow = {
     when: WhenDecl
     /** what it waits on, null when it waits on nothing */
     deps: string[] | null
+    /** when the planner runs it on its own (check.ts `every`, `cron`,
+     *  `whenInactive`). Absent: nothing declared, the planner's defaults */
+    plan?: PlanDecl
+    /** why the plan leaves this check out in this repo (check.ts `planOff`) */
+    planOff?: string
     /** whose check it is: `shipkit` = it ships with the toolkit (a built-in
      *  SK check, the contracts pass, a floor slot nothing in the repo filled),
      *  `repo` = this repo declared it (a package.json script behind a floor
@@ -150,7 +168,6 @@ function taskBody(t: TaskDef): CheckBody {
     }
 }
 
-const ttlMsOf = (ttl: string | undefined): number => (ttl == null || ttl === '' ? 0 : parseDuration(ttl))
 
 /** the runnable half of a row: everything the runner needs, and nothing it
  *  has to look up again */
@@ -340,6 +357,8 @@ export async function composeChecks(root: string, c: RepoConfig, o: ComposeOpts
             when: w,
             deps: u.def.deps ?? null,
             from: u.from,
+            ...(u.def.every !== undefined || u.def.cron != null || u.def.whenInactive != null ? { plan: { every: u.def.every, cron: u.def.cron, whenInactive: u.def.whenInactive } } : {}),
+            ...planOffOf(u.id, u.def.planOff, env),
         }
         const body: CheckBody = {
             ...(u.def.cmd == null ? {} : { cmd: u.def.cmd }),

package/src/ledger/git-scan.ts

@@ -145,13 +145,8 @@ export function indexPaths(root: string): { scratch: string; ignored: string; re
     // sharing one file across concurrent runners buys no warmth and only adds
     // lock contention
     const scratch = join(dir, `scan-${process.pid}.idx`)
-    // a run that was killed leaves its file behind, and pids are reused, so
-    // sweep anything an hour old rather than trusting the pid to be free
-    try {
-        const cutoff = Date.now() - 3_600_000
-        for (const f of readdirSync(dir))
-            if (/^scan-\d+\.idx(\.tmp)?$/.test(f) && statSync(join(dir, f)).mtimeMs < cutoff) rmSync(join(dir, f), { force: true })
-    } catch {}
+    sweepScanIndexes(dir, Date.now())
+    dropAtExit(scratch)
     // tmp + rename: a half-copied index is a corrupt index, and git's error
     // for that is not the one the retry loop is meant to absorb.
     //
@@ -180,6 +175,35 @@ export function indexPaths(root: string): { scratch: string; ignored: string; re
     return { scratch, ignored, real }
 }
 
+/** a scratch index is this process's own: it goes when the process exits */
+const dropping = new Set<string>()
+function dropAtExit(p: string): void {
+    if (dropping.size === 0) process.on('exit', () => { for (const f of dropping) { try { rmSync(f, { force: true }) } catch { /* gone either way */ } } })
+    dropping.add(p)
+}
+
+/** a scratch index older than this is swept whatever its pid: pids are reused */
+export const SCAN_INDEX_KEEP_MS = 60 * 60 * 1000
+
+/** the scratch indexes of processes that are gone (killed ones leave theirs),
+ *  and any past the keep window */
+export function sweepScanIndexes(dir: string, now: number): void {
+    try {
+        for (const f of readdirSync(dir)) {
+            const m = /^scan-(\d+)\.idx(\.tmp)?$/.exec(f)
+            if (m == null || Number(m[1]) === process.pid) continue
+            const p = join(dir, f)
+            try {
+                if (statSync(p).mtimeMs < now - SCAN_INDEX_KEEP_MS || !pidAlive(Number(m[1]))) rmSync(p, { force: true })
+            } catch { /* raced: gone either way */ }
+        }
+    } catch { /* no dir: nothing to sweep */ }
+}
+
+const pidAlive = (pid: number): boolean => {
+    try { process.kill(pid, 0); return true } catch (e) { return (e as { code?: string }).code === 'EPERM' }
+}
+
 /** the whole work tree as one input. A rule that walks the repo (SK001's test
  *  file probe, SK010's `git ls-files`) genuinely reads all of it, and saying so
  *  is more honest than naming three of the files it happens to open. Its object

package/src/ledger/house-runs.ts

@@ -0,0 +1,43 @@
+// THE HOUSE'S RUNS: what the dock at the bottom of the page draws, every
+// house repo's recent runs side by side on one clock. Each repo is shaped the
+// way its own live view is (live-timeline.ts), so a run looks the same
+// wherever it is drawn, and a repo that ran nothing in the window has no group.
+//
+// Pure, on a clock the caller passes. The reads are the caller's
+// (serve/house-runs.ts), which opens a record only when its files moved.
+import type { LiveRow } from './live-runs.ts'
+import type { InvocationRow, RunRow } from './run-log.ts'
+import type { TimelineInvocation } from './run-timeline.ts'
+import { LIVE_HISTORY_MS, shapeLive, type RunSummary } from './live-timeline.ts'
+
+/** one repo's record, as read for the window */
+export type HouseRecord = { repo: string; live: LiveRow[]; runs: RunRow[]; invocations: InvocationRow[] }
+
+/** one repo that ran something in the window: its runs, newest first, and
+ *  what it has in flight */
+export type HouseGroup = { repo: string; invocations: TimelineInvocation[]; busy: number; runs: RunSummary[] }
+
+export type HouseView = {
+    now: number
+    historyMs: number
+    /** the runner's cap, drawn over the concurrency band */
+    cap: number
+    /** checks in flight across every repo */
+    busy: number
+    /** by repo name, so a group keeps its place from one answer to the next */
+    groups: HouseGroup[]
+    /** what holds the machine's plan back, when the host has one (Planner.held) */
+    held?: string[]
+}
+
+export function shapeHouse(o: { now: number; cap: number; repos: HouseRecord[]; alive?: (pid: number) => boolean; historyMs?: number }): HouseView {
+    const historyMs = o.historyMs ?? LIVE_HISTORY_MS
+    const groups = o.repos
+        .map((r): HouseGroup => {
+            const v = shapeLive({ now: o.now, cap: o.cap, live: r.live, runs: r.runs, invocations: r.invocations, alive: o.alive, historyMs })
+            return { repo: r.repo, invocations: v.invocations, busy: v.busy, runs: v.runs }
+        })
+        .filter((g) => g.invocations.length > 0)
+        .sort((a, b) => a.repo.localeCompare(b.repo))
+    return { now: o.now, historyMs, cap: o.cap, busy: groups.reduce((a, g) => a + g.busy, 0), groups }
+}

package/src/ledger/ledger.ts

@@ -2,7 +2,7 @@
 // stored under the identity of the question it answered, replayed only when
 // that identity is bit-for-bit the same question again.
 //
-// ledger/git-key.ts owns the identity, ledger/store.ts owns the file. This
+// ledger/git-key.ts owns the identity, ledger/store.ts owns the table. This
 // module owns the POLICY, and the policy is where a cache turns into a false
 // green, so every rule below exists because a specific failure was reproduced
 // during the design pass:
@@ -38,11 +38,12 @@
 //     on disk. The same set is re-checked at commit, so an edit landing
 //     between the read and the store throws the answer away (rule 2). A body
 //     that reached the world (exec, fetch, tool) stores nothing.
-import { dirname, join } from 'path'
+import { join } from 'path'
 import type { RvtConfig } from '../ts/config.ts'
 import type { Line } from '../core/wire.ts'
 import { KeyLayer, type CheckDecl, type CheckKey } from './git-key.ts'
-import { entryPath, FRESH_ENV, KEEP_MS, readStored, storeRoot, sweepStore, writeStored } from './store.ts'
+import { shipkitRoot } from './db.ts'
+import { Answers, answersDb, FRESH_ENV, type AnswerRef, type AnswerWrite } from './store.ts'
 import type { Problem } from '../problems/problem-line.ts'
 import { cachedStamp, outcomeCounts } from '../core/outcome-words.ts'
 import { readSetDrift, type ReadSet } from '../core/read-set.ts'
@@ -119,6 +120,8 @@ export function ledgerReadEnabled(): boolean {
 
 export class Ledger {
     private readonly buffered = new Map<string, Stored>()
+    /** answers replayed this run, stamped as used in the commit's one write */
+    private readonly replayed: AnswerRef[] = []
     private viewMemo: RepoView | null = null
     private readonly keys = new Map<string, CheckKey>()
     private hits = 0
@@ -128,7 +131,10 @@ export class Ledger {
 
     private constructor(
         readonly layer: KeyLayer,
-        private readonly store: string,
+        /** the repo's answers, one handle for the run, closed by commit() */
+        private readonly answers: Answers,
+        /** the attach slots dir (core/attach.ts) */
+        private readonly inflight: string,
         /** replays are allowed */
         readonly reading: boolean,
         private readonly now: () => number,
@@ -138,7 +144,7 @@ export class Ledger {
         const layer = KeyLayer.open(root, decls, { cliEntry: o.cliEntry, cfg: o.cfg, scope: o.scope })
         const fresh = o.fresh === true || process.env[FRESH_ENV] != null
         const reading = (o.read ?? ledgerReadEnabled()) && !fresh
-        return new Ledger(layer, storeRoot(root), reading, o.now ?? Date.now)
+        return new Ledger(layer, new Answers(answersDb(root)), join(shipkitRoot(root), 'inflight'), reading, o.now ?? Date.now)
     }
 
     /** the key for a check, computed once per run and remembered: `keyFor`
@@ -150,8 +156,8 @@ export class Ledger {
         return k
     }
 
-    private path(k: CheckKey): string {
-        return entryPath(this.store, NS, k.id, k.key!)
+    private read(k: CheckKey): { payload: Stored } | null {
+        return this.answers.read<Stored>(NS, k.id, k.key!)
     }
 
     /** the file list this run lists and validates against, taken once */
@@ -166,10 +172,11 @@ export class Ledger {
         const k = this.key(id)
         if (k.key == null) { this.unkeyed++; return null }
         if (!this.reading) { this.misses++; return null }
-        const e = readStored<Stored>(this.path(k), k.key)
+        const e = this.read(k)
         if (e == null || !Array.isArray(e.payload.lines)) { this.misses++; return null }
         if (k.population === 'reads' && (e.payload.reads == null || this.driftOf(e.payload.reads, () => this.view()) != null)) { this.misses++; return null }
         this.hits++
+        this.replayed.push({ ns: NS, name: k.id, key: k.key })
         return e.payload
     }
 
@@ -177,7 +184,7 @@ export class Ledger {
     storedReads(id: string): ReadSet | null {
         const k = this.key(id)
         if (k.key == null || k.population !== 'reads') return null
-        return readStored<Stored>(this.path(k), k.key)?.payload.reads ?? null
+        return this.read(k)?.payload.reads ?? null
     }
 
     /** the view is asked for only when a glob needs it: a read set with no
@@ -200,7 +207,7 @@ export class Ledger {
         // a READS key names the question and not the tree, so two runs over
         // different trees share it: only one over this tree may answer
         if (k.population === 'reads') return null
-        return k.key == null ? null : entryPath(join(dirname(this.store), 'inflight'), NS, k.id, k.key).replace(/\.json$/, '')
+        return k.key == null ? null : inflightSlot(this.inflight, NS, k.id, k.key)
     }
 
     /** a check that missed the store and then adopted another run's in
@@ -227,13 +234,21 @@ export class Ledger {
     /** re-hash, then write what still describes the tree on disk. */
     commit(): CommitReport {
         const empty: CommitReport = { stored: [], discarded: [], drifted: [], error: null, ms: 0 }
-        if (this.buffered.size === 0) return empty
+        if (this.buffered.size === 0) {
+            this.answers.write([], { touched: this.replayed.splice(0), now: this.now() })
+            this.answers.close()
+            return empty
+        }
         const started = performance.now()
         const d = this.layer.rescan()
-        if (d.error != null) return { ...empty, discarded: [...this.buffered.keys()].sort(), error: d.error, ms: performance.now() - started }
+        if (d.error != null) {
+            this.answers.close()
+            return { ...empty, discarded: [...this.buffered.keys()].sort(), error: d.error, ms: performance.now() - started }
+        }
         const touched = this.layer.unitsTouchedBy(d.drifted)
         const stored: string[] = []
         const discarded: string[] = []
+        const rows: AnswerWrite[] = []
         const drifted = [...d.drifted]
         // a fresh list, never this run's: the question is whether the tree
         // still is what the body read
@@ -246,10 +261,14 @@ export class Ledger {
                 if (moved != null) { discarded.push(id); drifted.push(moved); continue }
             }
             const k = this.key(id)
-            writeStored(this.path(k), k.key!, outcome, this.now())
+            rows.push({ ns: NS, name: k.id, key: k.key!, payload: outcome, at: this.now() })
             stored.push(id)
         }
-        sweepStore(this.store, NS, this.now(), KEEP_MS)
+        // one transaction for every answer and every replay stamp. A write
+        // that fails stores nothing, which costs the next run a measurement
+        if (!this.answers.write(rows, { touched: this.replayed.splice(0), now: this.now() })) stored.length = 0
+        this.answers.sweep(this.now())
+        this.answers.close()
         return { stored: stored.sort(), discarded: discarded.sort(), drifted, error: null, ms: performance.now() - started }
     }
 
@@ -276,6 +295,13 @@ export class Ledger {
     }
 }
 
+/** where askers of one question meet while one of them measures it: a file
+ *  name per (ns, id, key), hashed so any id is a safe name */
+export function inflightSlot(dir: string, ns: string, id: string, key: string): string {
+    const h = new Bun.CryptoHasher('sha256').update(`${ns}\0${id}\0${key}`).digest('hex').slice(0, 12)
+    return join(dir, ns, `${id.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 60)}.${h}`)
+}
+
 /** stamp a cached check's lines. The FIRST line carries the word, because
  *  that is the line an agent reads, and a cached answer that renders
  *  identically to one that ran is the one thing this design refuses to ship. */

package/src/ledger/live-timeline.ts

@@ -1,7 +1,7 @@
-// THE LIVE TIMELINE: what the strip under the hub header draws. The same
+// THE LIVE TIMELINE: one repo's recent runs and its runs in flight. The same
 // shape the runs page reads (ledger/run-timeline.ts), cut to a rolling
-// window that ends now, with the runs still going in it, plus one collapsed
-// lane per OTHER repo that has something in flight.
+// window that ends now, with the runs still going in it. Every house repo's
+// view side by side is the dock at the bottom of the page (house-runs.ts).
 //
 // Pure, on a clock the caller passes, so every rule is pinned on a fake one.
 // A run still in the live table is drawn from there, its running checks
@@ -12,12 +12,9 @@ import { liveRowsOf, type LiveRow, type LiveWait } from './live-runs.ts'
 import type { InvocationRow, RunRow } from './run-log.ts'
 import { invocationsOf, type TimelineBar, type TimelineInvocation } from './run-timeline.ts'
 
-/** how far back the server looks: the unfolded strip's widest window */
+/** how far back the server looks: the widest window a live chart draws */
 export const LIVE_HISTORY_MS = 600_000
 
-/** another repo with something in flight, collapsed to one lane */
-export type RepoLane = { repo: string; label: string; by: string; start: number; running: number; checks: string[] }
-
 /** a run in flight here, for the header's one line */
 export type RunSummary = { runId: string; label: string; by: string; done: number; total: number; reds: number }
 
@@ -31,7 +28,6 @@ export type LiveView = {
     /** every invocation touching the window, newest first, the ones in flight
      *  marked running */
     invocations: TimelineInvocation[]
-    repos: RepoLane[]
     runs: RunSummary[]
     /** of the newest run in flight: checks ready for a slot, and checks
      *  waiting on another one */
@@ -53,15 +49,6 @@ export function invocationOfLive(r: LiveRow, now: number): TimelineInvocation {
     }
 }
 
-/** another repo, collapsed: one lane while it has anything running, from
- *  its earliest running check to now. null when nothing runs there */
-export function repoLane(repo: string, rows: LiveRow[], now: number, alive?: (pid: number) => boolean): RepoLane | null {
-    const going = liveRowsOf(rows, now, alive).filter((r) => r.ended == null && r.running.length > 0)
-    if (going.length === 0) return null
-    const running = going.flatMap((r) => r.running)
-    return { repo, label: going[0]!.label, by: going[0]!.by, start: Math.min(...running.map((c) => c.started)), running: running.length, checks: running.map((c) => c.id) }
-}
-
 export function shapeLive(o: {
     now: number
     cap: number
@@ -69,7 +56,6 @@ export function shapeLive(o: {
     /** the run record's rows that finished inside the window */
     runs: RunRow[]
     invocations: InvocationRow[]
-    others?: { repo: string; rows: LiveRow[] }[]
     alive?: (pid: number) => boolean
     historyMs?: number
 }): LiveView {
@@ -89,7 +75,6 @@ export function shapeLive(o: {
         cap: o.cap,
         busy: inFlight.reduce((a, r) => a + r.running.length, 0),
         invocations,
-        repos: (o.others ?? []).map((x) => repoLane(x.repo, x.rows, o.now, o.alive)).filter((x) => x != null).sort((a, b) => a.repo.localeCompare(b.repo)),
         runs: inFlight.map((r) => ({ runId: r.runId, label: r.label, by: r.by, done: r.done, total: r.total, reds: r.reds })),
         queued: newest?.waiting.filter((w) => w.deps.length === 0).length ?? 0,
         blocked: newest?.waiting.filter((w) => w.deps.length > 0) ?? [],

package/src/ledger/run-log.ts

@@ -23,10 +23,16 @@ import { existsSync } from 'fs'
 import type { Line } from '../core/wire.ts'
 import { BUSY_MS, dbPath, INSERT_RUN, openDb, UPSERT_INVOCATION, UPSERT_LAST, UPSERT_LIVE } from './db.ts'
 import { LIVE_BEAT_MS, liveRowDead, type LiveRow, type LiveState } from './live-runs.ts'
-import { KEEP_MS } from './store.ts'
 
 export type RunStatus = 'pass' | 'warn' | 'fail' | 'skip'
 
+/** how long a row of the record survives */
+export const KEEP_MS = 30 * 24 * 60 * 60 * 1000
+
+/** the most rows each record table keeps, newest first. A busy repo writes
+ *  tens of thousands of run rows a day, so age alone is no cap */
+export const MAX_ROWS = 200_000
+
 /** one check, one run. `ms` is what it MEASURED: a replay measured nothing and
  *  says 0, so the two can never be averaged together by accident. */
 export type RunRow = {
@@ -48,9 +54,7 @@ export const runsPath = dbPath
 
 /** what wrote a run: the command (`ci` answers the gate's question, `check`
  *  the health pass's), who started it (a terminal, the hub's buttons, the
- *  hub's daily timer), and whether it was narrowed to named checks. A
- *  narrowed health pass is not a health pass: the scheduler reads the last
- *  WHOLE one. */
+ *  plan), and whether it was narrowed to named checks. */
 export type InvocationKind = 'ci' | 'check'
 export type InvokedBy = 'cli' | 'hub' | 'schedule'
 export type Invocation = { kind: InvocationKind; label: string; by: InvokedBy; narrowed: boolean }
@@ -228,28 +232,57 @@ const unwritable = (path: string): Line[] => [
 
 /** the age sweep, over every table that grows per run. A live row nobody
  *  writes anymore is a run lost mid way, and it goes here too */
-const sweepAll = (db: Database, now: number, cutoff: number): void => {
+const sweepAll = (db: Database, now: number, cutoff: number, max?: number): void => {
     sweepDeadLive(db, now)
     db.query('delete from runs where at < ?').run(cutoff)
     db.query('delete from invocations where ended < ?').run(cutoff)
     db.query('delete from suites where at < ?').run(cutoff)
     db.query('delete from suite_runs where at < ?').run(cutoff)
+    if (max == null) return
+    for (const [table, col] of RECORD_TABLES) db.query(`delete from ${table} where rowid in (select rowid from ${table} order by ${col} desc limit -1 offset ?)`).run(max)
 }
 
+/** every record table and the column its age is read from */
+const RECORD_TABLES = [['runs', 'at'], ['invocations', 'ended'], ['suites', 'at'], ['suite_runs', 'at']] as const
+
+/** the biggest record table's row count and the oldest row, null when the db
+ *  cannot be read */
+export function recordUse(path: string): { count: number; oldest: number | null } | null {
+    const opened = openDb(path, { create: false })
+    if (opened == null) return null
+    try {
+        let count = 0
+        let oldest: number | null = null
+        for (const [table, col] of RECORD_TABLES) {
+            const r = opened.db.query(`select count(*) as n, min(${col}) as o from ${table}`).get() as { n: number; o: number | null }
+            count = Math.max(count, Number(r.n))
+            if (r.o != null) oldest = oldest == null ? r.o : Math.min(oldest, r.o)
+        }
+        return { count, oldest }
+    } catch {
+        return null
+    } finally {
+        try { opened.db.close() } catch { /* already gone */ }
+    }
+}
+
+type RawInvocation = { runId: string; kind: string; label: string; by: string; narrowed: number; started: number; ended: number }
+
+const INVOCATIONS_SINCE = 'select run_id as runId, kind, label, by, narrowed, started, ended from invocations where ended >= ? order by started asc'
+
+const invocationRow = (r: RawInvocation): InvocationRow => ({
+    runId: String(r.runId), kind: r.kind === 'ci' ? 'ci' : 'check', label: String(r.label),
+    by: r.by === 'hub' || r.by === 'schedule' ? r.by : 'cli', narrowed: Number(r.narrowed) === 1,
+    started: Number(r.started), ended: Number(r.ended),
+})
+
 /** every invocation on record that ended at or after `since`, oldest
  *  first. An unreadable db is none. */
 export function readInvocations(path: string, since = 0): InvocationRow[] {
     const opened = openDb(path, { create: false })
     if (opened == null) return []
     try {
-        const rows = opened.db.query('select run_id as runId, kind, label, by, narrowed, started, ended from invocations where ended >= ? order by started asc').all(since) as {
-            runId: string; kind: string; label: string; by: string; narrowed: number; started: number; ended: number
-        }[]
-        return rows.map((r): InvocationRow => ({
-            runId: String(r.runId), kind: r.kind === 'ci' ? 'ci' : 'check', label: String(r.label),
-            by: r.by === 'hub' || r.by === 'schedule' ? r.by : 'cli', narrowed: Number(r.narrowed) === 1,
-            started: Number(r.started), ended: Number(r.ended),
-        }))
+        return (opened.db.query(INVOCATIONS_SINCE).all(since) as RawInvocation[]).map(invocationRow)
     } catch {
         return []
     } finally {
@@ -309,14 +342,17 @@ export function readLiveReadonly(path: string): LiveRow[] {
 
 /** every check's last outcome in a record, read only, for a hub that shows
  *  ANOTHER repo's gate: `[]` when the record or the table is missing */
-export function readLastStatusReadonly(path: string): { id: string; status: string }[] {
+export function readLastStatusReadonly(path: string): { id: string; status: string; at: number }[]
+/** with `lines`: what each check last printed too, as its raw json */
+export function readLastStatusReadonly(path: string, o: { lines: true }): { id: string; status: string; at: number; lines: string }[]
+export function readLastStatusReadonly(path: string, o: { lines?: boolean } = {}): { id: string; status: string; at: number; lines?: string }[] {
     if (!existsSync(path)) return []
     let db: Database | null = null
     try {
         db = new Database(path, { readonly: true })
         db.exec('pragma busy_timeout = 50')
         if (db.query("select 1 from sqlite_master where type = 'table' and name = 'check_last'").get() == null) return []
-        return db.query('select id, status from check_last').all() as { id: string; status: string }[]
+        return db.query(`select id, status, at${o.lines === true ? ', lines' : ''} from check_last`).all() as { id: string; status: string; at: number; lines?: string }[]
     } catch {
         return []
     } finally {
@@ -324,6 +360,26 @@ export function readLastStatusReadonly(path: string): { id: string; status: stri
     }
 }
 
+/** every check's last result and how many runs in a row ended on that same
+ *  status: what the planner hands a check's `every` lambda. `{}` when the
+ *  record cannot be read, so a plan look never crashes on it */
+export function readLastResults(path: string): Record<string, { status: RunStatus; at: number; streak: number }> {
+    const opened = openDb(path, { create: false })
+    if (opened == null) return {}
+    const out: Record<string, { status: RunStatus; at: number; streak: number }> = {}
+    try {
+        const rows = opened.db.query(`select l.id as id, l.status as status, l.at as at,
+            (select count(*) from runs r where r.id = l.id and r.at > coalesce((select max(r2.at) from runs r2 where r2.id = l.id and r2.status != l.status), 0)) as streak
+            from runs l where l.rowid = (select r3.rowid from runs r3 where r3.id = l.id order by r3.at desc, r3.rowid desc limit 1)`).all() as { id: string; status: string; at: number; streak: number }[]
+        for (const r of rows) out[r.id] = { status: r.status as RunStatus, at: Number(r.at), streak: Math.max(1, Number(r.streak)) }
+    } catch {
+        return {}
+    } finally {
+        try { opened.db.close() } catch { /* already gone */ }
+    }
+    return out
+}
+
 /** the rows that finished at or after `since`, oldest first: the recent
  *  window a live chart draws, without reading a fortnight of history */
 export function readRunsSince(path: string, since: number): RunRow[] {
@@ -339,18 +395,26 @@ export function readRunsSince(path: string, since: number): RunRow[] {
     }
 }
 
-/** when the last WHOLE health pass started, whoever ran it. null = none on
- *  record, which is what makes a fresh hub run one at once. */
-export function lastHealthPassAt(path: string): number | null {
-    const opened = openDb(path, { create: false })
-    if (opened == null) return null
+/** what a live chart of ANOTHER repo draws from its record, strictly read
+ *  only and in one open: its live rows, and the runs and invocations that
+ *  finished at or after `since`. A table the record does not have yet is
+ *  none, and so is a record that cannot be opened */
+export function readWindowReadonly(path: string, since: number): { live: LiveRow[]; runs: RunRow[]; invocations: InvocationRow[] } {
+    const out = { live: [] as LiveRow[], runs: [] as RunRow[], invocations: [] as InvocationRow[] }
+    if (!existsSync(path)) return out
+    let db: Database | null = null
     try {
-        const r = opened.db.query("select max(started) as at from invocations where kind = 'check' and narrowed = 0").get() as { at: number | null } | null
-        return r?.at == null ? null : Number(r.at)
+        db = new Database(path, { readonly: true })
+        db.exec('pragma busy_timeout = 50')
+        const has = (t: string): boolean => db!.query("select 1 from sqlite_master where type = 'table' and name = ?").get(t) != null
+        if (has('live')) out.live = (db.query(LIVE_SELECT).all() as RawLive[]).map(liveRowOf).filter((r) => r != null)
+        if (has('invocations')) out.invocations = (db.query(INVOCATIONS_SINCE).all(since) as RawInvocation[]).map(invocationRow)
+        if (has('runs') && has('invocations')) out.runs = (db.query(`${RUN_ROWS} where r.at >= ? order by r.at asc, r.rowid asc`).all(since) as RawRow[]).map(runRow)
+        return out
     } catch {
-        return null
+        return out
     } finally {
-        try { opened.db.close() } catch { /* already gone */ }
+        try { db?.close() } catch { /* already gone */ }
     }
 }
 
@@ -417,13 +481,13 @@ export function runsStamp(path: string): string {
     }
 }
 
-/** age based housekeeping, the same window the store keeps. A DELETE, so a row
- *  written while it runs is kept: the file rewrite this replaced lost them. */
-export function sweepRuns(path: string, now: number, keepMs = KEEP_MS): void {
+/** the record's cap, enforced: by age, then by count per table. A DELETE, so
+ *  a row written while it runs is kept */
+export function sweepRuns(path: string, now: number, keepMs = KEEP_MS, max = MAX_ROWS): void {
     const opened = openDb(path, { create: false })
     if (opened == null) return
     try {
-        sweepAll(opened.db, now, now - keepMs)
+        sweepAll(opened.db, now, now - keepMs, max)
     } catch {
         // housekeeping never fails a run
     } finally {