rvlib-shipkit 1.3.0 → 1.5.0

package/src/serve/hub-app/tree-svc.ts

@@ -1,17 +1,16 @@
-// The resource tree, as state: which tab, what is expanded, where the
-// keyboard cursor sits. The trie itself is pure (tree-build.ts) and cached
-// here as computeds. Everything hand tuned persists to localStorage as
-// newline separated paths, text encodable and hand editable, and comes back
-// on reopen.
+// The left pane's tree, as state: what is unfolded and where the keyboard
+// cursor sits. The trie itself is pure (tree-build.ts) and cached here as
+// computeds, its top rows the sections repo-sections.tsx draws. The folds
+// persist to localStorage as newline separated keys, text encodable and hand
+// editable, and come back on reopen. A live filter unfolds what matches
+// without touching them, so clearing it restores them.
 import { makeAutoObservable } from 'mobx'
 import type { RepoSt } from './repo-st.ts'
 import type { Resource } from './hub-types.ts'
-import { buildPathTree, buildTypeTree, dirKeys, flattenTree, whenCounts, type TreeNode, type TreeRow } from './tree-build.ts'
-
-export type TreeTab = 'path' | 'type'
+import { repoSections, type RepoSection } from './repo-sections.ts'
+import { buildTree, dirKeys, flattenTree, matchesQuery, passesFilter, processResources, whenCounts, type TreeNode, type TreeRow } from './tree-build.ts'
 
 const EXPANDED_KEY = 'shipkit.tree.expanded'
-const TAB_KEY = 'shipkit.tree.tab'
 
 // every access is guarded: a private window, blocked site data or a stale
 // origin throws on read AND on write, and a tree that cannot remember is
@@ -32,44 +31,68 @@ const writeStore = (k: string, v: string): void => {
 }
 
 export class TreeSvc {
-    tab: TreeTab = 'path'
     expanded = new Set<string>()
     /** the row key under the keyboard cursor */
     cursor: string | null = null
 
     constructor(private st: RepoSt) {
-        this.tab = readStore(TAB_KEY) === 'type' ? 'type' : 'path'
         for (const p of readStore(EXPANDED_KEY).split('\n')) if (p !== '') this.expanded.add(p)
         makeAutoObservable<this, 'st'>(this, { st: false })
     }
 
-    /** the filter and the search apply BEFORE the grouping, so a filtered
-     *  tree prunes to the branches that still hold something */
+    private get q(): string {
+        return this.st.query.trim().toLowerCase()
+    }
+
+    /** what the tree holds, filtered BEFORE the grouping so it prunes to the
+     *  branches that still hold something. A search names a thing to find,
+     *  so it reads every row: the severity group applies only while it is empty */
+    /** every row the tree can show: the hub's resources, then the repo's
+     *  global processes, which pm reports and the hub never lists */
+    private get all(): Resource[] {
+        return [...this.st.cols.resources, ...processResources(this.st.globalProcesses)]
+    }
+
     get visible(): Resource[] {
+        const all = this.all
+        if (this.q !== '') return all.filter((r) => matchesQuery(r, this.q))
         const f = this.st.filter
-        const q = this.st.query.trim().toLowerCase()
-        return this.st.cols.resources.filter((r) => {
-            // the filter reads the COLOUR, so what `red` shows is what reads
-            // red on the tree. An ask is proactive work, so it is in needs
-            // and never in red (collection-types stateOf owns that rule)
-            if (f === 'red' && r.state !== 'red') return false
-            if (f === 'needs' && r.severity == null) return false
-            if (q !== '' && !r.title.toLowerCase().includes(q) && !r.path.toLowerCase().includes(q)) return false
-            return true
-        })
+        return all.filter((r) => passesFilter(r, f))
+    }
+
+    /** rows the severity group keeps out of the tree, said under it so a
+     *  pruned tree never reads as a broken one */
+    get hidden(): number {
+        return this.q !== '' ? 0 : this.all.length - this.visible.length
+    }
+
+    /** the sections the pane draws, with their counts, keys and pages */
+    get sections(): RepoSection[] {
+        return repoSections(this.st)
     }
 
     get nodes(): TreeNode[] {
-        return this.tab === 'type' ? buildTypeTree(this.visible) : buildPathTree(this.visible)
+        const all = buildTree(this.sections.map((s) => s.id), this.visible)
+        // a search hides every section with nothing matching, unless its own
+        // name is what was typed
+        if (this.q === '') return all
+        return all.filter((n) => n.children.length > 0 || n.label.includes(this.q))
+    }
+
+    /** what is unfolded right now: a live search must SHOW its matches, so
+     *  the folds yield while it runs, and they are back once it is cleared */
+    get open(): Set<string> {
+        return this.q === '' ? this.expanded : new Set(dirKeys(this.nodes, false))
+    }
+    isOpen(key: string): boolean {
+        return this.open.has(key)
     }
 
     get rows(): TreeRow[] {
-        // a live search must SHOW its matches: folds yield while it runs
-        if (this.st.query.trim() !== '') return flattenTree(this.nodes, new Set(dirKeys(this.nodes, false)))
-        return flattenTree(this.nodes, this.expanded)
+        return flattenTree(this.nodes, this.open)
     }
 
-    /** the one line above the tree: what runs always and what does not */
+    /** the line at the top of the checks page: what runs always and what does not */
     get whenLine(): string {
         const c = whenCounts(this.st.cols.resources)
         const total = c.always + c.release + c.health + c.off
@@ -83,14 +106,8 @@ export class TreeSvc {
 
     private save(): void {
         writeStore(EXPANDED_KEY, [...this.expanded].join('\n'))
-        writeStore(TAB_KEY, this.tab)
     }
 
-    setTab(t: TreeTab): void {
-        this.tab = t
-        this.cursor = null
-        this.save()
-    }
     toggle(key: string): void {
         this.expanded.has(key) ? this.expanded.delete(key) : this.expanded.add(key)
         this.save()
@@ -111,14 +128,21 @@ export class TreeSvc {
         return this.rowAt(this.cursor)
     }
 
+    /** what a row opens: a section its page, a group with a page that page,
+     *  a leaf its own page. Only a row with nothing to open folds */
+    private activate(row: TreeRow): void {
+        const sec = row.section == null ? null : this.sections.find((s) => s.id === row.section)
+        if (sec != null) sec.go()
+        else if (row.page != null) this.st.go(row.page)
+        else if (row.res != null) this.st.openResource(row.res)
+        else if (row.dir) this.toggle(row.key)
+    }
+
     /** a row click is both a cursor move and the open: one click, one result.
-     *  A folder with a page of its own opens the page, and only its chevron
-     *  folds (fold): the one convention for a row that is both */
+     *  Only the chevron folds a row that opens something (fold) */
     click(row: TreeRow): void {
         this.cursor = row.key
-        if (row.page != null) this.st.go(row.page)
-        else if (row.dir) this.toggle(row.key)
-        else if (row.res != null) this.st.openResource(row.res)
+        this.activate(row)
     }
     /** the chevron: fold or unfold, never open */
     fold(row: TreeRow): void {
@@ -133,17 +157,17 @@ export class TreeSvc {
         const next = i === -1 ? (d > 0 ? 0 : rows.length - 1) : Math.min(rows.length - 1, Math.max(0, i + d))
         this.cursor = rows[next]!.key
     }
-    /** right descends: a collapsed directory opens, anything else steps down */
+    /** right descends: a folded row unfolds, anything else steps down */
     right(): void {
         const r = this.cur
-        if (r != null && r.dir && !this.expanded.has(r.key)) this.toggle(r.key)
+        if (r != null && r.dir && !this.isOpen(r.key)) this.toggle(r.key)
         else this.move(1)
     }
-    /** left ascends: an open directory closes, anything else climbs to its parent */
+    /** left ascends: an unfolded row folds, anything else climbs to its parent */
     left(): void {
         const r = this.cur
         if (r == null) return this.move(-1)
-        if (r.dir && this.expanded.has(r.key)) return this.toggle(r.key)
+        if (r.dir && this.isOpen(r.key)) return this.toggle(r.key)
         const rows = this.rows
         const i = rows.findIndex((x) => x.key === r.key)
         for (let n = i - 1; n >= 0; n--) {
@@ -153,12 +177,9 @@ export class TreeSvc {
             }
         }
     }
-    open(): void {
+    enter(): void {
         const r = this.cur
-        if (r == null) return
-        if (r.page != null) this.st.go(r.page)
-        else if (r.dir) this.toggle(r.key)
-        else if (r.res != null) this.st.openResource(r.res)
+        if (r != null) this.activate(r)
     }
 
     /** true = the key was ours, so the page must not also scroll */
@@ -167,7 +188,7 @@ export class TreeSvc {
         else if (k === 'ArrowUp') this.move(-1)
         else if (k === 'ArrowRight') this.right()
         else if (k === 'ArrowLeft') this.left()
-        else if (k === 'Enter' || k === ' ') this.open()
+        else if (k === 'Enter' || k === ' ') this.enter()
         else return false
         return true
     }

package/src/serve/hub-app/when-view.tsx

@@ -0,0 +1,89 @@
+// A repo's when page: what runs when. The legend first (every context, every
+// value, what it means), then one row per check with its value on each axis,
+// read from the facts every check row already carries (core/runs-matrix.ts),
+// so the page reads nothing of its own and never disagrees with `shipkit when`.
+import { observer } from 'mobx-react-lite'
+import { useState } from 'react'
+import { MATRIX_AXES, RUNS_LEGEND, inColumn, type MatrixAxis } from '../../core/runs-matrix.ts'
+import type { RunsCells } from './hub-types.ts'
+import type { RepoSt } from './repo-st.ts'
+
+type Row = { id: string; title: string; cells: RunsCells; blocking: boolean | null; build: boolean }
+
+const shortOf = (k: MatrixAxis): string => RUNS_LEGEND.find((a) => a.axis === k)!.short
+
+const Legend = () => (
+    <table className="whlegend">
+        <tbody>
+            {RUNS_LEGEND.map((a) => (
+                <tr key={a.axis}>
+                    <td className="whaxis">{a.axis}</td>
+                    <td>
+                        <div>{a.context}</div>
+                        {a.values.map((v) => <div key={v.value} className="whval"><code>{v.value}</code> <span className="dim">{v.means}</span></div>)}
+                    </td>
+                </tr>
+            ))}
+        </tbody>
+    </table>
+)
+
+const Cell = ({ r, k }: { r: Row; k: MatrixAxis }) => {
+    const c = r.cells.cells[k]
+    return (
+        <td className={`whc${c.on ? ' on' : ''}`} title={`${k}: ${c.text} · from ${c.source}${r.cells.derivedWhy != null ? ` (${r.cells.derivedWhy})` : ''}`}>
+            {c.text}
+        </td>
+    )
+}
+
+export const WhenPage = observer(({ app }: { app: RepoSt }) => {
+    const [only, setOnly] = useState<MatrixAxis | null>(null)
+    const all: Row[] = app.cols.resources
+        .filter((r) => r.collection === 'checks' && r.check != null)
+        .map((r) => ({ id: r.check!.checkId, title: r.text, cells: r.check!.runs, blocking: r.check!.blocking, build: r.check!.build }))
+    const live = all.filter((r) => r.cells.off == null)
+    const off = all.filter((r) => r.cells.off != null)
+    const shown = only == null ? live : live.filter((r) => inColumn(r.cells, only))
+    return (
+        <div className="colcard checkcard whpage">
+            <div className="chead">
+                <span className="tid">when</span>
+                <h3 className="ctitle">what runs when</h3>
+            </div>
+            <div className="usays">every check declares every context, with no default. Click a column to see only what that context runs. `shipkit when` prints the same</div>
+            <section className="csec"><div className="cstitle">the legend</div><Legend /></section>
+            <section className="csec">
+                <div className="cstitle">{only == null ? `${live.length} checks` : `${shown.length} of ${live.length} checks run on ${only}`}{only != null ? <> · <a href="#" onClick={(e) => { e.preventDefault(); setOnly(null) }}>show all</a></> : null}</div>
+                <table className="whtable">
+                    <thead>
+                        <tr>
+                            <th>check</th>
+                            {MATRIX_AXES.map((k) => (
+                                <th key={k} className={only === k ? 'on' : ''} title={`${k}: ${RUNS_LEGEND.find((a) => a.axis === k)!.context}. Click: only what it runs (${live.filter((r) => inColumn(r.cells, k)).length})`} onClick={() => setOnly(only === k ? null : k)}>
+                                    {shortOf(k)} <span className="dim">{live.filter((r) => inColumn(r.cells, k)).length}</span>
+                                </th>
+                            ))}
+                            <th>cache</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {shown.map((r) => (
+                            <tr key={r.id}>
+                                <td className="whid"><a href="#" title={r.title} onClick={(e) => { e.preventDefault(); app.timeline.openCheck(r.id) }}>{r.id}</a>{r.build ? <span className="dim"> build</span> : r.blocking === false ? <span className="dim"> warns</span> : null}</td>
+                                {MATRIX_AXES.map((k) => <Cell key={k} r={r} k={k} />)}
+                                <td className="whcache dim" title={r.cells.cache}>{r.cells.cache}</td>
+                            </tr>
+                        ))}
+                    </tbody>
+                </table>
+            </section>
+            {off.length > 0 ? (
+                <section className="csec">
+                    <div className="cstitle">off in this repo ({off.length}): repo.config.ts `off`, or the check does not apply here</div>
+                    {off.map((r) => <div key={r.id} className="whoff"><span className="whid">{r.id}</span> <span className="dim">{r.cells.off}</span></div>)}
+                </section>
+            ) : null}
+        </div>
+    )
+})

package/src/serve/hub-app/when.css

@@ -0,0 +1,17 @@
+/* the when page (when-view.tsx): the legend, then the matrix. A cell that
+   runs is washed with the accent, a cell the repo moved carries a star, and
+   nothing here picks a colour of its own. */
+.whpage{font-size:13px}
+.whlegend{border-collapse:collapse;margin-bottom:var(--s2)}
+.whlegend td{vertical-align:top;padding:var(--s1) var(--s2);border-bottom:1px solid var(--line)}
+.whaxis{font-family:ui-monospace,monospace;color:var(--accent);white-space:nowrap}
+.whval{padding-left:var(--s3)}
+.whtable{border-collapse:collapse;width:100%}
+.whtable th{position:sticky;top:0;background:var(--panel);text-align:left;font-weight:500;padding:var(--s1) var(--s2);cursor:pointer;white-space:nowrap;border-bottom:1px solid var(--line)}
+.whtable th.on{color:var(--accent);border-bottom-color:var(--accent)}
+.whtable td{padding:var(--s0) var(--s2);border-bottom:1px solid var(--line);white-space:nowrap}
+.whc{color:var(--dim);font-family:ui-monospace,monospace}
+.whc.on{color:var(--ink);background:var(--wash2)}
+.whid{font-family:ui-monospace,monospace}
+.whcache{max-width:320px;overflow:hidden;text-overflow:ellipsis}
+.whoff{padding:var(--s0) var(--s2)}

package/src/serve/hub-runtime.ts

@@ -44,7 +44,6 @@ import { RUN_JOB } from '../home/home-words.ts'
 import { OtherRepos } from './other-repos.ts'
 import { HouseRuns } from './house-runs.ts'
 import { recordStamp } from './project-gutter.ts'
-import { RepoProcesses } from './repo-processes.ts'
 import { shapeTimeline } from '../ledger/run-timeline.ts'
 import { readSuiteRuns, readSuites } from '../ledger/suite-log.ts'
 import { shapeTestCheck, shapeTestsRoot } from '../collections/test-time.ts'
@@ -333,7 +332,6 @@ export async function resolveHubDeps(root: string, boot: RepoConfig, io: ServeIo
         root,
         name: c.name,
         uses: c.serve?.uses ?? [],
-        processes: new RepoProcesses(root, c.serve?.processes ?? []),
         port,
         graphs,
         studio,
@@ -443,10 +441,8 @@ export type HubRuntime = {
     ping: () => Promise<void>
     /** a run is in flight: a reload now would kill it */
     busy: () => boolean
-    /** everything this runtime started stops, and it leaves the plan. `procs`
-     *  also stops the repo's declared processes: a real stop of the hub,
-     *  never a process restart */
-    stop: (o?: { procs?: boolean }) => void
+    /** everything this runtime started stops, and it leaves the plan */
+    stop: () => void
 }
 
 export type LoadHubOpts = {
@@ -489,7 +485,6 @@ export async function loadHub(root: string, io: ServeIo, o: LoadHubOpts): Promis
         return ok
     }
     const handler = hubHandler(deps, { base: o.base, projects: o.projects })
-    const procs = deps.processes
     // tick failures are LOUD (the hub's own lines), never swallowed
     const ping = async (): Promise<void> => {
         if (deps.pingTick == null) return
@@ -519,13 +514,6 @@ export async function loadHub(root: string, io: ServeIo, o: LoadHubOpts): Promis
         // the answers a page waits on, computed now, one hub at a time
         // across the process, so a first visit reads them from memory
         warming = warming.then(() => handler.warm())
-        // the repo's own processes: the auto ones start, a restart adopts the
-        // ones still running from their pid records
-        void procs?.startAuto()
-        if (procs != null && procs.size > 0) {
-            const t = setInterval(() => void procs.tick(), 2_000)
-            live.push({ stop: () => clearInterval(t) })
-        }
         if (o.ownTimers) {
             // one tick now (the state file guarantees a restart never re-fires), then every minute
             void ping()
@@ -541,9 +529,8 @@ export async function loadHub(root: string, io: ServeIo, o: LoadHubOpts): Promis
         start,
         ping,
         busy: () => deps.busy?.() === true,
-        stop: (s) => {
+        stop: () => {
             for (const l of live.splice(0)) l.stop()
-            if (s?.procs === true) procs?.stopAll()
             handler.stop()
         },
     }

package/src/serve/project-gutter.ts

@@ -14,11 +14,10 @@ import { DB_FILE } from '../ledger/db.ts'
 import { defaultHubPort } from './hub-port.ts'
 import { LAYOUT } from '../core/layout.ts'
 import { isArchived } from '../core/archived.ts'
+import { CLAUDE_FILES } from '../home/pm-inputs.ts'
 
 export type WiredRepo = { name: string; path: string; icon: string | null }
 
-/** the files a repo carries its includes in */
-const CLAUDE_FILES = ['CLAUDE.md', 'CLAUDE.local.md']
 
 /** the absolute md file of every `@<path>.md` include line a repo's CLAUDE
  *  files carry, in order. A sentence that mentions a path is no include */

package/src/serve/run-serve.ts

@@ -142,7 +142,7 @@ export async function runServe(root: string, io: ServeIo, o?: { port?: number })
             stale.stop()
             clearInterval(planClock)
             plan.stop()
-            rt.stop({ procs: true })
+            rt.stop()
             hub.stop()
             process.exit(0)
         })

package/src/serve/serve-hub.ts

@@ -28,7 +28,6 @@ import type { HubProblems } from './hub-problems.ts'
 import hubIndex from './hub-app/index.html'
 import { homePort, homeUp } from '../home/home-paths.ts'
 import { RUN_EXIT } from '../home/home-words.ts'
-import type { RepoProcesses } from './repo-processes.ts'
 import { projectGutter } from './project-gutter-route.ts'
 import { sameOrigin } from './same-origin.ts'
 import { LAYOUT } from '../core/layout.ts'
@@ -54,8 +53,6 @@ export type HubDeps = {
     name: string
     /** the machine resources the repo declares in serve.uses */
     uses?: string[]
-    /** the long running processes the repo declares in serve.processes */
-    processes?: RepoProcesses
     /** a terminal's `shipkit ci` or `check`, run in this process; resolves to its exit code */
     runCli?: (kind: 'ci' | 'check', opts: Record<string, unknown>, print: (l: string) => void) => Promise<number>
     /** 0 = random (tests); real launches pass repo.config/default */
@@ -235,13 +232,6 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                 })
                 return new Response(stream, { headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' } })
             }
-            if (path === '/api/processes.json') return Response.json({ processes: d.processes?.views() ?? [] })
-            if (path === '/api/processes/act' && req.method === 'POST') {
-                const b = (await req.json().catch(() => ({}))) as { id?: string; act?: string }
-                if (b.act !== 'start' && b.act !== 'stop' && b.act !== 'restart') return new Response('act must be start, stop or restart', { status: 400 })
-                const v = d.processes?.act(b.id ?? '', b.act)
-                return v == null ? new Response(`no process '${b.id ?? ''}' in serve.processes`, { status: 404 }) : Response.json(v)
-            }
             // the three surfaces built on the config read the config on disk
             if (path === '/api/needs.json' || path === '/api/resources.json' || path === '/api/checks.json' || path === '/api/collections.json') await d.refresh?.()
             if (path === '/api/needs.json') {
@@ -249,9 +239,9 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                 return Response.json({ needs })
             }
             if (path === '/api/resources.json') {
-                // ONE flat list for the whole repo: the page groups it by
-                // path and by type, and a second endpoint would be a second
-                // answer to drift from this one
+                // ONE flat list for the whole repo: the page groups it
+                // under its sections, and a second endpoint would be a
+                // second answer to drift from this one
                 const r = await rows.get({ fresh: fresh(req) })
                 return Response.json({
                     collections: r.collections,
@@ -377,7 +367,7 @@ export function hubHandler(d: HubDeps, o: { base?: string; projects?: Gutter } =
                 if (req.method === 'POST') {
                     try {
                         const body = (await req.json()) as GateEdit & { expect?: string }
-                        const b = await writeGateBlock(d.root, { when: body.when, slow: body.slow, slowRemove: body.slowRemove, words: body.words }, { expect: body.expect })
+                        const b = await writeGateBlock(d.root, { off: body.off, slow: body.slow, slowRemove: body.slowRemove, words: body.words }, { expect: body.expect })
                         await d.refresh?.()
                         return Response.json({ ...b, dirty: configDirty(d.root) })
                     } catch (e) {

package/src/serve/warm-cell.ts

@@ -1,12 +1,21 @@
 // one answer of a hub kept warm in memory: computed when the hub loads,
 // recomputed in the background when something says it moved (a save, a
-// stamp, its age), and served from memory. A request never pays for the
-// walk behind it, except the very first one and one that asks for `fresh`.
+// stamp, its age) while a page reads it, and served from memory. A cell
+// nobody read for WARM_WATCH_MS computes nothing on a save: its next reader
+// waits on one compute instead, so an unwatched repo costs no cpu per save.
 //
-// the one constraint a reader breaks first: `get()` answers what is in
-// memory even when it is known stale. Whoever just changed the truth (an
-// act, the end of a run) asks for `fresh`, which waits on a compute that
-// started after its call.
+// the one constraint a reader breaks first: `get()` from a watched cell
+// answers what is in memory even when it is known stale. Whoever just
+// changed the truth (an act, the end of a run) asks for `fresh`, which waits
+// on a compute that started after its call.
+
+/** a cell read within this long has a reader: a save recomputes it in the
+ *  background. Past it, nothing recomputes until a reader asks */
+export const WARM_WATCH_MS = 30_000
+
+/** a background recompute waits this many times the last compute's length
+ *  after it ended: a 1.5s answer at most every 15s, a 50ms one at once */
+export const WARM_SPACING = 10
 
 export type WarmCellOpts = {
     /** a cheap fingerprint of what the answer reads (file stats): a new one
@@ -20,6 +29,10 @@ export type WarmCellOpts = {
 
 export class WarmCell<T> {
     private value: { v: T; at: number; stamp: string } | null = null
+    /** when a reader last asked, null before any */
+    private readAt: number | null = null
+    /** when the last compute ended and how long it took */
+    private last: { end: number; ms: number } | null = null
     private running: Promise<T> | null = null
     /** bumped by invalidate: a compute that started before it is stale */
     private gen = 0
@@ -37,6 +50,7 @@ export class WarmCell<T> {
         const gen = this.gen
         const stamp = this.o.stamp?.() ?? ''
         this.runGen = gen
+        const start = this.now()
         const p = (async (): Promise<T> => {
             try {
                 // never synchronously: `running` is set before this settles
@@ -44,6 +58,8 @@ export class WarmCell<T> {
                 this.value = { v, at: this.now(), stamp }
                 return v
             } finally {
+                const end = this.now()
+                this.last = { end, ms: end - start }
                 this.running = null
                 // what said it moved while this ran is not in this answer
                 if (this.gen !== gen) this.kick()
@@ -53,11 +69,19 @@ export class WarmCell<T> {
         return p
     }
 
-    /** a compute in the background: on a failure the last answer stays */
+    /** a compute in the background, at most once per WARM_SPACING times the
+     *  last one: a kick too soon is dropped, and the next read past the gap
+     *  kicks again. On a failure the last answer stays */
     private kick(): void {
+        if (this.last != null && this.now() < this.last.end + WARM_SPACING * this.last.ms) return
         void this.run().catch(() => {})
     }
 
+    /** a reader asked within WARM_WATCH_MS */
+    private get watched(): boolean {
+        return this.readAt != null && this.now() - this.readAt < WARM_WATCH_MS
+    }
+
     get stale(): boolean {
         const v = this.value
         if (v == null) return true
@@ -68,23 +92,32 @@ export class WarmCell<T> {
     /** the answer in memory, a stale one kicking a recompute behind it. With
      *  nothing in memory yet, or `fresh`, it waits on a compute */
     async get(o: { fresh?: boolean } = {}): Promise<T> {
-        if (o.fresh === true) {
-            // a compute that started before this call may miss what the
-            // caller just changed: wait for it, then for one of our own
-            if (this.running != null) await this.running.catch(() => {})
-            return this.run()
-        }
+        const watched = this.watched
+        this.readAt = this.now()
+        if (o.fresh === true) return this.fresh()
         const v = this.value
         // nothing in memory, a failed compute included: wait on a new one
         if (v == null) return this.run()
-        if (this.running == null && (this.stale || this.gen !== this.runGen)) this.kick()
+        const moved = this.stale || this.gen !== this.runGen
+        // the first reader in a while: what is in memory may be hours old,
+        // and no save recomputed it meanwhile
+        if (moved && !watched) return this.running != null && this.runGen === this.gen ? this.running : this.fresh()
+        if (this.running == null && moved) this.kick()
         return v.v
     }
 
-    /** something this answer reads moved: recompute in the background */
+    /** a compute that started after this call: one that started before may
+     *  miss what the caller just changed, so wait for it, then for our own */
+    private async fresh(): Promise<T> {
+        if (this.running != null) await this.running.catch(() => {})
+        return this.run()
+    }
+
+    /** something this answer reads moved: recompute in the background while
+     *  a reader watches, else leave it to the next reader */
     invalidate(): void {
         this.gen++
-        if (this.running == null) this.kick()
+        if (this.running == null && this.watched) this.kick()
     }
 
     /** compute now unless an answer is already in memory: the hub's load */