rvlib-shipkit 1.4.0 → 1.6.0

package/src/serve/hub-app/home-strip.tsx

@@ -1,21 +1,22 @@
 // the home's strip over every page it serves: one line that never wraps. On a
 // repo page the shown repo (its icon, its name in its own colour, the two
-// swatches that set those colours), what it runs now and its two runs, then
-// on the right its processes, its hub's trouble and its editor icons
-// (header-bar.tsx); on the overview and the plan, the page's name. At the
-// far right, only machine wide trouble, and only while it lasts (pm or the
-// daemon down, a child or a global process crashed). The places themselves
+// swatches that set those colours), its check… button and a spinner while
+// it runs, then on the right its processes and its editor icons
+// (header-bar.tsx); on the overview and the plan, the page's name. The strip
+// carries no trouble text: the shown hub's trouble and the machine's (the
+// daemon, pm or the web not answering, a child or a global process crashed, a
+// failed poll) are cards floating under it at the top right, only while they
+// last (float-cards.tsx). The machine not answering is said there and nowhere
+// else (reach.ts). The places themselves
 // are the place buttons at the top of the project list (the picker's ⌘J,
 // then ⌘K, ⌘L, ⌘') and the first three entries of the
 // picker. What administers one repo (reload its hub, keep it active, archive
 // it) is its admin page (admin-view.tsx). NotUp stands in for the hub page
 // while its hub cannot answer, with the fix. Every link of the home is a
-// page of the same app: a plain click moves it in place. The daemon or pm
-// down is said in MachineToasts, floating over the page column's bottom
-// right corner, taking no room.
+// page of the same app: a plain click moves it in place.
 import { observer } from 'mobx-react-lite'
 import type { ReactNode } from 'react'
-import type { ProcessIcon, ResourceView } from '../../home/resources.ts'
+import type { OpenHow, ProcessIcon, ResourceView } from '../../home/resources.ts'
 import type { WorkerView } from '../../home/hubs.ts'
 import { NOT_INSTALLED } from '../../home/home-words.ts'
 import { splitWidgetHead } from '../../home/widget-text.ts'
@@ -25,8 +26,10 @@ import { processIcon, stateWords, type ProcessRow } from '../../home/process-row
 import { plainClick, repoPage, type HomeSt } from './home-st.ts'
 import { stampWords } from './time-ago.tsx'
 import { Icon, ICON } from './icons.tsx'
-import { Tip } from './floating.tsx'
-import { notUp, RepoOpeners, RepoRun, RepoTools } from './header-bar.tsx'
+import { Pop, Tip } from './floating.tsx'
+import { renderMd } from './md.ts'
+import { FloatCards, type Card } from './float-cards.tsx'
+import { hubCards, notUp, RepoOpeners, RepoRun, RepoTools } from './header-bar.tsx'
 
 const STATUS_WORD: Record<WorkerView['status'], string> = { up: 'up', starting: 'starting', crashed: 'crashed', down: 'down', stopping: 'stopping' }
 
@@ -42,9 +45,9 @@ export const HomeLink = ({ app, to, className, title, children }: { app: HomeSt;
     }}>{children}</a>
 )
 
-const Log = ({ lines }: { lines: string[] }) => (lines.length === 0 ? null : <pre className="hlog">{lines.join('\n')}</pre>)
+export const Log = ({ lines }: { lines: string[] }) => (lines.length === 0 ? null : <pre className="hlog">{lines.join('\n')}</pre>)
 
-/** one switch per global process; its log floats under it on hover */
+/** a crashed global process's switch (start it again); its log floats under it on hover */
 export const ResourceChip = observer(({ m, r }: { m: MachineSt; r: ResourceView }) => {
     const on = r.status === 'up' || r.status === 'starting'
     const title = [r.description, r.where != null ? `on ${r.where}` : null, r.note].filter((x) => x != null).join(' · ')
@@ -154,9 +157,10 @@ const ProcessRepo = observer(({ app, name, icon }: { app: HomeSt; name: string;
 /** the processes as one table in the activity page's style: shipkit's own
  *  first, then a row group per declaring repo in the project list's order,
  *  its name in the first column, at the top of its group, then one line per
- *  process. The url's header carries the new window button */
-const ProcessTable = observer(({ app, m }: { app: HomeSt; m: MachineSt }) => {
-    const groups = m.processGroups
+ *  process. The url's header carries the new window button. `repo` keeps
+ *  that one repo's group, the table of its processes page */
+export const ProcessTable = observer(({ app, m, repo }: { app: HomeSt; m: MachineSt; repo?: string }) => {
+    const groups = repo == null ? m.processGroups : m.processGroups.filter((g) => g.core !== true && g.repo === repo)
     const rows = groups.flatMap((g) => g.rows)
     // wide enough for the longest set of declared actions, in the button font
     const act = Math.max(0, ...rows.map((r) => r.actions.reduce((n, a) => n + a.label.length + 3, 0)))
@@ -222,19 +226,6 @@ const Monitor = observer(({ m }: { m: MachineSt }) => {
     )
 })
 
-/** the two colours of a repo, a picker each: the page draws the dark one */
-export const IdentitySwatches = observer(({ app, name }: { app: HomeSt; name: string }) => {
-    const id = app.projects.identityOf(name)
-    return (
-        <span className="hswatch">
-            <input type="color" aria-label="colour on a dark background" title={`${name} on a dark background (this page): ${id.colorDark}, written to repo.config.ts identity.colorDark`}
-                value={id.colorDark} onChange={(e) => app.projects.setIdentity(name, { colorDark: e.currentTarget.value })} />
-            <input type="color" aria-label="colour on a light background" title={`${name} on a light background: ${id.colorLight}, written to repo.config.ts identity.colorLight`}
-                value={id.colorLight} onChange={(e) => app.projects.setIdentity(name, { colorLight: e.currentTarget.value })} />
-        </span>
-    )
-})
-
 /** the shown repo in the strip: its icon, its name in its colour */
 const ShownRepo = observer(({ app, name }: { app: HomeSt; name: string }) => {
     const p = app.projects.list.find((x) => x.name === name)
@@ -244,23 +235,96 @@ const ShownRepo = observer(({ app, name }: { app: HomeSt; name: string }) => {
             {/* the icon's box is there before the project list is, so the name never moves */}
             {p?.icon != null ? <img src={p.icon} alt="" width={18} height={18} /> : <i className="hrico" />}
             <b className="hrname" style={{ color: id.colorDark }}>{name}</b>
-            <IdentitySwatches app={app} name={name} />
         </span>
     )
 })
 
-/** what is wrong with the machine itself, one chip each. Nothing when all is
- *  well: the strip states trouble, never health */
-const MachineAlerts = observer(({ m }: { m: MachineSt }) => (
-    <>
-        {/* pm silent, its last answer is kept for the table and says nothing here */}
-        {(m.pmDown !== '' ? [] : m.pm?.children ?? []).filter((c) => c.status === 'crashed' || c.status === 'down').map((c) => (
-            <span key={c.id} className="halert" title={c.note ?? c.tail.at(-1) ?? ''}><Dot s={c.status} />{c.id} {STATUS_WORD[c.status]}</span>
-        ))}
-        {(m.pmDown !== '' ? [] : m.pm?.resources ?? []).filter((r) => r.status === 'crashed').map((r) => <ResourceChip key={r.id} m={m} r={r} />)}
-        {m.error !== '' ? <span className="herr" title={m.error}>{m.error}</span> : null}
-    </>
-))
+/** the machine not answering, as ONE card: the web (pm behind it is then
+ *  unknown, not down), the daemon, pm, or the daemon and pm together */
+const downCard = (m: MachineSt): Card[] => {
+    const web = m.down !== '' && m.downWho === 'web'
+    const pm = m.pmDown !== '' && !web
+    if (m.down === '' && !pm) return []
+    const head = m.down === '' ? 'pm down' : pm ? 'daemon and pm down' : `${m.downWho} down`
+    return [{ key: 'down', tone: 'red', head, body: m.down === '' ? m.pmDown : pm ? <>{m.down}<br />{m.pmDown}</> : m.down }]
+}
+
+/** what is wrong with the machine itself, one card each: the machine not
+ *  answering, a crashed child of pm, a crashed global process (its switch
+ *  starts it again), a failed poll. While pm is silent its last answer says
+ *  nothing here */
+const machineCards = (m: MachineSt): Card[] => {
+    const pm = m.pmDown !== '' ? null : m.pm
+    return [
+        ...downCard(m),
+        ...(pm?.children ?? []).filter((c) => c.status === 'crashed' || c.status === 'down').map((c): Card => ({ key: `child:${c.id}`, tone: 'red', head: `${c.id} ${STATUS_WORD[c.status]}`, body: c.note ?? c.tail.at(-1) ?? '' })),
+        ...(pm?.resources ?? []).filter((r) => r.status === 'crashed').map((r): Card => ({ key: `res:${r.id}`, tone: 'red', head: 'crashed', body: <ResourceChip m={m} r={r} /> })),
+        ...(m.error !== '' ? [{ key: 'poll', tone: 'red' as const, body: m.error }] : []),
+    ]
+}
+
+/** a global process's menu: start or stop, restart, its url opened three
+ *  ways (each starts it first when it is down), then its declared actions and
+ *  take over. Every entry is a click on purpose, never the chip itself */
+/** `lastLog: false` where the whole log is drawn under it, so its last line is not said twice */
+export const ProcessMenu = observer(({ m, r, close, lastLog = true }: { m: MachineSt; r: ProcessRow; close: () => void; lastLog?: boolean }) => {
+    const on = r.status === 'up' || r.status === 'starting'
+    const first = r.status === 'up' ? '' : ', starts it first'
+    const act = (a: Parameters<MachineSt['processAct']>[1], action?: string) => () => { close(); void m.processAct(r.id, a, action) }
+    const open = (how: OpenHow) => () => { close(); void m.openProcess(r.id, how) }
+    const log = lastLog ? r.lastLog : null
+    const about = r.description != null && r.description !== '' || r.note != null || log != null
+    return (
+        <div className="hmenu2">
+            <div className="hmenu hmacts">
+                <div className="hmhead"><i className={`pdot ${r.status}`} /><b>{r.label}</b><span>{r.status}</span></div>
+                {on ? (
+                    <button className="hmitem" disabled={r.status === 'stopping' || !r.canStop} onClick={act('stop')}>
+                        <Icon d={ICON.stop} /><span><b>stop</b>{r.canStop ? null : <small>started outside pm, so pm cannot stop it</small>}</span>
+                    </button>
+                ) : (
+                    <button className="hmitem" disabled={r.status === 'unknown'} onClick={act('start')}><Icon d={ICON.play} /><span><b>start</b></span></button>
+                )}
+                {r.canRestart ? <button className="hmitem" onClick={act('restart')}><Icon d={ICON.restart} /><span><b>restart</b></span></button> : null}
+                {r.url == null ? null : (
+                    <>
+                        <button className="hmitem" onClick={open('browser')}><Icon d={ICON.browser} /><span><b>open in a browser tab</b><small>{r.host}{first}</small></span></button>
+                        <button className="hmitem" onClick={open('chrome')}><Icon d={ICON.browser} /><span><b>open in Chrome</b><small>{r.host}{first}</small></span></button>
+                        <button className="hmitem" disabled={r.appBusy} onClick={open('app')}><Icon d={ICON.window} /><span><b>open as an app</b><small>{r.appBusy ? `building the ${r.label} app` : `${r.label} in the dock${first}`}</small></span></button>
+                    </>
+                )}
+                {r.actions.map((a) => <button key={a.id} className="hmitem" disabled={r.running != null} onClick={act('action', a.id)}><Icon d={ICON.process} /><span><b>{a.label}</b></span></button>)}
+                {r.takeOver?.ok === true ? <button className="hmitem" onClick={act('takeover')}><Icon d={ICON.restart} /><span><b>take over</b><small>stop the copy started elsewhere and start one pm supervises</small></span></button> : null}
+            </div>
+            {about ? (
+                <div className="hmabout">
+                    {r.description != null && r.description !== '' ? <div className="md" dangerouslySetInnerHTML={{ __html: renderMd(r.description) }} /> : null}
+                    {r.note != null ? <small className="hmnote">{r.note}</small> : null}
+                    {log != null ? <code className="hmlog" title="its last log line">{log}</code> : null}
+                </div>
+            ) : null}
+        </div>
+    )
+})
+
+/** the shown repo's global processes, one chip each, right after its name: its
+ *  dot and label, and a click opens its menu (ProcessMenu). pm runs them, so
+ *  they show whether the repo's hub answers or not */
+const RepoProcesses = observer(({ m, name }: { m: MachineSt; name: string }) => {
+    const rows = m.processGroups.find((g) => g.core !== true && g.repo === name)?.rows ?? []
+    if (rows.length === 0) return null
+    return (
+        <span className="hprocs hgprocs">
+            {rows.map((r) => (
+                <span key={r.id} className="hproc">
+                    <Pop className={`ghost ${r.status}`} popClass="fpop fpopw" aria-label={`${r.label}, ${r.status}: open its menu`} label={<><i className={`pdot ${r.status}`} />{r.label}</>}>
+                        {(close) => <ProcessMenu m={m} r={r} close={close} />}
+                    </Pop>
+                </span>
+            ))}
+        </span>
+    )
+})
 
 export const HomeStrip = observer(({ app }: { app: HomeSt }) => {
     const m = app.machine
@@ -273,33 +337,17 @@ export const HomeStrip = observer(({ app }: { app: HomeSt }) => {
         <>
             <div className="hstrip">
                 {name == null ? <span className="hplace">{app.page === 'overview' ? 'overview' : app.page}</span> : <ShownRepo app={app} name={name} />}
-                {live == null ? null : <RepoRun app={live} />}
+                {name == null ? null : <RepoProcesses m={m} name={name} />}
                 <span className="sp" />
                 {live == null ? null : <RepoTools app={live} />}
-                <MachineAlerts m={m} />
+                {live == null ? null : <RepoRun app={live} />}
                 {live == null ? null : <RepoOpeners app={live} />}
             </div>
-            <MachineToasts app={app} />
+            <FloatCards cards={[...(live == null ? [] : hubCards(live)), ...machineCards(m)]} />
         </>
     )
 })
 
-/** the daemon or pm not answering, as toasts floating over the bottom right
- *  corner of the page column, just above the dock. They take no room, so
- *  one coming or going moves nothing, and nothing is drawn while all is
- *  well. Only a failed probe sets down or pmDown: before the first answer
- *  there is none */
-export const MachineToasts = observer(({ app }: { app: HomeSt }) => {
-    const m = app.machine
-    if (m == null || (m.down === '' && m.pmDown === '')) return null
-    return (
-        <div className="htoasts">
-            {m.down !== '' ? <div className="htoast" role="alert" title={m.down}><b>daemon down</b> {m.down}</div> : null}
-            {m.pmDown !== '' ? <div className="htoast" role="alert" title={m.pmDown}><b>pm down</b> {m.pmDown}</div> : null}
-        </div>
-    )
-})
-
 /** archive the repo or bring it back: `archived` in its repo.config.ts, and
  *  only that key. Archived, it stays listed and nothing runs there */
 export const ArchiveButton = observer(({ app, name }: { app: HomeSt; name: string }) => {
@@ -326,7 +374,7 @@ export const NotUp = observer(({ app }: { app: HomeSt }) => {
                 <ArchiveButton app={app} name={name} />
             </div>
         )
-    if (w == null) return <div className="hwait"><p className="twait"><span className="spin" />{m.down !== '' ? `waiting for the daemon to load ${name}…` : `looking for ${name}…`}</p></div>
+    if (w == null) return <div className="hwait"><p className="twait"><span className="spin" />{`looking for ${name}…`}</p></div>
     return (
         <div className="hwait">
             {w.blocked != null ? <p>{w.blocked}</p> : <p><Dot s={w.status} />{name}'s hub is {STATUS_WORD[w.status]}{w.note != null ? `: ${w.note}` : ''}</p>}
@@ -366,9 +414,12 @@ export const Overview = observer(({ app }: { app: HomeSt }) => {
     const m = app.machine
     if (m == null) return null
     // the table waits for pm's first word and for the list's order, so its
-    // rows never arrive or reorder after it paints
+    // rows never arrive or reorder after it paints. The daemon silent, it
+    // draws whatever it last had: the down card says the rest
     const p = app.projects
-    if (m.data == null || (m.pm == null && m.pmDown === '') || (p.list.length === 0 && !p.fresh && p.error === '')) return <div className="hwait"><p className="twait"><span className="spin" />{m.down !== '' ? 'the daemon does not answer yet' : 'loading…'}</p></div>
+    const nothing = m.data == null && m.pm == null && m.widgets == null
+    const first = m.data == null || (m.pm == null && m.pmDown === '') || (p.list.length === 0 && !p.fresh && p.error === '')
+    if (nothing || (m.down === '' && first)) return <div className="hwait"><p className="twait"><span className="spin" />loading…</p></div>
     return (
         <div className="hall">
             <div className="hstack">

package/src/serve/hub-app/home.html

@@ -9,6 +9,7 @@
   <link rel="stylesheet" href="./prose-hits.css" />
   <link rel="stylesheet" href="./home-strip.css" />
   <link rel="stylesheet" href="./planned.css" />
+  <link rel="stylesheet" href="./when.css" />
   <link rel="stylesheet" href="./activity.css" />
   <link rel="stylesheet" href="./readme.css" />
   <link rel="stylesheet" href="./dock.css" />

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

@@ -2,16 +2,17 @@
 // app for every page the home serves ('/', '/planned', '/activity', '/r/<repo>/') and for a
 // hub serving on its own at '/'. mobx+react per build/app-state-tree: HomeSt
 // is the single root (window.app), each repo a RepoSt under it, services own
-// state, components read and call. A repo's page is its sections over ONE
-// tree of every repo resource (sidebar.tsx), by path or by type, coloured by
-// state in the label itself, over one severity filter persisted at
+// state, components read and call. A repo's page is ONE tree whose top rows
+// are its sections and whose rows under them are every repo resource
+// (sidebar.tsx), coloured by state in the label itself, under one filter
+// input and one severity filter persisted at
 // ?f=needs · ?f=red. A row opens its item view, an asset row opens the atelier.
 import { runInAction } from 'mobx'
 import { observer } from 'mobx-react-lite'
 import { StrictMode, useEffect, useLayoutEffect, useRef } from 'react'
 import { createRoot } from 'react-dom/client'
-import { ColCard, ColGrid, StatusCard } from './col-card.tsx'
-import { AskTable, CheckTable } from './col-tables-view.tsx'
+import { ColCard, StatusCard } from './col-card.tsx'
+import { AskTable, CheckTable, ItemTable, SecretTable } from './col-tables-view.tsx'
 import { WIKIS, WikisView } from './wikis-view.tsx'
 import { ComfyOverlay, ComfyView } from './comfy-view.tsx'
 import type { Filter, RepoSt } from './repo-st.ts'
@@ -24,6 +25,10 @@ import { TestCard } from './test-view.tsx'
 import { TestsPage } from './tests-view.tsx'
 import { AssetStage, CatGrid, InfoChips, MediaTopbar, ToolsBar, VariantsBar } from './media-view.tsx'
 import { Sidebar } from './sidebar.tsx'
+import { ProcessesPage } from './processes-view.tsx'
+import { PlanPage } from './plan-view.tsx'
+import { WhenPage } from './when-view.tsx'
+import { GitPage } from './git-view.tsx'
 import { AdminPage } from './admin-view.tsx'
 import { ReadmeView } from './readme-view.tsx'
 import { ProjectList } from './project-list.tsx'
@@ -35,7 +40,7 @@ import { ActivityView } from './activity-view.tsx'
 import { Palette } from './palette-view.tsx'
 import { SCREEN_WAIT_MS } from './screen-cache.ts'
 import { isSearchKey, pageKey, sectionKey } from './keys.ts'
-import { repoSections } from './repo-sections.tsx'
+import { repoSections } from './repo-sections.ts'
 import { Dock } from './dock-view.tsx'
 import { DOCK } from './dock-st.ts'
 import { animateDock } from './dock-anim.ts'
@@ -88,11 +93,16 @@ const Main = observer(({ app }: { app: RepoSt }) => {
     if (app.sel?.t === 'col') return (
         <main>
             {errs}
-            {app.sel.id === 'checks' ? <CheckTable app={app} id={app.sel.id} /> : app.sel.id === 'asks' ? <AskTable app={app} id={app.sel.id} /> : <ColGrid app={app} id={app.sel.id} />}
+            {app.sel.id === 'checks' ? <CheckTable app={app} id={app.sel.id} /> : app.sel.id === 'asks' ? <AskTable app={app} id={app.sel.id} /> : app.sel.id === 'creds' ? <SecretTable app={app} id={app.sel.id} /> : <ItemTable app={app} id={app.sel.id} />}
         </main>
     )
     if (app.sel?.t === 'tests') return <main>{errs}<div className="stagewrap"><TestsPage app={app} check={app.sel.check} /></div></main>
     if (app.sel?.t === 'admin') return <main>{errs}<div className="stagewrap"><AdminPage app={app} /></div></main>
+    if (app.sel?.t === 'plan') return <main>{errs}<div className="stagewrap"><PlanPage app={app} /></div></main>
+    if (app.sel?.t === 'git') return <main>{errs}<div className="stagewrap"><GitPage app={app} /></div></main>
+    if (app.sel?.t === 'checks') return <main>{errs}<CheckTable app={app} id="checks" from={app.sel.from} /></main>
+    if (app.sel?.t === 'when') return <main>{errs}<div className="stagewrap"><WhenPage app={app} /></div></main>
+    if (app.sel?.t === 'processes') return <main>{errs}<div className="stagewrap"><ProcessesPage app={app} id={app.sel.id} /></div></main>
     if (app.sel?.t === 'status') return <main>{errs}<div className="stagewrap"><StatusCard app={app} /></div></main>
     if (app.sel?.t === 'cat') return <main>{errs}<CatGrid app={app} /></main>
     if (app.sel?.t === 'asset') return (
@@ -185,13 +195,18 @@ const RepoView = observer(({ app }: { app: RepoSt }) => {
 function onKey(e: KeyboardEvent): void {
     // the command keys beat the focus check: they work from anywhere, any page
     const pk = pageKey(e)
-    if (pk != null) {
+    // in a text field ⌘↑ and ⌘↓ keep moving the caret to its ends
+    const typing = (e.target as HTMLElement).tagName === 'INPUT' || (e.target as HTMLElement).tagName === 'TEXTAREA'
+    if (pk != null && !(pk.t === 'step' && typing)) {
         e.preventDefault()
         if (pk.t === 'picker') home.palette.toggle()
         else if (pk.t === 'dock') home.dock.cycle()
         else if (pk.t === 'home' || pk.t === 'planned' || pk.t === 'activity') {
             home.palette.close()
             if (home.machine != null) home.navigate(PLACE_PATH[pk.t === 'home' ? 'overview' : pk.t])
+        } else if (pk.t === 'step') {
+            home.palette.close()
+            home.projects.step(pk.by)
         } else {
             const p = home.projects.list[pk.n - 1]
             home.palette.close()
@@ -225,6 +240,15 @@ function onKey(e: KeyboardEvent): void {
         return
     }
     if (e.metaKey || e.ctrlKey || e.altKey) return
+    // the tree's keys need no focus: the arrows move it from anywhere on the
+    // page, Enter and space only where no button or link claims them
+    // the atelier's ←/→ roll, so at its first or last roll they stop there
+    const rolls = app.sel?.t === 'asset' && (e.key === 'ArrowLeft' || e.key === 'ArrowRight')
+    const own = !rolls && (e.key.startsWith('Arrow') || t.closest('button, a, select, [role="button"]') == null)
+    if (own && app.tree.key(e.key)) {
+        e.preventDefault()
+        return
+    }
     if (e.key === FOLLOW_KEY && (!app.live.chart.follow || !home.dock.chart.follow)) {
         e.preventDefault()
         app.live.chart.attach()

package/src/serve/hub-app/hub-types.ts

@@ -73,9 +73,10 @@ export type RecentRun = { at: number; ms: number; status: CheckStatus; replayed:
 // engine reaches the bundle: two declarations of one vocabulary is how a
 // switch ends up writing a word the other half does not know
 import type { WhenAt, WhenSource } from '../../core/when.ts'
+import type { RunsCells } from '../../core/runs-matrix.ts'
 import type { Line } from '../../core/wire.ts'
 import type { CheckFrom } from '../../check.ts'
-export type { CheckFrom, WhenAt, WhenSource }
+export type { CheckFrom, WhenAt, WhenSource, RunsCells }
 
 /** a gate check's declaration and its numbers (collections/collection-types.ts
  *  CheckFacts is the source; this is the wire mirror the page reads) */
@@ -87,6 +88,8 @@ export type CheckFacts = {
     /** the wire lines of its last run, rendered as inline markdown */
     lastLines: string[]
     gate: boolean
+    /** every context it runs in and how it caches */
+    runs: RunsCells
     /** a build step: the gate runs it, the health pass does not */
     build: boolean
     blocking: boolean | null
@@ -138,7 +141,7 @@ export type GateBlock = {
     path: string
     hash: string
     state: 'missing-file' | 'missing-block' | 'stale' | 'current'
-    when: Record<string, string>
+    off: Record<string, string>
     tests: { budgetMs?: number; slow?: SlowSuite[]; serial?: { file: string; why: string }[] }
     declaredOutside: boolean
     dirty: boolean