rvlib-shipkit 1.4.0 → 1.5.0

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

@@ -14,6 +14,7 @@ import { processGroups, type ProcessGroup } from '../../home/process-rows.ts'
 import { ClockSvc } from './clock-svc.ts'
 import type { HomeSt } from './home-st.ts'
 import type { HubDot } from './projects-svc.ts'
+import { ownTrouble, reach, Unreachable } from './reach.ts'
 
 export const MACHINE_POLL_MS = 1_500
 /** past the web's own wait on the daemon (serve-web.ts MACHINE_ANSWER_MS), so
@@ -38,13 +39,9 @@ function loadKept(): Kept | null {
     }
 }
 
-/** the poll failed because nothing behind the page answers, not on an error of an answer */
-/** the web (no answer at all) or the daemon behind it (the web says so) */
-class DownError extends Error {
-    constructor(msg: string, readonly who: 'web' | 'daemon') {
-        super(msg)
-    }
-}
+/** the web not answering, in the words of the daemon's (serve-web.ts daemonDownText) */
+export const webDownText = (why: string): string =>
+    `the shipkit web does not answer on ${globalThis.location?.origin ?? 'this page\'s origin'} (${why}). \`shipkit pm\` runs it; this page comes back by itself once it answers`
 
 export type MachineOpts = { reload?: () => void; timeoutMs?: number }
 
@@ -149,7 +146,7 @@ export class MachineSt {
     /** pm is polled beside the daemon: either one down leaves the other shown */
     private async loadPm(): Promise<void> {
         try {
-            const r = await fetch('/api/pm/status.json', { signal: AbortSignal.timeout(this.o.timeoutMs ?? MACHINE_TIMEOUT_MS) })
+            const r = await reach('/api/pm/status.json', { signal: AbortSignal.timeout(this.o.timeoutMs ?? MACHINE_TIMEOUT_MS) })
             if (!r.ok) throw new Error(await r.text())
             const j = (await r.json()) as PmAnswer
             runInAction(() => {
@@ -180,19 +177,15 @@ export class MachineSt {
         if (this.polling) return
         this.polling = true
         const pm = this.loadPm()
-        // never held on: a widget that answers late only shows late
-        if (!this.widgetsPolling) {
+        // never held on: a widget that answers late only shows late. Asked only
+        // while the overview shows: the daemon renders a widget for a reader,
+        // and a render can cost another machine an ssh session
+        if (!this.widgetsPolling && this.st.page === 'overview' && globalThis.document?.visibilityState !== 'hidden') {
             this.widgetsPolling = true
             void this.loadWidgets().finally(() => { this.widgetsPolling = false })
         }
         try {
-            let r: Response
-            try {
-                r = await fetch('/api/home.json', { signal: AbortSignal.timeout(this.o.timeoutMs ?? MACHINE_TIMEOUT_MS) })
-            } catch (e) {
-                throw new DownError(`the home does not answer: ${(e as Error).message}`, 'web')
-            }
-            if (r.headers.get('x-shipkit-daemon') === 'down') throw new DownError(await r.text(), 'daemon')
+            const r = await reach('/api/home.json', { signal: AbortSignal.timeout(this.o.timeoutMs ?? MACHINE_TIMEOUT_MS) })
             if (!r.ok) throw new Error(`/api/home.json answered ${r.status}: ${await r.text()}`)
             const j = (await r.json()) as HomeAnswer
             const back = this.wasDown
@@ -213,11 +206,12 @@ export class MachineSt {
             if (back) this.reload()
         } catch (e) {
             const msg = (e as Error).message
-            if (e instanceof DownError) {
+            if (e instanceof Unreachable) {
                 this.wasDown = true
+                const who = e.who === 'web' ? 'web' : 'daemon'
                 runInAction(() => {
-                    this.down = msg
-                    this.downWho = e.who
+                    this.down = who === 'web' ? webDownText(msg) : msg
+                    this.downWho = who
                 })
             } else {
                 this.pollError = true
@@ -253,14 +247,16 @@ export class MachineSt {
 
     private async post(path: string, body: unknown): Promise<boolean> {
         try {
-            const r = await fetch(path, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
+            const r = await reach(path, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
             if (!r.ok) throw new Error(await r.text())
             this.pollError = false
             runInAction(() => { this.error = '' })
             void this.load()
             return true
         } catch (e) {
-            runInAction(() => { this.error = (e as Error).message })
+            // the machine not answering is the down card's, which the next poll raises
+            runInAction(() => { this.error = ownTrouble(e, this) })
+            void this.load()
             return false
         }
     }

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

@@ -0,0 +1,51 @@
+// A repo's plan page: what the machine runs here on its own time, soonest
+// first, then the checks only a save runs. The rows are this repo's slice of
+// the machine's plan, already carried by /api/resources.json, so the page
+// reads nothing of its own. The home's planned page is the same plan for
+// every repo at once.
+import { observer } from 'mobx-react-lite'
+import type { PlanRow } from '../../plan/planner.ts'
+import { LAST_TONE, markOf, reasonWords, whenWords } from './planned-st.ts'
+import type { RepoSt } from './repo-st.ts'
+import { ageWords } from './time-ago.tsx'
+
+const soonest = (a: PlanRow, b: PlanRow): number => (a.dueAt ?? Infinity) - (b.dueAt ?? Infinity) || a.check.localeCompare(b.check)
+
+const PlanLine = observer(({ app, r }: { app: RepoSt; r: PlanRow }) => {
+    const now = app.clock.now
+    const m = markOf(r)
+    const running = r.state === 'running'
+    return (
+        <tr className={`pln m-${m.mark}`}>
+            <td className="plnwhen">{whenWords(r, now)}</td>
+            <td><a href="#" title={r.title ?? r.check} onClick={(e) => { e.preventDefault(); app.timeline.openCheck(r.check) }}>{r.check}</a>{r.title != null ? <span className="dim"> {r.title}</span> : null}</td>
+            <td className="dim" title={`rule: ${r.rule}\ninactive: ${r.inactive}`}>{r.error != null ? <span className="tl red">{r.error}</span> : reasonWords(r)}</td>
+            <td>{r.last == null ? <span className="dim">never ran</span> : <span className={`tl ${LAST_TONE[r.last.status]}`}>{r.last.status}, {ageWords(r.last.at, now)}</span>}</td>
+            <td className="plnrun"><button className="ghost" disabled={running} onClick={() => void app.home.planned.run(r)}>{running ? <><span className="spin" />running</> : 'run now'}</button></td>
+        </tr>
+    )
+})
+
+const PlanTable = observer(({ app, rows }: { app: RepoSt; rows: PlanRow[] }) => (
+    <table className="plntable">
+        <tbody>{rows.map((r) => <PlanLine key={r.check} app={app} r={r} />)}</tbody>
+    </table>
+))
+
+export const PlanPage = observer(({ app }: { app: RepoSt }) => {
+    const all = [...(app.cols.planned ?? [])].sort(soonest)
+    const timed = all.filter((r) => r.dueAt != null)
+    const onSave = all.filter((r) => r.dueAt == null)
+    return (
+        <div className="colcard checkcard">
+            <div className="chead">
+                <span className="tid">plan</span>
+                <h3 className="ctitle">{app.name}</h3>
+            </div>
+            <div className="usays">what the machine runs here on its own time, soonest first. Every repo at once: the planned page (⌘')</div>
+            {app.cols.planned == null ? <div className="dim">no plan covers this repo</div> : null}
+            {timed.length > 0 ? <section className="csec"><div className="cstitle">next</div><PlanTable app={app} rows={timed} /></section> : null}
+            {onSave.length > 0 ? <section className="csec"><div className="cstitle">on a save only</div><PlanTable app={app} rows={onSave} /></section> : null}
+        </div>
+    )
+})

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

@@ -8,6 +8,7 @@ import type { PlannedAnswer } from '../../home/home-routes.ts'
 import type { PlanRow } from '../../plan/planner.ts'
 import { sectionOf, timeline, titleWords, waitingRows, waitingWords } from '../../plan/plan-timeline.ts'
 import type { HomeSt } from './home-st.ts'
+import { ownTrouble, reach } from './reach.ts'
 
 export const PLANNED_POLL_MS = 1_000
 
@@ -78,18 +79,22 @@ export class PlannedSt {
 
     async poll(): Promise<void> {
         try {
-            const r = await fetch('/api/home/planned.json', { signal: AbortSignal.timeout(8_000) })
+            const r = await reach('/api/home/planned.json', { signal: AbortSignal.timeout(8_000) })
             if (!r.ok) throw new Error(`${r.status} ${await r.text()}`)
             const j = (await r.json()) as PlannedAnswer
             runInAction(() => { this.data = j; this.error = '' })
         } catch (e) {
-            runInAction(() => { this.error = (e as Error).message })
+            runInAction(() => { this.error = ownTrouble(e, this.st.machine) })
         }
     }
 
     async run(row: PlanRow): Promise<void> {
-        const r = await fetch('/api/home/planned/run', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ repo: row.repo, check: row.check }) })
-        if (!r.ok) runInAction(() => { this.error = `run ${row.check}: ${r.status} ${r.statusText}` })
+        try {
+            const r = await reach('/api/home/planned/run', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ repo: row.repo, check: row.check }) })
+            if (!r.ok) throw new Error(`${r.status} ${r.statusText}`)
+        } catch (e) {
+            runInAction(() => { this.error = ownTrouble(e, this.st.machine, (m) => `run ${row.check}: ${m}`) })
+        }
         await this.poll()
     }
 

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

@@ -0,0 +1,38 @@
+// The processes page of a repo: one card per global process it declares,
+// each the process menu's two panels (actions, then its description as
+// markdown) and its log under them. pm runs them, so the page reads the
+// machine, never the hub. The card a tree row opened is scrolled to and lit.
+import { observer } from 'mobx-react-lite'
+import { useEffect, useRef } from 'react'
+import { Log, ProcessMenu } from './home-strip.tsx'
+import type { RepoSt } from './repo-st.ts'
+import type { ProcessRow } from '../../home/process-rows.ts'
+
+const noop = (): void => {}
+
+const ProcessCard = observer(({ app, r, lit }: { app: RepoSt; r: ProcessRow; lit: boolean }) => {
+    const el = useRef<HTMLElement>(null)
+    useEffect(() => { if (lit) el.current?.scrollIntoView({ block: 'nearest' }) }, [lit])
+    const m = app.home.machine
+    if (m == null) return null
+    return (
+        <section ref={el} className={`csec pcard${lit ? ' lit' : ''}`} id={`process-${r.id}`}>
+            <ProcessMenu m={m} r={r} close={noop} lastLog={r.tail.length === 0} />
+            {r.tail.length === 0 ? null : <><div className="cstitle">log</div><Log lines={r.tail} /></>}
+        </section>
+    )
+})
+
+export const ProcessesPage = observer(({ app, id }: { app: RepoSt; id: string | null }) => {
+    const rows = app.globalProcesses
+    return (
+        <div className="colcard checkcard">
+            <div className="chead">
+                <span className="tid">processes</span>
+                <h3 className="ctitle">{app.name}</h3>
+            </div>
+            <div className="usays">the processes this repo declares in its <code>.shipkit.ts</code> files. pm runs them, so they run whether or not the hub answers</div>
+            {rows.length === 0 ? <div className="dim">this repo declares no global process</div> : rows.map((r) => <ProcessCard key={r.id} app={app} r={r} lit={r.id === id} />)}
+        </div>
+    )
+})

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

@@ -5,6 +5,11 @@
 import { makeAutoObservable, observableRef, runInAction } from 'mobx'
 import type { ArchivedRow, ProjectRow as Project, Release } from '../project-gutter-route.ts'
 import { identityOfName, type Identity } from '../../core/identity-color.ts'
+import { ownTrouble, reach } from './reach.ts'
+
+/** the list never says the page's server is gone, even where no machine
+ *  card is (a hub on its own): that hub's trouble card says it */
+const SAID_ELSEWHERE = true
 
 export type { ArchivedRow, ProjectRow as Project, Release } from '../project-gutter-route.ts'
 
@@ -250,12 +255,12 @@ export class ProjectsSvc {
      *  loads its hub on its next tick */
     async setArchived(name: string, on: boolean): Promise<void> {
         try {
-            const r = await fetch('/api/projects/archived', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name, archived: on }) })
+            const r = await reach('/api/projects/archived', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name, archived: on }) })
             if (!r.ok) throw new Error(await r.text())
             runInAction(() => { this.error = '' })
             await this.load()
         } catch (e) {
-            runInAction(() => { this.error = `${on ? 'archive' : 'unarchive'} ${name}: ${(e as Error).message}` })
+            runInAction(() => { this.error = ownTrouble(e, SAID_ELSEWHERE, (m) => `${on ? 'archive' : 'unarchive'} ${name}: ${m}`) })
         }
     }
 
@@ -302,7 +307,7 @@ export class ProjectsSvc {
 
     private async saveIdentity(name: string, id: Identity, h: ReturnType<typeof setTimeout>): Promise<void> {
         try {
-            const r = await fetch('/api/projects/identity', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name, ...id }) })
+            const r = await reach('/api/projects/identity', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name, ...id }) })
             if (!r.ok) throw new Error(await r.text())
             const j = (await r.json()) as { identity: Identity }
             runInAction(() => {
@@ -310,7 +315,7 @@ export class ProjectsSvc {
                 this.error = ''
             })
         } catch (e) {
-            runInAction(() => { this.error = `colours of ${name}: ${(e as Error).message}` })
+            runInAction(() => { this.error = ownTrouble(e, SAID_ELSEWHERE, (m) => `colours of ${name}: ${m}`) })
         } finally {
             // a later pick rests on its own timer, which keeps the guard
             if (this.identitySaves.get(name) === h) this.identitySaves.delete(name)
@@ -390,11 +395,11 @@ export class ProjectsSvc {
         const by = new Map(this.list.map((p) => [p.name, p]))
         this.list = names.map((n) => by.get(n)).filter((p): p is Project => p != null)
         try {
-            const r = await fetch('/api/projects/order', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ names }) })
+            const r = await reach('/api/projects/order', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ names }) })
             if (!r.ok) throw new Error(await r.text())
             runInAction(() => { this.error = '' })
         } catch (e) {
-            runInAction(() => { this.error = `reorder: ${(e as Error).message}` })
+            runInAction(() => { this.error = ownTrouble(e, SAID_ELSEWHERE, (m) => `reorder: ${m}`) })
         }
     }
 
@@ -427,7 +432,7 @@ export class ProjectsSvc {
     async load(): Promise<void> {
         const order = this.orderGen
         try {
-            const r = await fetch('/api/projects.json')
+            const r = await reach('/api/projects.json')
             if (!r.ok) throw new Error(`${r.status} ${await r.text()}`)
             const j = (await r.json()) as { projects: Project[]; archived?: ArchivedRow[] }
             runInAction(() => {
@@ -440,17 +445,17 @@ export class ProjectsSvc {
                 this.fresh = true
             })
         } catch (e) {
-            runInAction(() => { this.error = `projects: ${(e as Error).message}` })
+            runInAction(() => { this.error = ownTrouble(e, SAID_ELSEWHERE, (m) => `projects: ${m}`) })
         }
     }
 
     async open(name: string): Promise<void> {
         try {
-            const r = await fetch('/api/projects/open', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name }) })
+            const r = await reach('/api/projects/open', { 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}: ${(e as Error).message}` })
+            runInAction(() => { this.error = ownTrouble(e, SAID_ELSEWHERE, (m) => `open ${name}: ${m}`) })
         }
     }
 }

package/src/serve/hub-app/prose-hits-st.ts

@@ -6,6 +6,7 @@
 import { makeAutoObservable, observableRef, runInAction } from 'mobx'
 import type { ProseGroup, ProseView } from '../../prose/prose-view.ts'
 import type { RepoSt } from './repo-st.ts'
+import { ownTrouble, reach } from './reach.ts'
 
 export type TierFilter = 'all' | 'blocking' | 'soft'
 export type ListKind = 'allow' | 'ban'
@@ -37,12 +38,12 @@ export class ProseHitsSt {
     async load(): Promise<void> {
         runInAction(() => { this.loading = true })
         try {
-            const r = await fetch(this.st.url('/api/prose.json'))
+            const r = await reach(this.st.url('/api/prose.json'))
             if (!r.ok) throw new Error(await r.text())
             const v = (await r.json()) as ProseView
             runInAction(() => { this.view = v; this.error = '' })
         } catch (e) {
-            runInAction(() => { this.error = `the hits could not be read: ${(e as Error).message}` })
+            runInAction(() => { this.error = ownTrouble(e, this.st.home.machine, (m) => `the hits could not be read: ${m}`) })
         }
         runInAction(() => { this.loading = false })
     }

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

@@ -0,0 +1,36 @@
+// the one reading of "nothing behind the page answers": the web itself (a
+// fetch that never gets an answer), or the daemon or pm behind it (the web's
+// tagged 502, serve-web.ts). On the home that is one fact about the machine,
+// said once, by the card under the strip (MachineSt). Every other surface
+// that fails for it stays silent and keeps what it last read.
+
+export type Who = 'web' | 'daemon' | 'pm'
+
+export class Unreachable extends Error {
+    constructor(msg: string, readonly who: Who) {
+        super(msg)
+    }
+}
+
+/** fetch, with the machine not answering thrown as Unreachable. Any other
+ *  answer comes back as it is, an error status included */
+export async function reach(input: string, init?: RequestInit): Promise<Response> {
+    let r: Response
+    try {
+        r = await fetch(input, init)
+    } catch (e) {
+        throw new Unreachable((e as Error).message, 'web')
+    }
+    if (r.headers.get('x-shipkit-daemon') === 'down') throw new Unreachable(await r.text(), 'daemon')
+    if (r.headers.get('x-shipkit-pm') === 'down') throw new Unreachable(await r.text(), 'pm')
+    return r
+}
+
+/** the words a surface shows for its failed request, or '' when the failure
+ *  is the machine's: the machine card says that. `machine` is whether the
+ *  page has one: a hub serving on its own has none, so a server it cannot
+ *  reach is its own trouble there */
+export function ownTrouble(e: unknown, machine: unknown, words: (msg: string) => string = (m) => m): string {
+    if (e instanceof Unreachable && (e.who !== 'web' || machine != null)) return ''
+    return words((e as Error).message)
+}

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

@@ -2,6 +2,7 @@
 // empty page shows, so an edited README appears without a reload
 import { makeAutoObservable, runInAction } from 'mobx'
 import type { RepoSt } from './repo-st.ts'
+import { ownTrouble, reach } from './reach.ts'
 
 export class ReadmeSvc {
     /** the file name at the root, null when the repo has none */
@@ -19,7 +20,7 @@ export class ReadmeSvc {
 
     async load(): Promise<void> {
         try {
-            const r = await fetch(this.st.url('/api/readme.json'))
+            const r = await reach(this.st.url('/api/readme.json'))
             if (!r.ok) throw new Error(`http ${r.status}: ${await r.text()}`)
             const j = (await r.json()) as { file: string | null; md: string | null }
             runInAction(() => {
@@ -30,7 +31,7 @@ export class ReadmeSvc {
             })
         } catch (e) {
             runInAction(() => {
-                this.error = `README fetch broke: ${(e as Error).message}`
+                this.error = ownTrouble(e, this.st.home.machine, (m) => `README fetch broke: ${m}`) || null
                 this.loaded = true
             })
         }

package/src/serve/hub-app/repo-sections.ts

@@ -0,0 +1,117 @@
+// A repo page's sections: the pages reached for most, the top rows of the
+// left pane's tree (tree-row.tsx draws them the way the project list draws its
+// lines: an icon, a label, a count where it says something, its ⌥ shortcut at
+// the end, keys.ts, the current one lit). A page this repo does not have is
+// not a row. The counts read the severity filter, like everything under them,
+// and come from what the page already holds (the kept screen on a reload), so
+// none arrives late and moves the tree.
+import { RUNS_ID } from '../../collections/collection-types.ts'
+import type { CheckOwner, HashSel } from './hash-route.ts'
+import { sectionLabel, type SectionId } from './keys.ts'
+import type { RepoSt } from './repo-st.ts'
+import { passesFilter } from './tree-build.ts'
+import { openWikis, WIKIS } from './wikis-view.tsx'
+
+export type RepoSection = {
+    id: SectionId
+    label: string
+    title: string
+    /** null when a number would say nothing */
+    count: number | null
+    tone: 'red' | 'warn' | null
+    on: boolean
+    go: () => void
+}
+
+const counted = (n: number, tone: 'red' | 'warn'): Pick<RepoSection, 'count' | 'tone'> => (n === 0 ? { count: null, tone: null } : { count: n, tone })
+
+/** the section a page belongs to: a collection, one of its items, its own
+ *  page. null for a page no section owns (the table of every check). A check
+ *  lives under whose it is, which only the resource knows: `ownerOf` reads it */
+export function sectionOfSel(sel: HashSel | null, ownerOf: (checkItemId: string) => CheckOwner | null = () => null): SectionId | null {
+    if (sel == null) return 'readme'
+    switch (sel.t) {
+        case 'readme': return 'readme'
+        case 'processes': return 'processes'
+        case 'plan': return 'plan'
+        case 'git': return 'git'
+        case 'when': return 'when'
+        case 'checks': return sel.from
+        case 'admin': return 'admin'
+        case 'tests': return 'tests'
+        case 'asset': case 'cat': return 'media'
+        case 'status': return null
+        case 'col': case 'item': {
+            const col = sel.t === 'col' ? sel.id : sel.col
+            if (col === RUNS_ID) return 'runs'
+            if (col === WIKIS) return 'wikis'
+            if (col === 'contracts') return 'contracts'
+            if (col === 'creds') return 'secrets'
+            if (col === 'checks') return sel.t === 'item' ? ownerOf(sel.id) : null
+            return col === 'asks' || col === 'tests' || col === 'reflections' ? col : null
+        }
+    }
+}
+
+/** the section a repo's current page belongs to, a check read off its
+ *  resource for whose it is */
+export const sectionOfRepo = (app: RepoSt): SectionId | null =>
+    sectionOfSel(app.sel, (id) => app.cols.find('checks', id)?.check?.from ?? null)
+
+/** open a section's own page, through the calls a click makes */
+export function openSection(app: RepoSt, id: SectionId): void {
+    switch (id) {
+        case 'readme': return app.showReadme()
+        case 'contracts': return app.showCol('contracts')
+        case 'shipkit': case 'repo': return app.showChecks(id)
+        case 'secrets': return app.showCol('creds')
+        case 'runs': return app.cols.select('runs', RUNS_ID)
+        case 'processes': return app.showProcesses(null)
+        case 'plan': return app.showPlan()
+        case 'git': return app.showGit()
+        case 'when': return app.showWhen()
+        case 'reflections': return app.showCol('reflections')
+        case 'asks': return app.showCol('asks')
+        case 'tests': return app.showTests(null)
+        case 'media': {
+            const cat = app.media.assets[0]?.cat ?? app.cols.cachedCat ?? undefined
+            if (cat != null) app.showCat(cat)
+            return
+        }
+        case 'wikis': return openWikis(app)
+        case 'admin': return app.showAdmin()
+    }
+}
+
+export function repoSections(app: RepoSt): RepoSection[] {
+    const has = (col: string): boolean => app.cols.colMeta.some((c) => c.id === col)
+    const cur = sectionOfRepo(app)
+    const res = app.cols.resources.filter((r) => passesFilter(r, app.filter))
+    const reds = (col: string): number => res.filter((r) => r.collection === col && r.state === 'red').length
+    const none = { count: null, tone: null }
+    const line = (id: SectionId, title: string, count: Pick<RepoSection, 'count' | 'tone'>): RepoSection => ({ id, label: sectionLabel(id), title, ...count, on: cur === id, go: () => openSection(app, id) })
+    const out: RepoSection[] = [line('readme', 'the README, what the repo is', none)]
+    const ownReds = (from: CheckOwner): number => res.filter((r) => r.check?.from === from && r.state === 'red').length
+    if (has('contracts')) out.push(line('contracts', 'what a release venue asks of this repo, and what it still lacks', counted(reds('contracts'), 'red')))
+    if (has('checks')) out.push(line('shipkit', 'the checks shipkit ships to every repo, one page each', counted(ownReds('shipkit'), 'red')))
+    if (has('checks')) out.push(line('repo', 'the checks this repo declares itself, one page each', counted(ownReds('repo'), 'red')))
+    if (has('creds')) out.push(line('secrets', 'the credentials this repo needs, present or missing', counted(reds('creds'), 'red')))
+    if (has('checks')) out.push(line('when', 'what runs when: every check on every context (commit, ci, full, release, health, save, clock), with the legend', none))
+    // a page, never a resource: every hub keeps a run record
+    out.push(line('runs', 'every run on record, the slowest checks and the longest runs', none))
+    // the plan and git come from the machine, so a hub of its own has neither
+    if (app.home.machine != null) out.push(line('plan', 'what the machine runs here on its own time, and when', none))
+    const procs = app.globalProcesses
+    if (procs.length > 0) out.push(line('processes', 'the processes this repo declares: start, stop, open, their description and their log', counted(procs.filter((r) => r.dot === 'crashed').length, 'red')))
+    if (app.home.machine != null) out.push(line('git', 'the branch, its upstream, what is not committed, the last commits', none))
+    if (has('asks')) {
+        const open = res.filter((r) => r.collection === 'asks' && r.type === 'ask' && r.slot !== 'done').length
+        out.push(line('asks', 'what waits on a human', counted(open, 'warn')))
+    }
+    if (has('reflections')) out.push(line('reflections', 'friction this repo logged against the wiki, waiting to be folded in', counted(res.filter((r) => r.type === 'reflection').length, 'warn')))
+    if (has('tests')) out.push(line('tests', 'every test file, slowest first, then each test check', counted(reds('tests'), 'red')))
+    if ((app.media.assets[0]?.cat ?? app.cols.cachedCat) != null) out.push(line('media', 'the assets, in the atelier', none))
+    if (has(WIKIS)) out.push(line('wikis', 'every wiki this repo mounts, as a link graph', none))
+    if (app.home.machine != null) out.push(line('admin', 'reload the hub, keep the repo active, archive it', none))
+    return out
+}

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

@@ -8,7 +8,7 @@
 import { makeAutoObservable } from 'mobx'
 import { ClockSvc } from './clock-svc.ts'
 import { ColsSvc } from './cols-svc.ts'
-import { canonicalSel, currentHash, hashFor, parseHash, selOf, type HashSel } from './hash-route.ts'
+import { canonicalSel, currentHash, hashFor, parseHash, selOf, type CheckOwner, type HashSel } from './hash-route.ts'
 import { ComfySvc } from './comfy-svc.ts'
 import { HealthSvc } from './health-svc.ts'
 import { ReadmeSvc } from './readme-svc.ts'
@@ -17,10 +17,11 @@ import { MediaSvc } from './media-svc.ts'
 import { TimelineSvc } from './timeline-svc.ts'
 import { TreeSvc } from './tree-svc.ts'
 import { ChecksSvc } from './checks-svc.ts'
-import { ProcessesSvc } from './processes-svc.ts'
+import { GitSt } from './git-st.ts'
+import type { ProcessRow } from '../../home/process-rows.ts'
 import { TestsSvc } from './tests-svc.ts'
 import { AdminSvc } from './admin-svc.ts'
-import { repoSections } from './repo-sections.tsx'
+import { repoSections } from './repo-sections.ts'
 import { sectionKeyLabel } from './keys.ts'
 import type { Resource } from './hub-types.ts'
 import type { HomeSt } from './home-st.ts'
@@ -59,7 +60,8 @@ export class RepoSt {
     timeline: TimelineSvc
     /** the runs in flight, whoever started them (live-svc.ts) */
     live: LiveSvc
-    processes: ProcessesSvc
+    /** the git page's one repo read (git-st.ts) */
+    git: GitSt
     /** the pages behind the test groups of the tree (tests-svc.ts) */
     tests: TestsSvc
     /** the admin page: archive behind its confirmation, reload, keep active */
@@ -98,10 +100,10 @@ export class RepoSt {
         this.comfy = new ComfySvc(this)
         this.timeline = new TimelineSvc(this)
         this.live = new LiveSvc(this)
-        this.processes = new ProcessesSvc(this)
+        this.git = new GitSt(this)
         this.tests = new TestsSvc(this)
         this.admin = new AdminSvc(this)
-        makeAutoObservable<this, 'beat' | 'onceRead'>(this, { onceRead: false, home: false, key: false, base: false, clock: false, media: false, cols: false, tree: false, health: false, readme: false, checks: false, comfy: false, timeline: false, live: false, processes: false, tests: false, admin: false, searchEl: false, beat: false })
+        makeAutoObservable<this, 'beat' | 'onceRead'>(this, { onceRead: false, home: false, key: false, base: false, clock: false, media: false, cols: false, tree: false, health: false, readme: false, checks: false, comfy: false, timeline: false, live: false, git: false, tests: false, admin: false, searchEl: false, beat: false })
     }
 
     /** an absolute hub path ('/api/…', '/media/…', '/hub.json') as this
@@ -150,7 +152,6 @@ export class RepoSt {
         const steps: (() => Promise<unknown>)[] = [
             () => this.cols.poll(),
             () => this.readOnce(),
-            () => this.processes.load(),
             () => this.media.heartbeat(),
             () => this.live.poll(),
             () => this.timeline.load(),
@@ -171,7 +172,6 @@ export class RepoSt {
             this.applyHash()
         }
         this.clock.start()
-        this.processes.start()
         this.media.start()
         this.cols.start()
         this.live.start()
@@ -182,7 +182,6 @@ export class RepoSt {
         if (!this.polling) return
         this.polling = false
         this.clock.stop()
-        this.processes.stop()
         this.media.stop()
         this.cols.stop()
         this.live.stop()
@@ -276,6 +275,7 @@ export class RepoSt {
      *  its own item card. A gate check has a page of its own now, so nothing
      *  lands on the raw wall of text unless it is asked for by name */
     openResource(r: Resource): void {
+        if (r.type === 'process') return this.showProcesses(r.id.replace(/^process:/, ''))
         const assetId = r.id.replace(/^media:/, '')
         if (r.collection === 'media' && this.media.assets.some((a) => a.id === assetId)) {
             this.selectAsset(assetId)
@@ -290,6 +290,37 @@ export class RepoSt {
         this.setSel({ t: 'admin' })
     }
 
+    /** the repo's README, the page a repo opens on */
+    showReadme(): void {
+        this.setSel({ t: 'readme' })
+    }
+
+    /** the global processes this repo declares, as pm runs them. None on a
+     *  hub of its own, since only the home talks to pm */
+    get globalProcesses(): ProcessRow[] {
+        return this.home.machine?.processGroups.find((g) => g.core !== true && g.repo === this.key)?.rows ?? []
+    }
+    /** what the machine plans to run here */
+    showPlan(): void {
+        this.setSel({ t: 'plan' })
+    }
+    /** what runs when: every check on every context */
+    showWhen(): void {
+        this.setSel({ t: 'when' })
+    }
+    /** the checks one owner ships, as the checks table */
+    showChecks(from: CheckOwner): void {
+        this.setSel({ t: 'checks', from })
+    }
+    /** the repo's git */
+    showGit(): void {
+        this.setSel({ t: 'git' })
+    }
+    /** the processes page, `id` the card to scroll to and light */
+    showProcesses(id: string | null): void {
+        this.setSel({ t: 'processes', id })
+    }
+
     /** collection view — one card per instance */
     showCol(id: string): void {
         this.setSel({ t: 'col', id })
@@ -304,6 +335,12 @@ export class RepoSt {
             case 'status': return this.showStatus()
             case 'tests': return this.showTests(sel.check)
             case 'admin': return this.showAdmin()
+            case 'readme': return this.showReadme()
+            case 'processes': return this.showProcesses(sel.id)
+            case 'plan': return this.showPlan()
+            case 'git': return this.showGit()
+            case 'when': return this.showWhen()
+            case 'checks': return this.showChecks(sel.from)
         }
     }
     /** the url decides the page: a reload, back, forward and a pasted link