rvlib-shipkit 1.1.1 → 1.3.0

package/src/release/unit-resolve.ts

@@ -165,9 +165,7 @@ export function resolveUnits(root: string, config: RepoConfig, io: UnitReader):
             tagTemplate: rc.tag ?? ROOT_TAG,
             changelogRel: rc.changelog ?? 'CHANGELOG.md',
             npm: rc.npm,
-            // the root IS the repo: its package.json private flag is the whole
-            // declaration, and a public root package publishes by default
-            npmWhenUndeclared: 'from-private-flag',
+            undeclaredFix: 'add `release: { npm: true }` to repo.config.ts to publish it',
             githubRelease: rc.githubRelease ?? true,
             tsconfigRel: rc.tsconfig,
             checkFolderName: false,
@@ -204,7 +202,7 @@ export function resolveUnits(root: string, config: RepoConfig, io: UnitReader):
             tagTemplate: decl.tag ?? SUB_TAG,
             changelogRel: decl.changelog ?? `${decl.dir}/CHANGELOG.md`,
             npm: decl.npm,
-            npmWhenUndeclared: 'refuse',
+            undeclaredFix: 'add `npm: true` to this units[] entry to publish it',
             githubRelease: decl.githubRelease ?? false,
             tsconfigRel: decl.tsconfig,
             // only the DEFAULT tag renders the package name into a git tag, so
@@ -226,11 +224,9 @@ function build(p: {
     tagTemplate: string
     changelogRel: string
     npm: boolean | undefined
-    /** how an UNDECLARED npm target resolves. The root IS the repo, so its
-     *  package.json private flag is the whole declaration. A sub-unit has no
-     *  such declaration, so a non-private package with no `npm` key is
-     *  ambiguous and REFUSES. */
-    npmWhenUndeclared: 'from-private-flag' | 'refuse'
+    /** where this unit's npm declaration goes, for the refusal a non-private
+     *  package with no `npm` key gets */
+    undeclaredFix: string
     githubRelease: boolean
     tsconfigRel: string | undefined
     checkFolderName: boolean
@@ -256,10 +252,10 @@ function build(p: {
     // about must refuse, not quietly resolve to no-publish. A silent false
     // here is a lib that bumps, tags and cuts a release while publishing
     // nothing, and the only trace is one note line in a long log.
-    if (p.npm == null && !isPrivate && p.npmWhenUndeclared === 'refuse')
-        errors.push(at('package.json is not private and this units[] entry does not say `npm` — add `npm: true` to publish it, or `private: true` to its package.json to keep it internal'))
+    if (p.npm == null && !isPrivate)
+        errors.push(at(`package.json is not private and no npm target is declared: ${p.undeclaredFix}, or \`private: true\` to its package.json to keep it internal`))
     if (errors.length > 0) return { error: errors }
-    const declaredNpm = p.npm ?? (p.npmWhenUndeclared === 'from-private-flag' && !isPrivate)
+    const declaredNpm = p.npm === true
     const tsconfig = p.tsconfigRel != null ? join(p.root, p.tsconfigRel) : join(p.dir, 'tsconfig.json')
     return {
         unit: {

package/src/repo-config.ts

@@ -59,6 +59,27 @@ export type ServeConfig = {
      *  prints beside localhost and rides on every ping message, because a
      *  phone cannot resolve localhost */
     publicHost?: string
+    /** the long running processes this repo needs (a dev server, a watcher).
+     *  The hub supervises them: a switch each on its page, a crash restarts,
+     *  and they outlive a hub restart */
+    processes?: ProcessDecl[]
+    /** the ids of the global processes this repo needs (any house repo's
+     *  `globalProcess` unit files). The home rail marks the repo while one is off */
+    uses?: string[]
+}
+
+/** one long running process a repo needs, supervised by its hub */
+export type ProcessDecl = {
+    /** kebab-case, unique in this repo */
+    id: string
+    /** the command as a list of words, run from the repo root */
+    cmd: string[]
+    /** where it runs, repo-relative (default the repo root) */
+    cwd?: string
+    /** the url it serves, probed for up and shown as a link */
+    url?: string
+    /** starts with the hub. Default false: it starts from its switch */
+    auto?: boolean
 }
 
 export type RepoConfig = {
@@ -164,8 +185,16 @@ export type RepoConfig = {
      *  lint and prints a skip line carrying the reason. `defineRepo` throws on
      *  an unknown id or a blank reason */
     ruleExempt?: Record<string, string>
-    /** declared github visibility INTENT (absent = 'private') — rule SK007
-     *  fails loud when `gh repo view` disagrees in either direction */
+    /** the repo is done for now: nothing processes it. The house discovery
+     *  leaves it out, so it has no rail row, no hub (no file watch, no plan
+     *  rows, no automatic gates), no processes or widgets, no identity fill,
+     *  no activity row, and fleet skips it. Only the archived page lists it.
+     *  The button in the repo header and the page's unarchive toggle it, and
+     *  only this key moves (core/archived.ts) */
+    archived?: boolean
+    /** declared github visibility INTENT (absent = 'private'): public means
+     *  strangers read the tracked tree. What each check does with it:
+     *  wiki/build/shipkit/built-in-checks.md */
     visibility?: 'private' | 'public'
     /** the reviewer agent type this repo declares: `.claude/agents/<name>.md`,
      *  whose system prompt points at `brief` (an md file holding the standing
@@ -250,13 +279,34 @@ export type RepoConfig = {
     }
     /** the `shipkit serve` hub: port + optional graph hooks */
     serve?: ServeConfig
+    /** the repo's own colours, one #rrggbb hex each: colorLight reads on a
+     *  light background, colorDark on a dark one. Every page that shows the
+     *  repo draws its name and its rail tile in them. Rule SK024 warns when
+     *  they are missing, and its fix derives them from the repo icon */
+    identity?: {
+        /** #rrggbb that reads on a light background */
+        colorLight: string
+        /** #rrggbb that reads on a dark background: the home page draws this one */
+        colorDark: string
+    }
     /** where a gate run writes its per task logs, repo-relative (default
      *  '.shipkit/tmp/shipkit-ci'). Each run owns a subdir of it, so several agents in
      *  one checkout never overwrite each other. Keep it gitignored. */
     logDir?: string
 }
 
-const KNOWN_KEYS = new Set(['name', 'venues', 'social', 'docsBase', 'defaults', 'tasks', 'asks', 'creds', 'credsCommand', 'credsReadCommand', 'notifyCommand', 'contracts', 'gitignore', 'untrackGenerated', 'nested', 'when', 'budgets', 'ruleExempt', 'visibility', 'reviewer', 'oneWayIn', 'rules', 'release', 'units', 'notReleasable', 'hooks', 'checkDefaults', 'tui', 'serve', 'logDir', 'prose', 'smoke', 'tests'])
+const KNOWN_KEYS = new Set(['name', 'venues', 'social', 'docsBase', 'defaults', 'tasks', 'asks', 'creds', 'credsCommand', 'credsReadCommand', 'notifyCommand', 'contracts', 'gitignore', 'untrackGenerated', 'nested', 'when', 'budgets', 'ruleExempt', 'visibility', 'archived', 'reviewer', 'oneWayIn', 'rules', 'release', 'units', 'notReleasable', 'hooks', 'checkDefaults', 'tui', 'serve', 'identity', 'logDir', 'prose', 'smoke', 'tests'])
+
+const KEBAB = /^[a-z0-9][a-z0-9-]*$/
+const words = (v: unknown): boolean => Array.isArray(v) && v.length > 0 && v.every((w) => typeof w === 'string')
+
+/** why a process declaration cannot run, or null */
+export function processProblem(d: ProcessDecl): string | null {
+    if (!KEBAB.test(d.id ?? '')) return `serve.processes: id '${String(d.id)}' must be kebab-case`
+    if (!words(d.cmd)) return `serve.processes['${d.id}'] needs cmd: a list of words`
+    if (d.url != null && !/^https?:\/\//.test(d.url)) return `serve.processes['${d.id}'].url must be an http url`
+    return null
+}
 
 export function defineRepo(c: RepoConfig): RepoConfig {
     if (typeof c.name !== 'string' || c.name === '') throw new Error('defineRepo: name is required')
@@ -266,11 +316,18 @@ export function defineRepo(c: RepoConfig): RepoConfig {
     // a half-declared reviewer would lint a path like `.claude/agents/.md`
     if (c.reviewer != null && (!/^[a-z0-9][a-z0-9-]*$/.test(c.reviewer.name ?? '') || (c.reviewer.brief ?? '') === ''))
         throw new Error(`defineRepo: reviewer needs { name: kebab-case, brief: path to the standing brief }`)
+    const pids = new Set<string>()
+    for (const d of c.serve?.processes ?? []) {
+        const why = processProblem(d)
+        if (why != null) throw new Error(`defineRepo: ${why}`)
+        if (pids.has(d.id)) throw new Error(`defineRepo: serve.processes declares '${d.id}' twice`)
+        pids.add(d.id)
+    }
     // unknown keys die loud — a typo'd or removed key silently changing the
     // gate is exactly the never-silence failure mode (A23)
     for (const k of Object.keys(c))
         if (!KNOWN_KEYS.has(k))
-            throw new Error(`defineRepo: unknown key '${k}'${k === 'checks' ? ` — checks:[] was removed; drop a <name>.check.ts file instead ('shipkit check' auto-discovers it)` : ''}`)
+            throw new Error(`defineRepo: unknown key '${k}'${k === 'checks' ? ` — checks:[] was removed; drop a <name>.check.ts file instead ('shipkit check' auto-discovers it)` : k === 'home' ? ` — home.resources was removed; declare each one in a <name>.shipkit.ts file as \`export default globalProcess({...})\`` : ''}`)
     // a typo'd unit key would silently drop a target and release the wrong shape
     for (const u of c.units ?? []) {
         if (typeof u.dir !== 'string' || u.dir === '') throw new Error(`defineRepo: every units[] entry needs a 'dir'`)

package/src/serve/house-runs.ts

@@ -0,0 +1,53 @@
+// The dock's data on the server: every house repo's record, read for the
+// live window and shaped into one view (ledger/house-runs.ts). One instance
+// serves every page that asks, the home's daemon and a hub serving on its own
+// alike.
+//
+// the one constraint a reader breaks first: this is asked every few seconds
+// while a dock is open, so nothing here may cost a record read when nothing
+// moved. A repo's record is opened only when its db or its write ahead log
+// changed since the last read (the window only slides, and the shaping drops
+// what slid out), and one shaped answer serves every request inside SHARE_MS.
+import { existsSync } from 'fs'
+import { parallelCap } from '../core/parallel.ts'
+import { shapeHouse, type HouseRecord, type HouseView } from '../ledger/house-runs.ts'
+import { LIVE_HISTORY_MS } from '../ledger/live-timeline.ts'
+import { readWindowReadonly } from '../ledger/run-log.ts'
+import { recordOf, recordStamp } from './project-gutter.ts'
+
+/** how long one shaped answer serves every page that asks */
+export const SHARE_MS = 1_000
+
+export type HouseRepo = { name: string; path: string }
+
+export class HouseRuns {
+    private records = new Map<string, { stamp: string; rec: HouseRecord }>()
+    private shaped: { at: number; view: HouseView } | null = null
+    /** records opened since this instance was built: what a test measures */
+    reads = 0
+
+    constructor(private list: () => HouseRepo[], private now: () => number = Date.now, private cap: () => number = parallelCap) {}
+
+    view(): HouseView {
+        const now = this.now()
+        if (this.shaped != null && now - this.shaped.at < SHARE_MS) return this.shaped.view
+        const since = now - LIVE_HISTORY_MS
+        const next = new Map<string, { stamp: string; rec: HouseRecord }>()
+        for (const r of this.list()) {
+            const path = recordOf(r.path)
+            if (path == null || !existsSync(path)) continue
+            const stamp = recordStamp(path)
+            let hit = this.records.get(r.path)
+            if (hit == null || hit.stamp !== stamp) {
+                this.reads++
+                hit = { stamp, rec: { repo: r.name, ...readWindowReadonly(path, since) } }
+            } else if (hit.rec.repo !== r.name) hit = { stamp, rec: { ...hit.rec, repo: r.name } }
+            next.set(r.path, hit)
+        }
+        // a repo gone from the list takes its rows with it
+        this.records = next
+        const view = shapeHouse({ now, cap: this.cap(), repos: [...next.values()].map((x) => x.rec) })
+        this.shaped = { at: now, view }
+        return view
+    }
+}

package/src/serve/hub-app/activity-st.ts

@@ -0,0 +1,168 @@
+// the activity page's state: what every house repo committed in a window and
+// what it holds uncommitted, as the daemon reads it from local git. It asks
+// again every ACTIVITY_POLL_MS, only while the page is shown AND the tab is
+// visible, so a page left in the background costs the daemon nothing. The
+// window and the commit cap are remembered per viewer.
+import { makeAutoObservable, observableRef, runInAction } from 'mobx'
+import { clampCap, DEFAULT_CAP, DEFAULT_MINUTES, idleRow, WINDOW_MINUTES, type ActivityAnswer, type ActivityRow } from '../../home/activity-shape.ts'
+
+// the words the page and `shipkit cross-repo-activity` share live beside the shapes
+export { ageShort, CAP_MAX, CAP_MIN, clampCap, DEFAULT_CAP, dirtWords, filesWords, upstreamWords, windowWords } from '../../home/activity-shape.ts'
+import type { HomeSt } from './home-st.ts'
+
+export const ACTIVITY_POLL_MS = 60_000
+const MINUTES_KEY = 'home:activity:minutes'
+const CAP_KEY = 'home:activity:cap'
+
+/** busy rows in the daemon's (rail) order, then the quiet ones below them */
+export function splitRows(rows: ActivityRow[]): { busy: ActivityRow[]; idle: ActivityRow[] } {
+    return { busy: rows.filter((r) => !idleRow(r)), idle: rows.filter(idleRow) }
+}
+
+function kept(key: string): string | null {
+    try {
+        return globalThis.localStorage?.getItem(key) ?? null
+    } catch {
+        return null
+    }
+}
+function keptMinutes(): number {
+    const n = Number(kept(MINUTES_KEY))
+    return (WINDOW_MINUTES as readonly number[]).includes(n) ? n : DEFAULT_MINUTES
+}
+function keep(key: string, n: number): void {
+    try { globalThis.localStorage?.setItem(key, String(n)) } catch { /* private window: the pick lasts the tab */ }
+}
+
+export class ActivitySt {
+    data: ActivityAnswer | null = null
+    error = ''
+    minutes: number = keptMinutes()
+    /** the most commits a repo shows before a click shows the rest */
+    cap: number = clampCap(kept(CAP_KEY) ?? DEFAULT_CAP)
+    /** repos whose commits all show, past the cap */
+    expanded = new Set<string>()
+    /** repos whose failing and warning checks show under their row */
+    checksOpen = new Set<string>()
+    /** a read is in flight */
+    loading = false
+    /** when the next read goes, epoch ms */
+    nextAt = 0
+    /** the page's clock, one tick a second while shown */
+    now = Date.now()
+    private timer: ReturnType<typeof setInterval> | null = null
+    private gen = 0
+    /** a tab coming back reads only when its countdown is already due */
+    private readonly onVisible = (): void => {
+        if (this.timer != null) this.tick()
+    }
+
+    constructor(private st: HomeSt) {
+        makeAutoObservable<this, 'st' | 'timer' | 'gen' | 'onVisible'>(this, { st: false, timer: false, gen: false, onVisible: false, data: observableRef })
+    }
+
+    get rows() {
+        return splitRows(this.data?.rows ?? [])
+    }
+
+    /** the answer shown is for another window than the one picked: it dims until the new one lands */
+    get stale(): boolean {
+        return this.data != null && this.data.minutes !== this.minutes
+    }
+
+    /** whole seconds to the next read */
+    get countdown(): number {
+        return Math.max(0, Math.ceil((this.nextAt - this.now) / 1000))
+    }
+
+    setMinutes(m: number): void {
+        this.minutes = m
+        keep(MINUTES_KEY, m)
+        void this.poll()
+    }
+
+    /** a typed cap, clamped to CAP_MIN..CAP_MAX */
+    setCap(v: unknown): void {
+        this.cap = clampCap(v)
+        keep(CAP_KEY, this.cap)
+    }
+
+    toggle(name: string): void {
+        if (this.expanded.has(name)) this.expanded.delete(name)
+        else this.expanded.add(name)
+    }
+
+    /** a click on the status dot: its checks show under the row, or hide */
+    toggleChecks(name: string): void {
+        if (this.checksOpen.has(name)) this.checksOpen.delete(name)
+        else this.checksOpen.add(name)
+    }
+
+    openCheck(repo: string, check: string): void {
+        this.st.openCheck(repo, check)
+    }
+
+    /** the repo in Fork, the git client: the daemon opens it by name */
+    async openFork(name: string): Promise<void> {
+        try {
+            const r = await fetch('/api/projects/fork', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name }) })
+            if (!r.ok) throw new Error(await r.text())
+            runInAction(() => { this.error = '' })
+        } catch (e) {
+            runInAction(() => { this.error = `open ${name} in Fork: ${(e as Error).message}` })
+        }
+    }
+
+    openRepo(name: string): void {
+        this.st.select(name)
+    }
+
+    /** the refresh button: a new git pass now, whatever the countdown says */
+    refresh(): void {
+        if (!this.loading) void this.poll(true)
+    }
+
+    /** one read. The daemon shares an answer younger than its ttl between
+     *  readers and never serves an older one; only `fresh` forces a pass */
+    async poll(fresh = false): Promise<void> {
+        const id = ++this.gen
+        runInAction(() => { this.loading = true; this.nextAt = Date.now() + ACTIVITY_POLL_MS })
+        try {
+            const r = await fetch(`/api/home/activity.json?m=${this.minutes}${fresh ? '&fresh=1' : ''}`, { signal: AbortSignal.timeout(30_000) })
+            if (!r.ok) throw new Error(`${r.status} ${await r.text()}`)
+            const j = (await r.json()) as ActivityAnswer
+            runInAction(() => { if (id === this.gen) { this.data = j; this.error = '' } })
+        } catch (e) {
+            runInAction(() => { if (id === this.gen) this.error = (e as Error).message })
+        } finally {
+            // the countdown starts when the answer lands, so reads never overlap
+            runInAction(() => { if (id === this.gen) { this.loading = false; this.nextAt = Date.now() + ACTIVITY_POLL_MS } })
+        }
+    }
+
+    /** one tick a second: the countdown moves, and a due read goes, unless
+     *  the tab is hidden (the daemon reads git only for a viewer) */
+    private tick(): void {
+        this.now = Date.now()
+        if (this.loading || this.now < this.nextAt) return
+        if (typeof document !== 'undefined' && document.visibilityState === 'hidden') return
+        void this.poll()
+    }
+
+    /** reads while the page is shown */
+    start(): void {
+        if (this.timer != null) return
+        void this.poll()
+        this.timer = setInterval(() => this.tick(), 1_000)
+        document.addEventListener('visibilitychange', this.onVisible)
+    }
+
+    stop(): void {
+        if (this.timer == null) return
+        clearInterval(this.timer)
+        this.timer = null
+        this.gen++
+        this.loading = false
+        document.removeEventListener('visibilitychange', this.onVisible)
+    }
+}

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

@@ -0,0 +1,218 @@
+// `/activity`: what every house repo committed in the window and what it holds
+// uncommitted, as ONE table with a row group per repo, so a glance says which
+// agents did what. Each commit carries its own state (↑ orange unpushed, ✓
+// green pushed), uncommitted work is a red line above the commits, the branch
+// is green on main and orange elsewhere. On top: the window, the commit cap
+// (a number, 1 to 15), then when the next read goes. Repos with nothing in the
+// window sit below the busy ones, each with its last commit in grey.
+import { observer } from 'mobx-react-lite'
+import type { ReactNode } from 'react'
+import { idleRow, isMainBranch, WINDOW_MINUTES, type ActivityCommit, type ActivityRow, type StatusCheck } from '../../home/activity-shape.ts'
+import { ageShort, CAP_MAX, CAP_MIN, dirtWords, filesWords, upstreamWords, windowWords } from './activity-st.ts'
+import { Tip } from './floating.tsx'
+import { Icon, ICON } from './icons.tsx'
+import type { HomeSt } from './home-st.ts'
+import { checkAddress, plainClick, repoPage } from './home-st.ts'
+import { stampWords } from './time-ago.tsx'
+
+/** the repo's icon and name; a plain click selects it in place */
+const RepoName = observer(({ app, name }: { app: HomeSt; name: string }) => {
+    const icon = app.projects.list.find((p) => p.name === name)?.icon ?? null
+    return (
+        <a className="acrepo" href={repoPage(name)} onClick={(e) => {
+            if (!plainClick(e)) return
+            e.preventDefault()
+            app.activity.openRepo(name)
+        }}>
+            {icon == null ? null : <img src={icon} alt="" width={14} height={14} draggable={false} />}
+            <span>{name}</span>
+        </a>
+    )
+})
+
+/** a bar of exclusive buttons */
+const Bar = <T extends number>({ label, values, value, words, set }: { label: string; values: readonly T[]; value: number; words: (v: T) => string; set: (v: T) => void }) => (
+    <div className="acwin" role="radiogroup" aria-label={label}>
+        {values.map((v) => (
+            <button key={v} role="radio" aria-checked={value === v} className={value === v ? 'on' : ''} onClick={() => set(v)}>{words(v)}</button>
+        ))}
+    </div>
+)
+
+/** when the next read goes; it spins while one runs */
+const Next = observer(({ app }: { app: HomeSt }) => {
+    const st = app.activity
+    return (
+        <button type="button" className="acnext acpill" disabled={st.loading} onClick={() => st.refresh()}
+            title="read every repo now · the page reads them again every minute while it is shown">
+            <span className={`acring${st.loading ? ' on' : ''}`}>↻</span>
+            {st.loading ? '' : ` ${st.countdown}s`}
+        </button>
+    )
+})
+
+/** one commit's cells; `old` is the last one, from before the window */
+const Commit = ({ c, now, old }: { c: ActivityCommit; now: number; old: boolean }) => (
+    <>
+        <td className="acsha">{c.sha}</td>
+        <td className="acwhen" title={stampWords(c.at)}>{ageShort(c.at, now)}</td>
+        <td className={`actitle ${c.pushed ? 'pushed' : 'unpushed'}${old ? ' old' : ''}`} title={`${old ? 'the last commit, before the window. ' : ''}${c.pushed ? 'pushed' : 'not pushed'}: ${c.title}`}>
+            <span className="acmark">{c.pushed ? '✓' : '↑'}</span>
+            {c.branch == null ? null : <span className="acside">{c.branch}</span>}
+            {c.title}
+        </td>
+        <td className="acwho">{c.author}</td>
+    </>
+)
+
+/** the checks behind a red or orange dot, failing first. An answer from
+ *  a daemon that sends no `failing` still names them, by id */
+export const failingOf = (r: ActivityRow): StatusCheck[] => {
+    if (r.failing != null) return r.failing
+    const c = r.status
+    if (c == null) return []
+    const one = (id: string, status: 'fail' | 'warn'): StatusCheck => ({ id, title: id, status, at: c.since[id] ?? null, line: '' })
+    return [...c.reds.map((id) => one(id, 'fail')), ...c.warns.map((id) => one(id, 'warn'))]
+}
+
+/** each failing and warning check: its id (a link to its page), its title,
+ *  how old that outcome is, and the first line it printed about it */
+export const CheckList = observer(({ app, r }: { app: HomeSt; r: ActivityRow }) => {
+    const now = app.activity.now
+    return (
+        <ul className="acchecks">
+            {failingOf(r).map((c) => (
+                <li key={c.id} className={c.status === 'fail' ? 'fail' : 'warn'}>
+                    <span className="acchkhead">
+                        <span className="acchkmark">{c.status === 'fail' ? '✗' : '!'}</span>
+                        <a className="acchkid" href={checkAddress(r.name, c.id)} onClick={(e) => {
+                            if (!plainClick(e)) return
+                            e.preventDefault()
+                            app.activity.openCheck(r.name, c.id)
+                        }}>{c.id}</a>
+                        {c.title !== c.id ? <span className="acchktitle">{c.title}</span> : null}
+                        {c.at == null ? null : <span className="acdim" title={stampWords(c.at)}>{ageShort(c.at, now)}</span>}
+                    </span>
+                    {c.line === '' ? null : <span className="acchkline">{c.line}</span>}
+                </li>
+            ))}
+        </ul>
+    )
+})
+
+/** the repo's checks as its own run record last saw them, only the ids it
+ *  declares today: one dot, red, orange or green, with the count behind it.
+ *  Hovering it floats the failing and warning checks; a click lists them
+ *  under the row, so they read without hover too */
+const Status = observer(({ app, r, span }: { app: HomeSt; r: ActivityRow; span: number }) => {
+    const c = r.status
+    if (c == null) return (
+        <td rowSpan={span} className="acstatus acdim">
+            <Tip content="no shipkit run recorded in this repo yet" placement="right">·</Tip>
+        </td>
+    )
+    const n = c.state === 'red' ? c.reds.length : c.state === 'orange' ? c.warns.length : 0
+    const tone = c.state === 'red' ? 'red' : c.state === 'orange' ? 'warn' : 'ok'
+    if (c.reds.length + c.warns.length === 0) return (
+        <td rowSpan={span} className={`acstatus t-${tone}`}>
+            <Tip content="every check passed on its last run" placement="right">●</Tip>
+        </td>
+    )
+    const open = app.activity.checksOpen.has(r.name)
+    return (
+        <td rowSpan={span} className={`acstatus t-${tone}`}>
+            <Tip content={<CheckList app={app} r={r} />} tipClass="acchktip" interactive placement="right-start" fallbacks={['bottom-start', 'left-start']}>
+                <button type="button" className={`acdot t-${tone}`} aria-expanded={open} aria-label={`${r.name}: ${c.reds.length} failing, ${c.warns.length} warning, click to ${open ? 'hide' : 'list'} them`}
+                    onClick={() => app.activity.toggleChecks(r.name)}>
+                    ●{n > 0 ? ` ${n}` : ''}
+                </button>
+            </Tip>
+        </td>
+    )
+})
+
+const Group = observer(({ app, r, now }: { app: HomeSt; r: ActivityRow; now: number }) => {
+    const st = app.activity
+    const open = st.expanded.has(r.name)
+    const capped = open ? r.commits : r.commits.slice(0, st.cap)
+    const more = r.commits.length - capped.length
+    const folds = more > 0 || (open && r.commits.length > st.cap)
+    const dirt = r.error == null ? dirtWords(r) : ''
+    const lines = (dirt !== '' || r.error != null ? 1 : 0) + capped.length + (r.last != null ? 1 : 0) + (folds ? 1 : 0)
+    const span = Math.max(1, lines)
+    const branch = r.branch ?? (r.detached == null ? '' : `detached ${r.detached}`)
+    const head = (
+        <>
+            <td rowSpan={span} className="acname"><RepoName app={app} name={r.name} /></td>
+            <Status app={app} r={r} span={span} />
+            <td rowSpan={span} className={`acbranch ${isMainBranch(r.branch) ? 't-ok' : 't-warn'}`} title={`${branch}: ${upstreamWords(r)}`}>{branch}</td>
+            {/* the lead in to the commit list, on its first line */}
+            <td rowSpan={span} className="acforkcell">
+                <button type="button" className="acfork" title="open in Fork" aria-label={`open ${r.name} in Fork`} onClick={() => void st.openFork(r.name)}><Icon d={ICON.fork} /></button>
+            </td>
+        </>
+    )
+    const rows: ReactNode[] = []
+    if (r.error != null) rows.push(<td key="e" colSpan={4} className="acerr" title={r.error}>git failed: {r.error}</td>)
+    else if (dirt !== '') rows.push(
+        <td key="d" colSpan={4} className="acdirty">
+            <Tip className="acdirt" tipClass="acfiles" placement="bottom-start" content={<pre>{filesWords(r)}</pre>}>{dirt}</Tip>
+        </td>,
+    )
+    for (const c of capped) rows.push(<Commit c={c} now={now} old={false} />)
+    // nothing newer in the window: HEAD's last commit, grey
+    if (r.last != null) rows.push(<Commit c={r.last} now={now} old />)
+    if (folds) rows.push(<td key="m" colSpan={4}><button className="acmore" onClick={() => st.toggle(r.name)}>{open ? 'show fewer' : `${more} more`}</button></td>)
+    if (rows.length === 0) rows.push(<td key="n" colSpan={4} className="acdim">no commit yet</td>)
+    return (
+        <tbody className={`acgrp${idleRow(r) ? ' quiet' : ''}`}>
+            {rows.map((cells, i) => <tr key={i}>{i === 0 ? head : null}{cells}</tr>)}
+            {st.checksOpen.has(r.name) && failingOf(r).length > 0 ? <tr className="acchkrow"><td colSpan={8}><CheckList app={app} r={r} /></td></tr> : null}
+        </tbody>
+    )
+})
+
+export const ActivityView = observer(({ app }: { app: HomeSt }) => {
+    const st = app.activity
+    const d = st.data
+    const now = d?.now ?? st.now
+    const { busy, idle } = st.rows
+    return (
+        <div className="hall activity">
+            <div className="actop">
+                <Bar label="how far back" values={WINDOW_MINUTES} value={st.minutes} words={windowWords} set={(m) => st.setMinutes(m)} />
+                <label className="accap" title={`the most commits a repo shows, ${CAP_MIN} to ${CAP_MAX}`}>
+                    {/* uncontrolled while typed, so an emptied box can take a new number; it reads back the clamped cap on blur */}
+                    <input type="number" min={CAP_MIN} max={CAP_MAX} step={1} defaultValue={st.cap} aria-label="commits per repo"
+                        onChange={(e) => { if (e.currentTarget.value !== '') st.setCap(e.currentTarget.value) }}
+                        onBlur={(e) => { e.currentTarget.value = String(st.cap) }} />
+                    <span className="acdim">commits</span>
+                </label>
+                <Next app={app} />
+                {d == null ? <span className="acdim">reading every repo…</span> : (
+                    <>
+                        <span className="acpill">{busy.length} busy</span>
+                        <span className="acpill">{idle.length} quiet</span>
+                        <span className="acpill">read in {d.ms}ms</span>
+                    </>
+                )}
+            </div>
+            {st.error !== '' ? <div className="hnote">{st.error}</div> : null}
+            {d != null && busy.length === 0 ? <div className="acdim">nothing committed or uncommitted in the last {windowWords(st.minutes)}</div> : null}
+            {busy.length + idle.length === 0 ? null : (
+                <table className={`actable${st.stale ? ' stale' : ''}`}>
+                    <colgroup>
+                        <col className="c-name" /><col className="c-status" /><col className="c-branch" />
+                        <col className="c-fork" /><col className="c-sha" /><col className="c-when" /><col /><col className="c-who" />
+                    </colgroup>
+                    <thead>
+                        <tr><th>repo</th><th>status</th><th>branch</th><th colSpan={5}>commits, newest first</th></tr>
+                    </thead>
+                    {busy.map((r) => <Group key={r.name} app={app} r={r} now={now} />)}
+                    {idle.map((r) => <Group key={r.name} app={app} r={r} now={now} />)}
+                </table>
+            )}
+            <p className="hdim">in the console: shipkit activity</p>
+        </div>
+    )
+})