rvlib-shipkit 1.3.0 → 1.5.0

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/project-list.tsx

@@ -14,7 +14,7 @@
 // in), archived shows or hides the archived repos just above the foot
 // (names only, no ⌘ number, a row opens the archived page, nothing loads),
 // the foot never moving. On the home a section of four lines on top, in the
-// repo rows' style, opens the overview, the picker, the activity and the
+// repo rows' style, opens the picker, the overview, the activity and the
 // plan, each with its shortcut at the line's end, the page shown lit. It
 // renders from the first paint with the list this browser kept, so a load
 // moves nothing.
@@ -30,11 +30,11 @@ import { cardModel, faceOf, hueOf, SORTS, type Place, type Project, type Project
 /** what the list needs of its page: the hub and the home both carry one */
 export type ListHost = { projects: ProjectsSvc }
 
-/** the lines on top of the list, in their order: the overview, the picker,
+/** the lines on top of the list, in their order: the picker, the overview,
  *  then the places, their shortcuts ⌘J ⌘K ⌘L ⌘' top to bottom */
 const PLACES: { id: Place | 'picker'; label: string; title: string }[] = [
-    { id: 'overview', label: 'overview', title: 'the overview: shipkit, every global process and every repo on this machine' },
     { id: 'picker', label: 'jump to…', title: 'jump to a page, a repo or one of its resources' },
+    { id: 'overview', label: 'overview', title: 'the overview: shipkit, every global process and every repo on this machine' },
     { id: 'activity', label: 'activity', title: 'what every repo committed lately, what it holds uncommitted, its branch and whether it is pushed' },
     { id: 'planned', label: 'planned', title: 'every check the machine runs on its own: now, next, late, and why' },
 ]

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,17 +17,18 @@ 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'
 
 export type Sel = HashSel | null
 
-/** one picker target (cmd+k): run() fires the SAME action clicking would */
+/** one picker target (cmd+j): run() fires the SAME action clicking would */
 /** what a picker entry wears: a repo's own icon, or a place's button icon */
 export type JumpFace = { repo: string } | { place: 'home' | 'planned' | 'activity' | 'archived' }
 /** `key`: the shortcut that does the same, printed at the entry's end */
@@ -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

package/src/serve/hub-app/runs-tabs.ts

@@ -7,7 +7,7 @@ export type RunsTab = 'runs' | 'files' | 'slowest' | 'longest'
 
 /** the four lists, in tab order. `key` is what the address carries */
 export const RUNS_TABS: { key: RunsTab; label: string; help: string }[] = [
-    { key: 'runs', label: 'runs', help: `every run on record, newest first: shipkit ci, shipkit check, the hub's buttons, and the runs the plan starts. One line per run: when, who started it, what ran, its wall time, how many checks ${RAN}, how many were ${CACHED} (answered from the cache, nothing ran), and its reds. Unfold a run for one line per check, named by its title with its id as the small tag, in a box that scrolls: its reds first, then what ${RAN}, slowest first, then what was ${CACHED}. Click a check for its page. Every run in time, and how many ran at once, is the chart over the tabs: press fit for the whole record` },
+    { key: 'runs', label: 'runs', help: `every run on record, newest first: shipkit ci, shipkit check, the hub's buttons, and the runs the plan starts. One line per run: when, who started it, what ran, its wall time, how many checks ${RAN}, how many were ${CACHED} (answered from the cache, nothing ran), and its reds. Unfold a run for one line per check, named by its title with its id as the small tag, in a box that scrolls: its reds first, then what ${RAN}, slowest first, then what was ${CACHED}. Click a check for its page. Every run in time, and how many ran at once, is the chart under this list: press fit for the whole record` },
     { key: 'files', label: 'test files to fix', help: "bun test files, not checks: each file's last recorded run inside the check that ran it (test, test:<unit>), kept when a test in it failed or when it broke the quick tier budget per file. The same verdict colours the file in the tree under tests. Click a file for its page, the check tag for the check" },
     { key: 'slowest', label: 'slowest checks', help: 'the checks that cost the most when they really run: the mean and the worst of the runs that ran. A check whose worst run passed half its ceiling is flagged, because the next slow machine trips it' },
     { key: 'longest', label: 'longest runs', help: 'the invocations on record that took the longest, start to end, whatever ran them' },

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

@@ -1,47 +1,31 @@
-// A repo page's left pane: its sections (repo-sections.tsx), then the tree of
-// every resource of the repo, one row deep in its path, under its filter, its
-// two tabs and its severity filter. Only the tree scrolls, so the sections and
-// the filter stay in reach. The row itself is tree-row.tsx.
+// A repo page's left pane: the filter with its severity group on one line,
+// then ONE tree whose top rows are the repo's sections (tree-svc.ts) and
+// whose rows under them are every resource of the repo. Only the tree
+// scrolls, so the filter stays in reach. The row itself is tree-row.tsx.
 import { observer } from 'mobx-react-lite'
-import { Help } from './help.tsx'
 import { SEARCH_KEY } from './keys.ts'
-import { Sections } from './repo-sections.tsx'
 import type { RepoSt } from './repo-st.ts'
-import { TYPE_MARK } from './tree-build.ts'
 import { TreeRowView } from './tree-row.tsx'
 
 const Tree = observer(({ app }: { app: RepoSt }) => {
     const t = app.tree
+    const empty = app.cols.loaded && app.filter !== 'all' && app.query.trim() === '' && t.visible.length === 0
     return (
         // roving focus: the arrows belong to the tree only while it HAS the
         // focus, so the atelier keeps its own keys
         <div className="tree" tabIndex={0} onKeyDown={(e) => { if (t.key(e.key)) e.preventDefault() }}>
             {t.rows.map((r) => <TreeRowView key={r.key} app={app} row={r} />)}
             {!app.cols.loaded && !app.cols.cached ? <div className="tempty twait"><span className="spin" />reading the repo…</div> : null}
-            {app.cols.loaded && t.rows.length === 0 ? <div className="tempty">{app.filter === 'red' ? 'no reds — nothing is blocked ✨' : app.filter === 'needs' ? 'nothing needs you ✨' : 'no resources yet'}</div> : null}
+            {empty ? <div className="tempty">{app.filter === 'red' ? 'no reds — nothing is blocked ✨' : 'nothing needs you ✨'}</div> : null}
+            {t.hidden > 0 ? (
+                <div className="tempty thidden" role="button" title="show every row (a)" onClick={() => app.setFilter('all')}>
+                    {t.hidden} {t.hidden === 1 ? 'row' : 'rows'} hidden by <b>{app.filter}</b> · show all <kbd className="pjkey">a</kbd>
+                </div>
+            ) : null}
         </div>
     )
 })
 
-/** what every glyph in the type slot means, behind one `(?)` */
-const TypeLegend = () => (
-    <Help text={
-        <span className="legend">
-            {Object.entries(TYPE_MARK).map(([kind, m]) => (
-                <span key={kind} className="lrow"><i className={`ty ${m.hue}`}>{m.glyph}</i>{m.word}</span>
-            ))}
-        </span>
-    } />
-)
-
-const TreeTabs = observer(({ app }: { app: RepoSt }) => (
-    <span className="seg">
-        {(['path', 'type'] as const).map((t) => (
-            <button key={t} className={app.tree.tab === t ? 'on' : ''} onClick={() => app.tree.setTab(t)}>by {t}</button>
-        ))}
-    </span>
-))
-
 // segmented severity filter — all · needs (yellow+red) · red, the address
 // rides at /?f=… so a filtered view is shareable. The shortcut letter rides
 // INSIDE its own button, so the binding is discoverable without a legend
@@ -58,24 +42,15 @@ const SegFilter = observer(({ app }: { app: RepoSt }) => (
 
 export const Sidebar = observer(({ app }: { app: RepoSt }) => (
     <aside>
-        <Sections app={app} />
         <div className="ssearch">
             <span className="sfield">
-                <input ref={(el) => { app.searchEl = el }} placeholder="filter" aria-label="filter the tree" value={app.query}
+                <input ref={(el) => { app.searchEl = el }} placeholder="filter" aria-label="filter the tree by name or path" value={app.query}
                     onChange={(e) => app.setQuery(e.target.value)}
                     onKeyDown={(e) => { if (e.key === 'Escape') app.setQuery('') }} />
                 <kbd className="skey">{SEARCH_KEY}</kbd>
             </span>
             <SegFilter app={app} />
         </div>
-        <div className="stabs">
-            <TreeTabs app={app} />
-            <span className="sp" />
-            <TypeLegend />
-            <span className="cnt">{app.tree.visible.length}</span>
-        </div>
-        {/* its line is held while the repo is read, so the tree never drops under it */}
-        {app.tree.whenLine === '' && app.cols.loaded ? null : <div className="swhen">{app.tree.whenLine === '' ? ' ' : app.tree.whenLine}</div>}
         {app.media.dead != null ? <div className="tempty"><span className="warnline">media API down: {app.media.dead}</span></div> : null}
         <div className="tscroll">
             <Tree app={app} />