rvlib-shipkit 1.2.0 → 1.4.0

package/src/home/resources.ts

@@ -1,16 +1,19 @@
 // the machine's global processes (ComfyUI, a TTS server, an app panel), each
 // declared once in a repo's `<name>.shipkit.ts` as `globalProcess({...})`
 // (shipkit-files.ts) and owned by pm: a switch, a restart, its log, its
-// action buttons, and for an app the window that opens on its url.
+// action buttons, and its url opened in the default browser, in Chrome, or
+// as its own app (home/gui-app.ts builds that app in its repo on first use).
 //
 // two kinds: with no `down`, the command IS the service, supervised like a
 // hub (restarted on a crash, signalled on stop). With `down`, the command is
 // a bring-up that exits (an idempotent ladder script), `down` its reverse,
 // and the probe is the only truth.
-import { mkdirSync, openSync, closeSync } from 'fs'
+import { closeSync, existsSync, mkdirSync, openSync } from 'fs'
+import { homedir } from 'os'
 import { dirname, join } from 'path'
 import { fileURLToPath } from 'url'
 import type { GlobalProcessDecl } from './global-units.ts'
+import { iconImageType } from '../shipkit-files.ts'
 import { Proc, realDeps, tailLines, type ProcStatus, type SuperviseDeps } from './supervise.ts'
 import { resourceLog, resourcePid } from './home-paths.ts'
 import { groupOf, localPort, portHolders } from '../core/port-holders.ts'
@@ -21,6 +24,11 @@ export type ResourceView = {
     description: string | null
     where: string | null
     status: ProcStatus
+    /** the pid pm holds for it, null for a bring-up or one started elsewhere */
+    pid: number | null
+    /** epoch ms its uptime counts from while up (its pid's start when it has
+     *  one, else its last status change), its crash time when crashed */
+    since: number
     /** what the owner last asked for */
     want: 'up' | 'down'
     note: string | null
@@ -35,13 +43,26 @@ export type ResourceView = {
     repo: string
     file: string
     url: string | null
-    /** opens as a shipkit app window on its url */
-    app: boolean
+    /** what its card wears, as declared: null leaves the card its repo's icon */
+    icon: ProcessIcon | null
     actions: { id: string; label: string }[]
     /** the action running now, or null */
     running: string | null
+    /** its own app is being built or opened: the page shows a spinner on
+     *  that button. Absent from an older pm */
+    appBusy?: boolean
 }
 
+/** where a url opens: the default browser, Chrome, or the process's own app */
+export type OpenHow = 'browser' | 'chrome' | 'app'
+
+/** an emoji, or the url pm serves a declared image file at */
+export type ProcessIcon = { text: string } | { src: string }
+
+/** the page's url for a process's declared icon */
+export const processIconOf = (d: GlobalProcessDecl): ProcessIcon | null =>
+    d.icon == null ? null : iconImageType(d.icon) != null ? { src: `/api/pm/icon/${encodeURIComponent(d.id)}` } : { text: d.icon }
+
 export type HttpProbe = (url: string) => Promise<boolean>
 
 export const probeUrl: HttpProbe = async (url) => {
@@ -69,17 +90,19 @@ export const runOnce: RunOnce = async (cmd, cwd, log) => {
     }
 }
 
-/** opens a shipkit app window on a url; what it did lands in the log */
-export type OpenApp = (url: string, log: string) => void
+/** opens a process's own app, building it first when it is missing or
+ *  stale; what it did lands in the log. Resolves with the exit code */
+export type OpenApp = (d: GlobalProcessDecl, log: string) => Promise<number>
 
 /** its own process: what building the app needs never loads in pm */
 const OPEN_APP = fileURLToPath(new URL('./open-app.ts', import.meta.url))
 
-const openApp: OpenApp = (url, log) => {
+const openApp: OpenApp = async (d, log) => {
     mkdirSync(dirname(log), { recursive: true })
     const fd = openSync(log, 'a')
     try {
-        Bun.spawn([process.execPath, OPEN_APP, url], { stdio: ['ignore', fd, fd] })
+        const spec = { id: d.id, label: d.label, url: d.url, icon: d.icon, root: d.root }
+        return await Bun.spawn([process.execPath, OPEN_APP, '--process', JSON.stringify(spec)], { stdio: ['ignore', fd, fd] }).exited
     } finally {
         closeSync(fd)
     }
@@ -99,6 +122,26 @@ const browse: Browse = (url, log) => {
     }
 }
 
+const CHROME_APPS = ['/Applications/Google Chrome.app', join(homedir(), 'Applications', 'Google Chrome.app')]
+
+/** the command that opens a url in Chrome, else in the default browser */
+export function chromeCmd(url: string, o: { platform?: string; has?: (path: string) => boolean } = {}): string[] {
+    const platform = o.platform ?? process.platform
+    const has = o.has ?? existsSync
+    if (platform === 'darwin') return CHROME_APPS.some(has) ? ['open', '-a', 'Google Chrome', url] : ['open', url]
+    return platform === 'win32' ? ['cmd', '/c', 'start', 'chrome', url] : ['xdg-open', url]
+}
+
+const chrome: Browse = (url, log) => {
+    mkdirSync(dirname(log), { recursive: true })
+    const fd = openSync(log, 'a')
+    try {
+        Bun.spawn(chromeCmd(url), { stdio: ['ignore', fd, fd] })
+    } finally {
+        closeSync(fd)
+    }
+}
+
 /** the function action runner: imports the unit file, calls the action */
 const ACTION_RUNNER = fileURLToPath(new URL('./run-unit-action.ts', import.meta.url))
 
@@ -106,10 +149,12 @@ export type ResourceOpts = {
     probe?: HttpProbe
     run?: RunOnce
     deps?: SuperviseDeps
-    /** the app window */
+    /** the process's own app */
     open?: OpenApp
     /** the default browser */
     browse?: Browse
+    /** Chrome */
+    chrome?: Browse
     /** the pids listening on a local port, and the process group of a pid */
     holders?: (port: number) => number[]
     groupOf?: (pid: number) => number | null
@@ -136,16 +181,26 @@ export class Resource {
     private busy = false
     /** the last bring-up exited non zero */
     private failed = false
-    /** open it once it answers: in the default browser, or as an app window */
-    private openWhenUp: 'browser' | 'app' | null = null
+    /** open it once it answers */
+    private openWhenUp: OpenHow | null = null
+    /** its own app is being built or opened */
+    appBusy = false
+    /** the status a tick last saw, and since when, for the bring-up kind */
+    private seen: ProcStatus = 'down'
+    private seenAt: number
     readonly log: string
 
     constructor(readonly decl: GlobalProcessDecl, dir: string, private o: ResourceOpts = {}) {
         this.log = resourceLog(dir, decl.id)
+        this.seenAt = this.now()
         if (decl.down == null)
             this.proc = new Proc({ id: decl.id, cmd: decl.cmd, cwd: decl.cwd, log: this.log, pidKey: resourcePid(dir, decl.id), probe: decl.probe == null ? undefined : () => this.probe() }, o.deps ?? realDeps)
     }
 
+    private now(): number {
+        return this.o.deps?.now() ?? Date.now()
+    }
+
     private probe(): Promise<boolean> {
         return this.decl.probe == null ? Promise.resolve(true) : (this.o.probe ?? probeUrl)(this.decl.probe)
     }
@@ -226,12 +281,10 @@ export class Resource {
         await this.set('up')
     }
 
-    /** its url in the default browser, or as a shipkit app window (app:
-     *  true only): at once while it answers, else it starts and opens once
-     *  it does */
-    async open(how: 'browser' | 'app'): Promise<void> {
+    /** its url in the default browser, in Chrome, or as its own app: at once
+     *  while it answers, else it starts and opens once it does */
+    async open(how: OpenHow): Promise<void> {
         if (this.decl.url == null) throw new Error(`${this.decl.id} declares no url to open`)
-        if (how === 'app' && !this.decl.app) throw new Error(`${this.decl.id} does not declare app: true, so it has no app window: open it in the browser`)
         if (this.status === 'up') {
             this.show(how, this.decl.url)
             return
@@ -240,9 +293,27 @@ export class Resource {
         await this.set('up')
     }
 
-    private show(how: 'browser' | 'app', url: string): void {
-        if (how === 'app') (this.o.open ?? openApp)(url, this.log)
-        else (this.o.browse ?? browse)(url, this.log)
+    private show(how: OpenHow, url: string): void {
+        if (how === 'browser') (this.o.browse ?? browse)(url, this.log)
+        else if (how === 'chrome') (this.o.chrome ?? chrome)(url, this.log)
+        else if (!this.appBusy) void this.showApp()
+    }
+
+    /** off the request path: the build takes seconds the first time, and
+     *  the page follows `appBusy` on its poll */
+    private async showApp(): Promise<void> {
+        this.appBusy = true
+        let failed: string | null = null
+        try {
+            const code = await (this.o.open ?? openApp)(this.decl, this.log)
+            if (code !== 0) failed = `opening ${this.decl.label} as an app exited ${code}: see the log`
+        } catch (e) {
+            failed = `opening ${this.decl.label} as an app: ${(e as Error).message}`
+        } finally {
+            this.appBusy = false
+        }
+        // kept beside what the supervisor says, like an action's outcome
+        if (failed != null) this.note = this.actionNote = failed
     }
 
     /** one declared button. A function action runs in its own bun process
@@ -275,6 +346,10 @@ export class Resource {
             const up = await this.probe()
             this.status = up ? 'up' : this.failed && this.want === 'up' ? 'crashed' : 'down'
         }
+        if (this.status !== this.seen) {
+            this.seen = this.status
+            this.seenAt = this.now()
+        }
         if (this.openWhenUp != null && this.status === 'up' && this.decl.url != null) {
             const how = this.openWhenUp
             this.openWhenUp = null
@@ -290,6 +365,9 @@ export class Resource {
             description: d.description,
             where: d.where,
             status: this.status,
+            pid: this.proc?.pid ?? null,
+            // up with a pid: since that pid started, so a pm reload never resets its uptime
+            since: (this.status === 'up' ? this.proc?.startedAt() : null) ?? this.proc?.since ?? this.seenAt,
             want: this.want,
             note: this.note,
             canStop: this.canStop,
@@ -298,9 +376,10 @@ export class Resource {
             repo: d.repo,
             file: d.file,
             url: d.url,
-            app: d.app,
+            icon: processIconOf(d),
             actions: d.actions.map((a) => ({ id: a.id, label: a.label })),
             running: this.running,
+            appBusy: this.appBusy,
         }
     }
 }

package/src/home/run-daemon.ts

@@ -20,8 +20,10 @@ import { daemonPort, homeDir, homePort, homeUp, hubBase, WORKER_ENV } from './ho
 import { HomeState } from './home-state.ts'
 import { Hubs } from './hubs.ts'
 import { Planner } from '../plan/planner.ts'
+import { machineCatchUp } from '../plan/catch-up.ts'
 import { serveDaemon } from './serve-daemon.ts'
 import { startSweeps } from './machine-stores.ts'
+import { landMotherhome } from '../core/motherhome.ts'
 import { Widgets } from './widgets.ts'
 
 const CLI = fileURLToPath(new URL('../cli.ts', import.meta.url))
@@ -58,10 +60,11 @@ export async function runDaemon(root: string, io: HomeIo, o: { port?: number } =
     if (reclaimed.killed.length > 0) io.print(`ok: the daemon restarted in place: killed ${reclaimed.killed.length} check process(es) its previous image left running`)
     const c = await loadRepoConfig(root)
     const dir = homeDir()
-    const gutter = projectGutter({ root, warn: (l) => io.printErr(l) })
-    const names = new Set(house.repos.map((r) => r.name))
-    // the machine's one plan: every repo and check pair, ticked by the daemon
-    const plan = new Planner({ onError: (repo, e) => io.printErr(`WARN the plan of ${repo} broke: ${e.message}`) })
+    // the machine's one plan: every repo and check pair, ticked by the daemon.
+    // Its catch up window lives in the machine db, so a restart in place keeps it
+    const plan = new Planner({ catchUp: machineCatchUp, onError: (repo, e) => io.printErr(`WARN the plan of ${repo} broke: ${e.message}`) })
+    // a repo's colour counts only the checks its plan holds today
+    const gutter = projectGutter({ root, warn: (l) => io.printErr(l), declared: (name) => plan.declared(name) })
     const hubs = new Hubs({
         dir,
         port,
@@ -84,8 +87,6 @@ export async function runDaemon(root: string, io: HomeIo, o: { port?: number } =
                 fresh: o.fresh,
                 // every gate is a detached job: a reload of this process never kills one
                 jobs: { cli: CLI },
-                // a lane click of the live strip opens that repo's page, on the page's own origin
-                repoHub: async (other) => (names.has(other) ? `${hubBase(other)}/` : null),
             })
             hubIo.print(`${rt.name} hub → http://localhost:${port}${hubBase(repo.name)}/`)
             return { ...rt, uses: rt.deps.uses ?? [] }
@@ -109,7 +110,11 @@ export async function runDaemon(root: string, io: HomeIo, o: { port?: number } =
         // nothing grows unbound: every store of every repo it loads, and the
         // machine's, swept on boot and hourly (core/retention.ts)
         const only = onlyRepos()
-        const sweeps = startSweeps({ roots: () => house.repos.filter((r) => only == null || only.has(r.name)).map((r) => r.path), dir, printErr: io.printErr })
+        const sweeps = startSweeps({
+            roots: () => house.repos.filter((r) => only == null || only.has(r.name)).map((r) => r.path), dir, printErr: io.printErr,
+            // the rows every gate filed land here, one commit a day at most
+            also: (now) => { for (const n of landMotherhome({ now })) io.printErr(n) },
+        })
         const code = reloadOnOwnCode({ role: 'daemon', entry: fileURLToPath(import.meta.url), busy: () => hubs.busy(), before: () => { sweeps.stop(); home.stop() }, io })
         io.print(`  ${house.repos.length} repos, state in ${dir}, reloads on ${code.files} lib files`)
         for (const sig of ['SIGINT', 'SIGTERM'] as const)

package/src/home/run-pm.ts

@@ -11,16 +11,37 @@ import { reloadOnOwnCode } from './lib-watch.ts'
 import { Pm, PM_TICK_MS, type Role } from './pm.ts'
 import { Resources } from './resources.ts'
 import type { HomeIo } from './run-daemon.ts'
-import type { PmConfig } from './pm-config.ts'
+import { stampOf, type PmConfig } from './pm-inputs.ts'
 
 const CLI = fileURLToPath(new URL('../cli.ts', import.meta.url))
 const PM_CONFIG = fileURLToPath(new URL('./pm-config.ts', import.meta.url))
 
 const RUN_PM = fileURLToPath(import.meta.url)
 
-/** how often pm reads the house repos' global processes again */
+/** how often pm stats what its last read of the house side saw */
 export const PM_RESCAN_MS = 15_000
 
+/** pm's reread of the house side: the child runs again only once a stat of
+ *  a path the last answer read moved. A few ms of stats per poll, against a
+ *  child that imports every unit file */
+export class PmConfigWatch {
+    private last: PmConfig | null = null
+
+    constructor(private readonly read: () => Promise<PmConfig>) {}
+
+    seed(c: PmConfig): void {
+        this.last = c
+    }
+
+    /** the new answer, or null when nothing it read moved */
+    async poll(): Promise<PmConfig | null> {
+        if (this.last != null && stampOf(this.last.inputs) === this.last.stamp) return null
+        const c = await this.read()
+        this.last = c
+        return c
+    }
+}
+
 /** replace this process's image with pm run from this file: same pid, same
  *  cwd, same env, none of cli.ts loaded. False when the runtime has no
  *  execve, and the caller runs pm in process */
@@ -75,6 +96,7 @@ export async function runPm(root: string, io: HomeIo, o: { port?: number } = {})
     const pm = new Pm({
         dir,
         root,
+        port,
         cmd: (role) => [process.execPath, CLI, role],
         probe: roleAnswers,
         resources: new Resources(c.processes, dir),
@@ -97,13 +119,16 @@ export async function runPm(root: string, io: HomeIo, o: { port?: number } = {})
     pm.resources.errors = c.errors
     for (const e of c.errors) io.printErr(`WARN ${e}`)
     // a unit file added, edited or removed in any house repo: read again,
-    // in its child process, and the unchanged processes keep their state
+    // in its child process, and the unchanged processes keep their state.
+    // Nothing moved, no child
+    const watch = new PmConfigWatch(() => readPmConfig(root))
+    watch.seed(c)
     let reading = false
     const reread = setInterval(() => {
         if (reading) return
         reading = true
-        void readPmConfig(root)
-            .then((n) => pm.resources.sync(n.processes, n.errors))
+        void watch.poll()
+            .then((n) => { if (n != null) pm.resources.sync(n.processes, n.errors) })
             .catch((e) => io.printErr(`WARN pm could not read the global processes again: ${(e as Error).message}`))
             .finally(() => { reading = false })
     }, PM_RESCAN_MS)

package/src/home/serve-web.ts

@@ -1,5 +1,5 @@
 // the web: ONE Bun.serve on the home port. It serves the one page bundle (the
-// overview at `/`, the plan at `/planned`, a repo's hub page at `/r/<repo>/`,
+// overview at `/`, the plan at `/planned`, the activity at `/activity`, a repo's hub page at `/r/<repo>/`,
 // all views of one app) and proxies every api,
 // graph and media request to the daemon, streams included, and /api/pm/* to
 // pm. A browser only ever sees this origin.
@@ -14,7 +14,7 @@ import { hubBase } from './home-paths.ts'
 /** the page routes: ONE app for the overview, the plan, and the hub page of
  *  each known repo, which moves between them in place (home-st.ts) */
 export function pageRoutes<T>(names: string[], page: T): Record<string, T> {
-    const out: Record<string, T> = { '/': page, '/planned': page }
+    const out: Record<string, T> = { '/': page, '/planned': page, '/activity': page, '/archived': page }
     for (const n of names) out[`${hubBase(n)}/`] = page
     return out
 }
@@ -51,6 +51,9 @@ export const REPO_ANSWER_MS = 30_000
 export const LIST_EVERY_MS = 30_000
 export const LIST_RETRY_MS = 1_000
 
+/** the one home answer that can wait on git: the activity page's first read of a window */
+export const readsGit = (path: string): boolean => path === '/api/home/activity.json'
+
 /** a run or a check run streams for minutes, and a silent one is never cut */
 export const streams = (path: string): boolean => /\/api\/(run|check\/run)$/.test(path)
 
@@ -94,7 +97,7 @@ export function serveWeb<T extends Bun.HTMLBundle | Response>(d: WebDeps<T>) {
         const path = url.pathname
         const pm = toPm(path)
         const target = pm ? d.pm : d.daemon
-        const wait = streams(path) ? null : path.startsWith('/r/') ? (d.repoMs ?? REPO_ANSWER_MS) : (d.machineMs ?? MACHINE_ANSWER_MS)
+        const wait = streams(path) ? null : path.startsWith('/r/') || readsGit(path) ? (d.repoMs ?? REPO_ANSWER_MS) : (d.machineMs ?? MACHINE_ANSWER_MS)
         // the wait covers the answer headers only: a body already flowing is never cut
         const ctl = new AbortController()
         const timer = wait == null ? null : setTimeout(() => ctl.abort(new Error(`no answer in ${wait / 1000}s: it runs but hangs`)), wait)

package/src/home/supervise.ts

@@ -143,19 +143,33 @@ export class Proc {
     external = false
     /** the pid came from the pid record an earlier image wrote, not from a start */
     adopted = false
+    /** when the pid started, kept per pid: a pid's start never moves, so the
+     *  OS is asked once for an adopted pid and never for one this image spawned */
+    private started: { pid: number; at: number | null } | null = null
 
     constructor(readonly spec: ProcSpec, private d: SuperviseDeps = realDeps) {
         this.since = d.now()
         const rec = readPid(spec.pidKey)
         // an earlier image started it and it still runs: adopt, never double
-        if (rec != null && d.alive(rec.pid) && !((d.startedAt?.(rec.pid) ?? 0) > rec.at + RECORD_SLACK_MS)) {
+        const at = rec != null && d.alive(rec.pid) ? (d.startedAt?.(rec.pid) ?? null) : undefined
+        if (rec != null && at !== undefined && !((at ?? 0) > rec.at + RECORD_SLACK_MS)) {
             this.pid = rec.pid
+            this.started = { pid: rec.pid, at }
             this.adopted = true
             this.want = 'up'
             this.set('starting')
         } else if (rec != null) dropPid(spec.pidKey)
     }
 
+    /** epoch ms its pid started, what its uptime counts from; null without
+     *  a pid, or when the OS cannot say */
+    startedAt(): number | null {
+        const pid = this.pid
+        if (pid == null) return null
+        if (this.started?.pid !== pid) this.started = { pid, at: this.d.startedAt?.(pid) ?? null }
+        return this.started.at
+    }
+
     private set(s: ProcStatus, note: string | null = null): void {
         if (s !== this.status) this.since = this.d.now()
         this.status = s
@@ -185,6 +199,7 @@ export class Proc {
         try {
             const pid = this.d.spawn(this.spec)
             this.pid = pid
+            this.started = { pid, at: this.d.now() }
             this.adopted = false
             writePid(this.spec.pidKey, { pid, cmd: this.spec.cmd, at: this.d.now() })
             this.set('starting')

package/src/home/widget-text.ts

@@ -0,0 +1,119 @@
+// a widget's html as console lines, for `shipkit overview`: the html the
+// daemon rendered for the page, tags stripped, a table's cells aligned in
+// columns, a block element on its own line, and a `.wbar` meter (its width
+// in `--p:NN%`) drawn as `█████░░░░░`. It reads, never runs: no script, no
+// style, no layout, so a widget that draws only with css reads as its text.
+
+const BLOCK = new Set(['div', 'p', 'section', 'article', 'header', 'footer', 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'pre', 'hr', 'dl', 'dt', 'dd', 'figure', 'figcaption', 'blockquote'])
+const SKIP = new Set(['script', 'style', 'template', 'svg'])
+const BAR_CELLS = 10
+
+const ENTITY: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', middot: '·', deg: '°', hellip: '…', times: '×' }
+
+export function decodeEntities(s: string): string {
+    return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e: string) => {
+        if (e[0] === '#') {
+            const n = e[1] === 'x' || e[1] === 'X' ? parseInt(e.slice(2), 16) : Number(e.slice(1))
+            return Number.isFinite(n) ? String.fromCodePoint(n) : m
+        }
+        return ENTITY[e.toLowerCase()] ?? m
+    })
+}
+
+/** a meter of BAR_CELLS cells, `p` in 0..100 */
+export function barText(p: number): string {
+    const on = Math.round((Math.min(100, Math.max(0, p)) / 100) * BAR_CELLS)
+    return '█'.repeat(on) + '░'.repeat(BAR_CELLS - on)
+}
+
+type Block = { kind: 'line'; text: string } | { kind: 'table'; rows: string[][] }
+
+const attr = (attrs: string, name: string): string | null => {
+    const m = new RegExp(`\\b${name}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i').exec(attrs)
+    return m == null ? null : (m[2] ?? m[3] ?? m[4] ?? '')
+}
+
+const squash = (s: string): string => s.replace(/\s+/g, ' ').trim()
+
+/** a table's rows as aligned lines: each column as wide as its widest cell */
+export function alignRows(rows: string[][]): string[] {
+    const w: number[] = []
+    for (const r of rows) r.forEach((c, i) => { w[i] = Math.max(w[i] ?? 0, c.length) })
+    return rows.map((r) => r.map((c, i) => (i === r.length - 1 ? c : c.padEnd(w[i]!))).join('  ').trimEnd())
+}
+
+/** a widget's leading `<header>`: the words it puts on its card's title
+ *  line (state, age), apart from the body drawn under that line */
+export function splitWidgetHead(html: string): { head: string | null; body: string } {
+    const m = /^\s*<header\b[^>]*>([\s\S]*?)<\/header>/i.exec(html)
+    return m == null ? { head: null, body: html } : { head: m[1]!, body: html.slice(m[0].length) }
+}
+
+/** the html as lines, no empty one */
+export function widgetText(html: string): string[] {
+    const blocks: Block[] = []
+    let line = ''
+    let table: string[][] | null = null
+    let cell: string | null = null
+    let skip: string | null = null
+    const put = (s: string): void => {
+        if (cell != null) cell += s
+        else line += s
+    }
+    const flush = (): void => {
+        for (const part of line.split('\n')) if (squash(part) !== '') blocks.push({ kind: 'line', text: squash(part) })
+        line = ''
+    }
+    const endCell = (): void => {
+        if (cell != null && table != null) table.at(-1)?.push(squash(cell))
+        cell = null
+    }
+    const tokens = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][a-zA-Z0-9-]*)([^>]*)>|([^<]+)|</g
+    for (const m of html.matchAll(tokens)) {
+        const [whole, close, rawTag, attrs = '', text] = m
+        if (text != null || whole === '<') {
+            if (skip == null) put(decodeEntities(text ?? '<'))
+            continue
+        }
+        if (rawTag == null) continue
+        const tag = rawTag.toLowerCase()
+        if (skip != null) {
+            if (close === '/' && tag === skip) skip = null
+            continue
+        }
+        if (SKIP.has(tag) && close !== '/' && !attrs.trim().endsWith('/')) {
+            skip = tag
+            continue
+        }
+        if (tag === 'table') {
+            endCell()
+            if (close === '/') {
+                if (table != null) blocks.push({ kind: 'table', rows: table.filter((r) => r.some((c) => c !== '')) })
+                table = null
+            } else {
+                flush()
+                table = []
+            }
+        } else if (tag === 'tr' && table != null) {
+            endCell()
+            if (close !== '/') table.push([])
+        } else if ((tag === 'td' || tag === 'th') && table != null) {
+            endCell()
+            if (close !== '/') {
+                if (table.length === 0) table.push([])
+                cell = ''
+            }
+        } else if (tag === 'br') put(cell != null ? ' ' : '\n')
+        else if (BLOCK.has(tag)) {
+            if (cell != null) put(' ')
+            else flush()
+        } else if (close !== '/' && /\bwbar\b/.test(attr(attrs, 'class') ?? '')) {
+            const p = /--p\s*:\s*(-?\d+(?:\.\d+)?)%/.exec(attr(attrs, 'style') ?? '')
+            if (p != null) put(` ${barText(Number(p[1]))} `)
+        }
+    }
+    endCell()
+    if (table != null) blocks.push({ kind: 'table', rows: table })
+    flush()
+    return blocks.flatMap((b) => (b.kind === 'line' ? [b.text] : alignRows(b.rows)))
+}

package/src/home/widgets.ts

@@ -2,7 +2,8 @@
 // rendered by the daemon on each one's own clock and kept as html the page
 // reads at /api/home/widgets.json. The files are read again every
 // WIDGET_RESCAN_MS, a walk of every repo that costs a few tens of ms, and an
-// unchanged file is never imported twice.
+// unchanged file is never imported twice. All of it only while a reader
+// asked within WIDGET_WATCH_MS: nobody looking, nothing scans or renders.
 //
 // the one constraint a reader breaks first: a render runs in the daemon, so
 // it is bounded (WIDGET_RENDER_MS) and never awaited by the daemon's tick.
@@ -11,6 +12,8 @@ import { scanGlobalUnits, type LoadedWidget, type RepoRef } from './global-units
 export const WIDGET_EVERY_MS = 5_000
 export const WIDGET_RENDER_MS = 5_000
 export const WIDGET_RESCAN_MS = 15_000
+/** a read within this long keeps the clocks running */
+export const WIDGET_WATCH_MS = 30_000
 
 export type WidgetView = {
     repo: string
@@ -38,6 +41,8 @@ export class Widgets {
     private slots = new Map<string, Slot>()
     private scannedAt = -Infinity
     private scanning = false
+    private readAt: number | null = null
+    private rendering = new Set<Promise<void>>()
     /** the unit files that would not load */
     errors: string[] = []
 
@@ -47,9 +52,14 @@ export class Widgets {
         return (this.d.now ?? Date.now)()
     }
 
+    private get watched(): boolean {
+        return this.readAt != null && this.now() - this.readAt < WIDGET_WATCH_MS
+    }
+
     /** one look: read the files again when due, render every widget due. Never
-     *  waits on a render */
+     *  waits on a render, and does nothing while no reader is watching */
     async tick(repos: RepoRef[]): Promise<void> {
+        if (!this.watched) return
         const now = this.now()
         if (!this.scanning && now - this.scannedAt >= WIDGET_RESCAN_MS) {
             this.scanning = true
@@ -73,7 +83,24 @@ export class Widgets {
                 this.scanning = false
             }
         }
-        for (const s of this.slots.values()) if (!s.busy && this.now() >= s.due) void this.render(s)
+        for (const s of this.slots.values()) {
+            if (s.busy || this.now() < s.due) continue
+            const p = this.render(s)
+            this.rendering.add(p)
+            void p.finally(() => this.rendering.delete(p))
+        }
+    }
+
+    /** a reader's views: the first one in a while waits on a scan and on the
+     *  renders it starts (each bounded), so it never reads hours old html */
+    async look(repos: RepoRef[]): Promise<WidgetView[]> {
+        const cold = !this.watched
+        this.readAt = this.now()
+        if (cold) {
+            await this.tick(repos)
+            await Promise.all(this.rendering)
+        }
+        return this.views()
     }
 
     /** one render, bounded, its result or its error kept */
@@ -96,7 +123,9 @@ export class Widgets {
         }
     }
 
+    /** the last html of each; a read that keeps the clocks running */
     views(): WidgetView[] {
+        this.readAt = this.now()
         return [...this.slots.values()].map((s) => s.view)
     }
 }

package/src/hooks/commit-message.ts

@@ -1,6 +1,5 @@
-// the commit-message predicate, shared by the commit-msg hook (blocks at
-// write time) and SK009 (audits history). one implementation, or the two
-// drift and the drift only shows when a repo goes public.
+// the commit-message predicate of the commit-msg hook, which blocks at write
+// time: the one guard against AI attribution (SK009 checks it is armed).
 //
 // mechanical text rules only, so this stays publishable.