rvlib-shipkit 1.3.0 → 1.4.0

package/src/home/pm-config.ts

@@ -2,18 +2,14 @@
 // and the global processes every house repo declares in its `.shipkit.ts`
 // files), read in a short child process so pm itself never imports a repo
 // file. That graph would make pm large and reload it on every edit there.
+// The answer names the paths it read (`inputs`) and their stamp, so pm runs
+// the child again only once a stat of one of them moved.
 //
-//   bun pm-config.ts <root>   prints { index, processes, errors } as json on stdout
+//   bun pm-config.ts <root>   prints a PmConfig as json on stdout
 import { homedir } from 'os'
-import type { GlobalProcessDecl } from './global-units.ts'
+import { houseInputs, stampOf, type PmConfig } from './pm-inputs.ts'
 
-export type PmConfig = {
-    /** the house wiki index the repo includes, null when it includes none */
-    index: string | null
-    processes: GlobalProcessDecl[]
-    /** the unit files that would not load */
-    errors: string[]
-}
+export type { PmConfig }
 
 if (import.meta.main) {
     const root = process.argv[2]
@@ -22,14 +18,22 @@ if (import.meta.main) {
         process.exit(2)
     }
     const { houseRepos } = await import('../serve/project-gutter.ts')
+    const { repoUnitFiles } = await import('../core/discover-checks.ts')
     const house = houseRepos(root, homedir())
-    const out: PmConfig = { index: house.index, processes: [], errors: [] }
+    const repos = house.index == null ? [] : house.repos
+    const files = new Map<string, string[]>()
+    const inputs = houseInputs(house.home, house.index, repos.map((r) => r.path), (r, dirs) => {
+        const f = repoUnitFiles(r, dirs)
+        files.set(r, f)
+        return f
+    })
+    const out: PmConfig = { index: house.index, processes: [], errors: [], inputs, stamp: stampOf(inputs) }
     if (house.index != null) {
         // a unit file imports the lib by name: this copy, like the daemon's
         const { useOneLib } = await import('../core/one-lib.ts')
         const { scanGlobalUnits } = await import('./global-units.ts')
         useOneLib()
-        const u = await scanGlobalUnits(house.repos.map((r) => ({ name: r.name, path: r.path })))
+        const u = await scanGlobalUnits(repos.map((r) => ({ name: r.name, path: r.path })), { files: (r) => files.get(r) ?? [] })
         out.processes = u.processes
         out.errors = u.errors
     }

package/src/home/pm-inputs.ts

@@ -0,0 +1,76 @@
+// what pm stamps to know whether the house side moved, without running the
+// child that reads it (pm-config.ts): the answer's shape, the paths it
+// depends on, and their stamp. Imports nothing a repo file does, so pm's own
+// graph stays small.
+import { readdirSync, statSync } from 'fs'
+import { dirname, join } from 'path'
+import { UNIT_SUFFIX } from '../core/check-file-names.ts'
+import type { GlobalProcessDecl } from './global-units.ts'
+
+export type PmConfig = {
+    /** the house wiki index the repo includes, null when it includes none */
+    index: string | null
+    processes: GlobalProcessDecl[]
+    /** the unit files that would not load */
+    errors: string[]
+    /** every path whose stat can change this answer (houseInputs) */
+    inputs: string[]
+    /** stampOf(inputs), taken before the unit files were imported */
+    stamp: string
+}
+
+/** the files a repo carries its includes in. Here, not in project-gutter.ts
+ *  which reads them, so pm stamps them without loading that graph */
+export const CLAUDE_FILES = ['CLAUDE.md', 'CLAUDE.local.md']
+
+/** what the answer depends on, as paths to stat: the dir holding the repos
+ *  (a repo added or removed), every sibling's CLAUDE files (a repo starting
+ *  to include the house), the index, each house repo's config (archived),
+ *  and every dir and unit file the unit walk read. A helper a unit file
+ *  imports is not in it: an edit there shows once the unit file moves */
+export function houseInputs(home: string, index: string | null, repos: string[], unitFiles: (root: string, dirs: string[]) => string[]): string[] {
+    const parent = dirname(home)
+    const out = [parent]
+    let names: string[] = []
+    try { names = readdirSync(parent) } catch { /* the stat of parent says when it appears */ }
+    for (const n of names.sort()) if (!n.startsWith('.')) for (const f of CLAUDE_FILES) out.push(join(parent, n, f))
+    if (index != null) out.push(index)
+    for (const r of repos) {
+        out.push(join(r, 'repo.config.ts'))
+        const dirs: string[] = []
+        const files = unitFiles(r, dirs)
+        out.push(...dirs, ...files)
+    }
+    return out
+}
+
+/** a dir's entries that can change the answer: its subdirs and its unit
+ *  files. A temp file coming and going moves the dir's mtime, not this */
+const listings = new Map<string, { mtime: number; names: string }>()
+function dirNames(dir: string, mtime: number): string {
+    const hit = listings.get(dir)
+    if (hit?.mtime === mtime) return hit.names
+    let names = ''
+    try {
+        names = readdirSync(dir, { withFileTypes: true })
+            .filter((e) => !e.name.startsWith('.') && (e.isDirectory() || e.name.endsWith(UNIT_SUFFIX)))
+            .map((e) => e.name)
+            .sort()
+            .join('/')
+    } catch { /* gone between the stat and the read: the next stat says so */ }
+    listings.set(dir, { mtime, names })
+    return names
+}
+
+/** every path as one string: a file by its mtime, a dir by the entries
+ *  that matter (read again only when its mtime moved), -1 when missing */
+export function stampOf(paths: string[]): string {
+    return paths.map((p) => {
+        try {
+            const st = statSync(p)
+            return st.isDirectory() ? dirNames(p, st.mtimeMs) : st.mtimeMs
+        } catch {
+            return -1
+        }
+    }).join(',')
+}

package/src/home/pm.ts

@@ -154,9 +154,9 @@ export class Pm {
             if (act === 'start') report(r.set('up'))
             else if (act === 'stop') report(r.set('down'))
             else if (act === 'restart') report(r.restart())
-            else if (act === 'open' || act === 'app') {
+            else if (act === 'open' || act === 'chrome' || act === 'app') {
                 if (r.decl.url == null) return new Response(`${r.decl.id} declares no url to open`, { status: 400 })
-                report(r.open(act === 'app' ? 'app' : 'browser'))
+                report(r.open(act === 'open' ? 'browser' : act))
             } else if (act === 'takeover') {
                 const v = r.takeOverView
                 if (v == null) return new Response(`${r.decl.id} does not run outside the supervisor: nothing to take over`, { status: 409 })
@@ -166,7 +166,7 @@ export class Pm {
                 if (!r.decl.actions.some((a) => a.id === b.action)) return new Response(`${r.decl.id} declares no action '${String(b.action)}'`, { status: 404 })
                 if (r.running != null) return new Response(`${r.decl.id} is already running its action '${r.running}'`, { status: 409 })
                 report(r.action(String(b.action)))
-            } else return new Response('act must be start, stop, restart, open, app, takeover or action', { status: 400 })
+            } else return new Response('act must be start, stop, restart, open, chrome, app, takeover or action', { status: 400 })
             return Response.json(r.view())
         }
         return new Response('not found', { status: 404 })

package/src/home/process-rows.ts

@@ -9,8 +9,9 @@ import type { CorePorts, PmAnswer } from './pm.ts'
 import type { ProcessIcon, ResourceView } from './resources.ts'
 import type { ProcStatus } from './supervise.ts'
 
-/** a status as pm reports it, or unknown while pm does not answer */
-export type RowStatus = ProcStatus | 'unknown'
+/** a status as pm reports it, unknown while pm does not answer, silent
+ *  while pm runs it but the page gets no answer from it */
+export type RowStatus = ProcStatus | 'unknown' | 'silent'
 
 /** the dot a row wears: green up, red crashed, grey stopped or unknown, orange on its way */
 export type RowDot = 'up' | 'crashed' | 'down' | 'starting' | 'unknown'
@@ -46,6 +47,8 @@ export type ProcessRow = {
     actions: { id: string; label: string }[]
     running: string | null
     icon: ProcessIcon | null
+    /** its own app is being built or opened */
+    appBusy: boolean
 }
 
 /** a repo's processes, or shipkit's own (`core`, always the first group) */
@@ -55,7 +58,7 @@ export type ProcessGroup = { repo: string; core?: true; rows: ProcessRow[] }
 export const CORE_GROUP = 'shipkit'
 
 export const dotOf = (s: RowStatus): RowDot =>
-    s === 'up' ? 'up' : s === 'crashed' ? 'crashed' : s === 'starting' || s === 'stopping' ? 'starting' : s === 'down' ? 'down' : 'unknown'
+    s === 'up' ? 'up' : s === 'crashed' || s === 'silent' ? 'crashed' : s === 'starting' || s === 'stopping' ? 'starting' : s === 'down' ? 'down' : 'unknown'
 
 const hostOf = (url: string | null): string | null => (url == null ? null : url.replace(/^https?:\/\//, '').replace(/\/$/, ''))
 
@@ -85,6 +88,7 @@ export function rowOf(r: ResourceView): ProcessRow {
         actions: r.actions,
         running: r.running,
         icon: r.icon,
+        appBusy: r.appBusy === true,
     }
 }
 
@@ -113,6 +117,7 @@ export function declaredRow(d: GlobalProcessDecl): ProcessRow {
         takeOver: null,
         actions: d.actions.map((a) => ({ id: a.id, label: a.label })),
         running: null,
+        appBusy: false,
         // an image is pm's to serve, and pm does not answer
         icon: d.icon == null || /\.[a-z0-9]+$/i.test(d.icon) ? null : { text: d.icon },
     }
@@ -143,6 +148,10 @@ export type CoreOpts = {
     daemonVersion?: string | null
     /** where each listens, when pm does not say (an older pm, or pm down) */
     ports?: CorePorts | null
+    /** one of shipkit's own not answering the page, and why: its row says
+     *  no answer whatever pm last reported. pm silent, every other row is
+     *  the last answer's with its state unknown, so the table keeps its lines */
+    silent?: Partial<Record<'pm' | 'daemon' | 'web', string>>
 }
 
 function coreRow(id: 'pm' | 'daemon' | 'web', o: { status: RowStatus; pid: number | null; since: number | null; note: string | null; tail: string[]; version: string | null; port: number | null; restart: boolean }): ProcessRow {
@@ -150,7 +159,7 @@ function coreRow(id: 'pm' | 'daemon' | 'web', o: { status: RowStatus; pid: numbe
     return {
         id, label: id, repo: CORE_GROUP, file: '', status: o.status, dot: dotOf(o.status), url, host: hostOf(url), pid: o.pid, since: o.since, note: o.note,
         description: CORE_ABOUT[id], where: null, lastLog: o.tail.at(-1) ?? null, tail: o.tail,
-        canStop: false, canRestart: o.restart, core: true, version: o.version, takeOver: null, actions: [], running: null, icon: null,
+        canStop: false, canRestart: o.restart, core: true, version: o.version, takeOver: null, actions: [], running: null, icon: null, appBusy: false,
     }
 }
 
@@ -171,13 +180,20 @@ export function coreGroup(pm: PmAnswer | null, o: CoreOpts = {}): ProcessGroup {
             rows.push(coreRow(id, { status: c.status, pid: c.pid, since: c.since, note: note === '' ? null : note, tail: c.tail, version, port, restart: true }))
         }
     }
-    return { repo: CORE_GROUP, core: true, rows }
+    const s = o.silent ?? {}
+    return { repo: CORE_GROUP, core: true, rows: rows.map((r) => {
+        const why = s[r.id as 'pm' | 'daemon' | 'web']
+        return why != null && why !== '' ? { ...r, status: 'silent', dot: 'crashed', note: why } : s.pm ? stale(r) : r
+    }) }
 }
 
 /** what the page's table holds, from pm's answer: the core group, then the
  *  global processes by repo */
 export const processGroups = (pm: PmAnswer | null, order: string[], o: CoreOpts = {}): ProcessGroup[] =>
-    [coreGroup(pm, o), ...groupRows((pm?.resources ?? []).map(rowOf), order)]
+    [coreGroup(pm, o), ...groupRows((pm?.resources ?? []).map((r) => (o.silent?.pm ? stale(rowOf(r)) : rowOf(r))), order)]
+
+/** a row from an answer pm can no longer confirm: its state unknown, nothing to click */
+const stale = (r: ProcessRow): ProcessRow => ({ ...r, status: 'unknown', dot: 'unknown', canStop: false, canRestart: false, takeOver: null, running: null, appBusy: false })
 
 /** the declared icon, else the repo's own, else none */
 export const processIcon = (r: { icon: ProcessIcon | null }, repoIcon: string | null): ProcessIcon | null =>
@@ -200,6 +216,7 @@ export function stateWords(r: Pick<ProcessRow, 'status' | 'since'>, now: number)
         case 'crashed': return age == null ? 'crashed' : `crashed ${age} ago`
         case 'down': return 'stopped'
         case 'unknown': return 'unknown (pm down)'
+        case 'silent': return 'no answer'
         default: return r.status
     }
 }

package/src/home/resources.ts

@@ -1,14 +1,15 @@
 // 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 its url opened in the default browser or as a shipkit
-// app window.
+// 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'
@@ -47,8 +48,14 @@ export type ResourceView = {
     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 }
 
@@ -83,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)
     }
@@ -113,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))
 
@@ -120,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
@@ -150,8 +181,10 @@ 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
@@ -248,9 +281,9 @@ export class Resource {
         await this.set('up')
     }
 
-    /** its url in the default browser, or as a shipkit app window: at once
+    /** 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: 'browser' | 'app'): Promise<void> {
+    async open(how: OpenHow): Promise<void> {
         if (this.decl.url == null) throw new Error(`${this.decl.id} declares no url to open`)
         if (this.status === 'up') {
             this.show(how, this.decl.url)
@@ -260,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
@@ -328,6 +379,7 @@ export class Resource {
             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

@@ -23,6 +23,7 @@ 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))
@@ -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 */
@@ -98,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/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.
 

package/src/hooks/run-hooks.ts

@@ -53,7 +53,8 @@ export type HooksConfig = {
     languageAllow?: string[]
     /** disable a built-in gate, visible in `hooks list`, never silent.
      *  'commit-language' lifts ONLY the French check, keeping the dash and
-     *  AI-attribution guards armed. */
+     *  AI-attribution guards armed. 'commit-message' lifts the dash and French
+     *  checks; the AI-attribution guard is never lifted. */
     disable?: ('leak-guard' | 'commit-message' | 'root-identity' | 'commit-language')[]
 }
 
@@ -309,6 +310,13 @@ export async function runCommitMsg(root: string, config: RepoConfig, messageFile
                     ...offenses.map((o) => `      line ${o.line}: ${o.text.slice(0, 100)}\n        ${o.why}`),
                 ],
             })
+    } else {
+        // AI attribution is the one message rule no config lifts: this hook is
+        // the guard against it in every repo (identity/how-we-commit.md)
+        const offenses = commitMessageOffenses(message).filter((o) => o.kind === 'attribution')
+        out.push(offenses.length === 0
+            ? { id: 'ai-attribution', ok: true, lines: ['ok: no AI attribution in the commit message'] }
+            : { id: 'ai-attribution', ok: false, lines: [`FAIL: commit message carries AI attribution`, ...offenses.map((o) => `      line ${o.line}: ${o.text.slice(0, 100)}\n        ${o.why}`)] })
     }
     // the leak guard also reads the MESSAGE, a private name pasted into a
     // commit body is as public as one pasted into a file
@@ -347,7 +355,9 @@ export function listGates(config: RepoConfig, root = process.cwd()): string[] {
         ...((h.blockedPaths ?? []).length > 0 ? [`pre-commit  blocked-paths — nothing under ${h.blockedPaths!.join(', ')} enters git${draftsOpen(config) && blockedStaged([COMFY_DRAFTS], config).length === 0 && h.blockedPaths!.some((p) => COMFY_DRAFTS.startsWith(p)) ? `, except ${COMFY_DRAFTS} (declared private)` : ''}`] : []),
         `pre-commit  root-identity${off.has('root-identity') ? ' (DISABLED by config)' : ''} — the repo's own name in package.json + repo.config.ts, and scratch files`,
         ...(h.preCommit ?? []).map((c) => `pre-commit  ${c.id} — ${c.cmd.join(' ')}`),
-        `commit-msg  commit-message${off.has('commit-message') ? ' (DISABLED by config)' : ''} — dash punctuation + AI attribution + French${off.has('commit-language') ? ' (commit-language DISABLED by config)' : ''}`,
+        off.has('commit-message')
+            ? `commit-msg  commit-message (DISABLED by config) — dash punctuation + French; ai-attribution stays on, never disabled`
+            : `commit-msg  commit-message — dash punctuation + AI attribution (never disabled) + French${off.has('commit-language') ? ' (commit-language DISABLED by config)' : ''}`,
         `commit-msg  leak-guard${leakState} — the message text`,
         ...(h.commitMsg ?? []).map((c) => `commit-msg  ${c.id} — ${c.cmd.join(' ')}`),
     ]

package/src/ledger/gate-checks.ts

@@ -351,7 +351,7 @@ export async function composeChecks(root: string, c: RepoConfig, o: ComposeOpts
             owner: u.owner,
             group: u.def.group ?? null,
             timeoutMs: u.def.timeoutMs ?? null,
-            budgetMs: budgetOf(u.id, u.def.budgetMs, { build: u.def.build === true, cmd: u.def.cmd != null, world: u.def.ttl != null }, c.budgets),
+            budgetMs: budgetOf(u.id, u.def.budgetMs, { build: u.def.build === true, cmd: u.def.cmd != null, world: u.def.ttl != null || u.def.never != null }, c.budgets),
             optIn: false,
             fixable: u.def.fix != null,
             when: w,
@@ -389,7 +389,7 @@ export async function composeChecks(root: string, c: RepoConfig, o: ComposeOpts
             owner: r.owner,
             group: null,
             timeoutMs: null,
-            budgetMs: budgetOf(r.id, undefined, { build: false, cmd: false, world: r.ttl != null }, c.budgets),
+            budgetMs: budgetOf(r.id, undefined, { build: false, cmd: false, world: r.ttl != null || r.never != null }, c.budgets),
             optIn: false,
             fixable: r.fix != null,
             when: whenOfRule(c, r.id),
@@ -433,7 +433,7 @@ export async function composeChecks(root: string, c: RepoConfig, o: ComposeOpts
             owner: rel,
             group: task?.group ?? null,
             timeoutMs: task?.timeoutMs ?? null,
-            budgetMs: budgetOf(d.name, undefined, { build: false, cmd: true, world: d.ttl != null }, c.budgets),
+            budgetMs: budgetOf(d.name, undefined, { build: false, cmd: true, world: d.ttl != null || d.never != null }, c.budgets),
             optIn: false,
             // the reader is a source scanner, so it cannot carry a function
             fixable: false,